Codeunit 99000810 Calculate Planning Route Line
src/Layers/W1/BaseApp/Manufacturing/Planning/CalculatePlanningRouteLine.Codeunit.al1,723 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.Planning;using Microsoft.Inventory.Item;using Microsoft.Inventory.Planning;using Microsoft.Inventory.Requisition;using Microsoft.Manufacturing.Capacity;using Microsoft.Manufacturing.Document;using Microsoft.Manufacturing.MachineCenter;using Microsoft.Manufacturing.Routing;using Microsoft.Manufacturing.Setup;using Microsoft.Manufacturing.WorkCenter;codeunit 99000810 "Calculate Planning Route Line"{ Permissions = TableData Item = r, TableData "Prod. Order Capacity Need" = rimd, TableData "Work Center" = r, TableData "Calendar Entry" = r, TableData "Machine Center" = r, TableData "Manufacturing Setup" = rm, TableData "Planning Routing Line" = rimd, TableData "Capacity Constrained Resource" = r; trigger OnRun() begin end; var MfgSetup: Record "Manufacturing Setup"; Item: Record Item; WorkCenter: Record "Work Center"; WorkCenter2: Record "Work Center"; MachineCenter: Record "Machine Center"; ReqLine: Record "Requisition Line"; PlanningRoutingLine: Record "Planning Routing Line"; CalendarEntry: Record "Calendar Entry"; ProdOrderCapNeed: Record "Prod. Order Capacity Need"; ProdOrderCapNeed2: Record "Prod. Order Capacity Need"; TempPlanningErrorLog: Record "Planning Error Log" temporary; TempConstrainedCapacity: Record "Capacity Constrained Resource" temporary; TempConstrainedCapacityEmpty: Record "Capacity Constrained Resource" temporary; CalendarMgt: Codeunit "Shop Calendar Management"; CalculateRoutingLine: Codeunit "Calculate Routing Line"; RoutingTimeType: Enum "Routing Time Type"; NextCapNeedLineNo: Integer; ProdStartingTime: Time; ProdEndingTime: Time; ProdStartingDate: Date; ProdEndingDate: Date; MaxLotSize: Decimal; TotalLotSize: Decimal; LotSize: Decimal; ConCurrCap: Decimal; RemainNeedQty: Decimal; FirstInBatch: Boolean; FirstEntry: Boolean; UpdateDates: Boolean; WaitTimeOnly: Boolean; PlanningResiliency: Boolean; 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';#pragma warning restore AA0074 local procedure TestForError(DirectionTxt: Text[30]; BefAfterTxt: Text[30]; Date: Date) var WorkCenter: Record "Work Center"; MachCenter: Record "Machine Center"; begin if RemainNeedQty <> 0 then begin if PlanningResiliency then case PlanningRoutingLine.Type of PlanningRoutingLine.Type::"Work Center": begin WorkCenter.Get(PlanningRoutingLine."No."); TempPlanningErrorLog.SetError( StrSubstNo( Text000, DirectionTxt, BefAfterTxt, Date, PlanningRoutingLine.Type, PlanningRoutingLine."No."), DATABASE::"Work Center", WorkCenter.GetPosition()); end; PlanningRoutingLine.Type::"Machine Center": begin MachCenter.Get(PlanningRoutingLine."No."); TempPlanningErrorLog.SetError( StrSubstNo( Text000, DirectionTxt, BefAfterTxt, Date, PlanningRoutingLine.Type, PlanningRoutingLine."No."), DATABASE::"Machine Center", MachCenter.GetPosition()); end; end; Error( Text000, DirectionTxt, BefAfterTxt, Date, PlanningRoutingLine.Type, PlanningRoutingLine."No."); end; end; local procedure CreatePlanningCapNeed(NeedDate: Date; StartingTime: Time; EndingTime: Time; NeedQty: Decimal; TimeType: Enum "Routing Time Type"; Direction: Option Forward,Backward) begin OnBeforeCreatePlanningCapNeed(PlanningRoutingLine, TimeType, NeedQty); ProdOrderCapNeed.Init(); ProdOrderCapNeed."Worksheet Template Name" := ReqLine."Worksheet Template Name"; ProdOrderCapNeed."Worksheet Batch Name" := ReqLine."Journal Batch Name"; ProdOrderCapNeed."Worksheet Line No." := ReqLine."Line No."; ProdOrderCapNeed.Type := PlanningRoutingLine.Type; ProdOrderCapNeed."No." := PlanningRoutingLine."No."; ProdOrderCapNeed."Work Center No." := PlanningRoutingLine."Work Center No."; ProdOrderCapNeed."Operation No." := PlanningRoutingLine."Operation No."; ProdOrderCapNeed."Work Center Group Code" := PlanningRoutingLine."Work Center Group Code"; ProdOrderCapNeed.Status := ReqLine."Ref. Order Status"; ProdOrderCapNeed."Prod. Order No." := ReqLine."Ref. Order No."; ProdOrderCapNeed."Routing No." := ReqLine."Routing No."; ProdOrderCapNeed."Routing Reference No." := ReqLine."Line No."; ProdOrderCapNeed.Active := true; ProdOrderCapNeed."Requested Only" := true; ProdOrderCapNeed."Line No." := NextCapNeedLineNo; ProdOrderCapNeed.Date := NeedDate; ProdOrderCapNeed."Starting Time" := StartingTime; ProdOrderCapNeed."Ending Time" := EndingTime; ProdOrderCapNeed."Allocated Time" := NeedQty; ProdOrderCapNeed."Needed Time" := NeedQty; ProdOrderCapNeed."Needed Time (ms)" := NeedQty * CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"); PlanningRoutingLine."Expected Capacity Need" := PlanningRoutingLine."Expected Capacity Need" + ProdOrderCapNeed."Needed Time (ms)"; ProdOrderCapNeed.Efficiency := CalendarEntry.Efficiency; ProdOrderCapNeed."Concurrent Capacities" := ConCurrCap; if PlanningRoutingLine."Unit Cost Calculation" = PlanningRoutingLine."Unit Cost Calculation"::Time then begin if (TimeType = TimeType::"Run Time") or MfgSetup."Cost Incl. Setup" then begin PlanningRoutingLine."Expected Operation Cost Amt." := PlanningRoutingLine."Expected Operation Cost Amt." + NeedQty * PlanningRoutingLine."Unit Cost per"; PlanningRoutingLine."Expected Capacity Ovhd. Cost" := PlanningRoutingLine."Expected Capacity Ovhd. Cost" + NeedQty * (PlanningRoutingLine."Direct Unit Cost" * PlanningRoutingLine."Indirect Cost %" / 100 + PlanningRoutingLine."Overhead Rate"); end; end else begin PlanningRoutingLine."Expected Operation Cost Amt." := PlanningRoutingLine."Input Quantity" * PlanningRoutingLine."Unit Cost per"; PlanningRoutingLine."Expected Capacity Ovhd. Cost" := PlanningRoutingLine."Input Quantity" * (PlanningRoutingLine."Direct Unit Cost" * PlanningRoutingLine."Indirect Cost %" / 100 + PlanningRoutingLine."Overhead Rate"); end; OnCreatePlanningCapNeedOnAfterCalulateExpectedUnitCost(PlanningRoutingLine, TimeType, PlanningRoutingLine."Input Quantity"); 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(); OnCreatePlanningCapNeedOnBeforeInsertProdOrderCapNeed(ProdOrderCapNeed, ReqLine, PlanningRoutingLine); ProdOrderCapNeed.Insert(); NextCapNeedLineNo := NextCapNeedLineNo + 1; OnAfterCreatePlanningCapNeed( NextCapNeedLineNo, PlanningRoutingLine, ReqLine, NeedDate, StartingTime, EndingTime, TimeType.AsInteger(), NeedQty, ConCurrCap, CalendarEntry, LotSize, RemainNeedQty, FirstInBatch, Direction); 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 xConCurrCap := 1; if (RemainNeedQty = 0) and ((not FirstEntry) or (not Write) or WaitTimeOnly) then exit; if CalendarEntry.Find('+') then begin IsHandled := false; OnCreateLoadBackOnBeforeFirstCalculate(PlanningRoutingLine, IsHandled); if not IsHandled then if (TimeType = TimeType::"Wait Time") and (CalendarEntry.Date < ProdEndingDate) then begin CalendarEntry.Date := ProdEndingDate; CreateCalendarEntry(CalendarEntry); end; GetCurrentWorkCenterTimeFactorAndRounding(WorkCenter); RemainNeedQtyBase := Round(RemainNeedQty * CurrentTimeFactor, CurrentRounding); repeat OldCalendarEntry := CalendarEntry; ConCurrCap := PlanningRoutingLine."Concurrent Capacities"; if (ConCurrCap = 0) or (CalendarEntry.Capacity < ConCurrCap) then ConCurrCap := CalendarEntry.Capacity; if TimeType <> TimeType::"Run Time" then RemainNeedQtyBase := RemainNeedQtyBase * ConCurrCap / xConCurrCap; xConCurrCap := ConCurrCap; AvQtyBase := CalculateRoutingLine.CalcAvailQtyBase( CalendarEntry, ProdEndingDate, ProdEndingTime, TimeType, ConCurrCap, false, CurrentTimeFactor, CurrentRounding); if AvQtyBase > RemainNeedQtyBase then AvQtyBase := RemainNeedQtyBase; if TimeType in [TimeType::"Setup Time", TimeType::"Run Time"] then RelevantEfficiency := CalendarEntry.Efficiency else RelevantEfficiency := 100; StartingTime := CalendarMgt.CalcTimeSubtract( CalendarEntry."Ending Time", Round(AvQtyBase * 100 / RelevantEfficiency / ConCurrCap, 1, '>')); RemainNeedQtyBase := RemainNeedQtyBase - AvQtyBase; OnCreatingLoadBackOnAfterUpdateRemainNeedQtyBase(PlanningRoutingLine, CalendarEntry, StartingTime); if Write then begin RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding); CreatePlanningCapNeed( CalendarEntry.Date, StartingTime, CalendarEntry."Ending Time", Round(AvQtyBase / CurrentTimeFactor, CurrentRounding), TimeType, 1); FirstInBatch := false; FirstEntry := false; end; if (CalendarEntry."Capacity (Effective)" <> 0) or (TimeType = TimeType::"Wait Time") then UpdateEndingDateAndTime(CalendarEntry.Date, CalendarEntry."Ending Time"); ProdEndingTime := StartingTime; ProdEndingDate := CalendarEntry.Date; PlanningRoutingLine."Starting Time" := StartingTime; PlanningRoutingLine."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; CalculateRoutingLine.ReturnNextCalendarEntry(CalendarEntry, OldCalendarEntry, 0); end else begin CalendarEntry := OldCalendarEntry; StopLoop := CalendarEntry.Next(-1) = 0; end; until StopLoop; RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding); UpdateEndingDateAndTime(ProdEndingDate, ProdEndingTime); end; end; local procedure CreateLoadForward(TimeType: Enum "Routing Time Type"; Write: Boolean) var OldCalendarEntry: Record "Calendar Entry"; AvQtyBase: Decimal; RelevantEfficiency: Decimal; xConCurrCap: Decimal; RemainNeedQtyBase: Decimal; EndingTime: Time; StopLoop: Boolean; begin 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; GetCurrentWorkCenterTimeFactorAndRounding(WorkCenter); RemainNeedQtyBase := Round(RemainNeedQty * CurrentTimeFactor, CurrentRounding); repeat OldCalendarEntry := CalendarEntry; ConCurrCap := PlanningRoutingLine."Concurrent Capacities"; if (ConCurrCap = 0) or (CalendarEntry.Capacity < ConCurrCap) then ConCurrCap := CalendarEntry.Capacity; if TimeType <> TimeType::"Run Time" then RemainNeedQtyBase := RemainNeedQtyBase * ConCurrCap / xConCurrCap; xConCurrCap := ConCurrCap; AvQtyBase := CalculateRoutingLine.CalcAvailQtyBase( CalendarEntry, ProdStartingDate, ProdStartingTime, TimeType, ConCurrCap, true, CurrentTimeFactor, CurrentRounding); if AvQtyBase > RemainNeedQtyBase then AvQtyBase := RemainNeedQtyBase; if TimeType in [TimeType::"Setup Time", TimeType::"Run Time"] then RelevantEfficiency := CalendarEntry.Efficiency else RelevantEfficiency := 100; EndingTime := CalendarEntry."Starting Time" + Round(AvQtyBase * 100 / RelevantEfficiency / ConCurrCap, 1, '>'); if AvQtyBase >= 0 then RemainNeedQtyBase := RemainNeedQtyBase - AvQtyBase; OnCreatingLoadForwardOnAfterUpdateRemainNeedQtyBase(PlanningRoutingLine, CalendarEntry, EndingTime); if Write then begin RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding); CreatePlanningCapNeed( CalendarEntry.Date, CalendarEntry."Starting Time", EndingTime, Round(AvQtyBase / CurrentTimeFactor, CurrentRounding), TimeType, 1); FirstInBatch := false; FirstEntry := false; end; if (CalendarEntry."Capacity (Effective)" <> 0) or (TimeType = TimeType::"Wait Time") then UpdateStartingDateAndTime(CalendarEntry.Date, CalendarEntry."Starting Time"); 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; PlanningRoutingLine."Ending Time" := EndingTime; PlanningRoutingLine."Ending Date" := CalendarEntry.Date; if (RemainNeedQtyBase = 0) and ((not FirstEntry) or (not Write)) and (AvQtyBase >= 0) then StopLoop := true else if TimeType = TimeType::"Wait Time" then begin StopLoop := false; CalculateRoutingLine.ReturnNextCalendarEntry(CalendarEntry, OldCalendarEntry, 1); end else begin CalendarEntry := OldCalendarEntry; StopLoop := CalendarEntry.Next() = 0; end; until StopLoop; RemainNeedQty := Round(RemainNeedQtyBase / CurrentTimeFactor, CurrentRounding); end; end; local procedure LoadCapBack(CapType: Enum "Capacity Type"; CapNo: Code[20]; TimeType: Enum "Routing Time Type"; Write: Boolean) var IsHandled: Boolean; begin IsHandled := false; OnBeforeLoadCapBack(PlanningRoutingLine, TimeType, ProdStartingDate, ProdStartingTime, IsHandled); if IsHandled then exit; PlanningRoutingLine."Starting Date" := ProdEndingDate; PlanningRoutingLine."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)); CreateLoadBack(TimeType, Write); if RemainNeedQty = 0 then exit; TestForError(Text001, Text002, PlanningRoutingLine."Starting Date"); end; procedure LoadCapForward(CapType: Enum "Capacity Type"; CapNo: Code[20]; TimeType: Enum "Routing Time Type"; Write: Boolean) var IsHandled: Boolean; begin IsHandled := false; OnBeforeLoadCapForward(PlanningRoutingLine, TimeType, ProdStartingDate, ProdStartingTime, IsHandled); if IsHandled then exit; PlanningRoutingLine."Ending Date" := ProdStartingDate; PlanningRoutingLine."Ending Time" := ProdStartingTime; CalendarEntry.SetCapacityFilters(CapType, CapNo); CalendarEntry.SetFilter("Starting Date-Time", '>=%1', CreateDateTime(ProdStartingDate - 1, ProdStartingTime)); CalendarEntry.SetFilter("Ending Date-Time", '>=%1', CreateDateTime(ProdStartingDate, ProdStartingTime)); CreateLoadForward(TimeType, Write); if RemainNeedQty = 0 then exit; TestForError(Text003, Text004, PlanningRoutingLine."Ending Date"); end; local procedure CalcMoveTimeBack() var IsHandled: Boolean; begin UpdateDates := true; IsHandled := false; OnBeforeCalcMoveTimeBack( PlanningRoutingLine, WorkCenter, ProdEndingDate, ProdEndingTime, ProdStartingDate, ProdStartingTime, UpdateDates, IsHandled); if IsHandled then exit; RemainNeedQty := Round( PlanningRoutingLine."Move Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Move Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Move Time", false); end; local procedure CalcWaitTimeBack() var IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcWaitTimeBack( PlanningRoutingLine, WorkCenter, ProdEndingDate, ProdEndingTime, ProdStartingDate, ProdStartingTime, UpdateDates, IsHandled); if IsHandled then exit; RemainNeedQty := Round( PlanningRoutingLine."Wait Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Wait Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Wait Time", false); end; local procedure GetSendAheadStartingTime(var PlanningRoutingLineNext: Record "Planning Routing Line"; var SendAheadLotSize: Decimal): Boolean var xPlanningRoutingLine: Record "Planning Routing Line"; RunTime: Decimal; WaitTime: Decimal; MoveTime: Decimal; ResidualLotSize: Decimal; ResidualProdStartDateTime: DateTime; begin ProdStartingDate := PlanningRoutingLineNext."Starting Date"; ProdStartingTime := PlanningRoutingLineNext."Starting Time"; SendAheadLotSize := MaxLotSize; if TotalLotSize = MaxLotSize then exit(true); if (PlanningRoutingLine."Send-Ahead Quantity" = 0) or (PlanningRoutingLine."Send-Ahead Quantity" >= MaxLotSize) then begin TotalLotSize := SendAheadLotSize; exit(false); end; SendAheadLotSize := PlanningRoutingLine."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( "Worksheet Template Name", "Worksheet Batch Name", "Worksheet Line No.", "Operation No.", Date, "Starting Time"); ProdOrderCapNeed2.SetRange("Worksheet Template Name", PlanningRoutingLine."Worksheet Template Name"); ProdOrderCapNeed2.SetRange("Worksheet Batch Name", PlanningRoutingLine."Worksheet Batch Name"); ProdOrderCapNeed2.SetRange("Worksheet Line No.", PlanningRoutingLine."Worksheet Line No."); ProdOrderCapNeed2.SetRange("Operation No.", PlanningRoutingLine."Operation No."); if not ProdOrderCapNeed2.IsEmpty() 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(PlanningRoutingLineNext."Work Center No."); RunTime := Round( (ResidualLotSize * PlanningRoutingLineNext.RunTimePer()) * CalendarMgt.TimeFactor(PlanningRoutingLineNext."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); WaitTime := Round( PlanningRoutingLineNext."Wait Time" * CalendarMgt.TimeFactor(PlanningRoutingLineNext."Wait Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); MoveTime := Round( PlanningRoutingLineNext."Move Time" * CalendarMgt.TimeFactor(PlanningRoutingLineNext."Move Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); xPlanningRoutingLine := PlanningRoutingLine; PlanningRoutingLine := PlanningRoutingLineNext; ProdEndingDate := PlanningRoutingLine."Ending Date"; ProdEndingTime := PlanningRoutingLine."Ending Time"; RemainNeedQty := MoveTime; LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Move Time", false); RemainNeedQty := WaitTime; LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Wait Time", false); RemainNeedQty := RunTime; LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Run Time", false); PlanningRoutingLine := xPlanningRoutingLine; PlanningRoutingLine."Starting Date" := ProdEndingDate; PlanningRoutingLine."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(PlanningRoutingLine."Work Center No."); RunTime := Round( (MaxLotSize - SendAheadLotSize) * PlanningRoutingLine.RunTimePer() * CalendarMgt.TimeFactor(PlanningRoutingLine."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); WaitTime := Round( PlanningRoutingLine."Wait Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Wait Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); MoveTime := Round( PlanningRoutingLine."Move Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Move Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); RemainNeedQty := RunTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Run Time", false); RemainNeedQty := WaitTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Wait Time", false); RemainNeedQty := MoveTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Move Time", false); // last lot must be finished by current Work Center, otherwise we recalculate Ending Date/Time of current line PlanningRoutingLine.UpdateDatetime(); if PlanningRoutingLine."Ending Date-Time" > ResidualProdStartDateTime then begin PlanningRoutingLine."Ending Date" := DT2Date(ResidualProdStartDateTime); PlanningRoutingLine."Ending Time" := DT2Time(ResidualProdStartDateTime); FilterCalendarEntryBeforeOrOnDateTime(PlanningRoutingLine.Type, PlanningRoutingLine."No.", PlanningRoutingLine."Ending Date", PlanningRoutingLine."Ending Time"); if CalendarEntry.FindLast() then if PlanningRoutingLine."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 PlanningRoutingLine."Ending Time" := CalendarEntry."Ending Time"; ProdStartingDate := PlanningRoutingLine."Ending Date"; ProdStartingTime := PlanningRoutingLine."Ending Time"; end; exit(false); end; procedure CalcRoutingLineBack(CalcStartEndDate: Boolean) var WorkCenter2: Record "Work Center"; PlanningRoutingLine2: Record "Planning Routing Line"; PlanningRoutingLine3: Record "Planning Routing Line"; ConstrainedCapacity: Record "Capacity Constrained Resource"; ParentWorkCenter: Record "Capacity Constrained Resource"; TempWorkCenter: Record "Work Center"; TempPlanRoutingLine: Record "Planning Routing Line" temporary; ResourceIsConstrained: Boolean; ParentIsConstrained: Boolean; ShouldCalcNextOperation: Boolean; SendAheadLotSize: Decimal; begin OnBeforeCalcRoutingLineBack(PlanningRoutingLine, CalcStartEndDate); CalendarEntry.SetRange(Date, 0D, PlanningRoutingLine."Ending Date"); ProdEndingTime := PlanningRoutingLine."Ending Time"; ProdEndingDate := PlanningRoutingLine."Ending Date"; ProdStartingTime := PlanningRoutingLine."Ending Time"; ProdStartingDate := PlanningRoutingLine."Ending Date"; FirstEntry := true; ShouldCalcNextOperation := (PlanningRoutingLine."Next Operation No." <> '') and CalcStartEndDate; OnCalcRoutingLineBackOnAfterCalcShouldCalcNextOperation(PlanningRoutingLine, MaxLotSize, TotalLotSize, SendAheadLotSize, ShouldCalcNextOperation); if ShouldCalcNextOperation then begin Clear(PlanningRoutingLine3); TempPlanRoutingLine.Reset(); TempPlanRoutingLine.DeleteAll(); PlanningRoutingLine2.SetRange("Worksheet Template Name", PlanningRoutingLine."Worksheet Template Name"); PlanningRoutingLine2.SetRange("Worksheet Batch Name", PlanningRoutingLine."Worksheet Batch Name"); PlanningRoutingLine2.SetRange("Worksheet Line No.", PlanningRoutingLine."Worksheet Line No."); PlanningRoutingLine2.SetFilter("Operation No.", PlanningRoutingLine."Next Operation No."); if PlanningRoutingLine2.Find('-') then repeat TotalLotSize := 0; GetSendAheadStartingTime(PlanningRoutingLine2, SendAheadLotSize); TempPlanRoutingLine.Copy(PlanningRoutingLine2); TempPlanRoutingLine.Insert(); if ProdEndingDate > ProdStartingDate then begin ProdEndingDate := ProdStartingDate; ProdEndingTime := ProdStartingTime; PlanningRoutingLine3 := PlanningRoutingLine2; end else if (ProdEndingDate = ProdStartingDate) and (ProdEndingTime > ProdStartingTime) then begin ProdEndingTime := ProdStartingTime; PlanningRoutingLine3 := PlanningRoutingLine2; end; until PlanningRoutingLine2.Next() = 0; if PlanningRoutingLine3."Worksheet Template Name" <> '' then begin WorkCenter2.Get(PlanningRoutingLine3."Work Center No."); PlanningRoutingLine3."Critical Path" := true; PlanningRoutingLine3.UpdateDatetime(); PlanningRoutingLine3.Modify(); if PlanningRoutingLine3.Type = PlanningRoutingLine3.Type::"Machine Center" then begin MachineCenter.Get(PlanningRoutingLine3."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"); TempWorkCenter := WorkCenter; WorkCenter."Unit of Measure Code" := WorkCenter2."Unit of Measure Code"; WorkCenter."Calendar Rounding Precision" := WorkCenter2."Calendar Rounding Precision"; LoadCapBack(PlanningRoutingLine2.Type, PlanningRoutingLine2."No.", RoutingTimeType::"Queue Time", false); WorkCenter."Unit of Measure Code" := TempWorkCenter."Unit of Measure Code"; WorkCenter."Calendar Rounding Precision" := TempWorkCenter."Calendar Rounding Precision"; end; end else SetLotSizesToMax(SendAheadLotSize, TotalLotSize); UpdateDates := true; CalcMoveTimeBack(); CalcWaitTimeBack(); repeat LotSize := SendAheadLotSize; RemainNeedQty := LotSize * PlanningRoutingLine.RunTimePer(); OnCalculateRoutingLineBackOnAfterCalcRemainNeedQtyForLotSize(PlanningRoutingLine, RemainNeedQty); RemainNeedQty := Round( RemainNeedQty * CalendarMgt.TimeFactor(PlanningRoutingLine."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); ResourceIsConstrained := GetConstrainedCapacity(PlanningRoutingLine.Type, PlanningRoutingLine."No.", ConstrainedCapacity); ParentIsConstrained := GetConstrainedCapacity(PlanningRoutingLine.Type::"Work Center", PlanningRoutingLine."Work Center No.", ParentWorkCenter); if ResourceIsConstrained or ParentIsConstrained then FinitelyLoadCapBack(RoutingTimeType::"Run Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained) else LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Run Time", true); ProdEndingDate := PlanningRoutingLine."Starting Date"; ProdEndingTime := PlanningRoutingLine."Starting Time"; until FindSendAheadStartingTime(TempPlanRoutingLine, SendAheadLotSize); ProdEndingDate := PlanningRoutingLine."Starting Date"; ProdEndingTime := PlanningRoutingLine."Starting Time"; RemainNeedQty := GetSetupTimeBaseUOM(); ResourceIsConstrained := GetConstrainedCapacity(PlanningRoutingLine.Type, PlanningRoutingLine."No.", ConstrainedCapacity); ParentIsConstrained := GetConstrainedCapacity(PlanningRoutingLine.Type::"Work Center", PlanningRoutingLine."Work Center No.", ParentWorkCenter); if ResourceIsConstrained or ParentIsConstrained then FinitelyLoadCapBack(RoutingTimeType::"Setup Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained) else LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Setup Time", true); PlanningRoutingLine."Starting Date" := ProdEndingDate; PlanningRoutingLine."Starting Time" := ProdEndingTime; if PlanningRoutingLine."Ending Date" = CalendarMgt.GetMaxDate() then begin PlanningRoutingLine."Ending Date" := PlanningRoutingLine."Starting Date"; PlanningRoutingLine."Ending Time" := PlanningRoutingLine."Starting Time"; end; PlanningRoutingLine.UpdateDatetime(); PlanningRoutingLine.Modify(); OnAfterCalcRoutingLineBack(PlanningRoutingLine, PlanningResiliency); end; local procedure SetLotSizesToMax(var SendAheadLotSize: Decimal; var TotalLotSize: Decimal) var IsHandled: Boolean; begin IsHandled := false; OnBeforeSetLotSizesToMax(SendAheadLotSize, TotalLotSize, MaxLotSize, PlanningRoutingLine, IsHandled); if IsHandled then exit; TotalLotSize := MaxLotSize; SendAheadLotSize := MaxLotSize; end; local procedure GetConstrainedCapacity(CapType: Enum "Capacity Type"; CapNo: Code[20]; var ConstrainedCapacity: Record "Capacity Constrained Resource") Result: Boolean var IsHandled: Boolean; begin IsHandled := false; OnBeforeGetConstrainedCapacity(CapType, CapNo, ConstrainedCapacity, Result, IsHandled); if IsHandled then exit(Result); if TempConstrainedCapacity.Get(CapType, CapNo) then begin ConstrainedCapacity := TempConstrainedCapacity; exit(true); end; if TempConstrainedCapacityEmpty.Get(CapType, CapNo) then exit(false); if ConstrainedCapacity.Get(CapType, CapNo) then begin TempConstrainedCapacity := ConstrainedCapacity; TempConstrainedCapacity.Insert(); exit(true); end; TempConstrainedCapacityEmpty.Init(); TempConstrainedCapacityEmpty."Capacity Type" := CapType; TempConstrainedCapacityEmpty."Capacity No." := CapNo; TempConstrainedCapacityEmpty.Insert(); exit(false); end; local procedure GetSendAheadEndingTime(var PlanningRoutingLinePrev: Record "Planning Routing Line"; var SendAheadLotSize: Decimal): Boolean var xPlanningRoutingLine: Record "Planning Routing Line"; SetupTime: Decimal; RunTime: Decimal; WaitTime: Decimal; MoveTime: Decimal; ResidualLotSize: Decimal; ResidualProdStartDateTime: DateTime; begin ProdEndingTime := PlanningRoutingLinePrev."Ending Time"; ProdEndingDate := PlanningRoutingLinePrev."Ending Date"; SendAheadLotSize := MaxLotSize; if TotalLotSize = MaxLotSize then exit(true); if (PlanningRoutingLinePrev."Send-Ahead Quantity" = 0) or (PlanningRoutingLinePrev."Send-Ahead Quantity" >= MaxLotSize) then begin TotalLotSize := SendAheadLotSize; exit(false); end; SendAheadLotSize := PlanningRoutingLinePrev."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( "Worksheet Template Name", "Worksheet Batch Name", "Worksheet Line No.", "Operation No.", Date, "Starting Time"); ProdOrderCapNeed2.SetRange("Worksheet Template Name", PlanningRoutingLine."Worksheet Template Name"); ProdOrderCapNeed2.SetRange("Worksheet Batch Name", PlanningRoutingLine."Worksheet Batch Name"); ProdOrderCapNeed2.SetRange("Worksheet Line No.", PlanningRoutingLine."Worksheet Line No."); ProdOrderCapNeed2.SetRange("Operation No.", PlanningRoutingLine."Operation No."); if not ProdOrderCapNeed2.IsEmpty() 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(PlanningRoutingLinePrev."Work Center No."); SetupTime := Round( PlanningRoutingLinePrev."Setup Time" * CalendarMgt.TimeFactor(PlanningRoutingLinePrev."Setup Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); RunTime := Round( SendAheadLotSize * PlanningRoutingLinePrev.RunTimePer() * CalendarMgt.TimeFactor(PlanningRoutingLinePrev."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); WaitTime := Round( PlanningRoutingLinePrev."Wait Time" * CalendarMgt.TimeFactor(PlanningRoutingLinePrev."Wait Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); MoveTime := Round( PlanningRoutingLinePrev."Move Time" * CalendarMgt.TimeFactor(PlanningRoutingLinePrev."Move Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); xPlanningRoutingLine := PlanningRoutingLine; PlanningRoutingLine := PlanningRoutingLinePrev; ProdStartingDate := PlanningRoutingLine."Starting Date"; ProdStartingTime := PlanningRoutingLine."Starting Time"; RemainNeedQty := SetupTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Setup Time", false); RemainNeedQty := RunTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Run Time", false); RemainNeedQty := WaitTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Wait Time", false); RemainNeedQty := MoveTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Move Time", false); PlanningRoutingLine := xPlanningRoutingLine; PlanningRoutingLine."Starting Date" := ProdStartingDate; PlanningRoutingLine."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(PlanningRoutingLine."Work Center No."); SetupTime := Round( PlanningRoutingLine."Setup Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); RunTime := Round( (MaxLotSize - ResidualLotSize) * PlanningRoutingLine.RunTimePer() * CalendarMgt.TimeFactor(PlanningRoutingLine."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); RemainNeedQty := SetupTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Setup Time", false); RemainNeedQty := RunTime; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."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 PlanningRoutingLinePrev.UpdateDatetime(); if PlanningRoutingLinePrev."Ending Date-Time" > ResidualProdStartDateTime then begin ProdEndingDate := PlanningRoutingLinePrev."Ending Date"; ProdEndingTime := PlanningRoutingLinePrev."Ending Time"; RemainNeedQty := RunTime; LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Run Time", false); RemainNeedQty := SetupTime; LoadCapBack(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Setup Time", false); end; ProdStartingDate := PlanningRoutingLine."Starting Date"; ProdStartingTime := PlanningRoutingLine."Starting Time"; ProdEndingDate := PlanningRoutingLine."Starting Date"; ProdEndingTime := PlanningRoutingLine."Starting Time"; exit(false); end; procedure CalcRoutingLineForward(CalcStartEndDate: Boolean) var PlanningRoutingLine2: Record "Planning Routing Line"; PlanningRoutingLine3: Record "Planning Routing Line"; ConstrainedCapacity: Record "Capacity Constrained Resource"; ParentWorkCenter: Record "Capacity Constrained Resource"; TempPlanRoutingLine: Record "Planning Routing Line" temporary; ResourceIsConstrained: Boolean; ParentIsConstrained: Boolean; SendAheadLotSize: Decimal; InputQtyDiffTime: Decimal; begin OnBeforeCalcRoutingLineForward(PlanningRoutingLine, WorkCenter, SendAheadLotSize, MaxLotSize, TotalLotSize, RemainNeedQty, UpdateDates, FirstEntry, TempPlanRoutingLine); ProdStartingTime := PlanningRoutingLine."Starting Time"; ProdStartingDate := PlanningRoutingLine."Starting Date"; ProdEndingTime := PlanningRoutingLine."Starting Time"; ProdEndingDate := PlanningRoutingLine."Starting Date"; InputQtyDiffTime := 0; FirstEntry := true; if (PlanningRoutingLine."Previous Operation No." <> '') and CalcStartEndDate then begin Clear(PlanningRoutingLine3); TempPlanRoutingLine.Reset(); TempPlanRoutingLine.DeleteAll(); PlanningRoutingLine2.SetRange("Worksheet Template Name", PlanningRoutingLine."Worksheet Template Name"); PlanningRoutingLine2.SetRange("Worksheet Batch Name", PlanningRoutingLine."Worksheet Batch Name"); PlanningRoutingLine2.SetRange("Worksheet Line No.", PlanningRoutingLine."Worksheet Line No."); PlanningRoutingLine2.SetFilter("Operation No.", PlanningRoutingLine."Previous Operation No."); if PlanningRoutingLine2.Find('-') then repeat TotalLotSize := 0; GetSendAheadEndingTime(PlanningRoutingLine2, SendAheadLotSize); TempPlanRoutingLine.Copy(PlanningRoutingLine2); TempPlanRoutingLine.Insert(); if ProdStartingDate < ProdEndingDate then begin ProdStartingDate := ProdEndingDate; ProdStartingTime := ProdEndingTime; PlanningRoutingLine3 := PlanningRoutingLine2; end else if (ProdStartingDate = ProdEndingDate) and (ProdStartingTime < ProdEndingTime) then begin ProdStartingTime := ProdEndingTime; PlanningRoutingLine3 := PlanningRoutingLine2; end; if (PlanningRoutingLine2."Send-Ahead Quantity" > 0) and (PlanningRoutingLine2."Input Quantity" > PlanningRoutingLine."Input Quantity") then begin WorkCenter2.Get(PlanningRoutingLine2."Work Center No."); InputQtyDiffTime := (PlanningRoutingLine2."Input Quantity" - PlanningRoutingLine."Input Quantity") * PlanningRoutingLine2.RunTimePer(); InputQtyDiffTime := Round( InputQtyDiffTime * CalendarMgt.TimeFactor(PlanningRoutingLine2."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter2."Unit of Measure Code"), WorkCenter2."Calendar Rounding Precision"); end; until PlanningRoutingLine2.Next() = 0; if PlanningRoutingLine3."Worksheet Template Name" <> '' then begin PlanningRoutingLine3."Critical Path" := true; PlanningRoutingLine3.UpdateDatetime(); PlanningRoutingLine3.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; LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Queue Time", false); RemainNeedQty := GetSetupTimeBaseUOM(); UpdateDates := true; ResourceIsConstrained := GetConstrainedCapacity(PlanningRoutingLine.Type, PlanningRoutingLine."No.", ConstrainedCapacity); ParentIsConstrained := ParentWorkCenter.Get(PlanningRoutingLine.Type::"Work Center", PlanningRoutingLine."Work Center No."); if (RemainNeedQty > 0) and (ResourceIsConstrained or ParentIsConstrained) then FinitelyLoadCapForward(RoutingTimeType::"Setup Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained) else LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Setup Time", true); FirstInBatch := true; repeat if (InputQtyDiffTime > 0) and (TotalLotSize = MaxLotSize) then if ProdStartingDate < PlanningRoutingLine2."Ending Date" then begin ProdStartingDate := PlanningRoutingLine2."Ending Date"; ProdStartingTime := PlanningRoutingLine2."Ending Time"; end else if PlanningRoutingLine2."Ending Date" = ProdEndingDate then if PlanningRoutingLine2."Ending Time" > ProdStartingTime then ProdStartingTime := PlanningRoutingLine2."Ending Time"; LotSize := SendAheadLotSize; RemainNeedQty := LotSize * PlanningRoutingLine.RunTimePer(); OnCalculateRoutingLineForwardOnAfterCalcRemainNeedQtyForLotSize(PlanningRoutingLine, RemainNeedQty); RemainNeedQty := Round( RemainNeedQty * CalendarMgt.TimeFactor(PlanningRoutingLine."Run Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); ResourceIsConstrained := GetConstrainedCapacity(PlanningRoutingLine.Type, PlanningRoutingLine."No.", ConstrainedCapacity); ParentIsConstrained := ParentWorkCenter.Get(PlanningRoutingLine.Type::"Work Center", PlanningRoutingLine."Work Center No."); if (RemainNeedQty > 0) and (ResourceIsConstrained or ParentIsConstrained) then FinitelyLoadCapForward(RoutingTimeType::"Run Time", ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained) else LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Run Time", true); ProdStartingDate := PlanningRoutingLine."Ending Date"; ProdStartingTime := PlanningRoutingLine."Ending Time"; until FindSendAheadEndingTime(TempPlanRoutingLine, SendAheadLotSize); RemainNeedQty := Round( PlanningRoutingLine."Wait Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Wait Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Wait Time", false); RemainNeedQty := Round( PlanningRoutingLine."Move Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Move Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision"); LoadCapForward(PlanningRoutingLine.Type, PlanningRoutingLine."No.", RoutingTimeType::"Move Time", false); if PlanningRoutingLine."Starting Date" = 0D then begin PlanningRoutingLine."Starting Date" := PlanningRoutingLine."Ending Date"; PlanningRoutingLine."Starting Time" := PlanningRoutingLine."Ending Time"; end; PlanningRoutingLine.UpdateDatetime(); PlanningRoutingLine.Modify(); OnAfterCalcRoutingLineForward(PlanningRoutingLine, PlanningResiliency); end; procedure CalculateRouteLine(var PlanningRoutingLine2: Record "Planning Routing Line"; Direction: Option Forward,Backward; CalcStartEndDate: Boolean; ReqLine2: Record "Requisition Line") var ProdOrderCapNeed: Record "Prod. Order Capacity Need"; begin MfgSetup.Get(); PlanningRoutingLine := PlanningRoutingLine2; WaitTimeOnly := (PlanningRoutingLine."Setup Time" = 0) and (PlanningRoutingLine."Run Time" = 0) and (PlanningRoutingLine."Move Time" = 0); if PlanningRoutingLine."Ending Time" = 0T then PlanningRoutingLine."Ending Time" := 000000T; if PlanningRoutingLine."Starting Time" = 0T then PlanningRoutingLine."Starting Time" := 000000T; PlanningRoutingLine."Expected Operation Cost Amt." := 0; PlanningRoutingLine."Expected Capacity Ovhd. Cost" := 0; PlanningRoutingLine."Expected Capacity Need" := 0; PlanningRoutingLine.TestField("Work Center No."); WorkCenter.Get(PlanningRoutingLine."Work Center No."); if PlanningRoutingLine.Type = PlanningRoutingLine.Type::"Machine Center" then begin MachineCenter.Get(PlanningRoutingLine."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"); ReqLine := ReqLine2; ProdOrderCapNeed.SetCurrentKey(Status, "Prod. Order No.", Active); ProdOrderCapNeed.SetRange(Status, ReqLine."Ref. Order Status"); ProdOrderCapNeed.SetRange("Prod. Order No.", ReqLine."Ref. Order No."); ProdOrderCapNeed.SetRange(Active, true); ProdOrderCapNeed.SetRange("Requested Only", false); ProdOrderCapNeed.SetRange("Routing No.", ReqLine."Routing No."); ProdOrderCapNeed.ModifyAll(Active, false); PlanningRoutingLine."Expected Operation Cost Amt." := 0; PlanningRoutingLine."Expected Capacity Ovhd. Cost" := 0; ProdOrderCapNeed.Reset(); ProdOrderCapNeed.SetRange("Worksheet Template Name", PlanningRoutingLine."Worksheet Template Name"); ProdOrderCapNeed.SetRange("Worksheet Batch Name", PlanningRoutingLine."Worksheet Batch Name"); ProdOrderCapNeed.SetRange("Worksheet Line No.", PlanningRoutingLine."Worksheet Line No."); ProdOrderCapNeed.SetRange("Operation No.", PlanningRoutingLine."Operation No."); ProdOrderCapNeed.DeleteAll(); NextCapNeedLineNo := 1; TotalLotSize := 0; Item.Get(ReqLine."No."); MaxLotSize := ReqLine.Quantity * ReqLine."Qty. per Unit of Measure" * (1 + PlanningRoutingLine."Scrap Factor % (Accumulated)") * (1 + ReqLine."Scrap %" / 100) + PlanningRoutingLine."Fixed Scrap Qty. (Accum.)"; PlanningRoutingLine."Input Quantity" := MaxLotSize; OnBeforeCalculateRouteLine(PlanningRoutingLine, CalcStartEndDate, Direction); if Direction = Direction::Backward then CalcRoutingLineBack(CalcStartEndDate) else CalcRoutingLineForward(CalcStartEndDate); PlanningRoutingLine2 := PlanningRoutingLine; 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; TimetoProgram: Decimal; AvailCap: Decimal; xConCurrCap: Decimal; EndTime: Time; StartTime: Time; IsHandled: Boolean; begin IsHandled := false; OnBeforeFinitelyLoadCapBack( TimeType, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained, ProdEndingTime, ProdEndingDate, ConCurrCap, PlanningRoutingLine, CalendarEntry, RemainNeedQty, WorkCenter, CurrentTimeFactor, CurrentRounding, CalculateRoutingLine, ReqLine, FirstInBatch, FirstEntry, NextCapNeedLineNo, LotSize, PlanningResiliency, TempPlanningErrorLog, IsHandled); if IsHandled then exit; if (RemainNeedQty = 0) and WaitTimeOnly then exit; EndTime := ProdEndingTime; ProdEndingDateTime := CreateDateTime(ProdEndingDate, ProdEndingTime); ProdEndingDateTimeAddOneDay := CreateDateTime(ProdEndingDate + 1, ProdEndingTime); ConCurrCap := PlanningRoutingLine."Concurrent Capacities"; xConCurrCap := 1; LastProdOrderCapNeed.SetCapacityFilters(PlanningRoutingLine.Type, PlanningRoutingLine."No."); CalendarEntry.SetCapacityFilters(PlanningRoutingLine.Type, PlanningRoutingLine."No."); CalendarEntry.SetFilter("Starting Date-Time", '<= %1', ProdEndingDateTime); CalendarEntry.SetFilter("Ending Date-Time", '<= %1', ProdEndingDateTimeAddOneDay); 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; AvailCap := GetConstrainedAvailCapBaseUOM( TimeType, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained, false); if AvailCap > 0 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); LastProdOrderCapNeed.SetRange(Active, true); if LastProdOrderCapNeed.Find('+') then repeat if LastProdOrderCapNeed."Ending Time" < EndTime then begin AvailTime := Min(CalendarMgt.CalcTimeDelta(EndTime, LastProdOrderCapNeed."Ending Time"), AvailCap); if AvailTime > 0 then begin UpdateTimesBack(AvailTime, AvailCap, TimetoProgram, StartTime, EndTime); CreatePlanningCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 1); if FirstInBatch and FirstEntry then begin FirstInBatch := false; FirstEntry := false end; UpdateEndingDateAndTime(CalendarEntry.Date, EndTime); 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); if AvailTime > 0 then begin UpdateTimesBack(AvailTime, AvailCap, TimetoProgram, StartTime, EndTime); if StartTime < CalendarEntry."Starting Time" then StartTime := CalendarEntry."Starting Time"; if TimetoProgram <> 0 then CreatePlanningCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 1); if FirstInBatch and FirstEntry then begin FirstInBatch := false; FirstEntry := false end; UpdateEndingDateAndTime(CalendarEntry.Date, EndTime); 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 UpdateEndingDateAndTime(CalendarEntry.Date, CalendarEntry."Ending Time"); ProdEndingTime := StartTime; ProdEndingDate := CalendarEntry.Date; PlanningRoutingLine."Starting Time" := StartTime; PlanningRoutingLine."Starting Date" := CalendarEntry.Date; exit; end; until false; end; local procedure UpdateEndingDateAndTime(NewDate: Date; NewTime: Time) begin if UpdateDates then begin PlanningRoutingLine."Ending Date" := NewDate; PlanningRoutingLine."Ending Time" := NewTime; UpdateDates := false; end; end; local procedure GetSetupTimeBaseUOM(): Decimal begin exit(Round(PlanningRoutingLine."Setup Time" * CalendarMgt.TimeFactor(PlanningRoutingLine."Setup Time Unit of Meas. Code") / CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code"), WorkCenter."Calendar Rounding Precision")); end; local procedure GetConstrainedAvailCapBaseUOM(TimeType: Enum "Routing Time Type"; CapacityConstrainedResource: Record "Capacity Constrained Resource"; ResourceIsConstrained: Boolean; ParentCapacityConstrainedResource: Record "Capacity Constrained Resource"; ParentIsConstrained: Boolean; IsForward: Boolean) AvailCap: Decimal var AbscenseAvailCap: Decimal; SetupTime: Decimal; DampTime: Decimal; begin CalculateDailyLoad( AvailCap, DampTime, CapacityConstrainedResource, ResourceIsConstrained, ParentCapacityConstrainedResource, ParentIsConstrained); SetupTime := 0; if TimeType = TimeType::"Run Time" then SetupTime := GetSetupTimeBaseUOM() * ConCurrCap; if RemainNeedQty + SetupTime <= AvailCap + DampTime then AvailCap := AvailCap + DampTime; AvailCap := Round(AvailCap * CalendarMgt.TimeFactor(WorkCenter."Unit of Measure Code") * 100 / CalendarEntry.Efficiency / ConCurrCap, 1, '>'); AbscenseAvailCap := CalculateRoutingLine.CalcAvailQtyBase( CalendarEntry, ProdEndingDate, ProdEndingTime, TimeType, ConCurrCap, IsForward, CurrentTimeFactor, CurrentRounding); AvailCap := Min(AbscenseAvailCap, AvailCap); end; local procedure FinitelyLoadCapForward(TimeType: Enum "Routing Time Type"; var ConstrainedCapacity: Record "Capacity Constrained Resource"; ResourceIsConstrained: Boolean; var ParentWorkCenter: Record "Capacity Constrained Resource"; ParentIsConstrained: Boolean) var NextProdOrderCapNeed: Record "Prod. Order Capacity Need"; AvailTime: Decimal; ProdStartingDateTime: DateTime; ProdStartingDateTimeSubOneDay: DateTime; TimetoProgram: Decimal; AvailCap: Decimal; xConCurrCap: Decimal; EndTime: Time; StartTime: Time; IsHandled: Boolean; begin IsHandled := false; OnBeforeFinitelyLoadCapForward(PlanningRoutingLine, TimeType, ProdStartingDate, ProdStartingTime, IsHandled, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained, ProdEndingTime, ProdEndingDate, ConCurrCap, CalendarEntry, RemainNeedQty, WorkCenter, CurrentTimeFactor, CurrentRounding, CalculateRoutingLine, ReqLine, FirstInBatch, FirstEntry, NextCapNeedLineNo, LotSize, PlanningResiliency, TempPlanningErrorLog); if IsHandled then exit; if (RemainNeedQty = 0) and WaitTimeOnly then exit; StartTime := ProdStartingTime; ProdStartingDateTime := CreateDateTime(ProdStartingDate, ProdStartingTime); ProdStartingDateTimeSubOneDay := CreateDateTime(ProdStartingDate - 1, ProdStartingTime); ConCurrCap := PlanningRoutingLine."Concurrent Capacities"; xConCurrCap := 1; NextProdOrderCapNeed.SetCapacityFilters(PlanningRoutingLine.Type, PlanningRoutingLine."No."); CalendarEntry.SetCapacityFilters(PlanningRoutingLine.Type, PlanningRoutingLine."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; AvailCap := GetConstrainedAvailCapBaseUOM( TimeType, ConstrainedCapacity, ResourceIsConstrained, ParentWorkCenter, ParentIsConstrained, true); 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"); NextProdOrderCapNeed.SetRange(Active, true); 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); CreatePlanningCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 0); if FirstInBatch and FirstEntry then begin FirstInBatch := false; FirstEntry := false end; UpdateStartingDateAndTime(CalendarEntry.Date, StartTime); 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); if EndTime > CalendarEntry."Ending Time" then EndTime := CalendarEntry."Ending Time"; if TimetoProgram <> 0 then CreatePlanningCapNeed(CalendarEntry.Date, StartTime, EndTime, TimetoProgram, TimeType, 0); if FirstInBatch and FirstEntry then begin FirstInBatch := false; FirstEntry := false end; UpdateStartingDateAndTime(CalendarEntry.Date, StartTime); 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; PlanningRoutingLine."Ending Time" := EndTime; PlanningRoutingLine."Ending Date" := CalendarEntry.Date; exit; end; until false; end; local procedure UpdateStartingDateAndTime(NewDate: Date; NewTime: Time) begin if UpdateDates then begin PlanningRoutingLine."Starting Date" := NewDate; PlanningRoutingLine."Starting Time" := NewTime; UpdateDates := false; end; end; local procedure CalculateDailyLoad(var AvailCap: Decimal; var DampTime: Decimal; var ConstrainedCapacity: Record "Capacity Constrained Resource"; IsResourceConstrained: Boolean; var ParentWorkCenter: Record "Capacity Constrained Resource"; IsParentConstrained: Boolean) var CurrentLoadBase: Decimal; AvailCapWorkCenter: Decimal; DampTimeWorkCenter: Decimal; CapEffectiveBase: Decimal; begin GetCurrentWorkCenterTimeFactorAndRounding(WorkCenter); 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); CalculateRoutingLine.CalcAvailCapBaseAndDampTime( ConstrainedCapacity, AvailCap, DampTime, CapEffectiveBase, CurrentLoadBase, CurrentTimeFactor, CurrentRounding); end else begin CalcCapConResProdOrderNeedBase(ConstrainedCapacity, CalendarEntry.Date, CapEffectiveBase, CurrentLoadBase); CalculateRoutingLine.CalcAvailCapBaseAndDampTime( ConstrainedCapacity, AvailCap, DampTime, CapEffectiveBase, CurrentLoadBase, CurrentTimeFactor, CurrentRounding); CalcCapConResWorkCenterLoadBase(ParentWorkCenter, CalendarEntry.Date, CapEffectiveBase, CurrentLoadBase); CalculateRoutingLine.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; begin 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; AvailCap := AvailCap - RoundedTimetoProgram; end; local procedure UpdateTimesForward(var AvailTime: Decimal; var AvailCap: Decimal; var TimetoProgram: Decimal; StartTime: Time; var EndTime: Time) var RoundedTimetoProgram: Decimal; begin 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; 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; procedure SetResiliencyOn(WkshTemplName: Code[10]; JnlBatchName: Code[10]; ItemNo: Code[20]) begin PlanningResiliency := true; TempPlanningErrorLog.SetJnlBatch(WkshTemplName, JnlBatchName, ItemNo); end; procedure GetResiliencyError(var PlanningErrorLog: Record "Planning Error Log"): Boolean begin exit(TempPlanningErrorLog.GetError(PlanningErrorLog)); end; local procedure FindSendAheadEndingTime(var TempPlanRoutingLine: Record "Planning Routing Line"; var SendAheadLotSize: Decimal): Boolean var Result: Boolean; xTotalLotSize: Decimal; xSendAheadLotSize: Decimal; begin xTotalLotSize := TotalLotSize; xSendAheadLotSize := SendAheadLotSize; if TempPlanRoutingLine.FindSet() then repeat TotalLotSize := xTotalLotSize; SendAheadLotSize := xSendAheadLotSize; Result := Result or GetSendAheadEndingTime(TempPlanRoutingLine, SendAheadLotSize); until TempPlanRoutingLine.Next() = 0 else Result := GetSendAheadEndingTime(TempPlanRoutingLine, SendAheadLotSize); exit(Result); end; local procedure FindSendAheadStartingTime(var TempPlanRoutingLine: Record "Planning Routing Line"; var SendAheadLotSize: Decimal): Boolean var Result: Boolean; xTotalLotSize: Decimal; xSendAheadLotSize: Decimal; begin xTotalLotSize := TotalLotSize; xSendAheadLotSize := SendAheadLotSize; if TempPlanRoutingLine.FindSet() then repeat TotalLotSize := xTotalLotSize; SendAheadLotSize := xSendAheadLotSize; Result := Result or GetSendAheadStartingTime(TempPlanRoutingLine, SendAheadLotSize); until TempPlanRoutingLine.Next() = 0 else Result := GetSendAheadStartingTime(TempPlanRoutingLine, SendAheadLotSize); exit(Result); end; local procedure CreateCalendarEntry(var CalEntry: Record "Calendar Entry") begin CalEntry."Ending Time" := 000000T; CalEntry."Starting Time" := 000000T; CalEntry.Efficiency := 100; CalEntry."Absence Capacity" := 0; CalEntry."Capacity (Total)" := 0; CalEntry."Capacity (Effective)" := CalEntry."Capacity (Total)"; CalEntry."Starting Date-Time" := CreateDateTime(CalEntry.Date, CalEntry."Starting Time"); CalEntry."Ending Date-Time" := CalEntry."Starting Date-Time" + 86400000; // 24h * 60m * 60s * 1000ms if not CalEntry.Get( CalEntry."Capacity Type", CalEntry."No.", CalEntry.Date, CalEntry."Starting Time", CalEntry."Ending Time", CalEntry."Work Shift Code") then CalEntry.Insert(); end; local procedure GetCurrentWorkCenterTimeFactorAndRounding(var CurrentWorkCenter: Record "Work Center") begin CurrentTimeFactor := CalendarMgt.TimeFactor(CurrentWorkCenter."Unit of Measure Code"); CurrentRounding := CurrentWorkCenter."Calendar Rounding Precision"; end; local procedure CalcCapConResWorkCenterLoadBase(var 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. for Plan"); if CapacityConstrainedResource."Capacity (Effective)" <> 0 then begin CapEffectiveBase := Round(CapacityConstrainedResource."Capacity (Effective)" * CurrentTimeFactor, CurrentRounding); LoadBase := Round(CapacityConstrainedResource."Work Center Load Qty. for Plan" * CurrentTimeFactor, CurrentRounding); end; end; local procedure CalcCapConResProdOrderNeedBase(var 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. for Plan"); if CapacityConstrainedResource."Capacity (Effective)" <> 0 then begin CapEffectiveBase := Round(CapacityConstrainedResource."Capacity (Effective)" * CurrentTimeFactor, CurrentRounding); LoadBase := Round(CapacityConstrainedResource."Prod. Order Need Qty. for Plan" * CurrentTimeFactor, CurrentRounding); end; 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; [IntegrationEvent(false, false)] local procedure OnAfterCalcRoutingLineBack(PlanningRoutingLine: Record "Planning Routing Line"; PlanningResiliency: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCalcRoutingLineForward(PlanningRoutingLine: Record "Planning Routing Line"; PlanningResiliency: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterCreatePlanningCapNeed( var NextCapNeedLineNo: Integer; var PlanningRoutingLine: Record "Planning Routing Line"; var ReqLine: Record "Requisition Line"; NeedDate: Date; StartingTime: Time; EndingTime: Time; TimeType: option "Setup Time","Run Time"; NeedQty: Decimal; ConCurrCap: Decimal; var CalendarEntry: Record "Calendar Entry"; LotSize: Decimal; RemainNeedQty: Decimal; FirstInBatch: Boolean; Direction: Option "Forward","Backward") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcMoveTimeBack(var PlanningRoutingLine: Record "Planning Routing Line"; var WorkCenter: Record "Work Center"; var ProdEndingDate: Date; var ProdEndingTime: Time; var ProdStartingDate: Date; var ProdStartingTime: Time; var UpdateDates: Boolean; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcRoutingLineBack(var PlanningRoutingLine: Record "Planning Routing Line"; CalcStartEndDate: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcRoutingLineForward(var PlanningRoutingLine: Record "Planning Routing Line"; WorkCenter: Record "Work Center"; SendAheadLotSize: Decimal; MaxLotSize: Decimal; var TotalLotSize: Decimal; var RemainNeedQty: Decimal; var UpdateDates: Boolean; var FirstEntry: Boolean; var TempPlanningRoutingLine: Record "Planning Routing Line") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcWaitTimeBack(var PlanningRoutingLine: Record "Planning Routing Line"; var WorkCenter: Record "Work Center"; var ProdEndingDate: Date; var ProdEndingTime: Time; var ProdStartingDate: Date; var ProdStartingTime: Time; var UpdateDates: Boolean; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalculateRouteLine(var PlanningRoutingLine: Record "Planning Routing Line"; var CalcStartEndDate: Boolean; var Direction: Option) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeLoadCapForward(var PlanningRoutingLine: Record "Planning Routing Line"; TimeType: Enum "Routing Time Type"; var ProdStartingDate: Date; var ProdStartingTime: Time; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSetLotSizesToMax(var SendAheadLotSize: Decimal; var TotalLotSize: Decimal; MaxLotSize: Decimal; PlanningRoutingLine: Record "Planning Routing Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreateLoadBackOnBeforeFirstCalculate(var PlanningRoutingLine: Record "Planning Routing Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePlanningCapNeedOnAfterCalulateExpectedUnitCost(var PlanningRoutingLine: Record "Planning Routing Line"; TimeType: Enum "Routing Time Type"; NeedQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreatePlanningCapNeed(var PlanningRoutingLine: Record "Planning Routing Line"; TimeType: Enum "Routing Time Type"; var NeedQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalculateRoutingLineBackOnAfterCalcRemainNeedQtyForLotSize(PlanningRoutingLine: Record "Planning Routing Line"; var RemainNeedQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcRoutingLineBackOnAfterCalcShouldCalcNextOperation(PlanningRoutingLine: Record "Planning Routing Line"; MaxLotSize: Decimal; var TotalLotSize: Decimal; var SendAheadLotSize: Decimal; var ShouldCalcNextOperation: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalculateRoutingLineForwardOnAfterCalcRemainNeedQtyForLotSize(PlanningRoutingLine: Record "Planning Routing Line"; var RemainNeedQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeGetConstrainedCapacity(CapType: Enum "Capacity Type"; CapNo: Code[20]; var ConstrainedCapacity: Record "Capacity Constrained Resource"; var Result: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeFinitelyLoadCapBack(TimeType: Enum "Routing Time Type"; ConstrainedCapacity: Record "Capacity Constrained Resource"; ResourceIsConstrained: Boolean; ParentWorkCenter: Record "Capacity Constrained Resource"; ParentIsConstrained: Boolean; var ProdEndingTime: Time; var ProdEndingDate: Date; var ConCurrCap: Decimal; var PlanningRoutingLine: Record "Planning Routing Line"; var CalendarEntry: Record "Calendar Entry"; var RemainNeedQty: Decimal; var WorkCenter: Record "Work Center"; var CurrentTimeFactor: Decimal; var CurrentRounding: Decimal; var CalculateRoutingLine: Codeunit "Calculate Routing Line"; var ReqLine: Record "Requisition Line"; var FirstInBatch: Boolean; var FirstEntry: Boolean; var NextCapNeedLineNo: Integer; var LotSize: Decimal; var PlanningResiliency: Boolean; var TempPlanningErrorLog: Record "Planning Error Log" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeLoadCapBack(var PlanningRoutingLine: Record "Planning Routing Line"; TimeType: Enum "Routing Time Type"; var ProdStartingDate: Date; var ProdStartingTime: Time; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeFinitelyLoadCapForward(var PlanningRoutingLine: Record "Planning Routing Line"; TimeType: Enum "Routing Time Type"; var ProdStartingDate: Date; var ProdStartingTime: Time; var IsHandled: Boolean; ConstrainedCapacity: Record "Capacity Constrained Resource"; ResourceIsConstrained: Boolean; ParentWorkCenter: Record "Capacity Constrained Resource"; ParentIsConstrained: Boolean; var ProdEndingTime: Time; var ProdEndingDate: Date; var ConCurrCap: Decimal; var CalendarEntry: Record "Calendar Entry"; var RemainNeedQty: Decimal; var WorkCenter: Record "Work Center"; var CurrentTimeFactor: Decimal; var CurrentRounding: Decimal; var CalculateRoutingLine: Codeunit "Calculate Routing Line"; var ReqLine: Record "Requisition Line"; var FirstInBatch: Boolean; var FirstEntry: Boolean; var NextCapNeedLineNo: Integer; var LotSize: Decimal; var PlanningResiliency: Boolean; var TempPlanningErrorLog: Record "Planning Error Log" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnCreatingLoadForwardOnAfterUpdateRemainNeedQtyBase(PlanningRoutingLine: Record "Planning Routing Line"; CalendarEntry: Record "Calendar Entry"; var EndingTime: Time) begin end; [IntegrationEvent(false, false)] local procedure OnCreatingLoadBackOnAfterUpdateRemainNeedQtyBase(PlanningRoutingLine: Record "Planning Routing Line"; CalendarEntry: Record "Calendar Entry"; var StartingTime: Time) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePlanningCapNeedOnBeforeInsertProdOrderCapNeed(var ProdOrderCapacityNeed: Record "Prod. Order Capacity Need"; var RequisitionLine: Record "Requisition Line"; var PlanningRoutingLine: Record "Planning Routing Line") begin end;}