Codeunit 99000774 Calculate Routing Line
- App
- Base Application
- Namespace
- Microsoft.Manufacturing.Routing
- Versions
- 17-28
Versions171819202122232425262728
Source29
Source in 29
src/Layers/W1/BaseApp/Manufacturing/Routing/CalculateRoutingLine.Codeunit.al2605 lines, Copyright (c) Microsoft Corporation. MIT
// ------------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// ------------------------------------------------------------------------------------------------
namespace Microsoft.Manufacturing.Routing;
using Microsoft.Foundation.Enums;
using Microsoft.Foundation.UOM;
using Microsoft.Inventory.Costing;
using Microsoft.Manufacturing.Capacity;
using Microsoft.Manufacturing.Document;
using Microsoft.Manufacturing.MachineCenter;
using Microsoft.Manufacturing.Setup;
using Microsoft.Manufacturing.WorkCenter;
codeunit 99000774 "Calculate Routing Line"
{
Permissions = TableData "Production Order" = r,
TableData "Prod. Order Line" = r,
TableData "Prod. Order Routing Line" = rim,
TableData "Prod. Order Capacity Need" = rimd,
TableData "Work Center" = r,
TableData "Calendar Entry" = r,
TableData "Machine Center" = r,
TableData "Manufacturing Setup" = r,
TableData "Capacity Constrained Resource" = r;
trigger OnRun()
begin
end;
var
MfgSetup: Record "Manufacturing Setup";
Workcenter: Record "Work Center";
Workcenter2: Record "Work Center";
MachineCenter: Record "Machine Center";
ProdOrder: Record "Production Order";
ProdOrderLine: Record "Prod. Order Line";
ProdOrderRoutingLine: Record "Prod. Order Routing Line";
ProdOrderCapNeed: Record "Prod. Order Capacity Need";
ProdOrderCapNeed2: Record "Prod. Order Capacity Need";
CalendarEntry: Record "Calendar Entry";
CalendarMgt: Codeunit "Shop Calendar Management";
UOMMgt: Codeunit "Unit of Measure Management";
RoutingTimeType: Enum "Routing Time Type";
NextCapNeedLineNo: Integer;
ProdStartingTime: Time;
ProdEndingTime: Time;
ProdStartingDate: Date;
ProdEndingDate: Date;
MaxLotSize: Decimal;
TotalLotSize: Decimal;
ProdOrderQty: Decimal;
TotalScrap: Decimal;
LotSize: Decimal;
RemainNeedQty: Decimal;
ConCurrCap: Decimal;
RunStartingDateTime: DateTime;
RunEndingDateTime: DateTime;
FirstInBatch: Boolean;
FirstEntry: Boolean;
UpdateDates: Boolean;
WaitTimeOnly: Boolean;
CurrentWorkCenterNo: Code[20];
CurrentTimeFactor: Decimal;
CurrentRounding: Decimal;
#pragma warning disable AA0074
#pragma warning disable AA0470
Text000: Label 'Error when calculating %1. Calendar is not available %2 %3 for %4 %5.';
#pragma warning restore AA0470
Text001: Label 'backward';
Text002: Label 'before';
Text003: Label 'forward';
Text004: Label 'after';
Text005: Label 'The sum of setup, move and wait time exceeds the available time in the period.';
Text006: Label 'fixed schedule';
Text007: Label 'Starting time must be before ending time.';
#pragma warning restore AA0074
local procedure TestForError(DirectionTxt: Text[30]; BefAfterTxt: Text[30]; Date: Date)
begin
if RemainNeedQty <> 0 then
Error(
Text000,
DirectionTxt,
BefAfterTxt,
Date,
ProdOrderRoutingLine.Type,
ProdOrderRoutingLine."No.");
end;
local procedure CreateCapNeed(NeedDate: Date; StartingTime: Time; EndingTime: Time; NeedQty: Decimal; TimeType: Enum "Routing Time Type"; Direction: Option Forward,Backward)
begin
InitProdOrderCapNeed(ProdOrder, ProdOrderRoutingLine, ProdOrderCapNeed, TimeType, NeedDate, StartingTime, EndingTime, NeedQty);
ProdOrderCapNeed."Time Type" := TimeType;
if TimeType = TimeType::"Run Time" then
ProdOrderCapNeed."Lot Size" := LotSize;
if TimeType = TimeType::"Run Time" then
if RemainNeedQty = 0 then begin
if FirstInBatch then
ProdOrderCapNeed."Send-Ahead Type" := ProdOrderCapNeed."Send-Ahead Type"::Both
else
case Direction of
Direction::Forward:
ProdOrderCapNeed."Send-Ahead Type" := ProdOrderCapNeed."Send-Ahead Type"::Output;
Direction::Backward:
ProdOrderCapNeed."Send-Ahead Type" := ProdOrderCapNeed."Send-Ahead Type"::Input;
end;
end else
if FirstInBatch then
case Direction of
Direction::Forward:
ProdOrderCapNeed."Send-Ahead Type" := ProdOrderCapNeed."Send-Ahead Type"::Input;
Direction::Backward:
ProdOrderCapNeed."Send-Ahead Type" := ProdOrderCapNeed."Send-Ahead Type"::Output;
end;
ProdOrderCapNeed.UpdateDatetime();
OnBeforeProdOrderCapNeedInsert(ProdOrderCapNeed, ProdOrderRoutingLine, ProdOrder, CalendarEntry);
ProdOrderCapNeed.Insert();
NextCapNeedLineNo := NextCapNeedLineNo + 1;
OnAfterCreateCapNeeded(
ProdOrderRoutingLine, NeedDate, NeedQty, RemainNeedQty, CalendarEntry, StartingTime, EndingTime, TimeType.AsInteger(),
NextCapNeedLineNo, ConCurrCap, LotSize, FirstInBatch, Direction);
end;
local procedure InitProdOrderCapNeed(ProdOrder: Record "Production Order"; var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ProdOrderCapNeed: Record "Prod. Order Capacity Need"; TimeType: Enum "Routing Time Type"; NeedDate: Date; StartingTime: Time; EndingTime: Time; NeedQty: Decimal)
var
ActuallyPostedTime: Decimal;
DistributedCapNeed: Decimal;
ShouldUpdateAllocatedTimeAndExpectedCapacityNeed: Boolean;
begin
OnBeforeInitProdOrderCapNeed(ProdOrder, ProdOrderRoutingLine, ProdOrderCapNeed, TimeType, NeedDate, StartingTime, EndingTime, NeedQty, LotSize);
ProdOrderCapNeed.Init();
ProdOrderCapNeed.Status := ProdOrder.Status;
ProdOrderCapNeed."Prod. Order No." := ProdOrder."No.";
ProdOrderCapNeed."Routing No." := ProdOrderRoutingLine."Routing No.";
ProdOrderCapNeed."Routing Reference No." := ProdOrderRoutingLine."Routing Reference No.";
ProdOrderCapNeed."Line No." := NextCapNeedLineNo;
ProdOrderCapNeed.Type := ProdOrderRoutingLine.Type;
ProdOrderCapNeed."No." := ProdOrderRoutingLine."No.";
ProdOrderCapNeed."Work Center No." := ProdOrderRoutingLine."Work Center No.";
ProdOrderCapNeed."Operation No." := ProdOrderRoutingLine."Operation No.";
ProdOrderCapNeed."Work Center Group Code" := ProdOrderRoutingLine."Work Center Group Code";
ProdOrderCapNeed.Date := NeedDate;
ProdOrderCapNeed."Starting Time" := StartingTime;
ProdOrderCapNeed."Ending Time" := EndingTime;
ProdOrderCapNeed."Needed Time" := NeedQty;
ProdOrderCapNeed."Needed Time (ms)" := NeedQty * CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code");
ProdOrderCapNeed."Concurrent Capacities" := ConCurrCap;
ProdOrderCapNeed.Efficiency := CalendarEntry.Efficiency;
ProdOrderCapNeed."Requested Only" := false;
ProdOrderCapNeed.Active := true;
ShouldUpdateAllocatedTimeAndExpectedCapacityNeed := ProdOrder.Status <> ProdOrder.Status::Simulated;
OnInitProdOrderCapNeedOnBeforeUpdateAllocatedTimeAndExpectedCapacityNeed(ProdOrderCapNeed, ShouldUpdateAllocatedTimeAndExpectedCapacityNeed);
if ShouldUpdateAllocatedTimeAndExpectedCapacityNeed then begin
ActuallyPostedTime := CalcActuallyPostedCapacityTime(ProdOrderRoutingLine, TimeType);
DistributedCapNeed := CalcDistributedCapacityNeedForOperation(ProdOrderRoutingLine, TimeType);
ProdOrderCapNeed."Allocated Time" := NeedQty - ActuallyPostedTime + DistributedCapNeed;
if ProdOrderCapNeed."Allocated Time" < 0 then
ProdOrderCapNeed."Allocated Time" := 0;
ProdOrderRoutingLine."Expected Capacity Need" :=
ProdOrderRoutingLine."Expected Capacity Need" + ProdOrderCapNeed."Needed Time (ms)";
end;
OnAfterInitProdOrderCapNeed(ProdOrder, ProdOrderRoutingLine, ProdOrderCapNeed, NeedQty, TimeType, ActuallyPostedTime, DistributedCapNeed);
end;
local procedure CreateLoadBack(TimeType: Enum "Routing Time Type"; Write: Boolean)
var
OldCalendarEntry: Record "Calendar Entry";
AvQtyBase: Decimal;
RelevantEfficiency: Decimal;
xConCurrCap: Decimal;
RemainNeedQtyBase: Decimal;
StartingTime: Time;
StopLoop: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCreateLoadBack(RemainNeedQty, CalendarEntry, TimeType, Write, FirstEntry, WaitTimeOnly, CurrentWorkCenterNo, ProdStartingDate, ProdStartingTime, ProdEndingDate, ProdEndingTime, IsHandled, RemainNeedQtyBase, CurrentTimeFactor);
if IsHandled then
exit;
xConCurrCap := 1;
if (RemainNeedQty = 0) and ((not FirstEntry) or (not Write) or WaitTimeOnly) then
exit;
if CalendarEntry.Find('+') then begin
if (TimeType = TimeType::"Wait Time") and (CalendarEntry.Date < ProdEndingDate) then begin
CalendarEntry.Date := ProdEndingDate;
CreateCalendarEntry(CalendarEntry);
end;
GetCurrentWorkCenterTimeFactorAndRounding(CalendarEntry."Work Center No.");
RemainNeedQtyBase := Round(RemainNeedQty * CurrentTimeFactor, CurrentRounding);
repeat
OldCalendarEntry := CalendarEntry;
ConCurrCap := ProdOrderRoutingLine."Concurrent Capacities";
if (ConCurrCap = 0) or (CalendarEntry.Capacity < ConCurrCap) then
ConCurrCap := CalendarEntry.Capacity;
if TimeType <> TimeType::"Run Time" then
RemainNeedQtyBase := Round(RemainNeedQtyBase * ConCurrCap / xConCurrCap, CurrentRounding);
xConCurrCap := ConCurrCap;
AvQtyBase := CalcLoadBackAvailQtyBase(TimeType);
if AvQtyBase > RemainNeedQtyBase then
AvQtyBase := RemainNeedQtyBase;
if TimeType in [TimeType::"Setup Time", TimeType::"Run Time"] then
RelevantEfficiency := CalendarEntry.Efficiency
else
RelevantEfficiency := 100;
OnCreateLoadBackOnAfterCalcRelevantEfficiency(ProdOrderRoutingLine, TimeType, RelevantEfficiency);
StartingTime :=
CalendarMgt.CalcTimeSubtract(
CalendarEntry."Ending Time",
Round(AvQtyBase * 100 / RelevantEfficiency / ConCurrCap, 1, '>'));
RemainNeedQtyBase := RemainNeedQtyBase - AvQtyBase;
OnCreateLoadBackOnBeforeCheckWrite(ProdOrderRoutingLine, TimeType, RelevantEfficiency, RemainNeedQtyBase, RemainNeedQty, CurrentRounding, Write, StartingTime, AvQtyBase, CalendarEntry);
if Write then begin
RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding);
CreateCapNeed(
CalendarEntry.Date, StartingTime, CalendarEntry."Ending Time",
Round(AvQtyBase / CurrentTimeFactor, CurrentRounding), TimeType, 1);
FirstInBatch := false;
FirstEntry := false;
end;
if UpdateDates and
((CalendarEntry."Capacity (Effective)" <> 0) or (TimeType = TimeType::"Wait Time"))
then begin
ProdOrderRoutingLine."Ending Time" := CalendarEntry."Ending Time";
ProdOrderRoutingLine."Ending Date" := CalendarEntry.Date;
UpdateDates := false;
end;
ProdEndingTime := StartingTime;
ProdEndingDate := CalendarEntry.Date;
ProdOrderRoutingLine."Starting Time" := StartingTime;
ProdOrderRoutingLine."Starting Date" := CalendarEntry.Date;
if (RemainNeedQtyBase = 0) and ((not FirstEntry) or (not Write)) then
StopLoop := true
else
if TimeType = TimeType::"Wait Time" then begin
StopLoop := false;
ReturnNextCalendarEntry(CalendarEntry, OldCalendarEntry, 0);
end else begin
CalendarEntry := OldCalendarEntry;
StopLoop := CalendarEntry.Next(-1) = 0;
end;
OnCreateLoadBackOnBeforeEndStopLoop(ProdOrderRoutingLine, TimeType, StopLoop);
until StopLoop;
RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding);
end;
end;
local procedure CalcLoadBackAvailQtyBase(TimeType: Enum "Routing Time Type") AvQtyBase: Decimal
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcLoadBackAvailQtyBase(ProdOrderRoutingLine, TimeType, CurrentTimeFactor, CurrentRounding, AvQtyBase, IsHandled);
if IsHandled then
exit(AvQtyBase);
AvQtyBase :=
CalcAvailQtyBase(
CalendarEntry, ProdEndingDate, ProdEndingTime, TimeType, ConCurrCap, false, CurrentTimeFactor, CurrentRounding);
end;
local procedure CreateLoadForward(TimeType: Enum "Routing Time Type"; Write: Boolean; LoadFactor: Decimal)
var
OldCalendarEntry: Record "Calendar Entry";
AvQtyBase: Decimal;
RelevantEfficiency: Decimal;
xConCurrCap: Decimal;
RemainNeedQtyBase: Decimal;
EndingTime: Time;
StopLoop: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCreateLoadForward(RemainNeedQty, CalendarEntry, TimeType, Write, LoadFactor, FirstEntry, WaitTimeOnly, CurrentWorkCenterNo, ProdStartingDate, ProdStartingTime, ProdEndingDate, ProdEndingTime, IsHandled, RemainNeedQtyBase, CurrentTimeFactor);
if IsHandled then
exit;
xConCurrCap := 1;
if (RemainNeedQty = 0) and ((not FirstEntry) or (not Write) or WaitTimeOnly) then
exit;
if CalendarEntry.Find('-') then begin
if (TimeType = TimeType::"Wait Time") and (CalendarEntry.Date > ProdStartingDate) then begin
CalendarEntry.Date := ProdStartingDate;
CreateCalendarEntry(CalendarEntry);
end;
if CalendarEntry."Capacity (Effective)" = 0 then begin
CalendarEntry."Starting Time" := ProdStartingTime;
CalendarEntry.Date := ProdStartingDate;
end;
if CalendarEntry."Work Center No." = Workcenter."No." then
GetCurrentWorkCenterTimeFactorAndRounding(Workcenter."No.")
else
GetCurrentWorkCenterTimeFactorAndRounding(CalendarEntry."Work Center No.");
RemainNeedQtyBase := Round(RemainNeedQty * CurrentTimeFactor, CurrentRounding);
repeat
OldCalendarEntry := CalendarEntry;
ConCurrCap := ProdOrderRoutingLine."Concurrent Capacities";
if (ConCurrCap = 0) or (CalendarEntry.Capacity < ConCurrCap) then
ConCurrCap := CalendarEntry.Capacity;
if TimeType <> TimeType::"Run Time" then
RemainNeedQtyBase := Round(RemainNeedQtyBase * ConCurrCap / xConCurrCap, CurrentRounding);
xConCurrCap := ConCurrCap;
AvQtyBase := CalcLoadForwardAvailQtyBase(TimeType);
if AvQtyBase * LoadFactor > RemainNeedQtyBase then
AvQtyBase := Round(RemainNeedQtyBase / LoadFactor, CurrentRounding);
if TimeType in [TimeType::"Setup Time", TimeType::"Run Time"] then
RelevantEfficiency := CalendarEntry.Efficiency
else
RelevantEfficiency := 100;
IsHandled := false;
OnCreateLoadForwardOnBeforeCalcEndingTime(EndingTime, CalendarEntry, AvQtyBase, RelevantEfficiency, ConCurrCap, IsHandled, ProdOrderRoutingLine, TimeType);
if not IsHandled then
EndingTime := CalendarEntry."Starting Time" + Round(AvQtyBase * 100 / RelevantEfficiency / ConCurrCap, 1, '>');
if AvQtyBase * LoadFactor >= 0 then
RemainNeedQtyBase := RemainNeedQtyBase - AvQtyBase * LoadFactor;
OnCreateLoadForwardOnBeforeCheckWrite(ProdOrderRoutingLine, TimeType, RelevantEfficiency, RemainNeedQtyBase, RemainNeedQty, CurrentRounding, Write);
if Write then begin
RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding);
CreateCapNeed(
CalendarEntry.Date, CalendarEntry."Starting Time", EndingTime,
Round(AvQtyBase * LoadFactor / CurrentTimeFactor, CurrentRounding), TimeType, 0);
FirstInBatch := false;
FirstEntry := false;
end;
if UpdateDates and
((CalendarEntry."Capacity (Effective)" <> 0) or (TimeType = TimeType::"Wait Time"))
then begin
ProdOrderRoutingLine."Starting Time" := CalendarEntry."Starting Time";
ProdOrderRoutingLine."Starting Date" := CalendarEntry.Date;
UpdateDates := false;
end;
if (EndingTime = 000000T) and (AvQtyBase <> 0) then
// Ending Time reached 24:00:00 so we need to move date as well
CalendarEntry.Date := CalendarEntry.Date + 1;
ProdStartingTime := EndingTime;
ProdStartingDate := CalendarEntry.Date;
ProdOrderRoutingLine."Ending Time" := EndingTime;
ProdOrderRoutingLine."Ending Date" := CalendarEntry.Date;
if ProdOrderRoutingLine."Schedule Manually" then begin
if TimeType = TimeType::"Setup Time" then
RunStartingDateTime := CreateDateTime(ProdStartingDate, ProdStartingTime);
if (RemainNeedQtyBase < 0) or (Round(RemainNeedQtyBase, CurrentRounding) = 0) then
RemainNeedQtyBase := 0;
end;
OnCreateLoadForwardOnAfterScheduleProdOrderRoutingLineManually(ProdOrderRoutingLine, TimeType, RunStartingDateTime, ProdStartingDate, ProdStartingTime, RemainNeedQtyBase);
if (RemainNeedQtyBase = 0) and ((not FirstEntry) or (not Write)) and (AvQtyBase * LoadFactor >= 0) then
StopLoop := true
else
if TimeType = TimeType::"Wait Time" then begin
StopLoop := false;
ReturnNextCalendarEntry(CalendarEntry, OldCalendarEntry, 1);
end else begin
CalendarEntry := OldCalendarEntry;
StopLoop := CalendarEntry.Next() = 0;
end;
OnCreateLoadForwardOnBeforeEndStopLoop(ProdOrderRoutingLine, TimeType, StopLoop, FirstEntry, WaitTimeOnly, ProdStartingDate, ProdStartingTime, ProdEndingDate, ProdEndingTime, RemainNeedQty, RemainNeedQtyBase, Write, LoadFactor, CurrentWorkCenterNo, CurrentTimeFactor, CurrentRounding, CalendarEntry);
until StopLoop;
RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding);
end;
end;
local procedure CalcLoadForwardAvailQtyBase(TimeType: Enum "Routing Time Type") AvQtyBase: Decimal
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcLoadForwardAvailQtyBase(ProdOrderRoutingLine, TimeType, CurrentTimeFactor, CurrentRounding, AvQtyBase, IsHandled);
if IsHandled then
exit(AvQtyBase);
AvQtyBase :=
CalcAvailQtyBase(
CalendarEntry, ProdStartingDate, ProdStartingTime, TimeType, ConCurrCap, true, CurrentTimeFactor, CurrentRounding);
end;
local procedure AvailableCapacity(CapType: Enum "Capacity Type"; CapNo: Code[20]; StartingDateTime: DateTime; EndingDateTime: DateTime) AvQty: Decimal
var
CalendarEntry2: Record "Calendar Entry";
ConCurrCapacity: Decimal;
Overlap: Decimal;
TotalDuration: Decimal;
begin
CalendarEntry2.SetCapacityFilters(CapType, CapNo);
CalendarEntry2.SetFilter("Starting Date-Time", '<=%1', EndingDateTime);
CalendarEntry2.SetFilter("Ending Date-Time", '>=%1', StartingDateTime);
if CalendarEntry2.Find('-') then
repeat
ConCurrCapacity := ProdOrderRoutingLine."Concurrent Capacities";
if (ConCurrCapacity = 0) or (CalendarEntry2.Capacity < ConCurrCapacity) then
ConCurrCapacity := CalendarEntry2.Capacity;
Overlap := 0;
if StartingDateTime > CalendarEntry2."Starting Date-Time" then
Overlap := CalcDuration(CalendarEntry2."Starting Date-Time", StartingDateTime);
if EndingDateTime < CalendarEntry2."Ending Date-Time" then
Overlap := Overlap + CalcDuration(EndingDateTime, CalendarEntry2."Ending Date-Time");
TotalDuration := CalcDuration(CalendarEntry2."Starting Date-Time", CalendarEntry2."Ending Date-Time");
AvQty := AvQty +
Round(
((TotalDuration - Overlap) / TotalDuration) *
CalendarEntry2."Capacity (Effective)" / CalendarEntry2.Capacity * ConCurrCapacity,
Workcenter."Calendar Rounding Precision");
until CalendarEntry2.Next() = 0;
exit(AvQty);
end;
local procedure LoadCapBack(CapType: Enum "Capacity Type"; CapNo: Code[20]; TimeType: Enum "Routing Time Type"; Write: Boolean)
begin
OnBeforeLoadCapBack(ProdOrderRoutingLine, TimeType, RemainNeedQty, ProdEndingDate, ProdEndingTime);
ProdOrderRoutingLine."Starting Date" := ProdEndingDate;
ProdOrderRoutingLine."Starting Time" := ProdEndingTime;
CalendarEntry.SetCapacityFilters(CapType, CapNo);
CalendarEntry.SetRange("Ending Date-Time", 0DT, CreateDateTime(ProdEndingDate + 1, ProdEndingTime));
CalendarEntry.SetRange("Starting Date-Time", 0DT, CreateDateTime(ProdEndingDate, ProdEndingTime));
OnLoadCapBackOnAfterSetCalendarEntryFilters(CalendarEntry);
CreateLoadBack(TimeType, Write);
OnLoadCapBackOnAfterCreateLoadBack(CapType, CapNo, TimeType, Write);
if RemainNeedQty = 0 then
exit;
TestForError(Text001, Text002, ProdOrderRoutingLine."Starting Date");
end;
procedure LoadCapForward(CapType: Enum "Capacity Type"; CapNo: Code[20]; TimeType: Enum "Routing Time Type"; Write: Boolean)
var
TotalAvailCapacity: Decimal;
LoadFactor: Decimal;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeLoadCapForward(ProdOrderRoutingLine, CapType, CapNo, TimeType, ProdStartingDate, ProdStartingTime, IsHandled, RemainNeedQty);
if IsHandled then
exit;
ProdOrderRoutingLine."Ending Date" := ProdStartingDate;
ProdOrderRoutingLine."Ending Time" := ProdStartingTime;
CalendarEntry.SetCapacityFilters(CapType, CapNo);
CalendarEntry.SetFilter("Starting Date-Time", '>=%1', CreateDateTime(ProdStartingDate - 1, ProdStartingTime));
if TimeType = TimeType::"Wait Time" then
CalendarEntry.SetFilter("Ending Date-Time", '>=%1', CreateDateTime(ProdStartingDate, 000000T))
else
CalendarEntry.SetFilter("Ending Date-Time", '>=%1', CreateDateTime(ProdStartingDate, ProdStartingTime));
if ProdOrderRoutingLine."Schedule Manually" and (TimeType = TimeType::"Run Time") then begin
OnLoadCapForwardOnScheduleManuallyOnBeforeCheckDateTimes(ProdOrderRoutingLine, CapType, CapNo, TimeType, ProdStartingDate, ProdStartingTime, RemainNeedQty, RunStartingDateTime, RunEndingDateTime);
if ProdOrderRoutingLine."Run Time" <> 0 then
if (RunEndingDateTime < RunStartingDateTime) or
((RunEndingDateTime = RunStartingDateTime) and (ProdOrderRoutingLine."Input Quantity" <> 0))
then
Error(Text005);
TotalAvailCapacity :=
AvailableCapacity(CapType, CapNo, RunStartingDateTime, RunEndingDateTime);
if TotalAvailCapacity = 0 then begin
TestForError(Text006, Text002, DT2Date(RunEndingDateTime));
LoadFactor := 0;
end else
LoadFactor := Round(RemainNeedQty / TotalAvailCapacity, Workcenter."Calendar Rounding Precision", '>');
end else
LoadFactor := 1;
OnLoadCapForwardOnBeforeCreateLoadForward(RemainNeedQty, CapType, CapNo, TimeType, Write, LoadFactor);
CreateLoadForward(TimeType, Write, LoadFactor);
OnLoadCapForwardOnAfterCreateLoadForward(RemainNeedQty, CapType, CapNo, TimeType, Write, LoadFactor);
if RemainNeedQty = 0 then
exit;
TestForError(Text003, Text004, ProdOrderRoutingLine."Ending Date");
end;
local procedure CalcMove()
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcMove(ProdOrderRoutingLine, WorkCenter, ProdEndingDate, ProdEndingTime, UpdateDates, IsHandled);
if IsHandled then
exit;
RemainNeedQty :=
Round(
ProdOrderRoutingLine."Move Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Move Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Move Time", false);
end;
local procedure CalcWaitBack()
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcWaitBack(ProdOrderRoutingLine, WorkCenter, ProdEndingDate, ProdEndingTime, UpdateDates, IsHandled);
if IsHandled then
exit;
RemainNeedQty :=
Round(
ProdOrderRoutingLine."Wait Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Wait Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Wait Time", false);
end;
local procedure GetSendAheadStartingTime(ProdOrderRoutingLineNext: Record "Prod. Order Routing Line"; var SendAheadLotSize: Decimal): Boolean
var
xProdOrderRoutingLine: Record "Prod. Order Routing Line";
RunTime: Decimal;
WaitTime: Decimal;
MoveTime: Decimal;
SetupTime: Decimal;
ResidualLotSize: Decimal;
ResidualProdStartDateTime: DateTime;
begin
ProdStartingDate := ProdOrderRoutingLineNext."Starting Date";
ProdStartingTime := ProdOrderRoutingLineNext."Starting Time";
SendAheadLotSize := MaxLotSize;
if TotalLotSize = MaxLotSize then
exit(true);
if (ProdOrderRoutingLine."Send-Ahead Quantity" = 0) or
(ProdOrderRoutingLine."Send-Ahead Quantity" >= MaxLotSize)
then begin
TotalLotSize := SendAheadLotSize;
exit(false);
end;
SendAheadLotSize := ProdOrderRoutingLine."Send-Ahead Quantity";
if MaxLotSize < (TotalLotSize + SendAheadLotSize) then begin
SendAheadLotSize := MaxLotSize - TotalLotSize;
TotalLotSize := MaxLotSize;
end else begin
if TotalLotSize = 0 then begin
ResidualLotSize := MaxLotSize mod SendAheadLotSize;
if ResidualLotSize = 0 then
ResidualLotSize := SendAheadLotSize;
end;
TotalLotSize := TotalLotSize + SendAheadLotSize;
end;
ProdOrderCapNeed2.Reset();
ProdOrderCapNeed2.SetCurrentKey(Status, "Prod. Order No.", "Routing Reference No.", "Operation No.", Date, "Starting Time");
ProdOrderCapNeed2.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderCapNeed2.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderCapNeed2.SetRange("Requested Only", false);
ProdOrderCapNeed2.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderCapNeed2.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderCapNeed2.SetRange("Operation No.", ProdOrderRoutingLine."Operation No.");
if ProdOrderCapNeed2.FindFirst() then begin
if TotalLotSize <> MaxLotSize then begin
SendAheadLotSize := MaxLotSize - (TotalLotSize - SendAheadLotSize);
TotalLotSize := MaxLotSize;
end;
exit(false);
end;
// calculate Starting Date/Time for the last lot of the next line by going back from Ending Date/Time of the line
Workcenter2.Get(ProdOrderRoutingLineNext."Work Center No.");
SetupTime :=
Round(
ProdOrderRoutingLineNext."Setup Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLineNext."Setup Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
RunTime :=
Round(
(ResidualLotSize * ProdOrderRoutingLineNext.RunTimePer()) *
CalendarMgt.TimeFactor(ProdOrderRoutingLineNext."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
WaitTime :=
Round(
ProdOrderRoutingLineNext."Wait Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLineNext."Wait Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
MoveTime :=
Round(
ProdOrderRoutingLineNext."Move Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLineNext."Move Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
xProdOrderRoutingLine := ProdOrderRoutingLine;
ProdOrderRoutingLine := ProdOrderRoutingLineNext;
ProdEndingDate := ProdOrderRoutingLine."Ending Date";
ProdEndingTime := ProdOrderRoutingLine."Ending Time";
RemainNeedQty := SetupTime;
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Setup Time", false);
RemainNeedQty := MoveTime;
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Move Time", false);
RemainNeedQty := WaitTime;
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Wait Time", false);
RemainNeedQty := RunTime;
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", false);
ProdOrderRoutingLine := xProdOrderRoutingLine;
ProdOrderRoutingLine."Starting Date" := ProdEndingDate;
ProdOrderRoutingLine."Starting Time" := ProdEndingTime;
ResidualProdStartDateTime := CreateDateTime(ProdEndingDate, ProdEndingTime);
// calculate Ending Date/Time of current line by going forward from Starting Date/Time of the next line
Workcenter.Get(ProdOrderRoutingLine."Work Center No.");
RunTime :=
Round(
(MaxLotSize - SendAheadLotSize) * ProdOrderRoutingLine.RunTimePer() *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
WaitTime :=
Round(
ProdOrderRoutingLine."Wait Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Wait Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
MoveTime :=
Round(
ProdOrderRoutingLine."Move Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Move Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
RemainNeedQty := RunTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", false);
RemainNeedQty := WaitTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Wait Time", false);
RemainNeedQty := MoveTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Move Time", false);
// last lot must be finished by current Work Center, otherwise we recalculate Ending Date/Time of current line
ProdOrderRoutingLine.UpdateDatetime();
if ProdOrderRoutingLine."Ending Date-Time" > ResidualProdStartDateTime then begin
ProdOrderRoutingLine."Ending Date" := DT2Date(ResidualProdStartDateTime);
ProdOrderRoutingLine."Ending Time" := DT2Time(ResidualProdStartDateTime);
FilterCalendarEntryBeforeOrOnDateTime(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", ProdOrderRoutingLine."Ending Date", ProdOrderRoutingLine."Ending Time");
if CalendarEntry.FindLast() then
if ProdOrderRoutingLine."Ending Time" > CalendarEntry."Ending Time" then
if (WaitTime = 0) or (MoveTime <> 0) then
// Wait Time can end outside of working hours, but only if Move Time = 0
ProdOrderRoutingLine."Ending Time" := CalendarEntry."Ending Time";
ProdStartingDate := ProdOrderRoutingLine."Ending Date";
ProdStartingTime := ProdOrderRoutingLine."Ending Time";
end;
exit(false);
end;
procedure CalcRoutingLineBack(CalculateEndDate: Boolean)
var
ProdOrderRoutingLine2: Record "Prod. Order Routing Line";
ProdOrderRoutingLine3: Record "Prod. Order Routing Line";
ConstrainedCapacity: Record "Capacity Constrained Resource";
ParentWorkCenter: Record "Capacity Constrained Resource";
TempProdOrderRoutingLine, TempProdOrderRoutingLine2 : Record "Prod. Order Routing Line" temporary;
WorkCenterQueueTime: Record "Work Center";
RoutingHeader: Record "Routing Header";
RoutingVersion: Record "Routing Version";
Qty, SendAheadLotSize : Decimal;
ParentIsConstrained: Boolean;
ResourceIsConstrained: Boolean;
ShouldCalcNextOperation: Boolean;
IsHandled, IsParallelRouting : Boolean;
begin
IsHandled := false;
OnBeforeCalcRoutingLineBack(ProdOrderRoutingLine, CalculateEndDate, IsHandled);
if IsHandled then
exit;
CalendarEntry.SetRange(Date, 0D, ProdOrderRoutingLine."Ending Date");
ProdEndingTime := ProdOrderRoutingLine."Ending Time";
ProdEndingDate := ProdOrderRoutingLine."Ending Date";
ProdStartingTime := ProdOrderRoutingLine."Ending Time";
ProdStartingDate := ProdOrderRoutingLine."Ending Date";
FirstEntry := true;
IsParallelRouting := false;
RoutingVersion.SetLoadFields(Type);
if RoutingVersion.Get(ProdOrderLine."Routing No.", ProdOrderLine."Routing Version Code") then
IsParallelRouting := RoutingVersion.Type = RoutingVersion.Type::Parallel
else begin
RoutingHeader.SetLoadFields(Type);
if RoutingHeader.Get(ProdOrderLine."Routing No.") then
IsParallelRouting := RoutingHeader.Type = RoutingHeader.Type::Parallel;
end;
ShouldCalcNextOperation := (ProdOrderRoutingLine."Next Operation No." <> '') and CalculateEndDate;
OnCalcRoutingLineBackOnAfterCalcShouldCalcNextOperation(ProdOrderRoutingLine, ShouldCalcNextOperation);
if ShouldCalcNextOperation then begin
Clear(ProdOrderRoutingLine3);
TempProdOrderRoutingLine.Reset();
TempProdOrderRoutingLine.DeleteAll();
SetRoutingLineFilters(ProdOrderRoutingLine, ProdOrderRoutingLine2);
ProdOrderRoutingLine2.SetFilter("Operation No.", ProdOrderRoutingLine."Next Operation No.");
if ProdOrderRoutingLine2.Find('-') then
repeat
TotalLotSize := 0;
GetSendAheadStartingTime(ProdOrderRoutingLine2, SendAheadLotSize);
TempProdOrderRoutingLine.Copy(ProdOrderRoutingLine2);
TempProdOrderRoutingLine.Insert(false, true);
SetMinDateTime(ProdEndingDate, ProdEndingTime, ProdStartingDate, ProdStartingTime);
if IsParallelRouting then
if TempProdOrderRoutingLine2.IsEmpty() then begin
WorkCenterQueueTime.Get(ProdOrderRoutingLine2."Work Center No.");
Qty := Round(
WorkCenterQueueTime."Queue Time" *
CalendarMgt.TimeFactor(WorkCenterQueueTime."Queue Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(WorkCenterQueueTime."Unit of Measure Code"),
WorkCenterQueueTime."Calendar Rounding Precision");
TempProdOrderRoutingLine2.TransferFields(ProdOrderRoutingLine2);
TempProdOrderRoutingLine2."Input Quantity" := Qty;
TempProdOrderRoutingLine2.Insert(false, true);
end else begin
WorkCenterQueueTime.Get(ProdOrderRoutingLine2."Work Center No.");
Qty := Round(
WorkCenterQueueTime."Queue Time" *
CalendarMgt.TimeFactor(WorkCenterQueueTime."Queue Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(WorkCenterQueueTime."Unit of Measure Code"),
WorkCenterQueueTime."Calendar Rounding Precision");
if TempProdOrderRoutingLine2."Work Center No." <> ProdOrderRoutingLine2."Work Center No." then begin
if TempProdOrderRoutingLine2."Input Quantity" < Qty then begin
TempProdOrderRoutingLine2.DeleteAll();
TempProdOrderRoutingLine2.TransferFields(ProdOrderRoutingLine2);
TempProdOrderRoutingLine2."Input Quantity" := Qty;
TempProdOrderRoutingLine2.Insert(false, true);
end;
end else
if ProdOrderRoutingLine2."Starting Date-Time" < TempProdOrderRoutingLine2."Starting Date-Time" then begin
TempProdOrderRoutingLine2.DeleteAll();
TempProdOrderRoutingLine2.TransferFields(ProdOrderRoutingLine2);
TempProdOrderRoutingLine2."Input Quantity" := Qty;
TempProdOrderRoutingLine2.Insert(false, true);
end;
end;
ProdOrderRoutingLine3 := ProdOrderRoutingLine2;
until ProdOrderRoutingLine2.Next() = 0;
if IsParallelRouting then
if ProdOrderRoutingLine2.Get(
TempProdOrderRoutingLine2.Status,
TempProdOrderRoutingLine2."Prod. Order No.",
TempProdOrderRoutingLine2."Routing Reference No.",
TempProdOrderRoutingLine2."Routing No.",
TempProdOrderRoutingLine2."Operation No.")
then begin
GetSendAheadStartingTime(ProdOrderRoutingLine2, SendAheadLotSize);
TempProdOrderRoutingLine.GetBySystemId(ProdOrderRoutingLine2.SystemId);
TempProdOrderRoutingLine.Copy(ProdOrderRoutingLine2);
TempProdOrderRoutingLine.Modify();
WorkCenterQueueTime.Get(ProdOrderRoutingLine2."Work Center No.");
if WorkCenterQueueTime."Queue Time" <> 0 then begin
ProdEndingDate := ProdStartingDate;
ProdEndingTime := ProdStartingTime;
end;
ProdOrderRoutingLine3 := ProdOrderRoutingLine2;
end;
OnCalcRoutingLineBackOnBeforeGetQueueTime(ProdOrderRoutingLine, ProdOrderRoutingLine2, ProdOrderRoutingLine3);
if ProdOrderRoutingLine3."Prod. Order No." <> '' then begin
Workcenter2.Get(ProdOrderRoutingLine3."Work Center No.");
ProdOrderRoutingLine3."Critical Path" := true;
ProdOrderRoutingLine3.UpdateDatetime();
ProdOrderRoutingLine3.Modify();
if ProdOrderRoutingLine3.Type = ProdOrderRoutingLine3.Type::"Machine Center" then begin
MachineCenter.Get(ProdOrderRoutingLine3."No.");
Workcenter2."Queue Time" := MachineCenter."Queue Time";
Workcenter2."Queue Time Unit of Meas. Code" :=
MachineCenter."Queue Time Unit of Meas. Code";
end;
UpdateDates := false;
RemainNeedQty :=
Round(
Workcenter2."Queue Time" *
CalendarMgt.TimeFactor(Workcenter2."Queue Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
LoadCapBack(ProdOrderRoutingLine2.Type, ProdOrderRoutingLine2."No.", RoutingTimeType::"Queue Time", false);
end else
ProdOrderRoutingLine3 := ProdOrderRoutingLine2;
end else
SetLotSizesToMax(SendAheadLotSize, TotalLotSize);
// In case of Parallel Routing and the last operation is finished
if ProdEndingDate = CalendarMgt.GetMaxDate() then begin
ProdOrderRoutingLine."Ending Date" := ProdOrderLine."Ending Date";
ProdOrderRoutingLine."Ending Time" := ProdOrderLine."Ending Time";
ProdEndingTime := ProdOrderRoutingLine."Ending Time";
ProdEndingDate := ProdOrderRoutingLine."Ending Date";
ProdStartingTime := ProdOrderRoutingLine."Ending Time";
ProdStartingDate := ProdOrderRoutingLine."Ending Date";
TotalLotSize := MaxLotSize;
SendAheadLotSize := MaxLotSize;
end;
UpdateDates := true;
CalcMove();
CalcWaitBack();
if ProdOrderRoutingLine."Schedule Manually" then // Move and wait time has been calculated
exit;
repeat
LotSize := SendAheadLotSize;
RemainNeedQty := LotSize * ProdOrderRoutingLine.RunTimePer();
OnCalculateRoutingLineBackOnAfterCalcRemainNeedQtyForLotSize(ProdOrderRoutingLine, RemainNeedQty);
RemainNeedQty :=
Round(
RemainNeedQty *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
GetConstrainedSetup(ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained);
if not ProdOrderRoutingLine."Schedule Manually" and
(ResourceIsConstrained or ParentIsConstrained)
then
FinitelyLoadCapBack(RoutingTimeType::"Run Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained)
else
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", true);
ProdEndingDate := ProdOrderRoutingLine."Starting Date";
ProdEndingTime := ProdOrderRoutingLine."Starting Time";
until FindSendAheadStartingTime(TempProdOrderRoutingLine, SendAheadLotSize);
ProdEndingDate := ProdOrderRoutingLine."Starting Date";
ProdEndingTime := ProdOrderRoutingLine."Starting Time";
RemainNeedQty :=
Round(
ProdOrderRoutingLine."Setup Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Setup Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
OnCalcRoutingLineBackOnAfterCalcRemainNeedQty(ProdOrderRoutingLine, Workcenter, RemainNeedQty);
GetConstrainedSetup(ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained);
if not ProdOrderRoutingLine."Schedule Manually" and
(ResourceIsConstrained or ParentIsConstrained)
then
FinitelyLoadCapBack(RoutingTimeType::"Setup Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained)
else
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Setup Time", true);
ProdOrderRoutingLine."Starting Date" := ProdEndingDate;
ProdOrderRoutingLine."Starting Time" := ProdEndingTime;
if ProdOrderRoutingLine."Ending Date" = CalendarMgt.GetMaxDate() then begin
ProdOrderRoutingLine."Ending Date" := ProdOrderRoutingLine."Starting Date";
ProdOrderRoutingLine."Ending Time" := ProdOrderRoutingLine."Starting Time";
end;
ProdOrderRoutingLine.UpdateDatetime();
ProdOrderRoutingLine.Modify();
OnAfterCalcRoutingLineBack(ProdOrderRoutingLine, ProdOrderLine);
end;
local procedure GetConstrainedSetup(var ConstrainedCapacity: Record "Capacity Constrained Resource"; var ResourceIsConstrained: Boolean; var ParentWorkCenter: Record "Capacity Constrained Resource"; var ParentIsConstrained: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeGetConstrainedSetup(ProdOrderRoutingLine, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained, IsHandled);
if IsHandled then
exit;
ResourceIsConstrained := ConstrainedCapacity.Get(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.");
ParentIsConstrained := ParentWorkCenter.Get(ProdOrderRoutingLine.Type::"Work Center", ProdOrderRoutingLine."Work Center No.");
end;
local procedure GetSendAheadEndingTime(ProdOrderRoutingLinePrev: Record "Prod. Order Routing Line"; var SendAheadLotSize: Decimal): Boolean
var
xProdOrderRoutingLine: Record "Prod. Order Routing Line";
SetupTime: Decimal;
RunTime: Decimal;
WaitTime: Decimal;
MoveTime: Decimal;
ResidualLotSize: Decimal;
ResidualProdStartDateTime: DateTime;
begin
ProdEndingTime := ProdOrderRoutingLinePrev."Ending Time";
ProdEndingDate := ProdOrderRoutingLinePrev."Ending Date";
SendAheadLotSize := MaxLotSize;
if TotalLotSize = MaxLotSize then
exit(true);
if (ProdOrderRoutingLinePrev."Send-Ahead Quantity" = 0) or
(ProdOrderRoutingLinePrev."Send-Ahead Quantity" >= MaxLotSize)
then begin
TotalLotSize := SendAheadLotSize;
exit(false);
end;
SendAheadLotSize := ProdOrderRoutingLinePrev."Send-Ahead Quantity";
if MaxLotSize < (TotalLotSize + SendAheadLotSize) then begin
SendAheadLotSize := MaxLotSize - TotalLotSize;
TotalLotSize := MaxLotSize;
end else begin
if TotalLotSize = 0 then begin
ResidualLotSize := MaxLotSize mod SendAheadLotSize;
if ResidualLotSize = 0 then
ResidualLotSize := SendAheadLotSize;
end;
TotalLotSize += SendAheadLotSize;
end;
ProdOrderCapNeed2.Reset();
ProdOrderCapNeed2.SetCurrentKey(Status, "Prod. Order No.", "Routing Reference No.", "Operation No.", Date, "Starting Time");
ProdOrderCapNeed2.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderCapNeed2.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderCapNeed2.SetRange("Requested Only", false);
ProdOrderCapNeed2.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderCapNeed2.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderCapNeed2.SetRange("Operation No.", ProdOrderRoutingLine."Operation No.");
if ProdOrderCapNeed2.FindFirst() then begin
if TotalLotSize <> MaxLotSize then begin
SendAheadLotSize := MaxLotSize - (TotalLotSize - SendAheadLotSize);
TotalLotSize := MaxLotSize;
end;
exit(false);
end;
// calculate Starting Date/Time of current line using Setup/Run/Wait/Move Time for the first send-ahead lot from previous line
Workcenter2.Get(ProdOrderRoutingLinePrev."Work Center No.");
SetupTime :=
Round(
ProdOrderRoutingLinePrev."Setup Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLinePrev."Setup Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
RunTime :=
Round(
SendAheadLotSize * ProdOrderRoutingLinePrev.RunTimePer() *
CalendarMgt.TimeFactor(ProdOrderRoutingLinePrev."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
WaitTime :=
Round(
ProdOrderRoutingLinePrev."Wait Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLinePrev."Wait Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
MoveTime :=
Round(
ProdOrderRoutingLinePrev."Move Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLinePrev."Move Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
OnGetSendAheadEndingTimeOnAfterCalcTimes(ProdOrderRoutingLinePrev, Workcenter2, SetupTime, RunTime, WaitTime, MoveTime);
xProdOrderRoutingLine := ProdOrderRoutingLine;
ProdOrderRoutingLine := ProdOrderRoutingLinePrev;
ProdStartingDate := ProdOrderRoutingLine."Starting Date";
ProdStartingTime := ProdOrderRoutingLine."Starting Time";
RemainNeedQty := SetupTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Setup Time", false);
RemainNeedQty := RunTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", false);
RemainNeedQty := WaitTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Wait Time", false);
RemainNeedQty := MoveTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Move Time", false);
ProdOrderRoutingLine := xProdOrderRoutingLine;
ProdOrderRoutingLine."Starting Date" := ProdStartingDate;
ProdOrderRoutingLine."Starting Time" := ProdStartingTime;
// calculate Starting Date/Time for the last lot of current line by going forward from Starting Date/Time of the line
Workcenter.Get(ProdOrderRoutingLine."Work Center No.");
SetupTime :=
Round(
ProdOrderRoutingLine."Setup Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
RunTime :=
Round(
(MaxLotSize - ResidualLotSize) * ProdOrderRoutingLine.RunTimePer() *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
OnGetSendAheadEndingTimeOnAfterCalcSetupAndRunTime(ProdOrderRoutingLine, Workcenter, SetupTime, RunTime);
RemainNeedQty := SetupTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Setup Time", false);
RemainNeedQty := RunTime;
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", false);
ResidualProdStartDateTime := CreateDateTime(ProdStartingDate, ProdStartingTime);
// last lot must be finished by previous Work Center, otherwise we recalculate Starting Date/Time of current line
ProdOrderRoutingLinePrev.UpdateDatetime();
if ProdOrderRoutingLinePrev."Ending Date-Time" > ResidualProdStartDateTime then begin
ProdEndingDate := ProdOrderRoutingLinePrev."Ending Date";
ProdEndingTime := ProdOrderRoutingLinePrev."Ending Time";
RemainNeedQty := RunTime;
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", false);
RemainNeedQty := SetupTime;
LoadCapBack(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Setup Time", false);
end;
ProdStartingDate := ProdOrderRoutingLine."Starting Date";
ProdStartingTime := ProdOrderRoutingLine."Starting Time";
ProdEndingDate := ProdOrderRoutingLine."Starting Date";
ProdEndingTime := ProdOrderRoutingLine."Starting Time";
exit(false);
end;
procedure CalcRoutingLineForward(CalculateStartDate: Boolean)
var
ProdOrderRoutingLine2: Record "Prod. Order Routing Line";
ProdOrderRoutingLine3: Record "Prod. Order Routing Line";
ConstrainedCapacity: Record "Capacity Constrained Resource";
ParentWorkCenter: Record "Capacity Constrained Resource";
TempProdOrderRoutingLine: Record "Prod. Order Routing Line" temporary;
SendAheadLotSize: Decimal;
InputQtyDiffTime: Decimal;
ParentIsConstrained: Boolean;
ResourceIsConstrained: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcRoutingLineForward(ProdOrderRoutingLine, CalculateStartDate, IsHandled, TempProdOrderRoutingLine, SendAheadLotSize, MaxLotSize, TotalLotSize, RemainNeedQty, UpdateDates);
if IsHandled then
exit;
CalendarEntry.SetRange(Date, ProdOrderRoutingLine."Starting Date", DMY2Date(31, 12, 9999));
ProdStartingTime := ProdOrderRoutingLine."Starting Time";
ProdStartingDate := ProdOrderRoutingLine."Starting Date";
ProdEndingTime := ProdOrderRoutingLine."Starting Time";
ProdEndingDate := ProdOrderRoutingLine."Starting Date";
InputQtyDiffTime := 0;
FirstEntry := true;
if (ProdOrderRoutingLine."Previous Operation No." <> '') and
CalculateStartDate
then begin
Clear(ProdOrderRoutingLine3);
TempProdOrderRoutingLine.Reset();
TempProdOrderRoutingLine.DeleteAll();
SetRoutingLineFilters(ProdOrderRoutingLine, ProdOrderRoutingLine2);
ProdOrderRoutingLine2.SetFilter("Operation No.", ProdOrderRoutingLine."Previous Operation No.");
if ProdOrderRoutingLine2.Find('-') then
repeat
TotalLotSize := 0;
GetSendAheadEndingTime(ProdOrderRoutingLine2, SendAheadLotSize);
TempProdOrderRoutingLine.Copy(ProdOrderRoutingLine2);
TempProdOrderRoutingLine.Insert();
SetMaxDateTime(ProdStartingDate, ProdStartingTime, ProdEndingDate, ProdEndingTime);
ProdOrderRoutingLine3 := ProdOrderRoutingLine2;
if (ProdOrderRoutingLine2."Send-Ahead Quantity" > 0) and
(ProdOrderRoutingLine2."Input Quantity" > ProdOrderRoutingLine."Input Quantity")
then begin
Workcenter2.Get(ProdOrderRoutingLine2."Work Center No.");
InputQtyDiffTime :=
(ProdOrderRoutingLine2."Input Quantity" - ProdOrderRoutingLine."Input Quantity") *
ProdOrderRoutingLine2.RunTimePer();
InputQtyDiffTime :=
Round(
InputQtyDiffTime *
CalendarMgt.TimeFactor(ProdOrderRoutingLine2."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter2."Unit of Measure Code"),
Workcenter2."Calendar Rounding Precision");
end;
until ProdOrderRoutingLine2.Next() = 0
else begin
// parallel routing with finished first operation
if ProdStartingDate = 0D then begin
ProdOrderRoutingLine2.Get(ProdOrderRoutingLine.Status,
ProdOrderRoutingLine."Prod. Order No.", ProdOrderRoutingLine."Routing Reference No.",
ProdOrderRoutingLine."Routing No.", ProdOrderRoutingLine."Operation No.");
ProdStartingDate := ProdOrderRoutingLine2."Starting Date";
ProdStartingTime := ProdOrderRoutingLine2."Starting Time";
end;
TotalLotSize := MaxLotSize;
SendAheadLotSize := MaxLotSize;
end;
if ProdOrderRoutingLine3."Prod. Order No." <> '' then begin
ProdOrderRoutingLine3."Critical Path" := true;
ProdOrderRoutingLine3.UpdateDatetime();
ProdOrderRoutingLine3.Modify();
end;
end else
SetLotSizesToMax(SendAheadLotSize, TotalLotSize);
RemainNeedQty :=
Round(
Workcenter."Queue Time" *
CalendarMgt.TimeFactor(Workcenter."Queue Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
RemainNeedQty += InputQtyDiffTime;
OnCalcRoutingLineForwardOnBeforeLoadCapForward(ProdOrderRoutingLine, ProdOrderRoutingLine3);
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Queue Time", false);
RemainNeedQty :=
Round(
ProdOrderRoutingLine."Setup Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Setup Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
OnCalcRoutingLineForwardOnAfterCalcRemainNeedQty(ProdOrderRoutingLine, Workcenter, RemainNeedQty);
UpdateDates := true;
GetConstrainedSetup(ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained);
if not ProdOrderRoutingLine."Schedule Manually" and
(RemainNeedQty > 0) and (ResourceIsConstrained or ParentIsConstrained)
then
FinitelyLoadCapForward(RoutingTimeType::"Setup Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained)
else
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Setup Time", true);
FirstInBatch := true;
repeat
if (InputQtyDiffTime > 0) and (TotalLotSize = MaxLotSize) then
SetMaxDateTime(
ProdStartingDate, ProdStartingTime, ProdOrderRoutingLine2."Ending Date", ProdOrderRoutingLine2."Ending Time");
if SendAheadLotSize > ProdOrderQty then
LotSize := ProdOrderQty
else
LotSize := SendAheadLotSize;
RemainNeedQty := LotSize * ProdOrderRoutingLine.RunTimePer();
OnCalculateRoutingLineForwardOnAfterCalcRemainNeedQtyForLotSize(ProdOrderRoutingLine, RemainNeedQty);
RemainNeedQty :=
Round(
RemainNeedQty *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
GetConstrainedSetup(ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained);
if not ProdOrderRoutingLine."Schedule Manually" and
(RemainNeedQty > 0) and (ResourceIsConstrained or ParentIsConstrained)
then
FinitelyLoadCapForward(RoutingTimeType::"Run Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained)
else
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Run Time", true);
ProdStartingDate := ProdOrderRoutingLine."Ending Date";
ProdStartingTime := ProdOrderRoutingLine."Ending Time";
until FindSendAheadEndingTime(TempProdOrderRoutingLine, SendAheadLotSize);
RemainNeedQty :=
Round(
ProdOrderRoutingLine."Wait Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Wait Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
OnCalcRoutingLineForwardOnBeforeLoadCapForward2(ProdOrderRoutingLine, ProdOrderRoutingLine3);
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Wait Time", false);
RemainNeedQty :=
Round(
ProdOrderRoutingLine."Move Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Move Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
LoadCapForward(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.", RoutingTimeType::"Move Time", false);
if ProdOrderRoutingLine."Starting Date" = 0D then begin
ProdOrderRoutingLine."Starting Date" := ProdOrderRoutingLine."Ending Date";
ProdOrderRoutingLine."Starting Time" := ProdOrderRoutingLine."Ending Time";
end;
ProdOrderRoutingLine.UpdateDatetime();
ProdOrderRoutingLine.Modify();
OnAfterCalcRoutingLineForward(ProdOrderRoutingLine, ProdOrderLine);
end;
local procedure CalculateRoutingLineFixed()
var
FixedProdOrderRoutingLine: Record "Prod. Order Routing Line";
CalcEndDate: Boolean;
CalcStartDate: Boolean;
begin
FixedProdOrderRoutingLine := ProdOrderRoutingLine;
if FixedProdOrderRoutingLine."Starting Date-Time" > FixedProdOrderRoutingLine."Ending Date-Time" then
Error(Text007);
// Calculate wait and move time, find end of runtime
CalcEndDate := true;
OnCalculateRoutingLineFixedOnBeforeCalcRoutingLineBack(ProdOrderRoutingLine, CalcEndDate);
CalcRoutingLineBack(CalcEndDate);
RunEndingDateTime :=
CreateDateTime(ProdOrderRoutingLine."Starting Date", ProdOrderRoutingLine."Starting Time");
// Find start of runtime
ProdOrderRoutingLine := FixedProdOrderRoutingLine;
CalcStartDate := true;
OnCalculateRoutingLineFixedOnBeforeCalcRoutingLineForward(ProdOrderRoutingLine, CalcStartDate);
CalcRoutingLineForward(CalcStartDate);
ProdOrderRoutingLine."Starting Time" := FixedProdOrderRoutingLine."Starting Time";
ProdOrderRoutingLine."Starting Date" := FixedProdOrderRoutingLine."Starting Date";
ProdOrderRoutingLine."Ending Time" := FixedProdOrderRoutingLine."Ending Time";
ProdOrderRoutingLine."Ending Date" := FixedProdOrderRoutingLine."Ending Date";
ProdOrderRoutingLine.UpdateDatetime();
ProdOrderRoutingLine.Modify();
end;
procedure CalculateRoutingLine(var ProdOrderRoutingLine2: Record "Prod. Order Routing Line"; Direction: Option Forward,Backward; CalcStartEndDate: Boolean)
var
ProdOrderCapNeed: Record "Prod. Order Capacity Need";
MfgCostCalcMgt: Codeunit "Mfg. Cost Calculation Mgt.";
ExpectedOperOutput: Decimal;
ActualOperOutput: Decimal;
TotalQtyPerOperation: Decimal;
TotalCapacityPerOperation: Decimal;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalculateRoutingLine(ProdOrderRoutingLine2, Direction, CalcStartEndDate, IsHandled);
if IsHandled then
exit;
MfgSetup.Get();
ProdOrderRoutingLine := ProdOrderRoutingLine2;
WaitTimeOnly :=
(ProdOrderRoutingLine."Setup Time" = 0) and (ProdOrderRoutingLine."Run Time" = 0) and
(ProdOrderRoutingLine."Move Time" = 0);
if ProdOrderRoutingLine."Ending Time" = 0T then
ProdOrderRoutingLine."Ending Time" := 000000T;
if ProdOrderRoutingLine."Starting Time" = 0T then
ProdOrderRoutingLine."Starting Time" := 000000T;
ProdOrderRoutingLine."Expected Operation Cost Amt." := 0;
ProdOrderRoutingLine."Expected Capacity Ovhd. Cost" := 0;
ProdOrderRoutingLine."Expected Capacity Need" := 0;
OnCalculateRoutingLineOnBeforeProdOrderCapNeedReset(ProdOrderRoutingLine, ProdOrderRoutingLine2);
ProdOrderCapNeed.Reset();
ProdOrderCapNeed.SetLoadFields(Status, "Prod. Order No.", "Requested Only", "Routing No.", "Routing Reference No.", "Operation No.");
ProdOrderCapNeed.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderCapNeed.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderCapNeed.SetRange("Requested Only", false);
ProdOrderCapNeed.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderCapNeed.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderCapNeed.SetRange("Operation No.", ProdOrderRoutingLine."Operation No.");
ProdOrderCapNeed.DeleteAll();
NextCapNeedLineNo := 1;
ProdOrderRoutingLine.TestField("Work Center No.");
CurrentWorkCenterNo := '';
Workcenter.Get(ProdOrderRoutingLine."Work Center No.");
if ProdOrderRoutingLine.Type = ProdOrderRoutingLine.Type::"Machine Center" then begin
MachineCenter.Get(ProdOrderRoutingLine."No.");
Workcenter."Queue Time" := MachineCenter."Queue Time";
Workcenter."Queue Time Unit of Meas. Code" := MachineCenter."Queue Time Unit of Meas. Code";
end;
if not CalcStartEndDate then
Clear(Workcenter."Queue Time");
ProdOrder.Get(ProdOrderRoutingLine.Status, ProdOrderRoutingLine."Prod. Order No.");
ProdOrderQty := 0;
TotalScrap := 0;
TotalLotSize := 0;
ProdOrderLine.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderLine.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderLine.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderLine.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderLine.SetLoadFields("Quantity (Base)", "Scrap %", "Prod. Order No.", "Line No.", Status, "Routing No.", "Routing Version Code", "Ending Date", "Ending Time");
OnCalculateRoutingLineOnAfterProdOrderLineSetFilters(ProdOrderLine, ProdOrder, ProdOrderRoutingLine);
if ProdOrderLine.Find('-') then begin
ExpectedOperOutput := 0;
repeat
IsHandled := false;
OnCalculateRoutingLineOnBeforeCalcExpectedOperOutput(ProdOrderLine, ExpectedOperOutput, IsHandled);
if not IsHandled then
ExpectedOperOutput := ExpectedOperOutput + ProdOrderLine."Quantity (Base)";
TotalScrap := TotalScrap + ProdOrderLine."Scrap %";
until ProdOrderLine.Next() = 0;
ActualOperOutput := MfgCostCalcMgt.CalcActOutputQtyBase(ProdOrderLine, ProdOrderRoutingLine);
ProdOrderQty := ExpectedOperOutput - ActualOperOutput;
if ProdOrderQty < 0 then
ProdOrderQty := 0;
end;
MaxLotSize :=
ExpectedOperOutput *
(1 + ProdOrderRoutingLine."Scrap Factor % (Accumulated)") *
(1 + TotalScrap / 100) +
ProdOrderRoutingLine."Fixed Scrap Qty. (Accum.)";
OnCalculateRoutingLineOnAfterCalcMaxLotSize(ProdOrderQty, ProdOrderRoutingLine, TotalScrap, MaxLotSize);
ProdOrderRoutingLine."Input Quantity" := MaxLotSize;
if ActualOperOutput > 0 then
TotalQtyPerOperation :=
ExpectedOperOutput *
(1 + ProdOrderRoutingLine."Scrap Factor % (Accumulated)") *
(1 + TotalScrap / 100) +
ProdOrderRoutingLine."Fixed Scrap Qty. (Accum.)"
else
TotalQtyPerOperation := MaxLotSize;
OnBeforeCalcExpectedCost(ProdOrderRoutingLine, MaxLotSize, TotalQtyPerOperation, ActualOperOutput, ExpectedOperOutput, TotalScrap);
TotalCapacityPerOperation :=
Round(
TotalQtyPerOperation *
ProdOrderRoutingLine.RunTimePer() *
CalendarMgt.QtyperTimeUnitofMeasure(
ProdOrderRoutingLine."Work Center No.", ProdOrderRoutingLine."Run Time Unit of Meas. Code"),
UOMMgt.QtyRndPrecision());
OnCalculateRoutingLineOnBeforeCalcCostInclSetup(ProdOrderRoutingLine, TotalCapacityPerOperation, TotalQtyPerOperation);
if MfgSetup."Cost Incl. Setup" then
CalcCostInclSetup(ProdOrderRoutingLine, TotalCapacityPerOperation);
OnCalculateRoutingLineOnAfterCalcCostInclSetup(ProdOrderRoutingLine, TotalCapacityPerOperation, TotalQtyPerOperation);
CalcExpectedCost(ProdOrderRoutingLine, TotalQtyPerOperation, TotalCapacityPerOperation);
IsHandled := false;
OnBeforeScheduleRoutingLine(ProdOrderRoutingLine, CalcStartEndDate, IsHandled, Direction);
if not IsHandled then
if ProdOrderRoutingLine."Schedule Manually" then
CalculateRoutingLineFixed()
else
if Direction = Direction::Backward then
CalcRoutingLineBack(CalcStartEndDate)
else
CalcRoutingLineForward(CalcStartEndDate);
OnAfterCalculateRoutingLine(ProdOrderRoutingLine, Enum::"Transfer Direction".FromInteger(Direction));
ProdOrderRoutingLine2 := ProdOrderRoutingLine;
end;
local procedure SetLotSizesToMax(var SendAheadLotSize: Decimal; var TotalLotSize: Decimal)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSetLotSizesToMax(SendAheadLotSize, TotalLotSize, MaxLotSize, ProdOrderRoutingLine, IsHandled);
if IsHandled then
exit;
TotalLotSize := MaxLotSize;
SendAheadLotSize := MaxLotSize;
end;
local procedure FinitelyLoadCapBack(TimeType: Enum "Routing Time Type"; ConstrainedCapacity: Record "Capacity Constrained Resource"; ResourceIsConstrained: Boolean; ParentWorkCenter: Record "Capacity Constrained Resource"; ParentIsConstrained: Boolean)
var
LastProdOrderCapNeed: Record "Prod. Order Capacity Need";
AvailTime: Decimal;
ProdEndingDateTime: DateTime;
ProdEndingDateTimeAddOneDay: DateTime;
SetupTime: Decimal;
TimetoProgram: Decimal;
AvailCap: Decimal;
DampTime: Decimal;
xConCurrCap: Decimal;
EndTime: Time;
StartTime: Time;
ShouldProcessLastProdOrderCapNeed: Boolean;
begin
if (RemainNeedQty = 0) and WaitTimeOnly then
exit;
EndTime := ProdEndingTime;
ProdEndingDateTime := CreateDateTime(ProdEndingDate, ProdEndingTime);
ProdEndingDateTimeAddOneDay := CreateDateTime(ProdEndingDate + 1, ProdEndingTime);
ConCurrCap := ProdOrderRoutingLine."Concurrent Capacities";
xConCurrCap := 1;
LastProdOrderCapNeed.SetCapacityFilters(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.");
CalendarEntry.SetCapacityFilters(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.");
CalendarEntry.SetFilter("Starting Date-Time", '<= %1', ProdEndingDateTime);
CalendarEntry.SetFilter("Ending Date-Time", '<= %1', ProdEndingDateTimeAddOneDay);
OnFinitelyLoadCapBackOnAfterSetCalendarEntryFilters(CalendarEntry);
if CalendarEntry.Find('+') then
repeat
if (EndTime > CalendarEntry."Ending Time") or (EndTime < CalendarEntry."Starting Time") or
(ProdEndingDate <> CalendarEntry.Date)
then
EndTime := CalendarEntry."Ending Time";
StartTime := EndTime;
if (ConCurrCap = 0) or (CalendarEntry.Capacity < ConCurrCap) then
ConCurrCap := CalendarEntry.Capacity;
if TimeType <> TimeType::"Run Time" then
RemainNeedQty := RemainNeedQty * ConCurrCap / xConCurrCap;
xConCurrCap := ConCurrCap;
CalculateDailyLoad(AvailCap, DampTime, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained);
SetupTime := 0;
if TimeType = TimeType::"Run Time" then begin
SetupTime :=
Round(
ProdOrderRoutingLine."Setup Time" *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Setup Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
SetupTime := SetupTime * ConCurrCap;
OnFinitelyLoadCapBackOnAfterCalcSetupTime(ProdOrderRoutingLine, Workcenter, SetupTime);
end;
if RemainNeedQty + SetupTime <= AvailCap + DampTime then
AvailCap := AvailCap + DampTime;
AvailCap :=
Round(AvailCap *
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code") *
100 / CalendarEntry.Efficiency / ConCurrCap, 1, '>');
if CalendarEntry.Capacity = CalendarEntry."Absence Capacity" then
AvailCap := 0;
ShouldProcessLastProdOrderCapNeed := AvailCap > 0;
OnFinitelyLoadCapBackOnAfterCalcShouldProcessLastProdOrderCapNeed(
ProdOrderRoutingLine, AvailCap, CalendarEntry, ProdEndingTime, ProdEndingDate, TimeType, FirstInBatch, FirstEntry,
UpdateDates, RemainNeedQty, ProdOrderCapNeed, ProdOrder, NextCapNeedLineNo, Workcenter, LotSize, ShouldProcessLastProdOrderCapNeed);
if ShouldProcessLastProdOrderCapNeed then begin
ProdEndingDateTime := CreateDateTime(CalendarEntry.Date, EndTime);
LastProdOrderCapNeed.SetFilter(
"Ending Date-Time", '>= %1 & < %2', CalendarEntry."Starting Date-Time", ProdEndingDateTimeAddOneDay);
LastProdOrderCapNeed.SetFilter(
"Starting Date-Time", '>= %1 & < %2', CalendarEntry."Starting Date-Time", ProdEndingDateTime);
if LastProdOrderCapNeed.Find('+') then
repeat
if LastProdOrderCapNeed."Ending Time" < EndTime then begin
AvailTime := Min(CalendarMgt.CalcTimeDelta(EndTime, LastProdOrderCapNeed."Ending Time"), AvailCap);
OnFinitelyLoadCapBackOnAfterCalcAvailTimeFromLastProdOrderCapNeed(AvailTime, EndTime, AvailCap, LastProdOrderCapNeed);
if AvailTime > 0 then begin
UpdateTimesBack(AvailTime, AvailCap, TimetoProgram, StartTime, EndTime);
CreateCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 1);
if FirstInBatch and FirstEntry then begin
FirstInBatch := false;
FirstEntry := false
end;
if UpdateDates then begin
ProdOrderRoutingLine."Ending Time" := EndTime;
ProdOrderRoutingLine."Ending Date" := CalendarEntry.Date;
UpdateDates := false
end;
EndTime := StartTime;
end;
end;
if LastProdOrderCapNeed."Starting Time" < EndTime then
EndTime := LastProdOrderCapNeed."Starting Time";
until (LastProdOrderCapNeed.Next(-1) = 0) or (RemainNeedQty = 0) or (AvailCap = 0);
if (AvailCap > 0) and (RemainNeedQty > 0) then begin
AvailTime := Min(CalendarMgt.CalcTimeDelta(EndTime, CalendarEntry."Starting Time"), AvailCap);
OnFinitelyLoadCapBackOnAfterCalcAvailTimeFromCalendarEntry(AvailTime, EndTime, AvailCap, CalendarEntry);
if AvailTime > 0 then begin
UpdateTimesBack(AvailTime, AvailCap, TimetoProgram, StartTime, EndTime);
AdjustStartingTime(CalendarEntry, StartTime);
if TimetoProgram <> 0 then
CreateCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 1);
if FirstInBatch and FirstEntry then begin
FirstInBatch := false;
FirstEntry := false
end;
if UpdateDates then begin
ProdOrderRoutingLine."Ending Time" := EndTime;
ProdOrderRoutingLine."Ending Date" := CalendarEntry.Date;
UpdateDates := false
end;
EndTime := StartTime;
end;
end;
end;
if RemainNeedQty > 0 then begin
if CalendarEntry.Next(-1) = 0 then begin
TestForError(Text001, Text002, CalendarEntry.Date);
exit;
end;
EndTime := CalendarEntry."Ending Time";
end else begin
ProdEndingTime := StartTime;
ProdEndingDate := CalendarEntry.Date;
ProdOrderRoutingLine."Starting Time" := StartTime;
ProdOrderRoutingLine."Starting Date" := CalendarEntry.Date;
exit;
end;
until false;
end;
local procedure FinitelyLoadCapForward(TimeType: Enum "Routing Time Type"; ConstrainedCapacity: Record "Capacity Constrained Resource"; ResourceIsConstrained: Boolean; ParentWorkCenter: Record "Capacity Constrained Resource"; ParentIsConstrained: Boolean)
var
NextProdOrderCapNeed: Record "Prod. Order Capacity Need";
AvailTime: Decimal;
ProdStartingDateTime: DateTime;
ProdStartingDateTimeSubOneDay: DateTime;
RunTime: Decimal;
TimetoProgram: Decimal;
AvailCap: Decimal;
DampTime: Decimal;
xConCurrCap: Decimal;
EndTime: Time;
StartTime: Time;
begin
if (RemainNeedQty = 0) and WaitTimeOnly then
exit;
StartTime := ProdStartingTime;
ProdStartingDateTime := CreateDateTime(ProdStartingDate, ProdStartingTime);
ProdStartingDateTimeSubOneDay := CreateDateTime(ProdStartingDate - 1, ProdStartingTime);
ConCurrCap := ProdOrderRoutingLine."Concurrent Capacities";
xConCurrCap := 1;
NextProdOrderCapNeed.SetCapacityFilters(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.");
CalendarEntry.SetCapacityFilters(ProdOrderRoutingLine.Type, ProdOrderRoutingLine."No.");
CalendarEntry.SetFilter("Starting Date-Time", '>= %1', ProdStartingDateTimeSubOneDay);
CalendarEntry.SetFilter("Ending Date-Time", '>= %1', ProdStartingDateTime);
if CalendarEntry.Find('-') then
repeat
if (StartTime < CalendarEntry."Starting Time") or (StartTime > CalendarEntry."Ending Time") or
(ProdStartingDate <> CalendarEntry.Date)
then
StartTime := CalendarEntry."Starting Time";
EndTime := StartTime;
if (ConCurrCap = 0) or (CalendarEntry.Capacity < ConCurrCap) then
ConCurrCap := CalendarEntry.Capacity;
if TimeType <> TimeType::"Run Time" then
RemainNeedQty := RemainNeedQty * ConCurrCap / xConCurrCap;
xConCurrCap := ConCurrCap;
CalculateDailyLoad(AvailCap, DampTime, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained);
RunTime := 0;
if TimeType = TimeType::"Setup Time" then begin
RunTime := LotSize * ProdOrderRoutingLine.RunTimePer();
RunTime :=
Round(RunTime *
CalendarMgt.TimeFactor(ProdOrderRoutingLine."Run Time Unit of Meas. Code") /
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
end;
if RemainNeedQty + RunTime <= AvailCap + DampTime then
AvailCap := AvailCap + DampTime;
AvailCap :=
Round(AvailCap *
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code") *
100 / CalendarEntry.Efficiency / ConCurrCap, 1, '>');
if CalendarEntry.Capacity = CalendarEntry."Absence Capacity" then
AvailCap := 0;
if AvailCap > 0 then begin
ProdStartingDateTime := CreateDateTime(CalendarEntry.Date, StartTime);
NextProdOrderCapNeed.SetFilter(
"Ending Date-Time", '> %1 & <= %2', ProdStartingDateTime, CalendarEntry."Ending Date-Time");
NextProdOrderCapNeed.SetFilter(
"Starting Date-Time", '> %1 & <= %2', ProdStartingDateTimeSubOneDay, CalendarEntry."Ending Date-Time");
if NextProdOrderCapNeed.Find('-') then
repeat
if NextProdOrderCapNeed."Starting Time" > StartTime then begin
AvailTime := Min(CalendarMgt.CalcTimeDelta(NextProdOrderCapNeed."Starting Time", StartTime), AvailCap);
if AvailTime > 0 then begin
UpdateTimesForward(AvailTime, AvailCap, TimetoProgram, StartTime, EndTime);
CreateCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 0);
if FirstInBatch and FirstEntry then begin
FirstInBatch := false;
FirstEntry := false
end;
if UpdateDates then begin
ProdOrderRoutingLine."Starting Time" := StartTime;
ProdOrderRoutingLine."Starting Date" := CalendarEntry.Date;
UpdateDates := false
end;
StartTime := EndTime;
end;
end;
if NextProdOrderCapNeed."Ending Time" > StartTime then
StartTime := NextProdOrderCapNeed."Ending Time"
until (NextProdOrderCapNeed.Next() = 0) or (RemainNeedQty = 0) or (AvailCap = 0);
if (AvailCap > 0) and (RemainNeedQty > 0) then begin
AvailTime := Min(CalendarMgt.CalcTimeDelta(CalendarEntry."Ending Time", StartTime), AvailCap);
if AvailTime > 0 then begin
UpdateTimesForward(AvailTime, AvailCap, TimetoProgram, StartTime, EndTime);
AdjustEndingTime(CalendarEntry, EndTime);
if TimetoProgram <> 0 then
CreateCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 0);
if FirstInBatch and FirstEntry then begin
FirstInBatch := false;
FirstEntry := false
end;
if UpdateDates then begin
ProdOrderRoutingLine."Starting Time" := StartTime;
ProdOrderRoutingLine."Starting Date" := CalendarEntry.Date;
UpdateDates := false
end;
StartTime := EndTime;
end;
end;
end;
if RemainNeedQty > 0 then begin
if CalendarEntry.Next() = 0 then begin
TestForError(Text003, Text004, CalendarEntry.Date);
exit;
end;
StartTime := CalendarEntry."Starting Time";
end else begin
ProdStartingTime := EndTime;
ProdStartingDate := CalendarEntry.Date;
ProdOrderRoutingLine."Ending Time" := EndTime;
ProdOrderRoutingLine."Ending Date" := CalendarEntry.Date;
exit;
end;
until false;
end;
local procedure AdjustEndingTime(CalendarEntry: Record "Calendar Entry"; var EndingTime: Time)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeAdjustEndingTime(IsHandled, CalendarEntry, EndingTime);
if IsHandled then
exit;
if EndingTime > CalendarEntry."Ending Time" then
EndingTime := CalendarEntry."Ending Time";
end;
local procedure AdjustStartingTime(CalendarEntry: Record "Calendar Entry"; var StartingTime: Time)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeAdjustStartingTime(IsHandled, CalendarEntry, StartingTime);
if IsHandled then
exit;
if StartingTime < CalendarEntry."Starting Time" then
StartingTime := CalendarEntry."Starting Time";
end;
local procedure CalculateDailyLoad(var AvailCap: Decimal; var DampTime: Decimal; ConstrainedCapacity: Record "Capacity Constrained Resource"; IsResourceConstrained: Boolean; ParentWorkCenter: Record "Capacity Constrained Resource"; IsParentConstrained: Boolean)
var
CurrentLoadBase: Decimal;
AvailCapWorkCenter: Decimal;
DampTimeWorkCenter: Decimal;
CapEffectiveBase: Decimal;
begin
GetCurrentWorkCenterTimeFactorAndRounding(Workcenter."No.");
if (CalendarEntry."Capacity Type" = CalendarEntry."Capacity Type"::"Work Center") or
((CalendarEntry."Capacity Type" = CalendarEntry."Capacity Type"::"Machine Center") and
(IsResourceConstrained xor IsParentConstrained))
then begin
if IsParentConstrained then begin
ConstrainedCapacity := ParentWorkCenter;
CalcCapConResWorkCenterLoadBase(ConstrainedCapacity, CalendarEntry.Date, CapEffectiveBase, CurrentLoadBase)
end else
CalcCapConResProdOrderNeedBase(ConstrainedCapacity, CalendarEntry.Date, CapEffectiveBase, CurrentLoadBase);
CalcAvailCapBaseAndDampTime(
ConstrainedCapacity, AvailCap, DampTime, CapEffectiveBase, CurrentLoadBase, CurrentTimeFactor, CurrentRounding);
end
else begin
CalcCapConResProdOrderNeedBase(ConstrainedCapacity, CalendarEntry.Date, CapEffectiveBase, CurrentLoadBase);
CalcAvailCapBaseAndDampTime(
ConstrainedCapacity, AvailCap, DampTime, CapEffectiveBase, CurrentLoadBase, CurrentTimeFactor, CurrentRounding);
CalcCapConResWorkCenterLoadBase(ParentWorkCenter, CalendarEntry.Date, CapEffectiveBase, CurrentLoadBase);
CalcAvailCapBaseAndDampTime(
ParentWorkCenter, AvailCapWorkCenter, DampTimeWorkCenter, CapEffectiveBase, CurrentLoadBase, CurrentTimeFactor, CurrentRounding);
if AvailCap + DampTime > AvailCapWorkCenter + DampTimeWorkCenter then
DampTime := DampTimeWorkCenter
else
if AvailCap + DampTime = AvailCapWorkCenter + DampTimeWorkCenter then
DampTime := max(DampTime, DampTimeWorkCenter);
AvailCap := Round(Min(AvailCap, AvailCapWorkCenter), 1);
end;
end;
local procedure UpdateTimesBack(var AvailTime: Decimal; var AvailCap: Decimal; var TimetoProgram: Decimal; var StartTime: Time; EndTime: Time)
var
RoundedTimetoProgram: Decimal;
IsHandled: Boolean;
ShouldUpdateAvailCap: Boolean;
begin
IsHandled := false;
OnBeforeUpdateTimesBack(CalendarEntry, ProdOrderRoutingLine, AvailTime, AvailCap, TimetoProgram, StartTime, EndTime, ConCurrCap, Workcenter, RemainNeedQty, IsHandled);
if IsHandled then
exit;
AvailTime :=
Round(AvailTime / CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code") *
CalendarEntry.Efficiency / 100 * ConCurrCap, Workcenter."Calendar Rounding Precision");
TimetoProgram := Min(RemainNeedQty, AvailTime);
RoundedTimetoProgram :=
Round(TimetoProgram *
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code") *
100 / CalendarEntry.Efficiency / ConCurrCap, 1, '>');
StartTime := CalendarMgt.CalcTimeSubtract(EndTime, RoundedTimetoProgram);
RemainNeedQty := RemainNeedQty - TimetoProgram;
ShouldUpdateAvailCap := ProdOrderRoutingLine.Status <> ProdOrderRoutingLine.Status::Simulated;
OnUpdateTimesBackOnBeforeUpdateAvailCap(ProdOrderRoutingLine, ShouldUpdateAvailCap);
if ShouldUpdateAvailCap then
AvailCap := AvailCap - RoundedTimetoProgram;
end;
local procedure UpdateTimesForward(var AvailTime: Decimal; var AvailCap: Decimal; var TimetoProgram: Decimal; StartTime: Time; var EndTime: Time)
var
RoundedTimetoProgram: Decimal;
IsHandled: Boolean;
ShouldUpdateAvailCap: Boolean;
begin
IsHandled := false;
OnBeforeUpdateTimesForward(CalendarEntry, ProdOrderRoutingLine, AvailTime, AvailCap, TimetoProgram, StartTime, EndTime, ConCurrCap, Workcenter, RemainNeedQty, IsHandled);
if IsHandled then
exit;
AvailTime :=
Round(AvailTime / CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code") *
CalendarEntry.Efficiency / 100 * ConCurrCap, Workcenter."Calendar Rounding Precision");
TimetoProgram := Min(RemainNeedQty, AvailTime);
RoundedTimetoProgram :=
Round(TimetoProgram *
CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code") *
100 / CalendarEntry.Efficiency / ConCurrCap, 1, '>');
EndTime := StartTime + RoundedTimetoProgram;
RemainNeedQty := RemainNeedQty - TimetoProgram;
ShouldUpdateAvailCap := ProdOrderRoutingLine.Status <> ProdOrderRoutingLine.Status::Simulated;
OnUpdateTimesForwardOnBeforeUpdateAvailCap(ProdOrderRoutingLine, ShouldUpdateAvailCap);
if ShouldUpdateAvailCap then
AvailCap := AvailCap - RoundedTimetoProgram;
end;
local procedure "Min"(Number1: Decimal; Number2: Decimal): Decimal
begin
if Number1 <= Number2 then
exit(Number1);
exit(Number2);
end;
local procedure "Max"(Number1: Decimal; Number2: Decimal): Decimal
begin
if Number1 >= Number2 then
exit(Number1);
exit(Number2);
end;
local procedure CalcExpectedCost(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TotalQtyPerOperation: Decimal; TotalCapacityPerOperation: Decimal)
begin
if ProdOrderRoutingLine."Unit Cost Calculation" = ProdOrderRoutingLine."Unit Cost Calculation"::Time then begin
ProdOrderRoutingLine."Expected Operation Cost Amt." :=
TotalCapacityPerOperation * ProdOrderRoutingLine."Unit Cost per";
ProdOrderRoutingLine."Expected Capacity Ovhd. Cost" :=
TotalCapacityPerOperation *
(ProdOrderRoutingLine."Direct Unit Cost" *
ProdOrderRoutingLine."Indirect Cost %" / 100 + ProdOrderRoutingLine."Overhead Rate");
end else begin
ProdOrderRoutingLine."Expected Operation Cost Amt." :=
TotalQtyPerOperation * ProdOrderRoutingLine."Unit Cost per";
ProdOrderRoutingLine."Expected Capacity Ovhd. Cost" :=
TotalQtyPerOperation *
(ProdOrderRoutingLine."Direct Unit Cost" *
ProdOrderRoutingLine."Indirect Cost %" / 100 + ProdOrderRoutingLine."Overhead Rate");
end;
end;
local procedure CalcCostInclSetup(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var TotalCapacityPerOperation: Decimal)
var
ConcurrentCapacity: Decimal;
begin
OnBeforeCalcCostInclSetup(ProdOrderRoutingLine, TotalCapacityPerOperation);
ConcurrentCapacity := ProdOrderRoutingLine."Concurrent Capacities";
if ConcurrentCapacity = 0 then
ConcurrentCapacity := 1;
TotalCapacityPerOperation :=
TotalCapacityPerOperation +
Round(
ConcurrentCapacity * ProdOrderRoutingLine."Setup Time" *
CalendarMgt.QtyperTimeUnitofMeasure(
ProdOrderRoutingLine."Work Center No.", ProdOrderRoutingLine."Setup Time Unit of Meas. Code"),
UOMMgt.QtyRndPrecision());
OnAfterCalcCostInclSetup(ProdOrderRoutingLine, TotalCapacityPerOperation);
end;
local procedure CalcDuration(DateTime1: DateTime; DateTime2: DateTime) TotalDuration: Decimal
begin
TotalDuration :=
Round(
(DT2Date(DateTime2) - DT2Date(DateTime1)) * (86400000 / CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code")) +
(DT2Time(DateTime2) - DT2Time(DateTime1)) / CalendarMgt.TimeFactor(Workcenter."Unit of Measure Code"),
Workcenter."Calendar Rounding Precision");
exit(TotalDuration);
end;
local procedure FindSendAheadEndingTime(var TempProdOrderRoutingLine: Record "Prod. Order Routing Line"; var SendAheadLotSize: Decimal): Boolean
var
Result: Boolean;
xTotalLotSize: Decimal;
xSendAheadLotSize: Decimal;
begin
xTotalLotSize := TotalLotSize;
xSendAheadLotSize := SendAheadLotSize;
if TempProdOrderRoutingLine.FindSet() then
repeat
TotalLotSize := xTotalLotSize;
SendAheadLotSize := xSendAheadLotSize;
Result := Result or GetSendAheadEndingTime(TempProdOrderRoutingLine, SendAheadLotSize);
until TempProdOrderRoutingLine.Next() = 0
else
Result := GetSendAheadEndingTime(TempProdOrderRoutingLine, SendAheadLotSize);
exit(Result);
end;
local procedure FindSendAheadStartingTime(var TempProdOrderRoutingLine: Record "Prod. Order Routing Line"; var SendAheadLotSize: Decimal): Boolean
var
Result: Boolean;
xTotalLotSize: Decimal;
xSendAheadLotSize: Decimal;
begin
xTotalLotSize := TotalLotSize;
xSendAheadLotSize := SendAheadLotSize;
if TempProdOrderRoutingLine.FindSet() then
repeat
TotalLotSize := xTotalLotSize;
SendAheadLotSize := xSendAheadLotSize;
Result := Result or GetSendAheadStartingTime(TempProdOrderRoutingLine, SendAheadLotSize);
until TempProdOrderRoutingLine.Next() = 0
else
Result := GetSendAheadStartingTime(TempProdOrderRoutingLine, SendAheadLotSize);
exit(Result);
end;
procedure ReturnNextCalendarEntry(var CalendarEntry2: Record "Calendar Entry"; OldCalendarEntry: Record "Calendar Entry"; Direction: Option Backward,Forward)
begin
CalendarEntry2 := OldCalendarEntry;
CalendarEntry2.SetRange(Date, CalendarEntry2.Date);
OnReturnNextCalendarEntryOnAfterSetCalendarEntryDateFilter(CalendarEntry);
if Direction = Direction::Backward then begin
CalendarEntry2.Find('-'); // rewind within the same day
CalendarEntry2.SetRange(Date);
if CalendarEntry2.Next(-1) = 0 then
TestForError(Text001, Text002, CalendarEntry2.Date);
if (CalendarEntry2.Date + 1) < OldCalendarEntry.Date then begin
CalendarEntry2.Date := OldCalendarEntry.Date - 1;
CreateCalendarEntry(CalendarEntry2);
end;
end else begin
CalendarEntry2.Find('+'); // rewind within the same day
CalendarEntry2.SetRange(Date);
if CalendarEntry2.Next() = 0 then
TestForError(Text003, Text004, CalendarEntry2.Date);
if OldCalendarEntry.Date < (CalendarEntry2.Date - 1) then begin
CalendarEntry2.Date := OldCalendarEntry.Date + 1;
CreateCalendarEntry(CalendarEntry2);
end;
end;
end;
local procedure CreateCalendarEntry(var CalendarEntry2: Record "Calendar Entry")
begin
CalendarEntry2."Ending Time" := 000000T;
CalendarEntry2."Starting Time" := 000000T;
CalendarEntry2.Efficiency := 100;
CalendarEntry2."Absence Capacity" := 0;
CalendarEntry2."Capacity (Total)" := 0;
CalendarEntry2."Capacity (Effective)" := CalendarEntry2."Capacity (Total)";
CalendarEntry2."Starting Date-Time" := CreateDateTime(CalendarEntry2.Date, CalendarEntry2."Starting Time");
CalendarEntry2."Ending Date-Time" := CalendarEntry2."Starting Date-Time" + 86400000;
if not CalendarEntry2.Get(CalendarEntry2."Capacity Type", CalendarEntry2."No.", CalendarEntry2.Date, CalendarEntry2."Starting Time", CalendarEntry2."Ending Time", CalendarEntry2."Work Shift Code") then
CalendarEntry2.Insert();
end;
local procedure GetCurrentWorkCenterTimeFactorAndRounding(WorkCenterNo: Code[20])
var
WorkCenter: Record "Work Center";
begin
if CurrentWorkCenterNo = WorkCenterNo then
exit;
WorkCenter.Get(WorkCenterNo);
CurrentTimeFactor := CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code");
CurrentRounding := WorkCenter."Calendar Rounding Precision";
end;
local procedure CalcCapConResWorkCenterLoadBase(CapacityConstrainedResource: Record "Capacity Constrained Resource"; DateFilter: Date; var CapEffectiveBase: Decimal; var LoadBase: Decimal)
begin
CapEffectiveBase := 0;
LoadBase := 0;
CapacityConstrainedResource.SetRange("Date Filter", DateFilter);
CapacityConstrainedResource.CalcFields("Capacity (Effective)", "Work Center Load Qty.");
if CapacityConstrainedResource."Capacity (Effective)" <> 0 then begin
CapEffectiveBase := Round(CapacityConstrainedResource."Capacity (Effective)" * CurrentTimeFactor, CurrentRounding);
LoadBase := Round(CapacityConstrainedResource."Work Center Load Qty." * CurrentTimeFactor, CurrentRounding);
end;
end;
local procedure CalcCapConResProdOrderNeedBase(CapacityConstrainedResource: Record "Capacity Constrained Resource"; DateFilter: Date; var CapEffectiveBase: Decimal; var LoadBase: Decimal)
begin
CapEffectiveBase := 0;
LoadBase := 0;
CapacityConstrainedResource.SetRange("Date Filter", DateFilter);
CapacityConstrainedResource.CalcFields("Capacity (Effective)", "Prod. Order Need Qty.");
if CapacityConstrainedResource."Capacity (Effective)" <> 0 then begin
CapEffectiveBase := Round(CapacityConstrainedResource."Capacity (Effective)" * CurrentTimeFactor, CurrentRounding);
LoadBase := Round(CapacityConstrainedResource."Prod. Order Need Qty." * CurrentTimeFactor, CurrentRounding);
end;
end;
procedure CalcAvailCapBaseAndDampTime(CapacityConstrainedResource: Record "Capacity Constrained Resource"; var AvailCap: Decimal; var DampTime: Decimal; CapEffectiveBase: Decimal; LoadBase: Decimal; TimeFactor: Decimal; Rounding: Decimal)
var
AvailCapBase: Decimal;
AvailCapBaseMax: Decimal;
LoadPct: Decimal;
DampenerPct: Decimal;
CriticalLoadPct: Decimal;
begin
AvailCap := 0;
DampTime := 0;
if CapEffectiveBase = 0 then
exit;
CriticalLoadPct := CapacityConstrainedResource."Critical Load %";
AvailCapBaseMax := Round(CapEffectiveBase * CriticalLoadPct / 100, Rounding);
AvailCapBase := max(0, AvailCapBaseMax - LoadBase);
AvailCap := Round(AvailCapBase / TimeFactor, Rounding);
LoadPct := Round(LoadBase / CapEffectiveBase * 100, Rounding);
DampenerPct := CapacityConstrainedResource."Dampener (% of Total Capacity)";
DampTime :=
Round(CapEffectiveBase / TimeFactor * Min(DampenerPct, CriticalLoadPct + DampenerPct - LoadPct) / 100, Rounding);
DampTime := Round(Max(0, DampTime), 1);
end;
procedure CalcAvailQtyBase(var CalendarEntry: Record "Calendar Entry"; ProdStartDate: Date; ProdStartTime: Time; TimeType: Enum "Routing Time Type"; ConCurrCap: Decimal; IsForward: Boolean; TimeFactor: Decimal; Rounding: Decimal) AvQtyBase: Decimal
var
CalendarStartTime: Time;
CalendarEndTime: Time;
CalcFactor: Integer;
ModifyCalendar: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcAvailQtyBase(CalendarEntry, TimeType, AvQtyBase, IsHandled);
if IsHandled then
exit(AvQtyBase);
if IsForward then begin
CalendarStartTime := CalendarEntry."Starting Time";
CalendarEndTime := CalendarEntry."Ending Time";
CalcFactor := -1
end else begin
CalendarStartTime := CalendarEntry."Ending Time";
CalendarEndTime := CalendarEntry."Starting Time";
CalcFactor := 1;
end;
ModifyCalendar := false;
if (((CalendarStartTime < ProdStartTime) and IsForward) or
((CalendarStartTime > ProdStartTime) and not IsForward)) and
(CalendarEntry.Date = ProdStartDate)
then begin
case TimeType of
TimeType::"Setup Time",
TimeType::"Run Time":
AvQtyBase :=
Round(
Abs(CalendarEndTime - ProdStartTime) *
CalendarEntry.Efficiency / 100 * ConCurrCap, Rounding);
TimeType::"Move Time",
TimeType::"Queue Time":
AvQtyBase :=
Round(
Abs(CalendarEndTime - ProdStartTime) *
ConCurrCap, Rounding);
TimeType::"Wait Time":
begin
AvQtyBase := CalcAvailQtyBaseForWaitTime(ProdStartTime, ProdStartDate, CalendarEntry.Date, CalcFactor, IsForward);
AvQtyBase := Round(AvQtyBase * ConCurrCap, Rounding);
end;
end;
ModifyCalendar := true;
end else
if (CalendarEntry.Capacity = CalendarEntry."Absence Capacity") and
(TimeType <> TimeType::"Wait Time")
then
AvQtyBase := 0
else
case TimeType of
TimeType::"Setup Time",
TimeType::"Run Time":
AvQtyBase :=
Round(
TimeFactor * CalendarEntry."Capacity (Effective)" /
(CalendarEntry.Capacity - CalendarEntry."Absence Capacity") * ConCurrCap,
Rounding);
TimeType::"Move Time",
TimeType::"Queue Time":
AvQtyBase :=
Round(
TimeFactor * CalendarEntry."Capacity (Total)" /
(CalendarEntry.Capacity - CalendarEntry."Absence Capacity") * ConCurrCap,
Rounding);
TimeType::"Wait Time":
begin
AvQtyBase := CalcAvailQtyBaseForWaitTime(ProdStartTime, ProdStartDate, CalendarEntry.Date, CalcFactor, IsForward);
AvQtyBase := Round(AvQtyBase * ConCurrCap, Rounding);
ModifyCalendar := true;
end;
end;
if ModifyCalendar then
if IsForward then
CalendarEntry."Starting Time" := ProdStartTime
else
CalendarEntry."Ending Time" := ProdStartTime;
end;
local procedure CalcAvailQtyBaseForWaitTime(ProdStartTime: Time; ProdStartDate: Date; CalendarEntryDate: Date; CalcFactor: Integer; IsForward: Boolean): Decimal
begin
if (ProdStartTime = 000000T) and ((CalendarEntryDate <> ProdStartDate) or IsForward) then
exit(86400000);
exit((86400000 + (ProdStartTime - 000000T) * CalcFactor) mod 86400000);
end;
local procedure CalcActuallyPostedCapacityTime(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"): Decimal
var
CapacityLedgerEntry: Record "Capacity Ledger Entry";
begin
if not (ProdOrderRoutingLine.Status in
[ProdOrderRoutingLine.Status::Released, ProdOrderRoutingLine.Status::Finished])
then
exit(0);
if TimeType in [TimeType::"Setup Time", TimeType::"Run Time"] then begin
CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Production);
CapacityLedgerEntry.SetRange("Order No.", ProdOrderRoutingLine."Prod. Order No.");
CapacityLedgerEntry.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
CapacityLedgerEntry.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
CapacityLedgerEntry.SetRange("Operation No.", ProdOrderRoutingLine."Operation No.");
if TimeType = TimeType::"Setup Time" then begin
CapacityLedgerEntry.CalcSums("Setup Time");
exit(CapacityLedgerEntry."Setup Time");
end;
if TimeType = TimeType::"Run Time" then begin
CapacityLedgerEntry.CalcSums("Run Time");
exit(CapacityLedgerEntry."Run Time");
end;
end;
exit(0);
end;
local procedure CalcDistributedCapacityNeedForOperation(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"): Decimal
var
ProdOrderCapacityNeed: Record "Prod. Order Capacity Need";
begin
ProdOrderCapacityNeed.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderCapacityNeed.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderCapacityNeed.SetRange("Requested Only", false);
ProdOrderCapacityNeed.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderCapacityNeed.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderCapacityNeed.SetRange("Operation No.", ProdOrderRoutingLine."Operation No.");
ProdOrderCapacityNeed.SetRange("Time Type", TimeType);
ProdOrderCapacityNeed.CalcSums("Needed Time", "Allocated Time");
exit(ProdOrderCapacityNeed."Needed Time" - ProdOrderCapacityNeed."Allocated Time");
end;
local procedure SetMaxDateTime(var ResultingDate: Date; var ResultingTime: Time; DateToCompare: Date; TimeToCompare: Time)
begin
if ((ResultingDate = DateToCompare) and (ResultingTime >= TimeToCompare)) or
(ResultingDate > DateToCompare)
then
exit;
ResultingDate := DateToCompare;
ResultingTime := TimeToCompare;
end;
local procedure SetMinDateTime(var ResultingDate: Date; var ResultingTime: Time; DateToCompare: Date; TimeToCompare: Time)
begin
if ((ResultingDate = DateToCompare) and (ResultingTime <= TimeToCompare)) or
(ResultingDate < DateToCompare)
then
exit;
ResultingDate := DateToCompare;
ResultingTime := TimeToCompare
end;
local procedure SetRoutingLineFilters(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ProdOrderRoutingLine2: Record "Prod. Order Routing Line")
begin
ProdOrderRoutingLine2.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderRoutingLine2.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderRoutingLine2.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderRoutingLine2.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderRoutingLine2.SetFilter("Routing Status", '<>%1', ProdOrderRoutingLine2."Routing Status"::Finished);
end;
local procedure FilterCalendarEntryBeforeOrOnDateTime(CapacityType: Enum "Capacity Type"; WorkMachineCenterNo: Code[20]; DateValue: Date; TimeValue: Time)
begin
CalendarEntry.SetCapacityFilters(CapacityType, WorkMachineCenterNo);
CalendarEntry.SetRange("Starting Date-Time", 0DT, CreateDateTime(DateValue, TimeValue));
CalendarEntry.SetRange("Ending Date-Time", 0DT, CreateDateTime(DateValue + 1, TimeValue));
end;
procedure ReplanRoutingLine(var ProdOrderRoutingLine2: Record "Prod. Order Routing Line"; Direction: Option Forward,Backward; CalcStartEndDate: Boolean)
var
ProdOrderCapacityNeed: Record "Prod. Order Capacity Need";
MfgCostCalcMgt: Codeunit "Mfg. Cost Calculation Mgt.";
ActualOperOutput: Decimal;
TotalQtyPerOperation: Decimal;
TotalCapacityPerOperation: Decimal;
begin
MfgSetup.Get();
ProdOrderRoutingLine := ProdOrderRoutingLine2;
WaitTimeOnly :=
(ProdOrderRoutingLine."Setup Time" = 0) and (ProdOrderRoutingLine."Run Time" = 0) and
(ProdOrderRoutingLine."Move Time" = 0);
if ProdOrderRoutingLine."Ending Time" = 0T then
ProdOrderRoutingLine."Ending Time" := 000000T;
if ProdOrderRoutingLine."Starting Time" = 0T then
ProdOrderRoutingLine."Starting Time" := 000000T;
ProdOrderRoutingLine."Expected Operation Cost Amt." := 0;
ProdOrderRoutingLine."Expected Capacity Ovhd. Cost" := 0;
ProdOrderRoutingLine."Expected Capacity Need" := 0;
ProdOrderCapacityNeed.Reset();
ProdOrderCapacityNeed.SetLoadFields(Status, "Prod. Order No.", "Requested Only", "Routing No.", "Routing Reference No.", "Operation No.");
ProdOrderCapacityNeed.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderCapacityNeed.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderCapacityNeed.SetRange("Requested Only", false);
ProdOrderCapacityNeed.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderCapacityNeed.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderCapacityNeed.SetRange("Operation No.", ProdOrderRoutingLine."Operation No.");
ProdOrderCapacityNeed.DeleteAll();
NextCapNeedLineNo := 1;
ProdOrderRoutingLine.TestField("Work Center No.");
CurrentWorkCenterNo := '';
Workcenter.Get(ProdOrderRoutingLine."Work Center No.");
if ProdOrderRoutingLine.Type = ProdOrderRoutingLine.Type::"Machine Center" then begin
MachineCenter.Get(ProdOrderRoutingLine."No.");
Workcenter."Queue Time" := MachineCenter."Queue Time";
Workcenter."Queue Time Unit of Meas. Code" := MachineCenter."Queue Time Unit of Meas. Code";
end;
if not CalcStartEndDate then
Clear(Workcenter."Queue Time");
ProdOrder.Get(ProdOrderRoutingLine.Status, ProdOrderRoutingLine."Prod. Order No.");
ProdOrderQty := 0;
TotalLotSize := 0;
ProdOrderLine.SetRange(Status, ProdOrderRoutingLine.Status);
ProdOrderLine.SetRange("Prod. Order No.", ProdOrderRoutingLine."Prod. Order No.");
ProdOrderLine.SetRange("Routing Reference No.", ProdOrderRoutingLine."Routing Reference No.");
ProdOrderLine.SetRange("Routing No.", ProdOrderRoutingLine."Routing No.");
ProdOrderLine.SetLoadFields("Quantity (Base)", "Scrap %", "Prod. Order No.", "Line No.", Status, "Routing No.", "Routing Version Code", "Ending Date", "Ending Time");
if ProdOrderLine.FindFirst() then
ProdOrderLine.CalcSums("Quantity (Base)", "Scrap %");
ActualOperOutput := MfgCostCalcMgt.CalcActOutputQtyBase(ProdOrderLine, ProdOrderRoutingLine);
ProdOrderQty := ProdOrderLine."Quantity (Base)" - ActualOperOutput;
if ProdOrderQty < 0 then
ProdOrderQty := 0;
MaxLotSize :=
ProdOrderQty *
(1 + ProdOrderRoutingLine."Scrap Factor % (Accumulated)") *
(1 + ProdOrderLine."Scrap %" / 100) +
ProdOrderRoutingLine."Fixed Scrap Qty. (Accum.)";
ProdOrderRoutingLine."Input Quantity" := MaxLotSize;
if ActualOperOutput > 0 then
TotalQtyPerOperation :=
ProdOrderLine."Quantity (Base)" *
(1 + ProdOrderRoutingLine."Scrap Factor % (Accumulated)") *
(1 + ProdOrderLine."Scrap %" / 100) +
ProdOrderRoutingLine."Fixed Scrap Qty. (Accum.)"
else
TotalQtyPerOperation := MaxLotSize;
TotalCapacityPerOperation :=
Round(
TotalQtyPerOperation *
ProdOrderRoutingLine.RunTimePer() *
CalendarMgt.QtyperTimeUnitofMeasure(
ProdOrderRoutingLine."Work Center No.", ProdOrderRoutingLine."Run Time Unit of Meas. Code"),
UOMMgt.QtyRndPrecision());
if MfgSetup."Cost Incl. Setup" then
CalcCostInclSetup(ProdOrderRoutingLine, TotalCapacityPerOperation);
CalcExpectedCost(ProdOrderRoutingLine, TotalQtyPerOperation, TotalCapacityPerOperation);
if ProdOrderRoutingLine."Schedule Manually" then
CalculateRoutingLineFixed()
else
if Direction = Direction::Backward then
CalcRoutingLineBack(CalcStartEndDate)
else
CalcRoutingLineForward(CalcStartEndDate);
ProdOrderRoutingLine2 := ProdOrderRoutingLine;
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcCostInclSetup(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var TotalCapacityPerOperation: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalculateRoutingLine(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; Direction: Enum "Transfer Direction")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitProdOrderCapNeed(ProdOrder: Record "Production Order"; var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ProdOrderCapNeed: Record "Prod. Order Capacity Need"; var NeedQty: Decimal; TimeType: Enum "Routing Time Type"; var ActuallyPostedTime: Decimal; var DistributedCapNeed: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeAdjustEndingTime(var IsHandled: Boolean; CalendarEntry: Record "Calendar Entry"; var EndingTime: Time)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeAdjustStartingTime(var IsHandled: Boolean; CalendarEntry: Record "Calendar Entry"; var StartingTime: Time)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcCostInclSetup(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var TotalCapacityPerOperation: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcExpectedCost(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var MaxLotSize: Decimal; var TotalQtyPerOperation: Decimal; var ActualOperOutput: Decimal; var ExpectedOperOutput: Decimal; var TotalScrap: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetConstrainedSetup(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ConstrainedCapacity: Record "Capacity Constrained Resource"; var ResourceIsConstrained: Boolean; var ParentWorkCenter: Record "Capacity Constrained Resource"; var ParentIsConstrained: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcRoutingLineBack(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; ProdOrderLine: Record "Prod. Order Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcRoutingLineForward(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; ProdOrderLine: Record "Prod. Order Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCreateCapNeeded(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; NeedDate: Date; NeedQty: Decimal; RemainNeedQty: Decimal; CalendarEntry: Record "Calendar Entry"; StartingTime: Time; EndingTime: Time; TimeType: Integer; var NextCapNeedLineNo: Integer; ConCurrCap: Decimal; LotSize: Decimal; FirstInBatch: Boolean; Direction: Integer);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcLoadBackAvailQtyBase(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; CurrentTimeFactor: Decimal; CurrentRounding: Decimal; var AvQtyBase: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcLoadForwardAvailQtyBase(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; CurrentTimeFactor: Decimal; CurrentRounding: Decimal; var AvQtyBase: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcRoutingLineBack(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var CalculateEndDate: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeLoadCapBack(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; RemainNeedQty: Decimal; var ProdEndingDate: Date; var ProdEndingTime: Time)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeLoadCapForward(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; CapType: Enum "Capacity Type"; CapNo: Code[20]; TimeType: Enum "Routing Time Type"; var ProdStartingDate: Date; var ProdStartingTime: Time; var IsHandled: Boolean; RemainNeedQty: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeProdOrderCapNeedInsert(var ProdOrderCapNeed: Record "Prod. Order Capacity Need"; ProdOrderRoutingLine: Record "Prod. Order Routing Line"; ProdOrder: Record "Production Order"; var CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSetLotSizesToMax(var SendAheadLotSize: Decimal; var TotalLotSize: Decimal; MaxLotSize: Decimal; ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeScheduleRoutingLine(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var CalcStartEndDate: Boolean; var IsHandled: Boolean; var Direction: Option Forward,Backward)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcMove(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var ProdEndingDate: Date; var ProdEndingTime: Time; var UpdateDates: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcRoutingLineForward(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var CalculateStartDate: Boolean; var IsHandled: Boolean; var TempProdOrderRoutingLine: Record "Prod. Order Routing Line" temporary; var SendAheadLotSize: Decimal; MaxLotSize: Decimal; var TotalLotSize: Decimal; var RemainNeedQty: Decimal; var UpdateDates: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcWaitBack(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var ProdEndingDate: Date; var ProdEndingTime: Time; var UpdateDates: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineOnAfterProdOrderLineSetFilters(var ProdOrderLine: Record "Prod. Order Line"; ProductionOrder: Record "Production Order"; ProdOrderRoutingLine: Record "Prod. Order Routing Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineOnBeforeCalcExpectedOperOutput(var ProdOrderLine: Record "Prod. Order Line"; var ExpectedOperOutput: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineOnBeforeProdOrderCapNeedReset(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; ProdOrderRoutingLine2: Record "Prod. Order Routing Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadBackOnAfterCalcRelevantEfficiency(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; var RelevantEfficiency: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadBackOnBeforeEndStopLoop(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; var StopLoop: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadForwardOnBeforeCalcEndingTime(var EndingTime: Time; CalendarEntry: Record "Calendar Entry"; AvQtyBase: Decimal; RelevantEfficiency: Decimal; ConCurrCap: Decimal; var IsHandled: Boolean; ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadForwardOnBeforeEndStopLoop(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var TimeType: Enum "Routing Time Type"; var StopLoop: Boolean; FirstEntry: Boolean; WaitTimeOnly: Boolean; ProdStartingDate: Date; ProdStartingTime: Time; ProdEndingDate: Date; ProdEndingTime: Time; var RemainNeedQty: Decimal; var RemainNeedQtyBase: Decimal; var Write: Boolean; var LoadFactor: Decimal; var CurrentWorkCenterNo: Code[20]; var CurrentTimeFactor: Decimal; var CurrentRounding: Decimal; var CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadForwardOnBeforeCheckWrite(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; var RelevantEfficiency: Decimal; var RemainNeedQtyBase: Decimal; var RemainNeedQty: Decimal; CurrentRounding: Decimal; Write: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadBackOnBeforeCheckWrite(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TimeType: Enum "Routing Time Type"; var RelevantEfficiency: Decimal; var RemainNeedQtyBase: Decimal; var RemainNeedQty: Decimal; CurrentRounding: Decimal; Write: Boolean; var StartingTime: Time; AvQtyBase: Decimal; var CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineOnAfterCalcCostInclSetup(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var TotalCapacityPerOperation: Decimal; var TotalQtyPerOperation: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineOnBeforeCalcCostInclSetup(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var TotalCapacityPerOperation: Decimal; var TotalQtyPerOperation: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcRoutingLineBackOnBeforeGetQueueTime(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ProdOrderRoutingLine2: Record "Prod. Order Routing Line"; var ProdOrderRoutingLine3: Record "Prod. Order Routing Line");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineBackOnAfterCalcRemainNeedQtyForLotSize(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var RemainNeedQty: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcRoutingLineBackOnAfterCalcShouldCalcNextOperation(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ShouldCalcNextOperation: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineForwardOnAfterCalcRemainNeedQtyForLotSize(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var RemainNeedQty: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineFixedOnBeforeCalcRoutingLineBack(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var CalcEndDate: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineFixedOnBeforeCalcRoutingLineForward(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var CalcStartDate: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnFinitelyLoadCapBackOnAfterCalcShouldProcessLastProdOrderCapNeed(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; AvailCap: Decimal; CalendarEntry: Record "Calendar Entry"; ProdEndingTime: Time; ProdEndingDate: Date; TimeType: Enum "Routing Time Type"; var FirstInBatch: Boolean; var FirstEntry: Boolean; var UpdateDates: Boolean; var RemainNeedQty: Decimal; var ProdOrderCapNeed: Record "Prod. Order Capacity Need"; ProdOrder: Record "Production Order"; var NextCapNeedLineNo: Integer; Workcenter: Record "Work Center"; LotSize: Decimal; var ShouldProcessLastProdOrderCapNeed: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateLoadForwardOnAfterScheduleProdOrderRoutingLineManually(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; RoutingTimeType: Enum "Routing Time Type"; var RunStartingDateTime: DateTime; var ProdStartingDate: Date; var ProdStartingTime: Time; var RemainNeedQtyBase: Decimal)
begin
end;
[IntegrationEvent(false, false)]
procedure OnBeforeCalculateRoutingLine(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; Direction: Option Forward,Backward; CalcStartEndDate: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLoadCapForwardOnScheduleManuallyOnBeforeCheckDateTimes(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; CapType: Enum "Capacity Type"; CapNo: Code[20]; TimeType: Enum "Routing Time Type"; var ProdStartingDate: Date; var ProdStartingTime: Time; RemainNeedQty: Decimal; var RunStartingDateTime: DateTime; var RunEndingDateTime: DateTime)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateTimesBack(CalendarEntry: Record "Calendar Entry"; ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var AvailTime: Decimal; var AvailCap: Decimal; var TimetoProgram: Decimal; var StartTime: Time; EndTime: Time; ConCurrCap: Decimal; Workcenter: Record "Work Center"; var RemainNeedQty: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateTimesForward(CalendarEntry: Record "Calendar Entry"; ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var AvailTime: Decimal; var AvailCap: Decimal; var TimetoProgram: Decimal; var StartTime: Time; EndTime: Time; ConCurrCap: Decimal; Workcenter: Record "Work Center"; var RemainNeedQty: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnReturnNextCalendarEntryOnAfterSetCalendarEntryDateFilter(var CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnFinitelyLoadCapBackOnAfterSetCalendarEntryFilters(var CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLoadCapBackOnAfterSetCalendarEntryFilters(var CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateRoutingLineOnAfterCalcMaxLotSize(ProdOrderQty: Decimal; var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; TotalScrap: Decimal; var MaxLotSize: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInitProdOrderCapNeed(ProductionOrder: Record "Production Order"; var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ProdOrderCapacityNeed: Record "Prod. Order Capacity Need"; RoutingTimeType: Enum "Routing Time Type"; NeedDate: Date; StartingTime: Time; EndingTime: Time; var NeedQty: Decimal; LotSize: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLoadCapBackOnAfterCreateLoadBack(CapacityType: Enum "Capacity Type"; CapacityNo: Code[20]; RoutingTimeType: Enum "Routing Time Type"; Write: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcRoutingLineForwardOnBeforeLoadCapForward(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; ProdOrderRoutingLine3: Record "Prod. Order Routing Line");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcRoutingLineForwardOnBeforeLoadCapForward2(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; ProdOrderRoutingLine3: Record "Prod. Order Routing Line");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLoadCapForwardOnBeforeCreateLoadForward(var RemainNeedQty: Decimal; CapacityType: Enum "Capacity Type"; CapacityNo: Code[20]; RoutingTimeType: Enum "Routing Time Type"; Write: Boolean; LoadFactor: Decimal);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLoadCapForwardOnAfterCreateLoadForward(var RemainNeedQty: Decimal; CapacityType: Enum "Capacity Type"; CapacityNo: Code[20]; RoutingTimeType: Enum "Routing Time Type"; Write: Boolean; LoadFactor: Decimal);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetSendAheadEndingTimeOnAfterCalcTimes(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var SetupTime: Decimal; var RunTime: Decimal; var WaitTime: Decimal; var MoveTime: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnGetSendAheadEndingTimeOnAfterCalcSetupAndRunTime(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var SetupTime: Decimal; var RunTime: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcRoutingLineBackOnAfterCalcRemainNeedQty(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var RemainNeedQty: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnFinitelyLoadCapBackOnAfterCalcSetupTime(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var SetupTime: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnFinitelyLoadCapBackOnAfterCalcAvailTimeFromLastProdOrderCapNeed(var AvailTime: Decimal; EndTime: Time; AvailCap: Decimal; LastProdOrderCapacityNeed: Record "Prod. Order Capacity Need")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnFinitelyLoadCapBackOnAfterCalcAvailTimeFromCalendarEntry(var AvailTime: Decimal; EndTime: Time; AvailCap: Decimal; CalendarEntry: Record "Calendar Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcRoutingLineForwardOnAfterCalcRemainNeedQty(ProdOrderRoutingLine: Record "Prod. Order Routing Line"; WorkCenter: Record "Work Center"; var RemainNeedQty: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcAvailQtyBase(CalendarEntry: Record "Calendar Entry"; RoutingTimeType: Enum "Routing Time Type"; var AvQtyBase: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateLoadBack(var RemainNeedQty: Decimal; CalendarEntry: Record "Calendar Entry"; var TimeType: Enum "Routing Time Type"; var Write: Boolean; FirstEntry: Boolean; WaitTimeOnly: Boolean; var CurrentWorkCenterNo: Code[20]; ProdStartingDate: Date; ProdStartingTime: Time; ProdEndingDate: Date; ProdEndingTime: Time; var IsHandled: Boolean; var RemainNeedQtyBase: Decimal; var CurrentTimeFactor: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateLoadForward(var RemainNeedQty: Decimal; CalendarEntry: Record "Calendar Entry"; var TimeType: Enum "Routing Time Type"; var Write: Boolean; var LoadFactor: Decimal; FirstEntry: Boolean; WaitTimeOnly: Boolean; var CurrentWorkCenterNo: Code[20]; ProdStartingDate: Date; ProdStartingTime: Time; ProdEndingDate: Date; ProdEndingTime: Time; var IsHandled: Boolean; var RemainNeedQtyBase: Decimal; var CurrentTimeFactor: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitProdOrderCapNeedOnBeforeUpdateAllocatedTimeAndExpectedCapacityNeed(var ProdOrderCapacityNeed: Record "Prod. Order Capacity Need"; var ShouldUpdateAllocatedTimeAndExpectedCapacityNeed: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdateTimesBackOnBeforeUpdateAvailCap(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ShouldUpdateAvailCap: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdateTimesForwardOnBeforeUpdateAvailCap(var ProdOrderRoutingLine: Record "Prod. Order Routing Line"; var ShouldUpdateAvailCap: Boolean)
begin
end;
}