Codeunit 99000774 Calculate Routing Line
src/Layers/W1/BaseApp/Manufacturing/Routing/CalculateRoutingLine.Codeunit.al2,605 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;}