Codeunit 912 Calculate Assembly Cost, source in 29
Source29
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;
}