Codeunit 912 Calculate Assembly Cost

Base Application, Microsoft.Assembly.Costing

src/Layers/W1/BaseApp/Assembly/Costing/CalculateAssemblyCost.Codeunit.al723 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.Assembly.Costing;using Microsoft.Assembly.Document;using Microsoft.Assembly.History;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.UOM;using Microsoft.Inventory.BOM;using Microsoft.Inventory.Costing;using Microsoft.Inventory.Item;using Microsoft.Pricing.Calculation;using Microsoft.Pricing.PriceList;using Microsoft.Projects.Resources.Resource;codeunit 912 "Calculate Assembly Cost"{    trigger OnRun()    begin    end;    var        GLSetup: Record "General Ledger Setup";        TempItem: Record Item temporary;        TempPriceListLine: Record "Price List Line" temporary;        CostCalcMgt: Codeunit "Cost Calculation Management";        UOMMgt: Codeunit "Unit of Measure Management";#if not CLEAN28        CalculateStandardCost: Codeunit Microsoft.Manufacturing.StandardCost."Calculate Standard Cost";#endif        Window: Dialog;        MaxLevel: Integer;        NextPriceListLineNo: Integer;        CalculationDate: Date;        CalcMultiLevel: 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; NewLogErrors: Boolean; NewStdCostWkshName: Text[50]; NewShowDialog: Boolean)    begin        TempItem.DeleteAll();        ClearAll();        OnBeforeSetProperties(NewCalculationDate, NewCalcMultiLevel, NewLogErrors, NewStdCostWkshName, NewShowDialog);        CalculationDate := NewCalculationDate;        CalcMultiLevel := NewCalcMultiLevel;        LogErrors := NewLogErrors;        StdCostWkshName := NewStdCostWkshName;        ShowDialog := NewShowDialog;        MaxLevel := 50;        GLSetup.Get();        OnAfterSetProperties(NewCalculationDate, NewCalcMultiLevel, NewLogErrors, NewStdCostWkshName, NewShowDialog);    end;    procedure TestPreconditions(var Item: Record Item)    var        TempItem2: Record Item temporary;    begin        CalcItems(Item, TempItem2);    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        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 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])    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, IsHandled);#if not CLEAN28        CalculateStandardCost.RunOnBeforeCalcItem(Item, true, IsHandled);#endif        if IsHandled then            exit;        Instruction := PrepareAssemblyCalculation(Item, Depth, 1, AssemblyContainsProdBOM); // 1=StandardCost        ShowStrMenu := 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, false, '', false);        ShowConfirm := NewCalcMultiLevel and AssemblyContainsProdBOM;        OnCalcItemOnAfterCalcShowConfirm(Item, CalcMfgItems, ShowConfirm);        if ShowConfirm then            CalcMfgItems := Confirm(CalcMfgPrompt, false, Item."No.");        CalcAssemblyItem(ItemNo, Item, 0, CalcMfgItems);        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;    begin        NewTempItem.DeleteAll();        Item2.Copy(Item);        OnBeforeCalcItems(Item2);#if not CLEAN28        CalculateStandardCost.RunOnBeforeCalcItems(Item);#endif        NoOfRecords := Item.Count();        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));                CalcAssemblyItem(Item2."No.", Item3, 0, true);            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);#if not CLEAN28            CalculateStandardCost.RunOnCalcAssemblyItemOnAfterInitItemCost(Item);#endif            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);                                    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);#if not CLEAN28                            CalculateStandardCost.RunOnCalcAssemblyItemOnAfterCalcItemCost(Item, CompItem, BOMComp, ComponentQuantity);#endif                        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);#if not CLEAN28            CalculateStandardCost.RunOnCalcAssemblyItemOnAfterCalcItemRolledupCost(Item);#endif            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);#if not CLEAN28            CalculateStandardCost.RunOnCalcAssemblyItemOnAfterCalcSingleLevelCost(Item);#endif            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, 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 not CLEAN28        CalculateStandardCost.RunOnBeforeDoCalcAssemblyItemPrice(Item, Level, MaxLevel, CalcMultiLevel, IsHandled);#endif        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 not CLEAN28        CalculateStandardCost.RunOnDoCalcAssemblyItemPriceOnAfterSetBOMCompFilters(Item, BOMComp);#endif        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 GetItem(ItemNo: Code[20]; var Item: Record Item) IsInBuffer: Boolean    var        StdCostWksh: Record Microsoft.Manufacturing.StandardCost."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);#if not CLEAN28        CalculateStandardCost.RunOnAfterGetItem(Item, StdCostWkshName, IsInBuffer);#endif    end;    local procedure GetResCost(ResourceNo: Code[20]; var PriceListLine: Record "Price List Line")    var        StdCostWksh: Record Microsoft.Manufacturing.StandardCost."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;    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;    [IntegrationEvent(false, false)]    local procedure OnAfterSetProperties(var NewCalculationDate: Date; var NewCalcMultiLevel: Boolean; var NewLogErrors: Boolean; var NewStdCostWkshName: Text[50]; var NewShowDialog: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcItems(var Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcItem(var Item: Record Item; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcAssemblyItemOnAfterInitItemCost(var Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcAssemblyItemOnAfterCalcItemRolledupCost(var Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcAssemblyItemOnAfterCalcSingleLevelCost(var Item: Record Item)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcAssemblyItemOnAfterCalcItemCost(var Item: Record Item; CompItem: Record Item; BOMComponent: Record "BOM Component"; ComponentQuantity: Decimal)    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 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 NewLogErrors: Boolean; var NewStdCostWkshName: Text[50]; var NewShowDialog: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeDoCalcAssemblyItemPrice(var Item: Record Item; Level: Integer; MaxLevel: Integer; CalcMultiLevel: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnDoCalcAssemblyItemPriceOnAfterSetBOMCompFilters(var Item: Record Item; var BOMComponent: Record "BOM Component")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetResCostOnBeforeAssignPriceListLineToTemp(var PriceListLine: Record "Price List Line"; var TempItem: Record Item temporary; StdCostWkshName: Text[50])    begin    end;    // Subscribers    [EventSubscriber(ObjectType::Table, Database::Microsoft.Manufacturing.StandardCost."Standard Cost Worksheet", 'OnAfterGetItemCosts', '', false, false)]    local procedure OnAfterGetItemCosts(var StandardCostWorksheet: Record Microsoft.Manufacturing.StandardCost."Standard Cost Worksheet"; var Item: Record Item)    begin        if Item.IsMfgItem() then            StandardCostWorksheet.TransferManufCostsFromItem(Item);    end;}