Codeunit 132207 Library - Assembly
src/Layers/W1/Tests/ApplicationTestLibrary/LibraryAssembly.Codeunit.al3,290 lines, Copyright (c) Microsoft Corporation. MIT
/// <summary>/// Provides utility functions for creating and managing assembly-related entities in test scenarios, including assembly orders, BOMs, and assembly items./// </summary>codeunit 132207 "Library - Assembly"{ Subtype = Normal; trigger OnRun() begin end; var LibraryUtility: Codeunit "Library - Utility"; LibraryCosting: Codeunit "Library - Costing"; LibraryPurchase: Codeunit "Library - Purchase"; LibraryInventory: Codeunit "Library - Inventory"; LibraryERM: Codeunit "Library - ERM"; LibraryDimension: Codeunit "Library - Dimension"; LibraryResource: Codeunit "Library - Resource"; LibraryWarehouse: Codeunit "Library - Warehouse"; Assert: Codeunit Assert; LibraryRandom: Codeunit "Library - Random"; ChangeType: Option " ",Add,Replace,Delete,Edit,"Delete all","Edit cards"; ErrorZeroQty: Label 'Quantity must have a value in Assembly Header: Document Type=Order, No.=%1. It cannot be zero or empty.'; ErrorStdCost: Label 'Changing Unit Cost or Cost Amount is not allowed when Costing Method is Standard.'; BlockType: Option Dimension,"Dimension Value","Dimension Combination","None"; ClearType: Option "Posting Group","Location Posting Setup","Posting Group Setup"; AdjSource: Option Purchase,Revaluation,"Item Card","Order Lines",Resource,"None"; ErrorDimCombination: Label 'The combination of dimensions used in Order %1%2 is blocked. Dimensions %3 and %4 can''t be used concurrently.', Comment = '%1=OrderNo, %2=LineNo, %3=DimensionCode[1], %4=DimensionCode[2]'; ErrorPostingSetup: Label 'The General Posting Setup does not exist. '; ErrorInvtPostingSetup: Label 'The Inventory Posting Setup does not exist.'; procedure AddCompInventory(AssemblyHeader: Record "Assembly Header"; PostingDate: Date; QtySupplement: Decimal) var AssemblyLine: Record "Assembly Line"; Item: Record Item; begin AssemblyLine.Reset(); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); AssemblyLine.SetRange(Type, AssemblyLine.Type::Item); if AssemblyLine.FindSet() then repeat Item.Get(AssemblyLine."No."); if Item.IsInventoriableType() then AddItemInventory( AssemblyLine, PostingDate, AssemblyLine."Location Code", AssemblyLine."Bin Code", AssemblyLine.Quantity + QtySupplement); until AssemblyLine.Next() = 0; end; procedure AddCompInventoryToBin(AssemblyHeader: Record "Assembly Header"; PostingDate: Date; QtySupplement: Decimal; LocationCode: Code[10]; BinCode: Code[20]) var AssemblyLine: Record "Assembly Line"; Bin: Record Bin; Location: Record Location; ItemJournalTemplate: Record "Item Journal Template"; ItemJournalBatch: Record "Item Journal Batch"; ItemJournalLine: Record "Item Journal Line"; WarehouseJournalTemplate: Record "Warehouse Journal Template"; WarehouseJournalBatch: Record "Warehouse Journal Batch"; WarehouseJournalLine: Record "Warehouse Journal Line"; Item: Record Item; isDirected: Boolean; begin isDirected := false; if BinCode <> '' then begin Bin.SetRange(Code, BinCode); Bin.SetRange("Location Code", LocationCode); Bin.FindFirst(); Location.Get(LocationCode); if Location."Directed Put-away and Pick" then isDirected := true; end; SetupItemJournal(ItemJournalTemplate, ItemJournalBatch); if isDirected then begin LibraryWarehouse.WarehouseJournalSetup(LocationCode, WarehouseJournalTemplate, WarehouseJournalBatch); AssemblyLine.Reset(); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); AssemblyLine.SetRange(Type, AssemblyLine.Type::Item); if AssemblyLine.FindSet() then repeat LibraryWarehouse.CreateWhseJournalLine(WarehouseJournalLine, WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name, LocationCode, Bin."Zone Code", BinCode, WarehouseJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", AssemblyLine.Quantity + QtySupplement); until AssemblyLine.Next() = 0; LibraryWarehouse.RegisterWhseJournalLine(WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name, LocationCode, true); // Add to inventory Item.SetRange("Location Filter", LocationCode); LibraryWarehouse.CalculateWhseAdjustment(Item, ItemJournalBatch); end else begin AssemblyLine.Reset(); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); AssemblyLine.SetRange(Type, AssemblyLine.Type::Item); if AssemblyLine.FindSet() then repeat LibraryInventory.CreateItemJournalLine(ItemJournalLine, ItemJournalTemplate.Name, ItemJournalBatch.Name, ItemJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", AssemblyLine.Quantity + QtySupplement); ItemJournalLine.Validate("Posting Date", CalcDate('<-1D>', PostingDate)); ItemJournalLine.Validate("Document Date", CalcDate('<-1D>', ItemJournalLine."Posting Date")); ItemJournalLine.Validate("Unit of Measure Code", AssemblyLine."Unit of Measure Code"); ItemJournalLine.Validate("Variant Code", AssemblyLine."Variant Code"); ItemJournalLine.Validate("Unit Cost", LibraryRandom.RandDec(50, 2)); ItemJournalLine.Validate("Location Code", LocationCode); ItemJournalLine.Validate("Bin Code", BinCode); ItemJournalLine.Modify(true); until AssemblyLine.Next() = 0; end; LibraryInventory.PostItemJournalLine(ItemJournalTemplate.Name, ItemJournalBatch.Name); end; procedure AddItemInventory(AssemblyLine: Record "Assembly Line"; PostingDate: Date; LocationCode: Code[10]; BinCode: Code[20]; Qty: Decimal) var ItemJournalLine: Record "Item Journal Line"; ItemJournalTemplate: Record "Item Journal Template"; ItemJournalBatch: Record "Item Journal Batch"; Location: Record Location; Bin: Record Bin; WarehouseJournalLine: Record "Warehouse Journal Line"; WarehouseJournalTemplate: Record "Warehouse Journal Template"; WarehouseJournalBatch: Record "Warehouse Journal Batch"; Item: Record Item; isDirected: Boolean; begin isDirected := false; if BinCode <> '' then begin Bin.SetRange(Code, BinCode); Bin.SetRange("Location Code", LocationCode); Bin.FindFirst(); Location.Get(LocationCode); if Location."Directed Put-away and Pick" then isDirected := true; end; SetupItemJournal(ItemJournalTemplate, ItemJournalBatch); if isDirected then begin LibraryWarehouse.WarehouseJournalSetup(LocationCode, WarehouseJournalTemplate, WarehouseJournalBatch); LibraryWarehouse.CreateWhseJournalLine(WarehouseJournalLine, WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name, LocationCode, Bin."Zone Code", BinCode, WarehouseJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", Qty); LibraryWarehouse.RegisterWhseJournalLine(WarehouseJournalTemplate.Name, WarehouseJournalBatch.Name, LocationCode, true); // Add to inventory Item.SetRange("No.", AssemblyLine."No."); Item.SetRange("Location Filter", LocationCode); LibraryWarehouse.CalculateWhseAdjustment(Item, ItemJournalBatch); end else begin LibraryInventory.CreateItemJournalLine(ItemJournalLine, ItemJournalTemplate.Name, ItemJournalBatch.Name, ItemJournalLine."Entry Type"::"Positive Adjmt.", AssemblyLine."No.", Qty); ItemJournalLine.Validate("Posting Date", CalcDate('<-1D>', PostingDate)); ItemJournalLine.Validate("Document Date", CalcDate('<-1D>', ItemJournalLine."Posting Date")); ItemJournalLine.Validate("Unit of Measure Code", AssemblyLine."Unit of Measure Code"); ItemJournalLine.Validate("Variant Code", AssemblyLine."Variant Code"); ItemJournalLine.Validate("Unit Cost", LibraryRandom.RandDec(50, 2)); ItemJournalLine.Validate("Location Code", LocationCode); ItemJournalLine.Validate("Bin Code", BinCode); ItemJournalLine.Modify(true); end; LibraryInventory.PostItemJournalLine(ItemJournalTemplate.Name, ItemJournalBatch.Name); end; procedure AddAssemblyHeaderComment(AssemblyHeader: Record "Assembly Header"; AssemblyLineNo: Integer) var AssemblyCommentLine: Record "Assembly Comment Line"; begin Clear(AssemblyCommentLine); AssemblyCommentLine.Init(); AssemblyCommentLine.Validate("Document Type", AssemblyHeader."Document Type"); AssemblyCommentLine.Validate("Document No.", AssemblyHeader."No."); AssemblyCommentLine.Validate("Document Line No.", AssemblyLineNo); AssemblyCommentLine.Validate(Comment, 'Order:' + AssemblyHeader."No." + ', Line:' + Format(AssemblyLineNo)); AssemblyCommentLine.Insert(true); end; procedure AddAssemblyLineComment(var AssemblyCommentLine: Record "Assembly Comment Line"; DocType: Option; DocumentNo: Code[20]; DocumentLineNo: Integer; Date: Date; Comment: Text[80]) var RecRef: RecordRef; begin Clear(AssemblyCommentLine); AssemblyCommentLine.Validate("Document Type", DocType); AssemblyCommentLine.Validate("Document No.", DocumentNo); AssemblyCommentLine.Validate("Document Line No.", DocumentLineNo); RecRef.GetTable(AssemblyCommentLine); AssemblyCommentLine.Validate("Line No.", LibraryUtility.GetNewLineNo(RecRef, AssemblyCommentLine.FieldNo("Line No."))); AssemblyCommentLine.Insert(true); AssemblyCommentLine.Validate(Date, Date); AssemblyCommentLine.Validate(Comment, Comment); AssemblyCommentLine.Modify(true); end; procedure AddEntityDimensions(Type: Enum "BOM Component Type"; No: Code[20]) var TempDimension: Record Dimension temporary; TempDimensionValue: Record "Dimension Value" temporary; DefaultDimension: Record "Default Dimension"; AssemblyLine: Record "Assembly Line"; begin CreateDimensionSetup(TempDimension, TempDimensionValue); TempDimension.FindSet(); TempDimensionValue.FindSet(); repeat case Type of AssemblyLine.Type::Item: LibraryDimension.CreateDefaultDimensionItem(DefaultDimension, No, TempDimension.Code, TempDimensionValue.Code); AssemblyLine.Type::Resource: LibraryDimension.CreateDefaultDimensionResource(DefaultDimension, No, TempDimension.Code, TempDimensionValue.Code); end; TempDimensionValue.Next(); until TempDimension.Next() = 0; end; procedure BatchPostAssemblyHeaders(var AssemblyHeader: Record "Assembly Header"; PostingDate: Date; ReplacePostingDate: Boolean; ExpectedError: Text[1024]) var BatchPostAssemblyOrders: Report "Batch Post Assembly Orders"; begin BatchPostAssemblyOrders.UseRequestPage(false); BatchPostAssemblyOrders.InitializeRequest(PostingDate, ReplacePostingDate); BatchPostAssemblyOrders.SetTableView(AssemblyHeader); if ExpectedError = '' then BatchPostAssemblyOrders.RunModal() else begin #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits. asserterror BatchPostAssemblyOrders.RunModal(); #pragma warning restore AS0058, PTE0007 Assert.IsTrue(StrPos(GetLastErrorText, ExpectedError) > 0, 'Actual:' + GetLastErrorText); ClearLastError(); end; end; procedure BlockDimensions(TableID: Integer; DimBlockType: Option; EntityNo: Code[20]; OrderNo: Code[20]; LineNo: Text[30]): Text[1024] var Dimension: Record Dimension; DimensionValue: Record "Dimension Value"; DimensionCombination: Record "Dimension Combination"; DefaultDimension: Record "Default Dimension"; DimensionCode: array[5] of Code[20]; "Count": Integer; ExpectedError: Text[1024]; begin LibraryDimension.FindDefaultDimension(DefaultDimension, TableID, EntityNo); DefaultDimension.FindSet(); for Count := 1 to DefaultDimension.Count do begin DimensionCode[Count] := DefaultDimension."Dimension Code"; DefaultDimension.Next(); end; ExpectedError := ''; case DimBlockType of BlockType::Dimension: begin Dimension.Get(DefaultDimension."Dimension Code"); Dimension.Validate(Blocked, true); Dimension.Modify(true); ExpectedError := 'Dimension ' + Dimension.Code + ' is blocked.'; end; BlockType::"Dimension Value": begin DimensionValue.Get(DefaultDimension."Dimension Code", DefaultDimension."Dimension Value Code"); DimensionValue.Validate(Blocked, true); DimensionValue.Modify(true); ExpectedError := 'Dimension Value ' + DimensionValue."Dimension Code" + ' - ' + DimensionValue.Code + ' is blocked.'; end; BlockType::"Dimension Combination": begin DimensionCombination.Get(DimensionCode[1], DimensionCode[2]); DimensionCombination.Validate("Combination Restriction", DimensionCombination."Combination Restriction"::Blocked); DimensionCombination.Modify(true); ExpectedError := StrSubstNo(ErrorDimCombination, OrderNo, LineNo, DimensionCode[1], DimensionCode[2]); end; end; exit(ExpectedError); end; procedure BlockOrderDimensions(AssemblyHeader: Record "Assembly Header"; HeaderBlockType: Option; CompBlockType: Option): Text[1024] var AssemblyLine: Record "Assembly Line"; TableID: Integer; HeaderError: Text[1024]; CompError: Text[1024]; begin AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); if AssemblyLine.FindFirst() then begin case AssemblyLine.Type of AssemblyLine.Type::Item: TableID := 27; AssemblyLine.Type::Resource: TableID := 156; AssemblyLine.Type::" ": begin TableID := 0; AssemblyLine.TestField("Dimension Set ID", 0); end; end; CompError := BlockDimensions(TableID, CompBlockType, AssemblyLine."No.", AssemblyLine."Document No.", ', line no. ' + Format(AssemblyLine."Line No.")); end; HeaderError := BlockDimensions(27, HeaderBlockType, AssemblyHeader."Item No.", AssemblyHeader."No.", ''); if HeaderError <> '' then exit(HeaderError); if CompError <> '' then exit(CompError); exit(''); end; procedure CalcExpectedStandardCost(var MaterialCost: Decimal; var CapacityCost: Decimal; var CapOverhead: Decimal; ParentItemNo: Code[20]): Decimal var BOMComponent: Record "BOM Component"; Item: Record Item; Item1: Record Item; Resource: Record Resource; ItemUnitOfMeasure: Record "Item Unit of Measure"; ResourceUnitOfMeasure: Record "Resource Unit of Measure"; ExpectedCost: Decimal; LotSize: Decimal; LineCost: Decimal; begin ExpectedCost := 0; MaterialCost := 0; CapacityCost := 0; CapOverhead := 0; BOMComponent.SetRange("Parent Item No.", ParentItemNo); Item.Get(ParentItemNo); if BOMComponent.FindSet() then repeat case BOMComponent.Type of BOMComponent.Type::Item: begin Item1.Get(BOMComponent."No."); ItemUnitOfMeasure.Get(Item1."No.", BOMComponent."Unit of Measure Code"); LineCost := Item1."Unit Cost" * BOMComponent."Quantity per" * ItemUnitOfMeasure."Qty. per Unit of Measure"; ExpectedCost += LineCost; MaterialCost += LineCost; end; BOMComponent.Type::Resource: begin Resource.Get(BOMComponent."No."); ResourceUnitOfMeasure.Get(Resource."No.", BOMComponent."Unit of Measure Code"); if (BOMComponent."Resource Usage Type" = BOMComponent."Resource Usage Type"::Direct) or (Item."Lot Size" = 0) then LotSize := 1 else LotSize := Item."Lot Size"; LineCost := (Resource."Unit Cost" * BOMComponent."Quantity per" * ResourceUnitOfMeasure."Qty. per Unit of Measure" ) / LotSize; CapOverhead += LineCost - Resource."Direct Unit Cost" * BOMComponent."Quantity per" * ResourceUnitOfMeasure."Qty. per Unit of Measure" / LotSize; CapacityCost += LineCost; ExpectedCost += LineCost; end end; until BOMComponent.Next() = 0; if ExpectedCost = 0 then exit(Item."Standard Cost"); ExpectedCost := ExpectedCost * (1 + Item."Indirect Cost %" / 100) + Item."Overhead Rate"; MaterialCost := Round(MaterialCost, LibraryERM.GetUnitAmountRoundingPrecision()); CapacityCost := Round(CapacityCost, LibraryERM.GetUnitAmountRoundingPrecision()); CapOverhead := Round(CapOverhead, LibraryERM.GetUnitAmountRoundingPrecision()); exit(Round(ExpectedCost, LibraryERM.GetUnitAmountRoundingPrecision())); end; procedure CalcExpectedPrice(ParentItemNo: Code[20]): Decimal var Item: Record Item; BOMComponent: Record "BOM Component"; ItemUnitOfMeasure: Record "Item Unit of Measure"; Resource: Record Resource; ResUnitOfMeasure: Record "Resource Unit of Measure"; ExpectedPrice: Decimal; begin ExpectedPrice := 0; BOMComponent.SetRange("Parent Item No.", ParentItemNo); BOMComponent.SetRange(Type, BOMComponent.Type::Item); if BOMComponent.FindSet() then repeat Item.Get(BOMComponent."No."); ItemUnitOfMeasure.Get(Item."No.", BOMComponent."Unit of Measure Code"); ExpectedPrice += Item."Unit Price" * BOMComponent."Quantity per" * ItemUnitOfMeasure."Qty. per Unit of Measure"; until BOMComponent.Next() = 0; Item.Get(ParentItemNo); BOMComponent.SetRange(Type, BOMComponent.Type::Resource); if BOMComponent.FindSet() then repeat Resource.Get(BOMComponent."No."); ResUnitOfMeasure.Get(Resource."No.", BOMComponent."Unit of Measure Code"); ExpectedPrice += Resource."Unit Price" * BOMComponent."Quantity per" * ResUnitOfMeasure."Qty. per Unit of Measure" until BOMComponent.Next() = 0; if ExpectedPrice = 0 then exit(Item."Unit Price"); exit(Round(ExpectedPrice, LibraryERM.GetUnitAmountRoundingPrecision())); end; procedure CalcOrderCostAmount(var MaterialCost: Decimal; var ResourceCost: Decimal; var ResourceOvhd: Decimal; var AssemblyOvhd: Decimal; AssemblyHeaderNo: Code[20]): Decimal var Item: Record Item; AssemblyLine: Record "Assembly Line"; AssemblyHeader: Record "Assembly Header"; ExpectedCost: Decimal; Overhead: Decimal; IndirectCost: Decimal; UnitCost: Decimal; LineCost: Decimal; LineOverhead: Decimal; begin ExpectedCost := 0; MaterialCost := 0; ResourceCost := 0; ResourceOvhd := 0; AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type); AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order); AssemblyLine.SetRange("Document No.", AssemblyHeaderNo); AssemblyLine.SetFilter(Type, '<>%1', AssemblyLine.Type::" "); if AssemblyLine.FindSet() then repeat GetCostInformation(UnitCost, Overhead, IndirectCost, AssemblyLine.Type, AssemblyLine."No.", '', ''); LineOverhead := Overhead * AssemblyLine.Quantity * AssemblyLine."Qty. per Unit of Measure"; LineCost := AssemblyLine."Unit Cost" * AssemblyLine.Quantity; if AssemblyLine.Type = AssemblyLine.Type::Item then MaterialCost += LineCost else begin ResourceCost += LineCost; ResourceOvhd += LineOverhead; end until AssemblyLine.Next() = 0; AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, AssemblyHeaderNo); Item.Get(AssemblyHeader."Item No."); AssemblyOvhd := Item."Indirect Cost %" / 100 * (MaterialCost + ResourceCost + ResourceOvhd) + Item."Overhead Rate" * AssemblyHeader.Quantity * AssemblyHeader."Qty. per Unit of Measure"; if Item."Costing Method" = Item."Costing Method"::Standard then exit((Item."Standard Cost" * (100 + Item."Indirect Cost %") / 100 + Item."Overhead Rate") * AssemblyHeader.Quantity * AssemblyHeader."Qty. per Unit of Measure"); MaterialCost := Round(MaterialCost, LibraryERM.GetAmountRoundingPrecision()); ResourceCost := Round(ResourceCost, LibraryERM.GetAmountRoundingPrecision()); ResourceOvhd := Round(ResourceOvhd, LibraryERM.GetAmountRoundingPrecision()); AssemblyOvhd := Round(AssemblyOvhd, LibraryERM.GetAmountRoundingPrecision()); ExpectedCost := MaterialCost + ResourceCost + ResourceOvhd + AssemblyOvhd; exit(Round(ExpectedCost, LibraryERM.GetAmountRoundingPrecision())); end; procedure ChangeResourceUsage(AssemblyHeaderNo: Code[20]) var AssemblyLine: Record "Assembly Line"; begin AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type); AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order); AssemblyLine.SetRange("Document No.", AssemblyHeaderNo); AssemblyLine.SetRange(Type, AssemblyLine.Type::Resource); AssemblyLine.Next(LibraryRandom.RandInt(AssemblyLine.Count)); if AssemblyLine."Resource Usage Type" = AssemblyLine."Resource Usage Type"::Fixed then AssemblyLine.Validate("Resource Usage Type", AssemblyLine."Resource Usage Type"::Direct) else AssemblyLine.Validate("Resource Usage Type", AssemblyLine."Resource Usage Type"::Fixed) end; procedure ClearOrderPostingSetup(OrderClearType: Option; InvtPostingGroup: Code[20]; GenProdPostingGroup: Code[20]; LocationCode: Code[10]): Text[1024] var InventoryPostingSetup: Record "Inventory Posting Setup"; GeneralPostingSetup: Record "General Posting Setup"; ExpectedError: Text[1024]; begin ExpectedError := ''; case OrderClearType of ClearType::"Posting Group Setup": begin InventoryPostingSetup.SetRange("Invt. Posting Group Code", InvtPostingGroup); if InventoryPostingSetup.FindFirst() then InventoryPostingSetup.DeleteAll(); GeneralPostingSetup.SetRange("Gen. Prod. Posting Group", GenProdPostingGroup); if GeneralPostingSetup.FindFirst() then GeneralPostingSetup.DeleteAll(); ExpectedError := ErrorPostingSetup; end; ClearType::"Location Posting Setup": begin InventoryPostingSetup.SetRange("Location Code", LocationCode); InventoryPostingSetup.SetRange("Invt. Posting Group Code", InvtPostingGroup); if InventoryPostingSetup.FindFirst() then InventoryPostingSetup.DeleteAll(); ExpectedError := ErrorInvtPostingSetup; end; end; exit(ExpectedError); end; local procedure CreateAssemblyHeaderLocal(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal; DocumentType: Enum "Assembly Document Type"; VariantCode: Code[10]): Code[20] begin Clear(AssemblyHeader); AssemblyHeader."Document Type" := DocumentType; AssemblyHeader.Insert(true); AssemblyHeader.Validate("Item No.", ParentItemNo); AssemblyHeader.Validate("Location Code", LocationCode); AssemblyHeader.Validate("Due Date", DueDate); AssemblyHeader.Validate(Quantity, Quantity); if VariantCode <> '' then AssemblyHeader.Validate("Variant Code", VariantCode); AssemblyHeader.Modify(true); exit(AssemblyHeader."No."); end; procedure CreateAssemblyHeader(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal; VariantCode: Code[10]): Code[20] begin exit( CreateAssemblyHeaderLocal( AssemblyHeader, DueDate, ParentItemNo, LocationCode, Quantity, AssemblyHeader."Document Type"::Order, VariantCode)); end; procedure CreateAssemblyQuote(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentItemNo: Code[20]; LocationCode: Code[10]; Quantity: Decimal; VariantCode: Code[10]): Code[20] begin exit( CreateAssemblyHeaderLocal( AssemblyHeader, DueDate, ParentItemNo, LocationCode, Quantity, AssemblyHeader."Document Type"::Quote, VariantCode)); end; procedure CreateAssemblyLine(AssemblyHeader: Record "Assembly Header"; var AssemblyLine: Record "Assembly Line"; Type: Enum "BOM Component Type"; No: Code[20]; UOMCode: Code[10]; Quantity: Decimal; QtyPer: Decimal; Desc: Text[100]) var RecRef: RecordRef; begin Clear(AssemblyLine); AssemblyLine."Document Type" := AssemblyHeader."Document Type"; AssemblyLine."Document No." := AssemblyHeader."No."; RecRef.GetTable(AssemblyLine); AssemblyLine.Validate("Line No.", LibraryUtility.GetNewLineNo(RecRef, AssemblyLine.FieldNo("Line No."))); AssemblyLine.Insert(true); AssemblyLine.Validate(Type, Type); AssemblyLine.Validate("No.", No); if AssemblyHeader.Quantity <> 0 then AssemblyLine."Quantity per" := AssemblyLine.CalcQuantityPer(Quantity); AssemblyLine.Validate(Quantity, Quantity); AssemblyLine.Validate("Unit of Measure Code", UOMCode); if QtyPer <> 0 then AssemblyLine.Validate("Quantity per", QtyPer); AssemblyLine.Validate(Description, Desc); AssemblyLine.Modify(true); end; procedure CreateAssemblyLines(CostingMethod: Enum "Costing Method"; AssemblyHeaderNo: Code[20]; NoOfItems: Integer; NoOfResources: Integer) var AssemblyHeader: Record "Assembly Header"; TempItem: Record Item temporary; TempResource: Record Resource temporary; AssemblyLine: Record "Assembly Line"; begin SetupComponents(TempItem, TempResource, CostingMethod, NoOfItems, NoOfResources, '', ''); AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, AssemblyHeaderNo); if TempItem.FindSet() then repeat CreateAssemblyLine(AssemblyHeader, AssemblyLine, "BOM Component Type"::Item, TempItem."No.", GetUnitOfMeasureCode("BOM Component Type"::Item, TempItem."No.", true), LibraryRandom.RandDec(20, 2), 0, ''); until TempItem.Next() = 0; if TempResource.FindSet() then repeat CreateAssemblyLine(AssemblyHeader, AssemblyLine, "BOM Component Type"::Resource, TempResource."No.", GetUnitOfMeasureCode("BOM Component Type"::Resource, TempResource."No.", true), LibraryRandom.RandDec(20, 2), 0, ''); until TempResource.Next() = 0; end; procedure CreateAssemblyList(CostingMethod: Enum "Costing Method"; ParentItemNo: Code[20]; UseBaseUnitOfMeasure: Boolean; NoOfItems: Integer; NoOfResources: Integer; NoOfTexts: Integer; QtyPerFactor: Integer; GenProdPostingGroup: Code[20]; InventoryPostingGroup: Code[20]) var BOMComponent: Record "BOM Component"; TempItem: Record Item temporary; TempResource: Record Resource temporary; CompCount: Integer; begin SetupComponents(TempItem, TempResource, CostingMethod, NoOfItems, NoOfResources, GenProdPostingGroup, InventoryPostingGroup); if TempItem.FindSet() then repeat CreateAssemblyListComponent(BOMComponent.Type::Item, TempItem."No.", ParentItemNo, '', BOMComponent."Resource Usage Type"::Direct, QtyPerFactor * LibraryRandom.RandDec(20, 5), UseBaseUnitOfMeasure); until TempItem.Next() = 0; CompCount := 1; if TempResource.FindSet() then repeat if CompCount mod 2 = 0 then CreateAssemblyListComponent(BOMComponent.Type::Resource, TempResource."No.", ParentItemNo, '', BOMComponent."Resource Usage Type"::Direct, QtyPerFactor * LibraryRandom.RandDec(20, 5), UseBaseUnitOfMeasure) else CreateAssemblyListComponent(BOMComponent.Type::Resource, TempResource."No.", ParentItemNo, '', BOMComponent."Resource Usage Type"::Fixed, QtyPerFactor * LibraryRandom.RandDec(20, 5), UseBaseUnitOfMeasure); CompCount += 1; until TempResource.Next() = 0; for CompCount := 1 to NoOfTexts do CreateAssemblyListComponent(BOMComponent.Type::" ", '', ParentItemNo, '', BOMComponent."Resource Usage Type"::Direct, 0, UseBaseUnitOfMeasure); Commit(); end; procedure CreateAssemblyListComponent(ComponentType: Enum "BOM Component Type"; ComponentNo: Code[20]; ParentItemNo: Code[20]; VariantCode: Code[10]; ResourceUsage: Option; Qty: Decimal; UseBaseUnitOfMeasure: Boolean) var BOMComponent: Record "BOM Component"; begin LibraryInventory.CreateBOMComponent( BOMComponent, ParentItemNo, ComponentType, ComponentNo, Qty, GetUnitOfMeasureCode(ComponentType, ComponentNo, UseBaseUnitOfMeasure)); if ComponentType = BOMComponent.Type::Resource then BOMComponent.Validate("Resource Usage Type", ResourceUsage); BOMComponent.Validate("Variant Code", VariantCode); BOMComponent.Validate( Description, LibraryUtility.GenerateRandomCode(BOMComponent.FieldNo(Description), DATABASE::"BOM Component")); BOMComponent.Modify(true); Commit(); end; procedure CreateAssemblySetup(var AssemblySetup: Record "Assembly Setup"; LocationCode: Code[10]; DimensionsFrom: Option; PostedOrdersNo: Code[20]) begin if AssemblySetup."Assembly Order Nos." = '' then AssemblySetup.Validate("Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode()); if AssemblySetup."Posted Assembly Order Nos." = '' then AssemblySetup.Validate("Posted Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode()); if AssemblySetup."Assembly Quote Nos." = '' then AssemblySetup.Validate("Assembly Quote Nos.", LibraryUtility.GetGlobalNoSeriesCode()); if AssemblySetup."Blanket Assembly Order Nos." = '' then AssemblySetup.Validate("Blanket Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode()); AssemblySetup.Validate("Default Location for Orders", LocationCode); AssemblySetup.Validate("Copy Component Dimensions from", DimensionsFrom); AssemblySetup.Validate("Posted Assembly Order Nos.", PostedOrdersNo); AssemblySetup.Modify(true); end; procedure CreateDimensionSetup(var TempDimension: Record Dimension temporary; var TempDimensionValue: Record "Dimension Value" temporary) var DimensionValue: Record "Dimension Value"; DimensionCombination: Record "Dimension Combination"; Dimension: Record Dimension; "Count": Integer; DimensionCode: array[5] of Code[20]; begin for Count := 1 to 2 do begin LibraryDimension.CreateDimension(Dimension); DimensionCode[Count] := Dimension.Code; TempDimension := Dimension; TempDimension.Insert(); LibraryDimension.CreateDimensionValue(DimensionValue, Dimension.Code); TempDimensionValue := DimensionValue; TempDimensionValue.Insert(); end; LibraryDimension.CreateDimensionCombination(DimensionCombination, DimensionCode[1], DimensionCode[2]); end; procedure CreateGLAccount(var GLAccount: Record "G/L Account"; IncomeBalance: Enum "G/L Account Report Type"; Name: Text[30]) begin LibraryERM.CreateGLAccount(GLAccount); GLAccount.Validate("Income/Balance", IncomeBalance); GLAccount.Validate("Debit/Credit", GLAccount."Debit/Credit"::Both); GLAccount.Validate("Account Type", GLAccount."Account Type"::Posting); GLAccount.Validate(Name, Name); GLAccount.Modify(true); end; procedure CreateItem(var Item: Record Item; CostingMethod: Enum "Costing Method"; ReplenishmentMethod: Enum "Replenishment System"; GenProdPostingGroup: Code[20]; InventoryPostingGroup: Code[20]): Code[20] var GeneralPostingSetup: Record "General Posting Setup"; ItemUnitOfMeasure: Record "Item Unit of Measure"; UnitOfMeasure: Record "Unit of Measure"; VATPostingSetup: Record "VAT Posting Setup"; begin LibraryInventory.CreateItem(Item); Item.Validate("Replenishment System", ReplenishmentMethod); Item.Validate("Costing Method", CostingMethod); if ReplenishmentMethod <> Item."Replenishment System"::Assembly then begin if CostingMethod = Item."Costing Method"::Standard then Item.Validate("Standard Cost", LibraryRandom.RandDec(25, 2)) else Item.Validate("Unit Cost", LibraryRandom.RandDec(25, 2)); Item.Validate("Unit Price", Item."Unit Cost" + LibraryRandom.RandDec(25, 2)); end else begin Item.Validate("Standard Cost", 0); Item.Validate("Unit Cost", 0); Item.Validate("Unit Price", 0); end; Item.Validate("Last Direct Cost", Item."Unit Cost"); if InventoryPostingGroup <> '' then Item.Validate("Inventory Posting Group", InventoryPostingGroup); if GenProdPostingGroup = '' then begin LibraryERM.FindGeneralPostingSetupInvtToGL(GeneralPostingSetup); GenProdPostingGroup := GeneralPostingSetup."Gen. Prod. Posting Group"; end; Item.Validate("Gen. Prod. Posting Group", GenProdPostingGroup); Clear(VATPostingSetup); LibraryERM.FindVATPostingSetup(VATPostingSetup, VATPostingSetup."VAT Calculation Type"::"Normal VAT"); Item.Validate("VAT Prod. Posting Group", VATPostingSetup."VAT Prod. Posting Group"); Item.Modify(true); UnitOfMeasure.SetFilter(Code, '<>%1', Item."Base Unit of Measure"); UnitOfMeasure.FindFirst(); LibraryInventory.CreateItemUnitOfMeasure( ItemUnitOfMeasure, Item."No.", UnitOfMeasure.Code, LibraryRandom.RandInt(10)); exit(Item."No."); end; procedure CreateInvtPostingSetup(var InventoryPostingSetup: Record "Inventory Posting Setup"; LocationCode: Code[10]; InvtPostingGroupCode: Code[20]; InvtAccount: Code[20]; MatVarAccount: Code[20]; CapVarAcc: Code[20]; CapOvhdVarAcc: Code[20]; MfgOvhdVarAcc: Code[20]; InvtAccInterim: Code[20]) var GLAccount: Record "G/L Account"; begin Clear(InventoryPostingSetup); InventoryPostingSetup.Init(); InventoryPostingSetup.Validate("Location Code", LocationCode); InventoryPostingSetup.Validate("Invt. Posting Group Code", InvtPostingGroupCode); InventoryPostingSetup.Validate("Inventory Account", InvtAccount); InventoryPostingSetup.Validate("Material Variance Account", MatVarAccount); InventoryPostingSetup.Validate("Capacity Variance Account", CapVarAcc); InventoryPostingSetup.Validate("Cap. Overhead Variance Account", CapOvhdVarAcc); InventoryPostingSetup.Validate("Mfg. Overhead Variance Account", MfgOvhdVarAcc); InventoryPostingSetup.Validate("Inventory Account (Interim)", InvtAccInterim); LibraryERM.CreateGLAccount(GLAccount); InventoryPostingSetup.Validate("WIP Account", GLAccount."No."); OnBeforeInsertInventoryPostingSetup(InventoryPostingSetup); InventoryPostingSetup.Insert(true); end; procedure CreateInvtMovement(AssemblyHeaderNo: Code[20]; NewCreateInvtPutAway: Boolean; NewCreateInvtPick: Boolean; NewCreateInvtMovement: Boolean) var TmpWarehouseRequest: Record "Warehouse Request"; WarehouseRequest: Record "Warehouse Request"; CreateInvtPutAwayPick: Report "Create Invt Put-away/Pick/Mvmt"; begin WarehouseRequest.SetCurrentKey("Source Document", "Source No."); WarehouseRequest.SetRange("Source Document", WarehouseRequest."Source Document"::"Assembly Consumption"); WarehouseRequest.SetRange("Source No.", AssemblyHeaderNo); Commit(); CreateInvtPutAwayPick.InitializeRequest( NewCreateInvtPutAway, NewCreateInvtPick, NewCreateInvtMovement, false, false); if WarehouseRequest.HasFilter then TmpWarehouseRequest.CopyFilters(WarehouseRequest) else begin WarehouseRequest.Get(WarehouseRequest.Type, WarehouseRequest."Location Code", WarehouseRequest."Source Type", WarehouseRequest."Source Subtype", WarehouseRequest."Source No."); TmpWarehouseRequest.SetRange(Type, WarehouseRequest.Type); TmpWarehouseRequest.SetRange("Location Code", WarehouseRequest."Location Code"); TmpWarehouseRequest.SetRange("Source Type", WarehouseRequest."Source Type"); TmpWarehouseRequest.SetRange("Source Subtype", WarehouseRequest."Source Subtype"); TmpWarehouseRequest.SetRange("Source No.", WarehouseRequest."Source No."); end; CreateInvtPutAwayPick.SetTableView(TmpWarehouseRequest); CreateInvtPutAwayPick.UseRequestPage(false); CreateInvtPutAwayPick.RunModal(); end; procedure AsmOrder_CreateInvtMovement(var WarehouseRequest: Record "Warehouse Request"; NewCreateInvtPutAway: Boolean; NewCreateInvtPick: Boolean; NewCreateInvtMovement: Boolean; NewPrintDocument: Boolean; NewShowError: Boolean) var TmpWarehouseRequest: Record "Warehouse Request"; CreateInvtPutAwayPick: Report "Create Invt Put-away/Pick/Mvmt"; begin Commit(); CreateInvtPutAwayPick.InitializeRequest( NewCreateInvtPutAway, NewCreateInvtPick, NewCreateInvtMovement, NewPrintDocument, NewShowError); if WarehouseRequest.HasFilter then TmpWarehouseRequest.CopyFilters(WarehouseRequest) else begin WarehouseRequest.Get(WarehouseRequest.Type, WarehouseRequest."Location Code", WarehouseRequest."Source Type", WarehouseRequest."Source Subtype", WarehouseRequest."Source No."); TmpWarehouseRequest.SetRange(Type, WarehouseRequest.Type); TmpWarehouseRequest.SetRange("Location Code", WarehouseRequest."Location Code"); TmpWarehouseRequest.SetRange("Source Type", WarehouseRequest."Source Type"); TmpWarehouseRequest.SetRange("Source Subtype", WarehouseRequest."Source Subtype"); TmpWarehouseRequest.SetRange("Source No.", WarehouseRequest."Source No."); end; CreateInvtPutAwayPick.SetTableView(TmpWarehouseRequest); CreateInvtPutAwayPick.UseRequestPage(false); CreateInvtPutAwayPick.RunModal(); end; procedure CreateWhsePick(AssemblyHeader: Record "Assembly Header"; AssignedUserID: Code[50]; SortingMethod: Option; SetBreakBulkFilter: Boolean; DoNotFillQtyToHandle: Boolean; PrintDocument: Boolean) begin AssemblyHeader.CreatePick(false, AssignedUserID, SortingMethod, SetBreakBulkFilter, DoNotFillQtyToHandle, PrintDocument); end; procedure CreateMultipleLvlTree(var Item: Record Item; var Item1: Record Item; ReplenishmentMethod: Enum "Replenishment System"; CostingMethod: Enum "Costing Method"; TreeDepth: Integer; NoOfComps: Integer) var BOMComponent: Record "BOM Component"; Item2: Record Item; Depth: Integer; BOMCreated: Boolean; begin CreateItem(Item, CostingMethod, ReplenishmentMethod, '', ''); BOMCreated := false; OnCreateMultipleLvlTreeOnCreateBOM(Item, NoOfComps, BOMCreated); if not BOMCreated then CreateAssemblyList(Item."Costing Method"::Standard, Item."No.", true, NoOfComps, NoOfComps, NoOfComps, 1, '', ''); CreateItem(Item1, Item."Costing Method"::Standard, Item."Replenishment System"::Assembly, '', ''); CreateAssemblyList(Item."Costing Method"::Standard, Item1."No.", true, 2, 1, 0, 1, '', ''); CreateAssemblyListComponent( BOMComponent.Type::Item, Item."No.", Item1."No.", '', BOMComponent."Resource Usage Type"::Direct, LibraryRandom.RandDec(20, 2), true); for Depth := 2 to TreeDepth do begin CreateItem(Item2, Item."Costing Method"::Standard, Item."Replenishment System"::Assembly, '', ''); CreateAssemblyList(Item."Costing Method"::Standard, Item2."No.", true, 2, 1, 0, 1, '', ''); CreateAssemblyListComponent(BOMComponent.Type::Item, Item1."No.", Item2."No.", '', BOMComponent."Resource Usage Type"::Direct, LibraryRandom.RandDec(20, 2), true); Item := Item1; Item1 := Item2; Item.Find(); Item.Validate("Replenishment System", ReplenishmentMethod); Item.Modify(true); OnCreateMultipleLvlTreeOnCreateBOM(Item, NoOfComps, BOMCreated); end; Commit(); end; procedure CreateItemSubstitution(var ItemSubstitution: Record "Item Substitution"; ItemNo: Code[20]) var Item1: Record Item; begin CreateItem(Item1, Item1."Costing Method"::Standard, Item1."Replenishment System"::Purchase, '', ''); Clear(ItemSubstitution); ItemSubstitution.Init(); ItemSubstitution.Validate(Type, ItemSubstitution.Type::Item); ItemSubstitution.Validate("No.", ItemNo); ItemSubstitution.Validate("Substitute Type", ItemSubstitution."Substitute Type"::Item); ItemSubstitution.Validate("Substitute No.", Item1."No."); ItemSubstitution.Insert(); end; procedure CreateAdjustmentSource(AssemblyHeader: Record "Assembly Header"; PostingDate: Date; AdjustHeader: Boolean; AdjustmentSource: Option; ItemNo: Code[20]; ResourceNo: Code[20]) var PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; Item: Record Item; ItemJournalLine: Record "Item Journal Line"; Resource: Record Resource; begin if AdjustHeader then ItemNo := AssemblyHeader."Item No."; Item.Get(ItemNo); case AdjustmentSource of AdjSource::Purchase: begin LibraryPurchase.CreatePurchHeader( PurchaseHeader, PurchaseHeader."Document Type"::Order, ''); LibraryPurchase.CreatePurchaseLine( PurchaseLine, PurchaseHeader, PurchaseLine.Type::Item, ItemNo, LibraryRandom.RandInt(10)); PurchaseHeader.Validate( "Vendor Invoice No.", LibraryUtility.GenerateRandomCode(PurchaseHeader.FieldNo("Vendor Invoice No."), DATABASE::"Purchase Header")); PurchaseHeader.Modify(true); LibraryPurchase.PostPurchaseDocument(PurchaseHeader, true, true); end; AdjSource::Revaluation: begin RevaluateItem(Item, ItemJournalLine, Item."Unit Cost", PostingDate); LibraryInventory.PostItemJournalLine(ItemJournalLine."Journal Template Name", ItemJournalLine."Journal Batch Name"); end; AdjSource::"Item Card": begin Item."Unit Cost" := Item."Unit Cost" + LibraryRandom.RandDec(10, 2); if Item."Costing Method" = Item."Costing Method"::Standard then Item."Standard Cost" := Item."Standard Cost" + LibraryRandom.RandDec(10, 2); Item.Modify(true); end; AdjSource::"Order Lines": begin ResourceNo := CreateResource(Resource, true, Item."Gen. Prod. Posting Group"); EditAssemblyLines(ChangeType::Add, "BOM Component Type"::Resource, "BOM Component Type"::Resource, ResourceNo, AssemblyHeader."No.", true); end; AdjSource::Resource: begin Resource.Get(ResourceNo); Resource."Unit Cost" := Resource."Unit Cost" + LibraryRandom.RandDec(10, 2); Resource.Modify(true); end end; end; procedure CreateItemWithSKU(var Item: Record Item; CostingMethod: Enum "Costing Method"; ReplenishmentSystem: Enum "Replenishment System"; CreatePer: Enum "SKU Creation Method"; GenProdPostingGr: Code[20]; InvtPostingGr: Code[20]; LocationCode: Code[10]) var ItemVariant: Record "Item Variant"; begin CreateItem(Item, CostingMethod, ReplenishmentSystem, GenProdPostingGr, InvtPostingGr); if CreatePer <> CreatePer::Location then LibraryInventory.CreateVariant(ItemVariant, Item); Item."Location Filter" := LocationCode; Item.Modify(); Item.SetRange("Location Filter", LocationCode); Item.SetRecFilter(); LibraryInventory.CreateStockKeepingUnit(Item, CreatePer, false, true); UpdateSKUCards(Item); end; procedure CheckOrderDimensions(AssemblyHeader: Record "Assembly Header"; DimensionsFrom: Option) var AssemblyLine: Record "Assembly Line"; AssemblySetup: Record "Assembly Setup"; TableID: Integer; begin VerifyEntityDimensions( DATABASE::Item, AssemblyHeader."Item No.", AssemblyHeader."Item No.", true, AssemblyHeader."Dimension Set ID"); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); if AssemblyLine.FindSet() then repeat case AssemblyLine.Type of AssemblyLine.Type::Item: TableID := DATABASE::Item; AssemblyLine.Type::Resource: TableID := DATABASE::Resource; AssemblyLine.Type::" ": begin TableID := 0; AssemblyLine.TestField("Dimension Set ID", 0); end; end; VerifyEntityDimensions( TableID, AssemblyLine."No.", AssemblyHeader."Item No.", DimensionsFrom = AssemblySetup."Copy Component Dimensions from"::"Order Header", AssemblyLine."Dimension Set ID"); until AssemblyLine.Next() = 0; end; procedure CreateResource(var Resource: Record Resource; UseRelatedUnitOfMeasure: Boolean; GenProdPostingGroup: Code[20]): Code[20] var GeneralPostingSetup: Record "General Posting Setup"; ResourceUnitOfMeasure: Record "Resource Unit of Measure"; UnitOfMeasure: Record "Unit of Measure"; VATPostingSetup: Record "VAT Posting Setup"; begin LibraryERM.FindVATPostingSetup(VATPostingSetup, VATPostingSetup."VAT Calculation Type"::"Normal VAT"); LibraryResource.CreateResource(Resource, VATPostingSetup."VAT Bus. Posting Group"); UnitOfMeasure.SetFilter(Code, '<>%1', Resource."Base Unit of Measure"); UnitOfMeasure.FindFirst(); // Add a second non-base unit of measure. Clear(ResourceUnitOfMeasure); ResourceUnitOfMeasure.Init(); ResourceUnitOfMeasure.Validate("Resource No.", Resource."No."); ResourceUnitOfMeasure.Validate(Code, UnitOfMeasure.Code); ResourceUnitOfMeasure.Insert(true); ResourceUnitOfMeasure.Validate("Qty. per Unit of Measure", LibraryRandom.RandInt(10)); ResourceUnitOfMeasure.Validate("Related to Base Unit of Meas.", UseRelatedUnitOfMeasure); ResourceUnitOfMeasure.Modify(true); if GenProdPostingGroup = '' then begin LibraryERM.FindGeneralPostingSetupInvtToGL(GeneralPostingSetup); GenProdPostingGroup := GeneralPostingSetup."Gen. Prod. Posting Group"; end; Resource.Validate("Gen. Prod. Posting Group", GenProdPostingGroup); Resource.Modify(true); exit(Resource."No.") end; procedure DeleteAssemblyLine(ComponentType: Enum "BOM Component Type"; AssemblyHeaderNo: Code[20]) var AssemblyLine: Record "Assembly Line"; begin AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type); AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order); AssemblyLine.SetRange("Document No.", AssemblyHeaderNo); AssemblyLine.SetRange(Type, ComponentType); if not AssemblyLine.FindSet() then exit; AssemblyLine.Next(LibraryRandom.RandInt(AssemblyLine.Count)); AssemblyLine.Delete(); end; procedure DeleteAssemblyLines(AssemblyHeaderNo: Code[20]) var AssemblyLine: Record "Assembly Line"; begin AssemblyLine.SetRange("Document No.", AssemblyHeaderNo); AssemblyLine.DeleteAll(); end; procedure DeleteAssemblyListComponent(ComponentType: Enum "BOM Component Type"; ParentItemNo: Code[20]) var BOMComponent: Record "BOM Component"; begin BOMComponent.SetRange("Parent Item No.", ParentItemNo); BOMComponent.SetRange(Type, ComponentType); if not BOMComponent.FindSet() then exit; BOMComponent.Next(LibraryRandom.RandInt(BOMComponent.Count)); BOMComponent.Delete(); end; procedure DeleteAssemblyList(ParentItemNo: Code[20]) var BOMComponent: Record "BOM Component"; begin BOMComponent.SetRange("Parent Item No.", ParentItemNo); BOMComponent.DeleteAll(); end; procedure EditAssemblyListComponent(ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; ParentItemNo: Code[20]; ResourceUsage: Option; Qty: Decimal; UseBaseUnitOfMeasure: Boolean) var BOMComponent: Record "BOM Component"; begin BOMComponent.SetRange("Parent Item No.", ParentItemNo); BOMComponent.SetRange(Type, ComponentType); if not BOMComponent.FindSet() then exit; BOMComponent.Next(LibraryRandom.RandInt(BOMComponent.Count)); if NewComponentNo <> '' then begin BOMComponent.Validate(Type, NewComponentType); BOMComponent.Validate("No.", NewComponentNo); BOMComponent.Validate("Unit of Measure Code", GetUnitOfMeasureCode(NewComponentType, NewComponentNo, UseBaseUnitOfMeasure)); end else BOMComponent.Validate("Unit of Measure Code", GetUnitOfMeasureCode(BOMComponent.Type, BOMComponent."No.", UseBaseUnitOfMeasure)); if ComponentType = BOMComponent.Type::Resource then BOMComponent.Validate("Resource Usage Type", ResourceUsage); BOMComponent.Validate("Quantity per", Qty); BOMComponent.Validate( Description, LibraryUtility.GenerateRandomCode(BOMComponent.FieldNo(Description), DATABASE::"BOM Component")); BOMComponent.Modify(true); end; procedure EditAssemblyList(ChangeType: Option " ",Add,Replace,Delete,Edit,"Delete all","Edit cards"; ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; ParentItemNo: Code[20]) var BOMComponent: Record "BOM Component"; begin case ChangeType of ChangeType::Add: CreateAssemblyListComponent( NewComponentType, NewComponentNo, ParentItemNo, '', BOMComponent."Resource Usage Type"::Direct, LibraryRandom.RandDec(20, 2), true); ChangeType::Replace: EditAssemblyListComponent( ComponentType, NewComponentType, NewComponentNo, ParentItemNo, BOMComponent."Resource Usage Type"::Direct, LibraryRandom.RandDec(20, 2), true); ChangeType::Delete: DeleteAssemblyListComponent(ComponentType, ParentItemNo); ChangeType::Edit: EditAssemblyListComponent( ComponentType, NewComponentType, '', ParentItemNo, BOMComponent."Resource Usage Type"::Direct, LibraryRandom.RandDec(20, 2), false); ChangeType::"Delete all": DeleteAssemblyList(ParentItemNo); ChangeType::"Edit cards": ModifyCostParams(ParentItemNo, false, 0, 0); end; end; procedure EditAssemblyLine(ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; AssemblyHeaderNo: Code[20]; Qty: Decimal; UseBaseUnitOfMeasure: Boolean) var AssemblyLine: Record "Assembly Line"; begin AssemblyLine.SetCurrentKey("Document Type", "Document No.", Type); AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order); AssemblyLine.SetRange("Document No.", AssemblyHeaderNo); AssemblyLine.SetRange(Type, ComponentType); if not AssemblyLine.FindSet() then exit; AssemblyLine.Next(LibraryRandom.RandInt(AssemblyLine.Count)); if AssemblyLine.Type = AssemblyLine.Type::Item then AssemblyLine.Validate("Variant Code", LibraryInventory.GetVariant(AssemblyLine."No.", AssemblyLine."Variant Code")); AssemblyLine.Validate(Description, LibraryUtility.GenerateRandomCode(AssemblyLine.FieldNo(Description), DATABASE::"Assembly Line")); AssemblyLine.Validate("Quantity per", Qty); if NewComponentNo <> '' then begin AssemblyLine.Validate(Type, NewComponentType); AssemblyLine.Validate("No.", NewComponentNo); AssemblyLine.Validate("Unit of Measure Code", GetUnitOfMeasureCode(NewComponentType, NewComponentNo, UseBaseUnitOfMeasure)); end else AssemblyLine.Validate("Unit of Measure Code", GetUnitOfMeasureCode(AssemblyLine.Type, AssemblyLine."No.", UseBaseUnitOfMeasure)); AssemblyLine.Modify(true); end; procedure EditAssemblyLines(ChangeType: Option " ",Add,Replace,Delete,Edit,"Delete all","Edit cards",Usage; ComponentType: Enum "BOM Component Type"; NewComponentType: Enum "BOM Component Type"; NewComponentNo: Code[20]; AssemblyHeaderNo: Code[20]; UseBaseUnitOfMeasure: Boolean) var AssemblyHeader: Record "Assembly Header"; AssemblyLine: Record "Assembly Line"; begin AssemblyHeader.Get(AssemblyHeader."Document Type"::Order, AssemblyHeaderNo); case ChangeType of ChangeType::Add: CreateAssemblyLine(AssemblyHeader, AssemblyLine, NewComponentType, NewComponentNo, GetUnitOfMeasureCode(NewComponentType, NewComponentNo, true), AssemblyHeader.Quantity, 1, ''); ChangeType::Replace: EditAssemblyLine( ComponentType, NewComponentType, NewComponentNo, AssemblyHeaderNo, LibraryRandom.RandDec(20, 2), UseBaseUnitOfMeasure); ChangeType::Delete: DeleteAssemblyLine(ComponentType, AssemblyHeaderNo); ChangeType::Edit: EditAssemblyLine( ComponentType, NewComponentType, '', AssemblyHeaderNo, LibraryRandom.RandDec(20, 2), UseBaseUnitOfMeasure); ChangeType::"Delete all": DeleteAssemblyLines(AssemblyHeaderNo); ChangeType::"Edit cards": ModifyCostParams(AssemblyHeaderNo, false, 0, 0); ChangeType::Usage: ChangeResourceUsage(AssemblyHeaderNo); end; Commit(); end; procedure EditOrderDimensions(AssemblyHeader: Record "Assembly Header") var TempDimension: Record Dimension temporary; TempDimensionValue: Record "Dimension Value" temporary; begin CreateDimensionSetup(TempDimension, TempDimensionValue); AssemblyHeader.Validate("Dimension Set ID", LibraryDimension.CreateDimSet(AssemblyHeader."Dimension Set ID", TempDimension.Code, TempDimensionValue.Code)); end; local procedure FindHeaderValueEntries(var ValueEntry: Record "Value Entry"; PostedAssemblyHeader: Record "Posted Assembly Header"; EntryType: Enum "Cost Entry Type"; ItemLedgerEntryType: Enum "Item Ledger Entry Type") begin ValueEntry.Reset(); ValueEntry.SetRange("Item No.", PostedAssemblyHeader."Item No."); ValueEntry.SetRange("Item Ledger Entry Type", ItemLedgerEntryType); ValueEntry.SetRange("Entry Type", EntryType); ValueEntry.SetRange("Document No.", PostedAssemblyHeader."No."); ValueEntry.SetRange("Location Code", PostedAssemblyHeader."Location Code"); ValueEntry.SetRange("Variant Code", PostedAssemblyHeader."Variant Code"); ValueEntry.SetRange("Inventory Posting Group", PostedAssemblyHeader."Inventory Posting Group"); ValueEntry.SetRange("Gen. Prod. Posting Group", PostedAssemblyHeader."Gen. Prod. Posting Group"); ValueEntry.SetRange("Item Ledger Entry Quantity", 0); ValueEntry.SetRange("Invoiced Quantity", 0); ValueEntry.SetRange("Valued Quantity", PostedAssemblyHeader.Quantity); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", PostedAssemblyHeader."Order No."); ValueEntry.SetRange("Order Line No.", 0); end; local procedure FindLineValueEntries(var ValueEntry: Record "Value Entry"; PostedAssemblyLine: Record "Posted Assembly Line"; EntryType: Enum "Cost Entry Type"; ItemLedgerEntryType: Enum "Item Ledger Entry Type") begin ValueEntry.Reset(); if PostedAssemblyLine.Type = PostedAssemblyLine.Type::Item then ValueEntry.SetRange("Item No.", PostedAssemblyLine."No.") else begin ValueEntry.SetRange(Type, ValueEntry.Type::Resource); ValueEntry.SetRange("No.", PostedAssemblyLine."No."); end; ValueEntry.SetRange("Item Ledger Entry Type", ItemLedgerEntryType); ValueEntry.SetRange("Entry Type", EntryType); ValueEntry.SetRange("Document No.", PostedAssemblyLine."Document No."); ValueEntry.SetRange("Location Code", PostedAssemblyLine."Location Code"); ValueEntry.SetRange("Variant Code", PostedAssemblyLine."Variant Code"); if ItemLedgerEntryType = "Item Ledger Entry Type"::"Assembly Consumption" then ValueEntry.SetRange("Valued Quantity", -PostedAssemblyLine.Quantity) else ValueEntry.SetRange("Valued Quantity", PostedAssemblyLine.Quantity); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", PostedAssemblyLine."Order No."); ValueEntry.SetRange("Order Line No.", PostedAssemblyLine."Order Line No."); end; procedure FindLinkedAssemblyOrder(var AssemblyHeader: Record "Assembly Header"; DocumentType: Enum "Sales Document Type"; DocumentNo: Code[20]; DocumentLineNo: Integer) var AssembleToOrderLink: Record "Assemble-to-Order Link"; begin AssembleToOrderLink.SetRange(Type, AssembleToOrderLink.Type::Sale); AssembleToOrderLink.SetRange("Document Type", DocumentType); AssembleToOrderLink.SetRange("Document No.", DocumentNo); AssembleToOrderLink.SetRange("Document Line No.", DocumentLineNo); AssembleToOrderLink.FindFirst(); AssemblyHeader.Get(AssembleToOrderLink."Assembly Document Type", AssembleToOrderLink."Assembly Document No."); end; procedure FindPostedAssemblyLines(var PostedAssemblyLine: Record "Posted Assembly Line"; PostedAssemblyHeader: Record "Posted Assembly Header") begin PostedAssemblyLine.Reset(); PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No."); PostedAssemblyLine.SetRange("Order No.", PostedAssemblyHeader."Order No."); PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Item); end; procedure FindPostedAssemblyHeaders(var PostedAssemblyHeader: Record "Posted Assembly Header"; AssemblyHeader: Record "Assembly Header") begin PostedAssemblyHeader.Reset(); PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No."); PostedAssemblyHeader.SetRange("Item No.", AssemblyHeader."Item No."); end; procedure GetBOMComponentLines(var TempBOMComponent: Record "BOM Component" temporary; ParentItemNo: Code[20]) var BOMComponent: Record "BOM Component"; Item: Record Item; begin BOMComponent.SetRange("Parent Item No.", ParentItemNo); BOMComponent.SetRange(Type, BOMComponent.Type::Item); if BOMComponent.FindSet() then repeat Item.Get(BOMComponent."No."); if Item."Assembly BOM" then GetBOMComponentLines(TempBOMComponent, Item."No.") else begin TempBOMComponent := BOMComponent; TempBOMComponent.Insert(); end; until BOMComponent.Next() = 0; BOMComponent.SetRange(Type, BOMComponent.Type::Resource); if BOMComponent.FindSet() then repeat TempBOMComponent := BOMComponent; TempBOMComponent.Insert(); until BOMComponent.Next() = 0; end; procedure GetCostInformation(var UnitCost: Decimal; var Overhead: Decimal; var IndirectCost: Decimal; Type: Enum "BOM Component Type"; No: Code[20]; VariantCode: Code[10]; LocationCode: Code[10]): Boolean var Resource: Record Resource; Item: Record Item; StockkeepingUnit: Record "Stockkeeping Unit"; begin case Type of "BOM Component Type"::Item: begin Item.Get(No); StockkeepingUnit.SetCurrentKey("Location Code", "Item No.", "Variant Code"); if StockkeepingUnit.Get(LocationCode, Item."No.", VariantCode) then UnitCost := StockkeepingUnit."Unit Cost" else UnitCost := Item."Unit Cost"; Overhead := Item."Overhead Rate"; IndirectCost := Item."Indirect Cost %"; exit(Item."Cost is Adjusted"); end; "BOM Component Type"::Resource: begin Resource.Get(No); UnitCost := Resource."Unit Cost"; Overhead := Resource."Unit Cost" - Resource."Direct Unit Cost"; IndirectCost := Resource."Indirect Cost %"; exit(false); end; end; end; procedure GetUnitOfMeasureCode(ComponentType: Enum "BOM Component Type"; ComponentNo: Code[20]; UseBaseUnitOfMeasure: Boolean): Code[10] var Item: Record Item; Resource: Record Resource; ItemUnitOfMeasure: Record "Item Unit of Measure"; ResourceUnitOfMeasure: Record "Resource Unit of Measure"; BOMComponent: Record "BOM Component"; begin case ComponentType of BOMComponent.Type::Item: begin Item.Get(ComponentNo); if UseBaseUnitOfMeasure then exit(Item."Base Unit of Measure"); ItemUnitOfMeasure.SetRange("Item No.", Item."No."); ItemUnitOfMeasure.SetFilter(Code, '<>%1', Item."Base Unit of Measure"); if ItemUnitOfMeasure.FindFirst() then exit(ItemUnitOfMeasure.Code); end; BOMComponent.Type::Resource: begin Resource.Get(ComponentNo); if UseBaseUnitOfMeasure then exit(Resource."Base Unit of Measure"); ResourceUnitOfMeasure.SetRange("Resource No.", Resource."No."); ResourceUnitOfMeasure.SetFilter(Code, '<>%1', Resource."Base Unit of Measure"); if ResourceUnitOfMeasure.FindFirst() then exit(ResourceUnitOfMeasure.Code); end end; exit(''); end; procedure GetAdjAmounts(var VarianceAmount: Decimal; var AdjAmount: Decimal; PostedAssemblyHeader: Record "Posted Assembly Header") var ValueEntry: Record "Value Entry"; DirectCostAmount: Decimal; OutputNotAdjAmount: Decimal; begin ValueEntry.Reset(); ValueEntry.SetRange("Document No.", PostedAssemblyHeader."No."); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", PostedAssemblyHeader."Order No."); ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost"); DirectCostAmount := 0; OutputNotAdjAmount := 0; if ValueEntry.FindSet() then repeat case ValueEntry."Item Ledger Entry Type" of ValueEntry."Item Ledger Entry Type"::" ": DirectCostAmount += -ValueEntry."Cost Amount (Actual)"; ValueEntry."Item Ledger Entry Type"::"Assembly Consumption": DirectCostAmount += ValueEntry."Cost Amount (Actual)"; ValueEntry."Item Ledger Entry Type"::"Assembly Output": if not ValueEntry.Adjustment then OutputNotAdjAmount += ValueEntry."Cost Amount (Actual)"; end; until ValueEntry.Next() = 0; AdjAmount := DirectCostAmount + OutputNotAdjAmount; VarianceAmount := DirectCostAmount + PostedAssemblyHeader."Cost Amount"; end; procedure GetCompsToAdjust(var ItemNo: array[10] of Code[20]; var ResourceNo: array[10] of Code[20]; AssemblyHeader: Record "Assembly Header"): Text[250] var AssemblyLine: Record "Assembly Line"; ItemFilter: Text[250]; i: Integer; begin AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); AssemblyLine.SetRange(Type, AssemblyLine.Type::Item); ItemFilter := AssemblyHeader."Item No."; i := 1; if AssemblyLine.FindSet() then repeat ItemNo[i] := AssemblyLine."No."; ItemFilter += '|' + ItemNo[i]; i += 1; until AssemblyLine.Next() = 0; ItemFilter := DelChr(ItemFilter, '>', '|'); i := 1; AssemblyLine.SetRange(Type, AssemblyLine.Type::Resource); if AssemblyLine.FindSet() then repeat ResourceNo[i] := AssemblyLine."No."; i += 1; until AssemblyLine.Next() = 0; exit(ItemFilter) end; local procedure GetValueEntriesAmount(PostedAssemblyHeader: Record "Posted Assembly Header"; ItemLedgerEntryType: Enum "Item Ledger Entry Type"; EntryType: Enum "Cost Entry Type"; VarianceType: Enum "Cost Variance Type"; ItemNo: Code[20]; PostedToGL: Boolean): Decimal var ValueEntry: Record "Value Entry"; Amount: Decimal; begin ValueEntry.Reset(); ValueEntry.SetRange("Document No.", PostedAssemblyHeader."No."); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", PostedAssemblyHeader."Order No."); ValueEntry.SetRange("Item Ledger Entry Type", ItemLedgerEntryType); ValueEntry.SetRange("Variance Type", VarianceType); ValueEntry.SetRange("Entry Type", EntryType); if ItemNo <> '' then ValueEntry.SetRange("Item No.", ItemNo); if PostedToGL then ValueEntry.SetFilter("Cost Posted to G/L", '<>%1', 0); Amount := 0; if ValueEntry.FindSet() then repeat Amount += ValueEntry."Cost Amount (Actual)"; until ValueEntry.Next() = 0; exit(Amount); end; procedure GetPostingSetup(var GeneralPostingSetup: Record "General Posting Setup"; var InventoryPostingSetup: Record "Inventory Posting Setup"; GenProdPostingGr: Code[20]; InvtPostingGroup: Code[20]; LocationCode: Code[10]) begin GeneralPostingSetup.Get('', GenProdPostingGr); InventoryPostingSetup.Get(LocationCode, InvtPostingGroup); end; procedure ModifyCostParams(ParentItemNo: Code[20]; CostAdjNeeded: Boolean; IndirectCost: Decimal; Overhead: Decimal) var Resource: Record Resource; BOMComponent: Record "BOM Component"; begin BOMComponent.SetRange("Parent Item No.", ParentItemNo); if BOMComponent.FindSet() then repeat case BOMComponent.Type of BOMComponent.Type::Item: ModifyItem(BOMComponent."No.", CostAdjNeeded, IndirectCost, Overhead); BOMComponent.Type::Resource: begin Resource.Get(BOMComponent."No."); Resource.Validate("Unit Price", Resource."Unit Price" + LibraryRandom.RandDec(10, 2)); if CostAdjNeeded then begin Resource.Validate("Direct Unit Cost", Resource."Direct Unit Cost" + LibraryRandom.RandDec(10, 2)); Resource.Validate("Indirect Cost %", IndirectCost); end; Resource.Modify(true); end end; until BOMComponent.Next() = 0; end; procedure ModifyItem(ItemNo: Code[20]; CostAdjNeeded: Boolean; IndirectCost: Decimal; Overhead: Decimal) var Item: Record Item; begin Item.Get(ItemNo); if CostAdjNeeded then begin Item.Validate("Indirect Cost %", IndirectCost); Item.Validate("Overhead Rate", Overhead); if Item."Costing Method" = Item."Costing Method"::Standard then Item.Validate("Standard Cost", Item."Standard Cost" + LibraryRandom.RandDec(10, 2)) else Item.Validate("Unit Cost", Item."Unit Cost" + LibraryRandom.RandDec(10, 2)); end; Item.Validate("Unit Price", Item."Unit Price" + LibraryRandom.RandDec(10, 2)); Item.Validate("Lot Size", Item."Lot Size" + LibraryRandom.RandInt(10)); Item.Modify(true); end; procedure ModifyOrderCostParams(AssemblyHeaderNo: Code[20]; CostAdjNeeded: Boolean; IndirectCost: Decimal; Overhead: Decimal) var Resource: Record Resource; AssemblyLine: Record "Assembly Line"; begin AssemblyLine.SetRange("Document Type", AssemblyLine."Document Type"::Order); AssemblyLine.SetRange("Document No.", AssemblyHeaderNo); if AssemblyLine.FindSet() then repeat case AssemblyLine.Type of AssemblyLine.Type::Item: ModifyItem(AssemblyLine."No.", CostAdjNeeded, IndirectCost, Overhead); AssemblyLine.Type::Resource: begin Resource.Get(AssemblyLine."No."); Resource.Validate("Indirect Cost %", IndirectCost); Resource.Validate("Unit Price", Resource."Unit Price" + LibraryRandom.RandDec(10, 2)); Resource.Validate("Unit Cost", Resource."Unit Cost" + LibraryRandom.RandDec(10, 2)); Resource.Modify(true); end end; until AssemblyLine.Next() = 0; end; procedure NeedsAdjustment(var AdjUnitCost: Decimal; Item: Record Item; PostedAssemblyLine: Record "Posted Assembly Line"; FinalAdjSource: Option; UnitCost: Decimal): Boolean begin if FinalAdjSource = AdjSource::Revaluation then AdjUnitCost := GetDirectUnitCost(Item."No.") - PostedAssemblyLine."Unit Cost" else AdjUnitCost := GetInboundItemCost(Item."No.") - PostedAssemblyLine."Unit Cost"; exit( Item."Cost is Adjusted" and (Abs(AdjUnitCost) > LibraryERM.GetAmountRoundingPrecision()) and (Abs(AdjUnitCost * PostedAssemblyLine.Quantity) >= LibraryERM.GetAmountRoundingPrecision()) ); end; local procedure GetInboundItemCost(ItemNo: Code[20]): Decimal var ItemLedgerEntry: Record "Item Ledger Entry"; begin ItemLedgerEntry.SetRange("Item No.", ItemNo); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Positive Adjmt."); ItemLedgerEntry.SetLoadFields(Quantity, "Cost Amount (Actual)", "Remaining Quantity"); ItemLedgerEntry.SetAutoCalcFields("Cost Amount (Actual)"); ItemLedgerEntry.FindFirst(); exit(ItemLedgerEntry.GetUnitCostLCY()); end; local procedure GetDirectUnitCost(ItemNo: Code[20]): Decimal var ValueEntry: Record "Value Entry"; begin ValueEntry.SetRange("Item No.", ItemNo); ValueEntry.SetRange("Entry Type", ValueEntry."Item Ledger Entry Type"::"Positive Adjmt."); ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost"); ValueEntry.SetLoadFields("Cost per Unit"); ValueEntry.FindFirst(); exit(ValueEntry."Cost per Unit"); end; procedure PostAssemblyHeader(AssemblyHeader: Record "Assembly Header"; ExpectedError: Text[1024]) var AssemblyPost: Codeunit "Assembly-Post"; begin if ExpectedError = '' then AssemblyPost.Run(AssemblyHeader) else begin #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits. asserterror AssemblyPost.Run(AssemblyHeader); #pragma warning restore AS0058, PTE0007 Assert.IsTrue(StrPos(GetLastErrorText, ExpectedError) > 0, 'Expected:' + ExpectedError + '. Actual:' + GetLastErrorText); ClearLastError(); end; Commit(); end; procedure PrepareOrderPosting(var AssemblyHeader: Record "Assembly Header"; var TempAssemblyLine: Record "Assembly Line" temporary; HeaderQtyFactor: Integer; CompQtyFactor: Integer; UpdateAllComps: Boolean; PostingDate: Date) var AssemblyLine: Record "Assembly Line"; begin TempAssemblyLine.DeleteAll(); AssemblyHeader.Validate("Quantity to Assemble", AssemblyHeader."Quantity to Assemble" * HeaderQtyFactor / 100); AssemblyHeader.Validate(Description, LibraryUtility.GenerateRandomCode(AssemblyHeader.FieldNo(Description), DATABASE::"Assembly Header")); AssemblyHeader.Validate("Posting Date", PostingDate); AddAssemblyHeaderComment(AssemblyHeader, 0); AssemblyHeader.Modify(true); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); if AssemblyLine.FindSet() then repeat AssemblyLine.Validate("Quantity to Consume", AssemblyLine.Quantity * CompQtyFactor / 100); AssemblyLine.Validate(Description, LibraryUtility.GenerateRandomCode(AssemblyLine.FieldNo(Description), DATABASE::"Assembly Line")); AddAssemblyHeaderComment(AssemblyHeader, AssemblyLine."Line No."); AssemblyLine.Modify(true); if AssemblyLine."Quantity to Consume" > 0 then begin TempAssemblyLine := AssemblyLine; TempAssemblyLine.Insert(); end; until (AssemblyLine.Next() = 0) or (not UpdateAllComps); end; procedure ReopenAO(var AssemblyHeader: Record "Assembly Header") var ReleaseAssemblyDoc: Codeunit "Release Assembly Document"; begin ReleaseAssemblyDoc.Reopen(AssemblyHeader); end; procedure ReleaseAO(var AssemblyHeader: Record "Assembly Header") begin CODEUNIT.Run(CODEUNIT::"Release Assembly Document", AssemblyHeader); end; procedure RevaluateItem(var Item: Record Item; var ItemJournalLine: Record "Item Journal Line"; OldUnitCost: Decimal; PostingDate: Date) var ItemJournalTemplate: Record "Item Journal Template"; ItemJournalBatch: Record "Item Journal Batch"; begin LibraryInventory.SelectItemJournalTemplateName(ItemJournalTemplate, ItemJournalTemplate.Type::Revaluation); LibraryInventory.SelectItemJournalBatchName(ItemJournalBatch, ItemJournalTemplate.Type::Revaluation, ItemJournalTemplate.Name); LibraryInventory.CreateItemJournalLine(ItemJournalLine, ItemJournalBatch."Journal Template Name", ItemJournalBatch.Name, ItemJournalLine."Entry Type"::Purchase, Item."No.", 0); Item.SetRange("No.", Item."No."); LibraryCosting.CreateRevaluationJnlLines( Item, ItemJournalLine, ItemJournalLine."Document No.", "Inventory Value Calc. Per"::Item, "Inventory Value Calc. Base"::" ", true, true, true, PostingDate); ItemJournalLine.Reset(); ItemJournalLine.SetRange("Journal Template Name", ItemJournalLine."Journal Template Name"); ItemJournalLine.SetRange("Journal Batch Name", ItemJournalLine."Journal Batch Name"); ItemJournalLine.SetRange("Item No.", Item."No."); ItemJournalLine.FindFirst(); ItemJournalLine.Validate("Unit Cost (Revalued)", OldUnitCost + LibraryRandom.RandInt(50)); ItemJournalLine.Modify(true); end; procedure RollUpAsmCost(var SalesLine: Record "Sales Line") begin SalesLine.RollUpAsmCost(); end; procedure RollUpAsmPrice(var SalesLine: Record "Sales Line") begin SalesLine.RollupAsmPrice(); end; procedure SetupComponents(var TempItem: Record Item temporary; var TempResource: Record Resource temporary; CostingMethod: Enum "Costing Method"; NoOfItems: Integer; NoOfResources: Integer; GenProdPostingGroup: Code[20]; InventoryPostingGroup: Code[20]) var Item: Record Item; Resource: Record Resource; AssemblyLine: Record "Assembly Line"; CompCount: Integer; begin TempItem.DeleteAll(); TempResource.DeleteAll(); for CompCount := 1 to NoOfItems do begin Clear(Item); CreateItem(Item, CostingMethod, Item."Replenishment System"::Purchase, GenProdPostingGroup, InventoryPostingGroup); AddEntityDimensions(AssemblyLine.Type::Item, Item."No."); TempItem := Item; TempItem.Insert(); end; for CompCount := 1 to NoOfResources do begin CreateResource(Resource, true, GenProdPostingGroup); AddEntityDimensions(AssemblyLine.Type::Resource, Resource."No."); TempResource := Resource; TempResource.Insert(); end; end; procedure CreateAssemblyOrder(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; LocationCode: Code[10]; NoOfItems: Integer) var Item: Record Item; begin SetupAssemblyItem( Item, Item."Costing Method"::Standard, Item."Costing Method"::Standard, Item."Replenishment System"::Assembly, LocationCode, false, NoOfItems, LibraryRandom.RandIntInRange(1, 3), LibraryRandom.RandIntInRange(1, 3), LibraryRandom.RandIntInRange(1, 10)); CreateAssemblyHeader(AssemblyHeader, DueDate, Item."No.", LocationCode, LibraryRandom.RandDec(10, 2), ''); end; procedure SetStockoutWarning(StockoutWarning: Boolean) var AssemblySetup: Record "Assembly Setup"; begin AssemblySetup.Get(); AssemblySetup.Validate("Stockout Warning", StockoutWarning); AssemblySetup.Modify(true); end; procedure SetupAssemblyData(var AssemblyHeader: Record "Assembly Header"; DueDate: Date; ParentCostingMethod: Enum "Costing Method"; CompCostingMethod: Enum "Costing Method"; ReplenishmentSystem: Enum "Replenishment System"; LocationCode: Code[10]; UpdateUnitCost: Boolean) var Item: Record Item; begin SetupAssemblyItem(Item, ParentCostingMethod, CompCostingMethod, ReplenishmentSystem, LocationCode, UpdateUnitCost, 1, 1, 1, 1); CreateAssemblyHeader(AssemblyHeader, DueDate, Item."No.", LocationCode, LibraryRandom.RandDec(10, 2), ''); end; procedure SetupAssemblyItem(var Item: Record Item; ParentCostingMethod: Enum "Costing Method"; CompCostingMethod: Enum "Costing Method"; ReplenishmentSystem: Enum "Replenishment System"; LocationCode: Code[10]; UpdateUnitCost: Boolean; NoOfItems: Integer; NoOfResources: Integer; NoOfTexts: Integer; QtyPerFactor: Integer) var AssemblyLine: Record "Assembly Line"; CalculateStandardCost: Codeunit "Calculate Standard Cost"; GenProdPostingGr: Code[20]; AsmInvtPostingGr: Code[20]; CompInvtPostingGr: Code[20]; begin SetupPostingToGL(GenProdPostingGr, AsmInvtPostingGr, CompInvtPostingGr, LocationCode); CreateItem(Item, ParentCostingMethod, ReplenishmentSystem, GenProdPostingGr, AsmInvtPostingGr); AddEntityDimensions(AssemblyLine.Type::Item, Item."No."); CreateAssemblyList( CompCostingMethod, Item."No.", true, NoOfItems, NoOfResources, NoOfTexts, QtyPerFactor, GenProdPostingGr, CompInvtPostingGr); if UpdateUnitCost then begin CalculateStandardCost.CalcItem(Item."No.", true); CalculateStandardCost.CalcAssemblyItemPrice(Item."No."); end; end; procedure SetupItemJournal(var ItemJournalTemplate: Record "Item Journal Template"; var ItemJournalBatch: Record "Item Journal Batch") var NoSeries: Record "No. Series"; NoSeriesLine: Record "No. Series Line"; begin Clear(ItemJournalTemplate); ItemJournalTemplate.Init(); LibraryInventory.SelectItemJournalTemplateName(ItemJournalTemplate, ItemJournalTemplate.Type::Item); Clear(ItemJournalBatch); ItemJournalBatch.Init(); LibraryInventory.SelectItemJournalBatchName(ItemJournalBatch, ItemJournalTemplate.Type, ItemJournalTemplate.Name); if ItemJournalBatch."No. Series" = '' then begin LibraryUtility.CreateNoSeries(NoSeries, true, true, true); LibraryUtility.CreateNoSeriesLine(NoSeriesLine, NoSeries.Code, '', ''); ItemJournalBatch.Validate("No. Series", NoSeries.Code); ItemJournalBatch.Modify(true); end; end; procedure SetupPostingToGL(var GenProdPostingGr: Code[20]; var AsmInvtPostingGr: Code[20]; var CompInvtPostingGr: Code[20]; LocationCode: Code[10]) var InventoryPostingGroup: Record "Inventory Posting Group"; GLAccount: Record "G/L Account"; GLAccount2: Record "G/L Account"; GLAccount3: Record "G/L Account"; GLAccount4: Record "G/L Account"; GLAccount5: Record "G/L Account"; GLAccount6: Record "G/L Account"; GeneralPostingSetup: Record "General Posting Setup"; InvtPostingSetup: Record "Inventory Posting Setup"; begin // Create Inventory posting setup accounts. // Assembly Item Inventory. CreateGLAccount(GLAccount, GLAccount."Income/Balance"::"Balance Sheet", 'Output Inventory'); // Material Variance. CreateGLAccount(GLAccount2, GLAccount."Income/Balance"::"Income Statement", 'Material Variance'); // Capacity Variance. CreateGLAccount(GLAccount3, GLAccount."Income/Balance"::"Income Statement", 'Capacity Variance'); // Capacity Overhead Variance. CreateGLAccount(GLAccount4, GLAccount."Income/Balance"::"Income Statement", 'Capacity Overhead Variance'); // Mfg. Overhead Variance. CreateGLAccount(GLAccount5, GLAccount."Income/Balance"::"Income Statement", 'Mfg. Overhead Variance'); // Inventory account (Interim) CreateGLAccount(GLAccount6, GLAccount."Income/Balance"::"Balance Sheet", 'Inventory Account (Interim)'); // Create Inventory Posting Group for Assembly Item. LibraryInventory.CreateInventoryPostingGroup(InventoryPostingGroup); AsmInvtPostingGr := InventoryPostingGroup.Code; // Create Inventory Posting Setup for Assembly Item. CreateInvtPostingSetup(InvtPostingSetup, LocationCode, InventoryPostingGroup.Code, GLAccount."No.", GLAccount2."No.", GLAccount3."No.", GLAccount4."No.", GLAccount5."No.", GLAccount6."No."); // Component Inventory Account. CreateGLAccount(GLAccount, GLAccount."Income/Balance"::"Balance Sheet", 'Component Item Inventory'); // Create Inventory Posting Group for Component. LibraryInventory.CreateInventoryPostingGroup(InventoryPostingGroup); CompInvtPostingGr := InventoryPostingGroup.Code; // Create Inventory Posting Setup for Assembly Item. CreateInvtPostingSetup(InvtPostingSetup, LocationCode, InventoryPostingGroup.Code, GLAccount."No.", GLAccount2."No.", GLAccount3."No.", GLAccount4."No.", GLAccount5."No.", GLAccount6."No."); LibraryERM.FindGeneralPostingSetupInvtToGL(GeneralPostingSetup); GenProdPostingGr := GeneralPostingSetup."Gen. Prod. Posting Group"; end; procedure UndoPostedAssembly(var PostedAssemblyHeader: Record "Posted Assembly Header"; RestoreAO: Boolean; ExpectedError: Text[1024]) var AsmPostCtrl: Codeunit "Assembly-Post"; begin Clear(AsmPostCtrl); if ExpectedError = '' then AsmPostCtrl.Undo(PostedAssemblyHeader, RestoreAO) else begin #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits. asserterror AsmPostCtrl.Undo(PostedAssemblyHeader, RestoreAO); #pragma warning restore AS0058, PTE0007 Assert.IsTrue(StrPos(GetLastErrorText, ExpectedError) > 0, 'Actual:' + GetLastErrorText); ClearLastError(); end; end; procedure UpdateOrderCost(var AssemblyHeader: Record "Assembly Header") var Item: Record Item; begin Commit(); if AssemblyHeader.Quantity = 0 then begin #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits. asserterror AssemblyHeader.UpdateUnitCost(); #pragma warning restore AS0058, PTE0007 Assert.AreEqual( StrSubstNo(ErrorZeroQty, AssemblyHeader."No."), GetLastErrorText, 'Actual:' + GetLastErrorText + '; Expected:' + StrSubstNo(ErrorZeroQty, AssemblyHeader."No.")); ClearLastError(); exit; end; Item.Get(AssemblyHeader."Item No."); if Item."Costing Method" <> Item."Costing Method"::Standard then AssemblyHeader.UpdateUnitCost() else begin #pragma warning disable AS0058, PTE0007 // Accepted violation: this is a test library helper that intentionally wraps asserterror for use by test codeunits. asserterror AssemblyHeader.UpdateUnitCost(); #pragma warning restore AS0058, PTE0007 Assert.IsTrue(StrPos(GetLastErrorText, ErrorStdCost) > 0, 'Actual:' + GetLastErrorText + '; Expected:' + ErrorStdCost); ClearLastError(); end; Commit(); end; procedure UpdateAssemblySetup(var AssemblySetup: Record "Assembly Setup"; LocationCode: Code[10]; DimensionsFrom: Option; PostedOrdersNos: Code[20]) begin AssemblySetup.Get(); if AssemblySetup."Assembly Order Nos." = '' then AssemblySetup.Validate("Assembly Order Nos.", LibraryUtility.GetGlobalNoSeriesCode()); AssemblySetup.Validate("Copy Component Dimensions from", DimensionsFrom); AssemblySetup.Validate("Default Location for Orders", LocationCode); AssemblySetup.Validate("Posted Assembly Order Nos.", PostedOrdersNos); AssemblySetup.Modify(true); end; procedure UpdateInventorySetup(var InventorySetup: Record "Inventory Setup"; AutomaticCostPosting: Boolean; ExpectedCostPostingtoGL: Boolean; AutomaticCostAdjustment: Enum "Automatic Cost Adjustment Type"; AverageCostCalcType: Enum "Average Cost Calculation Type"; AverageCostPeriod: Enum "Average Cost Period Type") begin InventorySetup.Get(); InventorySetup."Automatic Cost Posting" := AutomaticCostPosting; InventorySetup."Expected Cost Posting to G/L" := ExpectedCostPostingtoGL; InventorySetup."Automatic Cost Adjustment" := AutomaticCostAdjustment; InventorySetup."Average Cost Calc. Type" := AverageCostCalcType; InventorySetup."Average Cost Period" := AverageCostPeriod; InventorySetup.Modify(true); end; procedure UpdateAssemblyLine(var AssemblyLine: Record "Assembly Line"; FieldNo: Integer; Value: Variant) var RecRef: RecordRef; FieldRef: FieldRef; begin RecRef.GetTable(AssemblyLine); FieldRef := RecRef.Field(FieldNo); FieldRef.Validate(Value); RecRef.SetTable(AssemblyLine); AssemblyLine.Modify(true); end; procedure UpdateAssemblyHeader(var AssemblyHeader: Record "Assembly Header"; FieldNo: Integer; Value: Variant) var RecRef: RecordRef; FieldRef: FieldRef; begin RecRef.GetTable(AssemblyHeader); FieldRef := RecRef.Field(FieldNo); FieldRef.Validate(Value); RecRef.SetTable(AssemblyHeader); AssemblyHeader.Modify(true); end; procedure UpdateInvtPeriod(var InventoryPeriod: Record "Inventory Period"; ReOpen: Boolean) var ItemLedgerEntry: Record "Item Ledger Entry"; CloseInventoryPeriod: Codeunit "Close Inventory Period"; begin LibraryCosting.AdjustCostItemEntries('', ''); ItemLedgerEntry.SetRange(Open, true); if ItemLedgerEntry.FindFirst() then ItemLedgerEntry.Delete(); CloseInventoryPeriod.SetReOpen(ReOpen); CloseInventoryPeriod.SetHideDialog(true); CloseInventoryPeriod.Run(InventoryPeriod); if ReOpen then InventoryPeriod.Delete(); end; procedure UpdateSKUCards(Item: Record Item) var StockkeepingUnit: Record "Stockkeeping Unit"; begin StockkeepingUnit.SetRange("Item No.", Item."No."); if StockkeepingUnit.FindSet() then repeat if Item."Costing Method" = Item."Costing Method"::Standard then StockkeepingUnit.Validate("Standard Cost", Item."Standard Cost" + LibraryRandom.RandDec(10, 2)) else StockkeepingUnit.Validate("Unit Cost", Item."Unit Cost" + LibraryRandom.RandDec(10, 2)); StockkeepingUnit.Modify(true); until StockkeepingUnit.Next() = 0; end; procedure VerifytAsmReservationEntryATO(AssemblyHeader: Record "Assembly Header"): Integer var ReservationEntry: Record "Reservation Entry"; begin Clear(ReservationEntry); ReservationEntry.SetRange(Positive, true); ReservationEntry.SetRange("Item No.", AssemblyHeader."Item No."); ReservationEntry.SetRange(Description, AssemblyHeader.Description); ReservationEntry.SetRange("Location Code", AssemblyHeader."Location Code"); ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Reservation); ReservationEntry.SetRange("Source Type", DATABASE::"Assembly Header"); ReservationEntry.SetRange("Source Subtype", AssemblyHeader."Document Type"); ReservationEntry.SetRange("Source Ref. No.", 0); ReservationEntry.SetRange("Source ID", AssemblyHeader."No."); ReservationEntry.SetRange(Quantity, AssemblyHeader.Quantity); ReservationEntry.SetRange(Binding, ReservationEntry.Binding::"Order-to-Order"); ReservationEntry.SetRange("Planning Flexibility", ReservationEntry."Planning Flexibility"::None); ReservationEntry.SetRange("Shipment Date", AssemblyHeader."Due Date"); ReservationEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); ReservationEntry.SetRange("Disallow Cancellation", true); Assert.AreEqual(1, ReservationEntry.Count, 'Couldn''t find the AO reservation entry with the filters: ' + ReservationEntry.GetFilters); exit(ReservationEntry."Entry No."); end; procedure VerifyHardLinkEntry(SalesLine: Record "Sales Line"; AssemblyHeader: Record "Assembly Header"; NoOfEntries: Integer) var ATOLink: Record "Assemble-to-Order Link"; begin Clear(ATOLink); ATOLink.SetRange("Assembly Document Type", AssemblyHeader."Document Type"); ATOLink.SetRange("Assembly Document No.", AssemblyHeader."No."); ATOLink.SetRange(Type, ATOLink.Type::Sale); ATOLink.SetRange("Document Type", SalesLine."Document Type"); ATOLink.SetRange("Document No.", SalesLine."Document No."); ATOLink.SetRange("Document Line No.", SalesLine."Line No."); ATOLink.SetRange("Assembled Quantity", AssemblyHeader."Assembled Quantity"); Assert.AreEqual(NoOfEntries, ATOLink.Count, 'There are no ' + Format(NoOfEntries) + ' entries within the filter ' + ATOLink.GetFilters); end; procedure VerifySaleReservationEntryATO(SalesLine: Record "Sales Line"): Integer var ReservationEntry: Record "Reservation Entry"; begin Clear(ReservationEntry); ReservationEntry.SetRange(Positive, false); ReservationEntry.SetRange("Item No.", SalesLine."No."); ReservationEntry.SetRange(Description, SalesLine.Description); ReservationEntry.SetRange("Location Code", SalesLine."Location Code"); ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Reservation); ReservationEntry.SetRange("Source Type", DATABASE::"Sales Line"); ReservationEntry.SetRange("Source Subtype", SalesLine."Document Type"); ReservationEntry.SetRange("Source Ref. No.", SalesLine."Line No."); ReservationEntry.SetRange("Source ID", SalesLine."Document No."); ReservationEntry.SetRange(Quantity, -SalesLine."Qty. to Assemble to Order"); ReservationEntry.SetRange(Binding, ReservationEntry.Binding::"Order-to-Order"); ReservationEntry.SetRange("Planning Flexibility", ReservationEntry."Planning Flexibility"::None); ReservationEntry.SetRange("Shipment Date", SalesLine."Shipment Date"); ReservationEntry.SetRange("Variant Code", SalesLine."Variant Code"); ReservationEntry.SetRange("Disallow Cancellation", true); Assert.AreEqual(1, ReservationEntry.Count, 'Couldn''t find the SOL reservation entry with the filters: ' + ReservationEntry.GetFilters); exit(ReservationEntry."Entry No."); end; procedure VerifyEntityDimensions(TableID: Integer; EntityNo: Code[20]; ParentItemNo: Code[20]; CopyFromHeader: Boolean; DimensionSetID: Integer) var DefaultDimension: Record "Default Dimension"; DimensionSetEntry: Record "Dimension Set Entry"; begin if (TableID <= 0) or (DimensionSetID <= 0) then exit; LibraryDimension.FindDefaultDimension(DefaultDimension, TableID, EntityNo); if CopyFromHeader then LibraryDimension.FindDefaultDimension(DefaultDimension, 27, ParentItemNo); LibraryDimension.FindDimensionSetEntry(DimensionSetEntry, DimensionSetID); repeat DimensionSetEntry.SetRange("Dimension Code", DefaultDimension."Dimension Code"); DimensionSetEntry.SetRange("Dimension Value Code", DefaultDimension."Dimension Value Code"); Assert.AreEqual( 1, DimensionSetEntry.Count, 'Wrong no. of dimension set entries for dimension ' + Format(DefaultDimension."Dimension Code")); until DefaultDimension.Next() = 0; end; procedure VerifyILEs(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) begin VerifyILEsGeneric(TempAssemblyLine, AssemblyHeader, AssembledQty, false); end; procedure VerifyILEsGeneric(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal; IsATO: Boolean) var ItemLedgerEntry: Record "Item Ledger Entry"; begin // General filtering. ItemLedgerEntry.Reset(); ItemLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ItemLedgerEntry.SetRange("Source No.", AssemblyHeader."Item No."); ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Item); ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly); ItemLedgerEntry.SetRange("Order No.", AssemblyHeader."No."); ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0); // Output entry. ItemLedgerEntry.SetRange("Item No.", AssemblyHeader."Item No."); ItemLedgerEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Output"); ItemLedgerEntry.SetRange("Location Code", AssemblyHeader."Location Code"); ItemLedgerEntry.SetRange(Quantity, AssembledQty); ItemLedgerEntry.SetRange("Invoiced Quantity", AssembledQty); ItemLedgerEntry.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code"); ItemLedgerEntry.SetRange("Document Line No.", 0); ItemLedgerEntry.SetRange("Order Line No.", 0); ItemLedgerEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID"); ItemLedgerEntry.SetRange("Assemble to Order", false); if IsATO then begin ItemLedgerEntry.SetRange("Remaining Quantity", 0); ItemLedgerEntry.SetRange(Open, false); end else begin ItemLedgerEntry.SetRange("Remaining Quantity", AssembledQty); ItemLedgerEntry.SetRange(Open, true); end; Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of output entries for item ' + AssemblyHeader."Item No."); ItemLedgerEntry.FindFirst(); VerifyApplicationEntry(ItemLedgerEntry); // Consumption entries. // Find posted assembly lines. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item); if TempAssemblyLine.FindSet() then repeat Clear(ItemLedgerEntry); ItemLedgerEntry.SetRange("Item No.", TempAssemblyLine."No."); ItemLedgerEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code"); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Consumption"); ItemLedgerEntry.SetRange("Location Code", TempAssemblyLine."Location Code"); ItemLedgerEntry.SetRange(Quantity, -TempAssemblyLine."Quantity to Consume (Base)"); ItemLedgerEntry.SetRange("Remaining Quantity", 0); ItemLedgerEntry.SetRange("Invoiced Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ItemLedgerEntry.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code"); ItemLedgerEntry.SetRange(Open, false); ItemLedgerEntry.SetRange("Document Line No.", TempAssemblyLine."Line No."); ItemLedgerEntry.SetRange("Order Line No.", TempAssemblyLine."Line No."); ItemLedgerEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); ItemLedgerEntry.SetRange("Assemble to Order", false); Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of consumpt. ILEs for item ' + TempAssemblyLine."No."); ItemLedgerEntry.FindFirst(); VerifyApplicationEntry(ItemLedgerEntry); until TempAssemblyLine.Next() = 0; end; procedure VerifyILEsForAsmOnATO(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) begin VerifyILEsGeneric(TempAssemblyLine, AssemblyHeader, AssembledQty, true); end; procedure VerifyILEsUndo(var TempPostedAssemblyHeader: Record "Posted Assembly Header" temporary; var TempPostedAssemblyLine: Record "Posted Assembly Line" temporary; UndoEntries: Boolean) var ItemLedgerEntry: Record "Item Ledger Entry"; begin // General filtering. ItemLedgerEntry.Reset(); ItemLedgerEntry.SetRange("Posting Date", TempPostedAssemblyHeader."Posting Date"); ItemLedgerEntry.SetRange("Source No.", TempPostedAssemblyHeader."Item No."); ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Item); ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly); ItemLedgerEntry.SetRange("Order No.", TempPostedAssemblyHeader."Order No."); ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0); // Output entry. ItemLedgerEntry.SetRange("Item No.", TempPostedAssemblyHeader."Item No."); ItemLedgerEntry.SetRange("Variant Code", TempPostedAssemblyHeader."Variant Code"); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Output"); ItemLedgerEntry.SetRange("Location Code", TempPostedAssemblyHeader."Location Code"); if UndoEntries then begin ItemLedgerEntry.SetRange(Quantity, -TempPostedAssemblyHeader."Quantity (Base)"); ItemLedgerEntry.SetRange("Invoiced Quantity", -TempPostedAssemblyHeader."Quantity (Base)"); end else begin ItemLedgerEntry.SetRange(Quantity, TempPostedAssemblyHeader."Quantity (Base)"); ItemLedgerEntry.SetRange("Invoiced Quantity", TempPostedAssemblyHeader."Quantity (Base)"); end; ItemLedgerEntry.SetRange("Assemble to Order", false); ItemLedgerEntry.SetRange("Unit of Measure Code", TempPostedAssemblyHeader."Unit of Measure Code"); ItemLedgerEntry.SetRange("Document Line No.", 0); ItemLedgerEntry.SetRange("Order Line No.", 0); ItemLedgerEntry.SetRange("Dimension Set ID", TempPostedAssemblyHeader."Dimension Set ID"); ItemLedgerEntry.SetRange("Remaining Quantity", 0); ItemLedgerEntry.SetRange(Open, false); ItemLedgerEntry.SetRange(Correction, UndoEntries); Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of output entries for item ' + TempPostedAssemblyHeader."Item No."); // Verify application entries ItemLedgerEntry.FindFirst(); VerifyApplicationEntryUndo(ItemLedgerEntry); // Consumption entries. // Find posted assembly lines. TempPostedAssemblyLine.SetRange(Type, TempPostedAssemblyLine.Type::Item); if TempPostedAssemblyLine.FindSet() then repeat Clear(ItemLedgerEntry); ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly); ItemLedgerEntry.SetRange("Order No.", TempPostedAssemblyHeader."Order No."); ItemLedgerEntry.SetRange("Item No.", TempPostedAssemblyLine."No."); ItemLedgerEntry.SetRange("Variant Code", TempPostedAssemblyLine."Variant Code"); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Consumption"); ItemLedgerEntry.SetRange("Location Code", TempPostedAssemblyLine."Location Code"); if UndoEntries then begin ItemLedgerEntry.SetRange(Quantity, TempPostedAssemblyLine."Quantity (Base)"); ItemLedgerEntry.SetRange("Remaining Quantity", TempPostedAssemblyLine."Quantity (Base)"); ItemLedgerEntry.SetRange("Invoiced Quantity", TempPostedAssemblyLine."Quantity (Base)"); end else begin ItemLedgerEntry.SetRange(Quantity, -TempPostedAssemblyLine."Quantity (Base)"); ItemLedgerEntry.SetRange("Remaining Quantity", 0); ItemLedgerEntry.SetRange("Invoiced Quantity", -TempPostedAssemblyLine."Quantity (Base)"); end; ItemLedgerEntry.SetRange("Assemble to Order", false); ItemLedgerEntry.SetRange("Unit of Measure Code", TempPostedAssemblyLine."Unit of Measure Code"); ItemLedgerEntry.SetRange(Open, UndoEntries); ItemLedgerEntry.SetRange(Correction, UndoEntries); ItemLedgerEntry.SetRange("Document Line No.", TempPostedAssemblyLine."Line No."); ItemLedgerEntry.SetRange("Order Line No.", TempPostedAssemblyLine."Line No."); ItemLedgerEntry.SetRange("Dimension Set ID", TempPostedAssemblyLine."Dimension Set ID"); Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of consumpt. ILEs for item ' + TempPostedAssemblyLine."No."); ItemLedgerEntry.FindFirst(); VerifyApplicationEntryUndo(ItemLedgerEntry); until TempPostedAssemblyLine.Next() = 0; end; procedure VerifyILEATOAndSale(AssemblyHeader: Record "Assembly Header"; SalesLine: Record "Sales Line"; AssembledQty: Decimal; Invoiced: Boolean; NoOfLines: Integer) var ItemLedgerEntry: Record "Item Ledger Entry"; begin // General filtering. ItemLedgerEntry.Reset(); ItemLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ItemLedgerEntry.SetRange("Source No.", AssemblyHeader."Item No."); ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Item); ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly); ItemLedgerEntry.SetRange("Order No.", AssemblyHeader."No."); ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0); // Output entry. ItemLedgerEntry.SetRange("Item No.", AssemblyHeader."Item No."); ItemLedgerEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::"Assembly Output"); ItemLedgerEntry.SetRange("Location Code", AssemblyHeader."Location Code"); ItemLedgerEntry.SetRange(Quantity, AssembledQty); ItemLedgerEntry.SetRange("Invoiced Quantity", AssembledQty); ItemLedgerEntry.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code"); ItemLedgerEntry.SetRange("Document Line No.", 0); ItemLedgerEntry.SetRange("Order Line No.", 0); ItemLedgerEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID"); ItemLedgerEntry.SetRange("Assemble to Order", false); ItemLedgerEntry.SetRange("Remaining Quantity", 0); ItemLedgerEntry.SetRange(Open, false); Assert.AreEqual(NoOfLines, ItemLedgerEntry.Count, 'Wrong no. of output entries for item ' + AssemblyHeader."Item No."); if ItemLedgerEntry.FindSet() then repeat VerifyILESale(SalesLine, AssembledQty, ItemLedgerEntry."Entry No.", true, Invoiced); until ItemLedgerEntry.Next() = 0; end; procedure VerifyILESale(SalesLine: Record "Sales Line"; AssembledQty: Decimal; EntryNo: Integer; IsAto: Boolean; Invoiced: Boolean) var ItemLedgerEntry: Record "Item Ledger Entry"; begin // General filtering. ItemLedgerEntry.Reset(); ItemLedgerEntry.SetRange("Source No.", SalesLine."Sell-to Customer No."); ItemLedgerEntry.SetRange("Source Type", ItemLedgerEntry."Source Type"::Customer); ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::" "); ItemLedgerEntry.SetRange("Cost Amount (Expected)", 0); // Output entry. ItemLedgerEntry.SetRange("Item No.", SalesLine."No."); ItemLedgerEntry.SetRange("Variant Code", SalesLine."Variant Code"); ItemLedgerEntry.SetRange("Entry Type", ItemLedgerEntry."Entry Type"::Sale); ItemLedgerEntry.SetRange("Location Code", SalesLine."Location Code"); ItemLedgerEntry.SetRange(Quantity, -AssembledQty); if Invoiced then ItemLedgerEntry.SetRange("Invoiced Quantity", -AssembledQty) else ItemLedgerEntry.SetRange("Invoiced Quantity", 0); ItemLedgerEntry.SetRange("Unit of Measure Code", SalesLine."Unit of Measure Code"); ItemLedgerEntry.SetRange("Document Line No.", SalesLine."Line No."); ItemLedgerEntry.SetRange("Order Line No.", 0); ItemLedgerEntry.SetRange("Dimension Set ID", SalesLine."Dimension Set ID"); ItemLedgerEntry.SetRange("Assemble to Order", IsAto); ItemLedgerEntry.SetRange(Open, not IsAto); if IsAto then ItemLedgerEntry.SetRange("Remaining Quantity", 0) else ItemLedgerEntry.SetRange("Remaining Quantity", -AssembledQty); ItemLedgerEntry.SetRange("Applies-to Entry", EntryNo); Assert.AreEqual(1, ItemLedgerEntry.Count, 'Wrong no. of sale entries for item ' + SalesLine."No."); end; procedure VerifySKUCost(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header") var Item: Record Item; UnitCost: Decimal; Overhead: Decimal; IndirectCost: Decimal; begin // Check header item SKU cost. Item.Get(AssemblyHeader."Item No."); GetCostInformation(UnitCost, Overhead, IndirectCost, "BOM Component Type"::Item, AssemblyHeader."Item No.", AssemblyHeader."Variant Code", AssemblyHeader."Location Code"); if Item."Costing Method" = Item."Costing Method"::Standard then AssemblyHeader.TestField("Unit Cost", UnitCost); // Check item components SKU cost. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item); if TempAssemblyLine.FindSet() then repeat GetCostInformation(UnitCost, Overhead, IndirectCost, "BOM Component Type"::Item, TempAssemblyLine."No.", TempAssemblyLine."Variant Code", TempAssemblyLine."Location Code"); TempAssemblyLine.TestField("Unit Cost", UnitCost); until TempAssemblyLine.Next() = 0 end; procedure VerifyValueEntries(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) begin VerifyValueEntriesAsm(TempAssemblyLine, AssemblyHeader, AssembledQty); end; procedure VerifyValueEntriesAsm(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) var ValueEntry: Record "Value Entry"; begin ValueEntry.Reset(); // General filtering. ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ValueEntry.SetRange("Source No.", AssemblyHeader."Item No."); ValueEntry.SetRange("Source Type", ValueEntry."Source Type"::Item); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", AssemblyHeader."No."); ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost"); // Output entry. ValueEntry.SetRange("Item No.", AssemblyHeader."Item No."); ValueEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Output"); ValueEntry.SetRange("Location Code", AssemblyHeader."Location Code"); ValueEntry.SetRange("Valued Quantity", AssembledQty); ValueEntry.SetRange("Item Ledger Entry Quantity", AssembledQty); ValueEntry.SetRange("Invoiced Quantity", AssembledQty); ValueEntry.SetRange("Document Line No.", 0); ValueEntry.SetRange("Order Line No.", 0); ValueEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID"); ValueEntry.SetRange(Adjustment, false); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of output value entries for item' + AssemblyHeader."Item No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(Round(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity, LibraryERM.GetAmountRoundingPrecision()), ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for header.'); // Consumption value entries for items. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item); if TempAssemblyLine.FindSet() then repeat ValueEntry.SetRange("Item No.", TempAssemblyLine."No."); ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Consumption"); ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code"); ValueEntry.SetRange("Valued Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ValueEntry.SetRange("Item Ledger Entry Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ValueEntry.SetRange("Invoiced Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of consumpt. value entries for item' + TempAssemblyLine."No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual( TempAssemblyLine."Cost Amount" * Round(TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity), -ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for item ' + TempAssemblyLine."No."); until TempAssemblyLine.Next() = 0; // Consumption value entries for resources. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource); if TempAssemblyLine.FindSet() then repeat ValueEntry.SetRange("Item No.", ''); ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::" "); ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code"); ValueEntry.SetRange(Description, TempAssemblyLine.Description); ValueEntry.SetRange("Valued Quantity", TempAssemblyLine."Quantity to Consume"); ValueEntry.SetRange("Item Ledger Entry Quantity", 0); ValueEntry.SetRange("Invoiced Quantity", TempAssemblyLine."Quantity to Consume"); ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); ValueEntry.SetRange(Type, ValueEntry.Type::Resource); ValueEntry.SetRange("No.", TempAssemblyLine."No."); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of res. consumpt. value entries for res. ' + TempAssemblyLine."No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity, ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for res. ' + TempAssemblyLine."No."); until TempAssemblyLine.Next() = 0; end; procedure VerifyValueEntriesATO(var TempAssemblyLine: Record "Assembly Line" temporary; SalesHeader: Record "Sales Header"; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) begin VerifyValueEntriesAsm(TempAssemblyLine, AssemblyHeader, AssembledQty); VerifyValueEntriesSale(SalesHeader, AssemblyHeader, AssembledQty); end; procedure VerifyValueEntriesSale(SalesHeader: Record "Sales Header"; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) var ValueEntry: Record "Value Entry"; begin ValueEntry.Reset(); ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ValueEntry.SetRange("Source No.", SalesHeader."Sell-to Customer No."); ValueEntry.SetRange("Source Type", ValueEntry."Source Type"::Customer); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::" "); ValueEntry.SetRange("Order No.", ''); ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost"); ValueEntry.SetRange("Item No.", AssemblyHeader."Item No."); ValueEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::Sale); ValueEntry.SetRange("Location Code", AssemblyHeader."Location Code"); ValueEntry.SetRange("Valued Quantity", -AssembledQty); ValueEntry.SetRange("Item Ledger Entry Quantity", -AssembledQty); ValueEntry.SetRange("Invoiced Quantity", -AssembledQty); ValueEntry.SetRange(Adjustment, false); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of sales value entries for item' + AssemblyHeader."Item No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(Round(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity, LibraryERM.GetAmountRoundingPrecision()), ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for header.'); end; procedure VerifyValueEntriesUndo(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) var ValueEntry: Record "Value Entry"; begin ValueEntry.Reset(); // General filtering. ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ValueEntry.SetRange("Source No.", AssemblyHeader."Item No."); ValueEntry.SetRange("Source Type", ValueEntry."Source Type"::Item); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", AssemblyHeader."No."); ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost"); // Output entry. ValueEntry.SetRange("Item No.", AssemblyHeader."Item No."); ValueEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Output"); ValueEntry.SetRange("Location Code", AssemblyHeader."Location Code"); ValueEntry.SetRange("Valued Quantity", AssembledQty); ValueEntry.SetRange("Item Ledger Entry Quantity", AssembledQty); ValueEntry.SetRange("Invoiced Quantity", AssembledQty); ValueEntry.SetRange("Document Line No.", 0); ValueEntry.SetRange("Order Line No.", 0); ValueEntry.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID"); ValueEntry.SetRange(Adjustment, false); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of output value entries for item' + AssemblyHeader."Item No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(Round(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity, LibraryERM.GetAmountRoundingPrecision()), ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for header.'); // Consumption value entries for items. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item); if TempAssemblyLine.FindSet() then repeat ValueEntry.SetRange("Item No.", TempAssemblyLine."No."); ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Assembly Consumption"); ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code"); ValueEntry.SetRange("Valued Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ValueEntry.SetRange("Item Ledger Entry Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ValueEntry.SetRange("Invoiced Quantity", -TempAssemblyLine."Quantity to Consume (Base)"); ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of consumpt. value entries for item' + TempAssemblyLine."No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(Round(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity, LibraryERM.GetAmountRoundingPrecision()), -ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for item ' + TempAssemblyLine."No."); until TempAssemblyLine.Next() = 0; // Consumption value entries for resources. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource); if TempAssemblyLine.FindSet() then repeat ValueEntry.SetRange("Item No.", ''); ValueEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::" "); ValueEntry.SetRange("Location Code", TempAssemblyLine."Location Code"); ValueEntry.SetRange(Description, TempAssemblyLine.Description); ValueEntry.SetRange("Valued Quantity", TempAssemblyLine."Quantity to Consume"); ValueEntry.SetRange("Item Ledger Entry Quantity", 0); ValueEntry.SetRange("Invoiced Quantity", TempAssemblyLine."Quantity to Consume"); ValueEntry.SetRange("Document Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Order Line No.", TempAssemblyLine."Line No."); ValueEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); ValueEntry.SetRange(Type, ValueEntry.Type::Resource); ValueEntry.SetRange("No.", TempAssemblyLine."No."); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of res. consumpt. value entries for res. ' + TempAssemblyLine."No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity, ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong value entry cost amount for res. ' + TempAssemblyLine."No."); until TempAssemblyLine.Next() = 0; end; procedure VerifyResEntries(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header") begin VerifyResEntriesGeneric(TempAssemblyLine, AssemblyHeader, false); end; procedure VerifyResEntriesATO(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header") begin VerifyResEntriesGeneric(TempAssemblyLine, AssemblyHeader, true); end; procedure VerifyResEntriesGeneric(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; IsATO: Boolean) var ResLedgerEntry: Record "Res. Ledger Entry"; SourceCodeSetup: Record "Source Code Setup"; begin SourceCodeSetup.Get(); ResLedgerEntry.Reset(); // General filtering. ResLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ResLedgerEntry.SetRange("Order Type", ResLedgerEntry."Order Type"::Assembly); ResLedgerEntry.SetRange("Order No.", AssemblyHeader."No."); ResLedgerEntry.SetRange("Entry Type", ResLedgerEntry."Entry Type"::Usage); if IsATO then ResLedgerEntry.SetRange("Source Code", SourceCodeSetup.Sales) else ResLedgerEntry.SetRange("Source Code", SourceCodeSetup.Assembly); // Usage entries. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource); if TempAssemblyLine.FindSet() then repeat ResLedgerEntry.SetRange("Resource No.", TempAssemblyLine."No."); ResLedgerEntry.SetRange(Quantity, TempAssemblyLine."Quantity to Consume"); ResLedgerEntry.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code"); if not IsATO then begin // if ATO then dimensions can come from SOL also - skip checking them ResLedgerEntry.SetRange("Global Dimension 1 Code", TempAssemblyLine."Shortcut Dimension 1 Code"); ResLedgerEntry.SetRange("Global Dimension 2 Code", TempAssemblyLine."Shortcut Dimension 2 Code"); ResLedgerEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); end; ResLedgerEntry.SetRange("Order Line No.", TempAssemblyLine."Line No."); Assert.AreEqual(1, ResLedgerEntry.Count, 'Wrong no. of res ledger entries for res. ' + TempAssemblyLine."No."); ResLedgerEntry.FindFirst(); Assert.AreNearlyEqual(Round(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity, LibraryERM.GetAmountRoundingPrecision()), ResLedgerEntry."Total Cost", LibraryERM.GetAmountRoundingPrecision(), 'Wrong Res. Ledger Cost amount for res. ' + TempAssemblyLine."No.") until TempAssemblyLine.Next() = 0; end; procedure VerifyCapEntries(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header") begin VerifyCapEntriesGeneric(TempAssemblyLine, AssemblyHeader, false); end; procedure VerifyCapEntriesATO(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header") begin VerifyCapEntriesGeneric(TempAssemblyLine, AssemblyHeader, true); end; procedure VerifyCapEntriesGeneric(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; IsATO: Boolean) var CapacityLedgerEntry: Record "Capacity Ledger Entry"; begin CapacityLedgerEntry.Reset(); // General filtering. CapacityLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); CapacityLedgerEntry.SetRange(Type, CapacityLedgerEntry.Type::Resource); CapacityLedgerEntry.SetRange("Item No.", AssemblyHeader."Item No."); CapacityLedgerEntry.SetRange("Variant Code", AssemblyHeader."Variant Code"); CapacityLedgerEntry.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code"); CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Assembly); CapacityLedgerEntry.SetRange("Order No.", AssemblyHeader."No."); // Usage entries. TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Resource); if TempAssemblyLine.FindSet() then repeat CapacityLedgerEntry.SetRange("No.", TempAssemblyLine."No."); CapacityLedgerEntry.SetRange(Description, TempAssemblyLine.Description); CapacityLedgerEntry.SetRange(Quantity, TempAssemblyLine."Quantity to Consume"); CapacityLedgerEntry.SetRange("Invoiced Quantity", TempAssemblyLine."Quantity to Consume"); CapacityLedgerEntry.SetRange("Cap. Unit of Measure Code", TempAssemblyLine."Unit of Measure Code"); if not IsATO then begin // if ATO then dimensions can come from SOL also - skip checking them CapacityLedgerEntry.SetRange("Global Dimension 1 Code", TempAssemblyLine."Shortcut Dimension 1 Code"); CapacityLedgerEntry.SetRange("Global Dimension 2 Code", TempAssemblyLine."Shortcut Dimension 2 Code"); CapacityLedgerEntry.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); end; Assert.AreEqual(1, CapacityLedgerEntry.Count, 'Wrong no. of capacity ledger entries for res. ' + TempAssemblyLine."No."); CapacityLedgerEntry.FindFirst(); CapacityLedgerEntry.CalcFields("Direct Cost"); Assert.AreNearlyEqual(TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity, CapacityLedgerEntry."Direct Cost", LibraryERM.GetAmountRoundingPrecision(), 'Wrong Cap. Ledger Cost amount for res. ' + TempAssemblyLine."No.") until TempAssemblyLine.Next() = 0; end; procedure VerifyCapEntriesUndo(var TempPostedAssemblyHeader: Record "Posted Assembly Header" temporary; var TempPostedAssemblyLine: Record "Posted Assembly Line" temporary; IsUndo: Boolean) var CapacityLedgerEntry: Record "Capacity Ledger Entry"; begin CapacityLedgerEntry.Reset(); // General filtering. CapacityLedgerEntry.SetRange("Posting Date", TempPostedAssemblyHeader."Posting Date"); CapacityLedgerEntry.SetRange(Type, CapacityLedgerEntry.Type::Resource); CapacityLedgerEntry.SetRange("Item No.", TempPostedAssemblyHeader."Item No."); CapacityLedgerEntry.SetRange("Variant Code", TempPostedAssemblyHeader."Variant Code"); CapacityLedgerEntry.SetRange("Unit of Measure Code", TempPostedAssemblyHeader."Unit of Measure Code"); CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Assembly); CapacityLedgerEntry.SetRange("Order No.", TempPostedAssemblyHeader."Order No."); // Usage entries. TempPostedAssemblyLine.SetRange(Type, TempPostedAssemblyLine.Type::Resource); if TempPostedAssemblyLine.FindSet() then repeat CapacityLedgerEntry.SetRange("No.", TempPostedAssemblyLine."No."); CapacityLedgerEntry.SetRange(Description, TempPostedAssemblyLine.Description); CapacityLedgerEntry.SetRange("Cap. Unit of Measure Code", TempPostedAssemblyLine."Unit of Measure Code"); CapacityLedgerEntry.SetRange("Global Dimension 1 Code", TempPostedAssemblyLine."Shortcut Dimension 1 Code"); CapacityLedgerEntry.SetRange("Global Dimension 2 Code", TempPostedAssemblyLine."Shortcut Dimension 2 Code"); CapacityLedgerEntry.SetRange("Dimension Set ID", TempPostedAssemblyLine."Dimension Set ID"); if IsUndo then begin CapacityLedgerEntry.SetRange(Quantity, -TempPostedAssemblyLine."Quantity (Base)"); CapacityLedgerEntry.SetRange("Invoiced Quantity", -TempPostedAssemblyLine."Quantity (Base)"); end else begin CapacityLedgerEntry.SetRange(Quantity, TempPostedAssemblyLine."Quantity (Base)"); CapacityLedgerEntry.SetRange("Invoiced Quantity", TempPostedAssemblyLine."Quantity (Base)"); end; Assert.AreEqual(1, CapacityLedgerEntry.Count, 'Wrong no. of capacity ledger entries for res. ' + TempPostedAssemblyLine."No."); until TempPostedAssemblyLine.Next() = 0; end; procedure VerifyComments(AssemblyHeader: Record "Assembly Header") var AssemblyLine: Record "Assembly Line"; begin VerifyLineComment(AssemblyHeader, 0); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); if AssemblyLine.FindSet() then repeat VerifyLineComment(AssemblyHeader, AssemblyLine."Line No."); until AssemblyLine.Next() = 0; end; procedure VerifyLineComment(AssemblyHeader: Record "Assembly Header"; AssemblyLineNo: Integer) var AssemblyCommentLine: Record "Assembly Comment Line"; begin AssemblyCommentLine.Reset(); AssemblyCommentLine.SetRange("Document Type", AssemblyCommentLine."Document Type"::"Assembly Order"); AssemblyCommentLine.SetRange("Document No.", AssemblyHeader."No."); AssemblyCommentLine.SetRange("Document Line No.", AssemblyLineNo); AssemblyCommentLine.SetRange(Comment, 'Order:' + AssemblyHeader."No." + ', Line:' + Format(AssemblyLineNo)); AssemblyCommentLine.FindFirst(); Assert.AreEqual(1, AssemblyCommentLine.Count, 'Wrong no. of comment lines.'); end; procedure VerifyItemRegister(AssemblyHeader: Record "Assembly Header") var SourceCodeSetup: Record "Source Code Setup"; ItemLedgerEntry: Record "Item Ledger Entry"; CapacityLedgerEntry: Record "Capacity Ledger Entry"; ValueEntry: Record "Value Entry"; ItemRegister: Record "Item Register"; ILEMin: Integer; ILEMax: Integer; ValueEntryMin: Integer; ValueEntryMax: Integer; CapEntryMin: Integer; CapEntryMax: Integer; begin SourceCodeSetup.Get(); ItemLedgerEntry.Reset(); ItemLedgerEntry.SetRange("Order Type", ItemLedgerEntry."Order Type"::Assembly); ItemLedgerEntry.SetRange("Order No.", AssemblyHeader."No."); ItemLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); if ItemLedgerEntry.FindFirst() then ILEMin := ItemLedgerEntry."Entry No."; if ItemLedgerEntry.FindLast() then ILEMax := ItemLedgerEntry."Entry No."; ValueEntry.Reset(); ValueEntry.SetRange("Order Type", ValueEntry."Order Type"::Assembly); ValueEntry.SetRange("Order No.", AssemblyHeader."No."); ValueEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); ValueEntry.SetRange("Source Code", SourceCodeSetup.Assembly); if ValueEntry.FindFirst() then ValueEntryMin := ValueEntry."Entry No."; if ValueEntry.FindLast() then ValueEntryMax := ValueEntry."Entry No."; CapacityLedgerEntry.Reset(); CapacityLedgerEntry.SetRange("Order Type", CapacityLedgerEntry."Order Type"::Assembly); CapacityLedgerEntry.SetRange("Order No.", AssemblyHeader."No."); CapacityLedgerEntry.SetRange("Posting Date", AssemblyHeader."Posting Date"); if CapacityLedgerEntry.FindFirst() then CapEntryMin := CapacityLedgerEntry."Entry No."; if CapacityLedgerEntry.FindLast() then CapEntryMax := CapacityLedgerEntry."Entry No."; ItemRegister.Reset(); ItemRegister.SetRange("From Entry No.", ILEMin); ItemRegister.SetRange("To Entry No.", ILEMax); ItemRegister.SetRange("From Value Entry No.", ValueEntryMin); ItemRegister.SetRange("To Value Entry No.", ValueEntryMax); ItemRegister.SetRange("From Capacity Entry No.", CapEntryMin); ItemRegister.SetRange("To Capacity Entry No.", CapEntryMax); ItemRegister.SetRange("Source Code", SourceCodeSetup.Assembly); ItemRegister.FindFirst(); end; procedure VerifyApplicationEntry(ItemLedgerEntry: Record "Item Ledger Entry") var ItemApplicationEntry: Record "Item Application Entry"; begin ItemApplicationEntry.Reset(); ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity); case ItemLedgerEntry."Entry Type" of ItemLedgerEntry."Entry Type"::"Assembly Consumption": ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No."); ItemLedgerEntry."Entry Type"::"Assembly Output": begin ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange("Outbound Item Entry No.", 0); end; end; ItemApplicationEntry.FindFirst(); Assert.AreEqual(1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No.")); end; procedure VerifyApplicationEntryUndo(ItemLedgerEntry: Record "Item Ledger Entry") var ItemApplicationEntry: Record "Item Application Entry"; begin ItemApplicationEntry.Reset(); case ItemLedgerEntry."Entry Type" of ItemLedgerEntry."Entry Type"::"Assembly Consumption": if ItemLedgerEntry.Correction then begin // Check reversed entry ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity); ItemApplicationEntry.FindFirst(); Assert.AreEqual( 1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No.")); end else begin // Check initial posted entry ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity); ItemApplicationEntry.FindFirst(); Assert.AreEqual( 1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No.")); end; ItemLedgerEntry."Entry Type"::"Assembly Output": if ItemLedgerEntry.Correction then begin // Check reversed entry ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange("Outbound Item Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity); ItemApplicationEntry.FindFirst(); Assert.AreEqual( 1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No.")); end else begin // Check initial posted entry ItemApplicationEntry.SetRange("Item Ledger Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange("Outbound Item Entry No.", 0); ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntry."Entry No."); ItemApplicationEntry.SetRange(Quantity, ItemLedgerEntry.Quantity); Assert.AreEqual( 1, ItemApplicationEntry.Count, 'Wrong no. of application entries for ILE no ' + Format(ItemLedgerEntry."Entry No.")); end; end; end; procedure VerifyPostedLineComment(PostedAssemblyHeader: Record "Posted Assembly Header"; PostedAssemblyLineNo: Integer) var AssemblyCommentLine: Record "Assembly Comment Line"; begin AssemblyCommentLine.Reset(); AssemblyCommentLine.SetRange("Document Type", AssemblyCommentLine."Document Type"::"Posted Assembly"); AssemblyCommentLine.SetRange("Document No.", PostedAssemblyHeader."No."); AssemblyCommentLine.SetRange("Document Line No.", PostedAssemblyLineNo); AssemblyCommentLine.SetRange(Comment, 'Order:' + PostedAssemblyHeader."Order No." + ', Line:' + Format(PostedAssemblyLineNo)); AssemblyCommentLine.FindFirst(); Assert.AreEqual(1, AssemblyCommentLine.Count, 'Wrong no. of comment lines.'); end; procedure VerifyGLEntries(PostedAssemblyHeader: Record "Posted Assembly Header"; PerPostingGroup: Boolean) var GLEntry: Record "G/L Entry"; PostedAssemblyLine: Record "Posted Assembly Line"; InventoryPostingSetup: Record "Inventory Posting Setup"; GeneralPostingSetup: Record "General Posting Setup"; ValueEntry: Record "Value Entry"; TotalAmount: Decimal; OutputDirectCost: Decimal; ResDirectCost: Decimal; ItemDirectCost: Decimal; CompDirectCost: Decimal; OutputIndirectCost: Decimal; CompIndirectCost: Decimal; MaterialVariance: Decimal; CapacityVariance: Decimal; CapOverhead: Decimal; ManufOverhead: Decimal; begin // Get expected posting accounts for assembly item. GetPostingSetup(GeneralPostingSetup, InventoryPostingSetup, PostedAssemblyHeader."Gen. Prod. Posting Group", PostedAssemblyHeader."Inventory Posting Group", PostedAssemblyHeader."Location Code"); // Get output costs. OutputDirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", true); OutputIndirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", true); MaterialVariance := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::Material, PostedAssemblyHeader."Item No.", true); CapacityVariance := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::Capacity, PostedAssemblyHeader."Item No.", true); CapOverhead := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::"Capacity Overhead", PostedAssemblyHeader."Item No.", true); ManufOverhead := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::Variance, ValueEntry."Variance Type"::"Manufacturing Overhead", PostedAssemblyHeader."Item No.", true); // Get component costs. ResDirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::" ", ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", '', true); ItemDirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Consumption", ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", '', true); // Get consumption direct and indirect costs. CompDirectCost := -ItemDirectCost + ResDirectCost; CompIndirectCost := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Consumption", ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", '', true) + GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::" ", ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", '', true); // Verify GL entries. // Verify Inventory Account for output. VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Inventory Account", PostedAssemblyHeader."Posting Date", OutputDirectCost + OutputIndirectCost + MaterialVariance + CapacityVariance + CapOverhead + ManufOverhead, '<>'); // Verify Material variance account for header. VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Material Variance Account", PostedAssemblyHeader."Posting Date", -MaterialVariance, '<>'); // Verify Capacity variance account for header. VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Capacity Variance Account", PostedAssemblyHeader."Posting Date", -CapacityVariance, '<>'); // Verify Capacity overhead variance account for header. VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Cap. Overhead Variance Account", PostedAssemblyHeader. "Posting Date", -CapOverhead, '<>'); // Verify Mfg. overhead variance account for header. VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Mfg. Overhead Variance Account", PostedAssemblyHeader. "Posting Date", -ManufOverhead, '<>'); // Verify Inventory Adjustment account, both header and component. VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Inventory Adjmt. Account", PostedAssemblyHeader."Posting Date", CompDirectCost + CompIndirectCost - OutputDirectCost, '<>'); // Verify Overhead applied account, both header and component. VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Overhead Applied Account", PostedAssemblyHeader."Posting Date", -OutputIndirectCost - CompIndirectCost, '<>'); // Verify consumption entries. PostedAssemblyLine.Reset(); PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No."); PostedAssemblyLine.SetRange("Order No.", PostedAssemblyHeader."Order No."); PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Item); if PostedAssemblyLine.FindFirst() then GetPostingSetup(GeneralPostingSetup, InventoryPostingSetup, PostedAssemblyLine."Gen. Prod. Posting Group", PostedAssemblyLine."Inventory Posting Group", PostedAssemblyLine."Location Code"); // Verify cost aggregation under the document no. for 'Per posting group' option in posting. ValueEntry.SetRange("Item No.", PostedAssemblyLine."No."); ValueEntry.SetRange("Variant Code", PostedAssemblyLine."Variant Code"); ValueEntry.SetRange("Location Code", PostedAssemblyLine."Location Code"); ValueEntry.SetRange("Item Ledger Entry Type", ValueEntry."Item Ledger Entry Type"::"Positive Adjmt."); ValueEntry.SetRange("Entry Type", ValueEntry."Entry Type"::"Direct Cost"); if ValueEntry.FindFirst() and PerPostingGroup then VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Inventory Adjmt. Account", ValueEntry."Posting Date", -ValueEntry."Cost Amount (Actual)", '<>'); // Verify Inventory account for item consumption. VerifyGLEntry(PostedAssemblyHeader."No.", InventoryPostingSetup."Inventory Account", PostedAssemblyHeader."Posting Date", ItemDirectCost, '<>'); // Verify Direct Cost account for resource consumption. VerifyGLEntry(PostedAssemblyHeader."No.", GeneralPostingSetup."Direct Cost Applied Account", PostedAssemblyHeader."Posting Date", -ResDirectCost, '<>'); // Check G/L transaction is balanced. GLEntry.SetCurrentKey("Document No.", "Posting Date"); GLEntry.SetRange("Document No.", PostedAssemblyHeader."No."); GLEntry.SetRange("Posting Date", PostedAssemblyHeader."Posting Date"); GLEntry.FindSet(); repeat TotalAmount += GLEntry.Amount; until GLEntry.Next() = 0; Assert.AreEqual(0, TotalAmount, 'Transaction must be balanced:' + PostedAssemblyHeader."No."); end; procedure VerifyGLEntry(DocumentNo: Code[20]; AccountNo: Code[20]; PostingDate: Date; Amount: Decimal; Sign: Text[30]) var GLEntry: Record "G/L Entry"; ActualAmount: Decimal; begin ActualAmount := 0; GLEntry.Reset(); GLEntry.SetRange("Document No.", DocumentNo); GLEntry.SetRange("G/L Account No.", AccountNo); GLEntry.SetRange("Posting Date", PostingDate); GLEntry.SetFilter(Amount, Sign + '%1', 0); if GLEntry.FindSet() then repeat ActualAmount += GLEntry.Amount; until GLEntry.Next() = 0; Assert.AreNearlyEqual(Amount, ActualAmount, LibraryERM.GetAmountRoundingPrecision(), 'Account:' + AccountNo); end; procedure VerifyLineAdjustmentEntry(PostedAssemblyLine: Record "Posted Assembly Line"; FinalAdjSource: Option) var Item: Record Item; ValueEntry: Record "Value Entry"; UnitCost: Decimal; Overhead: Decimal; IndirectCost: Decimal; AdjUnitCost: Decimal; begin Item.Get(PostedAssemblyLine."No."); GetCostInformation(UnitCost, Overhead, IndirectCost, "BOM Component Type"::Item, PostedAssemblyLine."No.", PostedAssemblyLine."Variant Code", PostedAssemblyLine."Location Code"); FindLineValueEntries(ValueEntry, PostedAssemblyLine, ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Item Ledger Entry Type"::"Assembly Consumption"); ValueEntry.SetRange(Adjustment, true); if NeedsAdjustment(AdjUnitCost, Item, PostedAssemblyLine, FinalAdjSource, UnitCost) then begin Assert.AreEqual(1, ValueEntry.Count, 'Different than 1 entry for comp. item no. ' + PostedAssemblyLine."No."); ValueEntry.FindFirst(); Assert.AreNearlyEqual(Abs(AdjUnitCost), Abs(ValueEntry."Cost per Unit"), LibraryERM.GetAmountRoundingPrecision(), 'Wrong unit cost for adj.'); // Currently system's absolute error for "Cost Amount (Actual)" depends on ValueEntry."Valued Quantity" and GLSetup."Unit-amount rounding precision" Assert.AreNearlyEqual( ValueEntry."Cost Amount (Actual)", ValueEntry."Cost per Unit" * ValueEntry."Valued Quantity", LibraryERM.GetUnitAmountRoundingPrecision() * ValueEntry."Valued Quantity", 'Wrong adj. entry cost amount.'); end else begin // For differences in adj. amount less than 0.01, eliminate rounding adjustment entries. ValueEntry.SetFilter("Cost Amount (Actual)", '>%1', LibraryERM.GetAmountRoundingPrecision()); Assert.IsTrue(ValueEntry.IsEmpty, 'Unexpected adj. entries for comp item no. ' + PostedAssemblyLine."No."); end; end; procedure VerifyAdjustmentEntries(AssemblyHeader: Record "Assembly Header"; FinalAdjSource: Option) var PostedAssemblyHeader: Record "Posted Assembly Header"; PostedAssemblyLine: Record "Posted Assembly Line"; Item: Record Item; StockkeepingUnit: Record "Stockkeeping Unit"; AdjAmount: Decimal; VarianceAmount: Decimal; begin Commit(); PostedAssemblyHeader.Reset(); PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No."); PostedAssemblyHeader.SetRange("Item No.", AssemblyHeader."Item No."); PostedAssemblyHeader.SetRange("Variant Code", AssemblyHeader."Variant Code"); PostedAssemblyHeader.FindFirst(); PostedAssemblyLine.Reset(); PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No."); PostedAssemblyLine.SetRange("Order No.", AssemblyHeader."No."); PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Item); PostedAssemblyLine.SetFilter("No.", '<>%1', AssemblyHeader."Item No."); // Skip validation for auto consumption. if PostedAssemblyLine.FindSet() then repeat VerifyLineAdjustmentEntry(PostedAssemblyLine, FinalAdjSource); until PostedAssemblyLine.Next() = 0; GetAdjAmounts(VarianceAmount, AdjAmount, PostedAssemblyHeader); VerifyHeaderAdjustmentEntry(PostedAssemblyHeader, AdjAmount); Item.Get(AssemblyHeader."Item No."); if Item."Costing Method" = Item."Costing Method"::Standard then begin if StockkeepingUnit.Get(PostedAssemblyHeader."Location Code", Item."No.", PostedAssemblyHeader."Variant Code") then VarianceAmount := VarianceAmount - PostedAssemblyHeader."Cost Amount" + Item."Standard Cost" * PostedAssemblyHeader.Quantity; VerifyHeaderVarianceEntry(PostedAssemblyHeader, VarianceAmount); end; end; procedure VerifyHeaderAdjustmentEntry(PostedAssemblyHeader: Record "Posted Assembly Header"; AdjAmount: Decimal) var ValueEntry: Record "Value Entry"; begin FindHeaderValueEntries(ValueEntry, PostedAssemblyHeader, ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Item Ledger Entry Type"::"Assembly Output"); ValueEntry.SetRange(Adjustment, true); if AdjAmount <> 0 then begin ValueEntry.FindFirst(); Assert.AreEqual(1, ValueEntry.Count, 'Wrong no. of adjustment entries for header.'); Assert.AreNearlyEqual(-AdjAmount, ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong header adj. entry cost amount.'); // Currently system's absolute error for "Cost Amount (Actual)" depends on ValueEntry."Valued Quantity" and GLSetup."Unit-amount rounding precision" Assert.AreNearlyEqual( ValueEntry."Cost Amount (Actual)", ValueEntry."Cost per Unit" * ValueEntry."Valued Quantity", LibraryERM.GetUnitAmountRoundingPrecision() * ValueEntry."Valued Quantity", 'Wrong header adj. entry cost per unit.'); end else Assert.IsTrue(ValueEntry.IsEmpty, 'Unexpected adj. entries for header ' + PostedAssemblyHeader."No."); end; procedure VerifyHeaderVarianceEntry(PostedAssemblyHeader: Record "Posted Assembly Header"; VarianceAmount: Decimal) var ValueEntry: Record "Value Entry"; ActualVarianceAmount: Decimal; begin FindHeaderValueEntries(ValueEntry, PostedAssemblyHeader, ValueEntry."Entry Type"::Variance, ValueEntry."Item Ledger Entry Type"::"Assembly Output"); ValueEntry.SetRange(Adjustment, true); if VarianceAmount <> 0 then begin ValueEntry.FindSet(); ActualVarianceAmount := 0; repeat ActualVarianceAmount += ValueEntry."Cost Amount (Actual)"; until ValueEntry.Next() = 0; Assert.AreNearlyEqual(VarianceAmount, ActualVarianceAmount, LibraryERM.GetAmountRoundingPrecision(), 'Wrong variance entry cost amount for header.'); end else Assert.IsTrue(ValueEntry.IsEmpty, 'Unexpected variance entry for ' + PostedAssemblyHeader."No."); end; procedure VerifyIndirectCostEntries(AssemblyHeader: Record "Assembly Header") var ValueEntry: Record "Value Entry"; PostedAssemblyLine: Record "Posted Assembly Line"; PostedAssemblyHeader: Record "Posted Assembly Header"; Resource: Record Resource; IndirectCostAmount: Decimal; UnitCost: Decimal; Overhead: Decimal; IndirectCost: Decimal; ActualIndirectCostAmount: Decimal; begin GetCostInformation(UnitCost, Overhead, IndirectCost, PostedAssemblyLine.Type::Item, AssemblyHeader."Item No.", AssemblyHeader."Variant Code", AssemblyHeader."Location Code"); PostedAssemblyHeader.Reset(); PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No."); PostedAssemblyHeader.FindFirst(); // Output indirect cost. IndirectCostAmount := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", false) * IndirectCost / 100; ActualIndirectCostAmount := GetValueEntriesAmount(PostedAssemblyHeader, ValueEntry."Item Ledger Entry Type"::"Assembly Output", ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Variance Type"::" ", PostedAssemblyHeader."Item No.", false); Assert.AreNearlyEqual(IndirectCostAmount, ActualIndirectCostAmount, LibraryERM.GetAmountRoundingPrecision(), 'Wrong Output indirect cost'); // Resource component indirect cost. PostedAssemblyLine.Reset(); PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No."); PostedAssemblyLine.SetRange("Order No.", PostedAssemblyHeader."Order No."); PostedAssemblyLine.SetRange(Type, PostedAssemblyLine.Type::Resource); if PostedAssemblyLine.FindSet() then repeat FindLineValueEntries(ValueEntry, PostedAssemblyLine, ValueEntry."Entry Type"::"Direct Cost", ValueEntry."Item Ledger Entry Type"::" "); ValueEntry.FindFirst(); Resource.Get(PostedAssemblyLine."No."); IndirectCostAmount := ValueEntry."Cost Amount (Actual)" * Resource."Indirect Cost %" / 100; FindLineValueEntries(ValueEntry, PostedAssemblyLine, ValueEntry."Entry Type"::"Indirect Cost", ValueEntry."Item Ledger Entry Type"::" "); if ValueEntry.FindFirst() then Assert.AreNearlyEqual(IndirectCostAmount, ValueEntry."Cost Amount (Actual)", LibraryERM.GetAmountRoundingPrecision(), 'Wrong component indirect cost'); until PostedAssemblyLine.Next() = 0; end; procedure VerifyPartialPosting(AssemblyHeader: Record "Assembly Header"; HeaderQtyFactor: Decimal) var AssemblyLine: Record "Assembly Line"; begin if HeaderQtyFactor <> 100 then begin AssemblyHeader.Get(AssemblyHeader."Document Type", AssemblyHeader."No."); AssemblyHeader.TestField("Quantity to Assemble", AssemblyHeader.Quantity * (100 - HeaderQtyFactor) / 100); AssemblyHeader.TestField("Remaining Quantity", AssemblyHeader."Quantity to Assemble"); AssemblyLine.SetRange("Document Type", AssemblyHeader."Document Type"); AssemblyLine.SetRange("Document No.", AssemblyHeader."No."); AssemblyLine.FindSet(); repeat if AssemblyLine."Resource Usage Type" <> AssemblyLine."Resource Usage Type"::Fixed then begin Assert.AreNearlyEqual(AssemblyHeader.Quantity * AssemblyHeader."Qty. per Unit of Measure" * AssemblyLine."Quantity per", AssemblyLine.Quantity, LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line quantity.'); Assert.AreNearlyEqual( AssemblyHeader."Remaining Quantity" * AssemblyHeader."Qty. per Unit of Measure" * AssemblyLine."Quantity per", AssemblyLine."Quantity to Consume", LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line qty. to consume.'); end else begin Assert.AreNearlyEqual(AssemblyLine."Quantity per", AssemblyLine.Quantity, LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line qty. - fixed.'); Assert.AreNearlyEqual( AssemblyLine.Quantity - AssemblyLine."Consumed Quantity", AssemblyLine."Quantity to Consume", LibraryERM.GetUnitAmountRoundingPrecision(), 'Wrong partial line qty. to consume - fixed.'); end; until AssemblyLine.Next() = 0; end; end; procedure VerifyPostedAssemblyHeader(var TempAssemblyLine: Record "Assembly Line" temporary; AssemblyHeader: Record "Assembly Header"; AssembledQty: Decimal) var PostedAssemblyLine: Record "Posted Assembly Line"; PostedAssemblyHeader: Record "Posted Assembly Header"; begin PostedAssemblyHeader.Reset(); PostedAssemblyHeader.SetRange("Order No.", AssemblyHeader."No."); PostedAssemblyHeader.SetRange("Item No.", AssemblyHeader."Item No."); PostedAssemblyHeader.SetRange("Variant Code", AssemblyHeader."Variant Code"); PostedAssemblyHeader.SetRange(Description, AssemblyHeader.Description); PostedAssemblyHeader.SetRange("Inventory Posting Group", AssemblyHeader."Inventory Posting Group"); PostedAssemblyHeader.SetRange("Gen. Prod. Posting Group", AssemblyHeader."Gen. Prod. Posting Group"); PostedAssemblyHeader.SetRange("Location Code", AssemblyHeader."Location Code"); PostedAssemblyHeader.SetRange("Shortcut Dimension 1 Code", AssemblyHeader."Shortcut Dimension 1 Code"); PostedAssemblyHeader.SetRange("Shortcut Dimension 2 Code", AssemblyHeader."Shortcut Dimension 2 Code"); PostedAssemblyHeader.SetRange("Posting Date", AssemblyHeader."Posting Date"); PostedAssemblyHeader.SetRange(Quantity, AssembledQty); PostedAssemblyHeader.SetRange("Unit Cost", AssemblyHeader."Unit Cost"); PostedAssemblyHeader.SetRange("Unit of Measure Code", AssemblyHeader."Unit of Measure Code"); PostedAssemblyHeader.SetRange("Dimension Set ID", AssemblyHeader."Dimension Set ID"); Assert.AreEqual(1, PostedAssemblyHeader.Count, 'Wrong no. of posted assembly order records!'); PostedAssemblyHeader.FindFirst(); Assert.AreNearlyEqual(AssemblyHeader."Cost Amount" * AssembledQty / AssemblyHeader.Quantity, PostedAssemblyHeader."Cost Amount", LibraryERM.GetAmountRoundingPrecision(), 'Wrong posted cost amount.'); if TempAssemblyLine.FindSet() then repeat PostedAssemblyLine.Reset(); PostedAssemblyLine.SetRange("Document No.", PostedAssemblyHeader."No."); PostedAssemblyLine.SetRange("Order Line No.", TempAssemblyLine."Line No."); PostedAssemblyLine.SetRange(Type, TempAssemblyLine.Type); PostedAssemblyLine.SetRange("No.", TempAssemblyLine."No."); PostedAssemblyLine.SetRange("Variant Code", TempAssemblyLine."Variant Code"); PostedAssemblyLine.SetRange(Description, TempAssemblyLine.Description); PostedAssemblyLine.SetRange("Resource Usage Type", TempAssemblyLine."Resource Usage Type"); PostedAssemblyLine.SetRange("Location Code", TempAssemblyLine."Location Code"); PostedAssemblyLine.SetRange("Shortcut Dimension 1 Code", TempAssemblyLine."Shortcut Dimension 1 Code"); PostedAssemblyLine.SetRange("Shortcut Dimension 2 Code", TempAssemblyLine."Shortcut Dimension 2 Code"); PostedAssemblyLine.SetRange(Quantity, TempAssemblyLine."Quantity to Consume"); PostedAssemblyLine.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code"); PostedAssemblyLine.SetRange("Dimension Set ID", TempAssemblyLine."Dimension Set ID"); PostedAssemblyLine.SetRange("Unit Cost", TempAssemblyLine."Unit Cost"); Assert.AreEqual(1, PostedAssemblyLine.Count, 'Wrong no. of posted lines for ' + TempAssemblyLine."No."); PostedAssemblyLine.FindFirst(); // Do not check cost amount for comment lines. if TempAssemblyLine.Type <> TempAssemblyLine.Type::" " then Assert.AreNearlyEqual( TempAssemblyLine."Cost Amount" * TempAssemblyLine."Quantity to Consume" / TempAssemblyLine.Quantity, PostedAssemblyLine."Cost Amount", LibraryERM.GetAmountRoundingPrecision(), 'Wrong posted line cost amount.'); until TempAssemblyLine.Next() = 0; end; procedure VerifyPostedComments(AssemblyHeader: Record "Assembly Header") var PostedAssemblyLine: Record "Posted Assembly Line"; PostedAssemblyHeader: Record "Posted Assembly Header"; begin FindPostedAssemblyHeaders(PostedAssemblyHeader, AssemblyHeader); PostedAssemblyHeader.FindFirst(); VerifyPostedLineComment(PostedAssemblyHeader, 0); FindPostedAssemblyLines(PostedAssemblyLine, PostedAssemblyHeader); if PostedAssemblyLine.FindSet() then repeat VerifyPostedLineComment(PostedAssemblyHeader, PostedAssemblyLine."Line No."); until PostedAssemblyLine.Next() = 0; end; procedure VerifyWarehouseEntries(var TempAssemblyHeader: Record "Assembly Header" temporary; var TempAssemblyLine: Record "Assembly Line" temporary; IsUndo: Boolean) var WarehouseEntry: Record "Warehouse Entry"; SourceCodeSetup: Record "Source Code Setup"; begin SourceCodeSetup.Get(); WarehouseEntry.Reset(); WarehouseEntry.SetRange("Source Code", SourceCodeSetup.Assembly); WarehouseEntry.SetRange("Source No.", TempAssemblyHeader."No."); WarehouseEntry.SetRange("Registering Date", TempAssemblyHeader."Posting Date"); WarehouseEntry.SetRange("User ID", UserId); WarehouseEntry.SetRange("Variant Code", TempAssemblyHeader."Variant Code"); WarehouseEntry.SetRange("Unit of Measure Code", TempAssemblyHeader."Unit of Measure Code"); if IsUndo then begin WarehouseEntry.SetRange(Quantity, -TempAssemblyHeader."Quantity to Assemble"); WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Negative Adjmt.") end else begin WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Positive Adjmt."); WarehouseEntry.SetRange(Quantity, TempAssemblyHeader."Quantity to Assemble"); end; WarehouseEntry.SetRange("Location Code", TempAssemblyHeader."Location Code"); WarehouseEntry.SetRange("Bin Code", TempAssemblyHeader."Bin Code"); WarehouseEntry.SetRange( "Zone Code", LibraryWarehouse.GetZoneForBin(TempAssemblyHeader."Location Code", TempAssemblyHeader."Bin Code")); WarehouseEntry.SetRange("Item No.", TempAssemblyHeader."Item No."); Assert.AreEqual(1, WarehouseEntry.Count, 'Incorect number of warehouse entries for assembly ' + TempAssemblyHeader."No."); // Verify warehouse entries for components TempAssemblyLine.Reset(); TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item); TempAssemblyLine.FindSet(); repeat WarehouseEntry.Reset(); WarehouseEntry.SetRange("Source Code", SourceCodeSetup.Assembly); WarehouseEntry.SetRange("Source No.", TempAssemblyHeader."No."); WarehouseEntry.SetRange("Registering Date", TempAssemblyHeader."Posting Date"); WarehouseEntry.SetRange("User ID", UserId); WarehouseEntry.SetRange("Variant Code", TempAssemblyLine."Variant Code"); WarehouseEntry.SetRange("Unit of Measure Code", TempAssemblyLine."Unit of Measure Code"); if IsUndo then begin WarehouseEntry.SetRange(Quantity, TempAssemblyLine."Quantity to Consume"); WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Positive Adjmt.") end else begin WarehouseEntry.SetRange(Quantity, -TempAssemblyLine."Quantity to Consume"); WarehouseEntry.SetRange("Entry Type", WarehouseEntry."Entry Type"::"Negative Adjmt."); end; WarehouseEntry.SetRange("Location Code", TempAssemblyLine."Location Code"); WarehouseEntry.SetRange("Bin Code", TempAssemblyLine."Bin Code"); WarehouseEntry.SetRange("Item No.", TempAssemblyLine."No."); Assert.AreEqual(1, WarehouseEntry.Count, 'Incorrect number of warehouse entries for assembly line ' + TempAssemblyLine."No."); until TempAssemblyLine.Next() = 0; end; procedure VerifyBinContent(LocationCode: Code[20]; BinCode: Code[20]; ItemNo: Code[20]; VariantCode: Code[10]; UOMCode: Code[10]; Quantity: Decimal) var BinContent: Record "Bin Content"; begin BinContent.Reset(); BinContent.SetRange("Location Code", LocationCode); BinContent.SetRange("Bin Code", BinCode); BinContent.SetRange("Item No.", ItemNo); BinContent.SetRange("Variant Code", VariantCode); BinContent.SetRange("Unit of Measure Code", UOMCode); if BinContent.FindFirst() then begin BinContent.CalcFields(Quantity); BinContent.TestField(Quantity, Quantity); end else Assert.AreEqual(Quantity, 0, 'Incorrect Bin Code Qty for Item: ' + ItemNo + ' in Bin: ' + BinCode); end; procedure VerifyBinContents(var TempAssemblyHeader: Record "Assembly Header" temporary; var TempAssemblyLine: Record "Assembly Line" temporary; AdditionalQty: Decimal) begin // This function has to be called after the AO has been posted and no other "output" qtities exist in inventory // Verify bin content for header assembly item does not exist VerifyBinContent( TempAssemblyHeader."Location Code", TempAssemblyHeader."Bin Code", TempAssemblyHeader."Item No.", TempAssemblyHeader."Variant Code", TempAssemblyHeader."Unit of Measure Code", 0); // Verify bin contents for components TempAssemblyLine.Reset(); TempAssemblyLine.SetRange(Type, TempAssemblyLine.Type::Item); TempAssemblyLine.FindSet(); repeat VerifyBinContent( TempAssemblyLine."Location Code", TempAssemblyLine."Bin Code", TempAssemblyLine."No.", TempAssemblyLine."Variant Code", TempAssemblyLine."Unit of Measure Code", AdditionalQty + TempAssemblyLine.Quantity); until TempAssemblyLine.Next() = 0; end; procedure SetLinkToLines(AsmHeader: Record "Assembly Header"; var AsmLine: Record "Assembly Line") begin AsmLine.SetRange("Document Type", AsmHeader."Document Type"); AsmLine.SetRange("Document No.", AsmHeader."No."); end; procedure EarliestAvailableDate(AsmHeader: Record "Assembly Header"; var AssemblyLine: Record "Assembly Line"; var ReturnQtyAvailable: Decimal; var EarliestDueDate: Date) var Item: Record Item; ReqLine: Record "Requisition Line"; LeadTimeMgt: Codeunit "Lead-Time Management"; LineAvailabilityDate: Date; LineStartingDate: Date; EarliestEndingDate: Date; EarliestStartingDate: Date; LineProportion: Decimal; Proportion: Decimal; GrossRequirement: Decimal; ScheduledRcpt: Decimal; ExpectedInventory: Decimal; LineAbleToAssemble: Decimal; LineInventory: Decimal; begin SetLinkToLines(AsmHeader, AssemblyLine); AssemblyLine.SetRange(Type, AssemblyLine.Type::Item); AssemblyLine.SetFilter("No.", '<>%1', ''); AssemblyLine.SetFilter("Quantity per", '<>%1', 0); Proportion := AsmHeader."Remaining Quantity"; if AssemblyLine.FindFirst() then repeat AssemblyLine.CalcAvailToAssemble( AsmHeader, Item, GrossRequirement, ScheduledRcpt, ExpectedInventory, LineInventory, LineAvailabilityDate, LineAbleToAssemble); LineProportion := LineAbleToAssemble; if LineProportion < Proportion then Proportion := LineProportion; if LineAvailabilityDate > 0D then begin LineStartingDate := CalcDate(AssemblyLine."Lead-Time Offset", LineAvailabilityDate); if LineStartingDate > EarliestStartingDate then EarliestStartingDate := LineStartingDate; // latest of all line starting dates end; until AssemblyLine.Next() = 0; ReturnQtyAvailable := Proportion; EarliestDueDate := 0D; if EarliestStartingDate > 0D then begin EarliestEndingDate := // earliest starting date + lead time calculation LeadTimeMgt.GetPlannedEndingDate( AsmHeader."Item No.", AsmHeader."Location Code", AsmHeader."Variant Code", '', LeadTimeMgt.ManufacturingLeadTime(AsmHeader."Item No.", AsmHeader."Location Code", AsmHeader."Variant Code"), ReqLine."Ref. Order Type"::Assembly, EarliestStartingDate); EarliestDueDate := // earliest ending date + (default) safety lead time LeadTimeMgt.GetPlannedDueDate( AsmHeader."Item No.", AsmHeader."Location Code", AsmHeader."Variant Code", EarliestEndingDate, '', ReqLine."Ref. Order Type"::Assembly); end; end; procedure ComponentsAvailable(AssemblyHeader: Record "Assembly Header"): Boolean var AssemblyLine: Record "Assembly Line"; ItemCheckAvail: Codeunit "Item-Check Avail."; Inventory: Decimal; GrossRequirement: Decimal; ReservedRequirement: Decimal; ScheduledReceipts: Decimal; ReservedReceipts: Decimal; QtyAvailToMake: Decimal; EarliestAvailableDateX: Date; begin SetLinkToLines(AssemblyHeader, AssemblyLine); ItemCheckAvail.AsmOrderCalculate(AssemblyHeader, Inventory, GrossRequirement, ReservedRequirement, ScheduledReceipts, ReservedReceipts); EarliestAvailableDate(AssemblyHeader, AssemblyLine, QtyAvailToMake, EarliestAvailableDateX); exit(QtyAvailToMake >= AssemblyHeader."Remaining Quantity"); end; procedure LineCount(AssemblyHeader: Record "Assembly Header"): Integer var AssemblyLine: Record "Assembly Line"; begin SetLinkToLines(AssemblyHeader, AssemblyLine); exit(AssemblyLine.Count); end; [IntegrationEvent(false, false)] local procedure OnBeforeInsertInventoryPostingSetup(var InventoryPostingSetup: Record "Inventory Posting Setup") begin end; [IntegrationEvent(false, false)] local procedure OnCreateMultipleLvlTreeOnCreateBOM(var Item: Record Item; NoOfComps: Integer; var BOMCreated: Boolean) begin end;}