Codeunit 5812 Calculate Standard Cost
src/Layers/W1/BaseApp/Manufacturing/StandardCost/CalculateStandardCost.Codeunit.al1,636 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.StandardCost;using Microsoft.Assembly.Document;using Microsoft.Assembly.History;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.Enums;using Microsoft.Foundation.UOM;using Microsoft.Inventory.BOM;using Microsoft.Inventory.Costing;using Microsoft.Inventory.Item;using Microsoft.Inventory.Location;using Microsoft.Manufacturing.Capacity;using Microsoft.Manufacturing.MachineCenter;using Microsoft.Manufacturing.ProductionBOM;using Microsoft.Manufacturing.Routing;using Microsoft.Manufacturing.Setup;using Microsoft.Manufacturing.WorkCenter;using Microsoft.Pricing.Calculation;using Microsoft.Pricing.PriceList;using Microsoft.Projects.Resources.Resource;codeunit 5812 "Calculate Standard Cost"{ trigger OnRun() begin end; var MfgSetup: Record "Manufacturing Setup"; GLSetup: Record "General Ledger Setup"; TempItem: Record Item temporary; TempSKU: Record "Stockkeeping Unit" temporary; TempWorkCenter: Record "Work Center" temporary; TempMachineCenter: Record "Machine Center" temporary; TempPriceListLine: Record "Price List Line" temporary; TempProductionBOMVersion: Record "Production BOM Version" temporary; TempRoutingVersion: Record "Routing Version" temporary; CostCalcMgt: Codeunit "Cost Calculation Management"; MfgCostCalcMgt: Codeunit "Mfg. Cost Calculation Mgt."; VersionMgt: Codeunit VersionManagement; UOMMgt: Codeunit "Unit of Measure Management"; Window: Dialog; MaxLevel: Integer; NextPriceListLineNo: Integer; CalculationDate: Date; CalcMultiLevel: Boolean; UseAssemblyList: Boolean; LogErrors: Boolean; ShowDialog: Boolean; StdCostWkshName: Text[50]; ColIdx: Option ,StdCost,ExpCost,ActCost,Dev,"Var"; RowIdx: Option ,MatCost,ResCost,ResOvhd,AsmOvhd,Total;#pragma warning disable AA0074#pragma warning disable AA0470 Text000: Label 'Too many levels. Must be below %1.';#pragma warning restore AA0470 Text001: Label '&Top level,&All levels'; Text002: Label '@1@@@@@@@@@@@@@';#pragma warning disable AA0470 CalcMfgPrompt: Label 'One or more subassemblies on the assembly list for item %1 use replenishment system Prod. Order. Do you want to calculate standard cost for those subassemblies?';#pragma warning restore AA0470 TargetText: Label 'Standard Cost,Unit Price';#pragma warning disable AA0470 RecursionInstruction: Label 'Calculate the %3 of item %1 %2 by rolling up the assembly list components. Select All levels to include and update the %3 of any subassemblies.', Comment = '%1 = Item No., %2 = Description'; NonAssemblyItemError: Label 'Item %1 %2 does not use replenishment system Assembly. The %3 will not be calculated.', Comment = '%1 = Item No., %2 = Description'; NoAssemblyListError: Label 'Item %1 %2 has no assembly list. The %3 will not be calculated.', Comment = '%1 = Item No., %2 = Description'; NonAssemblyComponentWithList: Label 'One or more subassemblies on the assembly list for this item does not use replenishment system Assembly. The %1 for these subassemblies will not be calculated. Are you sure that you want to continue?';#pragma warning restore AA0470#pragma warning restore AA0074 procedure SetProperties(NewCalculationDate: Date; NewCalcMultiLevel: Boolean; NewUseAssemblyList: Boolean; NewLogErrors: Boolean; NewStdCostWkshName: Text[50]; NewShowDialog: Boolean) begin TempItem.DeleteAll(); TempProductionBOMVersion.DeleteAll(); TempRoutingVersion.DeleteAll(); ClearAll(); OnBeforeSetProperties(NewCalculationDate, NewCalcMultiLevel, NewUseAssemblyList, NewLogErrors, NewStdCostWkshName, NewShowDialog); CalculationDate := NewCalculationDate; CalcMultiLevel := NewCalcMultiLevel; UseAssemblyList := NewUseAssemblyList; LogErrors := NewLogErrors; StdCostWkshName := NewStdCostWkshName; ShowDialog := NewShowDialog; MaxLevel := 50; MfgSetup.Get(); GLSetup.Get(); OnAfterSetProperties(NewCalculationDate, NewCalcMultiLevel, NewUseAssemblyList, NewLogErrors, NewStdCostWkshName, NewShowDialog); end; procedure TestPreconditions(var Item: Record Item; var TempNewProductionBOMVersion: Record "Production BOM Version" temporary; var NewRtngVersionErrBuf: Record "Routing Version") var TempItem2: Record Item temporary; begin CalcItems(Item, TempItem2); TempProductionBOMVersion.Reset(); if TempProductionBOMVersion.Find('-') then repeat TempNewProductionBOMVersion := TempProductionBOMVersion; TempNewProductionBOMVersion.Insert(); until TempProductionBOMVersion.Next() = 0; TempRoutingVersion.Reset(); if TempRoutingVersion.Find('-') then repeat NewRtngVersionErrBuf := TempRoutingVersion; NewRtngVersionErrBuf.Insert(); until TempRoutingVersion.Next() = 0; end; local procedure AnalyzeAssemblyList(var Item: Record Item; var Depth: Integer; var NonAssemblyItemWithList: Boolean; var ContainsProdBOM: Boolean) var BOMComponent: Record "BOM Component"; SubItem: Record Item; BaseDepth: Integer; MaxDepth: Integer; begin if Item.IsMfgItem() and ((Item."Production BOM No." <> '') or (Item."Routing No." <> '')) then begin ContainsProdBOM := true; if Item."Production BOM No." <> '' then AnalyzeProdBOM(Item."Production BOM No.", Depth, NonAssemblyItemWithList, ContainsProdBOM) else Depth += 1; exit end; BOMComponent.SetRange("Parent Item No.", Item."No."); if BOMComponent.FindSet() then begin if not Item.IsAssemblyItem() then begin NonAssemblyItemWithList := true; exit end; Depth += 1; BaseDepth := Depth; repeat if BOMComponent.Type = BOMComponent.Type::Item then begin SubItem.Get(BOMComponent."No."); MaxDepth := BaseDepth; AnalyzeAssemblyList(SubItem, MaxDepth, NonAssemblyItemWithList, ContainsProdBOM); if MaxDepth > Depth then Depth := MaxDepth end until BOMComponent.Next() = 0 end; end; local procedure AnalyzeProdBOM(ProductionBOMNo: Code[20]; var Depth: Integer; var NonAssemblyItemWithList: Boolean; var ContainsProdBOM: Boolean) var ProdBOMLine: Record "Production BOM Line"; SubItem: Record Item; PBOMVersionCode: Code[20]; BaseDepth: Integer; MaxDepth: Integer; begin SetProdBOMFilters(ProdBOMLine, PBOMVersionCode, ProductionBOMNo); if ProdBOMLine.FindSet() then begin Depth += 1; BaseDepth := Depth; repeat case ProdBOMLine.Type of ProdBOMLine.Type::Item: begin SubItem.Get(ProdBOMLine."No."); MaxDepth := BaseDepth; AnalyzeAssemblyList(SubItem, MaxDepth, NonAssemblyItemWithList, ContainsProdBOM); if MaxDepth > Depth then Depth := MaxDepth end; ProdBOMLine.Type::"Production BOM": begin MaxDepth := BaseDepth; AnalyzeProdBOM(ProdBOMLine."No.", MaxDepth, NonAssemblyItemWithList, ContainsProdBOM); MaxDepth -= 1; if MaxDepth > Depth then Depth := MaxDepth end; end; until ProdBOMLine.Next() = 0 end end; local procedure PrepareAssemblyCalculation(var Item: Record Item; var Depth: Integer; Target: Option "Standard Cost","Unit Price"; var ContainsProdBOM: Boolean) Instruction: Text[1024] var CalculationTarget: Text; SubNonAssemblyItemWithList: Boolean; begin CalculationTarget := SelectStr(Target, TargetText); if not Item.IsAssemblyItem() then Error(NonAssemblyItemError, Item."No.", Item.Description, CalculationTarget); AnalyzeAssemblyList(Item, Depth, SubNonAssemblyItemWithList, ContainsProdBOM); if Depth = 0 then Error(NoAssemblyListError, Item."No.", Item.Description, CalculationTarget); Instruction := StrSubstNo(RecursionInstruction, Item."No.", Item.Description, CalculationTarget); if SubNonAssemblyItemWithList then Instruction += StrSubstNo(NonAssemblyComponentWithList, CalculationTarget) end; procedure CalcItem(ItemNo: Code[20]; NewUseAssemblyList: Boolean) var Item: Record Item; ItemCostMgt: Codeunit ItemCostManagement; Instruction: Text[1024]; NewCalcMultiLevel: Boolean; Depth: Integer; AssemblyContainsProdBOM: Boolean; CalcMfgItems: Boolean; IsHandled: Boolean; ShowStrMenu: Boolean; ShowConfirm: Boolean; begin Item.Get(ItemNo); IsHandled := false; OnBeforeCalcItem(Item, NewUseAssemblyList, IsHandled); if IsHandled then exit; if NewUseAssemblyList then Instruction := PrepareAssemblyCalculation(Item, Depth, 1, AssemblyContainsProdBOM) // 1=StandardCost else if not Item.IsMfgItem() then exit; ShowStrMenu := not NewUseAssemblyList or (Depth > 1); OnCalcItemOnBeforeShowStrMenu(Item, ShowStrMenu, NewCalcMultiLevel); if ShowStrMenu then case StrMenu(Text001, 1, Instruction) of 0: exit; 1: NewCalcMultiLevel := false; 2: NewCalcMultiLevel := true; end; SetProperties(WorkDate(), NewCalcMultiLevel, NewUseAssemblyList, false, '', false); if NewUseAssemblyList then begin ShowConfirm := NewCalcMultiLevel and AssemblyContainsProdBOM; OnCalcItemOnAfterCalcShowConfirm(Item, CalcMfgItems, ShowConfirm); if ShowConfirm then CalcMfgItems := Confirm(CalcMfgPrompt, false, Item."No."); CalcAssemblyItem(ItemNo, Item, 0, CalcMfgItems) end else CalcMfgItem(ItemNo, Item, 0); OnCalcItemOnAfterCalculateCosts(Item); if TempItem.Find('-') then repeat ItemCostMgt.UpdateStdCostShares(TempItem); until TempItem.Next() = 0; end;#if not CLEAN27 [Obsolete('procedure that was implemented to throw the error has now been identified as unnecessary', '27.0')] procedure CalcItemForNonInventoryValue(var Item: Record Item) begin end; [Obsolete('procedure that was implemented to throw the error has now been identified as unnecessary', '27.0')] procedure CalcSKUForNonInventoryValue(var SKU: Record "Stockkeeping Unit") begin end;#endif procedure CalcItemSKU(ItemNo: Code[20]; LocationCode: Code[20]; VariantCode: Code[20]) var SKU: Record "Stockkeeping Unit"; ItemCostMgt: Codeunit ItemCostManagement; Instruction: Text[1024]; NewCalcMultiLevel: Boolean; Depth: Integer; ShowStrMenu: Boolean; begin SKU.Get(LocationCode, ItemNo, VariantCode); if not SKU.IsMfgSKU() then exit; ShowStrMenu := (Depth > 1); if ShowStrMenu then case StrMenu(Text001, 1, Instruction) of 0: exit; 1: NewCalcMultiLevel := false; 2: NewCalcMultiLevel := true; end; SetProperties(WorkDate(), NewCalcMultiLevel, false, false, '', false); CalcMfgSKU(ItemNo, LocationCode, VariantCode, SKU, 0); if TempSKU.Find('-') then repeat ItemCostMgt.UpdateStdCostSharesForSKU(TempSKU); until TempSKU.Next() = 0; if TempItem.Find('-') then repeat ItemCostMgt.UpdateStdCostShares(TempItem); until TempItem.Next() = 0; end; procedure CalcItems(var Item: Record Item; var NewTempItem: Record Item) var Item2: Record Item; Item3: Record Item; NoOfRecords: Integer; LineCount: Integer; IsHandled: Boolean; begin NewTempItem.DeleteAll(); Item2.Copy(Item); OnBeforeCalcItems(Item2); NoOfRecords := Item.Count(); IsHandled := false; OnCalcItemsOnBeforeProcessItems(Item2, NewTempItem, IsHandled); if IsHandled then exit; if ShowDialog then Window.Open(Text002); if Item2.Find('-') then repeat LineCount := LineCount + 1; if ShowDialog then Window.Update(1, Round(LineCount / NoOfRecords * 10000, 1)); if UseAssemblyList then CalcAssemblyItem(Item2."No.", Item3, 0, true) else CalcMfgItem(Item2."No.", Item3, 0); until Item2.Next() = 0; TempItem.Reset(); if TempItem.Find('-') then repeat NewTempItem := TempItem; NewTempItem.Insert(); until TempItem.Next() = 0; if ShowDialog then Window.Close(); end; local procedure CalcAssemblyItem(ItemNo: Code[20]; var Item: Record Item; Level: Integer; CalcMfgItems: Boolean) var BOMComp: Record "BOM Component"; CompItem: Record Item; Res: Record Resource; LotSize: Decimal; ComponentQuantity: Decimal; begin if Level > MaxLevel then Error(Text000, MaxLevel); if GetItem(ItemNo, Item) then exit; if not Item.IsAssemblyItem() then exit; if not CalcMultiLevel and (Level <> 0) then exit; BOMComp.SetRange("Parent Item No.", ItemNo); BOMComp.SetFilter(Type, '<>%1', BOMComp.Type::" "); if BOMComp.FindSet() then begin Item."Rolled-up Material Cost" := 0; Item."Rolled-up Capacity Cost" := 0; Item."Rolled-up Cap. Overhead Cost" := 0; Item."Rolled-up Mfg. Ovhd Cost" := 0; Item."Rolled-up Subcontracted Cost" := 0; Item."Single-Level Material Cost" := 0; Item."Single-Level Capacity Cost" := 0; Item."Single-Level Cap. Ovhd Cost" := 0; Item."Single-Level Subcontrd. Cost" := 0; OnCalcAssemblyItemOnAfterInitItemCost(Item); repeat case BOMComp.Type of BOMComp.Type::Item: begin GetItem(BOMComp."No.", CompItem); ComponentQuantity := BOMComp."Quantity per" * UOMMgt.GetQtyPerUnitOfMeasure(CompItem, BOMComp."Unit of Measure Code"); if CompItem.IsInventoriableType() then if CompItem.IsAssemblyItem() or CompItem.IsMfgItem() then begin if CompItem.IsAssemblyItem() then CalcAssemblyItem(BOMComp."No.", CompItem, Level + 1, CalcMfgItems) else if CalcMfgItems then CalcMfgItem(BOMComp."No.", CompItem, Level + 1); Item."Rolled-up Material Cost" += ComponentQuantity * CompItem."Rolled-up Material Cost"; Item."Rolled-up Capacity Cost" += ComponentQuantity * CompItem."Rolled-up Capacity Cost"; Item."Rolled-up Cap. Overhead Cost" += ComponentQuantity * CompItem."Rolled-up Cap. Overhead Cost"; Item."Rolled-up Mfg. Ovhd Cost" += ComponentQuantity * CompItem."Rolled-up Mfg. Ovhd Cost"; Item."Rolled-up Subcontracted Cost" += ComponentQuantity * CompItem."Rolled-up Subcontracted Cost"; Item."Single-Level Material Cost" += ComponentQuantity * CompItem."Standard Cost" end else begin Item."Rolled-up Material Cost" += ComponentQuantity * CompItem."Unit Cost"; Item."Single-Level Material Cost" += ComponentQuantity * CompItem."Unit Cost" end; OnCalcAssemblyItemOnAfterCalcItemCost(Item, CompItem, BOMComp, ComponentQuantity, Level, CalcMfgItems); end; BOMComp.Type::Resource: begin LotSize := 1; if BOMComp."Resource Usage Type" = BOMComp."Resource Usage Type"::Fixed then if Item."Lot Size" <> 0 then LotSize := Item."Lot Size"; GetResCost(BOMComp."No.", TempPriceListLine); Res.Get(BOMComp."No."); ComponentQuantity := BOMComp."Quantity per" * UOMMgt.GetResQtyPerUnitOfMeasure(Res, BOMComp."Unit of Measure Code") / LotSize; Item."Single-Level Capacity Cost" += ComponentQuantity * TempPriceListLine."Direct Unit Cost"; Item."Single-Level Cap. Ovhd Cost" += ComponentQuantity * (TempPriceListLine."Unit Cost" - TempPriceListLine."Direct Unit Cost"); end; end; until BOMComp.Next() = 0; Item."Single-Level Mfg. Ovhd Cost" := Round( (Item."Single-Level Material Cost" + Item."Single-Level Capacity Cost" + Item."Single-Level Cap. Ovhd Cost") * Item."Indirect Cost %" / 100 + Item."Overhead Rate", GLSetup."Unit-Amount Rounding Precision"); Item."Rolled-up Material Cost" := Round( Item."Rolled-up Material Cost", GLSetup."Unit-Amount Rounding Precision"); Item."Rolled-up Capacity Cost" := Round( Item."Rolled-up Capacity Cost" + Item."Single-Level Capacity Cost", GLSetup."Unit-Amount Rounding Precision"); Item."Rolled-up Cap. Overhead Cost" := Round( Item."Rolled-up Cap. Overhead Cost" + Item."Single-Level Cap. Ovhd Cost", GLSetup."Unit-Amount Rounding Precision"); Item."Rolled-up Mfg. Ovhd Cost" := Round( Item."Rolled-up Mfg. Ovhd Cost" + Item."Single-Level Mfg. Ovhd Cost", GLSetup."Unit-Amount Rounding Precision"); Item."Rolled-up Subcontracted Cost" := Round( Item."Rolled-up Subcontracted Cost", GLSetup."Unit-Amount Rounding Precision"); OnCalcAssemblyItemOnAfterCalcItemRolledupCost(Item); Item."Standard Cost" := Round( Item."Single-Level Material Cost" + Item."Single-Level Capacity Cost" + Item."Single-Level Cap. Ovhd Cost" + Item."Single-Level Mfg. Ovhd Cost" + Item."Single-Level Subcontrd. Cost", GLSetup."Unit-Amount Rounding Precision"); Item."Single-Level Capacity Cost" := Round( Item."Single-Level Capacity Cost", GLSetup."Unit-Amount Rounding Precision"); Item."Single-Level Cap. Ovhd Cost" := Round( Item."Single-Level Cap. Ovhd Cost", GLSetup."Unit-Amount Rounding Precision"); OnCalcAssemblyItemOnAfterCalcSingleLevelCost(Item); Item."Last Unit Cost Calc. Date" := CalculationDate; TempItem := Item; TempItem.Insert(); end end; procedure CalcAssemblyItemPrice(ItemNo: Code[20]) var Item: Record Item; Instruction: Text[1024]; Depth: Integer; NewCalcMultiLevel: Boolean; AssemblyContainsProdBOM: Boolean; begin Item.Get(ItemNo); Instruction := PrepareAssemblyCalculation(Item, Depth, 2, AssemblyContainsProdBOM); // 2=UnitPrice if Depth > 1 then case StrMenu(Text001, 1, Instruction) of 0: exit; 1: NewCalcMultiLevel := false; 2: NewCalcMultiLevel := true; end; SetProperties(WorkDate(), NewCalcMultiLevel, true, false, '', false); Item.Get(ItemNo); DoCalcAssemblyItemPrice(Item, 0); end; local procedure DoCalcAssemblyItemPrice(var Item: Record Item; Level: Integer) var BOMComp: Record "BOM Component"; CompItem: Record Item; CompResource: Record Resource; UnitPrice: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeDoCalcAssemblyItemPrice(Item, Level, MaxLevel, CalcMultiLevel, IsHandled); if IsHandled then exit; if Level > MaxLevel then Error(Text000, MaxLevel); if not CalcMultiLevel and (Level <> 0) then exit; if not Item.IsAssemblyItem() then exit; BOMComp.SetRange("Parent Item No.", Item."No."); OnDoCalcAssemblyItemPriceOnAfterSetBOMCompFilters(Item, BOMComp); if BOMComp.Find('-') then begin repeat case BOMComp.Type of BOMComp.Type::Item: if CompItem.Get(BOMComp."No.") then begin DoCalcAssemblyItemPrice(CompItem, Level + 1); UnitPrice += BOMComp."Quantity per" * UOMMgt.GetQtyPerUnitOfMeasure(CompItem, BOMComp."Unit of Measure Code") * CompItem."Unit Price"; end; BOMComp.Type::Resource: if CompResource.Get(BOMComp."No.") then UnitPrice += BOMComp."Quantity per" * UOMMgt.GetResQtyPerUnitOfMeasure(CompResource, BOMComp."Unit of Measure Code") * CompResource."Unit Price"; end until BOMComp.Next() = 0; UnitPrice := Round(UnitPrice, GLSetup."Unit-Amount Rounding Precision"); Item.Validate("Unit Price", UnitPrice); Item.Modify(true) end; end; local procedure CalcMfgItem(ItemNo: Code[20]; var Item: Record Item; Level: Integer) var LotSize: Decimal; MfgItemQtyBase: Decimal; SLMat: Decimal; SLNonInvMat: Decimal; SLCap: Decimal; SLSub: Decimal; SLCapOvhd: Decimal; SLMfgOvhd: Decimal; RUMat: Decimal; RUNonInvMat: Decimal; RUCap: Decimal; RUSub: Decimal; RUCapOvhd: Decimal; RUMfgOvhd: Decimal; begin OnBeforeCalcMfgItem(Item, LogErrors, StdCostWkshName); if Level > MaxLevel then Error(Text000, MaxLevel); if GetItem(ItemNo, Item) then exit; if not CalcMultiLevel and (Level <> 0) then exit; LotSize := 1; if Item.IsMfgItem() then begin if Item."Lot Size" <> 0 then LotSize := Item."Lot Size"; MfgItemQtyBase := MfgCostCalcMgt.CalcQtyAdjdForBOMScrap(LotSize, Item."Scrap %"); OnCalcMfgItemOnBeforeCalcRtngCost(Item, Level, LotSize, MfgItemQtyBase, SLCap); CalcRtngCost(Item."Routing No.", MfgItemQtyBase, SLCap, SLSub, SLCapOvhd, Item); CalcProdBOMCost( Item, Item."Production BOM No.", Item."Routing No.", MfgItemQtyBase, true, Level, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd, SLNonInvMat, RUNonInvMat, Item); if not MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then SLMfgOvhd := CostCalcMgt.CalcOvhdCost( SLMat + SLCap + SLSub + SLCapOvhd, Item."Indirect Cost %", Item."Overhead Rate", LotSize) else SLMfgOvhd := CostCalcMgt.CalcOvhdCost( SLMat + SLCap + SLSub + SLCapOvhd + SLNonInvMat, Item."Indirect Cost %", Item."Overhead Rate", LotSize); Item."Last Unit Cost Calc. Date" := CalculationDate; end else if Item.IsAssemblyItem() then begin CalcAssemblyItem(ItemNo, Item, Level, true); exit end else begin SLMat := Item."Unit Cost"; RUMat := Item."Unit Cost"; end; OnCalcMfgItemOnBeforeCalculateCosts( SLMat, SLCap, SLSub, SLCapOvhd, SLMfgOvhd, Item, LotSize, MfgItemQtyBase, Level, CalculationDate, RUMat); Item."Single-Level Material Cost" := CalcCostPerUnit(SLMat, LotSize); Item."Single-Level Capacity Cost" := CalcCostPerUnit(SLCap, LotSize); Item."Single-Level Subcontrd. Cost" := CalcCostPerUnit(SLSub, LotSize); Item."Single-Level Cap. Ovhd Cost" := CalcCostPerUnit(SLCapOvhd, LotSize); Item."Single-Level Mfg. Ovhd Cost" := CalcCostPerUnit(SLMfgOvhd, LotSize); Item."Rolled-up Material Cost" := CalcCostPerUnit(RUMat, LotSize); Item."Rolled-up Capacity Cost" := CalcCostPerUnit(RUCap + SLCap, LotSize); Item."Rolled-up Subcontracted Cost" := CalcCostPerUnit(RUSub + SLSub, LotSize); Item."Rolled-up Cap. Overhead Cost" := CalcCostPerUnit(RUCapOvhd + SLCapOvhd, LotSize); Item."Rolled-up Mfg. Ovhd Cost" := CalcCostPerUnit(RUMfgOvhd + SLMfgOvhd, LotSize); if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then begin Item."Rolled-up Mat. Non-Invt. Cost" := CalcCostPerUnit(RUNonInvMat, LotSize); Item."Single-Lvl Mat. Non-Invt. Cost" := CalcCostPerUnit(SLNonInvMat, LotSize); end else begin Item."Rolled-up Mat. Non-Invt. Cost" := 0; Item."Single-Lvl Mat. Non-Invt. Cost" := 0; end; Item."Standard Cost" := Item."Single-Level Material Cost" + Item."Single-Level Capacity Cost" + Item."Single-Level Subcontrd. Cost" + Item."Single-Level Cap. Ovhd Cost" + Item."Single-Level Mfg. Ovhd Cost" + Item."Single-Lvl Mat. Non-Invt. Cost"; OnCalcMfgItemOnAfterCalculateCosts(SLMat, SLCap, SLSub, SLCapOvhd, SLMfgOvhd, Item, LotSize, MfgItemQtyBase, Level, CalculationDate, RUMat); TempItem := Item; TempItem.Insert(); end; local procedure CalcMfgSKU(ItemNo: Code[20]; LocationCode: Code[20]; VariantCode: Code[20]; var SKU: Record "Stockkeeping Unit"; Level: Integer) var MainItem: Record Item; BOMNo: Code[20]; RoutingNo: Code[20]; LotSize: Decimal; MfgItemQtyBase: Decimal; SLMat: Decimal; SLNonInvMat: Decimal; SLCap: Decimal; SLSub: Decimal; SLCapOvhd: Decimal; SLMfgOvhd: Decimal; RUMat: Decimal; RUNonInvMat: Decimal; RUCap: Decimal; RUSub: Decimal; RUCapOvhd: Decimal; RUMfgOvhd: Decimal; begin if not MainItem.Get(SKU."Item No.") then exit; if Level > MaxLevel then Error(Text000, MaxLevel); if GetSKU(ItemNo, LocationCode, VariantCode, SKU) then exit; if not CalcMultiLevel and (Level <> 0) then exit; LotSize := 1; if not SKU.IsMfgSKU() then exit; if SKU."Production BOM No." = '' then BOMNo := MainItem."Production BOM No." else BOMNo := SKU."Production BOM No."; if SKU."Routing No." = '' then RoutingNo := MainItem."Routing No." else RoutingNo := SKU."Routing No."; if SKU."Lot Size" <> 0 then LotSize := SKU."Lot Size"; MfgItemQtyBase := MfgCostCalcMgt.CalcQtyAdjdForBOMScrap(LotSize, MainItem."Scrap %"); CalcRtngCostSKU(RoutingNo, MfgItemQtyBase, SLCap, SLSub, SLCapOvhd); CalcProdBOMCost( MainItem, BOMNo, RoutingNo, MfgItemQtyBase, true, Level, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd, SLNonInvMat, RUNonInvMat, SKU); if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then SLMfgOvhd := CostCalcMgt.CalcOvhdCost( SLMat + SLCap + SLSub + SLCapOvhd + SLNonInvMat, MainItem."Indirect Cost %", MainItem."Overhead Rate", LotSize) else SLMfgOvhd := CostCalcMgt.CalcOvhdCost( SLMat + SLCap + SLSub + SLCapOvhd, MainItem."Indirect Cost %", MainItem."Overhead Rate", LotSize); SKU."Single-Level Material Cost" := CalcCostPerUnit(SLMat, LotSize); if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then SKU."Single-Lvl Mat. Non-Invt. Cost" := CalcCostPerUnit(SLNonInvMat, LotSize) else SKU."Single-Lvl Mat. Non-Invt. Cost" := 0; SKU."Single-Level Capacity Cost" := CalcCostPerUnit(SLCap, LotSize); SKU."Single-Level Subcontrd. Cost" := CalcCostPerUnit(SLSub, LotSize); SKU."Single-Level Cap. Ovhd Cost" := CalcCostPerUnit(SLCapOvhd, LotSize); SKU."Single-Level Mfg. Ovhd Cost" := CalcCostPerUnit(SLMfgOvhd, LotSize); SKU."Rolled-up Material Cost" := CalcCostPerUnit(RUMat, LotSize); if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then SKU."Rolled-up Mat. Non-Invt. Cost" := CalcCostPerUnit(RUNonInvMat, LotSize) else SKU."Rolled-up Mat. Non-Invt. Cost" := 0; SKU."Rolled-up Capacity Cost" := CalcCostPerUnit(RUCap + SLCap, LotSize); SKU."Rolled-up Subcontracted Cost" := CalcCostPerUnit(RUSub + SLSub, LotSize); SKU."Rolled-up Cap. Overhead Cost" := CalcCostPerUnit(RUCapOvhd + SLCapOvhd, LotSize); SKU."Rolled-up Mfg. Ovhd Cost" := CalcCostPerUnit(RUMfgOvhd + SLMfgOvhd, LotSize); SKU."Standard Cost" := SKU."Single-Level Material Cost" + SKU."Single-Level Capacity Cost" + SKU."Single-Level Subcontrd. Cost" + SKU."Single-Level Cap. Ovhd Cost" + SKU."Single-Level Mfg. Ovhd Cost" + SKU."Single-Lvl Mat. Non-Invt. Cost"; TempSKU := SKU; TempSKU.Insert(); end; local procedure SetProdBOMFilters(var ProdBOMLine: Record "Production BOM Line"; var PBOMVersionCode: Code[20]; ProdBOMNo: Code[20]) var ProdBOMHeader: Record "Production BOM Header"; begin PBOMVersionCode := VersionMgt.GetBOMVersion(ProdBOMNo, CalculationDate, true); if PBOMVersionCode = '' then begin ProdBOMHeader.Get(ProdBOMNo); TestBOMVersionIsCertified(PBOMVersionCode, ProdBOMHeader); end; ProdBOMLine.SetRange("Production BOM No.", ProdBOMNo); ProdBOMLine.SetRange("Version Code", PBOMVersionCode); ProdBOMLine.SetFilter("Starting Date", '%1|..%2', 0D, CalculationDate); ProdBOMLine.SetFilter("Ending Date", '%1|%2..', 0D, CalculationDate); ProdBOMLine.SetFilter("No.", '<>%1', ''); OnAfterSetProdBOMFilters(ProdBOMLine, PBOMVersionCode, ProdBOMNo); end; local procedure CalcProdBOMCost(MfgItem: Record Item; ProdBOMNo: Code[20]; RtngNo: Code[20]; MfgItemQtyBase: Decimal; IsTypeItem: Boolean; Level: Integer; var SLMat: Decimal; var RUMat: Decimal; var RUCap: Decimal; var RUSub: Decimal; var RUCapOvhd: Decimal; var RUMfgOvhd: Decimal; var SLNonInvMat: Decimal; var RUNonInvMat: Decimal; var ParentItem: Record Item) var CompItem: Record Item; ProdBOMLine: Record "Production BOM Line"; CompItemQtyBase: Decimal; UOMFactor: Decimal; PBOMVersionCode: Code[20]; IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcProdBOMCost( MfgItem, ProdBOMNo, RtngNo, MfgItemQtyBase, IsTypeItem, Level, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd, IsHandled, CalculationDate, LogErrors, TempRoutingVersion, TempProductionBOMVersion); if IsHandled then exit; if ProdBOMNo = '' then exit; SetProdBOMFilters(ProdBOMLine, PBOMVersionCode, ProdBOMNo); if IsTypeItem then UOMFactor := UOMMgt.GetQtyPerUnitOfMeasure(MfgItem, VersionMgt.GetBOMUnitOfMeasure(ProdBOMNo, PBOMVersionCode)) else UOMFactor := 1; if ProdBOMLine.Find('-') then repeat OnCalcProdBOMCostOnBeforeCalcCompItemQtyBase(ProdBOMLine, ParentItem, CalculationDate, MfgItem, MfgItemQtyBase, IsTypeItem, CompItemQtyBase, RtngNo, UOMFactor); CompItemQtyBase := UOMMgt.RoundQty( MfgCostCalcMgt.CalcCompItemQtyBase(ProdBOMLine, CalculationDate, MfgItemQtyBase, RtngNo, IsTypeItem) / UOMFactor); OnCalcProdBOMCostOnAfterCalcCompItemQtyBase( CalculationDate, MfgItem, MfgItemQtyBase, IsTypeItem, ProdBOMLine, CompItemQtyBase, RtngNo, UOMFactor); case ProdBOMLine.Type of ProdBOMLine.Type::Item: begin GetItem(ProdBOMLine."No.", CompItem); if CompItem.IsInventoriableType() then begin if CompItem.IsMfgItem() or CompItem.IsAssemblyItem() then begin CalcMfgItem(ProdBOMLine."No.", CompItem, Level + 1); IncrCost(SLMat, CompItem."Standard Cost", CompItemQtyBase); IncrCost(RUMat, CompItem."Rolled-up Material Cost", CompItemQtyBase); IncrCost(RUCap, CompItem."Rolled-up Capacity Cost", CompItemQtyBase); IncrCost(RUSub, CompItem."Rolled-up Subcontracted Cost", CompItemQtyBase); IncrCost(RUCapOvhd, CompItem."Rolled-up Cap. Overhead Cost", CompItemQtyBase); IncrCost(RUMfgOvhd, CompItem."Rolled-up Mfg. Ovhd Cost", CompItemQtyBase); if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then IncrCost(RUNonInvMat, CompItem."Rolled-up Mat. Non-Invt. Cost", CompItemQtyBase); OnCalcProdBOMCostOnAfterCalcMfgItem(ProdBOMLine, MfgItem, MfgItemQtyBase, CompItem, CompItemQtyBase, Level, IsTypeItem, UOMFactor, ParentItem); end else begin IncrCost(SLMat, CompItem."Unit Cost", CompItemQtyBase); IncrCost(RUMat, CompItem."Unit Cost", CompItemQtyBase); end; end else if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then begin IncrCost(SLNonInvMat, CompItem."Unit Cost", CompItemQtyBase); IncrCost(RUNonInvMat, CompItem."Unit Cost", CompItemQtyBase); end; OnCalcProdBOMCostOnAfterCalcAnyItem(ProdBOMLine, MfgItem, MfgItemQtyBase, CompItem, CompItemQtyBase, Level, IsTypeItem, UOMFactor, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd); end; ProdBOMLine.Type::"Production BOM": CalcProdBOMCost( MfgItem, ProdBOMLine."No.", RtngNo, CompItemQtyBase, false, Level, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd, SLNonInvMat, RUNonInvMat, ParentItem); end; until ProdBOMLine.Next() = 0; end; local procedure CalcProdBOMCost(MfgItem: Record Item; ProdBOMNo: Code[20]; RtngNo: Code[20]; MfgItemQtyBase: Decimal; IsTypeItem: Boolean; Level: Integer; var SLMat: Decimal; var RUMat: Decimal; var RUCap: Decimal; var RUSub: Decimal; var RUCapOvhd: Decimal; var RUMfgOvhd: Decimal; var SLNonInvMat: Decimal; var RUNonInvMat: Decimal; var SKU: Record "Stockkeeping Unit") var CompItem: Record Item; ProdBOMLine: Record "Production BOM Line"; CompItemQtyBase: Decimal; UOMFactor: Decimal; PBOMVersionCode: Code[20]; begin if ProdBOMNo = '' then exit; SetProdBOMFilters(ProdBOMLine, PBOMVersionCode, ProdBOMNo); if IsTypeItem then UOMFactor := UOMMgt.GetQtyPerUnitOfMeasure(MfgItem, VersionMgt.GetBOMUnitOfMeasure(ProdBOMNo, PBOMVersionCode)) else UOMFactor := 1; if ProdBOMLine.Find('-') then repeat CompItemQtyBase := UOMMgt.RoundQty( MfgCostCalcMgt.CalcCompItemQtyBase(ProdBOMLine, CalculationDate, MfgItemQtyBase, RtngNo, IsTypeItem) / UOMFactor); OnCalcProdBOMCostOnAfterCalcCompItemQtyBase( CalculationDate, MfgItem, MfgItemQtyBase, IsTypeItem, ProdBOMLine, CompItemQtyBase, RtngNo, UOMFactor); case ProdBOMLine.Type of ProdBOMLine.Type::Item: begin GetItem(ProdBOMLine."No.", CompItem); if CompItem.IsInventoriableType() then begin if CompItem.IsMfgItem() or CompItem.IsAssemblyItem() then begin CalcMfgItem(ProdBOMLine."No.", CompItem, Level + 1); IncrCost(SLMat, CompItem."Standard Cost", CompItemQtyBase); IncrCost(RUMat, CompItem."Rolled-up Material Cost", CompItemQtyBase); IncrCost(RUCap, CompItem."Rolled-up Capacity Cost", CompItemQtyBase); IncrCost(RUSub, CompItem."Rolled-up Subcontracted Cost", CompItemQtyBase); IncrCost(RUCapOvhd, CompItem."Rolled-up Cap. Overhead Cost", CompItemQtyBase); IncrCost(RUMfgOvhd, CompItem."Rolled-up Mfg. Ovhd Cost", CompItemQtyBase); if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then IncrCost(RUNonInvMat, CompItem."Rolled-up Mat. Non-Invt. Cost", CompItemQtyBase); end else begin IncrCost(SLMat, CompItem."Unit Cost", CompItemQtyBase); IncrCost(RUMat, CompItem."Unit Cost", CompItemQtyBase); end; end else if MfgCostCalcMgt.CanIncNonInvCostIntoProductionItem() then begin IncrCost(SLNonInvMat, CompItem."Unit Cost", CompItemQtyBase); IncrCost(RUNonInvMat, CompItem."Unit Cost", CompItemQtyBase); end; OnCalcProdBOMCostOnAfterCalcAnyItem(ProdBOMLine, MfgItem, MfgItemQtyBase, CompItem, CompItemQtyBase, Level, IsTypeItem, UOMFactor, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd); end; ProdBOMLine.Type::"Production BOM": CalcProdBOMCost( MfgItem, ProdBOMLine."No.", RtngNo, CompItemQtyBase, false, Level, SLMat, RUMat, RUCap, RUSub, RUCapOvhd, RUMfgOvhd, SLNonInvMat, RUNonInvMat, SKU); end; OnCalcProdBOMCostOnBeforeNextLineIteration(ProdBOMLine, PBOMVersionCode, Level, CompItemQtyBase, CompItem, SLMat); until ProdBOMLine.Next() = 0; end; local procedure CalcRtngCost(RtngHeaderNo: Code[20]; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal; var ParentItem: Record Item) var RtngLine: Record "Routing Line"; RtngHeader: Record "Routing Header"; IsHandled: Boolean; begin if RtngLine.CertifiedRoutingVersionExists(RtngHeaderNo, CalculationDate) then begin if RtngLine."Version Code" = '' then begin RtngHeader.Get(RtngHeaderNo); TestRtngVersionIsCertified(RtngLine."Version Code", RtngHeader); end; repeat IsHandled := false; OnCalcRtngCostOnBeforeCalcRtngLineCost(RtngLine, ParentItem, LogErrors, IsHandled); if not IsHandled then CalcRtngLineCost(RtngLine, MfgItemQtyBase, SLCap, SLSub, SLCapOvhd, ParentItem); until RtngLine.Next() = 0; end; end; local procedure CalcRtngCostSKU(RtngHeaderNo: Code[20]; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal) var RtngLine: Record "Routing Line"; RtngHeader: Record "Routing Header"; IsHandled: Boolean; begin if RtngLine.CertifiedRoutingVersionExists(RtngHeaderNo, CalculationDate) then begin if RtngLine."Version Code" = '' then begin RtngHeader.Get(RtngHeaderNo); TestRtngVersionIsCertified(RtngLine."Version Code", RtngHeader); end; repeat IsHandled := false; OnCalcRtngCostSKUOnBeforeCalcRtngLineCostSKU(RtngLine, MfgItemQtyBase, SLCap, SLSub, SLCapOvhd, IsHandled); if not IsHandled then CalcRtngLineCostSKU(RtngLine, MfgItemQtyBase, SLCap, SLSub, SLCapOvhd); until RtngLine.Next() = 0; end; end; local procedure CalcRoutingCostPerUnit(Type: Enum "Capacity Type Routing"; No: Code[20]; var DirUnitCost: Decimal; var IndirCostPct: Decimal; var OvhdRate: Decimal; var UnitCost: Decimal; var UnitCostCalculation: Enum "Unit Cost Calculation Type") var WorkCenter: Record "Work Center"; MachineCenter: Record "Machine Center"; IsHandled: Boolean; begin case Type of Type::"Work Center": GetWorkCenter(No, WorkCenter); Type::"Machine Center": GetMachineCenter(No, MachineCenter); end; IsHandled := false; OnCalcRoutingCostPerUnitOnBeforeCalc(Type, DirUnitCost, IndirCostPct, OvhdRate, UnitCost, UnitCostCalculation, WorkCenter, MachineCenter, IsHandled); if IsHandled then exit; MfgCostCalcMgt.CalcRoutingCostPerUnit( Type, DirUnitCost, IndirCostPct, OvhdRate, UnitCost, UnitCostCalculation, WorkCenter, MachineCenter); end; local procedure CalcCostPerUnit(CostPerLot: Decimal; LotSize: Decimal): Decimal begin exit(Round(CostPerLot / LotSize, GLSetup."Unit-Amount Rounding Precision")); end; local procedure TestBOMVersionIsCertified(BOMVersionCode: Code[20]; ProdBOMHeader: Record "Production BOM Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestBOMVersionIsCertified(BOMVersionCode, ProdBOMHeader, LogErrors, IsHandled); if IsHandled then exit; if BOMVersionCode = '' then if ProdBOMHeader.Status <> ProdBOMHeader.Status::Certified then if LogErrors then InsertInErrBuf(ProdBOMHeader."No.", '', false) else ProdBOMHeader.TestField(Status, ProdBOMHeader.Status::Certified); end; local procedure InsertInErrBuf(No: Code[20]; Version: Code[10]; IsRtng: Boolean) begin if not LogErrors then exit; if IsRtng then begin TempRoutingVersion."Routing No." := No; TempRoutingVersion."Version Code" := Version; if TempRoutingVersion.Insert() then; end else begin TempProductionBOMVersion."Production BOM No." := No; TempProductionBOMVersion."Version Code" := Version; if TempProductionBOMVersion.Insert() then; end; end; local procedure GetItem(ItemNo: Code[20]; var Item: Record Item) IsInBuffer: Boolean var StdCostWksh: Record "Standard Cost Worksheet"; begin if TempItem.Get(ItemNo) then begin Item := TempItem; IsInBuffer := true; end else begin Item.Get(ItemNo); if (StdCostWkshName <> '') and not (Item.IsMfgItem() or Item.IsAssemblyItem()) then if StdCostWksh.Get(StdCostWkshName, StdCostWksh.Type::Item, ItemNo) then begin Item."Unit Cost" := StdCostWksh."New Standard Cost"; Item."Standard Cost" := StdCostWksh."New Standard Cost"; Item."Indirect Cost %" := StdCostWksh."New Indirect Cost %"; Item."Overhead Rate" := StdCostWksh."New Overhead Rate"; end; IsInBuffer := false; end; OnAfterGetItem(Item, StdCostWkshName, IsInBuffer); end; local procedure GetSKU(ItemNo: Code[20]; LocationCode: Code[20]; VariantCode: Code[20]; var SKU: Record "Stockkeeping Unit") IsInSKUBuffer: Boolean begin if TempSKU.Get(LocationCode, ItemNo, VariantCode) then begin SKU := TempSKU; IsInSKUBuffer := true; end else IsInSKUBuffer := false; end; local procedure GetWorkCenter(No: Code[20]; var WorkCenter: Record "Work Center") var StdCostWksh: Record "Standard Cost Worksheet"; begin if TempWorkCenter.Get(No) then WorkCenter := TempWorkCenter else begin WorkCenter.Get(No); if StdCostWkshName <> '' then if StdCostWksh.Get(StdCostWkshName, StdCostWksh.Type::"Work Center", No) then begin WorkCenter."Unit Cost" := StdCostWksh."New Standard Cost"; WorkCenter."Indirect Cost %" := StdCostWksh."New Indirect Cost %"; WorkCenter."Overhead Rate" := StdCostWksh."New Overhead Rate"; WorkCenter."Direct Unit Cost" := CostCalcMgt.CalcDirUnitCost( StdCostWksh."New Standard Cost", StdCostWksh."New Overhead Rate", StdCostWksh."New Indirect Cost %"); end; OnGetWorkCenterOnBeforeAssignWorkCenterToTemp(WorkCenter, TempItem, StdCostWkshName); TempWorkCenter := WorkCenter; TempWorkCenter.Insert(); end; end; local procedure GetMachineCenter(No: Code[20]; var MachineCenter: Record "Machine Center") var StdCostWksh: Record "Standard Cost Worksheet"; begin if TempMachineCenter.Get(No) then MachineCenter := TempMachineCenter else begin MachineCenter.Get(No); if StdCostWkshName <> '' then if StdCostWksh.Get(StdCostWkshName, StdCostWksh.Type::"Machine Center", No) then begin MachineCenter."Unit Cost" := StdCostWksh."New Standard Cost"; MachineCenter."Indirect Cost %" := StdCostWksh."New Indirect Cost %"; MachineCenter."Overhead Rate" := StdCostWksh."New Overhead Rate"; MachineCenter."Direct Unit Cost" := CostCalcMgt.CalcDirUnitCost( StdCostWksh."New Standard Cost", StdCostWksh."New Overhead Rate", StdCostWksh."New Indirect Cost %"); end; OnGetMachineCenterOnBeforeAssignMachineCenterToTemp(MachineCenter, TempItem, StdCostWkshName); TempMachineCenter := MachineCenter; TempMachineCenter.Insert(); end; end; local procedure GetResCost(ResourceNo: Code[20]; var PriceListLine: Record "Price List Line") var StdCostWksh: Record "Standard Cost Worksheet"; begin TempPriceListLine.SetRange("Asset Type", TempPriceListLine."Asset Type"::Resource); TempPriceListLine.SetRange("Asset No.", ResourceNo); if TempPriceListLine.FindFirst() then PriceListLine := TempPriceListLine else begin PriceListLine.Init(); PriceListLine."Price Type" := PriceListLine."Price Type"::Purchase; PriceListLine."Asset Type" := PriceListLine."Asset Type"::Resource; PriceListLine."Asset No." := ResourceNo; PriceListLine."Work Type Code" := ''; FindResourceCost(PriceListLine); if StdCostWkshName <> '' then if StdCostWksh.Get(StdCostWkshName, StdCostWksh.Type::Resource, ResourceNo) then begin PriceListLine."Unit Cost" := StdCostWksh."New Standard Cost"; PriceListLine."Direct Unit Cost" := CostCalcMgt.CalcDirUnitCost( StdCostWksh."New Standard Cost", StdCostWksh."New Overhead Rate", StdCostWksh."New Indirect Cost %"); end; OnGetResCostOnBeforeAssignPriceListLineToTemp(PriceListLine, TempItem, StdCostWkshName); TempPriceListLine := PriceListLine; NextPriceListLineNo += 1; TempPriceListLine."Line No." := NextPriceListLineNo; TempPriceListLine.Insert(); end; end; local procedure FindResourceCost(var PriceListLine: Record "Price List Line") var PriceCalculationMgt: Codeunit "Price Calculation Mgt."; PriceListLinePrice: Codeunit "Price List Line - Price"; LineWithPrice: Interface "Line With Price"; PriceCalculation: Interface "Price Calculation"; Line: Variant; PriceType: Enum "Price Type"; begin LineWithPrice := PriceListLinePrice; LineWithPrice.SetLine(PriceType::Purchase, PriceListLine); PriceCalculationMgt.GetHandler(LineWithPrice, PriceCalculation); PriceCalculation.ApplyPrice(0); PriceCalculation.GetLine(Line); PriceListLine := Line; end; local procedure IncrCost(var Cost: Decimal; UnitCost: Decimal; Qty: Decimal) begin Cost := Cost + Round(Qty * UnitCost, GLSetup."Unit-Amount Rounding Precision"); end; procedure CalculateAssemblyCostExp(AssemblyHeader: Record "Assembly Header"; var ExpCost: array[5] of Decimal) begin GLSetup.Get(); ExpCost[RowIdx::AsmOvhd] := Round( CalcOverHeadAmt( AssemblyHeader.CalcTotalCost(ExpCost), AssemblyHeader."Indirect Cost %", AssemblyHeader."Overhead Rate" * AssemblyHeader.Quantity), GLSetup."Unit-Amount Rounding Precision"); end; local procedure CalculateAssemblyCostStd(ItemNo: Code[20]; QtyBase: Decimal; var StdCost: array[5] of Decimal) var Item: Record Item; StdTotalCost: Decimal; begin GLSetup.Get(); Item.Get(ItemNo); StdCost[RowIdx::MatCost] := Round( Item."Single-Level Material Cost" * QtyBase, GLSetup."Unit-Amount Rounding Precision"); StdCost[RowIdx::ResCost] := Round( Item."Single-Level Capacity Cost" * QtyBase, GLSetup."Unit-Amount Rounding Precision"); StdCost[RowIdx::ResOvhd] := Round( Item."Single-Level Cap. Ovhd Cost" * QtyBase, GLSetup."Unit-Amount Rounding Precision"); StdTotalCost := StdCost[RowIdx::MatCost] + StdCost[RowIdx::ResCost] + StdCost[RowIdx::ResOvhd]; StdCost[RowIdx::AsmOvhd] := Round( CalcOverHeadAmt( StdTotalCost, Item."Indirect Cost %", Item."Overhead Rate" * QtyBase), GLSetup."Unit-Amount Rounding Precision"); end; procedure CalcOverHeadAmt(CostAmt: Decimal; IndirectCostPct: Decimal; OverheadRateAmt: Decimal): Decimal begin exit(CostAmt * IndirectCostPct / 100 + OverheadRateAmt); end; local procedure CalculatePostedAssemblyCostExp(PostedAssemblyHeader: Record "Posted Assembly Header"; var ExpCost: array[5] of Decimal) begin GLSetup.Get(); ExpCost[RowIdx::AsmOvhd] := Round( CalcOverHeadAmt( PostedAssemblyHeader.CalcTotalCost(ExpCost), PostedAssemblyHeader."Indirect Cost %", PostedAssemblyHeader."Overhead Rate" * PostedAssemblyHeader.Quantity), GLSetup."Unit-Amount Rounding Precision"); end; local procedure CalcTotalAndVar(var Value: array[5, 5] of Decimal) begin CalcTotal(Value); CalcVariance(Value); end; local procedure CalcTotal(var Value: array[5, 5] of Decimal) var RowId: Integer; ColId: Integer; begin for ColId := 1 to 3 do begin Value[ColId, 5] := 0; for RowId := 1 to 4 do Value[ColId, 5] += Value[ColId, RowId]; end; end; local procedure CalcVariance(var Value: array[5, 5] of Decimal) var i: Integer; begin for i := 1 to 5 do begin Value[ColIdx::Dev, i] := CalcIndicatorPct(Value[ColIdx::StdCost, i], Value[ColIdx::ActCost, i]); Value[ColIdx::"Var", i] := Value[ColIdx::ActCost, i] - Value[ColIdx::StdCost, i]; end; end; local procedure CalcIndicatorPct(Value: Decimal; "Sum": Decimal): Decimal begin if Value = 0 then exit(0); exit(Round((Sum - Value) / Value * 100, 1)); end; procedure CalcAsmOrderStatistics(AssemblyHeader: Record "Assembly Header"; var Value: array[5, 5] of Decimal) begin CalculateAssemblyCostStd( AssemblyHeader."Item No.", AssemblyHeader."Quantity (Base)", Value[ColIdx::StdCost]); CalculateAssemblyCostExp(AssemblyHeader, Value[ColIdx::ExpCost]); AssemblyHeader.CalcActualCosts(Value[ColIdx::ActCost]); CalcTotalAndVar(Value); end; procedure CalcPostedAsmOrderStatistics(PostedAssemblyHeader: Record "Posted Assembly Header"; var Value: array[5, 5] of Decimal) begin CalculateAssemblyCostStd( PostedAssemblyHeader."Item No.", PostedAssemblyHeader."Quantity (Base)", Value[ColIdx::StdCost]); CalculatePostedAssemblyCostExp(PostedAssemblyHeader, Value[ColIdx::ExpCost]); PostedAssemblyHeader.CalcActualCosts(Value[ColIdx::ActCost]); CalcTotalAndVar(Value); end; procedure CalcRtngLineCost(RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal) var DummyParentItem: Record Item; begin CalcRtngLineCost(RoutingLine, MfgItemQtyBase, SLCap, SLSub, SLCapOvhd, DummyParentItem); end; internal procedure CalcRtngLineCost(RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal; var ParentItem: Record Item) var WorkCenter: Record "Work Center"; UnitCost: Decimal; DirUnitCost: Decimal; IndirCostPct: Decimal; OvhdRate: Decimal; CostTime: Decimal; UnitCostCalculation: Enum "Unit Cost Calculation Type"; IsHandled: Boolean; begin OnBeforeCalcRtngLineCost(RoutingLine, MfgItemQtyBase, ParentItem); if (RoutingLine.Type = RoutingLine.Type::"Work Center") and (RoutingLine."No." <> '') then WorkCenter.Get(RoutingLine."No."); UnitCost := RoutingLine."Unit Cost per"; IsHandled := false; OnCalcRtngLineCostOnBeforeCalcRoutingCostPerUnit(RoutingLine, MfgItemQtyBase, WorkCenter, DirUnitCost, IndirCostPct, OvhdRate, UnitCost, UnitCostCalculation, ParentItem, IsHandled); if not IsHandled then CalcRoutingCostPerUnit(RoutingLine.Type, RoutingLine."No.", DirUnitCost, IndirCostPct, OvhdRate, UnitCost, UnitCostCalculation); OnCalcRtngLineCostOnAfterCalcRoutingCostPerUnit(RoutingLine, WorkCenter, MfgItemQtyBase, UnitCostCalculation); CostTime := MfgCostCalcMgt.CalculateCostTime( MfgItemQtyBase, RoutingLine."Setup Time", RoutingLine."Setup Time Unit of Meas. Code", RoutingLine."Run Time", RoutingLine."Run Time Unit of Meas. Code", RoutingLine."Lot Size", RoutingLine."Scrap Factor % (Accumulated)", RoutingLine."Fixed Scrap Qty. (Accum.)", RoutingLine."Work Center No.", UnitCostCalculation, MfgSetup."Cost Incl. Setup", RoutingLine."Concurrent Capacities"); if (RoutingLine.Type = RoutingLine.Type::"Work Center") and (WorkCenter."Subcontractor No." <> '') then IncrCost(SLSub, DirUnitCost, CostTime) else IncrCost(SLCap, DirUnitCost, CostTime); IncrCost(SLCapOvhd, CostCalcMgt.CalcOvhdCost(DirUnitCost, IndirCostPct, OvhdRate, 1), CostTime); OnAfterCalcRtngLineCost(RoutingLine, MfgItemQtyBase, SLCap, SLSub, SLCapOvhd, StdCostWkshName, ParentItem, CostTime, DirUnitCost); end; internal procedure CalcRtngLineCostSKU(RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal) var WorkCenter: Record "Work Center"; UnitCost: Decimal; DirUnitCost: Decimal; IndirCostPct: Decimal; OvhdRate: Decimal; CostTime: Decimal; UnitCostCalculation: Enum "Unit Cost Calculation Type"; DummyParentItem: Record Item; begin OnBeforeCalcRtngLineCost(RoutingLine, MfgItemQtyBase, DummyParentItem); if (RoutingLine.Type = RoutingLine.Type::"Work Center") and (RoutingLine."No." <> '') then WorkCenter.Get(RoutingLine."No."); UnitCost := RoutingLine."Unit Cost per"; CalcRoutingCostPerUnit(RoutingLine.Type, RoutingLine."No.", DirUnitCost, IndirCostPct, OvhdRate, UnitCost, UnitCostCalculation); OnCalcRtngLineCostOnAfterCalcRoutingCostPerUnit(RoutingLine, WorkCenter, MfgItemQtyBase, UnitCostCalculation); CostTime := MfgCostCalcMgt.CalculateCostTime( MfgItemQtyBase, RoutingLine."Setup Time", RoutingLine."Setup Time Unit of Meas. Code", RoutingLine."Run Time", RoutingLine."Run Time Unit of Meas. Code", RoutingLine."Lot Size", RoutingLine."Scrap Factor % (Accumulated)", RoutingLine."Fixed Scrap Qty. (Accum.)", RoutingLine."Work Center No.", UnitCostCalculation, MfgSetup."Cost Incl. Setup", RoutingLine."Concurrent Capacities"); if (RoutingLine.Type = RoutingLine.Type::"Work Center") and (WorkCenter."Subcontractor No." <> '') then IncrCost(SLSub, DirUnitCost, CostTime) else IncrCost(SLCap, DirUnitCost, CostTime); IncrCost(SLCapOvhd, CostCalcMgt.CalcOvhdCost(DirUnitCost, IndirCostPct, OvhdRate, 1), CostTime); end; local procedure TestRtngVersionIsCertified(RtngVersionCode: Code[20]; RtngHeader: Record "Routing Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestRtngVersionIsCertified(RtngVersionCode, RtngHeader, LogErrors, IsHandled); if IsHandled then exit; if RtngVersionCode = '' then if RtngHeader.Status <> RtngHeader.Status::Certified then if LogErrors then InsertInErrBuf(RtngHeader."No.", '', true) else RtngHeader.TestField(Status, RtngHeader.Status::Certified); end; [IntegrationEvent(false, false)] local procedure OnAfterCalcRtngLineCost(RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal; var StdCostWkshName: Text[50]; var ParentItem: Record Item; CostTime: Decimal; var DirUnitCost: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcRtngCostSKUOnBeforeCalcRtngLineCostSKU(var RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetProdBOMFilters(var ProdBOMLine: Record "Production BOM Line"; var PBOMVersionCode: Code[20]; var ProdBOMNo: Code[20]) begin end; [IntegrationEvent(false, false)] local procedure OnAfterSetProperties(var NewCalculationDate: Date; var NewCalcMultiLevel: Boolean; var NewUseAssemblyList: Boolean; var NewLogErrors: Boolean; var NewStdCostWkshName: Text[50]; var NewShowDialog: Boolean) begin end; internal procedure RunOnBeforeCalcItems(var Item: Record Item) begin OnBeforeCalcItems(Item); end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcItems(var Item: Record Item) begin end; [IntegrationEvent(false, false)] local procedure OnCalcItemsOnBeforeProcessItems(var Item2: Record Item; var NewTempItem: Record Item; var IsHandled: Boolean) begin end; internal procedure RunOnBeforeCalcItem(var Item: Record Item; UseAssemblyList: Boolean; var IsHandled: Boolean) begin OnBeforeCalcItem(Item, UseAssemblyList, IsHandled); end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcItem(var Item: Record Item; UseAssemblyList: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcMfgItem(var Item: Record Item; var LogErrors: Boolean; StdCostWkshName: Text[50]) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcRtngLineCost(var RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var ParentItem: Record Item) begin end; internal procedure RunOnCalcAssemblyItemOnAfterInitItemCost(var Item: Record Item) begin OnCalcAssemblyItemOnAfterInitItemCost(Item); end; [IntegrationEvent(false, false)] local procedure OnCalcAssemblyItemOnAfterInitItemCost(var Item: Record Item) begin end; internal procedure RunOnCalcAssemblyItemOnAfterCalcItemRolledupCost(var Item: Record Item) begin OnCalcAssemblyItemOnAfterCalcItemRolledupCost(Item); end; [IntegrationEvent(false, false)] local procedure OnCalcAssemblyItemOnAfterCalcItemRolledupCost(var Item: Record Item) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeTestBOMVersionIsCertified(BOMVersionCode: Code[20]; ProductionBOMHeader: Record "Production BOM Header"; LogErrors: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeTestRtngVersionIsCertified(RtngVersionCode: Code[20]; RoutingHeader: Record "Routing Header"; LogErrors: Boolean; var IsHandled: Boolean) begin end; internal procedure RunOnCalcAssemblyItemOnAfterCalcSingleLevelCost(var Item: Record Item) begin OnCalcAssemblyItemOnAfterCalcSingleLevelCost(Item); end; [IntegrationEvent(false, false)] local procedure OnCalcAssemblyItemOnAfterCalcSingleLevelCost(var Item: Record Item) begin end; internal procedure RunOnCalcAssemblyItemOnAfterCalcItemCost(var Item: Record Item; CompItem: Record Item; BOMComponent: Record "BOM Component"; ComponentQuantity: Decimal) var DummyLevel: Integer; DummyCalcMfgItems: Boolean; begin OnCalcAssemblyItemOnAfterCalcItemCost(Item, CompItem, BOMComponent, ComponentQuantity, DummyLevel, DummyCalcMfgItems); end; [IntegrationEvent(false, false)] local procedure OnCalcAssemblyItemOnAfterCalcItemCost(var Item: Record Item; CompItem: Record Item; BOMComponent: Record "BOM Component"; var ComponentQuantity: Decimal; var Level: Integer; var CalcMfgItems: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalcItemOnBeforeShowStrMenu(var Item: Record Item; var ShowStrMenu: Boolean; var NewCalcMultiLevel: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalcItemOnAfterCalcShowConfirm(Item: Record Item; var CalcMfgItems: Boolean; var ShowConfirm: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalcMfgItemOnBeforeCalcRtngCost(var Item: Record Item; Level: Integer; var LotSize: Decimal; var MfgItemQtyBase: Decimal; var SLCap: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcMfgItemOnBeforeCalculateCosts(var SLMat: Decimal; var SLCap: Decimal; var SLSub: Decimal; var SLCapOvhd: Decimal; var SLMfgOvhd: Decimal; var Item: Record Item; LotSize: Decimal; MfgItemQtyBase: Decimal; Level: Integer; CalculationDate: Date; var RUMat: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcMfgItemOnAfterCalculateCosts(SingleLevelMaterial: Decimal; SingleLevelCapacity: Decimal; SingleLevelSubcontracted: Decimal; SingleLevelCapacityOverhead: Decimal; SingleLevelMfgOverhead: Decimal; var Item: Record Item; LotSize: Decimal; MfgItemQtyBase: Decimal; Level: Integer; CalculationDate: Date; RolledUpMaterial: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcProdBOMCostOnAfterCalcCompItemQtyBase(CalculationDate: Date; MfgItem: Record Item; MfgItemQtyBase: Decimal; IsTypeItem: Boolean; var ProdBOMLine: Record "Production BOM Line"; var CompItemQtyBase: Decimal; RtngNo: Code[20]; UOMFactor: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcProdBOMCostOnAfterCalcMfgItem(var ProdBOMLine: Record "Production BOM Line"; MfgItem: Record Item; MfgItemQtyBase: Decimal; CompItem: Record Item; CompItemQtyBase: Decimal; Level: Integer; IsTypeItem: Boolean; UOMFactor: Decimal; var ParentItem: Record Item) begin end; [IntegrationEvent(false, false)] local procedure OnCalcProdBOMCostOnAfterCalcAnyItem(var ProductionBOMLine: Record "Production BOM Line"; MfgItem: Record Item; MfgItemQtyBase: Decimal; CompItem: Record Item; CompItemQtyBase: Decimal; Level: Integer; IsTypeItem: Boolean; UOMFactor: Decimal; var SLMat: Decimal; var RUMat: Decimal; var RUCap: Decimal; var RUSub: Decimal; var RUCapOvhd: Decimal; var RUMfgOvhd: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnCalcRtngCostOnBeforeCalcRtngLineCost(var RoutingLine: Record "Routing Line"; ParentItem: Record Item; var LogErrors: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalcRoutingCostPerUnitOnBeforeCalc(Type: Enum "Capacity Type Routing"; var DirUnitCost: Decimal; var IndirCostPct: Decimal; var OvhdRate: Decimal; var UnitCost: Decimal; var UnitCostCalculation: Enum "Unit Cost Calculation Type"; WorkCenter: Record "Work Center"; MachineCenter: Record "Machine Center"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnGetWorkCenterOnBeforeAssignWorkCenterToTemp(var WorkCenter: Record "Work Center"; var TempItem: Record Item temporary; StdCostWkshName: Text[50]) begin end; internal procedure RunOnAfterGetItem(var Item: Record Item; StdCostWkshName: Text[50]; IsInBuffer: Boolean) begin OnAfterGetItem(Item, StdCostWkshName, IsInBuffer); end; [IntegrationEvent(false, false)] local procedure OnAfterGetItem(var Item: Record Item; StdCostWkshName: Text[50]; IsInBuffer: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSetProperties(var NewCalculationDate: Date; var NewCalcMultiLevel: Boolean; var NewUseAssemblyList: Boolean; var NewLogErrors: Boolean; var NewStdCostWkshName: Text[50]; var NewShowDialog: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcProdBOMCost(MfgItem: Record Item; ProdBOMNo: Code[20]; RtngNo: Code[20]; MfgItemQtyBase: Decimal; IsTypeItem: Boolean; Level: Integer; var SLMat: Decimal; var RUMat: Decimal; var RUCap: Decimal; var RUSub: Decimal; var RUCapOvhd: Decimal; var RUMfgOvhd: Decimal; var IsHandled: Boolean; var CalculationDate: Date; var LogErrors: Boolean; var TempRoutingVersion: Record "Routing Version" temporary; var TempProductionBOMVersion: Record "Production BOM Version" temporary) begin end; internal procedure RunOnBeforeDoCalcAssemblyItemPrice(var Item: Record Item; Level: Integer; MaxLevel: Integer; CalcMultiLevel: Boolean; var IsHandled: Boolean) begin OnBeforeDoCalcAssemblyItemPrice(Item, Level, MaxLevel, CalcMultiLevel, IsHandled); end; [IntegrationEvent(false, false)] local procedure OnBeforeDoCalcAssemblyItemPrice(var Item: Record Item; Level: Integer; MaxLevel: Integer; CalcMultiLevel: Boolean; var IsHandled: Boolean) begin end; internal procedure RunOnDoCalcAssemblyItemPriceOnAfterSetBOMCompFilters(var Item: Record Item; var BOMComponent: Record "BOM Component") begin OnDoCalcAssemblyItemPriceOnAfterSetBOMCompFilters(Item, BOMComponent); end; [IntegrationEvent(false, false)] local procedure OnDoCalcAssemblyItemPriceOnAfterSetBOMCompFilters(var Item: Record Item; var BOMComponent: Record "BOM Component") begin end; [IntegrationEvent(false, false)] local procedure OnCalcProdBOMCostOnBeforeCalcCompItemQtyBase(var ProductionBOMLine: Record "Production BOM Line"; var ParentItem: Record Item; CalculationDate: Date; MfgItem: Record Item; MfgItemQtyBase: Decimal; IsTypeItem: Boolean; var CompItemQtyBase: Decimal; RtngNo: Code[20]; UOMFactor: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnGetResCostOnBeforeAssignPriceListLineToTemp(var PriceListLine: Record "Price List Line"; var TempItem: Record Item temporary; StdCostWkshName: Text[50]) begin end; [IntegrationEvent(false, false)] local procedure OnGetMachineCenterOnBeforeAssignMachineCenterToTemp(var MachineCenter: Record "Machine Center"; var TempItem: Record Item temporary; StdCostWkshName: Text[50]) begin end; [IntegrationEvent(false, false)] local procedure OnCalcRtngLineCostOnAfterCalcRoutingCostPerUnit(RoutingLine: Record "Routing Line"; WorkCenter: Record "Work Center"; var MfgItemQtyBase: Decimal; var UnitCostCalculation: Enum "Unit Cost Calculation Type") begin end; [IntegrationEvent(false, false)] local procedure OnCalcRtngLineCostOnBeforeCalcRoutingCostPerUnit(var RoutingLine: Record "Routing Line"; MfgItemQtyBase: Decimal; var WorkCenter: Record "Work Center"; var DirUnitCost: Decimal; var IndirCostPct: Decimal; var OvhdRate: Decimal; var UnitCost: Decimal; var UnitCostCalculation: Enum "Unit Cost Calculation Type"; var ParentItem: Record Item; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalcItemOnAfterCalculateCosts(var Item: Record Item) begin end; [IntegrationEvent(false, false)] local procedure OnCalcProdBOMCostOnBeforeNextLineIteration(var ProductionBOMLine: Record "Production BOM Line"; PBOMVersionCode: Code[20]; Level: Integer; CompItemQtyBase: Decimal; CompItem: Record Item; SLMat: Decimal) begin end; [EventSubscriber(ObjectType::Table, Database::"Standard Cost Worksheet", 'OnAfterValidateEvent', 'No.', true, false)] local procedure OnValidateNoByType(var Rec: Record "Standard Cost Worksheet") var MachineCenter: Record "Machine Center"; WorkCenter: Record "Work Center"; begin if Rec."No." = '' then exit; case Rec.Type of Rec.Type::"Work Center": begin WorkCenter.Get(Rec."No."); Rec.Description := WorkCenter.Name; Rec.GetWorkCenterCosts(WorkCenter); end; Rec.Type::"Machine Center": begin MachineCenter.Get(Rec."No."); Rec.Description := MachineCenter.Name; Rec.GetMachineCenterCosts(MachineCenter); end; end; end;}