Codeunit 80 Sales-Post
src/Layers/W1/BaseApp/Sales/Posting/SalesPost.Codeunit.al14,025 lines, Copyright (c) Microsoft Corporation. MIT
// ------------------------------------------------------------------------------------------------// Copyright (c) Microsoft Corporation. All rights reserved.// Licensed under the MIT License. See License.txt in the project root for license information.// ------------------------------------------------------------------------------------------------namespace Microsoft.Sales.Posting;using Microsoft.Assembly.Document;using Microsoft.Assembly.History;using Microsoft.Assembly.Posting;using Microsoft.CRM.Contact;using Microsoft.CRM.Opportunity;using Microsoft.CRM.Outlook;using Microsoft.CRM.Segment;using Microsoft.EServices.EDocument;using Microsoft.Finance.Analysis;using Microsoft.Finance.Currency;using Microsoft.Finance.Deferral;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Ledger;using Microsoft.Finance.GeneralLedger.Posting;using Microsoft.Finance.GeneralLedger.Preview;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Finance.ReceivablesPayables;using Microsoft.Finance.VAT.Calculation;using Microsoft.Finance.VAT.Setup;using Microsoft.FixedAssets.Depreciation;using Microsoft.FixedAssets.FixedAsset;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.BatchProcessing;using Microsoft.Foundation.ExtendedText;using Microsoft.Foundation.NoSeries;using Microsoft.Foundation.Reporting;using Microsoft.Foundation.UOM;using Microsoft.Integration.D365Sales;using Microsoft.Integration.Graph;using Microsoft.Intercompany;using Microsoft.Intercompany.GLAccount;using Microsoft.Intercompany.Inbox;using Microsoft.Intercompany.Outbox;using Microsoft.Intercompany.Partner;using Microsoft.Inventory.Analysis;using Microsoft.Inventory.Costing;using Microsoft.Inventory.Item;using Microsoft.Inventory.Journal;using Microsoft.Inventory.Ledger;using Microsoft.Inventory.Location;using Microsoft.Inventory.Posting;using Microsoft.Inventory.Setup;using Microsoft.Inventory.Tracking;using Microsoft.Projects.Project.Archive;using Microsoft.Projects.Project.Job;using Microsoft.Projects.Project.Posting;using Microsoft.Projects.Resources.Journal;using Microsoft.Purchases.Comment;using Microsoft.Purchases.Document;using Microsoft.Purchases.History;using Microsoft.Purchases.Posting;using Microsoft.Purchases.Setup;using Microsoft.Purchases.Vendor;using Microsoft.Sales.Comment;using Microsoft.Sales.Customer;using Microsoft.Sales.Document;using Microsoft.Sales.History;using Microsoft.Sales.Receivables;using Microsoft.Sales.Setup;using Microsoft.Utilities;using Microsoft.Warehouse.Activity;using Microsoft.Warehouse.Availability;using Microsoft.Warehouse.Document;using Microsoft.Warehouse.History;using Microsoft.Warehouse.Journal;using Microsoft.Warehouse.Request;using Microsoft.Warehouse.Setup;using System.Automation;using System.Email;using System.Environment.Configuration;using System.Utilities;/// <summary>/// Posts sales documents by creating ledger entries for customers, items, resources, fixed assets, and the general ledger./// </summary>codeunit 80 "Sales-Post"{ Permissions = TableData "Sales Header" = rimd, TableData "Sales Line" = rimd, TableData "Purchase Header" = rm, TableData "Purchase Line" = rm, TableData "Sales Shipment Header" = rimd, TableData "Sales Shipment Line" = rimd, TableData "Sales Invoice Header" = rimd, TableData "Sales Invoice Line" = rimd, TableData "Sales Cr.Memo Header" = rimd, TableData "Sales Cr.Memo Line" = rimd, TableData "Purch. Rcpt. Header" = rimd, TableData "Purch. Rcpt. Line" = rimd, TableData "Drop Shpt. Post. Buffer" = rimd, TableData "General Posting Setup" = rimd, TableData "Posted Assemble-to-Order Link" = ri, TableData "Item Entry Relation" = ri, TableData "Value Entry Relation" = rid, TableData "Return Receipt Header" = rimd, TableData "Return Receipt Line" = rimd, TableData "G/L Entry" = r, Tabledata Job = r; TableNo = "Sales Header"; EventSubscriberInstance = Manual; trigger OnRun() begin RunWithCheck(Rec); end; var#pragma warning disable AA0470 PostingLinesMsg: Label 'Posting lines #2######\', Comment = 'Counter'; PostingSalesAndVATMsg: Label 'Posting sales and VAT #3######\', Comment = 'Counter'; PostingCustomersMsg: Label 'Posting to customers #4######\', Comment = 'Counter'; PostingBalAccountMsg: Label 'Posting to bal. account #5######', Comment = 'Counter'; PostingLines2Msg: Label 'Posting lines #2######', Comment = 'Counter';#pragma warning restore AA0470 InvoiceNoMsg: Label '%1 %2 -> Invoice %3', Comment = '%1 = Document Type, %2 = Document No, %3 = Invoice No.'; CreditMemoNoMsg: Label '%1 %2 -> Credit Memo %3', Comment = '%1 = Document Type, %2 = Document No, %3 = Credit Memo No.'; DropShipmentErr: Label 'You cannot ship sales order line %1. The line is marked as a drop shipment and is not yet associated with a purchase order.', Comment = '%1 = Line No.'; ShipmentSameSignErr: Label 'must have the same sign as the shipment'; ShipmentLinesDeletedErr: Label 'The shipment lines have been deleted.'; InvoiceMoreThanShippedErr: Label 'You cannot invoice more than you have shipped for order %1.', Comment = '%1 = Order No.'; VATAmountTxt: Label 'VAT Amount'; VATRateTxt: Label '%1% VAT', Comment = '%1 = VAT Rate'; BlanketOrderQuantityGreaterThanErr: Label 'in the associated blanket order must not be greater than %1', Comment = '%1 = Quantity'; BlanketOrderQuantityReducedErr: Label 'in the associated blanket order must not be reduced'; ShipInvoiceReceiveErr: Label 'Please enter "Yes" in Ship and/or Invoice and/or Receive.'; WarehouseRequiredErr: Label 'Warehouse handling is required for %1 = %2, %3 = %4, %5 = %6.', Comment = '%1/%2 = Document Type, %3/%4 - Document No.,%5/%6 = Line No.'; ReturnReceiptSameSignErr: Label 'must have the same sign as the return receipt'; ReturnReceiptInvoicedErr: Label 'Line %1 of the return receipt %2, which you are attempting to invoice, has already been invoiced.', Comment = '%1 = Line No., %2 = Document No.'; ShipmentInvoiceErr: Label 'Line %1 of the shipment %2, which you are attempting to invoice, has already been invoiced.', Comment = '%1 = Line No., %2 = Document No.'; QuantityToInvoiceGreaterErr: Label 'The quantity you are attempting to invoice is greater than the quantity in shipment %1.', Comment = '%1 = Document No.'; CannotAssignMoreErr: Label 'You cannot assign more than %1 units in %2 = %3, %4 = %5,%6 = %7.', Comment = '%1 = Quantity, %2/%3 = Document Type, %4/%5 - Document No.,%6/%7 = Line No.'; MustAssignErr: Label 'You must assign all item charges, if you invoice everything.'; Item: Record Item; SalesSetup: Record "Sales & Receivables Setup"; GLSetup: Record "General Ledger Setup"; [SecurityFiltering(SecurityFilter::Ignored)] GLEntry: Record "G/L Entry"; TempSalesLineGlobal: Record "Sales Line" temporary; xSalesLine: Record "Sales Line"; SalesLineACY: Record "Sales Line"; TotalSalesLine: Record "Sales Line"; TotalSalesLineLCY: Record "Sales Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; ReturnRcptHeader: Record "Return Receipt Header"; PurchRcptHeader: Record "Purch. Rcpt. Header"; ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; InvoicePostingParameters: Record "Invoice Posting Parameters"; SourceCodeSetup: Record "Source Code Setup"; Currency: Record Currency; CurrExchRate: Record "Currency Exchange Rate"; WhseRcptHeader: Record "Warehouse Receipt Header"; TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; WhseShptHeader: Record "Warehouse Shipment Header"; TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header"; PostedWhseRcptLine: Record "Posted Whse. Receipt Line"; PostedWhseShptHeader: Record "Posted Whse. Shipment Header"; PostedWhseShptLine: Record "Posted Whse. Shipment Line"; Location: Record Location; TempHandlingSpecification: Record "Tracking Specification" temporary; TempATOTrackingSpecification: Record "Tracking Specification" temporary; TempTrackingSpecification: Record "Tracking Specification" temporary; TempTrackingSpecificationInv: Record "Tracking Specification" temporary; TempWhseSplitSpecification: Record "Tracking Specification" temporary; TempValueEntryRelation: Record "Value Entry Relation" temporary; JobTaskSalesLine: Record "Sales Line"; TempICGenJnlLine: Record "Gen. Journal Line" temporary; TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; TempSKU: Record "Stockkeeping Unit" temporary; TempDeferralHeader: Record "Deferral Header" temporary; TempDeferralLine: Record "Deferral Line" temporary; ErrorMessageMgt: Codeunit "Error Message Management"; GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; ResJnlPostLine: Codeunit "Res. Jnl.-Post Line"; ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; SalesLineReserve: Codeunit "Sales Line-Reserve"; ApprovalsMgmt: Codeunit "Approvals Mgmt."; ItemTrackingMgt: Codeunit "Item Tracking Management"; WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line"; WhsePostRcpt: Codeunit "Whse.-Post Receipt"; WhsePostShpt: Codeunit "Whse.-Post Shipment"; PurchPost: Codeunit "Purch.-Post"; CostCalcMgt: Codeunit "Cost Calculation Management"; JobPostLine: Codeunit "Job Post-Line"; DocumentErrorsMgt: Codeunit "Document Errors Mgt."; AsmPost: Codeunit "Assembly-Post"; DeferralUtilities: Codeunit "Deferral Utilities"; UOMMgt: Codeunit "Unit of Measure Management"; ApplicationAreaMgmt: Codeunit "Application Area Mgmt."; InvoicePostingInterface: Interface "Invoice Posting"; IsInterfaceInitalized: Boolean; Window: Dialog; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; SrcCode: Code[10]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; ItemLedgShptEntryNo: Integer; RoundingLineNo: Integer; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; RemAmt: Decimal; RemDiscAmt: Decimal; TotalChargeAmt: Decimal; TotalChargeAmtLCY: Decimal; RoundedPrevTotalChargeAmt: Decimal; PreciseTotalChargeAmt: Decimal; LastLineRetrieved: Boolean; RoundingLineInserted: Boolean; DropShipOrder: Boolean; DocumentIsReadyToBeChecked: Boolean; PostponedValueEntries: List of [Integer]; ItemsToAdjust: List of [Code[20]]; CannotAssignInvoicedErr: Label 'You cannot assign item charges to the %1 %2 = %3,%4 = %5, %6 = %7, because it has been invoiced.', Comment = '%1 = Sales Line, %2/%3 = Document Type, %4/%5 - Document No.,%6/%7 = Line No.'; InvoiceMoreThanReceivedErr: Label 'You cannot invoice more than you have received for return order %1.', Comment = '%1 = Order No.'; ReturnReceiptLinesDeletedErr: Label 'The return receipt lines have been deleted.'; InvoiceGreaterThanReturnReceiptErr: Label 'The quantity you are attempting to invoice is greater than the quantity in return receipt %1.', Comment = '%1 = Receipt No.'; ItemJnlRollRndg: Boolean; RelatedItemLedgEntriesNotFoundErr: Label 'Related item ledger entries cannot be found.'; ItemTrackingWrongSignErr: Label 'Item Tracking is signed wrongly.'; ItemTrackingMismatchErr: Label 'Item Tracking does not match.'; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; PostingDateNotAllowedErr: Label '%1 is not within your range of allowed posting dates.', Comment = '%1 - Posting Date field caption'; ItemTrackQuantityMismatchErr: Label 'The %1 does not match the quantity defined in item tracking for item %2.', Comment = '%1 = Quantity, %2 = Item No.'; CannotBeGreaterThanErr: Label 'cannot be more than %1.', Comment = '%1 = Amount'; CannotBeSmallerThanErr: Label 'must be at least %1.', Comment = '%1 = Amount'; JobContractLine: Boolean; GLSetupRead: Boolean; SalesSetupRead: Boolean; ItemTrkgAlreadyOverruled: Boolean; LogErrorMode: Boolean; PrepAmountToDeductToBigErr: Label 'The total %1 cannot be more than %2.', Comment = '%1 = Prepmt Amt to Deduct, %2 = Max Amount'; PrepAmountToDeductToSmallErr: Label 'The total %1 must be at least %2.', Comment = '%1 = Prepmt Amt to Deduct, %2 = Max Amount'; MustAssignItemChargeErr: Label 'You must assign item charge %1 if you want to invoice it.', Comment = '%1 = Item Charge No.'; CannotInvoiceItemChargeErr: Label 'You can not invoice item charge %1 because there is no item ledger entry to assign it to.', Comment = '%1 = Item Charge No.'; SalesLinesProcessed: Boolean; AssemblyCheckProgressMsg: Label '#1#################################\\Checking Assembly #2###########', Comment = '%1 = Text, %2 = Progress bar'; AssemblyPostProgressMsg: Label '#1#################################\\Posting Assembly #2###########', Comment = '%1 = Text, %2 = Progress bar'; AssemblyFinalizeProgressMsg: Label '#1#################################\\Finalizing Assembly #2###########', Comment = '%1 = Text, %2 = Progress bar'; ReassignItemChargeErr: Label 'The order line that the item charge was originally assigned to has been fully posted. You must reassign the item charge to the posted receipt or shipment.';#pragma warning disable AA0470 ReservationDisruptedQst: Label 'One or more reservation entries exist for the item with %1 = %2, %3 = %4, %5 = %6 which may be disrupted if you post this negative adjustment. Do you want to continue?', Comment = 'One or more reservation entries exist for the item with No. = 1000, Location Code = SILVER, Variant Code = NEW which may be disrupted if you post this negative adjustment. Do you want to continue?';#pragma warning restore AA0470 NotSupportedDocumentTypeErr: Label 'Document type %1 is not supported.', Comment = '%1 = Document Type'; CalledBy: Integer; PreviewMode: Boolean; TotalInvoiceAmountNegativeErr: Label 'The total amount for the invoice must be 0 or greater.'; SendShipmentAlsoQst: Label 'You can take the same actions for the related Sales - Shipment document.\\Do you want to do that now?'; SuppressCommit: Boolean; PostingPreviewNoTok: Label '***', Locked = true; PostingPreviewNoFormatTxt: Label '<Integer,6><Filler Character,0>', Comment = 'Previewed document numbers are displayed in the format ***000000', Locked = true; InvPickExistsErr: Label 'One or more related inventory picks must be registered before you can post the shipment.'; InvPutAwayExistsErr: Label 'One or more related inventory put-aways must be registered before you can post the receipt.'; CheckSalesHeaderMsg: Label 'Check sales document fields.'; CheckSalesLineMsg: Label 'Check sales document line.'; PostDocumentLinesMsg: Label 'Post document lines.'; HideProgressWindow: Boolean; OrderArchived: Boolean; SetupBlockedErr: Label 'Setup is blocked in %1 for %2 %3 and %4 %5.', Comment = '%1 - General/VAT Posting Setup, %2 %3 %4 %5 - posting groups.'; SalesReturnRcptHeaderConflictErr: Label 'Cannot post the sales return because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Return Receipt No.'; SalesShptHeaderConflictErr: Label 'Cannot post the sales shipment because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Shipping No.'; SalesInvHeaderConflictErr: Label 'Cannot post the sales invoice because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Posting No.'; SalesCrMemoHeaderConflictErr: Label 'Cannot post the sales credit memo because its ID, %1, is already assigned to a record. Update the number series and try again.', Comment = '%1 = Posting No.'; SalesLinePostCategoryTok: Label 'Sales Line Post', Locked = true; SameIdFoundLbl: Label 'Same line id found.', Locked = true; EmptyIdFoundLbl: Label 'Empty line id found.', Locked = true; ItemReservDisruptionLbl: Label 'Confirm Item Reservation Disruption', Locked = true; ItemChargeZeroAmountErr: Label 'The amount for item charge %1 cannot be 0.', Comment = '%1 = Item Charge No.'; SuppressCommitErr: Label 'Commit is blocked when %1 %2 is used.', Comment = '%1 = Date Order, %2 = Number Series'; DateOrderSeriesUsed: Boolean; /// <summary> /// Verifies and posts the sales document. /// As a result, posted documents will be created, dependent on the type of the document, as well as any relevant posting to inventory and finance. /// A Quote cannot be posted - it has to be turned into an order or invoice first, which then can be posted. /// An Order can be shipped and/or invoiced. /// A Return order can be received and/or invoiced. /// An Invoice and a Credit memo can be invoiced. /// Any document, except quote, can be partly shipped/received/invoiced. /// </summary> /// <param name="SalesHeader2">The sales header of the document that is being posted.</param> internal procedure RunWithCheck(var SalesHeader2: Record "Sales Header") var SalesHeader: Record "Sales Header"; CustLedgEntry: Record "Cust. Ledger Entry"; TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; DisableAggregateTableUpdate: Codeunit "Disable Aggregate Table Update"; UpdateAnalysisView: Codeunit "Update Analysis View"; UpdateItemAnalysisView: Codeunit "Update Item Analysis View"; SequenceNoMgt: Codeunit "Sequence No. Mgt."; EverythingInvoiced: Boolean; SavedPreviewMode: Boolean; SavedSuppressCommit: Boolean; SavedCalledBy: Integer; SavedHideProgressWindow: Boolean; IsHandled: Boolean; begin SequenceNoMgt.SetPreviewMode(PreviewMode); IsHandled := false; OnBeforePostSalesDoc(SalesHeader2, SuppressCommit, PreviewMode, HideProgressWindow, IsHandled, CalledBy); if IsHandled then exit; GetSalesHeader(SalesHeader2); if not GuiAllowed() then LockTimeout(false); SetupDisableAggregateTableUpdate(SalesHeader2, DisableAggregateTableUpdate); ValidatePostingAndDocumentDate(SalesHeader2); SavedPreviewMode := PreviewMode; SavedSuppressCommit := SuppressCommit; SavedHideProgressWindow := HideProgressWindow; SavedCalledBy := CalledBy; ClearAllVariables(); SuppressCommit := SavedSuppressCommit; PreviewMode := SavedPreviewMode; HideProgressWindow := SavedHideProgressWindow; CalledBy := SavedCalledBy; GetGLSetup(); GetSalesSetup(); GetInvoicePostingSetup(); GetCurrency(SalesHeader2."Currency Code"); SalesHeader := SalesHeader2; OnCodeOnBeforeFillTempLines(SalesHeader, CalledBy); FillTempLines(SalesHeader, TempSalesLineGlobal); // Check that the invoice amount is zero or greater OnRunOnBeforeCheckTotalInvoiceAmount(SalesHeader, TempSalesLineGlobal); if SalesHeader.Invoice then CheckTotalInvoiceAmount(SalesHeader); OnRunOnBeforeCheckAndUpdate(SalesHeader); // Header CheckAndUpdate(SalesHeader); ProcessPosting(SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced); UpdateLastPostingNos(SalesHeader); OnRunOnBeforeFinalizePosting( SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlPostLine, SuppressCommit, GenJnlLineExtDocNo, EverythingInvoiced, GenJnlLineDocNo, SrcCode, PreviewMode); if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::"Credit Memo"]) then EnableAggregateTableUpdate(DisableAggregateTableUpdate); FinalizePosting(SalesHeader, EverythingInvoiced, TempDropShptPostBuffer); SalesHeader2 := SalesHeader; OnRunWithCheckOnAfterFinalize(SalesHeader); // Date-ordered No. Series require that number allocation and the posted document are in the same // transaction to prevent gaps. At this point FinalizePosting has completed, so both the allocated // number and the posted document exist in the current transaction — committing is safe. // Restore SuppressCommit to the caller's original value so that the date-order guard // no longer blocks the final commit. if DateOrderSeriesUsed and SuppressCommit then SuppressCommit := SavedSuppressCommit; if not (InvtPickPutaway or SuppressCommit or PreviewMode) then begin Commit(); UpdateAnalysisView.UpdateAll(0, true); UpdateItemAnalysisView.UpdateAll(0, true); end; OnAfterPostSalesDoc( SalesHeader2, GenJnlPostLine, SalesShptHeader."No.", ReturnRcptHeader."No.", SalesInvHeader."No.", SalesCrMemoHeader."No.", SuppressCommit, InvtPickPutaway, CustLedgEntry, WhseShip, WhseReceive, PreviewMode); OnAfterPostSalesDocDropShipment(PurchRcptHeader."No.", SuppressCommit); end; /// <summary> /// A wrapper function to delegate to either a function that allows commit or a function that ignores commit /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesHeader2">An unmodified copy of the sales header.</param> /// <param name="TempDropShptPostBuffer">An internal temp table holding drop shipment information.</param> /// <param name="CustLedgEntry">The customer ledger entry we are creating (='the invoice').</param> /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param> local procedure ProcessPosting(var SalesHeader: Record "Sales Header"; var SalesHeader2: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var CustLedgEntry: Record "Cust. Ledger Entry"; var EverythingInvoiced: Boolean) var IgnoreCommit: Boolean; begin IgnoreCommit := true; OnSetCommitBehavior(IgnoreCommit); if IgnoreCommit then ProcessPostingLinesCommitBehaviorIgnore( SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced) else ProcessPostingLines( SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced); end; /// <summary> /// A wrapper function to delegate to the ProcessPostingLines function in order to ignore commits /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesHeader2">An unmodified copy of the sales header.</param> /// <param name="TempDropShptPostBuffer">An internal temp table holding drop shipment information.</param> /// <param name="CustLedgEntry">The customer ledger entry we are creating (='the invoice').</param> /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param> [CommitBehavior(CommitBehavior::Ignore)] local procedure ProcessPostingLinesCommitBehaviorIgnore(var SalesHeader: Record "Sales Header"; var SalesHeader2: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var CustLedgEntry: Record "Cust. Ledger Entry"; var EverythingInvoiced: Boolean) begin ProcessPostingLines(SalesHeader, SalesHeader2, TempDropShptPostBuffer, CustLedgEntry, EverythingInvoiced); end; /// <summary> /// The main function that processes the document lines. /// Will update inventory, finance, resources, jobs, etc., dependent on what lines are in the document. /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesHeader2">An unmodified copy of the sales header.</param> /// <param name="TempDropShptPostBuffer">An internal temp table holding drop shipment information.</param> /// <param name="CustLedgEntry">The customer ledger entry we are creating (='the invoice').</param> /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param> local procedure ProcessPostingLines(var SalesHeader: Record "Sales Header"; var SalesHeader2: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var CustLedgEntry: Record "Cust. Ledger Entry"; var EverythingInvoiced: Boolean) var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; TempVATAmountLine: Record "VAT Amount Line" temporary; TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; InventorySetup: Record "Inventory Setup"; ErrorContextElementProcessLines: Codeunit "Error Context Element"; ErrorContextElementPostLine: Codeunit "Error Context Element"; ZeroSalesLineRecID: RecordId; ICGenJnlLineNo: Integer; LineCount: Integer; BiggestLineNo: Integer; HasATOShippedNotInvoiced: Boolean; SkipInventoryAdjustment: Boolean; IsHandled: Boolean; begin InvoicePostingInterface.ClearBuffers(); TempDropShptPostBuffer.DeleteAll(); EverythingInvoiced := true; // Lines GetZeroSalesLineRecID(SalesHeader, ZeroSalesLineRecID); ErrorMessageMgt.PushContext(ErrorContextElementProcessLines, ZeroSalesLineRecID, 0, PostDocumentLinesMsg); OnBeforePostLines(TempSalesLineGlobal, SalesHeader, SuppressCommit, PreviewMode, TempWhseShptHeader, ItemJnlPostLine, TempWhseRcptHeader); LineCount := 0; RoundingLineInserted := false; AdjustFinalInvWith100PctPrepmt(TempSalesLineGlobal); TempVATAmountLineRemainder.DeleteAll(); IsHandled := false; OnRunOnBeforeCalcVATAmountLines(TempSalesLineGlobal, SalesHeader, TempVATAmountLine, IsHandled); if not IsHandled then TempSalesLineGlobal.CalcVATAmountLines(1, SalesHeader, TempSalesLineGlobal, TempVATAmountLine); OnBeforePostSalesLines(SalesHeader, TempSalesLineGlobal, TempVATAmountLine, EverythingInvoiced); Clear(PostponedValueEntries); BindSubscription(this); // Start collect value entries for GLPosting SalesLinesProcessed := false; if not InventorySetup.UseLegacyPosting() then TempSalesLineGlobal.SetCurrentKey(Type, "Line No."); if TempSalesLineGlobal.FindSet() then repeat ErrorMessageMgt.PushContext(ErrorContextElementPostLine, TempSalesLineGlobal.RecordId, 0, PostDocumentLinesMsg); ItemJnlRollRndg := false; LineCount := LineCount + 1; if GuiAllowed() and not HideProgressWindow then Window.Update(2, LineCount); PostSalesLine( SalesHeader, TempSalesLineGlobal, EverythingInvoiced, TempVATAmountLine, TempVATAmountLineRemainder, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced, TempDropShptPostBuffer, ICGenJnlLineNo); UpdateInvoiceRounding(SalesHeader, BiggestLineNo); OnRunOnBeforePostSalesLineEndLoop( SalesHeader, TempSalesLineGlobal, LastLineRetrieved, SalesInvHeader, SalesCrMemoHeader, SalesHeader2, xSalesLine, SalesShptHeader, ReturnRcptHeader); ErrorMessageMgt.PopContext(ErrorContextElementPostLine); until LastLineRetrieved; TempSalesLineGlobal.SetCurrentKey("Document Type", "Document No.", "Line No."); UnBindSubscription(this); // Stop collecting value entries for GLPosting ItemJnlPostLine.PostDeferredValueEntriesToGL(PostponedValueEntries); OnAfterPostSalesLines( SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, WhseShip, WhseReceive, SalesLinesProcessed, SuppressCommit, EverythingInvoiced, TempSalesLineGlobal); ErrorMessageMgt.PopContext(ErrorContextElementProcessLines); ErrorMessageMgt.Finish(ZeroSalesLineRecID); SendICDocument(SalesHeader); UpdateHandledICInboxTransaction(SalesHeader); if not SalesHeader.IsCreditDocType() then begin ReverseAmount(TotalSalesLine); ReverseAmount(TotalSalesLineLCY); TotalSalesLineLCY."Unit Cost (LCY)" := -TotalSalesLineLCY."Unit Cost (LCY)"; end; OnProcessPostingLinesOnBeforePostDropOrderShipment(SalesHeader, TotalSalesLine, TotalSalesLineLCY); PostDropOrderShipment(SalesHeader, TempDropShptPostBuffer); if SalesHeader.Invoice then PostInvoice(SalesHeader, CustLedgEntry); OnRunOnBeforePostICGenJnl(SalesHeader, SalesInvHeader, SalesCrMemoHeader, GenJnlPostLine, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, ReturnRcptHeader, PreviewMode); if ICGenJnlLineNo > 0 then PostICGenJnl(); SkipInventoryAdjustment := false; OnRunOnBeforeMakeInventoryAdjustment(SalesHeader, SalesInvHeader, GenJnlPostLine, ItemJnlPostLine, PreviewMode, SkipInventoryAdjustment); if not SkipInventoryAdjustment then MakeInventoryAdjustment(); end; /// <summary> /// Generates a record id for an 'empty' line /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLineRecID">Return value: The record ID of the 'empty' line.</param> local procedure GetZeroSalesLineRecID(SalesHeader: Record "Sales Header"; var SalesLineRecID: RecordId) var ZeroSalesLine: Record "Sales Line"; begin ZeroSalesLine."Document Type" := SalesHeader."Document Type"; ZeroSalesLine."Document No." := SalesHeader."No."; ZeroSalesLine."Line No." := 0; SalesLineRecID := ZeroSalesLine.RecordId; end; /// <summary> /// Copies all the sales lines to a temporary table to speed up later processing /// </summary> /// <remarks> /// If the item charge exists for an item in sales sine, then gen. prod. posting group of item charge is copied to the sales line. /// </remarks> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="TempSalesLine">Return value: The temp table that holds a copy of all sales lines.</param> procedure CopyToTempLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) var SalesLine: Record "Sales Line"; begin SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); OnCopyToTempLinesOnAfterSetFilters(SalesLine, SalesHeader); if SalesLine.FindSet() then repeat UpdateChargeItemSalesLineGenProdPostingGroup(SalesLine); TempSalesLine := SalesLine; TempSalesLine.Insert(); until SalesLine.Next() = 0; OnAfterCopyToTempLines(TempSalesLine, SalesHeader); end; /// <summary> /// Copies all the sales lines to a temporary table, if they haven't been copied yet, to speed up later processing /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="TempSalesLine">Return value: The temp table that holds a copy of all sales lines.</param> procedure FillTempLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin TempSalesLine.Reset(); if TempSalesLine.IsEmpty() then CopyToTempLines(SalesHeader, TempSalesLine); end; local procedure SetupDisableAggregateTableUpdate(var SalesHeader: Record "Sales Header"; var DisableAggregateTableUpdate: Codeunit "Disable Aggregate Table Update") var AggregateTableID: Integer; begin AggregateTableID := DisableAggregateTableUpdate.GetAggregateTableIDFromSalesHeader(SalesHeader); if not (AggregateTableID > 0) then exit; DisableAggregateTableUpdate.SetAggregateTableIDDisabled(AggregateTableID); DisableAggregateTableUpdate.SetTableSystemIDDisabled(SalesHeader.SystemId); BindSubscription(DisableAggregateTableUpdate); end; local procedure EnableAggregateTableUpdate(var DisableAggregateTableUpdate: Codeunit "Disable Aggregate Table Update") begin if UnbindSubscription(DisableAggregateTableUpdate) then; end; local procedure ModifyTempLine(var TempSalesLineLocal: Record "Sales Line" temporary) var SalesLine: Record "Sales Line"; begin TempSalesLineLocal.Modify(); SalesLine.Get(TempSalesLineLocal.RecordId); OnModifyTempLineOnBeforeTransferFields(SalesLine, TempSalesLineLocal); SalesLine.TransferFields(TempSalesLineLocal, false); OnModifyTempLineOnBeforeSalesLineModify(SalesLine); SalesLine.Modify(); OnModifyTempLineOnAfterSalesLineModify(SalesLine); end; /// <summary> /// Deletes the sales line from the temp table and copies them again to account for any changes done to the document lines as part of the posting process /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="TempSalesLine">Return value: The temp table that holds a fresh copy of all sales lines.</param> procedure RefreshTempLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin TempSalesLine.Reset(); TempSalesLine.SetRange("Prepayment Line", false); TempSalesLine.DeleteAll(); TempSalesLine.Reset(); CopyToTempLines(SalesHeader, TempSalesLine); end; /// <summary> /// Removes any filters on the temp sales line and copies the values from the global temp sales line to the local temp sales line /// </summary> /// <param name="TempSalesLineLocal">Return value: The local temp table that holds a copy of all sales lines.</param> procedure ResetTempLines(var TempSalesLineLocal: Record "Sales Line" temporary) begin TempSalesLineLocal.Reset(); TempSalesLineLocal.Copy(TempSalesLineGlobal, true); OnAfterResetTempLines(TempSalesLineLocal); end; /// <summary> /// Checks if a new invoice should be created for the document /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <returns>True if a new invoice should be created, false otherwise.</returns> local procedure CalcInvoice(SalesHeader: Record "Sales Header") NewInvoice: Boolean var TempSalesLine: Record "Sales Line" temporary; IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcInvoice(SalesHeader, TempSalesLineGlobal, NewInvoice, IsHandled); if IsHandled then exit(NewInvoice); ResetTempLines(TempSalesLine); TempSalesLine.SetFilter(Quantity, '<>0'); if SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"] then TempSalesLine.SetFilter("Qty. to Invoice", '<>0'); OnCalcInvoiceOnAfterTempSalesLineSetFilters(SalesHeader, TempSalesLine); NewInvoice := not TempSalesLine.IsEmpty(); if NewInvoice then case SalesHeader."Document Type" of SalesHeader."Document Type"::Order: if not SalesHeader.Ship then begin TempSalesLine.SetFilter("Qty. Shipped Not Invoiced", '<>0'); NewInvoice := not TempSalesLine.IsEmpty(); end; SalesHeader."Document Type"::"Return Order": if not SalesHeader.Receive then begin TempSalesLine.SetFilter("Return Qty. Rcd. Not Invd.", '<>0'); NewInvoice := not TempSalesLine.IsEmpty(); end; end; OnAfterCalcInvoice(TempSalesLine, NewInvoice, SalesHeader); exit(NewInvoice); end; /// <summary> /// Calculates the invoice discount for the document and updates the document and lines accordingly /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> local procedure CalcInvDiscount(var SalesHeader: Record "Sales Header") var SalesHeaderCopy: Record "Sales Header"; SalesLine: Record "Sales Line"; begin if not (SalesSetup."Calc. Inv. Discount" and (SalesHeader.Status <> SalesHeader.Status::Open)) then exit; SalesHeaderCopy := SalesHeader; SalesLine.Reset(); SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); OnCalcInvDiscountSetFilter(SalesLine, SalesHeader); SalesLine.FindFirst(); CODEUNIT.Run(CODEUNIT::"Sales-Calc. Discount", SalesLine); RefreshTempLines(SalesHeader, TempSalesLineGlobal); SalesHeader.Get(SalesHeader."Document Type", SalesHeader."No."); RestoreSalesHeader(SalesHeader, SalesHeaderCopy); if not (PreviewMode or SuppressCommit) then Commit(); end; /// <summary> /// Restores postings flags and posting numbers of the document header to their original values. /// </summary> /// <param name="SalesHeader">Return value: The sales header of the document with the restored values.</param> /// <param name="SalesHeaderCopy">The sales header of the document with the original values.</param> local procedure RestoreSalesHeader(var SalesHeader: Record "Sales Header"; SalesHeaderCopy: Record "Sales Header") begin SalesHeader.Invoice := SalesHeaderCopy.Invoice; SalesHeader.Receive := SalesHeaderCopy.Receive; SalesHeader.Ship := SalesHeaderCopy.Ship; SalesHeader."Posting No." := SalesHeaderCopy."Posting No."; SalesHeader."Shipping No." := SalesHeaderCopy."Shipping No."; SalesHeader."Return Receipt No." := SalesHeaderCopy."Return Receipt No."; OnAfterRestoreSalesHeader(SalesHeader, SalesHeaderCopy); end; /// <summary> /// Checks if document header and lines are valid for posting, updates the document and lines and creates posted documents. /// Prepayment lines are created for documents that are invoiced. /// Unposted document is archived /// </summary> /// <remarks> /// Transaction is commited after updating the document header if posting is not in PreviewMode /// Several related tables are locked for update after this procedure. /// DocumentIsReadyToBeChecked is set to true, so that PrepareCheckDocument() is not called again in CheckSalesDocument(). Preparation already happened in RunWithCheck() (parent function). /// </remarks> /// <param name="SalesHeader">Return value: The sales header of the document that is being posted, returned with updated values.</param> local procedure CheckAndUpdate(var SalesHeader: Record "Sales Header") var DummyNoSeries: Record "No. Series"; ModifyHeader: Boolean; RefreshTempLinesNeeded: Boolean; begin OnBeforeCheckAndUpdate(SalesHeader, ModifyHeader); DocumentIsReadyToBeChecked := true; // to avoid re-calling it in CheckSalesDocument() CheckSalesDocument(SalesHeader); if SalesHeader.Ship then InitPostATOs(SalesHeader); if GuiAllowed() and not HideProgressWindow then InitProgressWindow(SalesHeader); // Update if SalesHeader.Invoice then begin CreatePrepaymentLines(SalesHeader, true); CreatePrepaymentLineForCreditMemo(SalesHeader); end; DateOrderSeriesUsed := false; ModifyHeader := UpdatePostingNos(SalesHeader); if DateOrderSeriesUsed then SuppressCommit := true; DropShipOrder := UpdateAssosOrderPostingNos(SalesHeader); OnBeforePostCommitSalesDoc(SalesHeader, GenJnlPostLine, PreviewMode, ModifyHeader, SuppressCommit, TempSalesLineGlobal); if DateOrderSeriesUsed and (not SuppressCommit) then Error(SuppressCommitErr, DummyNoSeries.FieldCaption("Date Order"), DummyNoSeries.TableCaption()); if not PreviewMode and ModifyHeader then begin SalesHeader.Modify(); if not SuppressCommit then Commit(); end; RefreshTempLinesNeeded := false; OnCheckAndUpdateOnBeforeCalcInvDiscount( SalesHeader, TempWhseRcptHeader, TempWhseShptHeader, WhseReceive, WhseShip, RefreshTempLinesNeeded); if RefreshTempLinesNeeded then RefreshTempLines(SalesHeader, TempSalesLineGlobal); CalcInvDiscount(SalesHeader); OnCheckAndUpdateOnAfterCalcInvDiscount(SalesHeader, TempWhseShptHeader, PreviewMode, TempSalesLineGlobal, SuppressCommit, WhseReceive, WhseShip); ReleaseSalesDocument(SalesHeader); OnCheckAndUpdateOnAfterReleaseSalesDocument(SalesHeader, PreviewMode); HandleArchiveUnpostedOrder(SalesHeader); CheckICPartnerBlocked(SalesHeader); LockTables(SalesHeader); SourceCodeSetup.Get(); SrcCode := SourceCodeSetup.Sales; OnCheckAndUpdateOnAfterSetSourceCode(SalesHeader, SourceCodeSetup, SrcCode); InsertPostedHeaders(SalesHeader); UpdateIncomingDocument(SalesHeader."Incoming Document Entry No.", SalesHeader."Posting Date", GenJnlLineDocNo); OnAfterCheckAndUpdate(SalesHeader, SuppressCommit, PreviewMode); end; local procedure HandleArchiveUnpostedOrder(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeHandleArchiveUnpostedOrder(SalesHeader, PreviewMode, IsHandled); if IsHandled then exit; if SalesHeader.Ship or SalesHeader.Receive then ArchiveUnpostedOrder(SalesHeader); end; /// <summary> /// Main function for checking if document header and lines are valid for posting. /// Checks for mandatory fields, posting dates, VAT dates, linked documents, posting restrictions, electronic documents, etc. /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> procedure CheckSalesDocument(var SalesHeader: Record "Sales Header") var CheckDimensions: Codeunit "Check Dimensions"; ErrorContextElement: Codeunit "Error Context Element"; ForwardLinkMgt: Codeunit "Forward Link Mgt."; GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line"; ReportDistributionManagement: Codeunit "Report Distribution Management"; SetupRecID: RecordID; ModifyHeader: Boolean; ShouldCheckItemCharge: Boolean; ShouldCheckDueDate: Boolean; IsHandled: Boolean; begin if not DocumentIsReadyToBeChecked then PrepareCheckDocument(SalesHeader); ErrorMessageMgt.PushContext(ErrorContextElement, SalesHeader.RecordId, 0, CheckSalesHeaderMsg); CheckMandatoryHeaderFields(SalesHeader); GetGLSetup(); if GLSetup."Journal Templ. Name Mandatory" then SalesHeader.TestField("Journal Templ. Name", ErrorInfo.Create()); if GenJnlCheckLine.IsDateNotAllowed(SalesHeader."Posting Date", SetupRecID, SalesHeader."Journal Templ. Name") then ErrorMessageMgt.LogContextFieldError( SalesHeader.FieldNo(SalesHeader."Posting Date"), StrSubstNo(PostingDateNotAllowedErr, SalesHeader.FieldCaption("Posting Date")), SetupRecID, ErrorMessageMgt.GetFieldNo(SetupRecID.TableNo, GLSetup.FieldName("Allow Posting From")), ForwardLinkMgt.GetHelpCodeForAllowedPostingDate()); CheckVATDate(SalesHeader); OnCheckAndUpdateOnBeforeSetPostingFlags(SalesHeader, TempSalesLineGlobal, ModifyHeader, HideProgressWindow); if LogErrorMode then SetLogErrorModePostingFlags(SalesHeader) else SetPostingFlags(SalesHeader); OnCheckAndUpdateOnAfterSetPostingFlags(SalesHeader, TempSalesLineGlobal, ModifyHeader); if GuiAllowed() and not HideProgressWindow then InitProgressWindow(SalesHeader); InvtPickPutaway := SalesHeader."Posting from Whse. Ref." <> 0; SalesHeader."Posting from Whse. Ref." := 0; OnCheckAndUpdateOnAfterSetPoszingFromWhseRef(SalesHeader, InvtPickPutaway, SalesHeader."Posting from Whse. Ref."); IsHandled := false; OnCheckSalesDocumentOnBeforeCheckSalesDim(SalesHeader, TempSalesLineGlobal, IsHandled); if not IsHandled then CheckDimensions.CheckSalesDim(SalesHeader, TempSalesLineGlobal); OnCheckAndUpdateOnBeforeCheckPostRestrictions(SalesHeader, PreviewMode); CheckPostRestrictions(SalesHeader); if SalesHeader.Invoice then SalesHeader.Invoice := CalcInvoice(SalesHeader); ShouldCheckItemCharge := SalesHeader.Invoice; OnCheckSalesDocumentOnAfterCalcShouldCheckItemCharge(SalesHeader, WhseReceive, WhseShip, ShouldCheckItemCharge, ModifyHeader); if ShouldCheckItemCharge then CopyAndCheckItemCharge(SalesHeader); ShouldCheckDueDate := SalesHeader.Invoice and not SalesHeader.IsCreditDocType(); OnCheckSalesDocumentOnBeforeCheckDueDate(SalesHeader, ShouldCheckDueDate); if ShouldCheckDueDate then SalesHeader.TestField("Due Date", ErrorInfo.Create()); UpdateShipAndCheckIfInvPickExists(SalesHeader); UpdateReceiveAndCheckIfInvPutawayExists(SalesHeader); CheckHeaderPostingType(SalesHeader); CheckHeaderShippingAdvice(SalesHeader); CheckAssosOrderLines(SalesHeader); ReportDistributionManagement.RunDefaultCheckSalesElectronicDocument(SalesHeader); ErrorMessageMgt.PopContext(ErrorContextElement); CheckSalesLines(SalesHeader); OnAfterCheckSalesDoc(SalesHeader, SuppressCommit, WhseShip, WhseReceive, PreviewMode, ErrorMessageMgt); if not LogErrorMode then ErrorMessageMgt.Finish(SalesHeader.RecordId); end; /// <summary> /// Checks all sales lines of the document if they are valid for posting. /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> local procedure CheckSalesLines(var SalesHeader: Record "Sales Header") var InventorySetup: Record "Inventory Setup"; ErrorContextElement: Codeunit "Error Context Element"; SequenceNoMgt: Codeunit "Sequence No. Mgt."; NoOfItemLines: Integer; begin if TempSalesLineGlobal.FindSet() then repeat ErrorMessageMgt.PushContext(ErrorContextElement, TempSalesLineGlobal.RecordId(), 0, CheckSalesLineMsg); TestSalesLine(SalesHeader, TempSalesLineGlobal); if (SalesHeader.Ship or SalesHeader.Receive or SalesHeader.Invoice) and (TempSalesLineGlobal.Type = TempSalesLineGlobal.Type::Item) and (TempSalesLineGlobal."Qty. to Ship" <> 0) then NoOfItemLines += 1; until TempSalesLineGlobal.Next() = 0; ErrorMessageMgt.PopContext(ErrorContextElement); if not InventorySetup.UseLegacyPosting() and (NoOfItemLines > 0) then begin if SalesHeader.Ship or SalesHeader.Receive then SequenceNoMgt.AllocateSeqNoBuffer(Database::"Item Ledger Entry", NoOfItemLines); SequenceNoMgt.AllocateSeqNoBuffer(Database::"Value Entry", NoOfItemLines); end; end; local procedure CheckTotalInvoiceAmount(SalesHeader: Record "Sales Header") var TempVATAmountLine: Record "VAT Amount Line" temporary; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckTotalInvoiceAmount(SalesHeader, IsHandled); if IsHandled then exit; if SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::Order] then begin TempSalesLineGlobal.CalcVATAmountLines(1, SalesHeader, TempSalesLineGlobal, TempVATAmountLine); if TempVATAmountLine.GetTotalLineAmount(false, '') < 0 then if TempVATAmountLine.GetTotalAmountInclVAT() < 0 then Error(TotalInvoiceAmountNegativeErr); end; end; /// <summary> /// Gets all the necessary setup information for the check document process /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> procedure PrepareCheckDocument(var SalesHeader: Record "Sales Header") begin OnBeforePrepareCheckDocument(SalesHeader); GetGLSetup(); GetSalesSetup(); GetInvoicePostingSetup(); GetCurrency(SalesHeader."Currency Code"); FillTempLines(SalesHeader, TempSalesLineGlobal); LogErrorMode := true; DocumentIsReadyToBeChecked := true; end; local procedure SetLogErrorModePostingFlags(var SalesHeader: Record "Sales Header") begin SalesHeader.Ship := SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice]; SalesHeader.Receive := SalesHeader."Document Type" in [SalesHeader."Document Type"::"Return Order", SalesHeader."Document Type"::"Credit Memo"]; SalesHeader.Invoice := true; end; /// <summary> /// Updates sales line quantities and amounts based on the posting type (Ship, Invoice), posts the line and creates a posted document lines. /// Deferrals and tracking information are posted for the line. /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="EverythingInvoiced">A flag telling whether it was a partial invoice and something is still left.</param> /// <param name="TempVATAmountLine">A temp table holding all VAT amounts for the document.</param> /// <param name="TempVATAmountLineRemainder">A temp table holding Rounding Reminder Amounts for VAT Amounts used to prevent rounding errors when dividing amounts if Qty to post is not equal to full line Qty.</param> /// <param name="TempItemLedgEntryNotInvoiced">A temp table that will be filled in with all Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param> /// <param name="HasATOShippedNotInvoiced">A flag telling whether there are any Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param> /// <param name="TempDropShptPostBuffer">Return Variable: A temp table that will get an additional entry with Drop Shipment information if it's an Item line.</param> /// <param name="ICGenJnlLineNo">Return Variable: The line number of the Inter Company General Journal Line for that was created, It's only filled if line type is G/L Account.</param> local procedure PostSalesLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var EverythingInvoiced: Boolean; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var ICGenJnlLineNo: Integer) var SalesInvLine: Record "Sales Invoice Line"; SearchSalesInvLine: Record "Sales Invoice Line"; SalesCrMemoLine: Record "Sales Cr.Memo Line"; SearchSalesCrMemoLine: Record "Sales Cr.Memo Line"; TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; CostBaseAmount: Decimal; ShouldPostLine: Boolean; ShouldInsertInvoiceLine: Boolean; IsHandled: Boolean; begin if SalesLine.Type = SalesLine.Type::Item then begin CostBaseAmount := SalesLine."Line Amount"; IsHandled := false; OnPostSalesLineOnBeforeTestUnitOfMeasureCode(SalesHeader, SalesLine, TempSalesLineGlobal, IsHandled); // Skip UoM validation for partially shipped/received documents and lines fetch through "Get Shipment Lines" if not IsHandled then if (SalesLine."No." <> '') and (SalesLine."Qty. Shipped (Base)" = 0) and (SalesLine."Shipment No." = '') and (SalesLine."Return Qty. Received (Base)" = 0) and (SalesLine."Return Receipt No." = '') then SalesLine.TestField("Unit of Measure Code"); end; if SalesLine."Qty. per Unit of Measure" = 0 then SalesLine."Qty. per Unit of Measure" := 1; OnPostSalesLineOnAfterTestSalesLine(SalesLine, SalesHeader, WhseShptHeader, WhseShip, PreviewMode, CostBaseAmount); TempPostedATOLink.Reset(); TempPostedATOLink.DeleteAll(); if SalesHeader.Ship then PostATO(SalesHeader, SalesLine, TempPostedATOLink); OnPostSalesLineOnBeforeUpdateSalesLineBeforePost(SalesLine, SalesHeader, WhseShip, WhseReceive, RoundingLineInserted, SuppressCommit); UpdateSalesLineBeforePost(SalesHeader, SalesLine); TestUpdatedSalesLine(SalesLine); IsHandled := false; OnPostSalesLineOnAfterTestUpdatedSalesLine(SalesLine, EverythingInvoiced, SalesHeader, IsHandled); if not IsHandled then if SalesLine."Qty. to Invoice" + SalesLine."Quantity Invoiced" <> SalesLine.Quantity then EverythingInvoiced := false; IsHandled := false; OnPostSalesLineOnAfterSetEverythingInvoiced(SalesLine, EverythingInvoiced, IsHandled, SalesHeader); if not IsHandled then if SalesLine.Quantity <> 0 then DivideAmount(SalesHeader, SalesLine, 1, SalesLine."Qty. to Invoice", TempVATAmountLine, TempVATAmountLineRemainder); CheckItemReservDisruption(SalesLine); RoundAmount(SalesHeader, SalesLine, SalesLine."Qty. to Invoice"); OnPostSalesLineOnAfterRoundAmount(SalesHeader, SalesLine, SalesInvHeader, SalesCrMemoHeader, GenJnlLineDocNo); if not SalesLine.IsCreditDocType() then begin ReverseAmount(SalesLine); ReverseAmount(SalesLineACY); end; RemQtyToBeInvoiced := SalesLine."Qty. to Invoice"; RemQtyToBeInvoicedBase := SalesLine."Qty. to Invoice (Base)"; OnPostSalesLineOnBeforePostItemTrackingLine( SalesHeader, SalesLine, WhseShip, WhseReceive, InvtPickPutaway, SalesInvHeader, SalesCrMemoHeader, ItemLedgShptEntryNo, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, GenJnlLineDocNo, SrcCode, ItemJnlPostLine); PostItemTrackingLine(SalesHeader, SalesLine, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced); OnPostSalesLineOnAfterPostItemTrackingLine(SalesHeader, SalesLine, WhseShip, WhseReceive, InvtPickPutaway, TempDropShptPostBuffer, TempPostedATOLink); case SalesLine.Type of SalesLine.Type::"G/L Account": PostGLAccICLine(SalesHeader, SalesLine, ICGenJnlLineNo); SalesLine.Type::Item: PostItemLine(SalesHeader, SalesLine, TempDropShptPostBuffer, TempPostedATOLink); SalesLine.Type::Resource: PostResJnlLine(SalesHeader, SalesLine, JobTaskSalesLine); SalesLine.Type::"Charge (Item)": PostItemChargeLine(SalesHeader, SalesLine); end; ShouldPostLine := (SalesLine.Type <> SalesLine.Type::" ") and (SalesLine."Qty. to Invoice" <> 0); OnPostSalesLineOnBeforePostSalesLine( SalesHeader, SalesLine, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, SrcCode, GenJnlPostLine, ShouldPostLine, SalesLineACY); if ShouldPostLine then begin AdjustPrepmtAmountLCY(SalesHeader, SalesLine); OnPostSalesLineOnAfterAdjustPrepmtAmountLCY(SalesLine, xSalesLine, TempTrackingSpecification, SalesHeader); InvoicePostingInterface.PrepareLine(SalesHeader, SalesLine, SalesLineACY); end; IsHandled := false; OnPostSalesLineOnBeforeTestJobNo(SalesLine, IsHandled); if not IsHandled then if not (SalesLine."Document Type" in [SalesLine."Document Type"::Invoice, SalesLine."Document Type"::"Credit Memo"]) then SalesLine.TestField("Job No.", ''); IsHandled := false; OnPostSalesLineOnBeforeInsertShipmentLine( SalesHeader, SalesLine, IsHandled, SalesLineACY, GenJnlLineDocType.AsInteger(), GenJnlLineDocNo, GenJnlLineExtDocNo); if not IsHandled then if (SalesShptHeader."No." <> '') and (SalesLine."Shipment No." = '') and not RoundingLineInserted and not SalesLine."Prepayment Line" then InsertShipmentLine(SalesHeader, SalesShptHeader, SalesLine, CostBaseAmount); IsHandled := false; OnPostSalesLineOnBeforeInsertReturnReceiptLine(SalesHeader, SalesLine, IsHandled); if not IsHandled then if (ReturnRcptHeader."No." <> '') and (SalesLine."Return Receipt No." = '') and not RoundingLineInserted then InsertReturnReceiptLine(ReturnRcptHeader, SalesLine, CostBaseAmount, SalesHeader); OnPostSalesLineOnAfterInsertReturnReceiptLine(SalesHeader, SalesLine, xSalesLine, ReturnRcptHeader, RoundingLineInserted, TempTrackingSpecification, ItemLedgShptEntryNo, SalesShptHeader); IsHandled := false; if SalesHeader.Invoice then begin ShouldInsertInvoiceLine := SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice]; OnPostSalesLineOnBeforeInsertInvoiceLine(SalesHeader, SalesLine, IsHandled, xSalesLine, SalesInvHeader, ShouldInsertInvoiceLine); if ShouldInsertInvoiceLine and not IsHandled then begin if not IsHandled then begin SalesInvLine.InitFromSalesLine(SalesInvHeader, xSalesLine); OnPostSalesLineOnBeforeCollectValueEntryRelation(SalesHeader, SalesLine, SalesInvHeader, SalesInvLine); ItemJnlPostLine.CollectValueEntryRelation(TempValueEntryRelation, SalesInvLine.RowID1()); OnPostSalesLineOnAfterCollectValueEntryRelation(SalesHeader, SalesLine, SalesInvHeader, SalesInvLine); SetInvoiceOrderNo(SalesLine, SalesInvLine); IsHandled := false; OnBeforeSalesInvLineInsert( SalesInvLine, SalesInvHeader, xSalesLine, SuppressCommit, IsHandled, SalesLine, SalesShptHeader, SalesHeader, ReturnRcptHeader); if IsHandled then exit; if not IsNullGuid(xSalesLine.SystemId) then begin SearchSalesInvLine.SetRange(SystemId, xSalesLine.SystemId); if SearchSalesInvLine.IsEmpty() then begin SalesInvLine.SystemId := xSalesLine.SystemId; SalesInvLine.Insert(true, true); end else begin Session.LogMessage('0000DD6', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok); SalesInvLine.Insert(true); end; end else begin SalesInvLine.Insert(true); Session.LogMessage('0000DDC', EmptyIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok); end; OnAfterSalesInvLineInsert( SalesInvLine, SalesInvHeader, xSalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, SalesHeader, TempItemChargeAssgntSales, TempWhseShptHeader, TempWhseRcptHeader, PreviewMode); InvoicePostingInterface.CreatePostedDeferralSchedule( xSalesLine, SalesInvLine.GetDocumentType(), SalesInvHeader."No.", SalesInvLine."Line No.", SalesInvHeader."Posting Date"); OnPostSalesLineOnAfterCreatePostedDeferralSchedule(SalesInvLine, SalesInvHeader); end; end else begin OnPostSalesLineOnBeforeInsertCrMemoLine(SalesHeader, SalesLine, IsHandled, xSalesLine, SalesCrMemoHeader); if not IsHandled then begin SalesCrMemoLine.InitFromSalesLine(SalesCrMemoHeader, xSalesLine); OnPostSalesLineOnBeforeCollectValueEntryRelationForCrMemo(SalesHeader, SalesLine, SalesInvHeader, SalesInvLine); ItemJnlPostLine.CollectValueEntryRelation(TempValueEntryRelation, SalesCrMemoLine.RowID1()); SetCreditMemoOrderNo(SalesLine, SalesCrMemoLine); IsHandled := false; OnBeforeSalesCrMemoLineInsert( SalesCrMemoLine, SalesCrMemoHeader, xSalesLine, SuppressCommit, IsHandled, SalesHeader, SalesShptHeader, ReturnRcptHeader, SalesLine); if IsHandled then exit; if not IsNullGuid(xSalesLine.SystemId) then begin SearchSalesCrMemoLine.SetRange(SystemId, xSalesLine.SystemId); if SearchSalesCrMemoLine.IsEmpty() then begin SalesCrMemoLine.SystemId := xSalesLine.SystemId; SalesCrMemoLine.Insert(true, true); end else begin Session.LogMessage('0000DD7', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok); SalesCrMemoLine.Insert(true); end; end else begin SalesCrMemoLine.Insert(true); Session.LogMessage('0000DDD', SameIdFoundLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok); end; OnAfterSalesCrMemoLineInsert( SalesCrMemoLine, SalesCrMemoHeader, SalesHeader, xSalesLine, TempItemChargeAssgntSales, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader); InvoicePostingInterface.CreatePostedDeferralSchedule( xSalesLine, SalesCrMemoLine.GetDocumentType(), SalesCrMemoHeader."No.", SalesCrMemoLine."Line No.", SalesCrMemoHeader."Posting Date"); end; end; end; OnAfterPostSalesLine(SalesHeader, SalesLine, SuppressCommit, SalesInvLine, SalesCrMemoLine, xSalesLine); end; local procedure SetInvoiceOrderNo(SalesLine: Record "Sales Line"; var SalesInvLine: Record "Sales Invoice Line") var SalesShptLine: Record "Sales Shipment Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforeSetInvoiceOrderNo(SalesLine, SalesInvLine, IsHandled); if IsHandled then exit; if SalesLine."Document Type" = SalesLine."Document Type"::Order then begin SalesInvLine."Order No." := SalesLine."Document No."; SalesInvLine."Order Line No." := SalesLine."Line No."; end else if SalesShptLine.Get(SalesLine."Shipment No.", SalesLine."Shipment Line No.") then begin SalesInvLine."Order No." := SalesShptLine."Order No."; SalesInvLine."Order Line No." := SalesShptLine."Order Line No."; end; end; local procedure SetCreditMemoOrderNo(SalesLine: Record "Sales Line"; var SalesCrMemoLine: Record "Sales Cr.Memo Line") var ReturnReceiptLine: Record "Return Receipt Line"; begin if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then begin SalesCrMemoLine."Order No." := SalesLine."Document No."; SalesCrMemoLine."Order Line No." := SalesLine."Line No."; end else if ReturnReceiptLine.Get(SalesLine."Return Receipt No.", SalesLine."Return Receipt Line No.") then begin SalesCrMemoLine."Order No." := ReturnReceiptLine."Return Order No."; SalesCrMemoLine."Order Line No." := ReturnReceiptLine."Return Order Line No."; end; end; local procedure UpdateInvoiceRounding(var SalesHeader: Record "Sales Header"; var BiggestLineNo: Integer) begin if RoundingLineInserted then LastLineRetrieved := true else begin BiggestLineNo := MAX(BiggestLineNo, TempSalesLineGlobal."Line No."); LastLineRetrieved := TempSalesLineGlobal.Next() = 0; if LastLineRetrieved and SalesSetup."Invoice Rounding" then InvoiceRounding(SalesHeader, TempSalesLineGlobal, false, BiggestLineNo); end; OnAfterUpdateInvoiceRounding( SalesHeader, TotalSalesLine, TempSalesLineGlobal, Currency, BiggestLineNo, LastLineRetrieved, RoundingLineInserted, RoundingLineNo, false); end; /// <summary> /// Posts sales and VAT to G/L entries from posting buffer and posts customer entry /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="CustLedgEntry">Return value: The customer ledger entry that was created.</param> local procedure PostInvoice(var SalesHeader: Record "Sales Header"; var CustLedgEntry: Record "Cust. Ledger Entry") var TotalAmount: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforePostInvoice(SalesHeader, CustLedgEntry, SuppressCommit, PreviewMode, GenJnlPostLine, IsHandled, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, SrcCode); if IsHandled then exit; // Post sales and VAT to G/L entries from posting buffer GetInvoicePostingParameters(); InvoicePostingInterface.SetParameters(InvoicePostingParameters); InvoicePostingInterface.SetTotalLines(TotalSalesLine, TotalSalesLineLCY); InvoicePostingInterface.PostLines(SalesHeader, GenJnlPostLine, Window, TotalAmount); OnPostInvoiceOnAfterPostLines(SalesHeader, SrcCode, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlPostLine); // Post customer entry if GuiAllowed() and not HideProgressWindow then Window.Update(4, 1); InvoicePostingInterface.SetParameters(InvoicePostingParameters); InvoicePostingInterface.SetTotalLines(TotalSalesLine, TotalSalesLineLCY); InvoicePostingInterface.PostLedgerEntry(SalesHeader, GenJnlPostLine); UpdateSalesHeader(CustLedgEntry, SalesHeader); // Balancing account if SalesHeader."Bal. Account No." <> '' then begin IsHandled := false; OnPostInvoiceOnBeforeBalAccountNoWindowUpdate(HideProgressWindow, IsHandled, SalesHeader); if not IsHandled then if GuiAllowed() and not HideProgressWindow then Window.Update(5, 1); IsHandled := false; OnPostInvoiceOnBeforePostBalancingEntry(SalesHeader, IsHandled, TotalSalesLine, TotalSalesLineLCY, PreviewMode, SuppressCommit, InvoicePostingParameters, GenJnlPostLine, SalesInvHeader, SalesCrMemoHeader); if not IsHandled then InvoicePostingInterface.PostBalancingEntry(SalesHeader, GenJnlPostLine); end; OnAfterPostGLAndCustomer( SalesHeader, GenJnlPostLine, TotalSalesLine, TotalSalesLineLCY, SuppressCommit, WhseShptHeader, WhseShip, TempWhseShptHeader, SalesInvHeader, SalesCrMemoHeader, CustLedgEntry, SrcCode, GenJnlLineDocNo, GenJnlLineExtDocNo, GenJnlLineDocType, PreviewMode, DropShipOrder); end; /// <summary> /// Creates a General Journal Line for Inter Company posting /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="ICGenJnlLineNo">Return value: The line number of the Inter Company General Journal Line for that was created.</param> local procedure PostGLAccICLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var ICGenJnlLineNo: Integer) begin if (SalesLine."No." <> '') and not SalesLine."System-Created Entry" then begin CheckGLAccountDirectPosting(SalesLine); if (SalesLine."IC Partner Code" <> '') and SalesHeader.Invoice then InsertICGenJnlLine(SalesHeader, xSalesLine, ICGenJnlLineNo); end; end; local procedure CheckGLAccountDirectPosting(SalesLine: Record "Sales Line") var GLAcc: Record "G/L Account"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckGLAccountDirectPosting(SalesLine, IsHandled); if IsHandled then exit; GLAcc.Get(SalesLine."No."); GLAcc.TestField("Direct Posting", true); end; /// <summary> /// Creates and posts (Invoice and Ship) Item Journal Lines for Sales lines of type Item /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted. A line with Type "Item" is expected.</param> /// <param name="TempDropShptPostBuffer">Return Variable: A temp table Set that will get an additional entry with Drop Shipment information.</param> /// <param name="TempPostedATOLink">A temp table Set containing Posted Assemble-to-Order Links. If a link exists, it posts an item journal line with assembled quantity</param> procedure PostItemLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary) var DummyTrackingSpecification: Record "Tracking Specification"; SalesLineToShip: Record "Sales Line"; QtyToInvoice: Decimal; QtyToInvoiceBase: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemLine(SalesHeader, SalesLine, IsHandled, TempSalesLineGlobal, TempDropShptPostBuffer, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, ItemJnlPostLine); if IsHandled then exit; ItemLedgShptEntryNo := 0; QtyToInvoice := RemQtyToBeInvoiced; QtyToInvoiceBase := RemQtyToBeInvoicedBase; ProcessAssocItemJnlLine(SalesHeader, SalesLine, TempDropShptPostBuffer); Clear(TempPostedATOLink); TempPostedATOLink.SetRange("Order No.", SalesLine."Document No."); TempPostedATOLink.SetRange("Order Line No.", SalesLine."Line No."); if TempPostedATOLink.FindFirst() then PostATOAssocItemJnlLine(SalesHeader, SalesLine, TempPostedATOLink, QtyToInvoice, QtyToInvoiceBase); OnPostItemLineOnBeforePostItemInvoiceLine(SalesHeader, SalesLine, TempDropShptPostBuffer, TempPostedATOLink, QtyToInvoice, QtyToInvoiceBase); if QtyToInvoice <> 0 then ItemLedgShptEntryNo := PostItemJnlLine( SalesHeader, SalesLine, QtyToInvoice, QtyToInvoiceBase, QtyToInvoice, QtyToInvoiceBase, 0, '', DummyTrackingSpecification, false); IsHandled := false; OnPostItemLineOnBeforeMakeSalesLineToShip( SalesHeader, SalesLine, TempPostedATOLink, ItemLedgShptEntryNo, IsHandled, GenJnlLineDocNo, GenJnlLineExtDocNo, ReturnRcptHeader, TempHandlingSpecification, TempTrackingSpecificationInv, TempTrackingSpecification); if not IsHandled then begin // Invoice discount amount is also included in expected sales amount posted for shipment or return receipt. MakeSalesLineToShip(SalesLineToShip, SalesLine); OnPostItemLineOnAfterMakeSalesLineToShip(SalesHeader, SalesLine, TempDropShptPostBuffer, TempPostedATOLink, QtyToInvoice, QtyToInvoiceBase); if SalesLineToShip.IsCreditDocType() then begin if Abs(SalesLineToShip."Return Qty. to Receive") > Abs(QtyToInvoice) then ItemLedgShptEntryNo := PostItemJnlLine( SalesHeader, SalesLineToShip, SalesLineToShip."Return Qty. to Receive" - QtyToInvoice, SalesLineToShip."Return Qty. to Receive (Base)" - QtyToInvoiceBase, 0, 0, 0, '', DummyTrackingSpecification, false); end else begin IsHandled := false; OnPostItemLineOnBeforePostItemJnlLineForInvoiceDoc(SalesHeader, SalesLineToShip, SalesHeader.Ship, ItemLedgShptEntryNo, GenJnlLineDocNo, GenJnlLineExtDocNo, SalesShptHeader, TempHandlingSpecification, TempTrackingSpecificationInv, TempTrackingSpecification, IsHandled, QtyToInvoice, TempPostedATOLink); if not IsHandled then if Abs(SalesLineToShip."Qty. to Ship") > Abs(QtyToInvoice) + Abs(TempPostedATOLink."Assembled Quantity") then ItemLedgShptEntryNo := PostItemJnlLine( SalesHeader, SalesLineToShip, SalesLineToShip."Qty. to Ship" - TempPostedATOLink."Assembled Quantity" - QtyToInvoice, SalesLineToShip."Qty. to Ship (Base)" - TempPostedATOLink."Assembled Quantity (Base)" - QtyToInvoiceBase, 0, 0, 0, '', DummyTrackingSpecification, false); end; end; OnAfterPostItemLine(SalesHeader, SalesLine, QtyToInvoice, QtyToInvoiceBase, SuppressCommit, ItemJnlPostLine); end; /// <summary> /// Processes associated item journal lines for drop shipment orders. /// </summary> /// <param name="SalesHeader">Specifies the sales header of the document being posted.</param> /// <param name="SalesLine">Specifies the sales line being processed.</param> /// <param name="TempDropShptPostBuffer">Returns the drop shipment posting buffer with the associated item entry.</param> procedure ProcessAssocItemJnlLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) var IsHandled: Boolean; begin IsHandled := false; OnBeforeProcessAssocItemJnlLine(SalesLine, IsHandled, SalesHeader, TempDropShptPostBuffer); if IsHandled then exit; if (SalesLine."Qty. to Ship" <> 0) and (SalesLine."Purch. Order Line No." <> 0) then begin TempDropShptPostBuffer."Order No." := SalesLine."Purchase Order No."; TempDropShptPostBuffer."Order Line No." := SalesLine."Purch. Order Line No."; TempDropShptPostBuffer.Quantity := -SalesLine."Qty. to Ship"; TempDropShptPostBuffer."Quantity (Base)" := -SalesLine."Qty. to Ship (Base)"; OnProcessAssocItemJnlLineOnBeforePostAssocItemJnlLine(TempDropShptPostBuffer, SalesLine); TempDropShptPostBuffer."Item Shpt. Entry No." := PostAssocItemJnlLine(SalesHeader, SalesLine, TempDropShptPostBuffer.Quantity, TempDropShptPostBuffer."Quantity (Base)"); OnProcessAssocItemJnlLineOnBeforeTempDropShptPostBufferInsert(TempDropShptPostBuffer, SalesLine); TempDropShptPostBuffer.Insert(); SalesLine."Appl.-to Item Entry" := TempDropShptPostBuffer."Item Shpt. Entry No."; end; end; local procedure PostItemChargeLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") var SalesLineBackup: Record "Sales Line"; IsHandled: Boolean; begin if not (SalesHeader.Invoice and (SalesLine."Qty. to Invoice" <> 0)) then exit; IsHandled := false; OnBeforePostItemChargeLine(SalesHeader, SalesLine, IsHandled); if IsHandled then exit; ItemJnlRollRndg := true; SalesLineBackup.Copy(SalesLine); if FindTempItemChargeAssgntSales(SalesLineBackup."Line No.") then repeat OnPostItemChargeLineOnBeforePostItemCharge(TempItemChargeAssgntSales, SalesHeader, SalesLineBackup); case TempItemChargeAssgntSales."Applies-to Doc. Type" of TempItemChargeAssgntSales."Applies-to Doc. Type"::Shipment: begin PostItemChargePerShpt(SalesHeader, SalesLineBackup); TempItemChargeAssgntSales.Mark(true); end; TempItemChargeAssgntSales."Applies-to Doc. Type"::"Return Receipt": begin PostItemChargePerRetRcpt(SalesHeader, SalesLineBackup); TempItemChargeAssgntSales.Mark(true); end; TempItemChargeAssgntSales."Applies-to Doc. Type"::Order, TempItemChargeAssgntSales."Applies-to Doc. Type"::Invoice, TempItemChargeAssgntSales."Applies-to Doc. Type"::"Return Order", TempItemChargeAssgntSales."Applies-to Doc. Type"::"Credit Memo": CheckItemCharge(TempItemChargeAssgntSales); end; OnPostItemChargeLineOnAfterTempItemChargeAssgntSalesLoop(TempItemChargeAssgntSales, SalesHeader, SalesLineBackup, SalesLine); until TempItemChargeAssgntSales.Next() = 0; OnAfterPostItemChargeLine(SalesLine, SalesLineACY); end; /// <summary> /// Finds Tracking Specification for the sales line, Posts Item Tracking and saves the Tracking Specification in a temp table /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="TempItemLedgEntryNotInvoiced">A temp table that will be filled in with all Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param> /// <param name="HasATOShippedNotInvoiced">A flag telling whether there are any Assemble-to-order item ledger entries that have not been invoiced yet. Used when posting Item tracking for Shipment if Tracking Specification doesn't exist</param> local procedure PostItemTrackingLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean) var TempTrackingSpecification: Record "Tracking Specification" temporary; TrackingSpecificationExists: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemTrackingLine(SalesHeader, SalesLine, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced, IsHandled, ItemLedgShptEntryNo, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, SalesInvHeader, SalesCrMemoHeader); if IsHandled then exit; if SalesLine."Prepayment Line" then exit; if SalesHeader.Invoice then if SalesLine."Qty. to Invoice" = 0 then TrackingSpecificationExists := false else TrackingSpecificationExists := SalesLineReserve.RetrieveInvoiceSpecification(SalesLine, TempTrackingSpecification); OnPostItemTrackingLineOnAfterRetrieveInvoiceSpecification(SalesLine, TempTrackingSpecification, TrackingSpecificationExists); PostItemTracking( SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced); if TrackingSpecificationExists then SaveInvoiceSpecification(TempTrackingSpecification); end; /// <summary> /// Creates and posts Item Journal Line for a sales line /// Creates Tracking Specification entries for the Journal Line /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="QtyToBeShipped">The quantity of the Item to be shipped.</param> /// <param name="QtyToBeShippedBase">The base quantity of the Item to be shipped.</param> /// <param name="QtyToBeInvoiced">The quantity of the Item to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The base quantity of the Item to be invoiced.</param> /// <param name="ItemLedgShptEntryNo">Item Shipment Entry No. to be assigned to the Item Journal Line.</param> /// <param name="ItemChargeNo">Item Charge No. to be assigned to the Item Journal Line.</param> /// <param name="TrackingSpecification">Tracking Specification for the sales line. This parameter is exposed through events, but isn't directly used in the procedure</param> /// <param name="IsATO">A flag indicating whether the Item is Assemble-to-order.</param> /// <returns>The Item Shipment Entry No. assigned to the Item Journal Line.</returns> procedure PostItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ItemLedgShptEntryNo: Integer; ItemChargeNo: Code[20]; TrackingSpecification: Record "Tracking Specification"; IsATO: Boolean) Result: Integer var ItemJnlLine: Record "Item Journal Line"; TempWhseJnlLine: Record "Warehouse Journal Line" temporary; TempWhseTrackingSpecification: Record "Tracking Specification" temporary; OriginalItemJnlLine: Record "Item Journal Line"; ItemShptEntryNo: Integer; PostWhseJnlLine: Boolean; IsHandled: Boolean; ShouldPostItemJnlLine: Boolean; ShouldPostItemJnlLineItemCharges: Boolean; begin IsHandled := false; OnBeforePostItemJnlLine( SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase, QtyToBeInvoiced, QtyToBeInvoicedBase, ItemLedgShptEntryNo, ItemChargeNo, TrackingSpecification, IsATO, SuppressCommit, IsHandled, Result, TempTrackingSpecification, TempHandlingSpecification, TempValueEntryRelation, ItemJnlPostLine); if IsHandled then exit(Result); PostItemJnlLinePrepareJournalLine( ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase, QtyToBeInvoiced, QtyToBeInvoicedBase, ItemLedgShptEntryNo, ItemChargeNo, TrackingSpecification, IsATO); ShouldPostItemJnlLine := not JobContractLine; OnPostItemJnlLineOnBeforeIsJobContactLineCheck(ItemJnlLine, SalesHeader, SalesLine, ShouldPostItemJnlLine, ItemJnlPostLine, QtyToBeShipped); if ShouldPostItemJnlLine then begin PostItemJnlLineBeforePost(ItemJnlLine, SalesLine, TempWhseJnlLine, PostWhseJnlLine, QtyToBeShippedBase, TrackingSpecification); OriginalItemJnlLine := ItemJnlLine; if not IsItemJnlPostLineHandled(ItemJnlLine, SalesLine, SalesHeader) then RunItemJnlPostLine(ItemJnlLine); OnPostItemJnlLineOnAfterItemJnlPostLineRunWithCheck(ItemJnlPostLine, SalesLine); if IsATO then PostItemJnlLineTracking( SalesLine, TempWhseTrackingSpecification, PostWhseJnlLine, QtyToBeInvoiced, TempATOTrackingSpecification) else PostItemJnlLineTracking(SalesLine, TempWhseTrackingSpecification, PostWhseJnlLine, QtyToBeInvoiced, TempHandlingSpecification); IsHandled := false; OnPostItemJnlLineOnBeforePostItemJnlLineWhseLine( ItemJnlLine, TempWhseJnlLine, TempWhseTrackingSpecification, TempTrackingSpecification, IsHandled, SalesLine); if not IsHandled then PostItemJnlLineWhseLine(TempWhseJnlLine, TempWhseTrackingSpecification); OnAfterPostItemJnlLineWhseLine(SalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit); ShouldPostItemJnlLineItemCharges := (SalesLine.Type = SalesLine.Type::Item) and SalesHeader.Invoice; OnPostItemJnlLineOnAfterCalcShouldPostItemJnlLineItemCharges(SalesLine, SalesHeader, ShouldPostItemJnlLineItemCharges); if ShouldPostItemJnlLineItemCharges then PostItemJnlLineItemCharges(SalesHeader, SalesLine, OriginalItemJnlLine, ItemJnlLine."Item Shpt. Entry No."); end; ItemShptEntryNo := ItemJnlLine."Item Shpt. Entry No."; OnAfterPostItemJnlLine(ItemJnlLine, SalesLine, SalesHeader, ItemJnlPostLine, WhseJnlPostLine, OriginalItemJnlLine, ItemShptEntryNo, IsATO, TempHandlingSpecification, TempATOTrackingSpecification, TempWhseJnlLine, ShouldPostItemJnlLine, WhseShip, WhseRcptHeader, WhseShptHeader); exit(ItemShptEntryNo); end; /// <summary> /// Prepares Item Journal Line for posting with information from sales header, sales line and parameters /// </summary> /// <param name="ItemJnlLine">Return value: The Item Journal Line that was prepared.</param> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="QtyToBeShipped">The quantity of the Item to be shipped.</param> /// <param name="QtyToBeShippedBase">The base quantity of the Item to be shipped.</param> /// <param name="QtyToBeInvoiced">The quantity of the Item to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The base quantity of the Item to be invoiced.</param> /// <param name="ItemLedgShptEntryNo">Item Shipment Entry No. to be assigned to the Item Journal Line.</param> /// <param name="ItemChargeNo">Item Charge No. to be assigned to the Item Journal Line.</param> /// <param name="TrackingSpecification">Tracking Specification for the sales line. This parameter is exposed through events, but isn't directly used in the procedure</param> /// <param name="IsATO">A flag indicating whether the Item is Assemble-to-order.</param> procedure PostItemJnlLinePrepareJournalLine(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ItemLedgShptEntryNo: Integer; ItemChargeNo: Code[20]; TrackingSpecification: Record "Tracking Specification"; IsATO: Boolean) var DummyItemTrackingSetup: Record "Item Tracking Setup"; IsHandled: Boolean; begin ClearRemAmtIfNotItemJnlRollRndg(SalesLine); ItemJnlLine.Init(); ItemJnlLine.CopyFromSalesHeader(SalesHeader); ItemJnlLine.CopyFromSalesLine(SalesLine); ItemJnlLine."Country/Region Code" := GetCountryCode(SalesLine, SalesHeader); OnPostItemJnlLineOnBeforeCopyTrackingFromSpec( TrackingSpecification, ItemJnlLine, SalesHeader, SalesLine, SalesInvHeader, SalesCrMemoHeader, IsATO); ItemJnlLine.CopyTrackingFromSpec(TrackingSpecification); OnPostItemJnlLineOnAfterCopyTrackingFromSpec(ItemJnlLine, SalesLine, QtyToBeShipped, IsATO); ItemJnlLine."Item Shpt. Entry No." := ItemLedgShptEntryNo; IsHandled := false; OnPostItemJnlLinePrepareJournalLineOnBeforeCalcQuantities( ItemJnlLine, SalesLine, QtyToBeShipped, QtyToBeShippedBase, QtyToBeInvoiced, QtyToBeInvoicedBase, IsHandled, IsATO); if not IsHandled then begin ItemJnlLine.Quantity := -QtyToBeShipped; ItemJnlLine."Quantity (Base)" := -QtyToBeShippedBase; ItemJnlLine."Invoiced Quantity" := -QtyToBeInvoiced; ItemJnlLine."Invoiced Qty. (Base)" := -QtyToBeInvoicedBase; end; PostItemJnlLineCopyDocumentFields(ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeInvoiced); if QtyToBeInvoiced <> 0 then ItemJnlLine."Invoice No." := GenJnlLineDocNo; ItemJnlLine."Assemble to Order" := IsATO; if ItemJnlLine."Assemble to Order" then ItemJnlLine."Applies-to Entry" := SalesLine.FindOpenATOEntry(DummyItemTrackingSetup) else ItemJnlLine."Applies-to Entry" := SalesLine."Appl.-to Item Entry"; if ItemChargeNo <> '' then begin ItemJnlLine."Item Charge No." := ItemChargeNo; SalesLine."Qty. to Invoice" := QtyToBeInvoiced; OnPostItemJnlLineOnAfterCopyItemCharge(ItemJnlLine, TempItemChargeAssgntSales); end else ItemJnlLine."Applies-from Entry" := SalesLine."Appl.-from Item Entry"; OnPostItemJnlLinePrepareJournalLineOnBeforeCalcItemJnlAmounts(ItemJnlLine, SalesHeader, SalesLine, IsATO); if QtyToBeInvoiced <> 0 then CalcItemJnlAmountsFromQtyToBeInvoiced(ItemJnlLine, SalesHeader, SalesLine, QtyToBeInvoiced) else CalcItemJnlAmountsFromQtyToBeShipped(ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped); OnPostItemJnlLineOnAfterPrepareItemJnlLine( ItemJnlLine, SalesLine, SalesHeader, WhseShip, ItemJnlPostLine, QtyToBeShipped, TrackingSpecification, QtyToBeInvoiced, QtyToBeInvoicedBase, QtyToBeShippedBase, RemAmt, RemDiscAmt); end; local procedure CalcItemJnlAmountsFromQtyToBeInvoiced(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal) var Factor: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcItemJnlAmountsFromQtyToBeInvoiced(ItemJnlLine, SalesHeader, SalesLine, QtyToBeInvoiced, IsHandled); if IsHandled then exit; Factor := QtyToBeInvoiced / SalesLine."Qty. to Invoice"; OnCalcItemJnlAmountsFromQtyToBeInvoicedOnAfterSetFactor(SalesLine, Factor, ItemJnlLine); ItemJnlLine.Amount := -(SalesLine.Amount * Factor - RemAmt); if SalesHeader."Prices Including VAT" then ItemJnlLine."Discount Amount" := -((SalesLine."Line Discount Amount" + SalesLine."Inv. Discount Amount") / (1 + SalesLine."VAT %" / 100) * Factor - RemDiscAmt) else ItemJnlLine."Discount Amount" := -((SalesLine."Line Discount Amount" + SalesLine."Inv. Discount Amount") * Factor - RemDiscAmt); RemAmt := ItemJnlLine.Amount - Round(ItemJnlLine.Amount); RemDiscAmt := ItemJnlLine."Discount Amount" - Round(ItemJnlLine."Discount Amount"); ItemJnlLine.Amount := Round(ItemJnlLine.Amount); ItemJnlLine."Discount Amount" := Round(ItemJnlLine."Discount Amount"); end; local procedure CalcItemJnlAmountsFromQtyToBeShipped(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal) var InvDiscAmountPerShippedQty: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcItemJnlAmountsFromQtyToBeShipped(ItemJnlLine, SalesHeader, SalesLine, QtyToBeShipped, IsHandled, InvDiscAmountPerShippedQty, RemAmt); if IsHandled then exit; InvDiscAmountPerShippedQty := Abs(SalesLine."Inv. Discount Amount") * QtyToBeShipped / SalesLine.Quantity; ItemJnlLine.Amount := QtyToBeShipped * SalesLine."Unit Price"; if SalesHeader."Prices Including VAT" then ItemJnlLine.Amount := -((ItemJnlLine.Amount * (1 - SalesLine."Line Discount %" / 100) - InvDiscAmountPerShippedQty) / (1 + SalesLine."VAT %" / 100) - RemAmt) else ItemJnlLine.Amount := -(ItemJnlLine.Amount * (1 - SalesLine."Line Discount %" / 100) - InvDiscAmountPerShippedQty - RemAmt); RemAmt := ItemJnlLine.Amount - Round(ItemJnlLine.Amount); if SalesHeader."Currency Code" <> '' then ItemJnlLine.Amount := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader."Posting Date", SalesHeader."Currency Code", ItemJnlLine.Amount, SalesHeader."Currency Factor")) else ItemJnlLine.Amount := Round(ItemJnlLine.Amount); end; /// <summary> /// Gets global document headers that were created during posting /// </summary> /// <param name="NewSalesShptHeader">Return value: Sales Shipment Header</param> /// <param name="NewSalesInvHeader">Return value: Sales Invoice Header</param> /// <param name="NewSalesCrMemoHeader">Return value: Sales Credit Memo Header</param> /// <param name="NewReturnRcptHeader">Return value: Return Receipt Header</param> procedure GetGlobaDocumentsHeaders(var NewSalesShptHeader: Record "Sales Shipment Header"; var NewSalesInvHeader: Record "Sales Invoice Header"; var NewSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var NewReturnRcptHeader: Record "Return Receipt Header") begin NewSalesShptHeader := SalesShptHeader; NewSalesInvHeader := SalesInvHeader; NewReturnRcptHeader := ReturnRcptHeader; NewSalesCrMemoHeader := SalesCrMemoHeader; end; /// <summary> /// Gets global warehouse posting flags that were set during posting /// </summary> /// <param name="NewWhseShip">Return value: Warehouse Shipment</param> /// <param name="NewWhseReceive">Return value: Warehouse Receipt</param> /// <param name="NewInvtPickPutaway">Return value: Inventory Pick/Put-Away</param> procedure GetGlobalWhseFlags(var NewWhseShip: Boolean; var NewWhseReceive: Boolean; var NewInvtPickPutaway: Boolean) begin NewWhseShip := WhseShip; NewWhseReceive := WhseReceive; NewInvtPickPutaway := InvtPickPutaway; end; /// <summary> /// Gets the Temp Set of Invoiced Tracking Specification lines /// </summary> /// <remarks> /// When Tracking Specification is posted for the line, if line is invoiced (Qty. to Invoice is not 0), the line's tracking information is stored in this buffer /// </remarks> /// <param name="NewTempTrackingSpecificationInv">Return value: Temp Tracking Specification lines that were Invoiced</param> procedure GetGlobalTempTrackingSpecificationInv(var NewTempTrackingSpecificationInv: Record "Tracking Specification" temporary) begin NewTempTrackingSpecificationInv.Copy(TempTrackingSpecificationInv, true); end; /// <summary> /// Gets the Temp Set of Posted Tracking Specification lines that were posted for the document /// </summary> /// <param name="NewTempTrackingSpecification">Return value: Temp Tracking Specification lines that were Posted</param> procedure GetGlobalTempTrackingSpecification(var NewTempTrackingSpecification: Record "Tracking Specification" temporary) begin NewTempTrackingSpecification.Copy(TempTrackingSpecification, true); end; /// <summary> /// Gets the Source Code that was used during posting /// </summary> /// <param name="NewSrcCode">Return value: Source Code</param> procedure GetGlobalSrcCode(var NewSrcCode: Code[10]) begin NewSrcCode := SrcCode; end; local procedure ClearRemAmtIfNotItemJnlRollRndg(SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeClearRemAmtIfNotItemJnlRollRndg(SalesLine, ItemJnlRollRndg, RemAmt, RemDiscAmt, IsHandled); if IsHandled then exit; if not ItemJnlRollRndg then begin RemAmt := 0; RemDiscAmt := 0; end; end; local procedure PostItemJnlLineCopyDocumentFields(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeInvoiced: Decimal) var QtyToBeShippedIsZero: Boolean; begin QtyToBeShippedIsZero := QtyToBeShipped = 0; OnBeforePostItemJnlLineCopyDocumentFields(SalesHeader, QtyToBeShipped, QtyToBeShippedIsZero); if QtyToBeShippedIsZero then if SalesLine.IsCreditDocType() then ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Sales Credit Memo", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series") else ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Sales Invoice", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series") else begin if SalesLine.IsCreditDocType() then ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Sales Return Receipt", ReturnRcptHeader."No.", ReturnRcptHeader."External Document No.", SrcCode, ReturnRcptHeader."No. Series") else ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Sales Shipment", SalesShptHeader."No.", SalesShptHeader."External Document No.", SrcCode, SalesShptHeader."No. Series"); if QtyToBeInvoiced <> 0 then begin if ItemJnlLine."Document No." = '' then if SalesLine."Document Type" = SalesLine."Document Type"::"Credit Memo" then ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Sales Credit Memo", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series") else ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Sales Invoice", GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series"); ItemJnlLine."Posting No. Series" := SalesHeader."Posting No. Series"; end; end; OnPostItemJnlLineOnAfterCopyDocumentFields(ItemJnlLine, SalesLine, TempWhseRcptHeader, TempWhseShptHeader); end; /// <summary> /// Posts Item Charges for a sales line /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="OriginalItemJnlLine">The original Item Journal Line that was posted for the sales line. It servers as the basis for Item Journal Lines that are created for Item Charges.</param> /// <param name="ItemShptEntryNo">Item Shipment Entry No. that is assigned to journal lines for Item Charges.</param> procedure PostItemJnlLineItemCharges(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var OriginalItemJnlLine: Record "Item Journal Line"; ItemShptEntryNo: Integer) var ItemChargeSalesLine: Record "Sales Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemJnlLineItemCharges(SalesLine, IsHandled); if IsHandled then exit; ClearItemChargeAssgntFilter(); TempItemChargeAssgntSales.SetCurrentKey( "Applies-to Doc. Type", "Applies-to Doc. No.", "Applies-to Doc. Line No."); TempItemChargeAssgntSales.SetRange("Applies-to Doc. Type", SalesLine."Document Type"); TempItemChargeAssgntSales.SetRange("Applies-to Doc. No.", SalesLine."Document No."); TempItemChargeAssgntSales.SetRange("Applies-to Doc. Line No.", SalesLine."Line No."); if TempItemChargeAssgntSales.FindSet() then repeat SalesLine.TestField("Allow Item Charge Assignment"); GetItemChargeLine(SalesHeader, ItemChargeSalesLine); OnPostItemJnlLineItemChargesOnAfterGetItemChargeLine(ItemChargeSalesLine, SalesLine); ItemChargeSalesLine.CalcFields("Qty. Assigned"); if (ItemChargeSalesLine."Qty. to Invoice" <> 0) or (Abs(ItemChargeSalesLine."Qty. Assigned") < Abs(ItemChargeSalesLine."Quantity Invoiced")) then begin OriginalItemJnlLine."Item Shpt. Entry No." := ItemShptEntryNo; PostItemChargePerOrder(SalesHeader, SalesLine, OriginalItemJnlLine, ItemChargeSalesLine); TempItemChargeAssgntSales.Mark(true); end; until TempItemChargeAssgntSales.Next() = 0; end; /// <summary> /// Adds Tracking Specification for a sales line to the global temp tables where it will later be posted from /// </summary> /// <remarks> /// If line is being invoiced, it's additionally stored in TempTrackingSpecificationInv, /// and if Warehouse Journal Lines are being posted, it's also stored in TempWhseTrackingSpecification /// </remarks> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="TempWhseTrackingSpecification">Return value: Temp Tracking Specification lines realted to Warehouse Journal Lines</param> /// <param name="PostWhseJnlLine">A flag indicating whether Warehouse Journal Lines should be posted for the sales line.</param> /// <param name="QtyToBeInvoiced">The quantity of the Item to be invoiced.</param> /// <param name="TempTrackingSpec">Return value: Temp Tracking Specification lines related to the Item Journal Line</param> procedure PostItemJnlLineTracking(SalesLine: Record "Sales Line"; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; PostWhseJnlLine: Boolean; QtyToBeInvoiced: Decimal; var TempTrackingSpec: Record "Tracking Specification" temporary) var ShouldInsertTrkgSpecInv: Boolean; begin if ItemJnlPostLine.CollectTrackingSpecification(TempTrackingSpec) then if TempTrackingSpec.FindSet() then repeat TempTrackingSpecification := TempTrackingSpec; TempTrackingSpecification.SetSourceFromSalesLine(SalesLine); OnPostItemJnlLineTrackingOnBeforeInsertTempTrkgSpec(TempTrackingSpecification, TempTrackingSpec, SalesLine); if TempTrackingSpecification.Insert() then; ShouldInsertTrkgSpecInv := QtyToBeInvoiced <> 0; OnPostItemJnlLineTrackingOnAfterCalcShouldInsertTrkgSpecInv(SalesLine, QtyToBeInvoiced, ShouldInsertTrkgSpecInv); // <-- NEW EVENT if ShouldInsertTrkgSpecInv then begin TempTrackingSpecificationInv := TempTrackingSpecification; if TempTrackingSpecificationInv.Insert() then; end; if PostWhseJnlLine then begin TempWhseTrackingSpecification := TempTrackingSpecification; if TempWhseTrackingSpecification.Insert() then; end; until TempTrackingSpec.Next() = 0; end; /// <summary> /// Splits the incoming Warehouse Journal Line into more lines if tracking is required and posts them /// </summary> /// <param name="TempWhseJnlLine">The Warehouse Journal Line to be posted.</param> /// <param name="TempWhseTrackingSpecification">The Tracking Specification Record Set for the Warehouse Journal Line.</param> procedure PostItemJnlLineWhseLine(var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary) var TempWhseJnlLine2: Record "Warehouse Journal Line" temporary; WMSMgt: Codeunit "WMS Management"; begin OnBeforePostItemJournalLineWarehouseLine(TempWhseJnlLine, TempWhseTrackingSpecification); ItemTrackingMgt.SplitWhseJnlLine(TempWhseJnlLine, TempWhseJnlLine2, TempWhseTrackingSpecification, false); if TempWhseJnlLine2.FindSet() then repeat OnPostItemJnlLineWhseLineOnBeforePostTempWhseJnlLine2(TempWhseJnlLine2, WhseShip, WhseReceive, InvtPickPutaway); if TempWhseJnlLine2."Location Code" <> '' then WMSMgt.CheckWhseJnlLine(TempWhseJnlLine2, 1, 0, false); WhseJnlPostLine.Run(TempWhseJnlLine2); until TempWhseJnlLine2.Next() = 0; TempWhseTrackingSpecification.DeleteAll(); OnAfterPostItemJournalLineWarehouseLine(TempWhseJnlLine, TempWhseTrackingSpecification); end; /// <summary> /// Prepares Warehouse Journal Line and Reservation Entries for later posting /// </summary> /// <param name="ItemJnlLine">The Item Journal Line to be posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="TempWhseJnlLine">Return value: The Warehouse Journal Line information that gets populated if the sales line requires Warehouse Journal Line to be posted.</param> /// <param name="PostWhseJnlLine">Return value: A flag indicating whether Warehouse Journal Lines should be posted for the sales line.</param> /// <param name="QtyToBeShippedBase">The base quantity of the Item to be shipped.</param> /// <param name="TrackingSpecification">Tracking Specification for the sales line. This parameter is exposed through events, but isn't directly used in the procedure</param> procedure PostItemJnlLineBeforePost(var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var PostWhseJnlLine: Boolean; QtyToBeShippedBase: Decimal; TrackingSpecification: Record "Tracking Specification") var CheckApplFromItemEntry: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemJnlLineBeforePost(SalesLine, ItemJnlLine, TempWhseJnlLine, Location, PostWhseJnlLine, QtyToBeShippedBase, IsHandled, TrackingSpecification); if IsHandled then exit; if SalesSetup."Exact Cost Reversing Mandatory" and (SalesLine.Type = SalesLine.Type::Item) then if SalesLine.IsCreditDocType() then CheckApplFromItemEntry := SalesLine.Quantity > 0 else CheckApplFromItemEntry := SalesLine.Quantity < 0; if (SalesLine."Location Code" <> '') and (SalesLine.Type = SalesLine.Type::Item) and (ItemJnlLine.Quantity <> 0) then if ShouldPostWhseJnlLine(SalesLine) then begin CreateWhseJnlLine(ItemJnlLine, SalesLine, TempWhseJnlLine); PostWhseJnlLine := true; end; OnPostItemJnlLineOnBeforeTransferReservToItemJnlLine(SalesLine, ItemJnlLine, CheckApplFromItemEntry, TrackingSpecification, QtyToBeShippedBase); if QtyToBeShippedBase <> 0 then begin if SalesLine.IsCreditDocType() then SalesLineReserve.TransferSalesLineToItemJnlLine(SalesLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false) else TransferReservToItemJnlLine( SalesLine, ItemJnlLine, -QtyToBeShippedBase, TempTrackingSpecification, CheckApplFromItemEntry); if CheckApplFromItemEntry and SalesLine.IsInventoriableItem() then SalesLine.TestField("Appl.-from Item Entry"); end; OnAfterPostItemJnlLineBeforePost(ItemJnlLine, SalesLine, QtyToBeShippedBase, ItemJnlPostLine, CheckApplFromItemEntry, TrackingSpecification); end; /// <summary> /// Checks wheter a Warehouse Journal Line should be posted for a sales line /// </summary> /// <param name="SalesLine">The sales line for which the check is performed.</param> /// <returns>true if a Warehouse Journal Line should be posted for the sales line; otherwise, false.</returns> procedure ShouldPostWhseJnlLine(SalesLine: Record "Sales Line") Result: Boolean var IsHandled: Boolean; begin OnBeforeShouldPostWhseJnlLine(SalesLine, Result, IsHandled); if IsHandled then exit(Result); if SalesLine.IsInventoriableItem() then begin GetLocation(SalesLine."Location Code"); if ((SalesLine."Document Type" in [SalesLine."Document Type"::Invoice, SalesLine."Document Type"::"Credit Memo"]) and Location."Directed Put-away and Pick") or (Location."Bin Mandatory" and not (WhseShip or WhseReceive or InvtPickPutaway or SalesLine."Drop Shipment")) then exit(true); end; exit(false); end; local procedure PostItemChargePerOrder(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; ItemJnlLine2: Record "Item Journal Line"; ItemChargeSalesLine: Record "Sales Line") var NonDistrItemJnlLine: Record "Item Journal Line"; QtyToInvoice: Decimal; Factor: Decimal; OriginalAmt: Decimal; OriginalDiscountAmt: Decimal; OriginalQty: Decimal; SignFactor: Integer; IsHandled: Boolean; begin OnBeforePostItemChargePerOrder(SalesHeader, SalesLine, ItemJnlLine2, ItemChargeSalesLine, SuppressCommit); IsHandled := false; OnPostItemChargePerOrderOnBeforeTestJobNo(SalesLine, IsHandled); if not IsHandled then SalesLine.TestField("Job No.", ''); SalesLine.TestField("Allow Item Charge Assignment", true); ItemJnlLine2."Document No." := GenJnlLineDocNo; ItemJnlLine2."External Document No." := GenJnlLineExtDocNo; ItemJnlLine2."Item Charge No." := TempItemChargeAssgntSales."Item Charge No."; ItemJnlLine2.Description := ItemChargeSalesLine.Description; ItemJnlLine2."Unit of Measure Code" := ''; ItemJnlLine2."Qty. per Unit of Measure" := 1; ItemJnlLine2."Applies-from Entry" := 0; if TempItemChargeAssgntSales."Document Type" in [TempItemChargeAssgntSales."Document Type"::"Return Order", TempItemChargeAssgntSales."Document Type"::"Credit Memo"] then QtyToInvoice := CalcQtyToInvoice(SalesLine."Return Qty. to Receive (Base)", SalesLine."Qty. to Invoice (Base)") else QtyToInvoice := CalcQtyToInvoice(SalesLine."Qty. to Ship (Base)", SalesLine."Qty. to Invoice (Base)"); if ItemJnlLine2."Invoiced Quantity" = 0 then begin ItemJnlLine2."Invoiced Quantity" := ItemJnlLine2.Quantity; ItemJnlLine2."Invoiced Qty. (Base)" := ItemJnlLine2."Quantity (Base)"; end; ItemJnlLine2."Document Line No." := ItemChargeSalesLine."Line No."; ItemJnlLine2.Amount := TempItemChargeAssgntSales."Amount to Handle" * ItemJnlLine2."Invoiced Qty. (Base)" / QtyToInvoice; if TempItemChargeAssgntSales."Document Type" in [TempItemChargeAssgntSales."Document Type"::"Return Order", TempItemChargeAssgntSales."Document Type"::"Credit Memo"] then ItemJnlLine2.Amount := -ItemJnlLine2.Amount; ItemJnlLine2."Unit Cost (ACY)" := Round(ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)", Currency."Unit-Amount Rounding Precision"); PreciseTotalChargeAmt += ItemJnlLine2.Amount; if SalesHeader."Currency Code" <> '' then ItemJnlLine2.Amount := CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", PreciseTotalChargeAmt + TotalSalesLine.Amount, SalesHeader."Currency Factor") - RoundedPrevTotalChargeAmt - TotalSalesLineLCY.Amount else ItemJnlLine2.Amount := PreciseTotalChargeAmt - RoundedPrevTotalChargeAmt; RoundedPrevTotalChargeAmt += Round(ItemJnlLine2.Amount, GLSetup."Amount Rounding Precision"); ItemJnlLine2."Unit Cost" := Round( ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)", GLSetup."Unit-Amount Rounding Precision"); ItemJnlLine2."Applies-to Entry" := ItemJnlLine2."Item Shpt. Entry No."; if SalesHeader."Currency Code" <> '' then ItemJnlLine2."Discount Amount" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", (ItemChargeSalesLine."Inv. Discount Amount" + ItemChargeSalesLine."Line Discount Amount") * ItemJnlLine2."Invoiced Qty. (Base)" / ItemChargeSalesLine."Quantity (Base)" * TempItemChargeAssgntSales."Qty. to Handle" / QtyToInvoice, SalesHeader."Currency Factor"), GLSetup."Amount Rounding Precision") else ItemJnlLine2."Discount Amount" := Round( (ItemChargeSalesLine."Inv. Discount Amount" + ItemChargeSalesLine."Line Discount Amount") * ItemJnlLine2."Invoiced Qty. (Base)" / ItemChargeSalesLine."Quantity (Base)" * TempItemChargeAssgntSales."Qty. to Handle" / QtyToInvoice, GLSetup."Amount Rounding Precision"); if SalesLine.IsCreditDocType() then ItemJnlLine2."Discount Amount" := -ItemJnlLine2."Discount Amount"; ItemJnlLine2."Shortcut Dimension 1 Code" := ItemChargeSalesLine."Shortcut Dimension 1 Code"; ItemJnlLine2."Shortcut Dimension 2 Code" := ItemChargeSalesLine."Shortcut Dimension 2 Code"; ItemJnlLine2."Dimension Set ID" := ItemChargeSalesLine."Dimension Set ID"; UpdateItemJnlLineDimSetIDFromAppliedShipmentEntry(ItemJnlLine2); ItemJnlLine2."Gen. Prod. Posting Group" := ItemChargeSalesLine."Gen. Prod. Posting Group"; OnPostItemChargePerOrderOnAfterCopyToItemJnlLine( ItemJnlLine2, ItemChargeSalesLine, GLSetup, QtyToInvoice, TempItemChargeAssgntSales); TempTrackingSpecificationInv.Reset(); TempTrackingSpecificationInv.SetRange("Source Type", DATABASE::"Sales Line"); TempTrackingSpecificationInv.SetRange("Source ID", TempItemChargeAssgntSales."Applies-to Doc. No."); TempTrackingSpecificationInv.SetRange("Source Ref. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No."); IsHandled := false; OnPostItemChargePerOrderOnAfterTempTrackingSpecificationInvSetFilters(SalesHeader, ItemJnlLine2, TempTrackingSpecificationInv, SalesLine, IsHandled, TotalSalesLineLCY, TotalSalesLine); if not IsHandled then if TempTrackingSpecificationInv.IsEmpty() then RunItemJnlPostLine(ItemJnlLine2) else begin TempTrackingSpecificationInv.FindSet(); NonDistrItemJnlLine := ItemJnlLine2; OriginalAmt := NonDistrItemJnlLine.Amount; OriginalDiscountAmt := NonDistrItemJnlLine."Discount Amount"; OriginalQty := NonDistrItemJnlLine."Quantity (Base)"; if (TempTrackingSpecificationInv."Quantity (Base)" / OriginalQty) > 0 then SignFactor := 1 else SignFactor := -1; repeat Factor := TempTrackingSpecificationInv."Quantity (Base)" / OriginalQty * SignFactor; if Abs(TempTrackingSpecificationInv."Quantity (Base)") < Abs(NonDistrItemJnlLine."Quantity (Base)") then begin ItemJnlLine2."Quantity (Base)" := -TempTrackingSpecificationInv."Quantity (Base)"; ItemJnlLine2."Invoiced Qty. (Base)" := ItemJnlLine2."Quantity (Base)"; if SalesHeader."Currency Code" <> '' then begin PreciseTotalChargeAmt += CurrExchRate.ExchangeAmtLCYToFCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", OriginalAmt * Factor, SalesHeader."Currency Factor"); ItemJnlLine2.Amount := CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", PreciseTotalChargeAmt + TotalSalesLine.Amount, SalesHeader."Currency Factor") - RoundedPrevTotalChargeAmt - TotalSalesLineLCY.Amount; end else begin PreciseTotalChargeAmt += OriginalAmt * Factor; ItemJnlLine2.Amount := PreciseTotalChargeAmt - RoundedPrevTotalChargeAmt; end; ItemJnlLine2.Amount := Round(ItemJnlLine2.Amount, GLSetup."Amount Rounding Precision"); RoundedPrevTotalChargeAmt += ItemJnlLine2.Amount; ItemJnlLine2."Discount Amount" := Round(OriginalDiscountAmt * Factor, GLSetup."Amount Rounding Precision"); ItemJnlLine2."Unit Cost" := Round(ItemJnlLine2.Amount / ItemJnlLine2."Invoiced Qty. (Base)", GLSetup."Unit-Amount Rounding Precision") * SignFactor; ItemJnlLine2."Item Shpt. Entry No." := TempTrackingSpecificationInv."Item Ledger Entry No."; ItemJnlLine2."Applies-to Entry" := TempTrackingSpecificationInv."Item Ledger Entry No."; ItemJnlLine2.CopyTrackingFromSpec(TempTrackingSpecificationInv); IsHandled := false; OnPostItemChargePerOrderOnBeforeRunWithCheck(ItemJnlLine2, IsHandled, SalesLine); if not IsHandled then RunItemJnlPostLine(ItemJnlLine2); ItemJnlLine2."Location Code" := NonDistrItemJnlLine."Location Code"; NonDistrItemJnlLine."Quantity (Base)" -= ItemJnlLine2."Quantity (Base)"; NonDistrItemJnlLine.Amount -= ItemJnlLine2.Amount; NonDistrItemJnlLine."Discount Amount" -= ItemJnlLine2."Discount Amount"; end else begin // the last time NonDistrItemJnlLine."Quantity (Base)" := -TempTrackingSpecificationInv."Quantity (Base)"; NonDistrItemJnlLine."Invoiced Qty. (Base)" := -TempTrackingSpecificationInv."Quantity (Base)"; NonDistrItemJnlLine."Unit Cost" := Round(NonDistrItemJnlLine.Amount / NonDistrItemJnlLine."Invoiced Qty. (Base)", GLSetup."Unit-Amount Rounding Precision"); NonDistrItemJnlLine."Item Shpt. Entry No." := TempTrackingSpecificationInv."Item Ledger Entry No."; NonDistrItemJnlLine."Applies-to Entry" := TempTrackingSpecificationInv."Item Ledger Entry No."; NonDistrItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecificationInv); IsHandled := false; OnPostItemChargePerOrderOnBeforeLastRunWithCheck(NonDistrItemJnlLine, SalesLine, IsHandled); if not IsHandled then RunItemJnlPostLine(NonDistrItemJnlLine); NonDistrItemJnlLine."Location Code" := ItemJnlLine2."Location Code"; end; until TempTrackingSpecificationInv.Next() = 0; end; end; /// <summary> /// Checks if Item Charge should be distributed across multiple Item Ledger Entries and posts the charges /// </summary> /// <remarks> /// If Sales Shipment Line doesn't exist for the Item Charge Line of the sales line, an error is raised within CheckItemChargePerShpt(). /// If no related Item Ledger Entries are found for the sales line, an error is raised. /// </remarks> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> procedure PostItemChargePerShpt(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") var SalesShptLine: Record "Sales Shipment Line"; TempItemLedgEntry: Record "Item Ledger Entry" temporary; ItemTrackingMgt: Codeunit "Item Tracking Management"; DistributeCharge: Boolean; IsHandled: Boolean; begin CheckItemChargePerShpt(SalesShptLine, SalesLine); IsHandled := false; OnPostItemChargePerShptOnAfterCheckItemChargePerShpt(SalesShptLine, TempItemChargeAssgntSales, DistributeCharge, IsHandled, SalesHeader, SalesLine); if IsHandled then exit; if SalesShptLine."Item Shpt. Entry No." <> 0 then DistributeCharge := CostCalcMgt.SplitItemLedgerEntriesExist( TempItemLedgEntry, -SalesShptLine."Quantity (Base)", SalesShptLine."Item Shpt. Entry No.") else begin DistributeCharge := true; if not ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry, DATABASE::"Sales Shipment Line", 0, SalesShptLine."Document No.", '', 0, SalesShptLine."Line No.", -SalesShptLine."Quantity (Base)") then Error(RelatedItemLedgEntriesNotFoundErr); end; IsHandled := false; OnPostItemChargePerShptOnAfterCalcDistributeCharge(SalesHeader, SalesLine, SalesShptLine, TempItemLedgEntry, TempItemChargeAssgntSales, DistributeCharge, IsHandled); if not IsHandled then if DistributeCharge then PostDistributeItemCharge( SalesHeader, SalesLine, TempItemLedgEntry, SalesShptLine."Quantity (Base)", TempItemChargeAssgntSales."Qty. to Handle", TempItemChargeAssgntSales."Amount to Handle") else PostItemCharge( SalesHeader, SalesLine, SalesShptLine."Item Shpt. Entry No.", SalesShptLine."Quantity (Base)", TempItemChargeAssgntSales."Amount to Handle", TempItemChargeAssgntSales."Qty. to Handle"); end; local procedure CheckItemChargePerShpt(var SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line") var IsHandled: Boolean; begin if not SalesShptLine.Get( TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No.") then Error(ShipmentLinesDeletedErr); IsHandled := false; OnPostItemChargePerShptOnBeforeTestJobNo(SalesShptLine, IsHandled, SalesLine); if not IsHandled then SalesShptLine.TestField("Job No.", ''); end; local procedure PostItemChargePerRetRcpt(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") var ReturnRcptLine: Record "Return Receipt Line"; TempItemLedgEntry: Record "Item Ledger Entry" temporary; ItemTrackingMgt: Codeunit "Item Tracking Management"; DistributeCharge: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemChargePerRetRcpt(SalesHeader, SalesLine, TempItemChargeAssgntSales, IsHandled); if IsHandled then exit; if not ReturnRcptLine.Get( TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No.") then Error(ShipmentLinesDeletedErr); IsHandled := false; OnPostItemChargePerRetRcptOnBeforeTestFieldJobNo(ReturnRcptLine, IsHandled, SalesLine); if not IsHandled then ReturnRcptLine.TestField("Job No.", ''); if ReturnRcptLine."Item Rcpt. Entry No." <> 0 then DistributeCharge := CostCalcMgt.SplitItemLedgerEntriesExist( TempItemLedgEntry, ReturnRcptLine."Quantity (Base)", ReturnRcptLine."Item Rcpt. Entry No.") else begin DistributeCharge := true; if not ItemTrackingMgt.CollectItemEntryRelation(TempItemLedgEntry, DATABASE::"Return Receipt Line", 0, ReturnRcptLine."Document No.", '', 0, ReturnRcptLine."Line No.", ReturnRcptLine."Quantity (Base)") then Error(RelatedItemLedgEntriesNotFoundErr); end; IsHandled := false; OnPostItemChargePerRetRcptOnAfterCalcDistributeCharge(SalesHeader, SalesLine, ReturnRcptLine, TempItemLedgEntry, TempItemChargeAssgntSales, DistributeCharge, IsHandled); if not IsHandled then if DistributeCharge then PostDistributeItemCharge( SalesHeader, SalesLine, TempItemLedgEntry, ReturnRcptLine."Quantity (Base)", TempItemChargeAssgntSales."Qty. to Handle", TempItemChargeAssgntSales."Amount to Handle") else PostItemCharge( SalesHeader, SalesLine, ReturnRcptLine."Item Rcpt. Entry No.", ReturnRcptLine."Quantity (Base)", TempItemChargeAssgntSales."Amount to Handle", TempItemChargeAssgntSales."Qty. to Handle") end; /// <summary> /// Distributes the item charge across Item Ledger Entries and posts the charges /// </summary> /// <remarks> /// Throws an error if no Item Ledger Entries are found in the TempItemLedgerEntry Record Set /// </remarks> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being posted.</param> /// <param name="TempItemLedgEntry">Temp Set of Item Ledger Entries to distribute the charge across</param> /// <param name="NonDistrQuantity">The full quantity, used for calculating the factor for individual Item Ledger Entries</param> /// <param name="NonDistrQtyToAssign">The full quantity to assign to be distributed</param> /// <param name="NonDistrAmountToAssign">The full amount to be distributed</param> procedure PostDistributeItemCharge(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemLedgEntry: Record "Item Ledger Entry" temporary; NonDistrQuantity: Decimal; NonDistrQtyToAssign: Decimal; NonDistrAmountToAssign: Decimal) var Factor: Decimal; QtyToAssign: Decimal; AmountToAssign: Decimal; IsHandled: Boolean; begin OnBeforePostDistributeItemCharge(SalesHeader, SalesLine, TempItemLedgEntry, NonDistrQuantity, NonDistrQtyToAssign, NonDistrAmountToAssign, IsHandled); if IsHandled then exit; if TempItemLedgEntry.FindSet() then repeat Factor := Abs(TempItemLedgEntry.Quantity / NonDistrQuantity); OnPostDistributeItemChargeOnAfterSetFactor(TempItemLedgEntry, Factor); QtyToAssign := NonDistrQtyToAssign * Factor; AmountToAssign := Round(NonDistrAmountToAssign * Factor, GLSetup."Amount Rounding Precision"); if Factor < 1 then begin PostItemCharge(SalesHeader, SalesLine, TempItemLedgEntry."Entry No.", -TempItemLedgEntry.Quantity, AmountToAssign, QtyToAssign); NonDistrQuantity := NonDistrQuantity + TempItemLedgEntry.Quantity; NonDistrQtyToAssign := NonDistrQtyToAssign - QtyToAssign; NonDistrAmountToAssign := NonDistrAmountToAssign - AmountToAssign; end else // the last time PostItemCharge(SalesHeader, SalesLine, TempItemLedgEntry."Entry No.", -TempItemLedgEntry.Quantity, NonDistrAmountToAssign, NonDistrQtyToAssign); until TempItemLedgEntry.Next() = 0 else Error(RelatedItemLedgEntriesNotFoundErr); end; /// <summary> /// Posts an associated item journal line for drop shipment or special order transactions. /// </summary> /// <param name="SalesHeader">The sales header record.</param> /// <param name="SalesLine">The sales line record.</param> /// <param name="QtyToBeShipped">The quantity to be shipped.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> /// <returns>The item shipment entry number, or 0 if tracking was handled.</returns> procedure PostAssocItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal): Integer var ItemJnlLine: Record "Item Journal Line"; TempHandlingSpecification2: Record "Tracking Specification" temporary; ItemEntryRelation: Record "Item Entry Relation"; PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; IsHandled: Boolean; begin PurchOrderHeader.Get( PurchOrderHeader."Document Type"::Order, SalesLine."Purchase Order No."); PurchOrderLine.Get( PurchOrderLine."Document Type"::Order, SalesLine."Purchase Order No.", SalesLine."Purch. Order Line No."); InitAssocItemJnlLine(ItemJnlLine, PurchOrderHeader, PurchOrderLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase); IsHandled := false; OnPostAssocItemJnlLineOnBeforePost(ItemJnlLine, PurchOrderLine, IsHandled); if (PurchOrderLine."Job No." = '') or IsHandled then begin TransferReservFromPurchLine(PurchOrderLine, ItemJnlLine, SalesLine, QtyToBeShippedBase); IsHandled := false; OnBeforePostAssocItemJnlLine(ItemJnlLine, PurchOrderLine, SuppressCommit, SalesLine, IsHandled); if not IsHandled then RunItemJnlPostLine(ItemJnlLine); // Handle Item Tracking if ItemJnlPostLine.CollectTrackingSpecification(TempHandlingSpecification2) then begin if TempHandlingSpecification2.FindSet() then repeat TempTrackingSpecification := TempHandlingSpecification2; TempTrackingSpecification.SetSourceFromPurchLine(PurchOrderLine); if TempTrackingSpecification.Insert() then; ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification2); ItemEntryRelation.SetSource(DATABASE::"Purch. Rcpt. Line", 0, PurchOrderHeader."Receiving No.", PurchOrderLine."Line No."); ItemEntryRelation.SetOrderInfo(PurchOrderLine."Document No.", PurchOrderLine."Line No."); ItemEntryRelation.Insert(); until TempHandlingSpecification2.Next() = 0; exit(0); end; end; exit(ItemJnlLine."Item Shpt. Entry No."); end; /// <summary> /// Initializes an item journal line for associated purchase order posting. /// </summary> /// <param name="ItemJnlLine">The item journal line to initialize.</param> /// <param name="PurchOrderHeader">The purchase order header.</param> /// <param name="PurchOrderLine">The purchase order line.</param> /// <param name="SalesHeader">The sales header record.</param> /// <param name="SalesLine">The sales line record.</param> /// <param name="QtyToBeShipped">The quantity to be shipped.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> procedure InitAssocItemJnlLine(var ItemJnlLine: Record "Item Journal Line"; PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal) begin OnBeforeInitAssocItemJnlLine(ItemJnlLine, PurchOrderHeader, PurchOrderLine, SalesHeader, SalesLine); ItemJnlLine.Init(); ItemJnlLine."Entry Type" := ItemJnlLine."Entry Type"::Purchase; ItemJnlLine.CopyDocumentFields( ItemJnlLine."Document Type"::"Purchase Receipt", PurchOrderHeader."Receiving No.", PurchOrderHeader."No.", SrcCode, PurchOrderHeader."Posting No. Series"); ItemJnlLine.CopyFromPurchHeader(PurchOrderHeader); ItemJnlLine."Posting Date" := SalesHeader."Posting Date"; ItemJnlLine."Document Date" := SalesHeader."Document Date"; ItemJnlLine.CopyFromPurchLine(PurchOrderLine); ItemJnlLine.Quantity := QtyToBeShipped; ItemJnlLine."Quantity (Base)" := QtyToBeShippedBase; ItemJnlLine."Invoiced Quantity" := 0; ItemJnlLine."Invoiced Qty. (Base)" := 0; ItemJnlLine."Source Currency Code" := SalesHeader."Currency Code"; ItemJnlLine.Amount := Round(PurchOrderLine.Amount * QtyToBeShipped / PurchOrderLine.Quantity); ItemJnlLine."Discount Amount" := PurchOrderLine."Line Discount Amount"; ItemJnlLine."Applies-to Entry" := 0; OnAfterInitAssocItemJnlLine(ItemJnlLine, PurchOrderHeader, PurchOrderLine, SalesHeader, SalesLine, QtyToBeShipped, QtyToBeShippedBase); end; /// <summary> /// Executes various checks and updates for an Open or Pending Prepayment document and releases it /// </summary> /// <remarks> /// Changes are committed to the database if the PreviewMode flag is not set /// Open Linked ATOs (Assembly-to-Order documents) are reopened after the document is released /// </remarks> /// <param name="SalesHeader">The sales header of the document that is being released.</param> procedure ReleaseSalesDocument(var SalesHeader: Record "Sales Header") var SalesHeaderCopy: Record "Sales Header"; TempAsmHeader: Record "Assembly Header" temporary; ReleaseSalesDocument: Codeunit "Release Sales Document"; LinesWereModified: Boolean; SavedStatus: Enum "Sales Document Status"; IsHandled: Boolean; begin OnBeforeReleaseSalesDocument(SalesHeader, PreviewMode); if not (SalesHeader.Status = SalesHeader.Status::Open) or (SalesHeader.Status = SalesHeader.Status::"Pending Prepayment") then exit; SalesHeaderCopy := SalesHeader; SavedStatus := SalesHeader.Status; GetOpenLinkedATOs(TempAsmHeader); OnBeforeReleaseSalesDoc(SalesHeader); LinesWereModified := ReleaseSalesDocument.ReleaseSalesHeader(SalesHeader, PreviewMode); if LinesWereModified then RefreshTempLines(SalesHeader, TempSalesLineGlobal); TestStatusRelease(SalesHeader); SalesHeader.Status := SavedStatus; RestoreSalesHeader(SalesHeader, SalesHeaderCopy); ReopenAsmOrders(TempAsmHeader); OnAfterReleaseSalesDoc(SalesHeader); if not (PreviewMode or SuppressCommit) then begin SalesHeader.Modify(); Commit(); end; IsHandled := false; OnReleaseSalesDocumentOnBeforeSetStatus(SalesHeader, IsHandled, SavedStatus, PreviewMode, SuppressCommit); if not IsHandled then SalesHeader.Status := SalesHeader.Status::Released; end; /// <summary> /// Checks if status of the document is Released /// </summary> /// <param name="SalesHeader">The sales header of the document whose status is being checked.</param> local procedure TestStatusRelease(SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestStatusRelease(SalesHeader, IsHandled); if not IsHandled then SalesHeader.TestField(Status, SalesHeader.Status::Released); end; /// <summary> /// Checks varous sales line fields (quantities, tracking, posting groups) depending on the Type of the Line, to ensure it is valid for posting /// </summary> /// <param name="SalesHeader">The sales header of the document that is being posted.</param> /// <param name="SalesLine">The sales line of the document line that is being tested.</param> procedure TestSalesLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestSalesLine(SalesHeader, SalesLine, SuppressCommit, IsHandled); if IsHandled then exit; case SalesLine.Type of SalesLine.Type::Item: CheckItemTrackingQuantity(SalesLine, SalesHeader); SalesLine.Type::"Charge (Item)": TestSalesLineItemCharge(SalesLine); SalesLine.Type::"Fixed Asset": TestSalesLineFixedAsset(SalesLine) else TestSalesLineOthers(SalesLine); end; TestSalesLineJob(SalesLine); OnTestSalesLineOnAfterTestSalesLineJob(SalesLine); TestFieldsByDocType(SalesHeader, SalesLine); CheckBlockedPostingGroups(SalesLine); OnAfterTestSalesLine(SalesHeader, SalesLine, WhseShip, WhseReceive, SuppressCommit); end; local procedure TestFieldsByDocType(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") var ShouldTestQtyToShip: Boolean; ShouldTestReturnQty: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeTestFieldsByDocType(SalesHeader, SalesLine, IsHandled); if IsHandled then exit; case SalesLine."Document Type" of SalesLine."Document Type"::Order: SalesLine.TestField("Return Qty. to Receive", 0, ErrorInfo.Create()); SalesLine."Document Type"::Invoice: begin ShouldTestQtyToShip := SalesLine."Shipment No." = ''; OnTestSalesLineOnBeforeTestFieldQtyToShip(SalesLine, ShouldTestQtyToShip); if ShouldTestQtyToShip then SalesLine.TestField("Qty. to Ship", SalesLine.Quantity, ErrorInfo.Create()); SalesLine.TestField("Return Qty. to Receive", 0, ErrorInfo.Create()); SalesLine.TestField("Qty. to Invoice", SalesLine.Quantity, ErrorInfo.Create()); end; SalesLine."Document Type"::"Return Order": SalesLine.TestField("Qty. to Ship", 0, ErrorInfo.Create()); SalesLine."Document Type"::"Credit Memo": begin ShouldTestReturnQty := SalesLine."Return Receipt No." = ''; OnTestSalesLineOnAfterCalcShouldTestReturnQty(SalesLine, ShouldTestReturnQty); if ShouldTestReturnQty then SalesLine.TestField("Return Qty. to Receive", SalesLine.Quantity, ErrorInfo.Create()); SalesLine.TestField("Qty. to Ship", 0, ErrorInfo.Create()); SalesLine.TestField("Qty. to Invoice", SalesLine.Quantity, ErrorInfo.Create()); end; end; end; local procedure CheckBlockedPostingGroups(SalesLine: Record "Sales Line") var GeneralPostingSetup: Record "General Posting Setup"; VATPostingSetup: Record "VAT Posting Setup"; ForwardLinkMgt: Codeunit "Forward Link Mgt."; begin if not SalesLine.HasTypeToFillMandatoryFields() then exit; if GeneralPostingSetup.Get(SalesLine."Gen. Bus. Posting Group", SalesLine."Gen. Prod. Posting Group") then if GeneralPostingSetup.Blocked then ErrorMessageMgt.LogContextFieldError( SalesLine.FieldNo("Gen. Prod. Posting Group"), StrSubstNo( SetupBlockedErr, GeneralPostingSetup.TableCaption(), GeneralPostingSetup.FieldCaption("Gen. Bus. Posting Group"), GeneralPostingSetup."Gen. Bus. Posting Group", GeneralPostingSetup.FieldCaption("Gen. Prod. Posting Group"), GeneralPostingSetup."Gen. Prod. Posting Group"), GeneralPostingSetup.RecordId(), GeneralPostingSetup.FieldNo(Blocked), ForwardLinkMgt.GetHelpCodeForFinancePostingGroups()); if VATPostingSetup.Get(SalesLine."VAT Bus. Posting Group", SalesLine."VAT Prod. Posting Group") then if VATPostingSetup.Blocked then ErrorMessageMgt.LogContextFieldError( SalesLine.FieldNo("VAT Prod. Posting Group"), StrSubstNo( SetupBlockedErr, VATPostingSetup.TableCaption(), VATPostingSetup.FieldCaption("VAT Bus. Posting Group"), VATPostingSetup."VAT Bus. Posting Group", VATPostingSetup.FieldCaption("VAT Prod. Posting Group"), VATPostingSetup."VAT Prod. Posting Group"), VATPostingSetup.RecordId(), VATPostingSetup.FieldNo(Blocked), ForwardLinkMgt.GetHelpCodeForFinanceSetupVAT()); end; local procedure CheckItemTrackingQuantity(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header") var TrackingSpecification: Record "Tracking Specification"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckItemTrackingQuantity(SalesLine, IsHandled, SalesHeader); if IsHandled then exit; SyncSurPlusItemTracking(SalesHeader, SalesLine); case SalesHeader."Document Type" of SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice: TrackingSpecification.CheckItemTrackingQuantity(DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", SalesLine."Qty. to Ship (Base)", SalesLine."Qty. to Invoice (Base)", SalesHeader.Ship, SalesHeader.Invoice); SalesHeader."Document Type"::"Credit Memo", SalesHeader."Document Type"::"Return Order": TrackingSpecification.CheckItemTrackingQuantity(DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", SalesLine."Return Qty. to Receive (Base)", SalesLine."Qty. to Invoice (Base)", SalesHeader.Receive, SalesHeader.Invoice); else OnCheckItemTrackingQuantityOnDocumentTypeCaseElse(SalesHeader, SalesLine); end; end; local procedure TestSalesLineItemCharge(SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestSalesLineItemCharge(SalesLine, IsHandled); if IsHandled then exit; if (SalesLine.Amount = 0) and (SalesLine.Quantity <> 0) then Error(ItemChargeZeroAmountErr, SalesLine."No."); SalesLine.TestField("Job No.", '', ErrorInfo.Create()); SalesLine.TestField("Job Contract Entry No.", 0, ErrorInfo.Create()); end; local procedure TestSalesLineFixedAsset(SalesLine: Record "Sales Line") var FixedAsset: Record "Fixed Asset"; DeprBook: Record "Depreciation Book"; IsHandled: Boolean; begin IsHandled := false; OnBeforeTestSalesLineFixedAsset(SalesLine, IsHandled); if IsHandled then exit; SalesLine.TestField("Job No.", '', ErrorInfo.Create()); SalesLine.TestField("Depreciation Book Code", ErrorInfo.Create()); DeprBook.Get(SalesLine."Depreciation Book Code"); DeprBook.TestField("G/L Integration - Disposal", true, ErrorInfo.Create()); FixedAsset.Get(SalesLine."No."); FixedAsset.TestField("Budgeted Asset", false, ErrorInfo.Create()); end; local procedure TestSalesLineJob(SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestSalesLineJob(SalesLine, IsHandled); if IsHandled then exit; if not (SalesLine."Document Type" in [SalesLine."Document Type"::Invoice, SalesLine."Document Type"::"Credit Memo"]) then SalesLine.TestField("Job No.", '', ErrorInfo.Create()); end; local procedure TestSalesLineOthers(SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestSalesLineOthers(SalesLine, IsHandled); if IsHandled then exit; SalesLine.TestField("Depreciation Book Code", '', ErrorInfo.Create()); SalesLine.TestField("Depr. until FA Posting Date", false, ErrorInfo.Create()); SalesLine.TestField("FA Posting Date", 0D, ErrorInfo.Create()); SalesLine.TestField("Duplicate in Depreciation Book", '', ErrorInfo.Create()); SalesLine.TestField("Use Duplication List", false, ErrorInfo.Create()); end; local procedure TestUpdatedSalesLine(SalesLine: Record "Sales Line") var ForwardLinkMgt: Codeunit "Forward Link Mgt."; IsHandled: Boolean; begin IsHandled := false; OnBeforeTestUpdatedSalesLine(SalesLine, IsHandled, ErrorMessageMgt); if IsHandled then exit; if SalesLine."Drop Shipment" then begin if SalesLine.Type <> SalesLine.Type::Item then SalesLine.TestField("Drop Shipment", false); if (SalesLine."Qty. to Ship" <> 0) and (SalesLine."Purch. Order Line No." = 0) then ErrorMessageMgt.LogErrorMessage(SalesLine.FieldNo("Purchasing Code"), StrSubstNo(DropShipmentErr, SalesLine."Line No."), 0, 0, ForwardLinkMgt.GetHelpCodeForSalesLineDropShipmentErr()); end; if SalesLine.Quantity = 0 then SalesLine.TestField(Amount, 0) else begin SalesLine.TestField("No."); SalesLine.TestField(Type); if not ApplicationAreaMgmt.IsSalesTaxEnabled() then TestGenPostingGroups(SalesLine); end; end; local procedure TestGenPostingGroups(var SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeTestGenPostingGroups(SalesLine, IsHandled); if IsHandled then exit; SalesLine.TestField("Gen. Bus. Posting Group"); SalesLine.TestField("Gen. Prod. Posting Group"); end; local procedure UpdateReceiveAndCheckIfInvPutawayExists(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateReceiveAndCheckIfInvPutawayExists(IsHandled, SalesHeader); if IsHandled then exit; if SalesHeader.Receive then begin SalesHeader.Receive := CheckTrackingAndWarehouseForReceive(SalesHeader); if not InvtPickPutaway then if CheckIfInvPutawayExists() then Error(ErrorInfo.Create(InvPutAwayExistsErr, true, SalesHeader)); end; end; local procedure UpdateShipAndCheckIfInvPickExists(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnCheckAndUpdateOnBeforeCheckShip(IsHandled, SalesHeader); if IsHandled then exit; if SalesHeader.Ship then begin SalesHeader.Ship := CheckTrackingAndWarehouseForShip(SalesHeader); if not InvtPickPutaway then if CheckIfInvPickExists(SalesHeader) then Error(ErrorInfo.Create(InvPickExistsErr, true, SalesHeader)); end; end; local procedure UpdatePostingNos(var SalesHeader: Record "Sales Header") ModifyHeader: Boolean begin OnBeforeUpdatePostingNos(SalesHeader, SuppressCommit, ModifyHeader); UpdateShippingNo(SalesHeader, ModifyHeader); UpdateReturnReceiptNo(SalesHeader, ModifyHeader); UpdatePostingNo(SalesHeader, ModifyHeader); OnAfterUpdatePostingNos(SalesHeader, SuppressCommit); end; local procedure UpdateShippingNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean) var NoSeries: Codeunit "No. Series"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateShippingNo(SalesHeader, WhseShip, WhseReceive, InvtPickPutaway, PreviewMode, ModifyHeader, IsHandled); UpdateShippingNoTelemetry(SalesHeader); if IsHandled then exit; if SalesHeader.Ship and (SalesHeader."Shipping No." = '') then if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) or ((SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and SalesSetup."Shipment on Invoice") then if not PreviewMode then begin ResetPostingNoSeriesFromSetup(SalesHeader."Shipping No. Series", SalesSetup."Posted Shipment Nos."); SalesHeader.TestField("Shipping No. Series"); SalesHeader."Shipping No." := NoSeries.GetNextNo(SalesHeader."Shipping No. Series", SalesHeader."Posting Date"); ModifyHeader := true; if NoSeries.IsNoSeriesInDateOrder(SalesHeader."Shipping No. Series") then DateOrderSeriesUsed := true; // Check for posting conflicts. if SalesShptHeader.Get(SalesHeader."Shipping No.") then Error(SalesShptHeaderConflictErr, SalesHeader."Shipping No."); end; OnAfterUpdateShippingNo(SalesHeader, PreviewMode, ModifyHeader); end; local procedure UpdateShippingNoTelemetry(var SalesHeader: Record "Sales Header") var TelemetryCustomDimensions: Dictionary of [Text, Text]; PreviewTokenFoundLbl: Label 'Preview token %1 found on fields.', Locked = true; PreviewToken: Text; begin if not Format(SalesHeader."Shipping No.").StartsWith(PostingPreviewNoTok) and not Format(SalesHeader."Return Receipt No.").StartsWith(PostingPreviewNoTok) and not Format(SalesHeader."Posting No.").StartsWith(PostingPreviewNoTok) then exit; TelemetryCustomDimensions.Add(SalesHeader.FieldCaption(SystemId), SalesHeader.SystemId); TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Document Type"), Format(SalesHeader."Document Type")); if Format(SalesHeader."Shipping No.").StartsWith(PostingPreviewNoTok) then begin PreviewToken := SalesHeader."Shipping No."; TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Shipping No."), SalesHeader."Shipping No."); SalesHeader."Shipping No." := ''; end; if Format(SalesHeader."Return Receipt No.").StartsWith(PostingPreviewNoTok) then begin PreviewToken := SalesHeader."Return Receipt No."; TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Return Receipt No."), SalesHeader."Return Receipt No."); SalesHeader."Return Receipt No." := ''; end; if Format(SalesHeader."Posting No.").StartsWith(PostingPreviewNoTok) then begin PreviewToken := SalesHeader."Posting No."; TelemetryCustomDimensions.Add(SalesHeader.FieldCaption("Posting No."), SalesHeader."Posting No."); SalesHeader."Posting No." := ''; end; Session.LogMessage('0000CUV', StrSubstNo(PreviewTokenFoundLbl, PreviewToken), Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::All, TelemetryCustomDimensions); end; local procedure UpdatePostingNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean) var NoSeries: Codeunit "No. Series"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdatePostingNo(SalesHeader, PreviewMode, ModifyHeader, IsHandled, DateOrderSeriesUsed); if IsHandled then exit; if SalesHeader.Invoice and (SalesHeader."Posting No." = '') then begin if (SalesHeader."No. Series" <> '') or (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) then begin if SalesHeader."Document Type" in [SalesHeader."Document Type"::"Return Order"] then ResetPostingNoSeriesFromSetup(SalesHeader."Posting No. Series", SalesSetup."Posted Credit Memo Nos.") else if (SalesHeader."Document Type" <> SalesHeader."Document Type"::"Credit Memo") then ResetPostingNoSeriesFromSetup(SalesHeader."Posting No. Series", SalesSetup."Posted Invoice Nos."); if SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo" then if (SalesSetup."Posted Credit Memo Nos." <> '') and (SalesHeader."Posting No. Series" = '') then CheckDefaultNoSeries(SalesSetup."Posted Credit Memo Nos."); SalesHeader.TestField("Posting No. Series"); end; if (SalesHeader."No. Series" <> SalesHeader."Posting No. Series") or (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) then if not PreviewMode then begin SalesHeader."Posting No." := NoSeries.GetNextNo(SalesHeader."Posting No. Series", SalesHeader."Posting Date"); if NoSeries.IsNoSeriesInDateOrder(SalesHeader."Posting No. Series") then DateOrderSeriesUsed := true; ModifyHeader := true; end; // Check for posting conflicts. if not PreviewMode then if SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice] then begin if SalesInvHeader.Get(SalesHeader."Posting No.") then Error(SalesInvHeaderConflictErr, SalesHeader."Posting No."); end else if SalesCrMemoHeader.Get(SalesHeader."Posting No.") then Error(SalesCrMemoHeaderConflictErr, SalesHeader."Posting No."); end; end; local procedure UpdateReturnReceiptNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean) var NoSeries: Codeunit "No. Series"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateReturnReceiptNo(SalesHeader, ModifyHeader, IsHandled, PreviewMode); if IsHandled then exit; if SalesHeader.Receive and (SalesHeader."Return Receipt No." = '') then if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order") or ((SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") and SalesSetup."Return Receipt on Credit Memo") then if not PreviewMode then begin ResetPostingNoSeriesFromSetup(SalesHeader."Return Receipt No. Series", SalesSetup."Posted Return Receipt Nos."); SalesHeader.TestField("Return Receipt No. Series"); SalesHeader."Return Receipt No." := NoSeries.GetNextNo(SalesHeader."Return Receipt No. Series", SalesHeader."Posting Date"); ModifyHeader := true; if NoSeries.IsNoSeriesInDateOrder(SalesHeader."Return Receipt No. Series") then DateOrderSeriesUsed := true; // Check for posting conflicts. if ReturnRcptHeader.Get(SalesHeader."Return Receipt No.") then Error(SalesReturnRcptHeaderConflictErr, SalesHeader."Return Receipt No.") end; OnAfterUpdateReturnReceiptNo(SalesHeader); end; local procedure ResetPostingNoSeriesFromSetup(var PostingNoSeries: Code[20]; SetupNoSeries: Code[20]) begin if (PostingNoSeries = '') and (SetupNoSeries <> '') then PostingNoSeries := SetupNoSeries; end; local procedure UpdateAssociatedPurchaseOrder(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesHeader: Record "Sales Header") var PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; PurchLineReserve: Codeunit "Purch. Line-Reserve"; begin TempDropShptPostBuffer.Reset(); if TempDropShptPostBuffer.IsEmpty() then exit; Clear(PurchOrderHeader); TempDropShptPostBuffer.FindSet(); repeat if PurchOrderHeader."No." <> TempDropShptPostBuffer."Order No." then begin PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No."); CheckAndUpdateAssocOrderPostingDate(PurchOrderHeader, SalesHeader."Posting Date"); PurchOrderHeader."Last Receiving No." := PurchOrderHeader."Receiving No."; PurchOrderHeader."Receiving No." := ''; PurchOrderHeader.Modify(); OnUpdateAssosOrderOnAfterPurchOrderHeaderModify(PurchOrderHeader); PurchLineReserve.UpdateItemTrackingAfterPosting(PurchOrderHeader); end; PurchOrderLine.Get( PurchOrderLine."Document Type"::Order, TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No."); PurchOrderLine."Quantity Received" := PurchOrderLine."Quantity Received" + TempDropShptPostBuffer.Quantity; PurchOrderLine."Qty. Received (Base)" := PurchOrderLine."Qty. Received (Base)" + TempDropShptPostBuffer."Quantity (Base)"; PurchOrderLine.InitOutstanding(); PurchOrderLine.ClearQtyIfBlank(); PurchOrderLine.InitQtyToReceive(); OnUpdateAssocOrderOnBeforeModifyPurchLine(PurchOrderLine, TempDropShptPostBuffer); PurchOrderLine.Modify(); OnUpdateAssocOrderOnAfterModifyPurchLine(PurchOrderLine, TempDropShptPostBuffer); until TempDropShptPostBuffer.Next() = 0; TempDropShptPostBuffer.DeleteAll(); end; /// <summary> /// Removes the association between the sales line and the Purchase Line /// </summary> /// <param name="SalesOrderLine">The sales line for which the association is being removed.</param> procedure UpdateAssocLines(var SalesOrderLine: Record "Sales Line") var PurchOrderLine: Record "Purchase Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateAssocLines(SalesOrderLine, IsHandled); if IsHandled then exit; if not PurchOrderLine.Get( PurchOrderLine."Document Type"::Order, SalesOrderLine."Purchase Order No.", SalesOrderLine."Purch. Order Line No.") then exit; PurchOrderLine."Sales Order No." := ''; PurchOrderLine."Sales Order Line No." := 0; PurchOrderLine.Modify(); SalesOrderLine."Purchase Order No." := ''; SalesOrderLine."Purch. Order Line No." := 0; end; local procedure UpdateAssosOrderPostingNos(SalesHeader: Record "Sales Header") DropShipment: Boolean var TempSalesLine: Record "Sales Line" temporary; PurchOrderHeader: Record "Purchase Header"; NoSeries: Codeunit "No. Series"; ReleasePurchaseDocument: Codeunit "Release Purchase Document"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateAssosOrderPostingNos(SalesHeader, TempSalesLineGlobal, PreviewMode, DropShipment, IsHandled); if IsHandled then exit(DropShipment); ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Purch. Order Line No.", '<>0'); OnUpdateAssosOrderPostingNosOnAfterSetFilterTempSalesLine(SalesHeader, TempSalesLine); DropShipment := not TempSalesLine.IsEmpty(); TempSalesLine.SetFilter("Qty. to Ship", '<>0'); if DropShipment and SalesHeader.Ship then if TempSalesLine.FindSet() then repeat if PurchOrderHeader."No." <> TempSalesLine."Purchase Order No." then begin PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempSalesLine."Purchase Order No."); PurchOrderHeader.TestField("Pay-to Vendor No."); PurchOrderHeader.Receive := true; OnUpdateAssosOrderPostingNosOnBeforeReleasePurchaseDocument(PurchOrderHeader, SalesHeader); ReleasePurchaseDocument.ReleasePurchaseHeader(PurchOrderHeader, PreviewMode); if PurchOrderHeader."Receiving No." = '' then begin PurchOrderHeader.TestField("Receiving No. Series"); PurchOrderHeader."Receiving No." := NoSeries.GetNextNo(PurchOrderHeader."Receiving No. Series", SalesHeader."Posting Date"); OnUpdateAssosOrderPostingNosOnBeforeModifyPurchOrderHeader(PurchOrderHeader, SalesHeader); PurchOrderHeader.Modify(); end; OnUpdateAssosOrderPostingNosOnAfterReleasePurchaseDocument(PurchOrderHeader, SalesHeader); end; until TempSalesLine.Next() = 0; OnAfterUpdateAssosOrderPostingNos(SalesHeader, TempSalesLine, DropShipment); exit(DropShipment); end; local procedure CheckAndUpdateAssocOrderPostingDate(var PurchaseHeader: Record "Purchase Header"; PostingDate: Date) var PurchasesPayablesSetup: Record "Purchases & Payables Setup"; ReleasePurchaseDocument: Codeunit "Release Purchase Document"; OriginalDocumentDate: Date; begin if (PostingDate <> 0D) and (PurchaseHeader."Posting Date" <> PostingDate) then begin ReleasePurchaseDocument.Reopen(PurchaseHeader); ReleasePurchaseDocument.SetSkipCheckReleaseRestrictions(); OriginalDocumentDate := PurchaseHeader."Document Date"; PurchaseHeader.SetHideValidationDialog(true); PurchaseHeader.Validate("Posting Date", PostingDate); PurchasesPayablesSetup.SetLoadFields("Link Doc. Date To Posting Date"); PurchasesPayablesSetup.GetRecordOnce(); if PurchasesPayablesSetup."Link Doc. Date To Posting Date" then PurchaseHeader.Validate("Document Date", PostingDate) else PurchaseHeader.Validate("Document Date", OriginalDocumentDate); ReleasePurchaseDocument.Run(PurchaseHeader); end; end; local procedure UpdateAfterPosting(SalesHeader: Record "Sales Header") var TempSalesLine: Record "Sales Line" temporary; begin ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Qty. to Assemble to Order", '<>0'); if TempSalesLine.FindSet() then repeat FinalizePostATO(TempSalesLine); until TempSalesLine.Next() = 0; ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Blanket Order Line No.", '<>0'); OnUpdateAfterPostingOnBeforeFindSetForUpdate(TempSalesLine, SalesHeader); if TempSalesLine.FindSet() then repeat UpdateBlanketOrderLine(TempSalesLine, SalesHeader.Ship, SalesHeader.Receive, SalesHeader.Invoice); until TempSalesLine.Next() = 0; OnAfterUpdateAfterPosting(SalesHeader, TempSalesLine); end; local procedure UpdateLastPostingNos(var SalesHeader: Record "Sales Header") begin if SalesHeader.Ship then begin SalesHeader."Last Shipping No." := SalesHeader."Shipping No."; SalesHeader."Shipping No." := ''; end; if SalesHeader.Invoice then begin SalesHeader."Last Posting No." := SalesHeader."Posting No."; SalesHeader."Posting No." := ''; end; if SalesHeader.Receive then begin SalesHeader."Last Return Receipt No." := SalesHeader."Return Receipt No."; SalesHeader."Return Receipt No." := ''; end; OnAfterUpdateLastPostingNos(SalesHeader); end; local procedure UpdateSalesLineBeforePost(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") var IsHandled: Boolean; begin OnBeforeUpdateSalesLineBeforePost(SalesLine, SalesHeader, WhseShip, WhseReceive, RoundingLineInserted, SuppressCommit); if not (SalesHeader.Ship or RoundingLineInserted) then begin SalesLine."Qty. to Ship" := 0; SalesLine."Qty. to Ship (Base)" := 0; end; if not (SalesHeader.Receive or RoundingLineInserted) then begin SalesLine."Return Qty. to Receive" := 0; SalesLine."Return Qty. to Receive (Base)" := 0; end; JobContractLine := false; if (SalesLine.Type = SalesLine.Type::Item) or (SalesLine.Type = SalesLine.Type::"G/L Account") or (SalesLine.Type = SalesLine.Type::" ") then if SalesLine."Job Contract Entry No." > 0 then PostJobContractLine(SalesHeader, SalesLine); OnUpdateSalesLineBeforePostOnAfterPostJobContractLine(SalesInvHeader, SalesCrMemoHeader, SalesHeader, SalesLine); if SalesLine.Type = SalesLine.Type::Resource then JobTaskSalesLine := SalesLine; if (SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and (SalesLine."Shipment No." <> '') then begin SalesLine."Quantity Shipped" := SalesLine.Quantity; SalesLine."Qty. Shipped (Base)" := SalesLine."Quantity (Base)"; SalesLine."Qty. to Ship" := 0; SalesLine."Qty. to Ship (Base)" := 0; end; if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") and (SalesLine."Return Receipt No." <> '') then begin SalesLine."Return Qty. Received" := SalesLine.Quantity; SalesLine."Return Qty. Received (Base)" := SalesLine."Quantity (Base)"; SalesLine."Return Qty. to Receive" := 0; SalesLine."Return Qty. to Receive (Base)" := 0; end; InitSalesLineQtyToInvoice(SalesHeader, SalesLine); IsHandled := false; OnUpdateSalesLineBeforePostOnBeforeGetUnitCost(SalesLine, IsHandled); if not IsHandled then if (SalesLine.Type = SalesLine.Type::Item) and (SalesLine."No." <> '') then begin SalesLine.GetItem(Item); if (Item."Costing Method" = Item."Costing Method"::Standard) and not SalesLine.IsShipment() and not IsCreatedFromJob(SalesLine) then SalesLine.GetUnitCost(); end; OnAfterUpdateSalesLineBeforePost(SalesLine, SalesHeader, WhseShip, WhseReceive, SuppressCommit); end; local procedure IsCreatedFromJob(var SalesLine: Record "Sales Line"): Boolean begin if (SalesLine."Job No." <> '') and (SalesLine."Job Task No." <> '') and (SalesLine."Job Contract Entry No." <> 0) then exit(true); end; local procedure InitSalesLineQtyToInvoice(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeInitSalesLineQtyToInvoice(SalesHeader, SalesLine, IsHandled); if IsHandled then exit; if SalesHeader.Invoice then begin if Abs(SalesLine."Qty. to Invoice") > Abs(SalesLine.MaxQtyToInvoice()) then SalesLine.InitQtyToInvoice(); end else begin SalesLine."Qty. to Invoice" := 0; SalesLine."Qty. to Invoice (Base)" := 0; end; end; local procedure UpdateWhseDocuments(SalesHeader: Record "Sales Header"; EverythingInvoiced: Boolean) var IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateWhseDocuments(SalesHeader, IsHandled, WhseReceive, WhseShip, WhseRcptHeader, WhseShptHeader, TempWhseRcptHeader, TempWhseShptHeader); if IsHandled then exit; if WhseReceive then begin WhsePostRcpt.PostUpdateWhseDocuments(WhseRcptHeader); TempWhseRcptHeader.Delete(); end; if WhseShip then begin WhsePostShpt.PostUpdateWhseDocuments(WhseShptHeader); TempWhseShptHeader.Delete(); end; OnAfterUpdateWhseDocuments(SalesHeader, WhseShip, WhseReceive, WhseShptHeader, WhseRcptHeader, EverythingInvoiced); end; /// <summary> /// Deletes the document, lines and records related to the sales header after posting, unless the SkipDelete parameter is set. /// This is only run if everything was invoiced and the posting is not in PreviewMode /// </summary> /// <param name="SalesHeader">The sales header of the document that was posted.</param> /// <param name="EverythingInvoiced">A flag indicating whether everything was invoiced. Only used in events, serves no functional purpose.</param> procedure DeleteAfterPosting(var SalesHeader: Record "Sales Header"; EverythingInvoiced: Boolean) var SalesCommentLine: Record "Sales Comment Line"; SalesLine: Record "Sales Line"; TempSalesLine: Record "Sales Line" temporary; WarehouseRequest: Record "Warehouse Request"; IsHandled: Boolean; SkipDelete: Boolean; begin OnBeforeDeleteAfterPosting(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SkipDelete, SuppressCommit, EverythingInvoiced, TempSalesLineGlobal); if SkipDelete then exit; IsHandled := false; OnDeleteAfterPostingOnBeforeDeleteLinks(SalesHeader, IsHandled); if not IsHandled then if SalesHeader.HasLinks() then SalesHeader.DeleteLinks(); WarehouseRequest.DeleteRequest(DATABASE::"Sales Line", SalesHeader."Document Type".AsInteger(), SalesHeader."No."); OnDeleteAfterPostingOnBeforeDeleteSalesHeader(SalesHeader); SalesHeader.Delete(); SalesLineReserve.DeleteInvoiceSpecFromHeader(SalesHeader); DeleteATOLinks(SalesHeader); ResetTempLines(TempSalesLine); OnDeleteAfterPostingOnAfterSetupSalesHeader(SalesHeader, TempSalesLine); if TempSalesLine.FindFirst() then repeat if TempSalesLine."Deferral Code" <> '' then DeferralUtilities.RemoveOrSetDeferralSchedule( '', Enum::"Deferral Document Type"::Sales.AsInteger(), '', '', TempSalesLine."Document Type".AsInteger(), TempSalesLine."Document No.", TempSalesLine."Line No.", 0, 0D, TempSalesLine.Description, '', true); if TempSalesLine.HasLinks() then TempSalesLine.DeleteLinks(); OnDeleteAfterPostingOnAfterDeleteLinks(TempSalesLine); until TempSalesLine.Next() = 0; SalesLine.SetCurrentKey("Document Type", "Document No.", "Line No."); SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); OnBeforeSalesLineDeleteAll(SalesLine, SuppressCommit, SalesHeader); SalesLine.DeleteAll(); OnDeleteAfterPostingOnAfterSalesLineDeleteAll(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SuppressCommit, EverythingInvoiced); DeleteItemChargeAssgnt(SalesHeader); SalesCommentLine.DeleteComments(SalesHeader."Document Type".AsInteger(), SalesHeader."No."); OnAfterDeleteAfterPosting(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SuppressCommit); end; local procedure FinalizePosting(var SalesHeader: Record "Sales Header"; EverythingInvoiced: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) var CRMConnectionSetup: Record "CRM Connection Setup"; TempSalesLine: Record "Sales Line" temporary; GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview"; ICInboxOutboxMgt: Codeunit ICInboxOutboxMgt; WhseSalesRelease: Codeunit "Whse.-Sales Release"; ArchiveManagement: Codeunit ArchiveManagement; IsHandled: Boolean; begin OnBeforeFinalizePosting(SalesHeader, TempSalesLineGlobal, EverythingInvoiced, SuppressCommit, GenJnlPostLine); if (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) and (not EverythingInvoiced) then begin SalesHeader.Modify(); InsertTrackingSpecification(SalesHeader); PostUpdateOrderLine(SalesHeader); UpdateAssociatedPurchaseOrder(TempDropShptPostBuffer, SalesHeader); if not PreviewMode then UpdateWhseDocuments(SalesHeader, EverythingInvoiced); WhseSalesRelease.Release(SalesHeader); UpdateItemChargeAssgnt(SalesHeader); OnFinalizePostingOnAfterUpdateItemChargeAssgnt(SalesHeader, TempDropShptPostBuffer, GenJnlPostLine); end else begin OnFinalizePostingOnBeforeInsertTrackingSpecification(TempDropShptPostBuffer, TempItemChargeAssgntSales, SalesHeader, TempTrackingSpecification, EverythingInvoiced, TempSalesLine, TempSalesLineGlobal, this); case SalesHeader."Document Type" of SalesHeader."Document Type"::Invoice: begin PostUpdateInvoiceLine(SalesHeader); InsertTrackingSpecification(SalesHeader); PostUpdateOrderNo(SalesInvHeader); ArchiveRelatedJob(SalesHeader); end; SalesHeader."Document Type"::"Credit Memo": begin PostUpdateReturnReceiptLine(); InsertTrackingSpecification(SalesHeader); PostUpdateOrderNo(SalesCrMemoHeader); end; else begin UpdateAssociatedPurchaseOrder(TempDropShptPostBuffer, SalesHeader); if DropShipOrder then InsertTrackingSpecification(SalesHeader); ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Purch. Order Line No.", '<>0'); if TempSalesLine.FindSet() then repeat UpdateAssocLines(TempSalesLine); TempSalesLine.Modify(); until TempSalesLine.Next() = 0; ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Prepayment %", '<>0'); if TempSalesLine.FindSet() then repeat DecrementPrepmtAmtInvLCY( SalesHeader, TempSalesLine, TempSalesLine."Prepmt. Amount Inv. (LCY)", TempSalesLine."Prepmt. VAT Amount Inv. (LCY)"); TempSalesLine.Modify(); until TempSalesLine.Next() = 0; if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) and SalesSetup."Archive Orders" then begin PostUpdateOrderLine(SalesHeader); if (not OrderArchived) or (OrderArchived and CRMConnectionSetup.IsBidirectionalSalesOrderIntEnabled()) then begin ArchiveManagement.AutoArchiveSalesDocument(SalesHeader); OrderArchived := true; end; end; end; end; UpdateAfterPosting(SalesHeader); UpdateEmailParameters(SalesHeader); if not PreviewMode then UpdateWhseDocuments(SalesHeader, EverythingInvoiced); if not OrderArchived then begin ArchiveManagement.AutoArchiveSalesDocument(SalesHeader); OrderArchived := true; end; OnFinalizePostingOnBeforeDeleteApprovalEntries(SalesHeader, EverythingInvoiced); DeleteApprovalEntries(SalesHeader); if not PreviewMode then DeleteAfterPosting(SalesHeader, EverythingInvoiced); end; InsertValueEntryRelation(); OnAfterFinalizePostingOnBeforeCommit( SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlPostLine, SuppressCommit, PreviewMode, WhseShip, WhseReceive, EverythingInvoiced); if PreviewMode and (CalledBy = 0) then begin if GuiAllowed() and not HideProgressWindow then Window.Close(); IsHandled := false; OnFinalizePostingOnBeforeGenJnlPostPreviewThrowError(SalesHeader, SalesInvHeader, SalesCrMemoHeader, IsHandled); if not IsHandled then GenJnlPostPreview.ThrowError(); end; ICInboxOutboxMgt.CheckPermissionToSendICTransaction(SalesHeader); if not (InvtPickPutaway or SuppressCommit or PreviewMode) then Commit(); if GuiAllowed() and not HideProgressWindow then Window.Close(); IsHandled := false; OnFinalizePostingOnBeforeCreateOutboxSalesTrans(SalesHeader, IsHandled, EverythingInvoiced, SalesInvHeader, SalesCrMemoHeader); if not IsHandled then if SalesHeader.Invoice and SalesHeader."Send IC Document" then if SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice] then ICInboxOutboxMgt.CreateOutboxSalesInvTrans(SalesInvHeader) else ICInboxOutboxMgt.CreateOutboxSalesCrMemoTrans(SalesCrMemoHeader); OnAfterFinalizePosting( SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlPostLine, SuppressCommit, PreviewMode); ClearPostBuffers(); if SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order" then UpdateSalesOrderLineIfExist(SalesHeader."No."); end; local procedure DeleteApprovalEntries(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeDeleteApprovalEntries(SalesHeader, IsHandled); if IsHandled then exit; ApprovalsMgmt.DeleteApprovalEntries(SalesHeader.RecordId()); OnAfterDeleteApprovalEntries(SalesHeader, SalesInvHeader, SalesCrMemoHeader, SalesShptHeader, ReturnRcptHeader); end; /// <summary> /// Initializes the global Currency variable with the currency code passed as a parameter. /// </summary> /// <param name="CurrencyCode">The currency code to initialize the global Currency variable with.</param> procedure GetCurrency(CurrencyCode: Code[10]) begin Currency.Initialize(CurrencyCode, true); OnAfterGetCurrency(CurrencyCode, Currency); end; local procedure DivideAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary) begin DivideAmount(SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, true); end; local procedure DivideAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; IncludePrepayments: Boolean) var OriginalDeferralAmount: Decimal; IsHandled: Boolean; begin if RoundingLineInserted and (RoundingLineNo = SalesLine."Line No.") then exit; IsHandled := false; OnBeforeDivideAmount( SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, IsHandled, TempPrepmtDeductLCYSalesLine); if IsHandled then exit; if (SalesLineQty = 0) or (SalesLine."Unit Price" = 0) then begin SalesLine."Line Amount" := 0; SalesLine."Line Discount Amount" := 0; SalesLine."Inv. Discount Amount" := 0; SalesLine."VAT Base Amount" := 0; SalesLine.Amount := 0; SalesLine."Amount Including VAT" := 0; OnDivideAmountOnAfterInitAmount(SalesHeader, SalesLine, SalesLineQty); end else begin OriginalDeferralAmount := SalesLine.GetDeferralAmount(); IsHandled := false; OnDivideAmountOnBeforeTempVATAmountLineGet(SalesLine, TempVATAmountLine, IsHandled); if not IsHandled then TempVATAmountLine.Get(SalesLine."VAT Identifier", SalesLine."VAT Calculation Type", SalesLine."Tax Group Code", false, SalesLine."Line Amount" >= 0); if SalesLine."VAT Calculation Type" = SalesLine."VAT Calculation Type"::"Sales Tax" then SalesLine."VAT %" := TempVATAmountLine."VAT %"; TempVATAmountLineRemainder := TempVATAmountLine; if not TempVATAmountLineRemainder.Find() then begin TempVATAmountLineRemainder.Init(); TempVATAmountLineRemainder.Insert(); end; DivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader, SalesLine, SalesLineQty, IncludePrepayments, TempVATAmountLine); OnDivideAmountOnAfterInitLineDiscountAmount(SalesHeader, SalesLine, SalesLineQty); if SalesLine."Allow Invoice Disc." and (TempVATAmountLine."Inv. Disc. Base Amount" <> 0) then if QtyType = QtyType::Invoicing then SalesLine."Inv. Discount Amount" := SalesLine."Inv. Disc. Amount to Invoice" else begin TempVATAmountLineRemainder."Invoice Discount Amount" := TempVATAmountLineRemainder."Invoice Discount Amount" + TempVATAmountLine."Invoice Discount Amount" * SalesLine."Line Amount" / TempVATAmountLine."Inv. Disc. Base Amount"; SalesLine."Inv. Discount Amount" := Round( TempVATAmountLineRemainder."Invoice Discount Amount", Currency."Amount Rounding Precision"); TempVATAmountLineRemainder."Invoice Discount Amount" := TempVATAmountLineRemainder."Invoice Discount Amount" - SalesLine."Inv. Discount Amount"; end; IsHandled := false; OnDivideAmountOnBeforeUpdateTempVATAmountLineRemainder(SalesLine, SalesHeader, TempVATAmountLine, TempVATAmountLineRemainder, Currency, IsHandled); if not IsHandled then if SalesHeader."Prices Including VAT" then begin if (TempVATAmountLine.CalcLineAmount() = 0) or (SalesLine."Line Amount" = 0) then begin TempVATAmountLineRemainder."VAT Amount" := 0; TempVATAmountLineRemainder."Amount Including VAT" := 0; end else begin TempVATAmountLineRemainder."VAT Amount" += TempVATAmountLine."VAT Amount" * SalesLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount(); TempVATAmountLineRemainder."Amount Including VAT" += TempVATAmountLine."Amount Including VAT" * SalesLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount(); end; if SalesLine."Line Discount %" <> 100 then SalesLine."Amount Including VAT" := Round(TempVATAmountLineRemainder."Amount Including VAT", Currency."Amount Rounding Precision") else SalesLine."Amount Including VAT" := 0; SalesLine.Amount := Round(SalesLine."Amount Including VAT", Currency."Amount Rounding Precision") - Round(TempVATAmountLineRemainder."VAT Amount", Currency."Amount Rounding Precision"); CalcVATBaseAmount(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder); TempVATAmountLineRemainder."Amount Including VAT" := TempVATAmountLineRemainder."Amount Including VAT" - SalesLine."Amount Including VAT"; TempVATAmountLineRemainder."VAT Amount" := TempVATAmountLineRemainder."VAT Amount" - SalesLine."Amount Including VAT" + SalesLine.Amount; end else if SalesLine."VAT Calculation Type" = SalesLine."VAT Calculation Type"::"Full VAT" then begin if SalesLine."Line Discount %" <> 100 then SalesLine."Amount Including VAT" := SalesLine.CalcLineAmount() else SalesLine."Amount Including VAT" := 0; SalesLine.Amount := 0; SalesLine."VAT Base Amount" := 0; end else begin SalesLine.Amount := SalesLine.CalcLineAmount(); CalcVATBaseAmount(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder); if TempVATAmountLine."VAT Base" = 0 then TempVATAmountLineRemainder."VAT Amount" := 0 else TempVATAmountLineRemainder."VAT Amount" += TempVATAmountLine."VAT Amount" * SalesLine.CalcLineAmount() / TempVATAmountLine.CalcLineAmount(); if SalesLine."Line Discount %" <> 100 then SalesLine."Amount Including VAT" := SalesLine.Amount + Round(TempVATAmountLineRemainder."VAT Amount", Currency."Amount Rounding Precision") else SalesLine."Amount Including VAT" := 0; TempVATAmountLineRemainder."VAT Amount" := TempVATAmountLineRemainder."VAT Amount" - SalesLine."Amount Including VAT" + SalesLine.Amount; end; OnDivideAmountOnBeforeTempVATAmountLineRemainderModify(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder, Currency); TempVATAmountLineRemainder.Modify();#pragma warning disable AA0005 if SalesLine."Deferral Code" <> '' then begin GetInvoicePostingSetup(); InvoicePostingInterface.CalcDeferralAmounts(SalesHeader, SalesLine, OriginalDeferralAmount); end;#pragma warning restore AA0005 end; OnAfterDivideAmount(SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder); end; local procedure DivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal; IncludePrepayments: Boolean; var TempVATAmountLine: Record "VAT Amount Line" temporary) var IsHandled: Boolean; begin IsHandled := false; OnBeforeDivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader, SalesLine, SalesLineQty, IncludePrepayments, IsHandled, TempPrepmtDeductLCYSalesLine, TempVATAmountLine); if IsHandled then exit; if IncludePrepayments then SalesLine."Line Amount" := SalesLine.GetLineAmountToHandleInclPrepmt(SalesLineQty) + GetPrepmtDiffToLineAmount(SalesLine) else SalesLine."Line Amount" := SalesLine.GetLineAmountToHandle(SalesLineQty); if SalesLineQty <> SalesLine.Quantity then SalesLine."Line Discount Amount" := Round(SalesLine."Line Discount Amount" * SalesLineQty / SalesLine.Quantity, Currency."Amount Rounding Precision"); end; local procedure RoundAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal) var NoVAT: Boolean; IsHandled: Boolean; begin OnBeforeRoundAmount(SalesHeader, SalesLine, SalesLineQty, CurrExchRate); IncrAmount(SalesHeader, SalesLine, TotalSalesLine); TotalSalesLine."Net Weight" += Round(SalesLineQty * SalesLine."Net Weight", UOMMgt.WeightRndPrecision()); TotalSalesLine."Gross Weight" += Round(SalesLineQty * SalesLine."Gross Weight", UOMMgt.WeightRndPrecision()); TotalSalesLine."Unit Volume" += Round(SalesLineQty * SalesLine."Unit Volume", UOMMgt.CubageRndPrecision()); TotalSalesLine.Quantity += SalesLineQty; if SalesLine."Units per Parcel" > 0 then TotalSalesLine."Units per Parcel" += Round(SalesLineQty / SalesLine."Units per Parcel", 1, '>'); xSalesLine := SalesLine; SalesLineACY := SalesLine; IsHandled := false; OnRoundAmountOnAfterAssignSalesLines(xSalesLine, SalesLineACY, SalesHeader, IsHandled, TotalSalesLine, TotalSalesLineLCY, SalesLine); if not IsHandled then if (SalesHeader."Currency Code" <> '') and (SalesLine.Type <> SalesLine.Type::" ") then begin NoVAT := SalesLine.Amount = SalesLine."Amount Including VAT"; SalesLine."Amount Including VAT" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine."Amount Including VAT", SalesHeader."Currency Factor")) - TotalSalesLineLCY."Amount Including VAT"; if NoVAT then SalesLine.Amount := SalesLine."Amount Including VAT" else SalesLine.Amount := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine.Amount, SalesHeader."Currency Factor")) - TotalSalesLineLCY.Amount; SalesLine."Line Amount" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine."Line Amount", SalesHeader."Currency Factor")) - TotalSalesLineLCY."Line Amount"; SalesLine."Line Discount Amount" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine."Line Discount Amount", SalesHeader."Currency Factor")) - TotalSalesLineLCY."Line Discount Amount"; SalesLine."Inv. Discount Amount" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine."Inv. Discount Amount", SalesHeader."Currency Factor")) - TotalSalesLineLCY."Inv. Discount Amount"; SalesLine."VAT Difference" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine."VAT Difference", SalesHeader."Currency Factor")) - TotalSalesLineLCY."VAT Difference"; SalesLine."VAT Base Amount" := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalSalesLine."VAT Base Amount", SalesHeader."Currency Factor")) - TotalSalesLineLCY."VAT Base Amount"; end; IsHandled := false; OnRoundAmountOnBeforeIncrAmount(SalesHeader, SalesLine, SalesLineQty, TotalSalesLine, TotalSalesLineLCY, xSalesLine, IsHandled); if not IsHandled then begin IncrAmount(SalesHeader, SalesLine, TotalSalesLineLCY); TotalSalesLineLCY."Unit Cost (LCY)" += Round(SalesLineQty * SalesLine."Unit Cost (LCY)"); end; OnAfterRoundAmount(SalesHeader, SalesLine, SalesLineQty); end; /// <summary> /// Reverses the amounts and quantities of a sales line. /// </summary> /// <param name="SalesLine">The sales line for which to reverse the amounts and quantities.</param> procedure ReverseAmount(var SalesLine: Record "Sales Line") begin SalesLine."Qty. to Ship" := -SalesLine."Qty. to Ship"; SalesLine."Qty. to Ship (Base)" := -SalesLine."Qty. to Ship (Base)"; SalesLine."Return Qty. to Receive" := -SalesLine."Return Qty. to Receive"; SalesLine."Return Qty. to Receive (Base)" := -SalesLine."Return Qty. to Receive (Base)"; SalesLine."Qty. to Invoice" := -SalesLine."Qty. to Invoice"; SalesLine."Qty. to Invoice (Base)" := -SalesLine."Qty. to Invoice (Base)"; SalesLine."Line Amount" := -SalesLine."Line Amount"; SalesLine.Amount := -SalesLine.Amount; SalesLine."VAT Base Amount" := -SalesLine."VAT Base Amount"; SalesLine."VAT Difference" := -SalesLine."VAT Difference"; SalesLine."Amount Including VAT" := -SalesLine."Amount Including VAT"; SalesLine."Line Discount Amount" := -SalesLine."Line Discount Amount"; SalesLine."Inv. Discount Amount" := -SalesLine."Inv. Discount Amount"; OnAfterReverseAmount(SalesLine); end; local procedure InvoiceRounding(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; UseTempData: Boolean; BiggestLineNo: Integer) var CustPostingGr: Record "Customer Posting Group"; InvoiceRoundingAmount: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeInvoiceRounding(SalesHeader, IsHandled); if IsHandled then exit; Currency.TestField("Invoice Rounding Precision"); InvoiceRoundingAmount := -Round( TotalSalesLine."Amount Including VAT" - Round( TotalSalesLine."Amount Including VAT", Currency."Invoice Rounding Precision", Currency.InvoiceRoundingDirection()), Currency."Amount Rounding Precision"); OnBeforeInvoiceRoundingAmount( SalesHeader, TotalSalesLine."Amount Including VAT", UseTempData, InvoiceRoundingAmount, SuppressCommit, TotalSalesLine, Currency); if InvoiceRoundingAmount <> 0 then begin CustPostingGr.Get(SalesHeader."Customer Posting Group"); SalesLine.Init(); BiggestLineNo := BiggestLineNo + 10000; SalesLine."System-Created Entry" := true; if UseTempData then begin SalesLine."Line No." := 0; SalesLine.Type := SalesLine.Type::"G/L Account"; SalesLine.SetHideValidationDialog(true); end else begin SalesLine."Line No." := BiggestLineNo; SalesLine.Validate(Type, SalesLine.Type::"G/L Account"); end; SalesLine.Validate("No.", CustPostingGr.GetInvRoundingAccount()); SalesLine.Validate(Quantity, 1); OnInvoiceRoundingOnAfterValidateQuantity(SalesHeader, SalesLine); if SalesLine.IsCreditDocType() then SalesLine.Validate("Return Qty. to Receive", SalesLine.Quantity) else SalesLine.Validate("Qty. to Ship", SalesLine.Quantity); if SalesHeader."Prices Including VAT" then SalesLine.Validate("Unit Price", InvoiceRoundingAmount) else SalesLine.Validate( "Unit Price", Round( InvoiceRoundingAmount / (1 + (1 - SalesLine.GetVatBaseDiscountPct(SalesHeader) / 100) * SalesLine."VAT %" / 100), Currency."Amount Rounding Precision")); SalesLine.Validate("Amount Including VAT", InvoiceRoundingAmount); SalesLine."Line No." := BiggestLineNo; OnInvoiceRoundingOnAfterSetLineNo(SalesHeader, SalesLine); LastLineRetrieved := false; RoundingLineInserted := true; RoundingLineNo := SalesLine."Line No."; end; OnAfterInvoiceRoundingAmount( SalesHeader, SalesLine, TotalSalesLine, UseTempData, InvoiceRoundingAmount, SuppressCommit, Currency, BiggestLineNo, LastLineRetrieved, RoundingLineInserted, RoundingLineNo); end; /// <summary> /// Adds the amounts from sales line to the TotalSalesLine record. /// </summary> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="SalesLine">The sales line to add the amounts from.</param> /// <param name="TotalSalesLine">Return Variable: The TotalSalesLine record to which the amounts are added.</param> procedure IncrAmount(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TotalSalesLine: Record "Sales Line") begin if SalesHeader."Prices Including VAT" or (SalesLine."VAT Calculation Type" <> SalesLine."VAT Calculation Type"::"Full VAT") then TotalSalesLine."Line Amount" += SalesLine."Line Amount"; TotalSalesLine.Amount += SalesLine.Amount; TotalSalesLine."VAT Base Amount" += SalesLine."VAT Base Amount"; TotalSalesLine."VAT Difference" += SalesLine."VAT Difference"; TotalSalesLine."Amount Including VAT" += SalesLine."Amount Including VAT"; TotalSalesLine."Line Discount Amount" += SalesLine."Line Discount Amount"; TotalSalesLine."Inv. Discount Amount" += SalesLine."Inv. Discount Amount"; TotalSalesLine."Inv. Disc. Amount to Invoice" += SalesLine."Inv. Disc. Amount to Invoice"; TotalSalesLine."Prepmt. Line Amount" += SalesLine."Prepmt. Line Amount"; TotalSalesLine."Prepmt. Amt. Inv." += SalesLine."Prepmt. Amt. Inv."; TotalSalesLine."Prepmt Amt to Deduct" += SalesLine."Prepmt Amt to Deduct"; TotalSalesLine."Prepmt Amt Deducted" += SalesLine."Prepmt Amt Deducted"; TotalSalesLine."Prepayment VAT Difference" += SalesLine."Prepayment VAT Difference"; TotalSalesLine."Prepmt VAT Diff. to Deduct" += SalesLine."Prepmt VAT Diff. to Deduct"; TotalSalesLine."Prepmt VAT Diff. Deducted" += SalesLine."Prepmt VAT Diff. Deducted"; OnAfterIncrAmount(TotalSalesLine, SalesLine, SalesHeader); end; local procedure GetSalesHeader(var SalesHeader: Record "Sales Header") var SalesHeaderCopy: Record "Sales Header"; begin SalesHeaderCopy := SalesHeader; SalesHeader.ReadIsolation := IsolationLevel::ReadCommitted; SalesHeader.Get(SalesHeader."Document Type", SalesHeader."No."); SalesHeader := SalesHeaderCopy; end; /// <summary> /// Collects the sales lines for the specified sales header and stores them in the NewSalesLine record set. /// Collected lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <remarks> /// An overload for GetSalesLines that always includes prepayments (if QtyType is set to Invoicing). /// </remarks> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> procedure GetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping) begin GetSalesLines(SalesHeader, NewSalesLine, QtyType, true); end; /// <summary> /// Collects and divides amounts of the sales lines for the specified sales header and stores them in the NewSalesLine record set. /// Collected lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included in the collected lines. Only applies if QtyType is set to Invoicing.</param> procedure GetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; IncludePrepayments: Boolean) var TotalAdjCostLCY: Decimal; begin OnBeforeGetSalesLines(SalesHeader, NewSalesLine, QtyType, IncludePrepayments); FillTempLines(SalesHeader, TempSalesLineGlobal); OnGetSalesLinesOnAfterFillTempLines(SalesHeader, TempSalesLineGlobal); if (QtyType = QtyType::Invoicing) and IncludePrepayments then CreatePrepaymentLines(SalesHeader, false); SumSalesLines2(SalesHeader, NewSalesLine, TempSalesLineGlobal, QtyType, true, false, TotalAdjCostLCY, IncludePrepayments, false); OnAfterGetSalesLines(SalesHeader, TempSalesLineGlobal, NewSalesLine); end; /// <summary> /// Collects and divides amounts of the sales lines for the specified sales header and stores them in the NewSalesLine record set. /// Collected lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included in the collected lines. Only applies if QtyType is set to Invoicing.</param> /// <param name="CalledFromStatistics">A flag indicating whether the procedure is called from statistics.</param> procedure GetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; IncludePrepayments: Boolean; CalledFromStatistics: Boolean) var TotalAdjCostLCY: Decimal; begin OnBeforeGetSalesLines(SalesHeader, NewSalesLine, QtyType, IncludePrepayments); FillTempLines(SalesHeader, TempSalesLineGlobal); OnGetSalesLinesOnAfterFillTempLines(SalesHeader, TempSalesLineGlobal); if (QtyType = QtyType::Invoicing) and IncludePrepayments then CreatePrepaymentLines(SalesHeader, false); SumSalesLines2(SalesHeader, NewSalesLine, TempSalesLineGlobal, QtyType, true, false, TotalAdjCostLCY, IncludePrepayments, CalledFromStatistics); OnAfterGetSalesLines(SalesHeader, TempSalesLineGlobal, NewSalesLine); end; /// <summary> /// Divides amounts of the sales lines passed as OldSalesLine parameter and stores them in the NewSalesLine record set. /// Lines will have the amounts divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <remarks> /// Behaves similarly to GetSalesLines with the exception that GetSalesLines collects all the lines for the specified sales header, /// while this method only divides the amounts of the lines passed as OldSalesLine parameter. /// </remarks> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="NewSalesLine">Return Variable: The NewSalesLine record set to store the collected sales lines in. This should be a temporary variable as new records will be inserted.</param> /// <param name="OldSalesLine">The sales line record set to copy the lines from and divide the amounts.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> procedure GetSalesLinesTemp(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping) var TotalAdjCostLCY: Decimal; begin OnBeforeGetSalesLinesTemp(SalesHeader, NewSalesLine, OldSalesLine, QtyType); OldSalesLine.SetSalesHeader(SalesHeader); SumSalesLines2(SalesHeader, NewSalesLine, OldSalesLine, QtyType, true, false, TotalAdjCostLCY); end; /// <summary> /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables. /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <remarks> /// This is an overload for SumSalesLineTemp that always includes prepayments in amount calculations /// it always takes the lines for the specified sales header (doesn't support a parameter for filtered or temp sales lines). /// </remarks> /// <param name="NewSalesHeader">The sales header of the document.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param> /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param> /// <param name="VATAmount">Return Variable: The total VAT amount.</param> /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param> /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param> /// <param name="ProfitPct">Return Variable: The total profit percentage.</param> /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param> procedure SumSalesLines(var NewSalesHeader: Record "Sales Header"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal) var OldSalesLine: Record "Sales Line"; begin SumSalesLinesTemp( NewSalesHeader, OldSalesLine, QtyType, NewTotalSalesLine, NewTotalSalesLineLCY, VATAmount, VATAmountText, ProfitLCY, ProfitPct, TotalAdjCostLCY); end; /// <summary> /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables. /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <remarks> /// OldSalesLine can be a temporary variable /// This is an overload for SumSalesLineTemp that always includes prepayments in amount calculations /// </remarks> /// <param name="SalesHeader"></param> /// <param name="OldSalesLine"></param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param> /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param> /// <param name="VATAmount">Return Variable: The total VAT amount.</param> /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param> /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param> /// <param name="ProfitPct">Return Variable: The total profit percentage.</param> /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param> procedure SumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal) begin SumSalesLinesTemp(SalesHeader, OldSalesLine, QtyType, NewTotalSalesLine, NewTotalSalesLineLCY, VATAmount, VATAmountText, ProfitLCY, ProfitPct, TotalAdjCostLCY, true); end; /// <summary> /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables. /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <remarks> /// OldSalesLine can be a temporary variable /// </remarks> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="OldSalesLine">The sales lines to sum.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param> /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param> /// <param name="VATAmount">Return Variable: The total VAT amount.</param> /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param> /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param> /// <param name="ProfitPct">Return Variable: The total profit percentage.</param> /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param> /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included when calculating Line Amounts.</param> procedure SumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean) var SalesLine: Record "Sales Line"; begin OnBeforeSumSalesLinesTemp(SalesHeader, OldSalesLine); SumSalesLines2(SalesHeader, SalesLine, OldSalesLine, QtyType, false, true, TotalAdjCostLCY, IncludePrepayments, false); ProfitLCY := TotalSalesLineLCY.Amount - TotalSalesLineLCY."Unit Cost (LCY)"; if TotalSalesLineLCY.Amount = 0 then ProfitPct := 0 else ProfitPct := Round(ProfitLCY / TotalSalesLineLCY.Amount * 100, 0.1); VATAmount := TotalSalesLine."Amount Including VAT" - TotalSalesLine.Amount; OnSumSalesLinesTempOnAfterVatAmountSet(VATAmount, TotalSalesLine); if TotalSalesLine."VAT %" = 0 then VATAmountText := VATAmountTxt else VATAmountText := StrSubstNo(VATRateTxt, TotalSalesLine.GetVATPct()); NewTotalSalesLine := TotalSalesLine; NewTotalSalesLineLCY := TotalSalesLineLCY; end; /// <summary> /// Sums the sales lines for the specified sales header (within the filters that are already set on OldSalesLine) and stores the results in the NewTotalSalesLine and NewTotalSalesLineLCY record variables. /// The amounts will be divided by quantity the same way as they are divided during the posting process, depending on the selected QtyType. /// </summary> /// <remarks> /// OldSalesLine can be a temporary variable /// </remarks> /// <param name="SalesHeader">The sales header of the document.</param> /// <param name="OldSalesLine">The sales lines to sum.</param> /// <param name="QtyType">The QtyType to use when dividing the amounts by quantity. General = Quantity, Invoicing = Qty. to Invoice, Shipping = Qty. to Ship.</param> /// <param name="NewTotalSalesLine">Return Variable: The NewTotalSalesLine record to store the summed amounts in.</param> /// <param name="NewTotalSalesLineLCY">Return Variable: The NewTotalSalesLineLCY record to store the summed amounts in LCY in.</param> /// <param name="VATAmount">Return Variable: The total VAT amount.</param> /// <param name="VATAmountText">Return Variable: The text to display for the VAT amount. This will include the VAT rate if the VAT rate is the same for all lines.</param> /// <param name="ProfitLCY">Return Variable: The total profit in LCY.</param> /// <param name="ProfitPct">Return Variable: The total profit percentage.</param> /// <param name="TotalAdjCostLCY">Return Variable: The total adjusted cost in LCY.</param> /// <param name="IncludePrepayments">A flag indicating whether prepayments should be included when calculating Line Amounts.</param> /// <param name="CalledFromStatistics">A flag indicating whether the procedure is called from statistics.</param> procedure SumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var NewTotalSalesLine: Record "Sales Line"; var NewTotalSalesLineLCY: Record "Sales Line"; var VATAmount: Decimal; var VATAmountText: Text[30]; var ProfitLCY: Decimal; var ProfitPct: Decimal; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean; CalledfromStatistics: Boolean) var SalesLine: Record "Sales Line"; begin OnBeforeSumSalesLinesTemp(SalesHeader, OldSalesLine); SumSalesLines2(SalesHeader, SalesLine, OldSalesLine, QtyType, false, true, TotalAdjCostLCY, IncludePrepayments, CalledfromStatistics); ProfitLCY := TotalSalesLineLCY.Amount - TotalSalesLineLCY."Unit Cost (LCY)"; if TotalSalesLineLCY.Amount = 0 then ProfitPct := 0 else ProfitPct := Round(ProfitLCY / TotalSalesLineLCY.Amount * 100, 0.1); VATAmount := TotalSalesLine."Amount Including VAT" - TotalSalesLine.Amount; OnSumSalesLinesTempOnAfterVatAmountSet(VATAmount, TotalSalesLine); if TotalSalesLine."VAT %" = 0 then VATAmountText := VATAmountTxt else VATAmountText := StrSubstNo(VATRateTxt, TotalSalesLine.GetVATPct()); NewTotalSalesLine := TotalSalesLine; NewTotalSalesLineLCY := TotalSalesLineLCY; end; local procedure SumSalesLines2(SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; InsertSalesLine: Boolean; CalcAdCostLCY: Boolean; var TotalAdjCostLCY: Decimal) begin SumSalesLines2(SalesHeader, NewSalesLine, OldSalesLine, QtyType, InsertSalesLine, CalcAdCostLCY, TotalAdjCostLCY, true, false); end; local procedure SumSalesLines2(SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; InsertSalesLine: Boolean; CalcAdCostLCY: Boolean; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean; CalledfromStatistics: Boolean) var SalesLine: Record "Sales Line"; TempVATAmountLine: Record "VAT Amount Line" temporary; TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; SalesLineQty: Decimal; AdjCostLCY: Decimal; BiggestLineNo: Integer; IsHandled: Boolean; begin IsHandled := false; OnBeforeSumSalesLines2(SalesHeader, NewSalesLine, OldSalesLine, QtyType, InsertSalesLine, CalcAdCostLCY, TotalAdjCostLCY, IncludePrepayments, IsHandled); if IsHandled then exit; TotalAdjCostLCY := 0; TempVATAmountLineRemainder.DeleteAll(); IsHandled := false; OnSumSalesLines2OnBeforeCalcVATAmountLines(OldSalesLine, SalesHeader, InsertSalesLine, TempVATAmountLine, QtyType, IsHandled); if not IsHandled then OldSalesLine.CalcVATAmountLines(QtyType, SalesHeader, OldSalesLine, TempVATAmountLine, IncludePrepayments); GetGLSetup(); GetSalesSetup(); GetCurrency(SalesHeader."Currency Code"); OldSalesLine.SetRange("Document Type", SalesHeader."Document Type"); OldSalesLine.SetRange("Document No.", SalesHeader."No."); OnSumSalesLines2SetFilter(OldSalesLine, SalesHeader, InsertSalesLine, QtyType); RoundingLineInserted := false; if OldSalesLine.FindSet() then repeat if not RoundingLineInserted then SalesLine := OldSalesLine; SalesLineQty := GetSalesLineQty(SalesHeader, SalesLine, QtyType, CalledfromStatistics); IsHandled := false; OnSumSalesLines2OnBeforeDivideAmount( OldSalesLine, IsHandled, SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, IncludePrepayments, RoundingLineInserted); if not IsHandled then DivideAmount(SalesHeader, SalesLine, QtyType, SalesLineQty, TempVATAmountLine, TempVATAmountLineRemainder, IncludePrepayments); OnSumSalesLines2OnAfterDivideAmount(OldSalesLine, SalesLineQty, QtyType); SalesLine.Quantity := SalesLineQty; if SalesLineQty <> 0 then begin if (SalesLine.Amount <> 0) and not RoundingLineInserted then if TotalSalesLine.Amount = 0 then TotalSalesLine."VAT %" := SalesLine."VAT %" else if TotalSalesLine."VAT %" <> SalesLine."VAT %" then TotalSalesLine."VAT %" := 0; RoundAmount(SalesHeader, SalesLine, SalesLineQty); if (QtyType in [QtyType::General, QtyType::Invoicing]) and not InsertSalesLine and CalcAdCostLCY then begin AdjCostLCY := CostCalcMgt.CalcSalesLineCostLCY(SalesLine, QtyType); TotalAdjCostLCY := TotalAdjCostLCY + GetSalesLineAdjCostLCY(SalesLine, QtyType, AdjCostLCY); OnSumSalesLines2OnAfterCalcTotalAdjCostLCY(TotalAdjCostLCY, SalesLine); end; SalesLine := xSalesLine; end; if InsertSalesLine then begin NewSalesLine := SalesLine; IsHandled := false; OnSumSalesLines2OnBeforeNewSalesLineInsert(NewSalesLine, IsHandled); if not IsHandled then NewSalesLine.Insert(); end; if RoundingLineInserted then LastLineRetrieved := true else begin BiggestLineNo := MAX(BiggestLineNo, OldSalesLine."Line No."); LastLineRetrieved := OldSalesLine.Next() = 0; if LastLineRetrieved and SalesSetup."Invoice Rounding" then InvoiceRounding(SalesHeader, SalesLine, true, BiggestLineNo); end; OnAfterUpdateInvoiceRounding( SalesHeader, TotalSalesLine, SalesLine, Currency, BiggestLineNo, LastLineRetrieved, RoundingLineInserted, RoundingLineNo, true); until LastLineRetrieved; OnAfterSumSalesLines2(SalesHeader, OldSalesLine, NewSalesLine); end; local procedure GetSalesLineQty(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; CalledFromStatistics: Boolean) SalesLineQty: Decimal; var IsHandled: Boolean; begin if (CalledFromStatistics) and (not RoundingLineInserted) and (IsInvoiceRoundingLine(SalesHeader, SalesLine)) and (SalesLine."System-Created Entry") then exit; IsHandled := false; OnBeforeGetSalesLineQty(SalesLine, QtyType, SalesLineQty, IsHandled); if IsHandled then exit(SalesLineQty); case QtyType of QtyType::General: SalesLineQty := SalesLine.Quantity; QtyType::Invoicing: SalesLineQty := SalesLine."Qty. to Invoice"; QtyType::Shipping: if SalesHeader.IsCreditDocType() then SalesLineQty := SalesLine."Return Qty. to Receive" else SalesLineQty := SalesLine."Qty. to Ship"; end; end; local procedure GetSalesLineAdjCostLCY(SalesLine2: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; AdjCostLCY: Decimal): Decimal var IsHandled: Boolean; Result: Decimal; begin IsHandled := false; OnBeforeGetSalesLineAdjCostLCY(SalesLine2, QtyType, AdjCostLCY, Result, IsHandled); if IsHandled then exit(Result); if SalesLine2."Document Type" in [SalesLine2."Document Type"::Order, SalesLine2."Document Type"::Invoice] then AdjCostLCY := -AdjCostLCY; case true of SalesLine2."Shipment No." <> '', SalesLine2."Return Receipt No." <> '': exit(AdjCostLCY); QtyType = QtyType::General: exit(Round(SalesLine2."Outstanding Quantity" * SalesLine2."Unit Cost (LCY)") + AdjCostLCY); SalesLine2."Document Type" in [SalesLine2."Document Type"::Order, SalesLine2."Document Type"::Invoice]: begin if SalesLine2."Qty. to Invoice" > SalesLine2."Qty. to Ship" then exit(Round(SalesLine2."Qty. to Ship" * SalesLine2."Unit Cost (LCY)") + AdjCostLCY); exit(Round(SalesLine2."Qty. to Invoice" * SalesLine2."Unit Cost (LCY)")); end; SalesLine2.IsCreditDocType(): begin if SalesLine2."Qty. to Invoice" > SalesLine2."Return Qty. to Receive" then exit(Round(SalesLine2."Return Qty. to Receive" * SalesLine2."Unit Cost (LCY)") + AdjCostLCY); exit(Round(SalesLine2."Qty. to Invoice" * SalesLine2."Unit Cost (LCY)")); end; end; end; /// <summary> /// Updated the related blanket order line for the quantities that are shipped, received or invoiced with the specified sales line. /// </summary> /// <param name="SalesLine">The sales line to update the blanket order line for.</param> /// <param name="Ship">A flag indicating whether the sales line is being shipped.</param> /// <param name="Receive">A flag indicating whether the sales line is being received (Return Orders).</param> /// <param name="Invoice">A flag indicating whether the sales line is being invoiced.</param> procedure UpdateBlanketOrderLine(SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean) var BlanketOrderSalesLine: Record "Sales Line"; xBlanketOrderSalesLine: Record "Sales Line"; ModifyLine: Boolean; Sign: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateBlanketOrderLine(SalesLine, Ship, Receive, Invoice, IsHandled); if IsHandled then exit; if (SalesLine."Blanket Order No." <> '') and (SalesLine."Blanket Order Line No." <> 0) and ((Ship and (SalesLine."Qty. to Ship" <> 0)) or (Receive and (SalesLine."Return Qty. to Receive" <> 0)) or (Invoice and (SalesLine."Qty. to Invoice" <> 0))) then if BlanketOrderSalesLine.Get( BlanketOrderSalesLine."Document Type"::"Blanket Order", SalesLine."Blanket Order No.", SalesLine."Blanket Order Line No.") then begin BlanketOrderSalesLine.TestField(Type, SalesLine.Type); BlanketOrderSalesLine.TestField("No.", SalesLine."No."); IsHandled := false; OnUpdateBlanketOrderLineOnBeforeCheckSellToCustomerNo(BlanketOrderSalesLine, SalesLine, IsHandled); if not IsHandled then BlanketOrderSalesLine.TestField("Sell-to Customer No.", SalesLine."Sell-to Customer No."); ModifyLine := false; case SalesLine."Document Type" of SalesLine."Document Type"::Order, SalesLine."Document Type"::Invoice: Sign := 1; SalesLine."Document Type"::"Return Order", SalesLine."Document Type"::"Credit Memo": Sign := -1; end; if Ship and (SalesLine."Shipment No." = '') then begin xBlanketOrderSalesLine := BlanketOrderSalesLine; if BlanketOrderSalesLine."Qty. per Unit of Measure" = SalesLine."Qty. per Unit of Measure" then BlanketOrderSalesLine."Quantity Shipped" += Sign * SalesLine."Qty. to Ship" else BlanketOrderSalesLine."Quantity Shipped" += Sign * Round( (SalesLine."Qty. per Unit of Measure" / BlanketOrderSalesLine."Qty. per Unit of Measure") * SalesLine."Qty. to Ship", UOMMgt.QtyRndPrecision()); BlanketOrderSalesLine."Qty. Shipped (Base)" += Sign * SalesLine."Qty. to Ship (Base)"; ModifyLine := true; AsmPost.UpdateBlanketATO(xBlanketOrderSalesLine, BlanketOrderSalesLine); end; if Receive and (SalesLine."Return Receipt No." = '') then begin if BlanketOrderSalesLine."Qty. per Unit of Measure" = SalesLine."Qty. per Unit of Measure" then BlanketOrderSalesLine."Quantity Shipped" += Sign * SalesLine."Return Qty. to Receive" else BlanketOrderSalesLine."Quantity Shipped" += Sign * Round( (SalesLine."Qty. per Unit of Measure" / BlanketOrderSalesLine."Qty. per Unit of Measure") * SalesLine."Return Qty. to Receive", UOMMgt.QtyRndPrecision()); BlanketOrderSalesLine."Qty. Shipped (Base)" += Sign * SalesLine."Return Qty. to Receive (Base)"; ModifyLine := true; end; if Invoice then begin if BlanketOrderSalesLine."Qty. per Unit of Measure" = SalesLine."Qty. per Unit of Measure" then BlanketOrderSalesLine."Quantity Invoiced" += Sign * SalesLine."Qty. to Invoice" else BlanketOrderSalesLine."Quantity Invoiced" += Sign * Round( (SalesLine."Qty. per Unit of Measure" / BlanketOrderSalesLine."Qty. per Unit of Measure") * SalesLine."Qty. to Invoice", UOMMgt.QtyRndPrecision()); BlanketOrderSalesLine."Qty. Invoiced (Base)" += Sign * SalesLine."Qty. to Invoice (Base)"; ModifyLine := true; end; if ModifyLine then begin OnUpdateBlanketOrderLineOnBeforeInitOutstanding(BlanketOrderSalesLine, SalesLine, Ship, Receive, Invoice); BlanketOrderSalesLine.InitOutstanding(); IsHandled := false; OnUpdateBlanketOrderLineOnBeforeCheck(BlanketOrderSalesLine, SalesLine, IsHandled); if not IsHandled then begin if (BlanketOrderSalesLine.Quantity * BlanketOrderSalesLine."Quantity Shipped" < 0) or (Abs(BlanketOrderSalesLine.Quantity) < Abs(BlanketOrderSalesLine."Quantity Shipped")) then BlanketOrderSalesLine.FieldError( "Quantity Shipped", StrSubstNo(BlanketOrderQuantityGreaterThanErr, BlanketOrderSalesLine.FieldCaption(Quantity))); if (BlanketOrderSalesLine."Quantity (Base)" * BlanketOrderSalesLine."Qty. Shipped (Base)" < 0) or (Abs(BlanketOrderSalesLine."Quantity (Base)") < Abs(BlanketOrderSalesLine."Qty. Shipped (Base)")) then BlanketOrderSalesLine.FieldError( "Qty. Shipped (Base)", StrSubstNo(BlanketOrderQuantityGreaterThanErr, BlanketOrderSalesLine.FieldCaption("Quantity (Base)"))); BlanketOrderSalesLine.CalcFields("Reserved Qty. (Base)"); if Abs(BlanketOrderSalesLine."Outstanding Qty. (Base)") < Abs(BlanketOrderSalesLine."Reserved Qty. (Base)") then BlanketOrderSalesLine.FieldError( "Reserved Qty. (Base)", BlanketOrderQuantityReducedErr); end; BlanketOrderSalesLine."Qty. to Invoice" := BlanketOrderSalesLine.Quantity - BlanketOrderSalesLine."Quantity Invoiced"; if (SalesLine.Quantity = SalesLine."Quantity Shipped") or (SalesLine."Quantity Shipped" = 0) then BlanketOrderSalesLine."Qty. to Ship" := BlanketOrderSalesLine.Quantity - BlanketOrderSalesLine."Quantity Shipped"; BlanketOrderSalesLine."Qty. to Invoice (Base)" := BlanketOrderSalesLine."Quantity (Base)" - BlanketOrderSalesLine."Qty. Invoiced (Base)"; if (SalesLine."Quantity (Base)" = SalesLine."Qty. Shipped (Base)") or (SalesLine."Qty. Shipped (Base)" = 0) then BlanketOrderSalesLine."Qty. to Ship (Base)" := BlanketOrderSalesLine."Quantity (Base)" - BlanketOrderSalesLine."Qty. Shipped (Base)"; OnBeforeBlanketOrderSalesLineModify(BlanketOrderSalesLine, SalesLine); BlanketOrderSalesLine.Modify(); OnAfterUpdateBlanketOrderLine(BlanketOrderSalesLine, SalesLine, Ship, Receive, Invoice); end; end; end; local procedure DeleteItemChargeAssgnt(SalesHeader: Record "Sales Header") var ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; begin ItemChargeAssgntSales.SetRange("Document Type", SalesHeader."Document Type"); ItemChargeAssgntSales.SetRange("Document No.", SalesHeader."No."); if not ItemChargeAssgntSales.IsEmpty() then ItemChargeAssgntSales.DeleteAll(); end; local procedure UpdateItemChargeAssgnt(var SalesHeader: Record "Sales Header") var ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; begin ClearItemChargeAssgntFilter(); TempItemChargeAssgntSales.MarkedOnly(true); if TempItemChargeAssgntSales.FindSet() then repeat ItemChargeAssgntSales.Get(TempItemChargeAssgntSales."Document Type", TempItemChargeAssgntSales."Document No.", TempItemChargeAssgntSales."Document Line No.", TempItemChargeAssgntSales."Line No."); ItemChargeAssgntSales."Qty. Assigned" += ItemChargeAssgntSales."Qty. to Handle"; ItemChargeAssgntSales."Qty. to Assign" -= ItemChargeAssgntSales."Qty. to Handle"; ItemChargeAssgntSales."Amount to Assign" -= ItemChargeAssgntSales."Amount to Handle"; ItemChargeAssgntSales."Qty. to Handle" := 0; ItemChargeAssgntSales."Amount to Handle" := 0; ItemChargeAssgntSales.Modify(); until TempItemChargeAssgntSales.Next() = 0; OnAfterUpdateItemChargeAssgnt(SalesHeader); end; /// <summary> /// Updates the Item Charge Assignment (Sales) lines quantities for the quantity that was posted for the specified sales line. /// </summary> /// <param name="SalesOrderInvLine">sales line of type Charge (Item) for the document being posted which is of type Invoice or Credit Memo</param> /// <param name="SalesOrderLine">sales line of document type Order or Return Order that is related to the SalesOrderInvLine</param> procedure UpdateSalesOrderChargeAssgnt(SalesOrderInvLine: Record "Sales Line"; SalesOrderLine: Record "Sales Line") var SalesOrderLine2: Record "Sales Line"; SalesOrderInvLine2: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; ReturnRcptLine: Record "Return Receipt Line"; begin ClearItemChargeAssgntFilter(); TempItemChargeAssgntSales.SetRange("Document Type", SalesOrderInvLine."Document Type"); TempItemChargeAssgntSales.SetRange("Document No.", SalesOrderInvLine."Document No."); TempItemChargeAssgntSales.SetRange("Document Line No.", SalesOrderInvLine."Line No."); TempItemChargeAssgntSales.MarkedOnly(true); if TempItemChargeAssgntSales.FindSet() then repeat if TempItemChargeAssgntSales."Applies-to Doc. Type" = SalesOrderInvLine."Document Type" then begin SalesOrderInvLine2.Get( TempItemChargeAssgntSales."Applies-to Doc. Type", TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No."); if SalesOrderLine."Document Type" = SalesOrderLine."Document Type"::Order then begin if not SalesShptLine.Get(SalesOrderInvLine2."Shipment No.", SalesOrderInvLine2."Shipment Line No.") then Error(ShipmentLinesDeletedErr); SalesOrderLine2.Get( SalesOrderLine2."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No."); end else begin if not ReturnRcptLine.Get(SalesOrderInvLine2."Return Receipt No.", SalesOrderInvLine2."Return Receipt Line No.") then Error(ReturnReceiptLinesDeletedErr); SalesOrderLine2.Get( SalesOrderLine2."Document Type"::"Return Order", ReturnRcptLine."Return Order No.", ReturnRcptLine."Return Order Line No."); end; UpdateSalesChargeAssgntLines( SalesOrderLine, SalesOrderLine2."Document Type", SalesOrderLine2."Document No.", SalesOrderLine2."Line No.", TempItemChargeAssgntSales."Qty. to Handle"); end else UpdateSalesChargeAssgntLines( SalesOrderLine, TempItemChargeAssgntSales."Applies-to Doc. Type", TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No.", TempItemChargeAssgntSales."Qty. to Handle"); until TempItemChargeAssgntSales.Next() = 0; end; local procedure UpdateSalesChargeAssgntLines(SalesOrderLine: Record "Sales Line"; ApplToDocType: Enum "Sales Applies-to Document Type"; ApplToDocNo: Code[20]; ApplToDocLineNo: Integer; QtyToHandle: Decimal) var ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; TempItemChargeAssgntSales2: Record "Item Charge Assignment (Sales)"; LastLineNo: Integer; TotalToAssign: Decimal; begin ItemChargeAssgntSales.SetRange("Document Type", SalesOrderLine."Document Type"); ItemChargeAssgntSales.SetRange("Document No.", SalesOrderLine."Document No."); ItemChargeAssgntSales.SetRange("Document Line No.", SalesOrderLine."Line No."); ItemChargeAssgntSales.SetRange("Applies-to Doc. Type", ApplToDocType); ItemChargeAssgntSales.SetRange("Applies-to Doc. No.", ApplToDocNo); ItemChargeAssgntSales.SetRange("Applies-to Doc. Line No.", ApplToDocLineNo); if ItemChargeAssgntSales.FindFirst() then begin ItemChargeAssgntSales."Qty. Assigned" += QtyToHandle; ItemChargeAssgntSales."Qty. to Assign" -= QtyToHandle; ItemChargeAssgntSales."Qty. to Handle" -= QtyToHandle; if ItemChargeAssgntSales."Qty. to Assign" < 0 then ItemChargeAssgntSales."Qty. to Assign" := 0; ItemChargeAssgntSales."Amount to Assign" := Round(ItemChargeAssgntSales."Qty. to Assign" * ItemChargeAssgntSales."Unit Cost", Currency."Amount Rounding Precision"); if ItemChargeAssgntSales."Qty. to Handle" < 0 then ItemChargeAssgntSales."Qty. to Handle" := 0; ItemChargeAssgntSales."Amount to Handle" := Round(ItemChargeAssgntSales."Qty. to Handle" * ItemChargeAssgntSales."Unit Cost", Currency."Amount Rounding Precision"); ItemChargeAssgntSales.Modify(); end else begin ItemChargeAssgntSales.SetRange("Applies-to Doc. Type"); ItemChargeAssgntSales.SetRange("Applies-to Doc. No."); ItemChargeAssgntSales.SetRange("Applies-to Doc. Line No."); ItemChargeAssgntSales.CalcSums("Qty. to Assign", "Qty. to Handle"); // calculate total qty. to assign of the invoice charge line TempItemChargeAssgntSales2.SetRange("Document Type", TempItemChargeAssgntSales."Document Type"); TempItemChargeAssgntSales2.SetRange("Document No.", TempItemChargeAssgntSales."Document No."); TempItemChargeAssgntSales2.SetRange("Document Line No.", TempItemChargeAssgntSales."Document Line No."); TempItemChargeAssgntSales2.CalcSums("Qty. to Assign", "Qty. to Handle"); TotalToAssign := ItemChargeAssgntSales."Qty. to Handle" + TempItemChargeAssgntSales2."Qty. to Handle"; if ItemChargeAssgntSales.FindLast() then LastLineNo := ItemChargeAssgntSales."Line No."; if SalesOrderLine.Quantity < TotalToAssign then repeat TotalToAssign -= ItemChargeAssgntSales."Qty. to Handle"; ItemChargeAssgntSales."Qty. to Assign" -= ItemChargeAssgntSales."Qty. to Handle"; ItemChargeAssgntSales."Amount to Assign" -= ItemChargeAssgntSales."Amount to Handle"; ItemChargeAssgntSales."Qty. to Handle" := 0; ItemChargeAssgntSales."Amount to Handle" := 0; ItemChargeAssgntSales.Modify(); until (ItemChargeAssgntSales.Next(-1) = 0) or (TotalToAssign = SalesOrderLine.Quantity); InsertAssocOrderCharge( SalesOrderLine, ApplToDocType, ApplToDocNo, ApplToDocLineNo, LastLineNo, TempItemChargeAssgntSales."Applies-to Doc. Line Amount"); end; end; local procedure InsertAssocOrderCharge(SalesOrderLine: Record "Sales Line"; ApplToDocType: Enum "Sales Applies-to Document Type"; ApplToDocNo: Code[20]; ApplToDocLineNo: Integer; LastLineNo: Integer; ApplToDocLineAmt: Decimal) var NewItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; begin NewItemChargeAssgntSales.Init(); NewItemChargeAssgntSales."Document Type" := SalesOrderLine."Document Type"; NewItemChargeAssgntSales."Document No." := SalesOrderLine."Document No."; NewItemChargeAssgntSales."Document Line No." := SalesOrderLine."Line No."; NewItemChargeAssgntSales."Line No." := LastLineNo + 10000; NewItemChargeAssgntSales."Item Charge No." := TempItemChargeAssgntSales."Item Charge No."; NewItemChargeAssgntSales."Item No." := TempItemChargeAssgntSales."Item No."; NewItemChargeAssgntSales."Qty. Assigned" := TempItemChargeAssgntSales."Qty. to Handle"; NewItemChargeAssgntSales."Qty. to Handle" := 0; NewItemChargeAssgntSales."Amount to Handle" := 0; NewItemChargeAssgntSales.Description := TempItemChargeAssgntSales.Description; NewItemChargeAssgntSales."Unit Cost" := TempItemChargeAssgntSales."Unit Cost"; NewItemChargeAssgntSales."Applies-to Doc. Type" := ApplToDocType; NewItemChargeAssgntSales."Applies-to Doc. No." := ApplToDocNo; NewItemChargeAssgntSales."Applies-to Doc. Line No." := ApplToDocLineNo; NewItemChargeAssgntSales."Applies-to Doc. Line Amount" := ApplToDocLineAmt; OnInsertAssocOrderChargeOnBeforeNewItemChargeAssgntSalesInsert(TempItemChargeAssgntSales, NewItemChargeAssgntSales); NewItemChargeAssgntSales.Insert(); end; /// <summary> /// Copies and validates item charge assignments for posting. /// </summary> /// <param name="SalesHeader">The sales header record to process item charges for.</param> procedure CopyAndCheckItemCharge(SalesHeader: Record "Sales Header") var TempSalesLine: Record "Sales Line" temporary; SalesLine: Record "Sales Line"; InvoiceEverything: Boolean; AssignError: Boolean; SkipTestJobNo: Boolean; QtyNeeded: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeCopyAndCheckItemCharge( SalesHeader, TempSalesLine, SalesLine, InvoiceEverything, AssignError, QtyNeeded, TempItemChargeAssgntSales, ItemChargeAssgntSales, TempSalesLineGlobal, IsHandled); if IsHandled then exit; TempItemChargeAssgntSales.Reset(); TempItemChargeAssgntSales.DeleteAll(); // Check for max qty posting ResetTempLines(TempSalesLine); TempSalesLine.SetRange(Type, TempSalesLine.Type::"Charge (Item)"); if TempSalesLine.IsEmpty() then exit; CopyItemChargeForSalesLine(TempItemChargeAssgntSales, TempSalesLine); TempSalesLine.SetFilter("Qty. to Invoice", '<>0'); if TempSalesLine.FindSet() then repeat SkipTestJobNo := false; OnCopyAndCheckItemChargeOnBeforeLoop(TempSalesLine, SalesHeader, SkipTestJobNo); if not SkipTestJobNo then begin TempSalesLine.TestField("Job No.", '', ErrorInfo.Create()); TempSalesLine.TestField("Job Contract Entry No.", 0, ErrorInfo.Create()); end; if (TempSalesLine."Qty. to Ship" + TempSalesLine."Return Qty. to Receive" <> 0) and ((SalesHeader.Ship or SalesHeader.Receive) or (Abs(TempSalesLine."Qty. to Invoice") > Abs(TempSalesLine."Qty. Shipped Not Invoiced" + TempSalesLine."Qty. to Ship") + Abs(TempSalesLine."Ret. Qty. Rcd. Not Invd.(Base)" + TempSalesLine."Return Qty. to Receive"))) then TempSalesLine.TestField("Line Amount", ErrorInfo.Create()); if not SalesHeader.Ship then TempSalesLine."Qty. to Ship" := 0; if not SalesHeader.Receive then TempSalesLine."Return Qty. to Receive" := 0; IsHandled := false; OnCopyAndCheckItemChargeOnBeforeAssignQtyToInvoice(TempSalesLine, IsHandled); if not IsHandled then if Abs(TempSalesLine."Qty. to Invoice") > Abs(TempSalesLine."Quantity Shipped" + TempSalesLine."Qty. to Ship" + TempSalesLine."Return Qty. Received" + TempSalesLine."Return Qty. to Receive" - TempSalesLine."Quantity Invoiced") then TempSalesLine."Qty. to Invoice" := TempSalesLine."Quantity Shipped" + TempSalesLine."Qty. to Ship" + TempSalesLine."Return Qty. Received" + TempSalesLine."Return Qty. to Receive" - TempSalesLine."Quantity Invoiced"; TempSalesLine.CalcFields("Qty. to Assign", "Qty. Assigned", "Item Charge Qty. to Handle"); if Abs(TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned") > Abs(TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") then begin AdjustQtyToAssignForSalesLine(TempSalesLine); TempSalesLine.CalcFields("Qty. to Assign", "Qty. Assigned", "Item Charge Qty. to Handle"); if Abs(TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned") > Abs(TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") then Error(CannotAssignMoreErr, TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced" - TempSalesLine."Qty. Assigned", TempSalesLine.FieldCaption("Document Type"), TempSalesLine."Document Type", TempSalesLine.FieldCaption("Document No."), TempSalesLine."Document No.", TempSalesLine.FieldCaption("Line No."), TempSalesLine."Line No."); CopyItemChargeForSalesLine(TempItemChargeAssgntSales, TempSalesLine); end; if TempSalesLine.Quantity = TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced" then begin if TempSalesLine."Item Charge Qty. to Handle" <> 0 then if TempSalesLine.Quantity = TempSalesLine."Quantity Invoiced" then begin TempItemChargeAssgntSales.SetRange("Document Line No.", TempSalesLine."Line No."); TempItemChargeAssgntSales.SetRange("Applies-to Doc. Type", TempSalesLine."Document Type"); if TempItemChargeAssgntSales.FindSet() then repeat SalesLine.Get( TempItemChargeAssgntSales."Applies-to Doc. Type", TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No."); if SalesLine.Quantity = SalesLine."Quantity Invoiced" then Error(CannotAssignInvoicedErr, SalesLine.TableCaption(), SalesLine.FieldCaption("Document Type"), SalesLine."Document Type", SalesLine.FieldCaption("Document No."), SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No."); until TempItemChargeAssgntSales.Next() = 0; end; if TempSalesLine.Quantity <> TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned" then AssignError := true; end; if (TempSalesLine."Item Charge Qty. to Handle" + TempSalesLine."Qty. Assigned") < (TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") then Error(MustAssignItemChargeErr, TempSalesLine."No."); // check if all ILEs exist QtyNeeded := TempSalesLine."Item Charge Qty. to Handle"; TempItemChargeAssgntSales.SetRange("Document Line No.", TempSalesLine."Line No."); if TempItemChargeAssgntSales.FindSet() then repeat if (TempItemChargeAssgntSales."Applies-to Doc. Type" <> TempSalesLine."Document Type") or (TempItemChargeAssgntSales."Applies-to Doc. No." <> TempSalesLine."Document No.") then QtyNeeded := QtyNeeded - TempItemChargeAssgntSales."Qty. to Handle" else begin SalesLine.Get( TempItemChargeAssgntSales."Applies-to Doc. Type", TempItemChargeAssgntSales."Applies-to Doc. No.", TempItemChargeAssgntSales."Applies-to Doc. Line No."); if ItemLedgerEntryExist(SalesLine, SalesHeader.Ship or SalesHeader.Receive) then QtyNeeded := QtyNeeded - TempItemChargeAssgntSales."Qty. to Handle"; end; until TempItemChargeAssgntSales.Next() = 0; if QtyNeeded <> 0 then Error(CannotInvoiceItemChargeErr, TempSalesLine."No."); until TempSalesLine.Next() = 0; // Check saleslines if AssignError then if SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::"Credit Memo"] then InvoiceEverything := true else begin TempSalesLine.Reset(); TempSalesLine.SetFilter(Type, '%1|%2', TempSalesLine.Type::Item, TempSalesLine.Type::"Charge (Item)"); if TempSalesLine.FindSet() then repeat if SalesHeader.Ship or SalesHeader.Receive then InvoiceEverything := TempSalesLine.Quantity = TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced" else InvoiceEverything := (TempSalesLine.Quantity = TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") and (TempSalesLine."Qty. to Invoice" = TempSalesLine."Qty. Shipped Not Invoiced" + TempSalesLine."Ret. Qty. Rcd. Not Invd.(Base)"); until (TempSalesLine.Next() = 0) or (not InvoiceEverything); end; OnCopyAndCheckItemChargeOnBeforeError(SalesHeader, TempSalesLine, InvoiceEverything); if InvoiceEverything and AssignError then Error(MustAssignErr); end; local procedure CopyItemChargeForSalesLine(var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; SalesLine: Record "Sales Line") var ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)"; begin TempItemChargeAssignmentSales.Reset(); TempItemChargeAssignmentSales.SetRange("Document Type", SalesLine."Document Type"); TempItemChargeAssignmentSales.SetRange("Document No.", SalesLine."Document No."); if not TempItemChargeAssignmentSales.IsEmpty() then TempItemChargeAssignmentSales.DeleteAll(); ItemChargeAssignmentSales.CopyFilters(TempItemChargeAssignmentSales); ItemChargeAssignmentSales.SetFilter("Qty. to Handle", '<>0'); if ItemChargeAssignmentSales.FindSet() then repeat TempItemChargeAssignmentSales.Init(); TempItemChargeAssignmentSales := ItemChargeAssignmentSales; TempItemChargeAssignmentSales.Insert(); until ItemChargeAssignmentSales.Next() = 0; end; local procedure AdjustQtyToAssignForSalesLine(var TempSalesLine: Record "Sales Line" temporary) var ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)"; Delta: Decimal; QtyToHandle: Decimal; begin TempSalesLine.CalcFields("Qty. to Assign"); ItemChargeAssignmentSales.Reset(); ItemChargeAssignmentSales.SetRange("Document Type", TempSalesLine."Document Type"); ItemChargeAssignmentSales.SetRange("Document No.", TempSalesLine."Document No."); ItemChargeAssignmentSales.SetRange("Document Line No.", TempSalesLine."Line No."); ItemChargeAssignmentSales.SetFilter("Qty. to Assign", '<>0'); if ItemChargeAssignmentSales.FindSet() then repeat QtyToHandle := ItemChargeAssignmentSales."Qty. to Handle"; ItemChargeAssignmentSales.Validate("Qty. to Assign", TempSalesLine."Qty. to Invoice" * Round(ItemChargeAssignmentSales."Qty. to Assign" / TempSalesLine."Qty. to Assign", UOMMgt.QtyRndPrecision())); if QtyToHandle = 0 then ItemChargeAssignmentSales.Validate("Qty. to Handle", 0); ItemChargeAssignmentSales.Modify(); until ItemChargeAssignmentSales.Next() = 0; TempSalesLine.CalcFields("Qty. to Assign"); Delta := TempSalesLine."Qty. to Invoice" - TempSalesLine."Qty. to Assign"; if Delta <> 0 then begin QtyToHandle := ItemChargeAssignmentSales."Qty. to Handle"; ItemChargeAssignmentSales.Validate("Qty. to Assign", ItemChargeAssignmentSales."Qty. to Assign" + Delta); if QtyToHandle = 0 then ItemChargeAssignmentSales.Validate("Qty. to Handle", 0); ItemChargeAssignmentSales.Modify(); end; end; local procedure ClearItemChargeAssgntFilter() begin TempItemChargeAssgntSales.SetRange("Document Line No."); TempItemChargeAssgntSales.SetRange("Applies-to Doc. Type"); TempItemChargeAssgntSales.SetRange("Applies-to Doc. No."); TempItemChargeAssgntSales.SetRange("Applies-to Doc. Line No."); TempItemChargeAssgntSales.MarkedOnly(false); end; local procedure GetItemChargeLine(SalesHeader: Record "Sales Header"; var ItemChargeSalesLine: Record "Sales Line") var SalesShptLine: Record "Sales Shipment Line"; ReturnReceiptLine: Record "Return Receipt Line"; QtyShippedNotInvd: Decimal; QtyReceivedNotInvd: Decimal; begin if (ItemChargeSalesLine."Document Type" <> TempItemChargeAssgntSales."Document Type") or (ItemChargeSalesLine."Document No." <> TempItemChargeAssgntSales."Document No.") or (ItemChargeSalesLine."Line No." <> TempItemChargeAssgntSales."Document Line No.") then begin ItemChargeSalesLine.Get(TempItemChargeAssgntSales."Document Type", TempItemChargeAssgntSales."Document No.", TempItemChargeAssgntSales."Document Line No."); if not SalesHeader.Ship then ItemChargeSalesLine."Qty. to Ship" := 0; if not SalesHeader.Receive then ItemChargeSalesLine."Return Qty. to Receive" := 0; if ItemChargeSalesLine."Shipment No." <> '' then begin SalesShptLine.Get(ItemChargeSalesLine."Shipment No.", ItemChargeSalesLine."Shipment Line No."); QtyShippedNotInvd := TempItemChargeAssgntSales."Qty. to Handle" - TempItemChargeAssgntSales."Qty. Assigned"; end else QtyShippedNotInvd := ItemChargeSalesLine."Quantity Shipped"; if ItemChargeSalesLine."Return Receipt No." <> '' then begin ReturnReceiptLine.Get(ItemChargeSalesLine."Return Receipt No.", ItemChargeSalesLine."Return Receipt Line No."); QtyReceivedNotInvd := TempItemChargeAssgntSales."Qty. to Handle" - TempItemChargeAssgntSales."Qty. Assigned"; end else QtyReceivedNotInvd := ItemChargeSalesLine."Return Qty. Received"; if Abs(ItemChargeSalesLine."Qty. to Invoice") > Abs(QtyShippedNotInvd + ItemChargeSalesLine."Qty. to Ship" + QtyReceivedNotInvd + ItemChargeSalesLine."Return Qty. to Receive" - ItemChargeSalesLine."Quantity Invoiced") then ItemChargeSalesLine."Qty. to Invoice" := QtyShippedNotInvd + ItemChargeSalesLine."Qty. to Ship" + QtyReceivedNotInvd + ItemChargeSalesLine."Return Qty. to Receive" - ItemChargeSalesLine."Quantity Invoiced"; end; end; local procedure CalcQtyToInvoice(QtyToHandle: Decimal; QtyToInvoice: Decimal): Decimal begin if Abs(QtyToHandle) > Abs(QtyToInvoice) then exit(-QtyToHandle); exit(-QtyToInvoice); end; local procedure CheckWarehouse(var TempItemSalesLine: Record "Sales Line" temporary) var ShowError: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckWarehouse(TempItemSalesLine, IsHandled); if IsHandled then exit; TempItemSalesLine.SetRange(Type, TempItemSalesLine.Type::Item); TempItemSalesLine.SetRange("Drop Shipment", false); if TempItemSalesLine.FindSet() then repeat if TempItemSalesLine.IsInventoriableItem() then begin GetLocation(TempItemSalesLine."Location Code"); case TempItemSalesLine."Document Type" of TempItemSalesLine."Document Type"::Order: if ((Location."Require Receive" or Location."Require Put-away") and (TempItemSalesLine.Quantity < 0)) or ((Location."Require Shipment" or Location."Require Pick") and (TempItemSalesLine.Quantity >= 0)) then ShowError := GetShowErrorOnWarehouseCheck(TempItemSalesLine, Location); TempItemSalesLine."Document Type"::"Return Order": if ((Location."Require Receive" or Location."Require Put-away") and (TempItemSalesLine.Quantity >= 0)) or ((Location."Require Shipment" or Location."Require Pick") and (TempItemSalesLine.Quantity < 0)) then ShowError := GetShowErrorOnWarehouseCheck(TempItemSalesLine, Location); TempItemSalesLine."Document Type"::Invoice, TempItemSalesLine."Document Type"::"Credit Memo": if Location."Directed Put-away and Pick" then Location.TestField("Adjustment Bin Code"); end; if ShowError then Error( WarehouseRequiredErr, TempItemSalesLine.FieldCaption("Document Type"), TempItemSalesLine."Document Type", TempItemSalesLine.FieldCaption("Document No."), TempItemSalesLine."Document No.", TempItemSalesLine.FieldCaption("Line No."), TempItemSalesLine."Line No."); end; until TempItemSalesLine.Next() = 0; end; local procedure GetShowErrorOnWarehouseCheck(var SalesLine: Record "Sales Line"; Location: Record Location) ShowError: Boolean; var WhseValidateSourceLine: Codeunit "Whse. Validate Source Line"; begin if Location."Directed Put-away and Pick" then ShowError := true else if WhseValidateSourceLine.WhseLinesExist( DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", 0, SalesLine.Quantity) then begin ShowError := true; OnAfterWhseLinesExist(WhseValidateSourceLine, SalesLine, ShowError); end; end; /// <summary> /// Creates a Warehouse Journal Line for the specified sales line. /// </summary> /// <remarks> /// Error can be raised if the Adjustment Bin of the Location has Movement Block. /// </remarks> /// <param name="ItemJnlLine">The Item Journal Line to create the Warehouse Journal Line for.</param> /// <param name="SalesLine">The sales line to create the Warehouse Journal Line for.</param> /// <param name="TempWhseJnlLine">Return Variable: The created Warehouse Journal Line.</param> procedure CreateWhseJnlLine(ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary) var WhseMgt: Codeunit "Whse. Management"; WMSMgt: Codeunit "WMS Management"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCreateWhseJnlLine(ItemJnlLine, IsHandled); if IsHandled then exit; WMSMgt.CheckAdjmtBin(Location, ItemJnlLine.Quantity, true); WMSMgt.CreateWhseJnlLine(ItemJnlLine, 0, TempWhseJnlLine, false); TempWhseJnlLine."Source Type" := DATABASE::"Sales Line"; TempWhseJnlLine."Source Subtype" := SalesLine."Document Type".AsInteger(); TempWhseJnlLine."Source Code" := SrcCode; TempWhseJnlLine."Source Document" := WhseMgt.GetWhseJnlSourceDocument(TempWhseJnlLine."Source Type", TempWhseJnlLine."Source Subtype"); TempWhseJnlLine."Source No." := SalesLine."Document No."; TempWhseJnlLine."Source Line No." := SalesLine."Line No."; case SalesLine."Document Type" of SalesLine."Document Type"::Order: TempWhseJnlLine."Reference Document" := TempWhseJnlLine."Reference Document"::"Posted Shipment"; SalesLine."Document Type"::Invoice: TempWhseJnlLine."Reference Document" := TempWhseJnlLine."Reference Document"::"Posted S. Inv."; SalesLine."Document Type"::"Credit Memo": TempWhseJnlLine."Reference Document" := TempWhseJnlLine."Reference Document"::"Posted S. Cr. Memo"; SalesLine."Document Type"::"Return Order": TempWhseJnlLine."Reference Document" := TempWhseJnlLine."Reference Document"::"Posted Rtrn. Rcpt."; end; TempWhseJnlLine."Reference No." := ItemJnlLine."Document No."; OnAfterCreateWhseJnlLine(SalesLine, TempWhseJnlLine); end; /// <summary> /// Checks if warehouse handling (warehouse shipment or receipt) is required for the specified sales line. /// Warehouse handling is relevant for sales lines for inventoriable item. Warehouse setup or location (if specified) determines if Warehouse Handling is required. /// Drop shipments do not require Warehouse Handling. /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <returns>Returns true if Warehouse Handling is required, otherwise false.</returns> procedure WhseHandlingRequiredExternal(SalesLine: Record "Sales Line"): Boolean begin exit(WhseHandlingRequired(SalesLine)); end; local procedure WhseHandlingRequired(SalesLine: Record "Sales Line") Required: Boolean var WhseSetup: Record "Warehouse Setup"; IsHandled: Boolean; begin IsHandled := false; OnBeforeWhseHandlingRequired(SalesLine, Required, IsHandled); if IsHandled then exit(Required); if SalesLine.IsInventoriableItem() and (not SalesLine."Drop Shipment") then begin if SalesLine."Location Code" = '' then begin WhseSetup.Get(); if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then exit(WhseSetup."Require Receive"); exit(WhseSetup."Require Shipment"); end; GetLocation(SalesLine."Location Code"); if SalesLine."Document Type" = SalesLine."Document Type"::"Return Order" then exit(Location."Require Receive"); exit(Location."Require Shipment"); end; exit(false); end; local procedure GetLocation(LocationCode: Code[10]) begin if LocationCode = '' then Location.GetLocationSetup(LocationCode, Location) else if Location.Code <> LocationCode then Location.Get(LocationCode); end; local procedure InsertShptEntryRelation(SalesHeader: Record "Sales Header"; var SalesShptLine: Record "Sales Shipment Line") ItemShptEntryNo: Integer var ItemEntryRelation: Record "Item Entry Relation"; IsHandled: Boolean; begin IsHandled := false; OnBeforeInsertShptEntryRelation(SalesHeader, SalesShptLine, ItemShptEntryNo, IsHandled); if IsHandled then exit(ItemShptEntryNo); TempHandlingSpecification.CopySpecification(TempTrackingSpecificationInv); TempHandlingSpecification.CopySpecification(TempATOTrackingSpecification); TempHandlingSpecification.Reset(); if TempHandlingSpecification.FindSet() then begin repeat ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification); ItemEntryRelation.TransferFieldsSalesShptLine(SalesShptLine); ItemEntryRelation.Insert(); OnInsertShptEntryRelationOnAfterItemEntryRelationInsert(SalesShptLine, ItemEntryRelation, xSalesLine); until TempHandlingSpecification.Next() = 0; OnInsertShptEntryRelationOnBeforeDeleteTempHandlingSpecification(TempHandlingSpecification); TempHandlingSpecification.DeleteAll(); exit(0); end; exit(ItemLedgShptEntryNo); end; local procedure InsertReturnEntryRelation(var ReturnRcptLine: Record "Return Receipt Line") EntryNo: Integer var ItemEntryRelation: Record "Item Entry Relation"; IsHandled: Boolean; begin IsHandled := false; OnBeforeInsertReturnEntryRelation(ReturnRcptLine, EntryNo, IsHandled); if IsHandled then exit; TempHandlingSpecification.CopySpecification(TempTrackingSpecificationInv); TempHandlingSpecification.CopySpecification(TempATOTrackingSpecification); TempHandlingSpecification.Reset(); if TempHandlingSpecification.FindSet() then begin repeat ItemEntryRelation.InitFromTrackingSpec(TempHandlingSpecification); ItemEntryRelation.TransferFieldsReturnRcptLine(ReturnRcptLine); ItemEntryRelation.Insert(); until TempHandlingSpecification.Next() = 0; TempHandlingSpecification.DeleteAll(); exit(0); end; exit(ItemLedgShptEntryNo); end; /// <summary> /// Checks if the sales line is posted with Item Tracking, then tracked quantity must be equal to posted quantity. /// </summary> /// <param name="SalesHeader">The sales header of the document. Only Orders and Return Orders are relevant.</param> /// <param name="TempItemSalesLine">Temp sales lines to Check.</param> procedure CheckTrackingSpecification(SalesHeader: Record "Sales Header"; var TempItemSalesLine: Record "Sales Line" temporary) var ReservationEntry: Record "Reservation Entry"; ItemTrackingCode: Record "Item Tracking Code"; ItemTrackingSetup: Record "Item Tracking Setup"; ItemJnlLine: Record "Item Journal Line"; CreateReservEntry: Codeunit "Create Reserv. Entry"; ItemTrackingManagement: Codeunit "Item Tracking Management"; ErrorFieldCaption: Text; SignFactor: Integer; SalesLineQtyToHandle: Decimal; TrackingQtyToHandle: Decimal; Inbound: Boolean; CheckSalesLine: Boolean; IsHandled: Boolean; begin OnBeforeCheckTrackingSpecification(SalesHeader, TempItemSalesLine); // if a SalesLine is posted with ItemTracking then tracked quantity must be equal to posted quantity if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) then exit; TrackingQtyToHandle := 0; TempItemSalesLine.SetRange(Type, TempItemSalesLine.Type::Item); if SalesHeader.Ship then begin TempItemSalesLine.SetFilter("Quantity Shipped", '<>%1', 0); ErrorFieldCaption := TempItemSalesLine.FieldCaption("Qty. to Ship"); end else begin TempItemSalesLine.SetFilter("Return Qty. Received", '<>%1', 0); ErrorFieldCaption := TempItemSalesLine.FieldCaption("Return Qty. to Receive"); end; if TempItemSalesLine.FindSet() then begin ReservationEntry."Source Type" := DATABASE::"Sales Line"; ReservationEntry."Source Subtype" := SalesHeader."Document Type".AsInteger(); SignFactor := CreateReservEntry.SignFactor(ReservationEntry); repeat // Only Item where no SerialNo or LotNo is required TempItemSalesLine.GetItem(Item); if Item."Item Tracking Code" <> '' then begin Inbound := (TempItemSalesLine.Quantity * SignFactor) > 0; ItemTrackingCode.Code := Item."Item Tracking Code"; IsHandled := false; OnCheckTrackingSpecificationOnBeforeGetItemTrackingSettings(TempItemSalesLine, ItemTrackingSetup, IsHandled); if not IsHandled then ItemTrackingManagement.GetItemTrackingSetup( ItemTrackingCode, ItemJnlLine."Entry Type"::Sale, Inbound, ItemTrackingSetup); CheckSalesLine := not ItemTrackingSetup.TrackingRequired(); if CheckSalesLine then CheckSalesLine := CheckTrackingExists(TempItemSalesLine); end else CheckSalesLine := false; TrackingQtyToHandle := 0; if CheckSalesLine then begin TrackingQtyToHandle := GetTrackingQuantities(TempItemSalesLine) * SignFactor; if SalesHeader.Ship then SalesLineQtyToHandle := TempItemSalesLine."Qty. to Ship (Base)" else SalesLineQtyToHandle := TempItemSalesLine."Return Qty. to Receive (Base)"; if TrackingQtyToHandle <> SalesLineQtyToHandle then Error(ItemTrackQuantityMismatchErr, ErrorFieldCaption, TempItemSalesLine."No."); end; OnCheckTrackingSpecificationOnAfterTempItemSalesLineLoop(TempItemSalesLine); until TempItemSalesLine.Next() = 0; end; if SalesHeader.Ship then TempItemSalesLine.SetRange("Quantity Shipped") else TempItemSalesLine.SetRange("Return Qty. Received"); end; local procedure CheckTrackingExists(SalesLine: Record "Sales Line"): Boolean begin exit( ItemTrackingMgt.ItemTrackingExistsOnDocumentLine( DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.")); end; local procedure GetTrackingQuantities(SalesLine: Record "Sales Line"): Decimal begin exit( ItemTrackingMgt.CalcQtyToHandleForTrackedQtyOnDocumentLine( DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.")); end; local procedure SaveInvoiceSpecification(var TempInvoicingSpecification: Record "Tracking Specification" temporary) begin TempInvoicingSpecification.Reset(); if TempInvoicingSpecification.FindSet() then begin repeat TempInvoicingSpecification."Quantity Invoiced (Base)" += TempInvoicingSpecification."Quantity actual Handled (Base)"; TempInvoicingSpecification."Quantity actual Handled (Base)" := 0; OnSaveInvoiceSpecificationOnBeforeAssignTempInvoicingSpecification(TempInvoicingSpecification); TempTrackingSpecification := TempInvoicingSpecification; TempTrackingSpecification."Buffer Status" := TempTrackingSpecification."Buffer Status"::MODIFY; if not TempTrackingSpecification.Insert() then begin TempTrackingSpecification.Get(TempInvoicingSpecification."Entry No."); TempTrackingSpecification."Qty. to Invoice (Base)" += TempInvoicingSpecification."Qty. to Invoice (Base)"; TempTrackingSpecification."Quantity Invoiced (Base)" += TempInvoicingSpecification."Qty. to Invoice (Base)"; TempTrackingSpecification."Qty. to Invoice" += TempInvoicingSpecification."Qty. to Invoice"; TempTrackingSpecification.Modify(); end; OnSaveInvoiceSpecificationOnAfterUpdateTempTrackingSpecification(TempTrackingSpecification, TempInvoicingSpecification); until TempInvoicingSpecification.Next() = 0; TempInvoicingSpecification.DeleteAll(); end; end; local procedure InsertTrackingSpecification(SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeInsertTrackingSpecification(SalesHeader, TempTrackingSpecification, IsHandled); if IsHandled then exit; TempTrackingSpecification.Reset(); if not TempTrackingSpecification.IsEmpty() then begin TempTrackingSpecification.InsertSpecification(); SalesLineReserve.UpdateItemTrackingAfterPosting(SalesHeader); end; end; /// <summary> /// Stores Value Entry Relations from a global temp table TempValueEntryRelation to the Value Entry Relation table. /// The global temp table is then cleared. /// </summary> procedure InsertValueEntryRelation() var ValueEntryRelation: Record "Value Entry Relation"; begin TempValueEntryRelation.Reset(); if TempValueEntryRelation.FindSet() then begin repeat ValueEntryRelation := TempValueEntryRelation; ValueEntryRelation.Insert(); until TempValueEntryRelation.Next() = 0; TempValueEntryRelation.DeleteAll(); end; end; /// <summary> /// Posts an item charge to the specified item ledger entry. /// </summary> /// <param name="SalesHeader">The sales header record.</param> /// <param name="SalesLine">The sales line with the item charge.</param> /// <param name="ItemLedgEntryNo">The item ledger entry number to apply the charge to.</param> /// <param name="QuantityBase">The quantity in base unit of measure.</param> /// <param name="AmountToAssign">The amount to assign.</param> /// <param name="QtyToAssign">The quantity to assign.</param> procedure PostItemCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; ItemLedgEntryNo: Integer; QuantityBase: Decimal; AmountToAssign: Decimal; QtyToAssign: Decimal) var DummyTrackingSpecification: Record "Tracking Specification"; SalesLineToPost: Record "Sales Line"; begin OnBeforePostItemCharge(SalesHeader, SalesLine, TempItemChargeAssgntSales, ItemLedgEntryNo); SalesLineToPost := SalesLine; SalesLineToPost."No." := TempItemChargeAssgntSales."Item No."; SalesLineToPost."Appl.-to Item Entry" := ItemLedgEntryNo; if not (TempItemChargeAssgntSales."Document Type" in [TempItemChargeAssgntSales."Document Type"::"Return Order", TempItemChargeAssgntSales."Document Type"::"Credit Memo"]) then SalesLineToPost.Amount := -AmountToAssign else SalesLineToPost.Amount := AmountToAssign; if SalesLineToPost."Currency Code" <> '' then SalesLineToPost."Unit Cost" := Round( SalesLineToPost.Amount / QuantityBase, Currency."Unit-Amount Rounding Precision") else SalesLineToPost."Unit Cost" := Round( SalesLineToPost.Amount / QuantityBase, GLSetup."Unit-Amount Rounding Precision"); TotalChargeAmt := TotalChargeAmt + SalesLineToPost.Amount; OnPostItemChargeOnAfterCalcTotalChargeAmt(SalesLineToPost, QtyToAssign, SalesLine, xSalesLine); if SalesHeader."Currency Code" <> '' then SalesLineToPost.Amount := CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader.GetUseDate(), SalesHeader."Currency Code", TotalChargeAmt, SalesHeader."Currency Factor"); SalesLineToPost."Inv. Discount Amount" := Round( SalesLine."Inv. Discount Amount" / SalesLine.Quantity * QtyToAssign, GLSetup."Amount Rounding Precision"); SalesLineToPost."Line Discount Amount" := Round( SalesLine."Line Discount Amount" / SalesLine.Quantity * QtyToAssign, GLSetup."Amount Rounding Precision"); SalesLineToPost."Line Amount" := Round( SalesLine."Line Amount" / SalesLine.Quantity * QtyToAssign, GLSetup."Amount Rounding Precision"); SalesLine."Inv. Discount Amount" := SalesLine."Inv. Discount Amount" - SalesLineToPost."Inv. Discount Amount"; SalesLine."Line Discount Amount" := SalesLine."Line Discount Amount" - SalesLineToPost."Line Discount Amount"; SalesLine."Line Amount" := SalesLine."Line Amount" - SalesLineToPost."Line Amount"; SalesLine.Quantity := SalesLine.Quantity - QtyToAssign; SalesLineToPost.Amount := Round(SalesLineToPost.Amount, GLSetup."Amount Rounding Precision") - TotalChargeAmtLCY; if SalesHeader."Currency Code" <> '' then TotalChargeAmtLCY := TotalChargeAmtLCY + SalesLineToPost.Amount; SalesLineToPost."Unit Cost (LCY)" := Round( SalesLineToPost.Amount / QuantityBase, GLSetup."Unit-Amount Rounding Precision"); UpdateSalesLineDimSetIDFromAppliedEntry(SalesLineToPost, SalesLine); SalesLineToPost."Line No." := TempItemChargeAssgntSales."Document Line No."; OnPostItemChargeOnBeforePostItemJnlLine(SalesLineToPost, SalesLine, QtyToAssign, TempItemChargeAssgntSales); PostItemJnlLine( SalesHeader, SalesLineToPost, 0, 0, -QuantityBase, -QuantityBase, SalesLineToPost."Appl.-to Item Entry", TempItemChargeAssgntSales."Item Charge No.", DummyTrackingSpecification, false); OnPostItemChargeOnAfterPostItemJnlLine(SalesHeader, SalesLineToPost); OnAfterPostItemCharge(SalesHeader, SalesLine, TempItemChargeAssgntSales, ItemLedgEntryNo); end; local procedure SaveTempWhseSplitSpec(var SalesLine3: Record "Sales Line"; var TempSrcTrackingSpec: Record "Tracking Specification" temporary) begin TempWhseSplitSpecification.Reset(); TempWhseSplitSpecification.DeleteAll(); if TempSrcTrackingSpec.FindSet() then repeat TempWhseSplitSpecification := TempSrcTrackingSpec; TempWhseSplitSpecification.SetSource( DATABASE::"Sales Line", SalesLine3."Document Type".AsInteger(), SalesLine3."Document No.", SalesLine3."Line No.", '', 0); TempWhseSplitSpecification.Insert(); until TempSrcTrackingSpec.Next() = 0; end; /// <summary> /// Transfers reservation entries from a sales line to an item journal line. /// </summary> /// <param name="SalesOrderLine">The sales order line with reservations.</param> /// <param name="ItemJnlLine">The item journal line to transfer reservations to.</param> /// <param name="QtyToBeShippedBase">The base quantity to be shipped.</param> /// <param name="TempTrackingSpecification2">Temporary tracking specifications.</param> /// <param name="CheckApplFromItemEntry">Returns whether to check application from item entry.</param> procedure TransferReservToItemJnlLine(var SalesOrderLine: Record "Sales Line"; var ItemJnlLine: Record "Item Journal Line"; QtyToBeShippedBase: Decimal; var TempTrackingSpecification2: Record "Tracking Specification" temporary; var CheckApplFromItemEntry: Boolean) var RemainingQuantity: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeTransferReservToItemJnlLine(SalesOrderLine, QtyToBeShippedBase, IsHandled); if IsHandled then exit; // Handle Item Tracking and reservations, also on drop shipment if QtyToBeShippedBase = 0 then exit; Clear(SalesLineReserve); if not SalesOrderLine."Drop Shipment" then SalesLineReserve.TransferSalesLineToItemJnlLine( SalesOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false) else begin SalesLineReserve.SetApplySpecificItemTracking(true); TempTrackingSpecification2.Reset(); TempTrackingSpecification2.SetSourceFilter( DATABASE::"Purchase Line", 1, SalesOrderLine."Purchase Order No.", SalesOrderLine."Purch. Order Line No.", false); TempTrackingSpecification2.SetSourceFilter('', 0); if TempTrackingSpecification2.IsEmpty() then SalesLineReserve.TransferSalesLineToItemJnlLine( SalesOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplFromItemEntry, false) else begin SalesLineReserve.SetOverruleItemTracking(true); SalesLineReserve.SetItemTrkgAlreadyOverruled(ItemTrkgAlreadyOverruled); TempTrackingSpecification2.FindSet(); if TempTrackingSpecification2."Quantity (Base)" / QtyToBeShippedBase < 0 then Error(ItemTrackingWrongSignErr); repeat ItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecification2); ItemJnlLine."Applies-to Entry" := TempTrackingSpecification2."Item Ledger Entry No."; RemainingQuantity := SalesLineReserve.TransferSalesLineToItemJnlLine( SalesOrderLine, ItemJnlLine, TempTrackingSpecification2."Quantity (Base)", CheckApplFromItemEntry, false); if RemainingQuantity <> 0 then Error(ItemTrackingMismatchErr); until TempTrackingSpecification2.Next() = 0; ItemJnlLine.ClearTracking(); ItemJnlLine."Applies-to Entry" := 0; end; end; end; /// <summary> /// Transfers reservation entries from a purchase line to an item journal line for drop shipments. /// </summary> /// <param name="PurchOrderLine">The purchase order line with reservations.</param> /// <param name="ItemJnlLine">The item journal line to transfer reservations to.</param> /// <param name="SalesLine">The related sales line.</param> /// <param name="QtyToBeShippedBase">The base quantity to be shipped.</param> procedure TransferReservFromPurchLine(var PurchOrderLine: Record "Purchase Line"; var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShippedBase: Decimal) var ReservEntry: Record "Reservation Entry"; TempTrackingSpecification2: Record "Tracking Specification" temporary; PurchLineReserve: Codeunit "Purch. Line-Reserve"; RemainingQuantity: Decimal; CheckApplToItemEntry: Boolean; begin // Handle Item Tracking on Drop Shipment ItemTrkgAlreadyOverruled := false; if QtyToBeShippedBase = 0 then exit; ReservEntry.SetSourceFilter( DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.", true); ReservEntry.SetSourceFilter('', 0); ReservEntry.SetFilter("Qty. to Handle (Base)", '<>0'); if not ReservEntry.IsEmpty() then ItemTrackingMgt.SumUpItemTracking(ReservEntry, TempTrackingSpecification2, false, true); TempTrackingSpecification2.SetFilter("Qty. to Handle (Base)", '<>0'); if TempTrackingSpecification2.IsEmpty() then begin SalesLineReserve.SetApplySpecificItemTracking(true); PurchLineReserve.TransferPurchLineToItemJnlLine( PurchOrderLine, ItemJnlLine, QtyToBeShippedBase, CheckApplToItemEntry) end else begin PurchLineReserve.SetOverruleItemTracking(true); ItemTrkgAlreadyOverruled := true; TempTrackingSpecification2.FindSet(); if -TempTrackingSpecification2."Quantity (Base)" / QtyToBeShippedBase < 0 then Error(ItemTrackingWrongSignErr); if PurchOrderLine.ReservEntryExist() then repeat ItemJnlLine.CopyTrackingFromSpec(TempTrackingSpecification2); RemainingQuantity := PurchLineReserve.TransferPurchLineToItemJnlLine( PurchOrderLine, ItemJnlLine, -TempTrackingSpecification2."Qty. to Handle (Base)", CheckApplToItemEntry); if RemainingQuantity <> 0 then Error(ItemTrackingMismatchErr); until TempTrackingSpecification2.Next() = 0; ItemJnlLine.ClearTracking(); ItemJnlLine."Applies-to Entry" := 0; end; end; /// <summary> /// Sets the incoming Warehouse Receipt Header record to the global variable and inserts it to the global Temp table for Warehouse Receipt Header. /// </summary> /// <param name="WhseRcptHeader2"></param> procedure SetWhseRcptHeader(var WhseRcptHeader2: Record "Warehouse Receipt Header") begin WhseRcptHeader := WhseRcptHeader2; TempWhseRcptHeader := WhseRcptHeader; TempWhseRcptHeader.Insert(); end; /// <summary> /// Sets the incoming Warehouse Shipment Header record to the global variable and inserts it to the global Temp table for Warehouse Shipment Header. /// </summary> /// <param name="WhseShptHeader2"></param> procedure SetWhseShptHeader(var WhseShptHeader2: Record "Warehouse Shipment Header") begin WhseShptHeader := WhseShptHeader2; TempWhseShptHeader := WhseShptHeader; TempWhseShptHeader.Insert(); end; /// <summary> /// Creates Prepayment lines for the specified sales header and adds them to the global sales line temp table. /// </summary> /// <remarks> /// If CompleteFunctionality is true, then the following is additionally done: /// - Prepayment Amount to deduct is tested using information from Sales Shipment Lines. /// - Validates Qty. to Invoice with Qty. Shipped Not Invoiced if the Qty. to Invoice is larger than shipped Qty. /// - Checks that Prepayment Amount to deduct is not greater than the remaining amount to invoice for each line /// - Prepayment Line Type is Validated (otherwise it's only assigned). /// If "Compress Prepayments" is enabled for the sales header, only one prepayment line is created. /// </remarks> /// <param name="SalesHeader">The sales header to create the prepayment lines for.</param> /// <param name="CompleteFunctionality">Specifies if the complete functionality of the procedure should be used.</param> procedure CreatePrepaymentLines(SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean) var GLAcc: Record "G/L Account"; TempSalesLine: Record "Sales Line" temporary; TempExtTextLine: Record "Extended Text Line" temporary; GenPostingSetup: Record "General Posting Setup"; TempPrepmtSalesLine: Record "Sales Line" temporary; TransferExtText: Codeunit "Transfer Extended Text"; NextLineNo: Integer; Fraction: Decimal; VATDifference: Decimal; TempLineFound: Boolean; PrepmtAmtToDeduct: Decimal; IsHandled: Boolean; ShouldValidateQtyToInvoice: Boolean; ShouldTestGetShipmentPPmtAmtToDeduct: Boolean; begin IsHandled := false; OnBeforeCreatePrepaymentLines(SalesHeader, TempPrepmtSalesLine, CompleteFunctionality, IsHandled, TempSalesLineGlobal); if IsHandled then exit; GetGLSetup(); FillTempLines(SalesHeader, TempSalesLineGlobal); ResetTempLines(TempSalesLine); if not TempSalesLine.FindLast() then exit; NextLineNo := TempSalesLine."Line No." + 10000; TempSalesLine.SetFilter(Quantity, '>0'); TempSalesLine.SetFilter("Qty. to Invoice", '>0'); OnCreatePrepaymentLinesOnAfterTempSalesLineSetFilters(TempSalesLine, SalesHeader, TempPrepmtSalesLine, NextLineNo); TempPrepmtSalesLine.SetHasBeenShown(); // Get all sales lines if TempSalesLine.FindSet() then begin ShouldTestGetShipmentPPmtAmtToDeduct := CompleteFunctionality and (TempSalesLine."Document Type" = TempSalesLine."Document Type"::Invoice); OnCreatePrepaymentLinesOnBeforeShouldTestGetShipmentPPmtAmtToDeduct(SalesHeader, CompleteFunctionality, ShouldTestGetShipmentPPmtAmtToDeduct); if ShouldTestGetShipmentPPmtAmtToDeduct then TestGetShipmentPPmtAmtToDeduct(); repeat if CompleteFunctionality then begin ShouldValidateQtyToInvoice := SalesHeader."Document Type" <> SalesHeader."Document Type"::Invoice; OnCreatePrepaymentLinesOnBeforeValidateQtyToInvoice(SalesHeader, ShouldValidateQtyToInvoice, TempSalesLine); if ShouldValidateQtyToInvoice then begin if not SalesHeader.Ship and (TempSalesLine."Qty. to Invoice" = TempSalesLine.Quantity - TempSalesLine."Quantity Invoiced") then if TempSalesLine."Qty. Shipped Not Invoiced" < TempSalesLine."Qty. to Invoice" then TempSalesLine.Validate("Qty. to Invoice", TempSalesLine."Qty. Shipped Not Invoiced"); Fraction := (TempSalesLine."Qty. to Invoice" + TempSalesLine."Quantity Invoiced") / TempSalesLine.Quantity; CheckPrepmtAmtToDeduct(SalesHeader, TempSalesLine, Fraction); end; end; if TempSalesLine."Prepmt Amt to Deduct" <> 0 then begin if (TempSalesLine."Gen. Bus. Posting Group" <> GenPostingSetup."Gen. Bus. Posting Group") or (TempSalesLine."Gen. Prod. Posting Group" <> GenPostingSetup."Gen. Prod. Posting Group") then GetGeneralPostingSetup(GenPostingSetup, TempSalesLine); IsHandled := false; OnCreatePrepaymentLinesOnBeforeGetSalesPrepmtAccount(GLAcc, TempSalesLine, SalesHeader, GenPostingSetup, CompleteFunctionality, IsHandled); if not IsHandled then GLAcc.Get(GenPostingSetup.GetSalesPrepmtAccount()); OnCreatePrepaymentLinesOnAfterGetSalesPrepmtAccount(GLAcc, TempSalesLine, SalesHeader, CompleteFunctionality); TempLineFound := false; if SalesHeader."Compress Prepayment" then begin TempPrepmtSalesLine.SetRange("No.", GLAcc."No."); TempPrepmtSalesLine.SetRange("Dimension Set ID", TempSalesLine."Dimension Set ID"); OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineSetFilters(TempPrepmtSalesLine, TempSalesLine); TempLineFound := TempPrepmtSalesLine.FindFirst(); end; if TempLineFound then begin PrepmtAmtToDeduct := TempPrepmtSalesLine."Prepmt Amt to Deduct" + InsertedPrepmtVATBaseToDeduct( SalesHeader, TempSalesLine, TempPrepmtSalesLine."Line No.", TempPrepmtSalesLine."Unit Price"); VATDifference := TempPrepmtSalesLine."VAT Difference"; TempPrepmtSalesLine.Validate( "Unit Price", TempPrepmtSalesLine."Unit Price" + TempSalesLine."Prepmt Amt to Deduct"); TempPrepmtSalesLine.Validate("VAT Difference", VATDifference - TempSalesLine."Prepmt VAT Diff. to Deduct"); TempPrepmtSalesLine."Prepmt Amt to Deduct" := PrepmtAmtToDeduct; if TempSalesLine."Prepayment %" < TempPrepmtSalesLine."Prepayment %" then TempPrepmtSalesLine."Prepayment %" := TempSalesLine."Prepayment %"; OnBeforeTempPrepmtSalesLineModify(TempPrepmtSalesLine, TempSalesLine, SalesHeader, CompleteFunctionality); TempPrepmtSalesLine.Modify(); OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineModify(TempPrepmtSalesLine, TempSalesLine, SalesHeader); end else begin TempPrepmtSalesLine.Init(); TempPrepmtSalesLine."Document Type" := SalesHeader."Document Type"; TempPrepmtSalesLine."Document No." := SalesHeader."No."; TempPrepmtSalesLine."Line No." := 0; TempPrepmtSalesLine."System-Created Entry" := true; OnCreatePrepaymentLinesOnBeforeValidateType(TempPrepmtSalesLine, SalesHeader, TempSalesLine); if CompleteFunctionality then TempPrepmtSalesLine.Validate(Type, TempPrepmtSalesLine.Type::"G/L Account") else TempPrepmtSalesLine.Type := TempPrepmtSalesLine.Type::"G/L Account"; // deduct from prepayment TempPrepmtSalesLine.Validate("No.", GLAcc."No."); TempPrepmtSalesLine.Validate(Quantity, -1); TempPrepmtSalesLine."Qty. to Ship" := TempPrepmtSalesLine.Quantity; TempPrepmtSalesLine."Qty. to Invoice" := TempPrepmtSalesLine.Quantity; OnCreatePrepaymentLinesOnBeforeInsertedPrepmtVATBaseToDeduct(TempPrepmtSalesLine, SalesHeader, TempSalesLine); PrepmtAmtToDeduct := InsertedPrepmtVATBaseToDeduct(SalesHeader, TempSalesLine, NextLineNo, 0); TempPrepmtSalesLine.Validate("Unit Price", TempSalesLine."Prepmt Amt to Deduct"); TempPrepmtSalesLine.Validate("VAT Difference", -TempSalesLine."Prepmt VAT Diff. to Deduct"); TempPrepmtSalesLine."Prepmt Amt to Deduct" := PrepmtAmtToDeduct; TempPrepmtSalesLine."Prepayment %" := TempSalesLine."Prepayment %"; TempPrepmtSalesLine."Prepayment Line" := true; TempPrepmtSalesLine."Shortcut Dimension 1 Code" := TempSalesLine."Shortcut Dimension 1 Code"; TempPrepmtSalesLine."Shortcut Dimension 2 Code" := TempSalesLine."Shortcut Dimension 2 Code"; TempPrepmtSalesLine."Gen. Bus. Posting Group" := TempSalesLine."Gen. Bus. Posting Group"; TempPrepmtSalesLine."Gen. Prod. Posting Group" := TempSalesLine."Gen. Prod. Posting Group"; TempPrepmtSalesLine."Dimension Set ID" := TempSalesLine."Dimension Set ID"; TempPrepmtSalesLine."Line No." := NextLineNo; NextLineNo := NextLineNo + 10000; OnBeforeTempPrepmtSalesLineInsert(TempPrepmtSalesLine, TempSalesLine, SalesHeader, CompleteFunctionality); TempPrepmtSalesLine.Insert(); OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineInsert(TempPrepmtSalesLine, TempSalesLine, SalesHeader); IsHandled := false; OnBeforeCreatePrepaymentTextLines(TempPrepmtSalesLine, TempSalesLine, SalesHeader, CompleteFunctionality, IsHandled); if not IsHandled then TransferExtText.PrepmtGetAnyExtText( TempPrepmtSalesLine."No.", DATABASE::"Sales Invoice Line", SalesHeader."Document Date", SalesHeader."Language Code", TempExtTextLine); if TempExtTextLine.Find('-') then repeat TempPrepmtSalesLine.Init(); TempPrepmtSalesLine.Description := TempExtTextLine.Text; TempPrepmtSalesLine."System-Created Entry" := true; TempPrepmtSalesLine."Prepayment Line" := true; TempPrepmtSalesLine."Line No." := NextLineNo; NextLineNo := NextLineNo + 10000; OnCreatePrepaymentLinesOnBeforeInsertTempLineForExtText(TempPrepmtSalesLine, TempSalesLine, TempExtTextLine, SalesHeader); TempPrepmtSalesLine.Insert(); until TempExtTextLine.Next() = 0; end; end; until TempSalesLine.Next() = 0; OnCreatePrepaymentLinesOnAfterProcessSalesLines(SalesHeader, TempPrepmtSalesLine, NextLineNo); end; DividePrepmtAmountLCY(TempPrepmtSalesLine, SalesHeader); if TempPrepmtSalesLine.FindSet() then repeat TempSalesLineGlobal := TempPrepmtSalesLine; TempSalesLineGlobal.Insert(); until TempPrepmtSalesLine.Next() = 0; end; /// <summary> /// Checks that the Prepayment amount to deduct of the sales line is within limits /// </summary> /// <remarks> /// First condition checks that the Prepayment amount to deduct is not greater than the amount being posted. /// Second condition checks that the remaining Prepayment amount to deduct is not greater than the remaining amount to invoice. /// </remarks> /// <param name="SalesHeader">The sales header of the document being posted.</param> /// <param name="TempSalesLine">The sales line to check.</param> /// <param name="Fraction">The fraction of the sales line to be invoiced.</param> procedure CheckPrepmtAmtToDeduct(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; Fraction: Decimal) var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckPrepmtAmtToDeduct(TempSalesLine, SalesHeader, IsHandled, Fraction); if IsHandled then exit; if TempSalesLine."Prepayment %" <> 100 then case true of (TempSalesLine."Prepmt Amt to Deduct" <> 0) and (TempSalesLine."Prepmt Amt to Deduct" > Round(Fraction * TempSalesLine."Line Amount", Currency."Amount Rounding Precision")): TempSalesLine.FieldError( TempSalesLine."Prepmt Amt to Deduct", StrSubstNo(CannotBeGreaterThanErr, Round(Fraction * TempSalesLine."Line Amount", Currency."Amount Rounding Precision"))); (TempSalesLine."Prepmt. Amt. Inv." <> 0) and (Round((1 - Fraction) * TempSalesLine."Line Amount", Currency."Amount Rounding Precision") < Round( Round( Round(TempSalesLine."Unit Price" * (TempSalesLine.Quantity - TempSalesLine."Quantity Invoiced" - TempSalesLine."Qty. to Invoice"), Currency."Amount Rounding Precision") * (1 - (TempSalesLine."Line Discount %" / 100)), Currency."Amount Rounding Precision") * TempSalesLine."Prepayment %" / 100, Currency."Amount Rounding Precision")): TempSalesLine.FieldError( TempSalesLine."Prepmt Amt to Deduct", StrSubstNo(CannotBeSmallerThanErr, Round( TempSalesLine."Prepmt. Amt. Inv." - TempSalesLine."Prepmt Amt Deducted" - (1 - Fraction) * TempSalesLine."Line Amount", Currency."Amount Rounding Precision"))); end; end; /// <summary> /// Calculates the prepayment VAT Base amount to deduct and inserts a prepayment line for it in a global temp table TempPrepmtDeductLCYSalesLine. /// </summary> /// <param name="SalesHeader">The sales header of the document being posted.</param> /// <param name="SalesLine">The sales line of the document for which the prepayment VAT Base amount is being calculated.</param> /// <param name="PrepmtLineNo">The Line No. of the prepayment line to which this VAT Base Prepayment line is attached to.</param> /// <param name="TotalPrepmtAmtToDeduct">The running total of the prepayment amount to deduct. Used when compressing prepayments to a single line.</param> /// <returns>Prepayment VAT Base amount to deduct</returns> procedure InsertedPrepmtVATBaseToDeduct(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; PrepmtLineNo: Integer; TotalPrepmtAmtToDeduct: Decimal): Decimal var PrepmtVATBaseToDeduct: Decimal; begin if SalesHeader."Prices Including VAT" then PrepmtVATBaseToDeduct := Round( (TotalPrepmtAmtToDeduct + SalesLine."Prepmt Amt to Deduct") / (1 + SalesLine.GetPrepaymentVATPct() / 100), Currency."Amount Rounding Precision") - Round( TotalPrepmtAmtToDeduct / (1 + SalesLine.GetPrepaymentVATPct() / 100), Currency."Amount Rounding Precision") else PrepmtVATBaseToDeduct := SalesLine."Prepmt Amt to Deduct"; TempPrepmtDeductLCYSalesLine := SalesLine; if TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Order then TempPrepmtDeductLCYSalesLine."Qty. to Invoice" := GetQtyToInvoice(SalesLine, SalesHeader.Ship) else GetLineDataFromOrder(TempPrepmtDeductLCYSalesLine); if (TempPrepmtDeductLCYSalesLine."Prepmt Amt to Deduct" = 0) or (TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Invoice) then TempPrepmtDeductLCYSalesLine.CalcPrepaymentToDeduct(); TempPrepmtDeductLCYSalesLine."Line Amount" := TempPrepmtDeductLCYSalesLine.GetLineAmountToHandleInclPrepmt(TempPrepmtDeductLCYSalesLine."Qty. to Invoice"); TempPrepmtDeductLCYSalesLine."Attached to Line No." := PrepmtLineNo; TempPrepmtDeductLCYSalesLine."VAT Base Amount" := PrepmtVATBaseToDeduct; TempPrepmtDeductLCYSalesLine.Insert(); OnAfterInsertedPrepmtVATBaseToDeduct( SalesHeader, SalesLine, PrepmtLineNo, TotalPrepmtAmtToDeduct, TempPrepmtDeductLCYSalesLine, PrepmtVATBaseToDeduct); exit(PrepmtVATBaseToDeduct); end; /// <summary> /// Calculates the LCY Amount of Prepayment VAT Base Amount for each prepayment line and updates the global temp table TempPrepmtDeductLCYSalesLine with it. /// </summary> /// <param name="PrepmtSalesLine">Temp tables with prepayment sales lines.</param> /// <param name="SalesHeader">The sales header of the document being posted.</param> procedure DividePrepmtAmountLCY(var PrepmtSalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header") var ActualCurrencyFactor: Decimal; begin PrepmtSalesLine.Reset(); PrepmtSalesLine.SetFilter(Type, '<>%1', PrepmtSalesLine.Type::" "); if PrepmtSalesLine.FindSet() then repeat if SalesHeader."Currency Code" <> '' then ActualCurrencyFactor := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader."Posting Date", SalesHeader."Currency Code", PrepmtSalesLine."Prepmt Amt to Deduct", SalesHeader."Currency Factor")) / PrepmtSalesLine."Prepmt Amt to Deduct" else ActualCurrencyFactor := 1; UpdatePrepmtAmountInvBuf(PrepmtSalesLine."Line No.", ActualCurrencyFactor); until PrepmtSalesLine.Next() = 0; PrepmtSalesLine.Reset(); end; local procedure UpdatePrepmtAmountInvBuf(PrepmtSalesLineNo: Integer; CurrencyFactor: Decimal) var PrepmtAmtRemainder: Decimal; begin TempPrepmtDeductLCYSalesLine.Reset(); TempPrepmtDeductLCYSalesLine.SetRange("Attached to Line No.", PrepmtSalesLineNo); if TempPrepmtDeductLCYSalesLine.FindSet(true) then repeat TempPrepmtDeductLCYSalesLine."Prepmt. Amount Inv. (LCY)" := CalcRoundedAmount(CurrencyFactor * TempPrepmtDeductLCYSalesLine."VAT Base Amount", PrepmtAmtRemainder); TempPrepmtDeductLCYSalesLine.Modify(); until TempPrepmtDeductLCYSalesLine.Next() = 0; end; local procedure AdjustPrepmtAmountLCY(SalesHeader: Record "Sales Header"; var PrepmtSalesLine: Record "Sales Line") var SalesLine: Record "Sales Line"; SalesInvoiceLine: Record "Sales Line"; TempSalesLineShipmentBuffer: Record "Sales Line" temporary; DeductionFactor: Decimal; PrepmtVATPart: Decimal; PrepmtVATAmtRemainder: Decimal; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; CurrentLineFinalInvoice: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeAdjustPrepmtAmountLCY(SalesHeader, PrepmtSalesLine, IsHandled); if IsHandled then exit; if PrepmtSalesLine."Prepayment Line" then begin PrepmtVATPart := (PrepmtSalesLine."Amount Including VAT" - PrepmtSalesLine.Amount) / PrepmtSalesLine."Unit Price"; OnAdjustPrepmtAmountLCYOnAfterCalcPrepmtVATPart(PrepmtVATPart, SalesHeader, PrepmtSalesLine); TempPrepmtDeductLCYSalesLine.Reset(); TempPrepmtDeductLCYSalesLine.SetRange("Attached to Line No.", PrepmtSalesLine."Line No."); if TempPrepmtDeductLCYSalesLine.FindSet(true) then begin FinalInvoice := true; repeat SalesLine := TempPrepmtDeductLCYSalesLine; SalesLine.Find(); if TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Invoice then begin SalesInvoiceLine := SalesLine; GetSalesOrderLine(SalesLine, SalesInvoiceLine); SalesLine."Qty. to Invoice" := SalesInvoiceLine."Qty. to Invoice"; OnAdjustPrepmtAmountLCYOnAfterGetOrderLine(SalesLine, SalesInvoiceLine); TempSalesLineShipmentBuffer := SalesLine; if TempSalesLineShipmentBuffer.Find() then begin TempSalesLineShipmentBuffer."Qty. to Invoice" += TempPrepmtDeductLCYSalesLine."Qty. to Invoice"; TempSalesLineShipmentBuffer.Modify(); end else begin TempSalesLineShipmentBuffer.Quantity := TempPrepmtDeductLCYSalesLine.Quantity; TempSalesLineShipmentBuffer."Qty. to Invoice" := TempPrepmtDeductLCYSalesLine."Qty. to Invoice"; TempSalesLineShipmentBuffer.Insert(); end; CurrentLineFinalInvoice := TempSalesLineShipmentBuffer.IsFinalInvoice(); end else begin CurrentLineFinalInvoice := TempPrepmtDeductLCYSalesLine.IsFinalInvoice(); FinalInvoice := FinalInvoice and CurrentLineFinalInvoice; end; if SalesLine."Qty. to Invoice" <> TempPrepmtDeductLCYSalesLine."Qty. to Invoice" then SalesLine."Prepmt Amt to Deduct" := CalcPrepmtAmtToDeduct(SalesLine, SalesHeader.Ship); DeductionFactor := SalesLine."Prepmt Amt to Deduct" / (SalesLine."Prepmt. Amt. Inv." - SalesLine."Prepmt Amt Deducted"); TempPrepmtDeductLCYSalesLine."Prepmt. VAT Amount Inv. (LCY)" := CalcRoundedAmount(SalesLine."Prepmt Amt to Deduct" * PrepmtVATPart, PrepmtVATAmtRemainder); if (TempPrepmtDeductLCYSalesLine."Prepayment %" <> 100) or CurrentLineFinalInvoice or (TempPrepmtDeductLCYSalesLine."Currency Code" <> '') then CalcPrepmtRoundingAmounts(TempPrepmtDeductLCYSalesLine, SalesLine, DeductionFactor, TotalRoundingAmount); TempPrepmtDeductLCYSalesLine.Modify(); if SalesHeader."Prices Including VAT" then if ((TempPrepmtDeductLCYSalesLine."Prepayment %" <> 100) or CurrentLineFinalInvoice) and (DeductionFactor = 1) then begin PricesInclVATRoundingAmount[1] := TotalRoundingAmount[1]; PricesInclVATRoundingAmount[2] := TotalRoundingAmount[2]; end; if TempPrepmtDeductLCYSalesLine."VAT Calculation Type" <> TempPrepmtDeductLCYSalesLine."VAT Calculation Type"::"Full VAT" then TotalPrepmtAmount[1] += TempPrepmtDeductLCYSalesLine."Prepmt. Amount Inv. (LCY)"; TotalPrepmtAmount[2] += TempPrepmtDeductLCYSalesLine."Prepmt. VAT Amount Inv. (LCY)"; until TempPrepmtDeductLCYSalesLine.Next() = 0; end; if FinalInvoice then if TempSalesLineShipmentBuffer.FindSet() then repeat if not TempSalesLineShipmentBuffer.IsFinalInvoice() then FinalInvoice := false; until not FinalInvoice or (TempSalesLineShipmentBuffer.Next() = 0); if SalesHeader."Document Type" <> SalesHeader."Document Type"::"Credit Memo" then UpdatePrepmtSalesLineWithRounding( PrepmtSalesLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount); end; end; local procedure CalcPrepmtAmtToDeduct(SalesLine: Record "Sales Line"; Ship: Boolean): Decimal var IsHandled: Boolean; PrepmtAmtToDeduct: Decimal; begin OnBeforeCalcPrepmtAmtToDeduct(SalesLine, Ship, IsHandled, PrepmtAmtToDeduct); if IsHandled then exit(PrepmtAmtToDeduct); SalesLine."Qty. to Invoice" := GetQtyToInvoice(SalesLine, Ship); SalesLine.CalcPrepaymentToDeduct(); exit(SalesLine."Prepmt Amt to Deduct"); end; local procedure GetQtyToInvoice(SalesLine: Record "Sales Line"; Ship: Boolean): Decimal var AllowedQtyToInvoice: Decimal; QtyToInvoice: Decimal; IsHandled: Boolean; begin OnBeforeGetQtyToInvoice(SalesLine, Ship, IsHandled, QtyToInvoice); if IsHandled then exit(QtyToInvoice); AllowedQtyToInvoice := SalesLine."Qty. Shipped Not Invoiced"; if Ship then AllowedQtyToInvoice := AllowedQtyToInvoice + SalesLine."Qty. to Ship"; if SalesLine."Qty. to Invoice" > AllowedQtyToInvoice then exit(AllowedQtyToInvoice); exit(SalesLine."Qty. to Invoice"); end; local procedure GetLineDataFromOrder(var SalesLine: Record "Sales Line") var SalesShptLine: Record "Sales Shipment Line"; SalesOrderLine: Record "Sales Line"; begin SalesShptLine.Get(SalesLine."Shipment No.", SalesLine."Shipment Line No."); SalesOrderLine.Get(SalesLine."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No."); SalesLine.Quantity := SalesOrderLine.Quantity; SalesLine."Qty. Shipped Not Invoiced" := SalesOrderLine."Qty. Shipped Not Invoiced"; SalesLine."Quantity Invoiced" := SalesOrderLine."Quantity Invoiced"; SalesLine."Prepmt Amt Deducted" := SalesOrderLine."Prepmt Amt Deducted"; SalesLine."Prepmt. Amt. Inv." := SalesOrderLine."Prepmt. Amt. Inv."; SalesLine."Line Discount Amount" := SalesOrderLine."Line Discount Amount"; OnAfterGetLineDataFromOrder(SalesLine, SalesOrderLine); end; local procedure CalcPrepmtRoundingAmounts(var PrepmtSalesLineBuf: Record "Sales Line"; SalesLine: Record "Sales Line"; DeductionFactor: Decimal; var TotalRoundingAmount: array[2] of Decimal) var RoundingAmount: array[2] of Decimal; begin if PrepmtSalesLineBuf."VAT Calculation Type" <> PrepmtSalesLineBuf."VAT Calculation Type"::"Full VAT" then begin RoundingAmount[1] := PrepmtSalesLineBuf."Prepmt. Amount Inv. (LCY)" - Round(DeductionFactor * SalesLine."Prepmt. Amount Inv. (LCY)"); PrepmtSalesLineBuf."Prepmt. Amount Inv. (LCY)" := PrepmtSalesLineBuf."Prepmt. Amount Inv. (LCY)" - RoundingAmount[1]; TotalRoundingAmount[1] += RoundingAmount[1]; end; RoundingAmount[2] := PrepmtSalesLineBuf."Prepmt. VAT Amount Inv. (LCY)" - Round(DeductionFactor * SalesLine."Prepmt. VAT Amount Inv. (LCY)"); PrepmtSalesLineBuf."Prepmt. VAT Amount Inv. (LCY)" := PrepmtSalesLineBuf."Prepmt. VAT Amount Inv. (LCY)" - RoundingAmount[2]; TotalRoundingAmount[2] += RoundingAmount[2]; end; /// <summary> /// Updates the prepayment sales line with rounding adjustments. /// </summary> /// <param name="PrepmtSalesLine">The prepayment sales line to update.</param> /// <param name="TotalRoundingAmount">Array with the total rounding amount to add. First value is the amount excluding VAT, second value is the VAT amount.</param> /// <param name="TotalPrepmtAmount">Array with the total prepayment amount to deduct. First value is the amount excluding VAT, second value is the VAT amount.</param> /// <param name="FinalInvoice">Indicates if the current invoice is the final invoice.</param> /// <param name="PricesInclVATRoundingAmount">Array with the rounding amount to add to the prices including VAT. First value is the amount excluding VAT, second value is the VAT amount.</param> procedure UpdatePrepmtSalesLineWithRounding(var PrepmtSalesLine: Record "Sales Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal) var NewAmountIncludingVAT: Decimal; Prepmt100PctVATRoundingAmt: Decimal; AmountRoundingPrecision: Decimal; begin OnBeforeUpdatePrepmtSalesLineWithRounding( PrepmtSalesLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount, TotalSalesLine, TotalSalesLineLCY); NewAmountIncludingVAT := TotalPrepmtAmount[1] + TotalPrepmtAmount[2] + TotalRoundingAmount[1] + TotalRoundingAmount[2]; if PrepmtSalesLine."Prepayment %" = 100 then TotalRoundingAmount[1] += PrepmtSalesLine."Amount Including VAT" - NewAmountIncludingVAT; AmountRoundingPrecision := GetAmountRoundingPrecisionInLCY(PrepmtSalesLine."Document Type", PrepmtSalesLine."Document No.", PrepmtSalesLine."Currency Code"); if (Abs(TotalRoundingAmount[1]) <= AmountRoundingPrecision) and (Abs(TotalRoundingAmount[2]) <= AmountRoundingPrecision) and (PrepmtSalesLine."Prepayment %" = 100) then begin Prepmt100PctVATRoundingAmt := TotalRoundingAmount[1]; TotalRoundingAmount[1] := 0; end; if (PricesInclVATRoundingAmount[1] <> 0) and (PricesInclVATRoundingAmount[1] = TotalRoundingAmount[1]) and (PricesInclVATRoundingAmount[2] = 0) and (PricesInclVATRoundingAmount[2] = TotalRoundingAmount[2]) and FinalInvoice and (PrepmtSalesLine."Prepayment %" <> 100) then begin PricesInclVATRoundingAmount[1] := 0; TotalRoundingAmount[1] := 0; end; PrepmtSalesLine."Prepmt. Amount Inv. (LCY)" := TotalRoundingAmount[1]; PrepmtSalesLine.Amount := TotalPrepmtAmount[1] + TotalRoundingAmount[1]; if (PricesInclVATRoundingAmount[1] <> 0) and (TotalRoundingAmount[1] = 0) then begin if (PrepmtSalesLine."Prepayment %" = 100) and FinalInvoice and (PrepmtSalesLine.Amount + TotalPrepmtAmount[2] = PrepmtSalesLine."Amount Including VAT") then Prepmt100PctVATRoundingAmt := 0; PricesInclVATRoundingAmount[1] := 0; end; if ((TotalRoundingAmount[2] <> 0) or FinalInvoice) and (TotalRoundingAmount[1] = 0) then begin if (PrepmtSalesLine."Prepayment %" = 100) and (PrepmtSalesLine."Prepmt. Amount Inv. (LCY)" = 0) then Prepmt100PctVATRoundingAmt += TotalRoundingAmount[2]; if (PrepmtSalesLine."Prepayment %" = 100) or FinalInvoice then TotalRoundingAmount[2] := 0; end; if (PricesInclVATRoundingAmount[2] <> 0) and (TotalRoundingAmount[2] = 0) then begin if Abs(Prepmt100PctVATRoundingAmt) <= AmountRoundingPrecision then Prepmt100PctVATRoundingAmt := 0; PricesInclVATRoundingAmount[2] := 0; end; PrepmtSalesLine."Prepmt. VAT Amount Inv. (LCY)" := TotalRoundingAmount[2] + Prepmt100PctVATRoundingAmt; NewAmountIncludingVAT := PrepmtSalesLine.Amount + TotalPrepmtAmount[2] + TotalRoundingAmount[2]; if (PricesInclVATRoundingAmount[1] = 0) and (PricesInclVATRoundingAmount[2] = 0) or (PrepmtSalesLine."Currency Code" <> '') and FinalInvoice then TotalSalesLineLCY."Amount Including VAT" += PrepmtSalesLine."Amount Including VAT" - NewAmountIncludingVAT - Prepmt100PctVATRoundingAmt; if PrepmtSalesLine."Currency Code" = '' then TotalSalesLine."Amount Including VAT" := TotalSalesLineLCY."Amount Including VAT"; PrepmtSalesLine."Amount Including VAT" := NewAmountIncludingVAT; if FinalInvoice and (TotalSalesLine.Amount = 0) and (TotalSalesLine."Amount Including VAT" <> 0) and (Abs(TotalSalesLine."Amount Including VAT") <= Currency."Amount Rounding Precision") then begin PrepmtSalesLine."Amount Including VAT" += TotalSalesLineLCY."Amount Including VAT"; TotalSalesLine."Amount Including VAT" := 0; TotalSalesLineLCY."Amount Including VAT" := 0; end; OnAfterUpdatePrepmtSalesLineWithRounding( PrepmtSalesLine, TotalRoundingAmount, TotalPrepmtAmount, FinalInvoice, PricesInclVATRoundingAmount, TotalSalesLine, TotalSalesLineLCY); end; local procedure CalcRoundedAmount(Amount: Decimal; var Remainder: Decimal): Decimal var AmountRnded: Decimal; begin Amount := Amount + Remainder; AmountRnded := Round(Amount, GLSetup."Amount Rounding Precision"); Remainder := Amount - AmountRnded; exit(AmountRnded); end; local procedure GetSalesOrderLine(var SalesOrderLine: Record "Sales Line"; SalesLine: Record "Sales Line") var SalesShptLine: Record "Sales Shipment Line"; begin SalesShptLine.Get(SalesLine."Shipment No.", SalesLine."Shipment Line No."); SalesOrderLine.Get( SalesOrderLine."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No."); SalesOrderLine."Prepmt Amt to Deduct" := SalesLine."Prepmt Amt to Deduct"; end; /// <summary> /// Decrements the prepayment amount invoiced in LCY and the prepayment VAT amount invoiced in LCY for a given sales line. /// </summary> /// <param name="SalesHeader">The sales header of the document being posted.</param> /// <param name="SalesLine">The sales line of the document for which the prepayment amount is being calculated.</param> /// <param name="PrepmtAmountInvLCY">The invoiced prepayment amount of a sales line. The amount passed in gets reduced by the amount to be deducted.</param> /// <param name="PrepmtVATAmountInvLCY">The invoiced prepayment VAT amount of a sales line. The amount passed in gets reduced by the amount to be deducted.</param> procedure DecrementPrepmtAmtInvLCY(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PrepmtAmountInvLCY: Decimal; var PrepmtVATAmountInvLCY: Decimal) begin TempPrepmtDeductLCYSalesLine.Reset(); if TempPrepmtDeductLCYSalesLine.Get(SalesLine."Document Type", SalesLine."Document No.", SalesLine."Line No.") then begin PrepmtAmountInvLCY := PrepmtAmountInvLCY - TempPrepmtDeductLCYSalesLine."Prepmt. Amount Inv. (LCY)"; PrepmtVATAmountInvLCY := PrepmtVATAmountInvLCY - TempPrepmtDeductLCYSalesLine."Prepmt. VAT Amount Inv. (LCY)"; end; OnAfterDecrementPrepmtAmtInvLCY(SalesHeader, SalesLine, PrepmtAmountInvLCY, PrepmtVATAmountInvLCY); end; local procedure AdjustFinalInvWith100PctPrepmt(var CombinedSalesLine: Record "Sales Line") var DiffToLineDiscAmt: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeAdjustFinalInvWith100PctPrepmt(TempPrepmtDeductLCYSalesLine, CombinedSalesLine, IsHandled); if IsHandled then exit; TempPrepmtDeductLCYSalesLine.Reset(); TempPrepmtDeductLCYSalesLine.SetRange(TempPrepmtDeductLCYSalesLine."Prepayment %", 100); if TempPrepmtDeductLCYSalesLine.FindSet(true) then repeat if TempPrepmtDeductLCYSalesLine.IsFinalInvoice() then begin DiffToLineDiscAmt := TempPrepmtDeductLCYSalesLine."Prepmt Amt to Deduct" - TempPrepmtDeductLCYSalesLine."Line Amount"; if TempPrepmtDeductLCYSalesLine."Document Type" = TempPrepmtDeductLCYSalesLine."Document Type"::Order then DiffToLineDiscAmt := DiffToLineDiscAmt * TempPrepmtDeductLCYSalesLine.Quantity / TempPrepmtDeductLCYSalesLine."Qty. to Invoice"; if DiffToLineDiscAmt <> 0 then begin CombinedSalesLine.Get(TempPrepmtDeductLCYSalesLine."Document Type", TempPrepmtDeductLCYSalesLine."Document No.", TempPrepmtDeductLCYSalesLine."Line No."); TempPrepmtDeductLCYSalesLine."Line Discount Amount" := CombinedSalesLine."Line Discount Amount" - DiffToLineDiscAmt; TempPrepmtDeductLCYSalesLine.Modify(); end; end; until TempPrepmtDeductLCYSalesLine.Next() = 0; TempPrepmtDeductLCYSalesLine.Reset(); end; local procedure GetPrepmtDiffToLineAmount(SalesLine: Record "Sales Line"): Decimal begin if SalesLine."Prepayment %" = 100 then if TempPrepmtDeductLCYSalesLine.Get(SalesLine."Document Type", SalesLine."Document No.", SalesLine."Line No.") then exit(TempPrepmtDeductLCYSalesLine."Prepmt Amt to Deduct" + TempPrepmtDeductLCYSalesLine."Inv. Disc. Amount to Invoice" - TempPrepmtDeductLCYSalesLine."Line Amount"); exit(0); end; local procedure PostJobContractLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforePostJobContractLine( SalesHeader, SalesLine, IsHandled, JobContractLine, InvoicePostingInterface, SalesLineACY, SalesInvHeader, SalesCrMemoHeader); if not IsHandled then begin if SalesLine."Job Contract Entry No." = 0 then exit; IsHandled := false; OnPostJobContractLineBeforeTestFields(SalesHeader, SalesLine, IsHandled); if not IsHandled then begin if (SalesHeader."Document Type" <> SalesHeader."Document Type"::Invoice) and (SalesHeader."Document Type" <> SalesHeader."Document Type"::"Credit Memo") then SalesLine.TestField("Job Contract Entry No.", 0); SalesLine.TestField("Job No."); SalesLine.TestField("Job Task No."); end; if SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice then SalesLine."Document No." := SalesInvHeader."No."; if SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo" then SalesLine."Document No." := SalesCrMemoHeader."No."; JobContractLine := true; InvoicePostingInterface.PrepareJobLine(SalesHeader, SalesLine, SalesLineACY); end; OnAfterPostJobContractLine(SalesHeader, SalesLine, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode); end; local procedure InsertICGenJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var ICGenJnlLineNo: Integer) var ICGLAccount: Record "IC G/L Account"; ICPartner: Record "IC Partner"; GenJnlLine: Record "Gen. Journal Line"; begin SalesHeader.TestField("Sell-to IC Partner Code", ''); SalesHeader.TestField("Bill-to IC Partner Code", ''); SalesLine.TestField("IC Partner Ref. Type", SalesLine."IC Partner Ref. Type"::"G/L Account"); ICGLAccount.Get(SalesLine."IC Partner Reference"); ICGenJnlLineNo := ICGenJnlLineNo + 1; TempICGenJnlLine.InitNewLine( SalesHeader."Posting Date", SalesHeader."Document Date", SalesHeader."VAT Reporting Date", SalesHeader."Posting Description", SalesLine."Shortcut Dimension 1 Code", SalesLine."Shortcut Dimension 2 Code", SalesLine."Dimension Set ID", SalesHeader."Reason Code"); TempICGenJnlLine."Line No." := ICGenJnlLineNo; TempICGenJnlLine.CopyDocumentFields(GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series"); TempICGenJnlLine."Account Type" := TempICGenJnlLine."Account Type"::"IC Partner"; TempICGenJnlLine.Validate(TempICGenJnlLine."Account No.", SalesLine."IC Partner Code"); TempICGenJnlLine."Source Currency Code" := SalesHeader."Currency Code"; TempICGenJnlLine."Source Currency Amount" := TempICGenJnlLine.Amount; TempICGenJnlLine.Correction := SalesHeader.Correction; TempICGenJnlLine."Country/Region Code" := SalesHeader."VAT Country/Region Code"; TempICGenJnlLine."Source Type" := GenJnlLine."Source Type"::Customer; TempICGenJnlLine."Source No." := SalesHeader."Bill-to Customer No."; TempICGenJnlLine."Source Line No." := SalesLine."Line No."; TempICGenJnlLine.Validate("Bal. Account Type", TempICGenJnlLine."Bal. Account Type"::"G/L Account"); TempICGenJnlLine.Validate("Bal. Account No.", SalesLine."No."); TempICGenJnlLine."Shortcut Dimension 1 Code" := SalesLine."Shortcut Dimension 1 Code"; TempICGenJnlLine."Shortcut Dimension 2 Code" := SalesLine."Shortcut Dimension 2 Code"; TempICGenJnlLine."Dimension Set ID" := SalesLine."Dimension Set ID"; ValidateICPartnerBusPostingGroups(SalesLine); TempICGenJnlLine.Validate("Bal. VAT Prod. Posting Group", SalesLine."VAT Prod. Posting Group"); TempICGenJnlLine."IC Partner Code" := SalesLine."IC Partner Code"; TempICGenJnlLine."IC Account Type" := TempICGenJnlLine."IC Account Type"::"G/L Account"; TempICGenJnlLine."IC Account No." := SalesLine."IC Partner Reference"; TempICGenJnlLine."IC Direction" := TempICGenJnlLine."IC Direction"::Outgoing; ICPartner.Get(SalesLine."IC Partner Code"); if ICPartner."Cost Distribution in LCY" and (SalesLine."Currency Code" <> '') then begin TempICGenJnlLine."Currency Code" := ''; TempICGenJnlLine."Currency Factor" := 0; Currency.Get(SalesLine."Currency Code"); if SalesHeader.IsCreditDocType() then TempICGenJnlLine.Amount := Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader."Posting Date", SalesLine."Currency Code", SalesLine.Amount, SalesHeader."Currency Factor")) else TempICGenJnlLine.Amount := -Round( CurrExchRate.ExchangeAmtFCYToLCY( SalesHeader."Posting Date", SalesLine."Currency Code", SalesLine.Amount, SalesHeader."Currency Factor")); end else begin Currency.InitRoundingPrecision(); TempICGenJnlLine."Currency Code" := SalesHeader."Currency Code"; TempICGenJnlLine."Currency Factor" := SalesHeader."Currency Factor"; if SalesHeader.IsCreditDocType() then TempICGenJnlLine.Amount := SalesLine.Amount else TempICGenJnlLine.Amount := -SalesLine.Amount; end; if TempICGenJnlLine."Bal. VAT %" <> 0 then TempICGenJnlLine.Amount := Round(TempICGenJnlLine.Amount * (1 + TempICGenJnlLine."Bal. VAT %" / 100), Currency."Amount Rounding Precision"); TempICGenJnlLine.Validate(Amount); TempICGenJnlLine."Journal Template Name" := SalesLine.GetJnlTemplateName(); OnBeforeInsertICGenJnlLine(TempICGenJnlLine, SalesHeader, SalesLine, SuppressCommit); TempICGenJnlLine.Insert(); end; local procedure ValidateICPartnerBusPostingGroups(SalesLine: Record "Sales Line") var Vendor: Record Vendor; IsHandled: Boolean; begin IsHandled := false; OnBeforeValidateICPartnerBusPostingGroups(TempICGenJnlLine, SalesLine, IsHandled); if IsHandled then exit; Vendor.SetCurrentKey("IC Partner Code"); Vendor.SetRange("IC Partner Code", SalesLine."IC Partner Code"); if Vendor.FindFirst() then begin TempICGenJnlLine.Validate("Bal. Gen. Bus. Posting Group", Vendor."Gen. Bus. Posting Group"); TempICGenJnlLine.Validate("Bal. VAT Bus. Posting Group", Vendor."VAT Bus. Posting Group"); end; end; local procedure PostICGenJnl() var ICInOutBoxMgt: Codeunit ICInboxOutboxMgt; ICOutboxExport: Codeunit "IC Outbox Export"; ICTransactionNo: Integer; begin TempICGenJnlLine.Reset(); TempICGenJnlLine.SetFilter(Amount, '<>%1', 0); if TempICGenJnlLine.Find('-') then repeat ICTransactionNo := ICInOutBoxMgt.CreateOutboxJnlTransaction(TempICGenJnlLine, false); ICInOutBoxMgt.CreateOutboxJnlLine(ICTransactionNo, 1, TempICGenJnlLine); ICOutboxExport.ProcessAutoSendOutboxTransactionNo(ICTransactionNo); if TempICGenJnlLine.Amount <> 0 then GenJnlPostLine.RunWithCheck(TempICGenJnlLine); until TempICGenJnlLine.Next() = 0; end; /// <summary> /// Checks if the prepayment amount for the sales lines is too big or too small using information from the related sales order lines. /// It throws an error if it is. /// </summary> /// <remarks> /// It is too big if the prepayment amount is bigger than the remaining prepayment amount on the sales order line. /// It is too small if the prepayment amount is smaller than the remaining prepayment amount on the sales order line and the sales order line is fully invoiced. /// If this is the last invoice and the sales line has 100% prepayment, then the actual (non-temp) invoice line is adjusted so that prepayment amount to deduct equals the line amount. /// </remarks> procedure TestGetShipmentPPmtAmtToDeduct() var TempSalesLine: Record "Sales Line" temporary; TempShippedSalesLine: Record "Sales Line" temporary; TempTotalSalesLine: Record "Sales Line" temporary; TempSalesShptLine: Record "Sales Shipment Line" temporary; SalesShptLine: Record "Sales Shipment Line"; SalesOrderLine: Record "Sales Line"; MaxAmtToDeduct: Decimal; begin ResetTempLines(TempSalesLine); TempSalesLine.SetFilter(Quantity, '>0'); TempSalesLine.SetFilter("Qty. to Invoice", '>0'); TempSalesLine.SetFilter("Shipment No.", '<>%1', ''); TempSalesLine.SetFilter("Prepmt Amt to Deduct", '<>0'); if TempSalesLine.IsEmpty() then exit; TempSalesLine.SetRange("Prepmt Amt to Deduct"); if TempSalesLine.FindSet() then repeat if SalesShptLine.Get(TempSalesLine."Shipment No.", TempSalesLine."Shipment Line No.") then begin TempShippedSalesLine := TempSalesLine; TempShippedSalesLine.Insert(); TempSalesShptLine := SalesShptLine; if TempSalesShptLine.Insert() then; if not TempTotalSalesLine.Get(TempSalesLine."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No.") then begin TempTotalSalesLine.Init(); TempTotalSalesLine."Document Type" := TempSalesLine."Document Type"::Order; TempTotalSalesLine."Document No." := SalesShptLine."Order No."; TempTotalSalesLine."Line No." := SalesShptLine."Order Line No."; TempTotalSalesLine.Insert(); end; TempTotalSalesLine."Qty. to Invoice" := TempTotalSalesLine."Qty. to Invoice" + TempSalesLine."Qty. to Invoice"; TempTotalSalesLine."Prepmt Amt to Deduct" := TempTotalSalesLine."Prepmt Amt to Deduct" + TempSalesLine."Prepmt Amt to Deduct"; AdjustInvLineWith100PctPrepmt(TempSalesLine, TempTotalSalesLine); TempTotalSalesLine.Modify(); end; until TempSalesLine.Next() = 0; if TempShippedSalesLine.FindSet() then repeat if TempSalesShptLine.Get(TempShippedSalesLine."Shipment No.", TempShippedSalesLine."Shipment Line No.") then if SalesOrderLine.Get( TempShippedSalesLine."Document Type"::Order, TempSalesShptLine."Order No.", TempSalesShptLine."Order Line No.") then if TempTotalSalesLine.Get( TempShippedSalesLine."Document Type"::Order, TempSalesShptLine."Order No.", TempSalesShptLine."Order Line No.") then begin MaxAmtToDeduct := SalesOrderLine."Prepmt. Amt. Inv." - SalesOrderLine."Prepmt Amt Deducted"; CheckTotalPrepmtAmtToDeduct(TempSalesLine, TempTotalSalesLine, MaxAmtToDeduct); if (TempTotalSalesLine."Qty. to Invoice" = SalesOrderLine.Quantity - SalesOrderLine."Quantity Invoiced") and (SalesOrderLine."Prepmt Amt to Deduct" <> MaxAmtToDeduct) then Error(PrepAmountToDeductToSmallErr, TempSalesLine.FieldCaption(TempSalesLine."Prepmt Amt to Deduct"), MaxAmtToDeduct); end; until TempShippedSalesLine.Next() = 0; end; local procedure CheckTotalPrepmtAmtToDeduct(var TempSalesLine: Record "Sales Line" temporary; var TempTotalSalesLine: Record "Sales Line" temporary; MaxAmtToDeduct: Decimal) var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckTotalPrepmtAmtToDeduct(TempSalesLine, TempTotalSalesLine, MaxAmtToDeduct, IsHandled); if IsHandled then exit; if TempTotalSalesLine."Prepmt Amt to Deduct" > MaxAmtToDeduct then Error(PrepAmountToDeductToBigErr, TempSalesLine.FieldCaption("Prepmt Amt to Deduct"), MaxAmtToDeduct); end; local procedure AdjustInvLineWith100PctPrepmt(var SalesInvoiceLine: Record "Sales Line"; var TempTotalSalesLine: Record "Sales Line" temporary) var SalesOrderLine: Record "Sales Line"; DiffAmtToDeduct: Decimal; begin if SalesInvoiceLine."Prepayment %" = 100 then begin SalesOrderLine.Get(TempTotalSalesLine."Document Type", TempTotalSalesLine."Document No.", TempTotalSalesLine."Line No."); if TempTotalSalesLine."Qty. to Invoice" = SalesOrderLine.Quantity - SalesOrderLine."Quantity Invoiced" then begin DiffAmtToDeduct := SalesOrderLine."Prepmt. Amt. Inv." - SalesOrderLine."Prepmt Amt Deducted" - TempTotalSalesLine."Prepmt Amt to Deduct"; if DiffAmtToDeduct <> 0 then begin SalesInvoiceLine."Prepmt Amt to Deduct" := SalesInvoiceLine."Prepmt Amt to Deduct" + DiffAmtToDeduct; SalesInvoiceLine."Line Amount" := SalesInvoiceLine."Prepmt Amt to Deduct"; SalesInvoiceLine."Line Discount Amount" := SalesInvoiceLine."Line Discount Amount" - DiffAmtToDeduct; ModifyTempLine(SalesInvoiceLine); TempTotalSalesLine."Prepmt Amt to Deduct" := TempTotalSalesLine."Prepmt Amt to Deduct" + DiffAmtToDeduct; end; end; end; end; /// <summary> /// Archives unposted orders and return orders if archiving is enabled in the Sales Setup. /// </summary> /// <remarks> /// Order isn't archived if there are no lines to archive or PreviewMode is true. /// </remarks> /// <param name="SalesHeader"></param> procedure ArchiveUnpostedOrder(var SalesHeader: Record "Sales Header") var SalesLine: Record "Sales Line"; ArchiveManagement: Codeunit ArchiveManagement; IsHandled: Boolean; begin IsHandled := false; OnBeforeArchiveUnpostedOrder(SalesHeader, IsHandled, PreviewMode, OrderArchived); if IsHandled then exit; GetSalesSetup(); if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) then exit; if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) and not SalesSetup."Archive Orders" then exit; if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order") and not SalesSetup."Archive Return Orders" then exit; SalesLine.Reset(); SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); SalesLine.SetFilter(Quantity, '<>0'); if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then SalesLine.SetFilter("Qty. to Ship", '<>0') else SalesLine.SetFilter("Return Qty. to Receive", '<>0'); if not SalesLine.IsEmpty() and not PreviewMode then begin ArchiveManagement.RoundSalesDeferralsForArchive(SalesHeader, SalesLine); ArchiveManagement.ArchSalesDocumentNoConfirm(SalesHeader); OrderArchived := true; end; OnAfterArchiveUnpostedOrder(SalesHeader, SalesLine, OrderArchived); end; /// <summary> /// Retrieves the G/L Setup record if it hasn't been read before. /// </summary> procedure GetGLSetup() begin if not GLSetupRead then GLSetup.Get(); GLSetupRead := true; OnAfterGetGLSetup(GLSetup); end; local procedure GetSalesSetup() begin if not SalesSetupRead then SalesSetup.Get(); SalesSetupRead := true; OnAfterGetSalesSetup(SalesSetup); end; local procedure GetInvoicePostingSetup() var IsHandled: Boolean; begin if IsInterfaceInitalized then exit; IsHandled := false; OnBeforeGetInvoicePostingSetup(InvoicePostingInterface, IsHandled); if not IsHandled then InvoicePostingInterface := Enum::"Sales Invoice Posting"::"Invoice Posting (v.19)"; InvoicePostingInterface.Check(Database::"Sales Header"); IsInterfaceInitalized := true; InvoicePostingInterface.SetHideProgressWindow(HideProgressWindow); InvoicePostingInterface.SetPreviewMode(PreviewMode); InvoicePostingInterface.SetSuppressCommit(SuppressCommit); end; local procedure GetInvoicePostingParameters() begin InvoicePostingParameters."Document Type" := GenJnlLineDocType; InvoicePostingParameters."Document No." := GenJnlLineDocNo; InvoicePostingParameters."External Document No." := GenJnlLineExtDocNo; InvoicePostingParameters."Source Code" := SrcCode; InvoicePostingParameters."Auto Document No." := ''; end; local procedure LockTables(var SalesHeader: Record "Sales Header") var SalesLine: Record "Sales Line"; PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; InventorySetup: Record "Inventory Setup"; IsHandled: Boolean; begin IsHandled := false; OnBeforeLockTables(SalesHeader, PreviewMode, SuppressCommit, IsHandled); if IsHandled then exit; SalesLine.LockTable(); ItemChargeAssgntSales.LockTable(); PurchOrderLine.LockTable(); PurchOrderHeader.LockTable(); GetGLSetup(); if InventorySetup.UseLegacyPosting() and not InventorySetup.OptimGLEntLockForMultiuserEnv() then begin GLEntry.LockTable(); GLEntry.GetLastEntryNo(); end; end; local procedure UpdateSalesHeader(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SalesHeader: Record "Sales Header") var GenJnlLine: Record "Gen. Journal Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateSalesHeader(CustLedgerEntry, SalesInvHeader, SalesCrMemoHeader, GenJnlLineDocType.AsInteger(), IsHandled, GenJnlLineDocNo, PreviewMode, SalesHeader); if IsHandled then exit; case GenJnlLineDocType of GenJnlLine."Document Type"::Invoice: begin FindCustLedgEntry(GenJnlLineDocType, GenJnlLineDocNo, CustLedgerEntry); SalesInvHeader."Cust. Ledger Entry No." := CustLedgerEntry."Entry No."; SalesInvHeader.Modify(); end; GenJnlLine."Document Type"::"Credit Memo": begin FindCustLedgEntry(GenJnlLineDocType, GenJnlLineDocNo, CustLedgerEntry); SalesCrMemoHeader."Cust. Ledger Entry No." := CustLedgerEntry."Entry No."; SalesCrMemoHeader.Modify(); end; end; OnAfterUpdateSalesHeader(CustLedgerEntry, SalesInvHeader, SalesCrMemoHeader, GenJnlLineDocType.AsInteger(), GenJnlLineDocNo, PreviewMode, SalesHeader); end; local procedure MakeSalesLineToShip(var SalesLineToShip: Record "Sales Line"; SalesLineInvoiced: Record "Sales Line") var TempSalesLine: Record "Sales Line" temporary; begin ResetTempLines(TempSalesLine); TempSalesLine := SalesLineInvoiced; TempSalesLine.Find(); SalesLineToShip := SalesLineInvoiced; SalesLineToShip."Inv. Discount Amount" := TempSalesLine."Inv. Discount Amount"; end; local procedure "MAX"(number1: Integer; number2: Integer): Integer begin if number1 > number2 then exit(number1); exit(number2); end; local procedure FindCustLedgEntry(DocType: Enum "Gen. Journal Document Type"; DocNo: Code[20]; var CustLedgEntry: Record "Cust. Ledger Entry") begin OnBeforeFindCustLedgEntry(CustLedgEntry); CustLedgEntry.SetRange("Document Type", DocType); CustLedgEntry.SetRange("Document No.", DocNo); CustLedgEntry.FindLast(); end; local procedure ItemLedgerEntryExist(SalesLine2: Record "Sales Line"; ShipOrReceive: Boolean): Boolean var HasItemLedgerEntry: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeItemLedgerEntryExist(SalesLine2, ShipOrReceive, HasItemLedgerEntry, IsHandled); if IsHandled then exit(HasItemLedgerEntry); if ShipOrReceive then // item ledger entry will be created during posting in this transaction HasItemLedgerEntry := ((SalesLine2."Qty. to Ship" + SalesLine2."Quantity Shipped") <> 0) or ((SalesLine2."Qty. to Invoice" + SalesLine2."Quantity Invoiced") <> 0) or ((SalesLine2."Return Qty. to Receive" + SalesLine2."Return Qty. Received") <> 0) else // item ledger entry must already exist HasItemLedgerEntry := (SalesLine2."Quantity Shipped" <> 0) or (SalesLine2."Return Qty. Received" <> 0); exit(HasItemLedgerEntry); end; local procedure CheckPostRestrictions(SalesHeader: Record "Sales Header") var Contact: Record Contact; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckPostRestrictions(SalesHeader, IsHandled); if IsHandled then exit; if not PreviewMode then SalesHeader.CheckSalesPostRestrictions(); CheckCustBlockage(SalesHeader, SalesHeader."Sell-to Customer No.", true); SalesHeader.ValidateSalesPersonOnSalesHeader(SalesHeader, true, true); if SalesHeader."Bill-to Customer No." <> SalesHeader."Sell-to Customer No." then CheckCustBlockage(SalesHeader, SalesHeader."Bill-to Customer No.", false); if SalesHeader."Sell-to Contact No." <> '' then if Contact.Get(SalesHeader."Sell-to Contact No.") then Contact.CheckIfPrivacyBlocked(true); if SalesHeader."Bill-to Contact No." <> '' then if Contact.Get(SalesHeader."Bill-to Contact No.") then Contact.CheckIfPrivacyBlocked(true); end; local procedure CheckCustBlockage(SalesHeader: Record "Sales Header"; CustCode: Code[20]; ExecuteDocCheck: Boolean) var Cust: Record Customer; TempSalesLine: Record "Sales Line" temporary; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckCustBlockage(SalesHeader, CustCode, ExecuteDocCheck, IsHandled, TempSalesLineGlobal); if IsHandled then exit; Cust.Get(CustCode); if SalesHeader.Receive then Cust.CheckBlockedCustOnDocs(Cust, SalesHeader."Document Type", false, true) else if SalesHeader.Ship and CheckDocumentType(SalesHeader, ExecuteDocCheck) then begin ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Qty. to Ship", '<>0'); TempSalesLine.SetRange("Shipment No.", ''); OnCheckCustBlockageOnAfterTempLinesSetFilters(SalesHeader, TempSalesLine); if not TempSalesLine.IsEmpty() then Cust.CheckBlockedCustOnDocs(Cust, SalesHeader."Document Type", true, true); end else Cust.CheckBlockedCustOnDocs(Cust, SalesHeader."Document Type", false, true); end; /// <summary> /// Retrieves the General Posting Setup record for the specified sales line. /// </summary> /// <param name="GenPostingSetup">Return Variable: General Posting Setup record</param> /// <param name="SalesLine">sales line for which to retrieve the Gen. Posting Setup</param> procedure GetGeneralPostingSetup(var GenPostingSetup: Record "General Posting Setup"; SalesLine: Record "Sales Line") begin GenPostingSetup.Get(SalesLine."Gen. Bus. Posting Group", SalesLine."Gen. Prod. Posting Group"); OnAfterGetGeneralPostingSetup(GenPostingSetup, SalesLine); end; local procedure CheckDocumentType(SalesHeader: Record "Sales Header"; ExecuteDocCheck: Boolean): Boolean begin if ExecuteDocCheck then exit( (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) or ((SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and SalesSetup."Shipment on Invoice")); exit(true); end; local procedure UpdateWonOpportunities(var SalesHeader: Record "Sales Header") var Opp: Record Opportunity; OpportunityEntry: Record "Opportunity Entry"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateWonOpportunities(SalesHeader, SalesInvHeader, IsHandled); if not IsHandled then if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin Opp.Reset(); Opp.SetCurrentKey("Sales Document Type", "Sales Document No."); Opp.SetRange("Sales Document Type", Opp."Sales Document Type"::Order); Opp.SetRange("Sales Document No.", SalesHeader."No."); Opp.SetRange(Status, Opp.Status::Won); if Opp.FindFirst() then begin Opp."Sales Document Type" := Opp."Sales Document Type"::"Posted Invoice"; Opp."Sales Document No." := SalesInvHeader."No."; OnUpdateWonOpportunitiesOnBeforeOpportunityModify(SalesHeader, SalesInvHeader, Opp); Opp.Modify(); OpportunityEntry.Reset(); OpportunityEntry.SetCurrentKey(Active, "Opportunity No."); OpportunityEntry.SetRange(Active, true); OpportunityEntry.SetRange("Opportunity No.", Opp."No."); if OpportunityEntry.FindFirst() then begin OpportunityEntry."Calcd. Current Value (LCY)" := OpportunityEntry.GetSalesDocValue(SalesHeader); OpportunityEntry.Modify(); end; end; end; OnAfterUpdateWonOpportunities(SalesHeader, SalesInvHeader); end; local procedure UpdateQtyToBeInvoicedForShipment(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; InvoicingTrackingSpecification: Record "Tracking Specification"; ItemLedgEntryNotInvoiced: Record "Item Ledger Entry") begin OnBeforeUpdateQtyToBeInvoicedForShipment( QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, HasATOShippedNotInvoiced, SalesLine, SalesShptLine, InvoicingTrackingSpecification); if TrackingSpecificationExists then begin QtyToBeInvoiced := InvoicingTrackingSpecification."Qty. to Invoice"; QtyToBeInvoicedBase := InvoicingTrackingSpecification."Qty. to Invoice (Base)"; end else if HasATOShippedNotInvoiced then begin QtyToBeInvoicedBase := ItemLedgEntryNotInvoiced.Quantity - ItemLedgEntryNotInvoiced."Invoiced Quantity"; if Abs(QtyToBeInvoicedBase) > Abs(RemQtyToBeInvoicedBase) then QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - SalesLine."Qty. to Ship (Base)"; QtyToBeInvoiced := Round(QtyToBeInvoicedBase / SalesShptLine."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision()); end else begin QtyToBeInvoiced := RemQtyToBeInvoiced - SalesLine."Qty. to Ship"; QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - SalesLine."Qty. to Ship (Base)"; end; OnUpdateQtyToBeInvoicedForShipmentOnAfterSetQtyToBeInvoiced( TrackingSpecificationExists, HasATOShippedNotInvoiced, QtyToBeInvoiced, QtyToBeInvoicedBase, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, SalesLine); if Abs(QtyToBeInvoiced) > Abs(SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced") then begin QtyToBeInvoiced := -(SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced"); QtyToBeInvoicedBase := -(SalesShptLine."Quantity (Base)" - SalesShptLine."Qty. Invoiced (Base)"); end; end; local procedure UpdateQtyToBeInvoicedForReturnReceipt(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; ReturnReceiptLine: Record "Return Receipt Line"; InvoicingTrackingSpecification: Record "Tracking Specification") var IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateQtyToBeInvoicedForReturnReceipt( QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, SalesLine, ReturnReceiptLine, InvoicingTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, IsHandled); if IsHandled then exit; if TrackingSpecificationExists then begin QtyToBeInvoiced := InvoicingTrackingSpecification."Qty. to Invoice"; QtyToBeInvoicedBase := InvoicingTrackingSpecification."Qty. to Invoice (Base)"; end else begin QtyToBeInvoiced := RemQtyToBeInvoiced - SalesLine."Return Qty. to Receive"; QtyToBeInvoicedBase := RemQtyToBeInvoicedBase - SalesLine."Return Qty. to Receive (Base)"; end; OnUpdateQtyToBeInvoicedForReturnReceiptOnAfterSetQtyToBeInvoiced(TrackingSpecificationExists, QtyToBeInvoiced, QtyToBeInvoicedBase, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, SalesLine); if Abs(QtyToBeInvoiced) > Abs(ReturnReceiptLine.Quantity - ReturnReceiptLine."Quantity Invoiced") then begin QtyToBeInvoiced := ReturnReceiptLine.Quantity - ReturnReceiptLine."Quantity Invoiced"; QtyToBeInvoicedBase := ReturnReceiptLine."Quantity (Base)" - ReturnReceiptLine."Qty. Invoiced (Base)"; end; end; local procedure UpdateRemainingQtyToBeInvoiced(SalesShptLine: Record "Sales Shipment Line"; var RemQtyToInvoiceCurrLine: Decimal; var RemQtyToInvoiceCurrLineBase: Decimal) var IsHandled: Boolean; begin OnBeforeUpdateRemainingQtyToBeInvoiced(SalesShptLine, RemQtyToInvoiceCurrLine, RemQtyToInvoiceCurrLineBase, IsHandled); if IsHandled then exit; RemQtyToInvoiceCurrLine := -SalesShptLine.Quantity + SalesShptLine."Quantity Invoiced"; RemQtyToInvoiceCurrLineBase := -SalesShptLine."Quantity (Base)" + SalesShptLine."Qty. Invoiced (Base)"; if RemQtyToInvoiceCurrLine < RemQtyToBeInvoiced then begin RemQtyToInvoiceCurrLine := RemQtyToBeInvoiced; RemQtyToInvoiceCurrLineBase := RemQtyToBeInvoicedBase; end; end; local procedure IsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var HasATOShippedNotInvoiced: Boolean; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; SalesLine: Record "Sales Line") Result: Boolean var IsHandled: Boolean; begin IsHandled := false; OnBeforeIsEndLoopForShippedNotInvoiced( RemQtyToBeInvoiced, TrackingSpecificationExists, HasATOShippedNotInvoiced, SalesShptLine, InvoicingTrackingSpecification, ItemLedgEntryNotInvoiced, SalesLine, Result, IsHandled); if IsHandled then exit(Result); if TrackingSpecificationExists then exit((InvoicingTrackingSpecification.Next() = 0) or (RemQtyToBeInvoiced = 0)); if HasATOShippedNotInvoiced then begin HasATOShippedNotInvoiced := ItemLedgEntryNotInvoiced.Next() <> 0; if not HasATOShippedNotInvoiced then exit(not SalesShptLine.FindSet() or (Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Qty. to Ship"))); exit(Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Qty. to Ship")); end; IsHandled := false; OnIsEndLoopForShippedNotInvoicedOnBeforeExit(SalesLine, SalesShptLine, RemQtyToBeInvoiced, Result, IsHandled); if IsHandled then exit(Result); exit((SalesShptLine.Next() = 0) or (Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Qty. to Ship"))); end; /// <summary> /// Retrieves the Item Entry Relation and Sales Shipment Line that are related to the item entry /// If tracking specification exists, they are retrieved from the tracking specification information /// If there are assembly-to-order shipped not invoiced lines, they are retrieved from the assembly-to-order shipped not invoiced item ledger entry information /// </summary> /// <remarks> /// If tracking specification doesn't exist, and there are no assembly-to-order shipped not invoiced lines, Item Entry Relation is assigned the Item Shipment Entry No. from the incoming Sales Shipment Line /// </remarks> /// <param name="ItemEntryRelation">Return value: Item Entry Relation related to the Item Entry</param> /// <param name="SalesShptLine">Return value: Sales Shipment Line related to the Item Entry</param> /// <param name="InvoicingTrackingSpecification">Tracking Specification for the Item Ledger Entry</param> /// <param name="ItemLedgEntryNotInvoiced">An assemble-to-order Item Ledger Entry that is shipped, but not invoiced.</param> /// <param name="TrackingSpecificationExists">Indicates whether the Item Ledger Entry has a Tracking Specification</param> /// <param name="HasATOShippedNotInvoiced">Indicates whether there are Assembly-to-order Shipped Not Invoiced lines</param> procedure SetItemEntryRelation(var ItemEntryRelation: Record "Item Entry Relation"; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean) var IsHandled: Boolean; begin IsHandled := false; OnBeforeSetItemEntryRelation(ItemEntryRelation, SalesShptLine, InvoicingTrackingSpecification, IsHandled); if IsHandled then exit; if TrackingSpecificationExists then begin ItemEntryRelation.Get(InvoicingTrackingSpecification."Item Ledger Entry No."); SalesShptLine.Get(ItemEntryRelation."Source ID", ItemEntryRelation."Source Ref. No."); end else if HasATOShippedNotInvoiced then begin ItemEntryRelation."Item Entry No." := ItemLedgEntryNotInvoiced."Entry No."; SalesShptLine.Get(ItemLedgEntryNotInvoiced."Document No.", ItemLedgEntryNotInvoiced."Document Line No."); end else ItemEntryRelation."Item Entry No." := SalesShptLine."Item Shpt. Entry No."; end; local procedure PostATOAssocItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PostedATOLink: Record "Posted Assemble-to-Order Link"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal) var DummyTrackingSpecification: Record "Tracking Specification"; IsHandled: Boolean; begin IsHandled := false; OnBeforePostATOAssocItemJnlLine(SalesHeader, SalesLine, PostedATOLink, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, ItemLedgShptEntryNo, IsHandled); if IsHandled then exit; DummyTrackingSpecification.Init(); if SalesLine."Document Type" = SalesLine."Document Type"::Order then begin PostedATOLink."Assembled Quantity" := -PostedATOLink."Assembled Quantity"; PostedATOLink."Assembled Quantity (Base)" := -PostedATOLink."Assembled Quantity (Base)"; if Abs(RemQtyToBeInvoiced) >= Abs(PostedATOLink."Assembled Quantity") then begin ItemLedgShptEntryNo := PostItemJnlLine( SalesHeader, SalesLine, PostedATOLink."Assembled Quantity", PostedATOLink."Assembled Quantity (Base)", PostedATOLink."Assembled Quantity", PostedATOLink."Assembled Quantity (Base)", 0, '', DummyTrackingSpecification, true); RemQtyToBeInvoiced -= PostedATOLink."Assembled Quantity"; RemQtyToBeInvoicedBase -= PostedATOLink."Assembled Quantity (Base)"; end else begin if RemQtyToBeInvoiced <> 0 then ItemLedgShptEntryNo := PostItemJnlLine( SalesHeader, SalesLine, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, 0, '', DummyTrackingSpecification, true); OnPostATOAssocItemJnlLineOnBeforeRemainingPost( SalesHeader, SalesLine, PostedATOLink, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, ItemLedgShptEntryNo); ItemLedgShptEntryNo := PostItemJnlLine( SalesHeader, SalesLine, PostedATOLink."Assembled Quantity" - RemQtyToBeInvoiced, PostedATOLink."Assembled Quantity (Base)" - RemQtyToBeInvoicedBase, 0, 0, 0, '', DummyTrackingSpecification, true); RemQtyToBeInvoiced := 0; RemQtyToBeInvoicedBase := 0; end; end; end; local procedure GetOpenLinkedATOs(var TempAsmHeader: Record "Assembly Header" temporary) var TempSalesLine: Record "Sales Line" temporary; AsmHeader: Record "Assembly Header"; begin ResetTempLines(TempSalesLine); if TempSalesLine.FindSet() then repeat if TempSalesLine.AsmToOrderExists(AsmHeader) then if AsmHeader.Status = AsmHeader.Status::Open then begin TempAsmHeader.TransferFields(AsmHeader); TempAsmHeader.Insert(); end; until TempSalesLine.Next() = 0; end; local procedure ReopenAsmOrders(var TempAsmHeader: Record "Assembly Header" temporary) var AsmHeader: Record "Assembly Header"; begin if TempAsmHeader.Find('-') then repeat AsmHeader.Get(TempAsmHeader."Document Type", TempAsmHeader."No."); AsmHeader.Status := AsmHeader.Status::Open; AsmHeader.Modify(); until TempAsmHeader.Next() = 0; end; local procedure InitPostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") var AsmHeader: Record "Assembly Header"; Window: Dialog; IsHandled: Boolean; begin IsHandled := false; OnBeforeInitPostATO(SalesHeader, SalesLine, AsmPost, HideProgressWindow, IsHandled); if IsHandled then exit; if SalesLine.AsmToOrderExists(AsmHeader) then begin if GuiAllowed() and not HideProgressWindow then begin Window.Open(AssemblyCheckProgressMsg); Window.Update(1, StrSubstNo('%1 %2 %3 %4', SalesLine."Document Type", SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No.")); Window.Update(2, StrSubstNo('%1 %2', AsmHeader."Document Type", AsmHeader."No.")); end; SalesLine.CheckAsmToOrder(AsmHeader); if not HasQtyToAsm(SalesLine, AsmHeader) then exit; AsmPost.SetSuppressCommit(SuppressCommit); AsmPost.SetPostingDate(true, SalesHeader."Posting Date"); AsmPost.InitPostATO(AsmHeader); if GuiAllowed() and not HideProgressWindow then Window.Close(); end; end; local procedure InitPostATOs(SalesHeader: Record "Sales Header") var TempSalesLine: Record "Sales Line" temporary; begin FindNotShippedLines(SalesHeader, TempSalesLine); TempSalesLine.SetFilter("Qty. to Assemble to Order", '<>0'); if TempSalesLine.FindSet() then repeat InitPostATO(SalesHeader, TempSalesLine); until TempSalesLine.Next() = 0; end; local procedure PostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary) var AsmHeader: Record "Assembly Header"; PostedATOLink: Record "Posted Assemble-to-Order Link"; Window: Dialog; IsHandled: Boolean; begin IsHandled := false; OnBeforePostATO(SalesHeader, SalesLine, TempPostedATOLink, AsmPost, ItemJnlPostLine, ResJnlPostLine, WhseJnlPostLine, HideProgressWindow, IsHandled); if IsHandled then exit; if SalesLine.AsmToOrderExists(AsmHeader) then begin if GuiAllowed() and not HideProgressWindow then begin Window.Open(AssemblyPostProgressMsg); Window.Update(1, StrSubstNo('%1 %2 %3 %4', SalesLine."Document Type", SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No.")); Window.Update(2, StrSubstNo('%1 %2', AsmHeader."Document Type", AsmHeader."No.")); end; SalesLine.CheckAsmToOrder(AsmHeader); if not HasQtyToAsm(SalesLine, AsmHeader) then exit; if AsmHeader."Remaining Quantity (Base)" = 0 then exit; PostedATOLink.Init(); PostedATOLink."Assembly Document Type" := PostedATOLink."Assembly Document Type"::Assembly; PostedATOLink."Assembly Document No." := AsmHeader."Posting No."; PostedATOLink."Document Type" := PostedATOLink."Document Type"::"Sales Shipment"; PostedATOLink."Document No." := SalesHeader."Shipping No."; PostedATOLink."Document Line No." := SalesLine."Line No."; PostedATOLink."Assembly Order No." := AsmHeader."No."; PostedATOLink."Order No." := SalesLine."Document No."; PostedATOLink."Order Line No." := SalesLine."Line No."; PostedATOLink."Assembled Quantity" := AsmHeader."Quantity to Assemble"; PostedATOLink."Assembled Quantity (Base)" := AsmHeader."Quantity to Assemble (Base)"; OnPostATOOnBeforePostedATOLinkInsert(PostedATOLink, AsmHeader, SalesLine); PostedATOLink.Insert(); TempPostedATOLink := PostedATOLink; TempPostedATOLink.Insert(); AsmPost.PostATO(AsmHeader, ItemJnlPostLine, ResJnlPostLine, WhseJnlPostLine); if GuiAllowed() and not HideProgressWindow then Window.Close(); end; end; local procedure FinalizePostATO(var SalesLine: Record "Sales Line") var ATOLink: Record "Assemble-to-Order Link"; AsmHeader: Record "Assembly Header"; Window: Dialog; IsHandled: Boolean; begin OnBeforeFinalizePostATO(SalesLine, IsHandled); if IsHandled then exit; if SalesLine.AsmToOrderExists(AsmHeader) then begin if GuiAllowed() and not HideProgressWindow then begin Window.Open(AssemblyFinalizeProgressMsg); Window.Update(1, StrSubstNo('%1 %2 %3 %4', SalesLine."Document Type", SalesLine."Document No.", SalesLine.FieldCaption("Line No."), SalesLine."Line No.")); Window.Update(2, StrSubstNo('%1 %2', AsmHeader."Document Type", AsmHeader."No.")); end; SalesLine.CheckAsmToOrder(AsmHeader); AsmHeader.TestField("Remaining Quantity (Base)", 0); AsmPost.FinalizePostATO(AsmHeader); ATOLink.Get(AsmHeader."Document Type", AsmHeader."No."); ATOLink.Delete(); if GuiAllowed() and not HideProgressWindow then Window.Close(); end; end; local procedure CheckATOLink(SalesLine: Record "Sales Line") var AsmHeader: Record "Assembly Header"; IsHandled: Boolean; begin OnBeforeCheckATOLink(SalesLine, IsHandled); if IsHandled then exit; if SalesLine."Qty. to Asm. to Order (Base)" = 0 then exit; if SalesLine.AsmToOrderExists(AsmHeader) then SalesLine.CheckAsmToOrder(AsmHeader); end; local procedure DeleteATOLinks(SalesHeader: Record "Sales Header") var ATOLink: Record "Assemble-to-Order Link"; IsHandled: Boolean; begin OnBeforeDeleteATOLinks(SalesHeader, IsHandled); if IsHandled then exit; ATOLink.SetCurrentKey(ATOLink.Type, ATOLink."Document Type", ATOLink."Document No."); ATOLink.SetRange(ATOLink.Type, ATOLink.Type::Sale); ATOLink.SetRange(ATOLink."Document Type", SalesHeader."Document Type"); ATOLink.SetRange(ATOLink."Document No.", SalesHeader."No."); if not ATOLink.IsEmpty() then ATOLink.DeleteAll(); end; local procedure HasQtyToAsm(SalesLine: Record "Sales Line"; AsmHeader: Record "Assembly Header"): Boolean begin if SalesLine."Qty. to Asm. to Order (Base)" = 0 then exit(false); if SalesLine."Qty. to Ship (Base)" = 0 then exit(false); if AsmHeader."Quantity to Assemble (Base)" = 0 then exit(false); exit(true); end; local procedure GetATOItemLedgEntriesNotInvoiced(SalesLine: Record "Sales Line"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"): Boolean var PostedATOLink: Record "Posted Assemble-to-Order Link"; ItemLedgEntry: Record "Item Ledger Entry"; begin ItemLedgEntryNotInvoiced.Reset(); ItemLedgEntryNotInvoiced.DeleteAll(); if PostedATOLink.FindLinksFromSalesLine(SalesLine) then repeat ItemLedgEntry.SetCurrentKey("Document No.", "Document Type", "Document Line No."); ItemLedgEntry.SetRange("Document Type", ItemLedgEntry."Document Type"::"Sales Shipment"); ItemLedgEntry.SetRange("Document No.", PostedATOLink."Document No."); ItemLedgEntry.SetRange("Document Line No.", PostedATOLink."Document Line No."); ItemLedgEntry.SetRange("Assemble to Order", true); ItemLedgEntry.SetRange("Completely Invoiced", false); if ItemLedgEntry.FindSet() then repeat if ItemLedgEntry.Quantity <> ItemLedgEntry."Invoiced Quantity" then begin ItemLedgEntryNotInvoiced := ItemLedgEntry; OnGetATOItemLedgEntriesNotInvoicedOnBeforeItemLedgEntryNotInvoicedInsert(ItemLedgEntryNotInvoiced); ItemLedgEntryNotInvoiced.Insert(); end; until ItemLedgEntry.Next() = 0; until PostedATOLink.Next() = 0; exit(ItemLedgEntryNotInvoiced.FindSet()); end; /// <summary> /// Sets the Warehouse Journal Register Line codeunit to the global variable /// The codeunit is used when posting Warehouse Journal Lines, Assembly Orders and Warehouse Shipments /// </summary> /// <param name="WhseJnlRegisterLine">Warehouse Journal Register Line codeunit to be set</param> procedure SetWhseJnlRegisterCU(var WhseJnlRegisterLine: Codeunit "Whse. Jnl.-Register Line") begin WhseJnlPostLine := WhseJnlRegisterLine; end; local procedure CheckPostWhseShptLines(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line") var WarehouseShipmentLine: Record "Warehouse Shipment Line"; IsHandled: Boolean; WhseShptLinesFound: Boolean; begin IsHandled := false; OnBeforeCheckPostWhseShptLines(SalesShipmentLine, SalesLine, IsHandled, WhseShptHeader, WhseRcptHeader, WhseShip, WhseReceive); if IsHandled then exit; if WhseShip then begin WhseShptLinesFound := WarehouseShipmentLine.GetWhseShptLine( WhseShptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No."); OnCheckPostWhseShptLinesOnAfterWhseShptLinesFound(SalesShipmentLine, SalesLine, WhseShptLinesFound, WhseShptHeader, WhseRcptHeader, WhseShip, WhseReceive, WarehouseShipmentLine); if WhseShptLinesFound then PostWhseShptLines(WarehouseShipmentLine, SalesShipmentLine, SalesLine); end; end; local procedure PostWhseShptLines(var WhseShptLine2: Record "Warehouse Shipment Line"; SalesShptLine2: Record "Sales Shipment Line"; var SalesLine2: Record "Sales Line") var ATOWhseShptLine: Record "Warehouse Shipment Line"; NonATOWhseShptLine: Record "Warehouse Shipment Line"; ATOLineFound: Boolean; NonATOLineFound: Boolean; TotalSalesShptLineQty: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforePostWhseShptLines(WhseShptLine2, SalesShptLine2, SalesLine2, IsHandled, PostedWhseShptHeader); if IsHandled then exit; WhseShptLine2.GetATOAndNonATOLines(ATOWhseShptLine, NonATOWhseShptLine, ATOLineFound, NonATOLineFound); if ATOLineFound then TotalSalesShptLineQty += ATOWhseShptLine."Qty. to Ship"; if NonATOLineFound then TotalSalesShptLineQty += NonATOWhseShptLine."Qty. to Ship"; SalesShptLine2.TestField(Quantity, TotalSalesShptLineQty); SaveTempWhseSplitSpec(SalesLine2, TempATOTrackingSpecification); WhsePostShpt.SetWhseJnlRegisterCU(WhseJnlPostLine); if ATOLineFound and (ATOWhseShptLine."Qty. to Ship (Base)" > 0) then WhsePostShpt.CreatePostedShptLine( ATOWhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification); SaveTempWhseSplitSpec(SalesLine2, TempHandlingSpecification); if NonATOLineFound and (NonATOWhseShptLine."Qty. to Ship (Base)" > 0) then WhsePostShpt.CreatePostedShptLine( NonATOWhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification); end; local procedure GetCountryCode(SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"): Code[10] var SalesShipmentHeader: Record "Sales Shipment Header"; CountryRegionCode: Code[10]; IsHandled: Boolean; begin IsHandled := false; OnBeforeGetCountryCode(SalesHeader, SalesLine, CountryRegionCode, IsHandled); if IsHandled then exit(CountryRegionCode); if SalesLine."Shipment No." <> '' then begin SalesShipmentHeader.Get(SalesLine."Shipment No."); exit( GetCountryRegionCode( SalesLine."Sell-to Customer No.", SalesShipmentHeader."Ship-to Code", SalesShipmentHeader."Sell-to Country/Region Code")); end; if SalesHeader.IsCreditDocType() then begin if not SalesHeader.Receive then begin if (SalesHeader."Ship-to Country/Region Code" <> '') then exit(SalesHeader."Ship-to Country/Region Code") else exit(SalesHeader."Sell-to Country/Region Code"); end else begin if (SalesHeader."Ship-to Country/Region Code" = '') and (SalesHeader."Rcvd.-from Count./Region Code" = '') then exit(SalesHeader."Sell-to Country/Region Code"); if SalesHeader."Rcvd.-from Count./Region Code" <> '' then exit(SalesHeader."Rcvd.-from Count./Region Code"); exit(SalesHeader."Ship-to Country/Region Code"); end; end else begin CountryRegionCode := SalesHeader."Ship-to Country/Region Code"; exit( GetCountryRegionCode( SalesLine."Sell-to Customer No.", SalesHeader."Ship-to Code", CountryRegionCode)); end; end; local procedure GetCountryRegionCode(CustNo: Code[20]; ShipToCode: Code[10]; SellToCountryRegionCode: Code[10]) Result: Code[10] var ShipToAddress: Record "Ship-to Address"; IsHandled: Boolean; begin IsHandled := false; OnBeforeGetCountryRegionCode(CustNo, ShipToCode, SellToCountryRegionCode, Result, IsHandled); if IsHandled then exit(Result); if ShipToCode <> '' then begin ShipToAddress.Get(CustNo, ShipToCode); exit(ShipToAddress."Country/Region Code"); end; exit(SellToCountryRegionCode); end; local procedure UpdateIncomingDocument(IncomingDocNo: Integer; PostingDate: Date; GenJnlLineDocNo: Code[20]) var IncomingDocument: Record "Incoming Document"; begin IncomingDocument.UpdateIncomingDocumentFromPosting(IncomingDocNo, PostingDate, GenJnlLineDocNo); end; local procedure CheckItemCharge(ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)") var SalesLineForCharge: Record "Sales Line"; begin case ItemChargeAssgntSales."Applies-to Doc. Type" of ItemChargeAssgntSales."Applies-to Doc. Type"::Order, ItemChargeAssgntSales."Applies-to Doc. Type"::Invoice: if SalesLineForCharge.Get( ItemChargeAssgntSales."Applies-to Doc. Type", ItemChargeAssgntSales."Applies-to Doc. No.", ItemChargeAssgntSales."Applies-to Doc. Line No.") then if (SalesLineForCharge."Quantity (Base)" = SalesLineForCharge."Qty. Shipped (Base)") and (SalesLineForCharge."Qty. Shipped Not Invd. (Base)" = 0) then Error(ReassignItemChargeErr); ItemChargeAssgntSales."Applies-to Doc. Type"::"Return Order", ItemChargeAssgntSales."Applies-to Doc. Type"::"Credit Memo": if SalesLineForCharge.Get( ItemChargeAssgntSales."Applies-to Doc. Type", ItemChargeAssgntSales."Applies-to Doc. No.", ItemChargeAssgntSales."Applies-to Doc. Line No.") then if (SalesLineForCharge."Quantity (Base)" = SalesLineForCharge."Return Qty. Received (Base)") and (SalesLineForCharge."Ret. Qty. Rcd. Not Invd.(Base)" = 0) then Error(ReassignItemChargeErr); end; end; local procedure CheckItemReservDisruption(SalesLine: Record "Sales Line") var ConfirmManagement: Codeunit "Confirm Management"; AvailableQty: Decimal; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckItemReservDisruption(SalesLine, IsHandled); if IsHandled then exit; if not (SalesLine."Document Type" in [SalesLine."Document Type"::Order, SalesLine."Document Type"::Invoice]) or (SalesLine.Type <> SalesLine.Type::Item) or not (SalesLine."Qty. to Ship (Base)" > 0) then exit; if (SalesLine."Job Contract Entry No." <> 0) or SalesLine.Nonstock or SalesLine."Special Order" or SalesLine."Drop Shipment" or SalesLine.FullQtyIsForAsmToOrder() or TempSKU.Get(SalesLine."Location Code", SalesLine."No.", SalesLine."Variant Code") then exit; if SalesLine.IsNonInventoriableItem() then exit; // For muliple sales order lines, the transaction acquires a lock on the reservation entry table while transfering reservervation entry for the first sales line to the item journal line. This locks the corresponding reserveration entries that are being modified. // Therefore, using ReadUncommitted to calculate "Reserved Qty. on Inventory" will prevent unnecessary locking all the reservation entries for the item at a given location. Item.SetRange("Location Filter", SalesLine."Location Code"); Item.SetRange("Variant Filter", SalesLine."Variant Code"); Item.ReadIsolation := IsolationLevel::ReadUncommitted; Item.CalcFields("Reserved Qty. on Inventory"); if Item."Reserved Qty. on Inventory" <= 0 then exit; Item.ReadIsolation := IsolationLevel::Default; Item.CalcFields("Net Change"); SalesLine.CalcFields("Reserved Qty. (Base)"); AvailableQty := Item."Net Change" - (Item."Reserved Qty. on Inventory" - SalesLine."Reserved Qty. (Base)"); if (AvailableQty < SalesLine."Qty. to Ship (Base)") and (Item."Reserved Qty. on Inventory" > SalesLine."Reserved Qty. (Base)") then begin InsertTempSKU(SalesLine."Location Code", SalesLine."No.", SalesLine."Variant Code"); if Location.BinMandatory(SalesLine."Location Code") then begin Session.LogMessage('0000GKN', ItemReservDisruptionLbl, Verbosity::Warning, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', SalesLinePostCategoryTok); if not ConfirmManagement.GetResponseOrDefault( StrSubstNo( ReservationDisruptedQst, SalesLine.FieldCaption("No."), Item."No.", SalesLine.FieldCaption("Location Code"), SalesLine."Location Code", SalesLine.FieldCaption("Variant Code"), SalesLine."Variant Code"), true) then Error(''); end; end; end; local procedure InsertTempSKU(LocationCode: Code[10]; ItemNo: Code[20]; VariantCode: Code[10]) begin TempSKU.Init(); TempSKU."Location Code" := LocationCode; TempSKU."Item No." := ItemNo; TempSKU."Variant Code" := VariantCode; TempSKU.Insert(); end; /// <summary> /// Initializes the progress window for posting with information about the sales header. /// </summary> /// <param name="SalesHeader">The sales header record for which the progress window is being initialized.</param> procedure InitProgressWindow(SalesHeader: Record "Sales Header") begin if SalesHeader.Invoice then Window.Open( '#1#################################\\' + PostingLinesMsg + PostingSalesAndVATMsg + PostingCustomersMsg + PostingBalAccountMsg) else Window.Open( '#1#################################\\' + PostingLines2Msg); Window.Update(1, StrSubstNo('%1 %2', SalesHeader."Document Type", SalesHeader."No.")); end; local procedure CheckCertificateOfSupplyStatus(SalesShptHeader: Record "Sales Shipment Header"; SalesShptLine: Record "Sales Shipment Line") var CertificateOfSupply: Record "Certificate of Supply"; VATPostingSetup: Record "VAT Posting Setup"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckCertificateOfSupplyStatus(SalesShptHeader, SalesShptLine, IsHandled); if IsHandled then exit; if SalesShptLine.Quantity <> 0 then if VATPostingSetup.Get(SalesShptHeader."VAT Bus. Posting Group", SalesShptLine."VAT Prod. Posting Group") and VATPostingSetup."Certificate of Supply Required" then begin CertificateOfSupply.InitFromSales(SalesShptHeader); CertificateOfSupply.SetRequired(SalesShptHeader."No."); end; end; local procedure InsertPostedHeaders(var SalesHeader: Record "Sales Header") var SalesShptLine: Record "Sales Shipment Line"; PurchRcptLine: Record "Purch. Rcpt. Line"; GenJnlLine: Record "Gen. Journal Line"; PostingPreviewEventHandler: Codeunit "Posting Preview Event Handler"; InsertShipmentHeaderNeeded: Boolean; ShouldInsertInvoiceHeader: Boolean; IsHandled: Boolean; begin if PreviewMode then PostingPreviewEventHandler.PreventCommit(); OnBeforeInsertPostedHeaders(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader); // Insert shipment header InsertShipmentHeaderNeeded := SalesHeader.Ship; OnInsertPostedHeadersOnAfterCalcInsertShipmentHeaderNeeded(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader, InsertShipmentHeaderNeeded); if InsertShipmentHeaderNeeded then begin if (SalesHeader."Document Type" = SalesHeader."Document Type"::Order) or ((SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice) and SalesSetup."Shipment on Invoice") then begin if DropShipOrder then begin PurchRcptHeader.LockTable(); PurchRcptLine.LockTable(); SalesShptHeader.LockTable(); SalesShptLine.LockTable(); end; InsertShipmentHeader(SalesHeader, SalesShptHeader); end; OnInsertPostedHeadersOnAfterInsertShipmentHeader(SalesHeader); end; IsHandled := false; OnInsertPostedHeadersOnBeforeDeleteServItemOnSaleCreditMemo(SalesHeader, SalesShptHeader, IsHandled); if not IsHandled then OnInsertPostedHeadersDeleteServItemOnSaleCreditMemo(SalesHeader); // Insert return receipt header CheckInsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader); IsHandled := false; OnInsertPostedHeadersOnBeforeInsertInvoiceHeader(SalesHeader, IsHandled, SalesInvHeader, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo, InvoicePostingInterface); if not IsHandled then // Insert invoice header or credit memo header if SalesHeader.Invoice then begin ShouldInsertInvoiceHeader := SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::Invoice]; OnInsertPostedHeadersOnAfterCalcShouldInsertInvoiceHeader(SalesHeader, ShouldInsertInvoiceHeader); if ShouldInsertInvoiceHeader then begin InsertInvoiceHeader(SalesHeader, SalesInvHeader); GenJnlLineDocType := GenJnlLine."Document Type"::Invoice; GenJnlLineDocNo := SalesInvHeader."No."; GenJnlLineExtDocNo := SalesInvHeader."External Document No."; OnInsertPostedHeadersOnAfterInsertInvoiceHeader(SalesHeader, SalesInvHeader); end else begin // Credit Memo InsertCrMemoHeader(SalesHeader, SalesCrMemoHeader); GenJnlLineDocType := GenJnlLine."Document Type"::"Credit Memo"; GenJnlLineDocNo := SalesCrMemoHeader."No."; GenJnlLineExtDocNo := SalesCrMemoHeader."External Document No."; OnInsertPostedHeadersOnAfterInsertCrMemoHeader(SalesHeader, SalesCrMemoHeader); end; GetInvoicePostingParameters(); InvoicePostingInterface.SetParameters(InvoicePostingParameters); end; OnAfterInsertPostedHeaders(SalesHeader, SalesShptHeader, SalesInvHeader, SalesCrMemoHeader, ReturnRcptHeader, GenJnlLineDocType, GenJnlLineDocNo, GenJnlLineExtDocNo); end; local procedure InsertShipmentHeader(var SalesHeader: Record "Sales Header"; var SalesShptHeader: Record "Sales Shipment Header") var SalesCommentLine: Record "Sales Comment Line"; RecordLinkManagement: Codeunit "Record Link Management"; begin SalesShptHeader.Init(); SalesHeader.CalcFields("Work Description"); OnInsertShipmentHeaderOnBeforeTransferfieldsToSalesShptHeader(SalesHeader); SalesShptHeader.TransferFields(SalesHeader); OnInsertShipmentHeaderOnAfterTransferfieldsToSalesShptHeader(SalesHeader, SalesShptHeader); AssignPostedDocumentNo(SalesShptHeader."No.", SalesHeader."Shipping No."); if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin SalesShptHeader."Order No. Series" := SalesHeader."No. Series"; SalesShptHeader."Order No." := SalesHeader."No."; if SalesSetup."Ext. Doc. No. Mandatory" then SalesHeader.TestField("External Document No."); end; SalesShptHeader."Source Code" := SrcCode; SalesShptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(SalesShptHeader."User ID")); SalesShptHeader."No. Printed" := 0; SalesShptHeaderInsert(SalesShptHeader, SalesHeader); ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, SalesShptHeader.RecordId, SalesShptHeader."No."); if SalesSetup."Copy Comments Order to Shpt." then begin SalesCommentLine.CopyComments( SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::Shipment.AsInteger(), SalesHeader."No.", SalesShptHeader."No."); RecordLinkManagement.CopyLinks(SalesHeader, SalesShptHeader); end; if WhseShip then begin WhseShptHeader.Get(TempWhseShptHeader."No."); OnBeforeCreatePostedWhseShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader); WhsePostShpt.CreatePostedShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader."Shipping No.", SalesHeader."Posting Date"); end; if WhseReceive then begin WhseRcptHeader.Get(TempWhseRcptHeader."No."); OnBeforeCreatePostedWhseRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader); WhsePostRcpt.CreatePostedRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader."Shipping No.", SalesHeader."Posting Date"); end; OnAfterInsertShipmentHeader(SalesHeader, SalesShptHeader); end; local procedure CheckInsertReturnReceiptHeader(var SalesHeader: Record "Sales Header"; var ReturnRcptHeader: Record "Return Receipt Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckInsertReturnReceiptHeader(SalesHeader, IsHandled); if IsHandled then exit; if SalesHeader.Receive then if (SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order") or ((SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") and SalesSetup."Return Receipt on Credit Memo") then InsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader); end; local procedure InsertReturnReceiptHeader(var SalesHeader: Record "Sales Header"; var ReturnRcptHeader: Record "Return Receipt Header") var SalesCommentLine: Record "Sales Comment Line"; RecordLinkManagement: Codeunit "Record Link Management"; IsHandled: Boolean; begin OnBeforeInsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader, IsHandled, SuppressCommit); if not IsHandled then begin ReturnRcptHeader.Init(); OnInsertReturnReceiptHeaderOnBeforeReturnReceiptHeaderTransferFields(SalesHeader); ReturnRcptHeader.TransferFields(SalesHeader); AssignPostedDocumentNo(ReturnRcptHeader."No.", SalesHeader."Return Receipt No."); if SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order" then begin ReturnRcptHeader."Return Order No. Series" := SalesHeader."No. Series"; ReturnRcptHeader."Return Order No." := SalesHeader."No."; if SalesSetup."Ext. Doc. No. Mandatory" then SalesHeader.TestField("External Document No."); end; ReturnRcptHeader."No. Series" := SalesHeader."Return Receipt No. Series"; ReturnRcptHeader."Source Code" := SrcCode; ReturnRcptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(ReturnRcptHeader."User ID")); ReturnRcptHeader."No. Printed" := 0; OnBeforeReturnRcptHeaderInsert(ReturnRcptHeader, SalesHeader, SuppressCommit, TempWhseRcptHeader, WhseReceive, TempWhseShptHeader, WhseShip); ReturnRcptHeader.Insert(true); OnAfterReturnRcptHeaderInsert(ReturnRcptHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader); ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, ReturnRcptHeader.RecordId, ReturnRcptHeader."No."); if SalesSetup."Copy Cmts Ret.Ord. to Ret.Rcpt" then begin SalesCommentLine.CopyComments( SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::"Posted Return Receipt".AsInteger(), SalesHeader."No.", ReturnRcptHeader."No."); RecordLinkManagement.CopyLinks(SalesHeader, ReturnRcptHeader); end; end; if WhseReceive then begin WhseRcptHeader.Get(TempWhseRcptHeader."No."); OnBeforeCreatePostedWhseRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader); WhsePostRcpt.CreatePostedRcptHeader(PostedWhseRcptHeader, WhseRcptHeader, SalesHeader."Return Receipt No.", SalesHeader."Posting Date"); end; if WhseShip then begin WhseShptHeader.Get(TempWhseShptHeader."No."); OnBeforeCreatePostedWhseShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader); WhsePostShpt.CreatePostedShptHeader(PostedWhseShptHeader, WhseShptHeader, SalesHeader."Return Receipt No.", SalesHeader."Posting Date"); end; OnAfterInsertReturnReceiptHeader(SalesHeader, ReturnRcptHeader); end; local procedure InsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header") var SalesCommentLine: Record "Sales Comment Line"; RecordLinkManagement: Codeunit "Record Link Management"; SegManagement: Codeunit SegManagement; IsHandled: Boolean; begin IsHandled := false; OnBeforeInsertInvoiceHeader(SalesHeader, SalesInvHeader, IsHandled); if IsHandled then exit; SalesInvHeader.Init(); SalesHeader.CalcFields("Work Description"); OnInsertInvoiceHeaderOnBeforeSalesInvHeaderTransferFields(SalesHeader); SalesInvHeader.TransferFields(SalesHeader); OnInsertInvoiceHeaderOnAfterSalesInvHeaderTransferFields(SalesHeader, SalesInvHeader); AssignPostedDocumentNo(SalesInvHeader."No.", SalesHeader."Posting No."); IsHandled := false; OnInsertInvoiceHeaderOnBeforeCheckDocumentType(SalesHeader, SalesInvHeader, SalesSetup, IsHandled); if not IsHandled then if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then begin if SalesSetup."Ext. Doc. No. Mandatory" then SalesHeader.TestField("External Document No."); SalesInvHeader."Pre-Assigned No. Series" := ''; SalesInvHeader."Order No. Series" := SalesHeader."No. Series"; SalesInvHeader."Order No." := SalesHeader."No."; end else begin if SalesHeader."Posting No." = '' then AssignPostedDocumentNo(SalesInvHeader."No.", SalesHeader."No."); SalesInvHeader."Pre-Assigned No. Series" := SalesHeader."No. Series"; SalesInvHeader."Pre-Assigned No." := SalesHeader."No."; end; if GuiAllowed() and not HideProgressWindow then Window.Update(1, StrSubstNo(InvoiceNoMsg, SalesHeader."Document Type", SalesHeader."No.", SalesInvHeader."No.")); SalesInvHeader."Source Code" := SrcCode; SalesInvHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(SalesInvHeader."User ID")); SalesInvHeader."No. Printed" := 0; if SalesHeader."Document Type" = SalesHeader."Document Type"::Invoice then SalesInvHeader."Draft Invoice SystemId" := SalesHeader.SystemId; SalesInvHeaderInsert(SalesInvHeader, SalesHeader); UpdateWonOpportunities(SalesHeader); SegManagement.CreateCampaignEntryOnSalesInvoicePosting(SalesInvHeader); ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, SalesInvHeader.RecordId, SalesInvHeader."No."); if SalesSetup."Copy Comments Order to Invoice" then begin SalesCommentLine.CopyComments( SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::"Posted Invoice".AsInteger(), SalesHeader."No.", SalesInvHeader."No."); RecordLinkManagement.CopyLinks(SalesHeader, SalesInvHeader); end; OnAfterInsertInvoiceHeader(SalesHeader, SalesInvHeader); end; local procedure InsertCrMemoHeader(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header") var SalesCommentLine: Record "Sales Comment Line"; RecordLinkManagement: Codeunit "Record Link Management"; ShouldProcessAsReturnOrder: Boolean; begin SalesCrMemoHeader.Init(); SalesHeader.CalcFields("Work Description"); OnInsertCrMemoHeaderOnBeforeSalesCrMemoHeaderTransferFields(SalesHeader); SalesCrMemoHeader.TransferFields(SalesHeader); AssignPostedDocumentNo(SalesCrMemoHeader."No.", SalesHeader."No."); OnInsertCrMemoHeaderOnAfterSalesCrMemoHeaderTransferFields(SalesHeader, SalesCrMemoHeader); ShouldProcessAsReturnOrder := SalesHeader."Document Type" = SalesHeader."Document Type"::"Return Order"; OnInsertCrMemoHeaderOnAfterCalcShouldProcessAsReturnOrder(SalesHeader, ShouldProcessAsReturnOrder); if ShouldProcessAsReturnOrder then begin AssignPostedDocumentNo(SalesCrMemoHeader."No.", SalesHeader."Posting No."); if SalesSetup."Ext. Doc. No. Mandatory" then SalesHeader.TestField("External Document No."); SalesCrMemoHeader."Pre-Assigned No. Series" := ''; SalesCrMemoHeader."Return Order No. Series" := SalesHeader."No. Series"; SalesCrMemoHeader."Return Order No." := SalesHeader."No."; if GuiAllowed() and not HideProgressWindow then Window.Update(1, StrSubstNo(CreditMemoNoMsg, SalesHeader."Document Type", SalesHeader."No.", SalesCrMemoHeader."No.")); end else begin SalesCrMemoHeader."Pre-Assigned No. Series" := SalesHeader."No. Series"; SalesCrMemoHeader."Pre-Assigned No." := SalesHeader."No."; if SalesHeader."Posting No." <> '' then begin AssignPostedDocumentNo(SalesCrMemoHeader."No.", SalesHeader."Posting No."); if GuiAllowed() and not HideProgressWindow then Window.Update(1, StrSubstNo(CreditMemoNoMsg, SalesHeader."Document Type", SalesHeader."No.", SalesCrMemoHeader."No.")); end; end; SalesCrMemoHeader."Source Code" := SrcCode; SalesCrMemoHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(SalesCrMemoHeader."User ID")); SalesCrMemoHeader."No. Printed" := 0; SalesCrMemoHeader."Draft Cr. Memo SystemId" := SalesCrMemoHeader.SystemId; SalesCrMemoHeaderInsert(SalesCrMemoHeader, SalesHeader); ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, SalesCrMemoHeader.RecordId, SalesCrMemoHeader."No."); if SalesSetup."Copy Cmts Ret.Ord. to Cr. Memo" then begin SalesCommentLine.CopyComments( SalesHeader."Document Type".AsInteger(), SalesCommentLine."Document Type"::"Posted Credit Memo".AsInteger(), SalesHeader."No.", SalesCrMemoHeader."No."); RecordLinkManagement.CopyLinks(SalesHeader, SalesCrMemoHeader); end; OnAfterInsertCrMemoHeader(SalesHeader, SalesCrMemoHeader); end; local procedure InsertPurchRcptHeader(var PurchaseHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header") var RunOnInsert: Boolean; begin PurchRcptHeader.Init(); PurchRcptHeader.TransferFields(PurchaseHeader); AssignPostedDocumentNo(PurchRcptHeader."No.", PurchaseHeader."Receiving No."); PurchRcptHeader."Order No." := PurchaseHeader."No."; PurchRcptHeader."Posting Date" := SalesHeader."Posting Date"; PurchRcptHeader."Document Date" := SalesHeader."Document Date"; PurchRcptHeader."No. Printed" := 0; RunOnInsert := false; OnBeforePurchRcptHeaderInsert(PurchRcptHeader, PurchaseHeader, SalesHeader, SuppressCommit, RunOnInsert); PurchRcptHeader.Insert(RunOnInsert); OnAfterPurchRcptHeaderInsert(PurchRcptHeader, PurchaseHeader, SalesHeader, SuppressCommit); end; local procedure InsertPurchRcptLine(PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer") var PurchRcptLine: Record "Purch. Rcpt. Line"; begin PurchRcptLine.Init(); PurchRcptLine.TransferFields(PurchOrderLine); PurchRcptLine."Posting Date" := PurchRcptHeader."Posting Date"; PurchRcptLine."Document No." := PurchRcptHeader."No."; PurchRcptLine.Quantity := DropShptPostBuffer.Quantity; PurchRcptLine."Quantity (Base)" := DropShptPostBuffer."Quantity (Base)"; PurchRcptLine."Quantity Invoiced" := 0; PurchRcptLine."Qty. Invoiced (Base)" := 0; PurchRcptLine."Order No." := PurchOrderLine."Document No."; PurchRcptLine."Order Line No." := PurchOrderLine."Line No."; PurchRcptLine."Qty. Rcd. Not Invoiced" := PurchRcptLine.Quantity - PurchRcptLine."Quantity Invoiced"; if PurchRcptLine.Quantity <> 0 then begin PurchRcptLine."Item Rcpt. Entry No." := DropShptPostBuffer."Item Shpt. Entry No."; PurchRcptLine."Item Charge Base Amount" := PurchOrderLine."Line Amount" end; PurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchOrderLine, DropShptPostBuffer); end; local procedure PurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer") var IsHandled: Boolean; begin IsHandled := false; OnBeforePurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchOrderLine, DropShptPostBuffer, SuppressCommit, TempSalesLineGlobal, IsHandled); if IsHandled then exit; PurchRcptLine.Insert(); OnAfterPurchRcptLineInsert(PurchRcptLine, PurchRcptHeader, PurchOrderLine, DropShptPostBuffer, SuppressCommit, TempSalesLineGlobal); end; local procedure InsertShipmentLine(var SalesHeader: Record "Sales Header"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; CostBaseAmount: Decimal) var SalesShptLine: Record "Sales Shipment Line"; IsHandled: Boolean; ShouldProcessShipmentRelation: Boolean; begin IsHandled := false; OnBeforeInsertShipmentLine(SalesHeader, SalesLine, IsHandled); if IsHandled then exit; SalesShptLine.InitFromSalesLine(SalesShptHeader, xSalesLine); SalesShptLine."Quantity Invoiced" := -RemQtyToBeInvoiced; SalesShptLine."Qty. Invoiced (Base)" := -RemQtyToBeInvoicedBase; SalesShptLine."Qty. Shipped Not Invoiced" := SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced"; OnInsertShipmentLineOnAfterInitQuantityFields(SalesLine, xSalesLine, SalesShptLine); ShouldProcessShipmentRelation := (SalesLine.Type = SalesLine.Type::Item) and (SalesLine."Qty. to Ship" <> 0); OnInsertShipmentLineOnAfterCalcShouldProcessShipmentRelation(SalesLine, ShouldProcessShipmentRelation); if ShouldProcessShipmentRelation then begin CheckPostWhseShptLines(SalesShptLine, SalesLine); CheckPostWhseRcptLineFromShipmentLine(SalesLine, SalesShptLine); SalesShptLine."Item Shpt. Entry No." := InsertShptEntryRelation(SalesHeader, SalesShptLine); // ItemLedgShptEntryNo SalesShptLine."Item Charge Base Amount" := Round(CostBaseAmount / SalesLine.Quantity * SalesShptLine.Quantity); end; SalesShptLineInsert(SalesShptLine, SalesShptHeader, SalesLine, SalesHeader); CheckCertificateOfSupplyStatus(SalesShptHeader, SalesShptLine); OnInvoiceSalesShptLine(SalesShptLine, SalesInvHeader."No.", xSalesLine."Line No.", xSalesLine."Qty. to Invoice", SuppressCommit); OnAfterInsertShipmentLine(SalesHeader, SalesLine, SalesShptLine, PreviewMode, xSalesLine); end; local procedure CheckPostWhseRcptLineFromShipmentLine(var SalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line") var WhseRcptLine: Record "Warehouse Receipt Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckPostWhseRcptLineFromShipmentLine(SalesShptLine, SalesLine, IsHandled); if IsHandled then exit; if WhseReceive then if WhseRcptLine.GetWhseRcptLine( WhseRcptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.") then PostWhseRcptLineFromShipmentLine(WhseRcptLine, SalesLine, SalesShptLine); end; local procedure PostWhseRcptLineFromShipmentLine(var WhseRcptLine: Record "Warehouse Receipt Line"; var SalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforePostWhseRcptLineFromShipmentLine(WhseRcptLine, SalesShptLine, SalesLine, IsHandled, PostedWhseRcptHeader); if IsHandled then exit; WhseRcptLine.TestField("Qty. to Receive", -SalesShptLine.Quantity); SaveTempWhseSplitSpec(SalesLine, TempHandlingSpecification); WhsePostRcpt.CreatePostedRcptLine( WhseRcptLine, PostedWhseRcptHeader, PostedWhseRcptLine, TempWhseSplitSpecification); end; local procedure InsertReturnReceiptLine(ReturnRcptHeader: Record "Return Receipt Header"; SalesLine: Record "Sales Line"; CostBaseAmount: Decimal; var SalesHeader: Record "Sales Header") var ReturnRcptLine: Record "Return Receipt Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforeInsertReturnReceiptLine(SalesLine, ReturnRcptLine, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase, IsHandled); if not IsHandled then begin ReturnRcptLine.InitFromSalesLine(ReturnRcptHeader, xSalesLine); ReturnRcptLine."Quantity Invoiced" := RemQtyToBeInvoiced; ReturnRcptLine."Qty. Invoiced (Base)" := RemQtyToBeInvoicedBase; ReturnRcptLine."Return Qty. Rcd. Not Invd." := ReturnRcptLine.Quantity - ReturnRcptLine."Quantity Invoiced"; InsertReturnReceiptLineWhsePost(SalesLine, ReturnRcptHeader, ReturnRcptLine, CostBaseAmount); OnBeforeReturnRcptLineInsert(ReturnRcptLine, ReturnRcptHeader, SalesLine, SuppressCommit, xSalesLine, TempSalesLineGlobal, SalesHeader); ReturnRcptLine.Insert(true); end; OnAfterReturnRcptLineInsert( ReturnRcptLine, ReturnRcptHeader, SalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, SalesCrMemoHeader, TempWhseShptHeader, TempWhseRcptHeader, SalesHeader); end; local procedure InsertReturnReceiptLineWhsePost(var SalesLine: Record "Sales Line"; ReturnRcptHeader: Record "Return Receipt Header"; var ReturnRcptLine: Record "Return Receipt Line"; CostBaseAmount: Decimal) var WhseShptLine: Record "Warehouse Shipment Line"; WhseRcptLine: Record "Warehouse Receipt Line"; ShouldGetWhseRcptLine: Boolean; ShouldGetWhseShptLine: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeInsertReturnReceiptLineWhsePost(SalesLine, ReturnRcptHeader, WhseShip, WhseReceive, TempWhseRcptHeader, IsHandled, ReturnRcptLine, xSalesLine, PostedWhseRcptHeader, WhseRcptHeader, CostBaseAmount); if IsHandled then exit; if (SalesLine.Type = SalesLine.Type::Item) and (SalesLine."Return Qty. to Receive" <> 0) then begin ShouldGetWhseRcptLine := WhseReceive and SalesLine.IsInventoriableItem(); OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseRcptLine(ReturnRcptLine, SalesLine, WhseShip, WhseReceive, ReturnRcptHeader, ShouldGetWhseRcptLine); if ShouldGetWhseRcptLine then if WhseRcptLine.GetWhseRcptLine( WhseRcptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.") then begin WhseRcptLine.TestField("Qty. to Receive", ReturnRcptLine.Quantity); SaveTempWhseSplitSpec(SalesLine, TempHandlingSpecification); OnInsertReturnReceiptLineOnBeforeCreatePostedRcptLine(SalesLine, ReturnRcptLine, WhseRcptLine, PostedWhseRcptHeader); WhsePostRcpt.CreatePostedRcptLine( WhseRcptLine, PostedWhseRcptHeader, PostedWhseRcptLine, TempWhseSplitSpecification); end; ShouldGetWhseShptLine := WhseShip and SalesLine.IsInventoriableItem(); OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseShptLine(ReturnRcptLine, SalesLine, WhseShip, WhseReceive, ReturnRcptHeader, ShouldGetWhseShptLine); if ShouldGetWhseShptLine then if WhseShptLine.GetWhseShptLine( WhseShptHeader."No.", DATABASE::"Sales Line", SalesLine."Document Type".AsInteger(), SalesLine."Document No.", SalesLine."Line No.") then begin WhseShptLine.TestField("Qty. to Ship", -ReturnRcptLine.Quantity); SaveTempWhseSplitSpec(SalesLine, TempHandlingSpecification); WhsePostShpt.SetWhseJnlRegisterCU(WhseJnlPostLine); OnInsertReturnReceiptLineWhsePostOnBeforeCreatePostedShptLine(ReturnRcptLine, WhseShptLine, PostedWhseShptHeader); WhsePostShpt.CreatePostedShptLine( WhseShptLine, PostedWhseShptHeader, PostedWhseShptLine, TempWhseSplitSpecification); end; ReturnRcptLine."Item Rcpt. Entry No." := InsertReturnEntryRelation(ReturnRcptLine); // ItemLedgShptEntryNo; ReturnRcptLine."Item Charge Base Amount" := Round(CostBaseAmount / SalesLine.Quantity * ReturnRcptLine.Quantity); end; OnAfterInsertReturnReceiptLineWhsePost(SalesLine, xSalesLine, ReturnRcptLine); end; local procedure CheckICPartnerBlocked(SalesHeader: Record "Sales Header") var ICPartner: Record "IC Partner"; begin if SalesHeader."Sell-to IC Partner Code" <> '' then if ICPartner.Get(SalesHeader."Sell-to IC Partner Code") then ICPartner.TestField(Blocked, false); if SalesHeader."Bill-to IC Partner Code" <> '' then if ICPartner.Get(SalesHeader."Bill-to IC Partner Code") then ICPartner.TestField(Blocked, false); end; local procedure SendICDocument(var SalesHeader: Record "Sales Header") var ICInboxOutboxMgt: Codeunit ICInboxOutboxMgt; IsHandled: Boolean; ModifyHeader: Boolean; begin IsHandled := false; OnBeforeSendICDocument(SalesHeader, ModifyHeader, IsHandled); if IsHandled then exit; if SalesHeader."Send IC Document" and (SalesHeader."IC Status" = SalesHeader."IC Status"::New) and (SalesHeader."IC Direction" = SalesHeader."IC Direction"::Outgoing) and (SalesHeader."Document Type" in [SalesHeader."Document Type"::Order, SalesHeader."Document Type"::"Return Order"]) then begin SalesHeader.Modify(); ICInboxOutboxMgt.SendSalesDoc(SalesHeader, true); SalesHeader.Get(SalesHeader."Document Type", SalesHeader."No."); IsHandled := false; OnSendICDocumentOnBeforeSetICStatus(SalesHeader, IsHandled); if not IsHandled then SalesHeader."IC Status" := SalesHeader."IC Status"::Pending; ModifyHeader := true; end; end; local procedure UpdateHandledICInboxTransaction(SalesHeader: Record "Sales Header") var HandledICInboxTrans: Record "Handled IC Inbox Trans."; Customer: Record Customer; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateHandledICInboxTransaction(SalesHeader, IsHandled); if IsHandled then exit; if SalesHeader."IC Direction" = SalesHeader."IC Direction"::Incoming then begin HandledICInboxTrans.SetRange("Document No.", SalesHeader."IC Reference Document No."); Customer.Get(SalesHeader."Sell-to Customer No."); HandledICInboxTrans.SetRange("IC Partner Code", Customer."IC Partner Code"); HandledICInboxTrans.LockTable(); if HandledICInboxTrans.FindFirst() then begin HandledICInboxTrans.Status := HandledICInboxTrans.Status::Posted; HandledICInboxTrans.Modify(); end; end; end; local procedure RunItemJnlPostLine(var ItemJnlLineToPost: Record "Item Journal Line") begin ItemJnlPostLine.RunWithCheck(ItemJnlLineToPost); end; /// <summary> /// Gets the posted document that was created from the specified sales header. /// </summary> /// <remarks> /// Orders and Return Orders return Invoice or Credit Memo. If the Invoice or Credit Memo was not posted, the function does not return a value. /// </remarks> /// <param name="SalesHeader">The sales header for which to get the posted document.</param> /// <param name="PostedSalesDocumentVariant">Return Variable: The posted document that was created from the specified sales header.</param> procedure GetPostedDocumentRecord(SalesHeader: Record "Sales Header"; var PostedSalesDocumentVariant: Variant) var SalesShipmentHeader: Record "Sales Shipment Header"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; ReturnReceiptHeader: Record "Return Receipt Header"; IsHandled: Boolean; begin case SalesHeader."Document Type" of SalesHeader."Document Type"::Order: begin if (not SalesHeader.Invoice) and (SalesHeader.Ship) then begin SalesShipmentHeader.Get(SalesHeader."Last Shipping No."); SalesShipmentHeader.SetRecFilter(); PostedSalesDocumentVariant := SalesShipmentHeader; end; if SalesHeader.Invoice then begin SalesInvHeader.Get(SalesHeader."Last Posting No."); SalesInvHeader.SetRecFilter(); PostedSalesDocumentVariant := SalesInvHeader; end; end; SalesHeader."Document Type"::Invoice: begin if SalesHeader."Last Posting No." = '' then SalesInvHeader.Get(SalesHeader."No.") else SalesInvHeader.Get(SalesHeader."Last Posting No."); SalesInvHeader.SetRecFilter(); PostedSalesDocumentVariant := SalesInvHeader; end; SalesHeader."Document Type"::"Credit Memo": begin if SalesHeader."Last Posting No." = '' then SalesCrMemoHeader.Get(SalesHeader."No.") else SalesCrMemoHeader.Get(SalesHeader."Last Posting No."); SalesCrMemoHeader.SetRecFilter(); PostedSalesDocumentVariant := SalesCrMemoHeader; end; SalesHeader."Document Type"::"Return Order": begin if (not SalesHeader.Invoice) and (SalesHeader.Receive) then begin ReturnReceiptHeader.Get(SalesHeader."Last Return Receipt No."); ReturnReceiptHeader.SetRecFilter(); PostedSalesDocumentVariant := ReturnReceiptHeader; end; if SalesHeader.Invoice then begin if SalesHeader."Last Posting No." = '' then SalesCrMemoHeader.Get(SalesHeader."No.") else SalesCrMemoHeader.Get(SalesHeader."Last Posting No."); SalesCrMemoHeader.SetRecFilter(); PostedSalesDocumentVariant := SalesCrMemoHeader; end; end; else begin IsHandled := false; OnGetPostedDocumentRecordElseCase(SalesHeader, PostedSalesDocumentVariant, IsHandled); if not IsHandled then Error(NotSupportedDocumentTypeErr, SalesHeader."Document Type"); end; end; end; /// <summary> /// Sends the posted document(s) that were created during posting to the specified Document Sending Profile. /// </summary> /// <remarks> /// Send function in Document Sending Profile commits the transaction after it successfully sends the document. /// </remarks> /// <param name="SalesHeader">The sales header for which to find the documents to send.</param> /// <param name="DocumentSendingProfile">The Document Sending Profile to use for sending the documents.</param> procedure SendPostedDocumentRecord(SalesHeader: Record "Sales Header"; var DocumentSendingProfile: Record "Document Sending Profile") var SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesShipmentHeader: Record "Sales Shipment Header"; OfficeManagement: Codeunit "Office Management"; IsHandled: Boolean; begin IsHandled := false; OnBeforeSendPostedDocumentRecord(SalesHeader, IsHandled, DocumentSendingProfile); if IsHandled then exit; case SalesHeader."Document Type" of SalesHeader."Document Type"::Order: begin OnSendSalesDocument(SalesHeader.Invoice and SalesHeader.Ship, SuppressCommit); if SalesHeader.Invoice then begin SalesInvHeader.Get(SalesHeader."Last Posting No."); SalesInvHeader.SetRecFilter(); SalesInvHeader.SendProfile(DocumentSendingProfile); end; if SalesHeader.Ship and SalesHeader.Invoice and not OfficeManagement.IsAvailable() then if not ConfirmDownloadShipment(SalesHeader) then exit; if SalesHeader.Ship then begin SalesShipmentHeader.Get(SalesHeader."Last Shipping No."); SalesShipmentHeader.SetRecFilter(); SalesShipmentHeader.SendProfile(DocumentSendingProfile); end; end; SalesHeader."Document Type"::Invoice: begin if SalesHeader."Last Posting No." = '' then SalesInvHeader.Get(SalesHeader."No.") else SalesInvHeader.Get(SalesHeader."Last Posting No."); SalesInvHeader.SetRecFilter(); SalesInvHeader.SendProfile(DocumentSendingProfile); end; SalesHeader."Document Type"::"Credit Memo": begin if SalesHeader."Last Posting No." = '' then SalesCrMemoHeader.Get(SalesHeader."No.") else SalesCrMemoHeader.Get(SalesHeader."Last Posting No."); SalesCrMemoHeader.SetRecFilter(); SalesCrMemoHeader.SendProfile(DocumentSendingProfile); end; SalesHeader."Document Type"::"Return Order": if SalesHeader.Invoice then begin if SalesHeader."Last Posting No." = '' then SalesCrMemoHeader.Get(SalesHeader."No.") else SalesCrMemoHeader.Get(SalesHeader."Last Posting No."); SalesCrMemoHeader.SetRecFilter(); SalesCrMemoHeader.SendProfile(DocumentSendingProfile); end; else begin IsHandled := false; OnSendPostedDocumentRecordElseCase(SalesHeader, DocumentSendingProfile, IsHandled); if not IsHandled then Error(NotSupportedDocumentTypeErr, SalesHeader."Document Type"); end; end; end; local procedure ConfirmDownloadShipment(SalesHeader: Record "Sales Header") Result: Boolean var ConfirmManagement: Codeunit "Confirm Management"; IsHandled: Boolean; begin IsHandled := false; OnBeforeConfirmDownloadShipment(SalesHeader, Result, IsHandled); if IsHandled then exit(Result); if ConfirmManagement.GetResponseOrDefault(SendShipmentAlsoQst, true) then exit(true); exit(false); end; local procedure MakeInventoryAdjustment() var InvtSetup: Record "Inventory Setup"; InvtAdjmtHandler: Codeunit "Inventory Adjustment Handler"; IsHandled: Boolean; begin InvtSetup.Get(); if InvtSetup.AutomaticCostAdjmtRequired() then begin IsHandled := false; OnBeforeMakeInventoryAdjustment(InvtSetup, InvtAdjmtHandler, IsHandled); if not IsHandled then InvtAdjmtHandler.MakeAutomaticInventoryAdjustment(ItemsToAdjust); end; end; local procedure FindNotShippedLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) var IsHandled: Boolean; begin IsHandled := false; OnBeforeFindNotShippedLines(SalesHeader, TempSalesLine, IsHandled); if IsHandled then exit; ResetTempLines(TempSalesLine); TempSalesLine.SetFilter(Quantity, '<>0'); if SalesHeader."Document Type" = SalesHeader."Document Type"::Order then TempSalesLine.SetFilter("Qty. to Ship", '<>0'); TempSalesLine.SetRange("Shipment No.", ''); OnAfterFindNotShippedLines(SalesHeader, TempSalesLine); end; local procedure CheckTrackingAndWarehouseForShip(SalesHeader: Record "Sales Header") Ship: Boolean var TempSalesLine: Record "Sales Line" temporary; begin FindNotShippedLines(SalesHeader, TempSalesLine); Ship := TempSalesLine.FindFirst(); WhseShip := TempWhseShptHeader.FindFirst(); WhseReceive := TempWhseRcptHeader.FindFirst(); OnCheckTrackingAndWarehouseForShipOnBeforeCheck(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader, Ship, TempSalesLine); if Ship then begin CheckTrackingSpecification(SalesHeader, TempSalesLine); if not (WhseShip or WhseReceive or InvtPickPutaway) then CheckWarehouse(TempSalesLine); end; OnAfterCheckTrackingAndWarehouseForShip(SalesHeader, Ship, SuppressCommit, TempWhseShptHeader, TempWhseRcptHeader, TempSalesLine); exit(Ship); end; local procedure CheckTrackingAndWarehouseForReceive(SalesHeader: Record "Sales Header") Receive: Boolean var TempSalesLine: Record "Sales Line" temporary; begin ResetTempLines(TempSalesLine); TempSalesLine.SetFilter(Quantity, '<>0'); TempSalesLine.SetFilter("Return Qty. to Receive", '<>0'); TempSalesLine.SetRange("Return Receipt No.", ''); OnCheckTrackingAndWarehouseForReceiveOnAfterSetFilters(SalesHeader, TempSalesLine); Receive := TempSalesLine.FindFirst(); WhseShip := TempWhseShptHeader.FindFirst(); WhseReceive := TempWhseRcptHeader.FindFirst(); OnCheckTrackingAndWarehouseForReceiveOnBeforeCheck(SalesHeader, TempWhseShptHeader, TempWhseRcptHeader, Receive); if Receive then begin CheckTrackingSpecification(SalesHeader, TempSalesLine); if not (WhseReceive or WhseShip or InvtPickPutaway) then CheckWarehouse(TempSalesLine); end; OnAfterCheckTrackingAndWarehouseForReceive(SalesHeader, Receive, SuppressCommit, TempWhseShptHeader, TempWhseRcptHeader, TempSalesLine); exit(Receive); end; local procedure CheckIfInvPickExists(SalesHeader: Record "Sales Header"): Boolean var TempSalesLine: Record "Sales Line" temporary; WarehouseActivityLine: Record "Warehouse Activity Line"; begin FindNotShippedLines(SalesHeader, TempSalesLine); if TempSalesLine.IsEmpty() then exit(false); TempSalesLine.FindSet(); repeat if WarehouseActivityLine.ActivityExists( DATABASE::"Sales Line", TempSalesLine."Document Type".AsInteger(), TempSalesLine."Document No.", TempSalesLine."Line No.", 0, WarehouseActivityLine."Activity Type"::"Invt. Pick".AsInteger()) then exit(true); until TempSalesLine.Next() = 0; exit(false); end; local procedure CheckIfInvPutawayExists(): Boolean var TempSalesLine: Record "Sales Line" temporary; WarehouseActivityLine: Record "Warehouse Activity Line"; begin ResetTempLines(TempSalesLine); TempSalesLine.SetFilter(Quantity, '<>0'); TempSalesLine.SetFilter("Return Qty. to Receive", '<>0'); TempSalesLine.SetRange("Return Receipt No.", ''); if TempSalesLine.IsEmpty() then exit(false); TempSalesLine.FindSet(); repeat if WarehouseActivityLine.ActivityExists( DATABASE::"Sales Line", TempSalesLine."Document Type".AsInteger(), TempSalesLine."Document No.", TempSalesLine."Line No.", 0, WarehouseActivityLine."Activity Type"::"Invt. Put-away".AsInteger()) then exit(true); until TempSalesLine.Next() = 0; exit(false); end; local procedure FindTempItemChargeAssgntSales(SalesLineNo: Integer): Boolean begin ClearItemChargeAssgntFilter(); TempItemChargeAssgntSales.SetCurrentKey("Applies-to Doc. Type"); TempItemChargeAssgntSales.SetRange("Document Line No.", SalesLineNo); exit(TempItemChargeAssgntSales.FindSet()); end; local procedure UpdateInvoicedQtyOnShipmentLine(var SalesShptLine: Record "Sales Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin OnBeforeUpdateInvoicedQtyOnShipmentLineProcedure(SalesShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase); SalesShptLine."Quantity Invoiced" := SalesShptLine."Quantity Invoiced" - QtyToBeInvoiced; SalesShptLine."Qty. Invoiced (Base)" := SalesShptLine."Qty. Invoiced (Base)" - QtyToBeInvoicedBase; SalesShptLine."Qty. Shipped Not Invoiced" := SalesShptLine.Quantity - SalesShptLine."Quantity Invoiced"; OnUpdateInvoicedQtyOnShipmentLineOnBeforeModifySalesShptLine(SalesShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase); SalesShptLine.Modify(); end; /// <summary> /// Sets the CalledBy global variable. /// </summary> /// <param name="NewCalledBy"></param> procedure SetCalledBy(NewCalledBy: Integer) begin CalledBy := NewCalledBy; end; /// <summary> /// Sets the Preview Mode for the current instance of the codeunit. /// Preview Mode ensures no transactions are commited to the database and no documents are sent. /// </summary> /// <param name="NewPreviewMode">The new value for the Preview Mode.</param> procedure SetPreviewMode(NewPreviewMode: Boolean) begin PreviewMode := NewPreviewMode; end; local procedure PostDropOrderShipment(var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) var PurchSetup: Record "Purchases & Payables Setup"; PurchCommentLine: Record "Purch. Comment Line"; PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; RecordLinkManagement: Codeunit "Record Link Management"; begin OnBeforePostDropOrderShipment(SalesHeader, TempDropShptPostBuffer); ArchivePurchaseOrders(TempDropShptPostBuffer); if TempDropShptPostBuffer.FindSet() then begin PurchSetup.Get(); repeat PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No."); InsertPurchRcptHeader(PurchOrderHeader, SalesHeader, PurchRcptHeader); ApprovalsMgmt.PostApprovalEntries(SalesHeader.RecordId, PurchRcptHeader.RecordId, PurchRcptHeader."No."); if PurchSetup."Copy Comments Order to Receipt" then begin PurchCommentLine.CopyComments( PurchOrderHeader."Document Type".AsInteger(), PurchCommentLine."Document Type"::Receipt.AsInteger(), PurchOrderHeader."No.", PurchRcptHeader."No."); RecordLinkManagement.CopyLinks(PurchOrderHeader, PurchRcptHeader); end; TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No."); repeat PurchOrderLine.Get( PurchOrderLine."Document Type"::Order, TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No."); InsertPurchRcptLine(PurchRcptHeader, PurchOrderLine, TempDropShptPostBuffer); PurchPost.UpdateBlanketOrderLine(PurchOrderLine, true, false, false); OnPostDropOrderShipmentOnAfterUpdateBlanketOrderLine( PurchOrderHeader, PurchOrderLine, TempDropShptPostBuffer, SalesShptHeader, SalesHeader, PurchRcptHeader, TempTrackingSpecification, SrcCode); until TempDropShptPostBuffer.Next() = 0; TempDropShptPostBuffer.SetRange("Order No."); OnAfterInsertDropOrderPurchRcptHeader(PurchRcptHeader); until TempDropShptPostBuffer.Next() = 0; end; OnAfterPostDropOrderShipment(TempDropShptPostBuffer); end; local procedure PostItemTracking(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean) var QtyToInvoiceBaseInTrackingSpec: Decimal; ShouldPostItemTrackingForReceipt: Boolean; ShouldPostItemTrackingForShipment: Boolean; ShouldProcessReceipt: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemTracking(SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification, IsHandled, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced, PreciseTotalChargeAmt, RoundedPrevTotalChargeAmt, RemQtyToBeInvoiced, ItemJnlRollRndg); if IsHandled then exit; if TrackingSpecificationExists then begin TempTrackingSpecification.CalcSums("Qty. to Invoice (Base)"); QtyToInvoiceBaseInTrackingSpec := TempTrackingSpecification."Qty. to Invoice (Base)"; if not TempTrackingSpecification.FindFirst() then TempTrackingSpecification.Init(); end; ShouldProcessReceipt := SalesLine.IsCreditDocType(); OnPostItemTrackingOnAfterCalcShouldProcessReceipt(SalesHeader, SalesLine, ShouldProcessReceipt, ItemJnlRollRndg); if ShouldProcessReceipt then begin ShouldPostItemTrackingForReceipt := (Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Return Qty. to Receive")) or (Abs(RemQtyToBeInvoiced) >= Abs(QtyToInvoiceBaseInTrackingSpec)) and (QtyToInvoiceBaseInTrackingSpec <> 0); OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForReceipt( SalesHeader, SalesLine, RemQtyToBeInvoiced, QtyToInvoiceBaseInTrackingSpec, ShouldPostItemTrackingForReceipt); if ShouldPostItemTrackingForReceipt then PostItemTrackingForReceipt( SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification); PostItemTrackingCheckReturnReceipt(SalesLine, RemQtyToBeInvoiced); end else begin ShouldPostItemTrackingForShipment := (Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Qty. to Ship")) or (Abs(RemQtyToBeInvoiced) >= Abs(QtyToInvoiceBaseInTrackingSpec)) and (QtyToInvoiceBaseInTrackingSpec <> 0); OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForShipment( SalesHeader, SalesLine, RemQtyToBeInvoiced, QtyToInvoiceBaseInTrackingSpec, ShouldPostItemTrackingForShipment); if ShouldPostItemTrackingForShipment then PostItemTrackingForShipment( SalesHeader, SalesLine, TrackingSpecificationExists, TempTrackingSpecification, TempItemLedgEntryNotInvoiced, HasATOShippedNotInvoiced); PostItemTrackingCheckShipment(SalesLine, RemQtyToBeInvoiced); end; end; /// <summary> /// Checks if remaining quantity to be invoiced is greater than the return quantity to be received. Throws an error if it is. /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> procedure PostItemTrackingCheckReturnReceipt(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal) var IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemTrackingCheckReturnReceipt(SalesLine, RemQtyToBeInvoiced, IsHandled); if IsHandled then exit; if Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Return Qty. to Receive") then begin if SalesLine."Document Type" = SalesLine."Document Type"::"Credit Memo" then Error(InvoiceGreaterThanReturnReceiptErr, SalesLine."Return Receipt No."); Error(ReturnReceiptLinesDeletedErr); end; end; /// <summary> /// Checks if remaining quantity to be invoiced is greater than the quantity to be shipped. Throws an error if it is /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> procedure PostItemTrackingCheckShipment(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal) var IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemTrackingCheckShipment(SalesLine, RemQtyToBeInvoiced, IsHandled); if IsHandled then exit; if Abs(RemQtyToBeInvoiced) > Abs(SalesLine."Qty. to Ship") then begin if SalesLine."Document Type" = SalesLine."Document Type"::Invoice then Error(QuantityToInvoiceGreaterErr, SalesLine."Shipment No."); Error(ShipmentLinesDeletedErr); end; end; /// <summary> /// Posts item tracking for return receipt lines during invoicing. /// </summary> /// <param name="SalesHeader">The sales header record.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="TrackingSpecificationExists">Indicates if tracking specification exists.</param> /// <param name="TempTrackingSpecification">Temporary tracking specification records.</param> procedure PostItemTrackingForReceipt(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary) var ItemEntryRelation: Record "Item Entry Relation"; ReturnRcptLine: Record "Return Receipt Line"; SalesShptLine: Record "Sales Shipment Line"; EndLoop: Boolean; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ShouldAdjustQuantityRounding: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforePostItemTrackingForReceipt(SalesLine, IsHandled); if IsHandled then exit; EndLoop := false; ReturnRcptLine.Reset(); case SalesHeader."Document Type" of SalesHeader."Document Type"::"Return Order": begin ReturnRcptLine.SetCurrentKey("Return Order No.", "Return Order Line No."); ReturnRcptLine.SetRange("Return Order No.", SalesLine."Document No."); ReturnRcptLine.SetRange("Return Order Line No.", SalesLine."Line No."); end; SalesHeader."Document Type"::"Credit Memo": begin ReturnRcptLine.SetRange("Document No.", SalesLine."Return Receipt No."); ReturnRcptLine.SetRange("Line No.", SalesLine."Return Receipt Line No."); end; end; ReturnRcptLine.SetFilter("Return Qty. Rcd. Not Invd.", '<>0'); OnPostItemTrackingForReceiptOnAfterSetFilters(ReturnRcptLine, SalesHeader, SalesLine); if ReturnRcptLine.FindSet() then begin ItemJnlRollRndg := true; repeat GetReturnRcptLineFromTrackingOrUpdateItemEntryRelation( SalesHeader, TrackingSpecificationExists, ItemEntryRelation, TempTrackingSpecification, ReturnRcptLine); UpdateChargeItemReturnRcptLineGenProdPostingGroup(ReturnRcptLine); CheckReturnRcptLine(ReturnRcptLine, SalesLine); if SalesLine."Qty. to Invoice" * ReturnRcptLine.Quantity < 0 then SalesLine.FieldError("Qty. to Invoice", ReturnReceiptSameSignErr); UpdateQtyToBeInvoicedForReturnReceipt( QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, SalesLine, ReturnRcptLine, TempTrackingSpecification); if TrackingSpecificationExists then begin TempTrackingSpecification."Quantity actual Handled (Base)" := QtyToBeInvoicedBase; TempTrackingSpecification.Modify(); end; ShouldAdjustQuantityRounding := TrackingSpecificationExists; OnPostItemTrackingForReceiptOnBeforeAdjustQuantityRounding( ReturnRcptLine, RemQtyToBeInvoiced, QtyToBeInvoiced, RemQtyToBeInvoicedBase, QtyToBeInvoicedBase, TrackingSpecificationExists, ShouldAdjustQuantityRounding); if ShouldAdjustQuantityRounding then ItemTrackingMgt.AdjustQuantityRounding( RemQtyToBeInvoiced, QtyToBeInvoiced, RemQtyToBeInvoicedBase, QtyToBeInvoicedBase); RemQtyToBeInvoiced := RemQtyToBeInvoiced - QtyToBeInvoiced; RemQtyToBeInvoicedBase := RemQtyToBeInvoicedBase - QtyToBeInvoicedBase; ReturnRcptLine."Quantity Invoiced" := ReturnRcptLine."Quantity Invoiced" + QtyToBeInvoiced; ReturnRcptLine."Qty. Invoiced (Base)" := ReturnRcptLine."Qty. Invoiced (Base)" + QtyToBeInvoicedBase; ReturnRcptLine."Return Qty. Rcd. Not Invd." := ReturnRcptLine.Quantity - ReturnRcptLine."Quantity Invoiced"; IsHandled := false; OnPostItemTrackingForReceiptOnBeforeReturnRcptLineModify(SalesHeader, ReturnRcptLine, SalesLine, IsHandled); if not IsHandled then ReturnRcptLine.Modify(); OnBeforePostItemTrackingReturnRcpt( SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists, SalesCrMemoHeader, ReturnRcptLine, SalesLine, QtyToBeInvoiced, QtyToBeInvoicedBase); if PostItemTrackingForReceiptCondition(SalesLine, ReturnRcptLine) then PostItemJnlLine( SalesHeader, SalesLine, 0, 0, QtyToBeInvoiced, QtyToBeInvoicedBase, ItemEntryRelation."Item Entry No.", '', TempTrackingSpecification, false); OnAfterPostItemTrackingReturnRcpt( SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists, SalesCrMemoHeader, ReturnRcptLine, SalesLine, QtyToBeInvoiced, QtyToBeInvoicedBase); EndLoop := IsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, ReturnRcptLine, TempTrackingSpecification, SalesLine); until EndLoop; end else begin IsHandled := false; OnPostItemTrackingForShipmentOnBeforeReturnReceiptInvoiceErr(SalesLine, IsHandled, SalesHeader, ItemJnlRollRndg, TrackingSpecificationExists, TempTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase); if not IsHandled then Error( ReturnReceiptInvoicedErr, SalesLine."Return Receipt Line No.", SalesLine."Return Receipt No."); end; end; local procedure CheckReturnRcptLine(var ReturnReceiptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckReturnRcptLine(ReturnReceiptLine, SalesLine, IsHandled); if IsHandled then exit; ReturnReceiptLine.TestField("Sell-to Customer No.", SalesLine."Sell-to Customer No."); ReturnReceiptLine.TestField(Type, SalesLine.Type); ReturnReceiptLine.TestField("No.", SalesLine."No."); ReturnReceiptLine.TestField("Gen. Bus. Posting Group", SalesLine."Gen. Bus. Posting Group"); ReturnReceiptLine.TestField("Gen. Prod. Posting Group", SalesLine."Gen. Prod. Posting Group"); ReturnReceiptLine.TestField("Job No.", SalesLine."Job No."); ReturnReceiptLine.TestField("Unit of Measure Code", SalesLine."Unit of Measure Code"); ReturnReceiptLine.TestField("Variant Code", SalesLine."Variant Code"); end; local procedure IsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var ReturnReceiptLine: Record "Return Receipt Line"; var TempTrackingSpecification: Record "Tracking Specification"; SalesLine: Record "Sales Line") EndLoop: Boolean var IsHandled: Boolean; begin IsHandled := false; OnBeforeIsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced, TrackingSpecificationExists, ReturnReceiptLine, TempTrackingSpecification, SalesLine, EndLoop, IsHandled); if IsHandled then exit; if TrackingSpecificationExists then exit((TempTrackingSpecification.Next() = 0) or (RemQtyToBeInvoiced = 0)); exit((ReturnReceiptLine.Next() = 0) or (Abs(RemQtyToBeInvoiced) <= Abs(SalesLine."Return Qty. to Receive"))); end; local procedure GetItemEntryRelation(var SalesHeader: Record "Sales Header"; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary) var IsHandled: Boolean; begin IsHandled := false; OnBeforeGetItemEntryRelation(SalesHeader, ItemEntryRelation, TempTrackingSpecification, IsHandled); if IsHandled then exit; ItemEntryRelation.Get(TempTrackingSpecification."Item Ledger Entry No."); end; local procedure GetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(SalesHeader: Record "Sales Header"; TrackingSpecificationExists: Boolean; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var ReturnRcptLine: Record "Return Receipt Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeGetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(TempTrackingSpecification, ReturnRcptLine, ItemEntryRelation, IsHandled, TrackingSpecificationExists); if IsHandled then exit; if TrackingSpecificationExists then begin // Item Tracking GetItemEntryRelation(SalesHeader, ItemEntryRelation, TempTrackingSpecification); ReturnRcptLine.Get(ItemEntryRelation."Source ID", ItemEntryRelation."Source Ref. No."); end else ItemEntryRelation."Item Entry No." := ReturnRcptLine."Item Rcpt. Entry No."; end; local procedure PostItemTrackingForReceiptCondition(SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"): Boolean var Condition: Boolean; begin Condition := SalesLine.Type = SalesLine.Type::Item; OnBeforePostItemTrackingForReceiptCondition(SalesLine, ReturnRcptLine, Condition); exit(Condition); end; /// <summary> /// Posts item tracking entries for shipments during invoice posting. /// Processes shipment lines that have been shipped but not yet invoiced, applying item tracking and updating invoiced quantities. /// </summary> /// <param name="SalesHeader">The sales header record.</param> /// <param name="SalesLine">The sales line record being invoiced.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists for the line.</param> /// <param name="TempTrackingSpecification">Temporary tracking specification records.</param> /// <param name="TempItemLedgEntryNotInvoiced">Temporary item ledger entries that have not been invoiced.</param> /// <param name="HasATOShippedNotInvoiced">Indicates whether there are assemble-to-order items shipped but not invoiced.</param> procedure PostItemTrackingForShipment(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean) var ItemEntryRelation: Record "Item Entry Relation"; SalesShptLine: Record "Sales Shipment Line"; RemQtyToInvoiceCurrLine: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; ShouldAdjustQuantityRounding: Boolean; IsHandled: Boolean; begin SalesShptLine.Reset(); case SalesHeader."Document Type" of SalesHeader."Document Type"::Order: begin SalesShptLine.SetCurrentKey("Order No.", "Order Line No."); SalesShptLine.SetRange("Order No.", SalesLine."Document No."); SalesShptLine.SetRange("Order Line No.", SalesLine."Line No."); end; SalesHeader."Document Type"::Invoice: begin SalesShptLine.SetRange("Document No.", SalesLine."Shipment No."); SalesShptLine.SetRange("Line No.", SalesLine."Shipment Line No."); end; end; IsHandled := false; OnPostItemTrackingForShipmentOnBeforeGetATOItemLedgEntriesNotInvoiced(SalesHeader, IsHandled); if not IsHandled then if not TrackingSpecificationExists then HasATOShippedNotInvoiced := GetATOItemLedgEntriesNotInvoiced(SalesLine, TempItemLedgEntryNotInvoiced); SalesShptLine.SetFilter("Qty. Shipped Not Invoiced", '<>0'); OnPostItemTrackingForShipmentOnAfterSetFilters(SalesShptLine, SalesHeader, SalesLine); if SalesShptLine.FindFirst() then begin ItemJnlRollRndg := true; repeat SetItemEntryRelation( ItemEntryRelation, SalesShptLine, TempTrackingSpecification, TempItemLedgEntryNotInvoiced, TrackingSpecificationExists, HasATOShippedNotInvoiced); UpdateRemainingQtyToBeInvoiced(SalesShptLine, RemQtyToInvoiceCurrLine, RemQtyToInvoiceCurrLineBase); UpdateChargeItemSalesShptLineGenProdPostingGroup(SalesShptLine); OnPostItemTrackingForShipmentOnAfterUpdateSalesShptLineFields(SalesShptLine, SalesLine); IsHandled := false; OnPostItemTrackingForShipmentOnBeforeTestLineFields(SalesShptLine, SalesLine, IsHandled); if not IsHandled then begin SalesShptLine.TestField("Sell-to Customer No.", SalesLine."Sell-to Customer No."); SalesShptLine.TestField(Type, SalesLine.Type); SalesShptLine.TestField("No.", SalesLine."No."); SalesShptLine.TestField("Gen. Bus. Posting Group", SalesLine."Gen. Bus. Posting Group"); SalesShptLine.TestField("Gen. Prod. Posting Group", SalesLine."Gen. Prod. Posting Group"); CheckJobNoOnShptLineEqualToSales(SalesShptLine, SalesLine); SalesShptLine.TestField("Unit of Measure Code", SalesLine."Unit of Measure Code"); SalesShptLine.TestField("Variant Code", SalesLine."Variant Code"); end; if -SalesLine."Qty. to Invoice" * SalesShptLine.Quantity < 0 then SalesLine.FieldError("Qty. to Invoice", ShipmentSameSignErr); UpdateQtyToBeInvoicedForShipment( QtyToBeInvoiced, QtyToBeInvoicedBase, TrackingSpecificationExists, HasATOShippedNotInvoiced, SalesLine, SalesShptLine, TempTrackingSpecification, TempItemLedgEntryNotInvoiced); if TrackingSpecificationExists then begin TempTrackingSpecification."Quantity actual Handled (Base)" := QtyToBeInvoicedBase; TempTrackingSpecification.Modify(); end; ShouldAdjustQuantityRounding := TrackingSpecificationExists or HasATOShippedNotInvoiced; OnPostItemTrackingForShipmentOnBeforeAdjustQuantityRounding( SalesShptLine, RemQtyToInvoiceCurrLine, QtyToBeInvoiced, RemQtyToInvoiceCurrLineBase, QtyToBeInvoicedBase, TrackingSpecificationExists, HasATOShippedNotInvoiced, ShouldAdjustQuantityRounding); if ShouldAdjustQuantityRounding then ItemTrackingMgt.AdjustQuantityRounding( RemQtyToInvoiceCurrLine, QtyToBeInvoiced, RemQtyToInvoiceCurrLineBase, QtyToBeInvoicedBase); RemQtyToBeInvoiced := RemQtyToBeInvoiced - QtyToBeInvoiced; RemQtyToBeInvoicedBase := RemQtyToBeInvoicedBase - QtyToBeInvoicedBase; OnBeforeUpdateInvoicedQtyOnShipmentLine(SalesShptLine, SalesLine, SalesHeader, SalesInvHeader, SuppressCommit); UpdateInvoicedQtyOnShipmentLine(SalesShptLine, QtyToBeInvoiced, QtyToBeInvoicedBase); OnInvoiceSalesShptLine(SalesShptLine, SalesInvHeader."No.", SalesLine."Line No.", -QtyToBeInvoiced, SuppressCommit); OnBeforePostItemTrackingForShipment( SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists, SalesLine, QtyToBeInvoiced, QtyToBeInvoicedBase); if PostItemTrackingForShipmentCondition(SalesLine, SalesShptLine) then PostItemJnlLine( SalesHeader, SalesLine, 0, 0, QtyToBeInvoiced, QtyToBeInvoicedBase, ItemEntryRelation."Item Entry No.", '', TempTrackingSpecification, false); OnAfterPostItemTrackingForShipment( SalesInvHeader, SalesShptLine, TempTrackingSpecification, TrackingSpecificationExists, SalesLine, QtyToBeInvoiced, QtyToBeInvoicedBase); until IsEndLoopForShippedNotInvoiced( RemQtyToBeInvoiced, TrackingSpecificationExists, HasATOShippedNotInvoiced, SalesShptLine, TempTrackingSpecification, TempItemLedgEntryNotInvoiced, SalesLine); end else begin IsHandled := false; OnPostItemTrackingForShipmentOnBeforeShipmentInvoiceErr(SalesLine, IsHandled, SalesHeader, ItemJnlRollRndg, TrackingSpecificationExists, TempTrackingSpecification, RemQtyToBeInvoiced, RemQtyToBeInvoicedBase); if not IsHandled then Error( ShipmentInvoiceErr, SalesLine."Shipment Line No.", SalesLine."Shipment No."); end; end; local procedure CheckJobNoOnShptLineEqualToSales(SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckJobNoOnShptLineEqualToSales(SalesShipmentLine, SalesLine, IsHandled); if IsHandled then exit; SalesShipmentLine.TestField("Job No.", SalesLine."Job No."); end; local procedure PostItemTrackingForShipmentCondition(SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"): Boolean var Condition: Boolean; begin Condition := SalesLine.Type = SalesLine.Type::Item; OnBeforePostItemTrackingForShipmentCondition(SalesLine, SalesShptLine, Condition); exit(Condition); end; /// <summary> /// Updates order lines after posting by adjusting shipped, received, and invoiced quantities. /// Also handles prepayment deductions, blanket order updates, and resets quantities for the next posting. /// </summary> /// <param name="SalesHeader">The sales header record that was posted.</param> procedure PostUpdateOrderLine(SalesHeader: Record "Sales Header") var TempSalesLine: Record "Sales Line" temporary; SetDefaultQtyBlank: Boolean; IsHandled: Boolean; ShouldCalcPrepmtAmounts: Boolean; ShouldSetInvoiceFields: Boolean; begin OnBeforePostUpdateOrderLine(SalesHeader, TempSalesLineGlobal, SuppressCommit, SalesSetup); ResetTempLines(TempSalesLine); TempSalesLine.SetRange("Prepayment Line", false); TempSalesLine.SetFilter(Quantity, '<>0'); OnPostUpdateOrderLineOnAfterSetFilters(TempSalesLine); if TempSalesLine.FindSet() then repeat OnPostUpdateOrderLineOnBeforeInitTempSalesLineQuantities(SalesHeader, TempSalesLine); if SalesHeader.Ship then begin IsHandled := false; OnPostUpdateOrderLineOnBeforeGetQuantityShipped(TempSalesLine, IsHandled, SalesHeader); if not IsHandled then begin TempSalesLine."Quantity Shipped" += TempSalesLine."Qty. to Ship"; TempSalesLine."Qty. Shipped (Base)" += TempSalesLine."Qty. to Ship (Base)"; end; end; if SalesHeader.Receive then begin IsHandled := false; OnPostUpdateOrderLineOnBeforeGetReturnQtyReceived(TempSalesLine, IsHandled, SalesHeader); if not IsHandled then begin TempSalesLine."Return Qty. Received" += TempSalesLine."Return Qty. to Receive"; TempSalesLine."Return Qty. Received (Base)" += TempSalesLine."Return Qty. to Receive (Base)"; end; end; ShouldSetInvoiceFields := SalesHeader.Invoice; OnPostUpdateOrderLineOnBeforeSetInvoiceFields(SalesHeader, TempSalesLine, ShouldSetInvoiceFields); if ShouldSetInvoiceFields then begin IsHandled := false; OnPostUpdateOrderLineOnBeforeUpdateInvoicedValues(SalesHeader, TempSalesLine, IsHandled); if not IsHandled then begin if TempSalesLine."Document Type" = TempSalesLine."Document Type"::Order then begin if Abs(TempSalesLine."Quantity Invoiced" + TempSalesLine."Qty. to Invoice") > Abs(TempSalesLine."Quantity Shipped") then begin TempSalesLine.Validate(TempSalesLine."Qty. to Invoice", TempSalesLine."Quantity Shipped" - TempSalesLine."Quantity Invoiced"); TempSalesLine."Qty. to Invoice (Base)" := TempSalesLine."Qty. Shipped (Base)" - TempSalesLine."Qty. Invoiced (Base)"; end end else if Abs(TempSalesLine."Quantity Invoiced" + TempSalesLine."Qty. to Invoice") > Abs(TempSalesLine."Return Qty. Received") then begin TempSalesLine.Validate(TempSalesLine."Qty. to Invoice", TempSalesLine."Return Qty. Received" - TempSalesLine."Quantity Invoiced"); TempSalesLine."Qty. to Invoice (Base)" := TempSalesLine."Return Qty. Received (Base)" - TempSalesLine."Qty. Invoiced (Base)"; end; TempSalesLine."Quantity Invoiced" += TempSalesLine."Qty. to Invoice"; TempSalesLine."Qty. Invoiced (Base)" += TempSalesLine."Qty. to Invoice (Base)"; ShouldCalcPrepmtAmounts := TempSalesLine."Qty. to Invoice" <> 0; OnPostUpdateOrderLineOnAfterCalcShouldCalcPrepmtAmounts(TempSalesLine, ShouldCalcPrepmtAmounts); if ShouldCalcPrepmtAmounts then begin TempSalesLine."Prepmt Amt Deducted" += TempSalesLine."Prepmt Amt to Deduct"; TempSalesLine."Prepmt VAT Diff. Deducted" += TempSalesLine."Prepmt VAT Diff. to Deduct"; DecrementPrepmtAmtInvLCY(SalesHeader, TempSalesLine, TempSalesLine."Prepmt. Amount Inv. (LCY)", TempSalesLine."Prepmt. VAT Amount Inv. (LCY)"); TempSalesLine."Prepmt Amt to Deduct" := TempSalesLine."Prepmt. Amt. Inv." - TempSalesLine."Prepmt Amt Deducted"; TempSalesLine."Prepmt VAT Diff. to Deduct" := 0; end; end; OnPostUpdateOrderLineOnAfterUpdateInvoicedValues(TempSalesLine, SalesHeader); end; OnPostItemTrackingForShipmentConditionOnBeforeUpdateBlanketOrderLine(TempSalesLine, SalesHeader); UpdateBlanketOrderLine(TempSalesLine, SalesHeader.Ship, SalesHeader.Receive, SalesHeader.Invoice); IsHandled := false; OnPostUpdateOrderLineOnBeforeInitOutstanding(SalesHeader, TempSalesLine, IsHandled); if not IsHandled then begin TempSalesLine.InitOutstanding(); CheckATOLink(TempSalesLine); SetDefaultQtyBlank := SalesSetup."Default Quantity to Ship" = SalesSetup."Default Quantity to Ship"::Blank; OnPostUpdateOrderLineOnSetDefaultQtyBlank(SalesHeader, TempSalesLine, SalesSetup, SetDefaultQtyBlank); if WhseHandlingRequiredExternal(TempSalesLine) or SetDefaultQtyBlank then begin if TempSalesLine."Document Type" = TempSalesLine."Document Type"::"Return Order" then begin TempSalesLine."Return Qty. to Receive" := 0; TempSalesLine."Return Qty. to Receive (Base)" := 0; end else begin TempSalesLine."Qty. to Ship" := 0; TempSalesLine."Qty. to Ship (Base)" := 0; end; OnPostUpdateOrderLineBeforeInitQtyToInvoice(TempSalesLine, WhseShip, WhseReceive); TempSalesLine.InitQtyToInvoice(); end else begin if TempSalesLine."Document Type" = TempSalesLine."Document Type"::"Return Order" then TempSalesLine.InitQtyToReceive() else TempSalesLine.InitQtyToShip2(); OnPostUpdateOrderLineOnAfterInitQtyToReceiveOrShip(SalesHeader, TempSalesLine, WhseShip, WhseReceive); end; if (TempSalesLine."Purch. Order Line No." <> 0) and (TempSalesLine.Quantity = TempSalesLine."Quantity Invoiced") then UpdateAssocLines(TempSalesLine); TempSalesLine.SetDefaultQuantity(); IsHandled := false; OnBeforePostUpdateOrderLineModifyTempLine(TempSalesLine, WhseShip, WhseReceive, SuppressCommit, IsHandled, SalesHeader); if not IsHandled then ModifyTempLine(TempSalesLine); OnAfterPostUpdateOrderLineModifyTempLine(TempSalesLine, WhseShip, WhseReceive, SuppressCommit, SalesHeader); end; until TempSalesLine.Next() = 0; OnAfterPostUpdateOrderLine(TempSalesLine); end; local procedure PostUpdateInvoiceLine(var SalesHeader: Record "Sales Header") var SalesOrderLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; TempSalesLine: Record "Sales Line" temporary; TempSalesOrderHeader: Record "Sales Header" temporary; CRMSalesDocumentPostingMgt: Codeunit "CRM Sales Document Posting Mgt"; IsHandled: Boolean; begin IsHandled := false; OnBeforePostUpdateInvoiceLine(TempSalesLineGlobal, IsHandled); if IsHandled then exit; ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Shipment No.", '<>%1', ''); TempSalesLine.SetFilter(Type, '<>%1', TempSalesLine.Type::" "); if TempSalesLine.FindSet() then repeat SalesShptLine.Get(TempSalesLine."Shipment No.", TempSalesLine."Shipment Line No."); SalesOrderLine.Get( SalesOrderLine."Document Type"::Order, SalesShptLine."Order No.", SalesShptLine."Order Line No."); OnPostUpdateInvoiceLineOnAfterGetSalesOrderLine(TempSalesLine, SalesShptLine, SalesOrderLine); if TempSalesLine.Type = TempSalesLine.Type::"Charge (Item)" then UpdateSalesOrderChargeAssgnt(TempSalesLine, SalesOrderLine); IsHandled := false; OnPostUpdateInvoiceLineOnBeforeCalcQuantityInvoiced(SalesOrderLine, TempSalesLine, IsHandled); if not IsHandled then begin SalesOrderLine."Quantity Invoiced" += TempSalesLine."Qty. to Invoice"; SalesOrderLine."Qty. Invoiced (Base)" += TempSalesLine."Qty. to Invoice (Base)"; end; CheckSalesLineInvoiceMoreThanShipped(SalesOrderLine, TempSalesLine, SalesShptLine); OnPostUpdateInvoiceLineOnBeforeInitQtyToInvoice(SalesOrderLine, TempSalesLine); SalesOrderLine.InitQtyToInvoice(); if SalesOrderLine."Prepayment %" <> 0 then begin SalesOrderLine."Prepmt Amt Deducted" += TempSalesLine."Prepmt Amt to Deduct"; SalesOrderLine."Prepmt VAT Diff. Deducted" += TempSalesLine."Prepmt VAT Diff. to Deduct"; DecrementPrepmtAmtInvLCY( SalesHeader, TempSalesLine, SalesOrderLine."Prepmt. Amount Inv. (LCY)", SalesOrderLine."Prepmt. VAT Amount Inv. (LCY)"); SalesOrderLine."Prepmt Amt to Deduct" := SalesOrderLine."Prepmt. Amt. Inv." - SalesOrderLine."Prepmt Amt Deducted"; SalesOrderLine."Prepmt VAT Diff. to Deduct" := 0; end; IsHandled := false; OnPostUpdateInvoiceLineOnBeforeInitOutstanding(SalesOrderLine, IsHandled); if not IsHandled then SalesOrderLine.InitOutstanding(); OnPostUpdateInvoiceLineOnBeforeModifySalesOrderLine(SalesOrderLine, TempSalesLine); SalesOrderLine.Modify(); OnPostUpdateInvoiceLineOnAfterModifySalesOrderLine(SalesOrderLine, TempSalesLine); if not TempSalesOrderHeader.Get(SalesOrderLine."Document Type", SalesOrderLine."Document No.") then begin TempSalesOrderHeader."Document Type" := SalesOrderLine."Document Type"; TempSalesOrderHeader."No." := SalesOrderLine."Document No."; TempSalesOrderHeader.Insert(); end; OnPostUpdateInvoiceLineOnAfterInsertSalesOrderHeader(SalesOrderLine, TempSalesLine); until TempSalesLine.Next() = 0; CRMSalesDocumentPostingMgt.CheckShippedOrders(TempSalesOrderHeader); OnAfterPostUpdateInvoiceLine(TempSalesLine, SalesHeader, TempSalesOrderHeader); end; local procedure PostUpdateOrderNo(var SalesInvoiceHeader: Record "Sales Invoice Header") var SalesInvoiceLine: Record "Sales Invoice Line"; IsHandled: Boolean; begin IsHandled := false; OnBeforePostUpdateOrderNo(SalesInvoiceHeader, IsHandled); if IsHandled then exit; if SalesInvoiceHeader."No." = '' then exit; // Do not change 'Order No.' if already set if SalesInvoiceHeader."Order No." <> '' then exit; // Get a line where 'Order No.' is set SalesInvoiceLine.SetLoadFields("Order No."); SalesInvoiceLine.SetRange("Document No.", SalesInvoiceHeader."No."); SalesInvoiceLine.SetFilter(Type, '<>%1', SalesInvoiceLine.Type::" "); // Ignore comment lines SalesInvoiceLine.SetFilter("Order No.", '<>%1', ''); if not SalesInvoiceLine.FindFirst() then exit; // If all the lines have the same 'Order No.' then set 'Order No.' field on the header SalesInvoiceLine.SetFilter("Order No.", '<>%1', SalesInvoiceLine."Order No."); if SalesInvoiceLine.IsEmpty() then begin SalesInvoiceHeader.Validate("Order No.", SalesInvoiceLine."Order No."); SalesInvoiceHeader.Modify(true); end; end; local procedure CheckSalesLineInvoiceMoreThanShipped(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var SalesShptLine: Record "Sales Shipment Line") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckSalesLineInvoiceMoreThanShipped(SalesOrderLine, TempSalesLine, SalesShptLine, IsHandled); if IsHandled then exit; if Abs(SalesOrderLine."Quantity Invoiced") > Abs(SalesOrderLine."Quantity Shipped") then Error(InvoiceMoreThanShippedErr, SalesOrderLine."Document No."); end; /// <summary> /// Updates return order lines after posting credit memos that reference return receipts. /// Adjusts invoiced quantities and validates that invoiced quantity does not exceed received quantity. /// </summary> procedure PostUpdateReturnReceiptLine() var SalesOrderLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; TempSalesLine: Record "Sales Line" temporary; IsHandled: Boolean; begin IsHandled := false; OnBeforePostUpdateReturnReceiptLine(TempSalesLineGlobal, IsHandled); if IsHandled then exit; ResetTempLines(TempSalesLine); TempSalesLine.SetFilter("Return Receipt No.", '<>%1', ''); TempSalesLine.SetFilter(Type, '<>%1', TempSalesLine.Type::" "); if TempSalesLine.FindSet() then repeat ReturnRcptLine.Get(TempSalesLine."Return Receipt No.", TempSalesLine."Return Receipt Line No."); SalesOrderLine.Get( SalesOrderLine."Document Type"::"Return Order", ReturnRcptLine."Return Order No.", ReturnRcptLine."Return Order Line No."); OnPostUpdateReturnReceiptLineOnAfterGetSalesOrderLine(TempSalesLine, ReturnRcptLine, SalesOrderLine); if TempSalesLine.Type = TempSalesLine.Type::"Charge (Item)" then UpdateSalesOrderChargeAssgnt(TempSalesLine, SalesOrderLine); IsHandled := false; OnPostUpdateReturnReceiptLineOnBeforeCalcQuantityInvoiced(SalesOrderLine, TempSalesLine, IsHandled); if not IsHandled then begin SalesOrderLine."Quantity Invoiced" += TempSalesLine."Qty. to Invoice"; SalesOrderLine."Qty. Invoiced (Base)" += TempSalesLine."Qty. to Invoice (Base)"; end; if Abs(SalesOrderLine."Quantity Invoiced") > Abs(SalesOrderLine."Return Qty. Received") then Error(InvoiceMoreThanReceivedErr, SalesOrderLine."Document No."); OnPostUpdateReturnReceiptLineOnBeforeInitQtyToInvoice(SalesOrderLine, TempSalesLine); SalesOrderLine.InitQtyToInvoice(); IsHandled := false; OnPostUpdateReturnReceiptLineOnBeforeInitOutstanding(SalesOrderLine, IsHandled); if not IsHandled then SalesOrderLine.InitOutstanding(); OnPostUpdateReturnReceiptLineOnBeforeModifySalesOrderLine(SalesOrderLine, TempSalesLine); SalesOrderLine.Modify(); OnPostUpdateReturnReceiptLineOnAfterModifySalesOrderLine(SalesOrderLine, TempSalesLine); until TempSalesLine.Next() = 0; OnAfterPostUpdateReturnReceiptLine(TempSalesLine); end; local procedure PostUpdateOrderNo(var SalesCrMemoHeader: Record "Sales Cr.Memo Header") var SalesCrMemoLine: Record "Sales Cr.Memo Line"; NoOfLines: Integer; NoOfLinesWithOrderNo: Integer; NoOfLinesWithParticularOrderNo: Integer; begin // Do not change 'Return Order No.' if already set if SalesCrMemoHeader."Return Order No." <> '' then exit; SalesCrMemoLine.SetLoadFields("Order No."); // Get number of lines. Ignore comment lines SalesCrMemoLine.SetRange("Document No.", SalesCrMemoHeader."No."); SalesCrMemoLine.SetFilter(Type, '<>%1', SalesCrMemoLine.Type::" "); // Ignore Comment lines NoOfLines := SalesCrMemoLine.Count(); if NoOfLines = 0 then exit; // Get number of lines with filled in 'Order No.' SalesCrMemoLine.SetFilter("Order No.", '<>%1', ''); NoOfLinesWithOrderNo := SalesCrMemoLine.Count(); if not SalesCrMemoLine.FindFirst() then exit; // Get number of lines with filled with a 'Order No.' SalesCrMemoLine.SetRange("Order No.", SalesCrMemoLine."Order No."); NoOfLinesWithParticularOrderNo := SalesCrMemoLine.Count(); SalesCrMemoLine.SetRange("Order No."); if (NoOfLines = NoOfLinesWithOrderNo) and (NoOfLinesWithOrderNo = NoOfLinesWithParticularOrderNo) then begin SalesCrMemoHeader.Validate("Return Order No.", SalesCrMemoLine."Order No."); SalesCrMemoHeader.Modify(true); end; end; local procedure CheckMandatoryHeaderFields(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckMandatoryHeaderFields(SalesHeader, IsHandled); if IsHandled then exit; SalesHeader.TestField("Document Type", ErrorInfo.Create()); SalesHeader.TestField("Sell-to Customer No.", ErrorInfo.Create()); SalesHeader.TestField("Bill-to Customer No.", ErrorInfo.Create()); SalesHeader.TestField("Posting Date", ErrorInfo.Create()); SalesHeader.TestField("Document Date", ErrorInfo.Create()); OnAfterCheckMandatoryFields(SalesHeader, SuppressCommit); end; local procedure ClearPostBuffers() begin Clear(WhsePostRcpt); Clear(WhsePostShpt); Clear(GenJnlPostLine); Clear(ResJnlPostLine); Clear(JobPostLine); Clear(ItemJnlPostLine); Clear(WhseJnlPostLine); end; /// <summary> /// Sets the posting flags (Ship, Invoice, Receive) on the sales header based on the document type. /// </summary> /// <param name="SalesHeader">The sales header for which to set the posting flags.</param> procedure SetPostingFlags(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeSetPostingFlags(SalesHeader, IsHandled); if IsHandled then exit; case SalesHeader."Document Type" of SalesHeader."Document Type"::Order: SalesHeader.Receive := false; SalesHeader."Document Type"::Invoice: begin SalesHeader.Ship := true; SalesHeader.Invoice := true; SalesHeader.Receive := false; end; SalesHeader."Document Type"::"Return Order": SalesHeader.Ship := false; SalesHeader."Document Type"::"Credit Memo": begin SalesHeader.Ship := false; SalesHeader.Invoice := true; SalesHeader.Receive := true; end; end; CheckPostingFlags(SalesHeader); end; local procedure CheckPostingFlags(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckPostingFlags(SalesHeader, IsHandled); if IsHandled then exit; if not (SalesHeader.Ship or SalesHeader.Invoice or SalesHeader.Receive) then Error(ShipInvoiceReceiveErr); end; /// <summary> /// Sets the Supress Commit flag. /// </summary> /// <param name="NewSuppressCommit">The new value of the Supress Commit flag.</param> procedure SetSuppressCommit(NewSuppressCommit: Boolean) begin SuppressCommit := NewSuppressCommit; end; local procedure ClearAllVariables() begin ClearAll(); TempSalesLineGlobal.DeleteAll(); TempItemChargeAssgntSales.DeleteAll(); TempHandlingSpecification.DeleteAll(); TempATOTrackingSpecification.DeleteAll(); TempTrackingSpecification.DeleteAll(); TempTrackingSpecificationInv.DeleteAll(); TempWhseSplitSpecification.DeleteAll(); TempValueEntryRelation.DeleteAll(); TempICGenJnlLine.DeleteAll(); TempPrepmtDeductLCYSalesLine.DeleteAll(); TempSKU.DeleteAll(); TempDeferralHeader.DeleteAll(); TempDeferralLine.DeleteAll(); OrderArchived := false; end; local procedure CheckHeaderShippingAdvice(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckHeaderShippingAdvice(SalesHeader, WhseShip, IsHandled); if IsHandled then exit; if (SalesHeader."Shipping Advice" = SalesHeader."Shipping Advice"::Complete) and SalesHeader.Ship then SalesHeader.CheckShippingAdvice(); end; local procedure CheckHeaderPostingType(var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckHeaderPostingType(SalesHeader, IsHandled); if IsHandled then exit; if not (SalesHeader.Ship or SalesHeader.Invoice or SalesHeader.Receive) then Error(ErrorInfo.Create(DocumentErrorsMgt.GetNothingToPostErrorMsg(), true, SalesHeader)); end; local procedure CheckAssosOrderLines(SalesHeader: Record "Sales Header") var SalesLine: Record "Sales Line"; PurchaseOrderLine: Record "Purchase Line"; PurchaseHeader: Record "Purchase Header"; TempPurchaseHeader: Record "Purchase Header" temporary; TempPurchaseLine: Record "Purchase Line" temporary; CheckDimensions: Codeunit "Check Dimensions"; IsHandled: Boolean; begin IsHandled := false; OnBeforeCheckAssosOrderLines(SalesHeader, IsHandled); if IsHandled then exit; SalesLine.Reset(); SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); SalesLine.SetFilter("Purch. Order Line No.", '<>0'); SalesLine.SetFilter("Qty. to Ship", '<>0'); OnCheckAssosOrderLinesOnAfterSetFilters(SalesLine, SalesHeader); if SalesLine.FindSet() then repeat PurchaseOrderLine.Get( PurchaseOrderLine."Document Type"::Order, SalesLine."Purchase Order No.", SalesLine."Purch. Order Line No."); TempPurchaseLine := PurchaseOrderLine; TempPurchaseLine.Insert(); TempPurchaseHeader."Document Type" := TempPurchaseHeader."Document Type"::Order; TempPurchaseHeader."No." := SalesLine."Purchase Order No."; if TempPurchaseHeader.Insert() then; until SalesLine.Next() = 0; if TempPurchaseHeader.FindSet() then repeat PurchaseHeader.Get(PurchaseHeader."Document Type"::Order, TempPurchaseHeader."No."); TempPurchaseLine.SetRange("Document No.", TempPurchaseHeader."No."); CheckDimensions.CheckPurchDim(PurchaseHeader, TempPurchaseLine); until TempPurchaseHeader.Next() = 0; end; local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine: Record "Sales Line"): Boolean var NeedUpdate: Boolean; IsHandled: Boolean; begin NeedUpdate := true; IsHandled := false; OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine, NeedUpdate, IsHandled); if IsHandled then exit(NeedUpdate); if SalesLine.Type <> SalesLine.Type::"Charge (Item)" then exit(false); if SalesLine."No." = '' then exit(false); if ((SalesLine.Type = SalesLine.Type::"Charge (Item)") and (SalesLine."Gen. Prod. Posting Group" <> '')) then exit(false); exit(true); end; local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine: Record "Sales Shipment Line"): Boolean var NeedUpdate: Boolean; IsHandled: Boolean; begin NeedUpdate := true; IsHandled := false; OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine, NeedUpdate, IsHandled); if IsHandled then exit(NeedUpdate); if SalesShipmentLine.Type <> SalesShipmentLine.Type::"Charge (Item)" then exit(false); if SalesShipmentLine."No." = '' then exit(false); if ((SalesShipmentLine.Type = SalesShipmentLine.Type::"Charge (Item)") and (SalesShipmentLine."Gen. Prod. Posting Group" <> '')) then exit(false); exit(true); end; local procedure NeedUpdateGenProdPostingGroupOnItemChargeOnReturnRecepitLine(ReturnReceiptLine: Record "Return Receipt Line"): Boolean var NeedUpdate: Boolean; IsHandled: Boolean; begin NeedUpdate := true; IsHandled := false; OnNeedUpdateGenProdPostingGroupOnItemChargeOnReturnReceiptLine(ReturnReceiptLine, NeedUpdate, IsHandled); if IsHandled then exit(NeedUpdate); if ReturnReceiptLine.Type <> ReturnReceiptLine.Type::"Charge (Item)" then exit(false); if ReturnReceiptLine."No." = '' then exit(false); if ((ReturnReceiptLine.Type = ReturnReceiptLine.Type::"Charge (Item)") and (ReturnReceiptLine."Gen. Prod. Posting Group" <> '')) then exit(false); exit(true); end; local procedure CheckDefaultNoSeries(NoSeriesCode: Code[20]) var NoSeries: Record "No. Series"; begin if NoSeries.Get(NoSeriesCode) then NoSeries.TestField("Default Nos.", true); end; local procedure CheckVATDate(var SalesHeader: Record "Sales Header") begin // ensure VAT Date is filled in if SalesHeader."VAT Reporting Date" = 0D then begin SalesHeader."VAT Reporting Date" := GLSetup.GetVATDate(SalesHeader."Posting Date", SalesHeader."Document Date"); SalesHeader.Modify(); end; end; local procedure ArchiveRelatedJob(SalesHeader: Record "Sales Header") var Job: Record Job; SalesLine: Record "Sales Line"; JobArchiveManagement: Codeunit "Job Archive Management"; IsHandled: Boolean; begin IsHandled := false; OnBeforeArchiveRelatedJob(SalesHeader, IsHandled); if IsHandled then exit; SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); SalesLine.SetFilter("Job No.", '<>%1', ''); if not SalesLine.FindFirst() then exit; if Job.Get(SalesLine."Job No.") then JobArchiveManagement.AutoArchiveJob(Job); end; local procedure IsInvoiceRoundingLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"): Boolean var CustomerPostingGroup: Record "Customer Posting Group"; begin if SalesLine.Type <> SalesLine.Type::"G/L Account" then exit(false); CustomerPostingGroup.Get(SalesHeader."Customer Posting Group"); if SalesLine."No." = CustomerPostingGroup."Invoice Rounding Account" then exit(true); exit(false); end; local procedure UpdateSalesOrderLineIfExist(DocumentNo: Code[20]) var SalesCreditMemoHeader: Record "Sales Cr.Memo Header"; CorrectPostedSalesInvoice: Codeunit "Correct Posted Sales Invoice"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateSalesOrderLineIfExist(DocumentNo, IsHandled); if IsHandled then exit; SalesCreditMemoHeader.SetLoadFields("Return Order No.", "No."); SalesCreditMemoHeader.SetRange("Return Order No.", DocumentNo); if SalesCreditMemoHeader.FindFirst() then CorrectPostedSalesInvoice.UpdateSalesOrderLineIfExist(SalesCreditMemoHeader."No."); end; /// <summary> /// Raised before updating a sales order line from a posted sales return order. /// </summary> /// <param name="DocumentNo">The number of the sales return order.</param> /// <param name="IsHandled">Set to true to skip the default sales order line update.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateSalesOrderLineIfExist(DocumentNo: Code[20]; var IsHandled: Boolean) begin end; /// <summary> /// Raised before posting sales lines. /// </summary> /// <param name="SalesLine">The sales line to be posted.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> /// <param name="TempWarehouseReceiptHeader">The temporary warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostLines(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary) begin end; /// <summary> /// Raised before posting a sales document. /// </summary> /// <param name="SalesHeader">The sales header to be posted.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="HideProgressWindow">Indicates whether to hide the progress window.</param> /// <param name="IsHandled">Set to true to skip the default posting logic.</param> /// <param name="CalledBy">Identifies the caller of the posting routine.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostSalesDoc(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; var HideProgressWindow: Boolean; var IsHandled: Boolean; var CalledBy: Integer) begin end; /// <summary> /// Raised before checking item tracking quantity on a sales line. /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <param name="IsHandled">Set to true to skip the default quantity check.</param> /// <param name="SalesHeader">The sales header of the document being posted.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckItemTrackingQuantity(SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before checking the tracking specification for a sales document. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="TempItemSalesLine">The temporary sales line with item tracking.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckTrackingSpecification(SalesHeader: Record "Sales Header"; var TempItemSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised before checking the certificate of supply status for a shipment. /// </summary> /// <param name="SalesShipmentHeader">The sales shipment header.</param> /// <param name="SalesShipmentLine">The sales shipment line.</param> /// <param name="IsHandled">Set to true to skip the default status check.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckCertificateOfSupplyStatus(SalesShipmentHeader: Record "Sales Shipment Header"; SalesShipmentLine: Record "Sales Shipment Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before committing the posted sales document. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TempSalesLineGlobal">The temporary sales lines being posted.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostCommitSalesDoc(var SalesHeader: Record "Sales Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; PreviewMode: Boolean; var ModifyHeader: Boolean; var CommitIsSuppressed: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary) begin end; /// <summary> /// Raised before determining end loop condition for received but not invoiced items. /// </summary> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="ReturnReceiptLine">The return receipt line being processed.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="EndLoop">Indicates whether to end the loop.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeIsEndLoopForReceivedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var ReturnReceiptLine: Record "Return Receipt Line"; var TempTrackingSpecification: Record "Tracking Specification"; SalesLine: Record "Sales Line"; var EndLoop: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised after calculating the prepayment VAT portion during prepayment amount adjustment. /// </summary> /// <param name="PrepmtVATPart">The calculated prepayment VAT portion.</param> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line being processed.</param> [IntegrationEvent(false, false)] local procedure OnAdjustPrepmtAmountLCYOnAfterCalcPrepmtVATPart(var PrepmtVATPart: Decimal; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") begin end; /// <summary> /// Raised after calculating whether a new invoice is required. /// </summary> /// <param name="TempSalesLine">The temporary sales lines being processed.</param> /// <param name="NewInvoice">Indicates whether a new invoice will be created.</param> /// <param name="SalesHeader">The sales header being processed.</param> [IntegrationEvent(false, false)] local procedure OnAfterCalcInvoice(var TempSalesLine: Record "Sales Line" temporary; var NewInvoice: Boolean; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after checking the sales document for posting readiness. /// </summary> /// <param name="SalesHeader">The sales header that was checked.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is required.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is required.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="ErrorMessageMgt">The error message management codeunit for handling errors.</param> [IntegrationEvent(false, false)] local procedure OnAfterCheckSalesDoc(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; PreviewMode: Boolean; var ErrorMessageMgt: Codeunit "Error Message Management") begin end; /// <summary> /// Raised after checking and updating the sales header for posting. /// </summary> /// <param name="SalesHeader">The sales header that was checked and updated.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnAfterCheckAndUpdate(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean) begin end; /// <summary> /// Raised after checking tracking and warehouse requirements for receiving. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="Receive">Indicates whether receiving is required.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="TempSalesLine">The temporary sales lines being processed.</param> [IntegrationEvent(false, false)] local procedure OnAfterCheckTrackingAndWarehouseForReceive(var SalesHeader: Record "Sales Header"; var Receive: Boolean; CommitIsSuppressed: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var TempSalesLine: record "Sales Line" temporary) begin end; /// <summary> /// Raised after checking tracking and warehouse requirements for shipping. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="Ship">Indicates whether shipping is required.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="TempSalesLine">The temporary sales lines being processed.</param> [IntegrationEvent(false, false)] local procedure OnAfterCheckTrackingAndWarehouseForShip(var SalesHeader: Record "Sales Header"; var Ship: Boolean; CommitIsSuppressed: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var TempSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after creating a warehouse journal line. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="TempWhseJnlLine">The temporary warehouse journal line that was created.</param> [IntegrationEvent(false, false)] local procedure OnAfterCreateWhseJnlLine(var SalesLine: Record "Sales Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary) begin end; /// <summary> /// Raised after copying sales lines to temporary lines. /// </summary> /// <param name="TempSalesLine">The temporary sales lines that were populated.</param> /// <param name="SalesHeader">The sales header being processed.</param> [IntegrationEvent(false, false)] local procedure OnAfterCopyToTempLines(var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after deleting documents after posting. /// </summary> /// <param name="SalesHeader">The sales header that was posted.</param> /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param> /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterDeleteAfterPosting(SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after retrieving the general ledger setup. /// </summary> /// <param name="GLSetup">The general ledger setup that was retrieved.</param> [IntegrationEvent(false, false)] local procedure OnAfterGetGLSetup(var GLSetup: Record "General Ledger Setup") begin end; /// <summary> /// Raised after retrieving sales lines for posting. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="NewSalesLine">The new sales line record.</param> [IntegrationEvent(false, false)] local procedure OnAfterGetSalesLines(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: record "Sales Line"; var NewSalesLine: record "Sales Line"); begin end; /// <summary> /// Raised after retrieving line data from the sales order. /// </summary> /// <param name="SalesLine">The sales line being populated.</param> /// <param name="SalesOrderLine">The source sales order line.</param> [IntegrationEvent(false, false)] local procedure OnAfterGetLineDataFromOrder(var SalesLine: Record "Sales Line"; SalesOrderLine: Record "Sales Line") begin end; /// <summary> /// Raised after retrieving the sales and receivables setup. /// </summary> /// <param name="SalesSetup">The sales and receivables setup that was retrieved.</param> [IntegrationEvent(false, false)] local procedure OnAfterGetSalesSetup(var SalesSetup: Record "Sales & Receivables Setup") begin end; /// <summary> /// Raised before retrieving sales lines for posting. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="NewSalesLine">The sales line record to be populated.</param> /// <param name="QtyType">The quantity type to retrieve.</param> /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetSalesLines(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; QtyType: Option; IncludePrepayments: Boolean) begin end; /// <summary> /// Raised before retrieving sales lines into temporary records. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="NewSalesLine">The new sales line record.</param> /// <param name="OldSalesLine">The original sales line record.</param> /// <param name="QtyType">The quantity type to retrieve.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetSalesLinesTemp(var SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option) begin end; /// <summary> /// Raised after incrementing the total amount with a sales line. /// </summary> /// <param name="TotalSalesLine">The total sales line being accumulated.</param> /// <param name="SalesLine">The sales line being added to the total.</param> /// <param name="SalesHeader">The sales header being processed.</param> [IntegrationEvent(false, false)] local procedure OnAfterIncrAmount(var TotalSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after initializing an associated item journal line for drop shipment. /// </summary> /// <param name="ItemJournalLine">The item journal line that was initialized.</param> /// <param name="PurchaseHeader">The associated purchase header.</param> /// <param name="PurchaseLine">The associated purchase line.</param> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeShipped">The quantity to be shipped.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> [IntegrationEvent(false, false)] local procedure OnAfterInitAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal) begin end; /// <summary> /// Raised after calculating the invoice rounding amount. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line for invoice rounding.</param> /// <param name="TotalSalesLine">The total sales line amounts.</param> /// <param name="UseTempData">Indicates whether to use temporary data.</param> /// <param name="InvoiceRoundingAmount">The calculated invoice rounding amount.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="Currency">The currency used for rounding.</param> /// <param name="BiggestLineNo">The biggest line number in the document.</param> /// <param name="LastLineRetrieved">Indicates whether the last line was retrieved.</param> /// <param name="RoundingLineInserted">Indicates whether a rounding line was inserted.</param> /// <param name="RoundingLineNo">The line number of the rounding line.</param> [IntegrationEvent(false, false)] local procedure OnAfterInvoiceRoundingAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TotalSalesLine: Record "Sales Line"; UseTempData: Boolean; InvoiceRoundingAmount: Decimal; CommitIsSuppressed: Boolean; Currency: Record Currency; var BiggestLineNo: Integer; var LastLineRetrieved: Boolean; var RoundingLineInserted: Boolean; var RoundingLineNo: Integer) begin end; /// <summary> /// Raised after inserting a drop shipment purchase receipt header. /// </summary> /// <param name="PurchRcptHeader">The purchase receipt header that was inserted.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertDropOrderPurchRcptHeader(var PurchRcptHeader: Record "Purch. Rcpt. Header") begin end; /// <summary> /// Raised after inserting a sales credit memo header. /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header that was inserted.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertCrMemoHeader(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; /// <summary> /// Raised after inserting a sales invoice header. /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SalesInvHeader">The sales invoice header that was inserted.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header") begin end; /// <summary> /// Raised after inserting the prepayment VAT base to deduct. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="PrepmtLineNo">The prepayment line number.</param> /// <param name="TotalPrepmtAmtToDeduct">The total prepayment amount to deduct.</param> /// <param name="TempPrepmtDeductLCYSalesLine">The temporary prepayment deduction line in LCY.</param> /// <param name="PrepmtVATBaseToDeduct">The prepayment VAT base amount to deduct.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertedPrepmtVATBaseToDeduct(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; PrepmtLineNo: Integer; TotalPrepmtAmtToDeduct: Decimal; var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; var PrepmtVATBaseToDeduct: Decimal) begin end; /// <summary> /// Raised after inserting all posted headers (shipment, invoice, credit memo, receipt). /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SalesShipmentHeader">The posted sales shipment header.</param> /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param> /// <param name="SalesCrMemoHdr">The posted sales credit memo header.</param> /// <param name="ReceiptHeader">The posted return receipt header.</param> /// <param name="GenJournalDocumentType">The general journal document type.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertPostedHeaders(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHdr: Record "Sales Cr.Memo Header"; var ReceiptHeader: Record "Return Receipt Header"; var GenJournalDocumentType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]) begin end; /// <summary> /// Raised after inserting a sales shipment header. /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SalesShipmentHeader">The sales shipment header that was inserted.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertShipmentHeader(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header") begin end; /// <summary> /// Raised after inserting a sales shipment line. /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="SalesShptLine">The sales shipment line that was inserted.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="xSalesLine">The original sales line before modification.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertShipmentLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesShptLine: record "Sales Shipment Line"; PreviewMode: Boolean; xSalesLine: Record "Sales Line") begin end; /// <summary> /// Raised after inserting a return receipt line for warehouse posting. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="xSalesLine">The original sales line before modification.</param> /// <param name="ReturnReceiptLine">The return receipt line that was inserted.</param> [IntegrationEvent(false, false)] local procedure OnAfterInsertReturnReceiptLineWhsePost(var SalesLine: Record "Sales Line"; xSalesLine: Record "Sales Line"; var ReturnReceiptLine: Record "Return Receipt Line") begin end; /// <summary> /// Raised after posting a drop shipment order. /// </summary> /// <param name="TempDropShptPostBuffer">The temporary drop shipment posting buffer.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostDropOrderShipment(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) begin end; /// <summary> /// Raised after posting a sales document. /// </summary> /// <param name="SalesHeader">The sales header that was posted.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="SalesShptHdrNo">The posted sales shipment header number.</param> /// <param name="RetRcpHdrNo">The posted return receipt header number.</param> /// <param name="SalesInvHdrNo">The posted sales invoice header number.</param> /// <param name="SalesCrMemoHdrNo">The posted sales credit memo header number.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param> /// <param name="CustLedgerEntry">The customer ledger entry that was created.</param> /// <param name="WhseShip">Indicates whether warehouse shipment was processed.</param> /// <param name="WhseReceiv">Indicates whether warehouse receipt was processed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostSalesDoc(var SalesHeader: Record "Sales Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; SalesShptHdrNo: Code[20]; RetRcpHdrNo: Code[20]; SalesInvHdrNo: Code[20]; SalesCrMemoHdrNo: Code[20]; CommitIsSuppressed: Boolean; InvtPickPutaway: Boolean; var CustLedgerEntry: Record "Cust. Ledger Entry"; WhseShip: Boolean; WhseReceiv: Boolean; PreviewMode: Boolean) begin end; /// <summary> /// Raised after updating the order line after posting. /// </summary> /// <param name="TempSalesLine">The temporary sales line that was updated.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostUpdateOrderLine(var TempSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after posting a sales document with drop shipment. /// </summary> /// <param name="PurchRcptNo">The purchase receipt number for the drop shipment.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostSalesDocDropShipment(PurchRcptNo: Code[20]; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after posting an item journal line for a sales line. /// </summary> /// <param name="ItemJournalLine">The item journal line that was posted.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> /// <param name="WhseJnlPostLine">The warehouse journal register line codeunit instance.</param> /// <param name="OriginalItemJnlLine">The original item journal line before posting.</param> /// <param name="ItemShptEntryNo">The item shipment entry number.</param> /// <param name="IsATO">Indicates whether this is an assemble-to-order transaction.</param> /// <param name="TempHandlingSpecification">The temporary handling tracking specification.</param> /// <param name="TempATOTrackingSpecification">The temporary ATO tracking specification.</param> /// <param name="TempWarehouseJournalLine">The temporary warehouse journal line.</param> /// <param name="ShouldPostItemJnlLine">Indicates whether the item journal line should be posted.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseRcptHeader">The warehouse receipt header.</param> [IntegrationEvent(true, false)] local procedure OnAfterPostItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line"; OriginalItemJnlLine: Record "Item Journal Line"; var ItemShptEntryNo: Integer; IsATO: Boolean; var TempHandlingSpecification: Record "Tracking Specification"; var TempATOTrackingSpecification: Record "Tracking Specification"; TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; ShouldPostItemJnlLine: Boolean; WhseShip: Boolean; WhseRcptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header") begin end; /// <summary> /// Raised after posting all sales lines. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesShipmentHeader">The sales shipment header.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="ReturnReceiptHeader">The return receipt header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment was processed.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt was processed.</param> /// <param name="SalesLinesProcessed">Indicates whether sales lines were processed.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="EverythingInvoiced">Indicates whether all lines were invoiced.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostSalesLines(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean; var SalesLinesProcessed: Boolean; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after posting a sales line. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line that was posted.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesInvLine">The sales invoice line that was created.</param> /// <param name="SalesCrMemoLine">The sales credit memo line that was created.</param> /// <param name="xSalesLine">The original sales line before posting.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostSalesLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var SalesInvLine: Record "Sales Invoice Line"; var SalesCrMemoLine: Record "Sales Cr.Memo Line"; var xSalesLine: Record "Sales Line") begin end; /// <summary> /// Raised after updating the invoice line during post update processing. /// </summary> /// <param name="TempSalesLine">The temporary sales line that was updated.</param> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempSalesOrderHeader">The temporary sales order header.</param> [IntegrationEvent(true, false)] local procedure OnAfterPostUpdateInvoiceLine(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempSalesOrderHeader: Record "Sales Header" temporary) begin end; /// <summary> /// Raised after updating the return receipt line during post update processing. /// </summary> /// <param name="TempSalesLine">The temporary sales line that was updated.</param> [IntegrationEvent(true, false)] local procedure OnAfterPostUpdateReturnReceiptLine(var TempSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after updating item charge assignments. /// </summary> /// <param name="SalesHeader">The sales header that was updated.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateItemChargeAssgnt(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after updating posting numbers. /// </summary> /// <param name="SalesHeader">The sales header that was updated.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdatePostingNos(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after updating the return receipt number. /// </summary> /// <param name="SalesHeader">The sales header that was updated.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateReturnReceiptNo(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after updating the shipping number. /// </summary> /// <param name="SalesHeader">The sales header that was updated.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateShippingNo(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; var ModifyHeader: Boolean) begin end; /// <summary> /// Raised after updating won opportunities. /// </summary> /// <param name="SalesHeader">The sales header that was posted.</param> /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateWonOpportunities(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header") begin end; /// <summary> /// Raised after checking mandatory fields. /// </summary> /// <param name="SalesHeader">The sales header that was checked.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterCheckMandatoryFields(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after inserting the sales invoice header. /// </summary> /// <param name="SalesInvHeader">The sales invoice header that was inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnAfterSalesInvHeaderInsert(var SalesInvHeader: Record "Sales Invoice Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header"; PreviewMode: Boolean) begin end; /// <summary> /// Raised after inserting a sales invoice line. /// </summary> /// <param name="SalesInvLine">The sales invoice line that was inserted.</param> /// <param name="SalesInvHeader">The sales invoice header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment records.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnAfterSalesInvLineInsert(var SalesInvLine: Record "Sales Invoice Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesLine: Record "Sales Line"; ItemLedgShptEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; var SalesHeader: Record "Sales Header"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; PreviewMode: Boolean) begin end; /// <summary> /// Raised after inserting the sales credit memo header. /// </summary> /// <param name="SalesCrMemoHeader">The sales credit memo header that was inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnAfterSalesCrMemoHeaderInsert(var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header") begin end; /// <summary> /// Raised after inserting a sales credit memo line. /// </summary> /// <param name="SalesCrMemoLine">The sales credit memo line that was inserted.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment records.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnAfterSalesCrMemoLineInsert(var SalesCrMemoLine: Record "Sales Cr.Memo Line"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; CommitIsSuppressed: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary) begin end; /// <summary> /// Raised after inserting the sales shipment header. /// </summary> /// <param name="SalesShipmentHeader">The sales shipment header that was inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SuppressCommit">Indicates whether database commits are suppressed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnAfterSalesShptHeaderInsert(var SalesShipmentHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; SuppressCommit: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header"; PreviewMode: Boolean) begin end; /// <summary> /// Raised after inserting a sales shipment line. /// </summary> /// <param name="SalesShipmentLine">The sales shipment line that was inserted.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="ItemShptLedEntryNo">The item shipment ledger entry number.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="SalesShptHeader">The sales shipment header.</param> /// <param name="SalesHeader">The sales header being posted.</param> [IntegrationEvent(false, false)] local procedure OnAfterSalesShptLineInsert(var SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line"; ItemShptLedEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; SalesInvoiceHeader: Record "Sales Invoice Header"; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; SalesShptHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after inserting the purchase receipt header for a drop shipment. /// </summary> /// <param name="PurchRcptHeader">The purchase receipt header that was inserted.</param> /// <param name="PurchaseHeader">The source purchase header.</param> /// <param name="SalesHeader">The related sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterPurchRcptHeaderInsert(var PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchaseHeader: Record "Purchase Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after inserting a purchase receipt line for a drop shipment. /// </summary> /// <param name="PurchRcptLine">The purchase receipt line that was inserted.</param> /// <param name="PurchRcptHeader">The purchase receipt header.</param> /// <param name="PurchOrderLine">The source purchase order line.</param> /// <param name="DropShptPostBuffer">The drop shipment posting buffer.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> [IntegrationEvent(false, false)] local procedure OnAfterPurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; CommitIsSuppressed: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after inserting the return receipt header. /// </summary> /// <param name="ReturnReceiptHeader">The return receipt header that was inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SuppressCommit">Indicates whether database commits are suppressed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnAfterReturnRcptHeaderInsert(var ReturnReceiptHeader: Record "Return Receipt Header"; SalesHeader: Record "Sales Header"; SuppressCommit: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header") begin end; /// <summary> /// Raised after inserting a return receipt line. /// </summary> /// <param name="ReturnRcptLine">The return receipt line that was inserted.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="ItemShptLedEntryNo">The item shipment ledger entry number.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="SalesHeader">The sales header being posted.</param> [IntegrationEvent(false, false)] local procedure OnAfterReturnRcptLineInsert(var ReturnRcptLine: Record "Return Receipt Line"; ReturnRcptHeader: Record "Return Receipt Header"; SalesLine: Record "Sales Line"; ItemShptLedEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after finalizing the posting process. /// </summary> /// <param name="SalesHeader">The sales header that was posted.</param> /// <param name="SalesShipmentHeader">The sales shipment header that was created.</param> /// <param name="SalesInvoiceHeader">The sales invoice header that was created.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header that was created.</param> /// <param name="ReturnReceiptHeader">The return receipt header that was created.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnAfterFinalizePosting(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; CommitIsSuppressed: Boolean; PreviewMode: Boolean) begin end; /// <summary> /// Raised after finalizing posting but before the database commit. /// </summary> /// <param name="SalesHeader">The sales header that was posted.</param> /// <param name="SalesShipmentHeader">The sales shipment header that was created.</param> /// <param name="SalesInvoiceHeader">The sales invoice header that was created.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header that was created.</param> /// <param name="ReturnReceiptHeader">The return receipt header that was created.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="WhseShip">Indicates whether warehouse shipment was processed.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt was processed.</param> /// <param name="EverythingInvoiced">Indicates whether all lines were invoiced.</param> [IntegrationEvent(false, false)] local procedure OnAfterFinalizePostingOnBeforeCommit(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var CommitIsSuppressed: Boolean; var PreviewMode: Boolean; WhseShip: Boolean; WhseReceive: Boolean; var EverythingInvoiced: Boolean) begin end; /// <summary> /// Raised after finding lines that have not been shipped. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempSalesLine">The temporary sales lines that have not been shipped.</param> [IntegrationEvent(false, false)] local procedure OnAfterFindNotShippedLines(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after resetting temporary sales lines. /// </summary> /// <param name="TempSalesLineLocal">The temporary sales lines that were reset.</param> [IntegrationEvent(false, false)] local procedure OnAfterResetTempLines(var TempSalesLineLocal: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after restoring the sales header from a copy. /// </summary> /// <param name="SalesHeader">The sales header that was restored.</param> /// <param name="SalesHeaderCopy">The copy of the sales header used for restoration.</param> [IntegrationEvent(false, false)] local procedure OnAfterRestoreSalesHeader(var SalesHeader: Record "Sales Header"; SalesHeaderCopy: Record "Sales Header") begin end; /// <summary> /// Raised after updating the sales header after posting. /// </summary> /// <param name="SalesHeader">The sales header that was updated.</param> /// <param name="TempSalesLine">The temporary sales lines.</param> [IntegrationEvent(true, false)] local procedure OnAfterUpdateAfterPosting(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised after updating the last posting numbers. /// </summary> /// <param name="SalesHeader">The sales header that was updated.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateLastPostingNos(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after updating the sales header with posting information. /// </summary> /// <param name="CustLedgerEntry">The customer ledger entry that was created.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="GenJnlLineDocType">The general journal line document type.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="SalesHeader">The sales header that was updated.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateSalesHeader(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; GenJnlLineDocType: Integer; GenJnlLineDocNo: Code[20]; PreviewMode: Boolean; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after updating the sales line before posting. /// </summary> /// <param name="SalesLine">The sales line that was updated.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateSalesLineBeforePost(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after checking if warehouse lines exist. /// </summary> /// <param name="WhseValidateSourceLine">The warehouse validate source line codeunit instance.</param> /// <param name="SalesLine">The sales line being checked.</param> /// <param name="ShowError">Indicates whether to show an error.</param> [IntegrationEvent(false, false)] local procedure OnAfterWhseLinesExist(var WhseValidateSourceLine: Codeunit "Whse. Validate Source Line"; SalesLine: Record "Sales Line"; var ShowError: Boolean) begin end; /// <summary> /// Raised before archiving the unposted order. /// </summary> /// <param name="SalesHeader">The sales header to be archived.</param> /// <param name="IsHandled">Set to true to skip the default archiving logic.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="OrderArchived">Indicates whether the order was archived.</param> [IntegrationEvent(false, false)] local procedure OnBeforeArchiveUnpostedOrder(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; PreviewMode: Boolean; var OrderArchived: Boolean) begin end; /// <summary> /// Raised before confirming the download of a shipment. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="Result">The result of the confirmation.</param> /// <param name="IsHandled">Set to true to skip the default confirmation logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeConfirmDownloadShipment(var SalesHeader: Record "Sales Header"; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before creating the posted warehouse receipt header. /// </summary> /// <param name="PostedWhseReceiptHeader">The posted warehouse receipt header to be created.</param> /// <param name="WarehouseReceiptHeader">The source warehouse receipt header.</param> /// <param name="SalesHeader">The related sales header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCreatePostedWhseRcptHeader(var PostedWhseReceiptHeader: Record "Posted Whse. Receipt Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before creating prepayment lines. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempPrepmtSalesLine">The temporary prepayment sales lines to be created.</param> /// <param name="CompleteFunctionality">Indicates whether complete functionality is enabled.</param> /// <param name="IsHandled">Set to true to skip the default prepayment line creation.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> [IntegrationEvent(true, false)] local procedure OnBeforeCreatePrepaymentLines(var SalesHeader: Record "Sales Header"; var TempPrepmtSalesLine: Record "Sales Line" temporary; CompleteFunctionality: Boolean; var IsHandled: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary) begin end; /// <summary> /// Raised before modifying the blanket order sales line. /// </summary> /// <param name="BlanketOrderSalesLine">The blanket order sales line to be modified.</param> /// <param name="SalesLine">The source sales line.</param> [IntegrationEvent(false, false)] local procedure OnBeforeBlanketOrderSalesLineModify(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line") begin end; /// <summary> /// Raised before creating the posted warehouse shipment header. /// </summary> /// <param name="PostedWhseShipmentHeader">The posted warehouse shipment header to be created.</param> /// <param name="WarehouseShipmentHeader">The source warehouse shipment header.</param> /// <param name="SalesHeader">The related sales header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCreatePostedWhseShptHeader(var PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before creating a warehouse journal line. /// </summary> /// <param name="ItemJnlLine">The item journal line being processed.</param> /// <param name="IsHandled">Set to true to skip the default warehouse journal line creation.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCreateWhseJnlLine(ItemJnlLine: Record "Item Journal Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before finalizing the posting process. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="EverythingInvoiced">Indicates whether all lines were invoiced.</param> /// <param name="SuppressCommit">Indicates whether database commits are suppressed.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> [IntegrationEvent(true, false)] local procedure OnBeforeFinalizePosting(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var EverythingInvoiced: Boolean; SuppressCommit: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line") begin end; /// <summary> /// Raised before initializing an associated item journal line for drop shipment. /// </summary> /// <param name="ItemJournalLine">The item journal line to be initialized.</param> /// <param name="PurchaseHeader">The associated purchase header.</param> /// <param name="PurchaseLine">The associated purchase line.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being processed.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInitAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; PurchaseHeader: Record "Purchase Header"; PurchaseLine: Record "Purchase Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; /// <summary> /// Raised before inserting an intercompany general journal line. /// </summary> /// <param name="ICGenJournalLine">The intercompany general journal line to be inserted.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertICGenJnlLine(var ICGenJournalLine: Record "Gen. Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised before inserting posted document headers. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="TempWarehouseShipmentHeader">The temporary warehouse shipment header.</param> /// <param name="TempWarehouseReceiptHeader">The temporary warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertPostedHeaders(var SalesHeader: Record "Sales Header"; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary) begin end; /// <summary> /// Raised before inserting the return receipt header. /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="ReturnReceiptHeader">The return receipt header to be inserted.</param> /// <param name="Handled">Set to true to skip the default insertion logic.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertReturnReceiptHeader(SalesHeader: Record "Sales Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var Handled: Boolean; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised before inserting a return receipt line during warehouse posting. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> /// <param name="ReturnRcptLine">The return receipt line to be inserted.</param> /// <param name="xSalesLine">The original sales line before modification.</param> /// <param name="PostedWhseRcptHeader">The posted warehouse receipt header.</param> /// <param name="WhseRcptHeader">The warehouse receipt header.</param> /// <param name="CostBaseAmount">The cost base amount.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertReturnReceiptLineWhsePost(SalesLine: Record "Sales Line"; ReturnRcptHeader: Record "Return Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean; TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var IsHandled: Boolean; var ReturnRcptLine: Record "Return Receipt Line"; var xSalesLine: Record "Sales Line"; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; var CostBaseAmount: Decimal) begin end; /// <summary> /// Raised before inserting the return entry relation. /// </summary> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="EntryNo">The entry number.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertReturnEntryRelation(var ReturnRcptLine: Record "Return Receipt Line"; var EntryNo: Integer; var IsHandled: Boolean) begin end; /// <summary> /// Raised before inserting the shipment entry relation. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="ItemShptEntryNo">The item shipment entry number.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertShptEntryRelation(SalesHeader: Record "Sales Header"; var SalesShptLine: Record "Sales Shipment Line"; var ItemShptEntryNo: Integer; var IsHandled: Boolean) begin end; /// <summary> /// Raised before inserting the sales invoice header. /// </summary> /// <param name="SalesHeader">The source sales header.</param> /// <param name="SalesInvHeader">The sales invoice header to be inserted.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertInvoiceHeader(SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before calculating the invoice rounding amount. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TotalAmountIncludingVAT">The total amount including VAT.</param> /// <param name="UseTempData">Indicates whether temporary data is being used.</param> /// <param name="InvoiceRoundingAmount">The invoice rounding amount.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TotalSalesLine">The total sales line record.</param> /// <param name="Currency">The currency record.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInvoiceRoundingAmount(SalesHeader: Record "Sales Header"; TotalAmountIncludingVAT: Decimal; UseTempData: Boolean; var InvoiceRoundingAmount: Decimal; CommitIsSuppressed: Boolean; var TotalSalesLine: Record "Sales Line"; var Currency: Record Currency) begin end; /// <summary> /// Raised before determining if the loop should end for shipped but not invoiced items. /// </summary> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="HasATOShippedNotInvoiced">Indicates whether there are assemble-to-order items shipped but not invoiced.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param> /// <param name="ItemLedgEntryNotInvoiced">The item ledger entry not invoiced.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="Result">The result indicating whether to end the loop.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeIsEndLoopForShippedNotInvoiced(RemQtyToBeInvoiced: Decimal; TrackingSpecificationExists: Boolean; var HasATOShippedNotInvoiced: Boolean; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var ItemLedgEntryNotInvoiced: Record "Item Ledger Entry"; SalesLine: Record "Sales Line"; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before posting the item journal line. /// </summary> /// <param name="ItemJournalLine">The item journal line to be posted.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default posting logic.</param> /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment records.</param> [IntegrationEvent(false, false)] local procedure OnBeforeItemJnlPostLine(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary) begin end; /// <summary> /// Raised before handling the archiving of an unposted order. /// </summary> /// <param name="SalesHeader">The sales header to be archived.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="IsHandled">Set to true to skip the default archiving logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeHandleArchiveUnpostedOrder(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before locking database tables. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default table locking logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeLockTables(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before making inventory adjustment during the Run procedure. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesInvHeader">The sales invoice header.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="SkipInventoryAdjustment">Indicates whether to skip the inventory adjustment.</param> [IntegrationEvent(false, false)] local procedure OnRunOnBeforeMakeInventoryAdjustment(var SalesHeader: Record "Sales Header"; SalesInvHeader: Record "Sales Invoice Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; PreviewMode: Boolean; var SkipInventoryAdjustment: Boolean) begin end; /// <summary> /// Raised before posting the intercompany general journal during the Run procedure. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="SrcCode">The source code.</param> /// <param name="GenJnlLineDocType">The general journal line document type.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="ReturnReceiptHeader">The return receipt header.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnRunOnBeforePostICGenJnl(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var SrcCode: Code[10]; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; var ReturnReceiptHeader: Record "Return Receipt Header"; var PreviewMode: Boolean) begin end; /// <summary> /// Raised before preparing to check the document. /// </summary> /// <param name="SalesHeader">The sales header to be checked.</param> [IntegrationEvent(false, false)] local procedure OnBeforePrepareCheckDocument(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before processing the associated item journal line for drop shipment. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="IsHandled">Set to true to skip the default processing logic.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="TempDropShptPostBuffer">The temporary drop shipment posting buffer.</param> [IntegrationEvent(false, false)] local procedure OnBeforeProcessAssocItemJnlLine(var SalesLine: Record "Sales Line"; var IsHandled: Boolean; var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) begin end; /// <summary> /// Raised before deleting all sales lines. /// </summary> /// <param name="SalesLine">The sales line record set to be deleted.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesHeader">The sales header being posted.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesLineDeleteAll(var SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before inserting the sales shipment header. /// </summary> /// <param name="SalesShptHeader">The sales shipment header to be inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesShptHeaderInsert(var SalesShptHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; WhseShip: Boolean; InvtPickPutaway: Boolean) begin end; /// <summary> /// Raised before inserting a sales shipment line. /// </summary> /// <param name="SalesShptLine">The sales shipment line to be inserted.</param> /// <param name="SalesShptHeader">The sales shipment header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PostedWhseShipmentLine">The posted warehouse shipment line.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param> /// <param name="xSalesLine">The original sales line before modification.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesShptLineInsert(var SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; PostedWhseShipmentLine: Record "Posted Whse. Shipment Line"; SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; ItemLedgShptEntryNo: Integer; xSalesLine: record "Sales Line"; var TempSalesLineGlobal: record "Sales Line" temporary; var IsHandled: Boolean) begin end; /// <summary> /// Raised before inserting the sales invoice header. /// </summary> /// <param name="SalesInvHeader">The sales invoice header to be inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseShptHeader">The warehouse shipment header.</param> /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesInvHeaderInsert(var SalesInvHeader: Record "Sales Invoice Header"; var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; WhseShip: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; InvtPickPutaway: Boolean) begin end; /// <summary> /// Raised before inserting a sales invoice line. /// </summary> /// <param name="SalesInvLine">The sales invoice line to be inserted.</param> /// <param name="SalesInvHeader">The sales invoice header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> /// <param name="PostingSalesLine">The posting sales line.</param> /// <param name="SalesShipmentHeader">The sales shipment header.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="ReturnReceiptHeader">The return receipt header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesInvLineInsert(var SalesInvLine: Record "Sales Invoice Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; PostingSalesLine: Record "Sales Line"; SalesShipmentHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; var ReturnReceiptHeader: Record "Return Receipt Header") begin end; /// <summary> /// Raised before inserting the sales credit memo header. /// </summary> /// <param name="SalesCrMemoHeader">The sales credit memo header to be inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> /// <param name="SalesInvHeader">The sales invoice header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesCrMemoHeaderInsert(var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var SalesInvHeader: Record "Sales Invoice Header") begin end; /// <summary> /// Raised before inserting a sales credit memo line. /// </summary> /// <param name="SalesCrMemoLine">The sales credit memo line to be inserted.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesShptHeader">The sales shipment header.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="PostingSalesLine">The posting sales line.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSalesCrMemoLineInsert(var SalesCrMemoLine: Record "Sales Cr.Memo Line"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var SalesHeader: Record "Sales Header"; var SalesShptHeader: Record "Sales Shipment Header"; var ReturnRcptHeader: Record "Return Receipt Header"; var PostingSalesLine: Record "Sales Line") begin end; /// <summary> /// Raised before inserting the purchase receipt header for a drop shipment. /// </summary> /// <param name="PurchRcptHeader">The purchase receipt header to be inserted.</param> /// <param name="PurchaseHeader">The source purchase header.</param> /// <param name="SalesHeader">The related sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="RunOnInsert">Indicates whether to run the OnInsert trigger.</param> [IntegrationEvent(false, false)] local procedure OnBeforePurchRcptHeaderInsert(var PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchaseHeader: Record "Purchase Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var RunOnInsert: Boolean) begin end; /// <summary> /// Raised before inserting a purchase receipt line for a drop shipment. /// </summary> /// <param name="PurchRcptLine">The purchase receipt line to be inserted.</param> /// <param name="PurchRcptHeader">The purchase receipt header.</param> /// <param name="PurchOrderLine">The source purchase order line.</param> /// <param name="DropShptPostBuffer">The drop shipment posting buffer.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="IsHandled">Set to true to skip the default insertion logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforePurchRcptLineInsert(var PurchRcptLine: Record "Purch. Rcpt. Line"; PurchRcptHeader: Record "Purch. Rcpt. Header"; PurchOrderLine: Record "Purchase Line"; DropShptPostBuffer: Record "Drop Shpt. Post. Buffer"; CommitIsSuppressed: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; /// <summary> /// Raised before releasing the sales document. /// </summary> /// <param name="SalesHeader">The sales header to be released.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnBeforeReleaseSalesDocument(SalesHeader: Record "Sales Header"; PreviewMode: Boolean) begin end; /// <summary> /// Raised before inserting the return receipt header. /// </summary> /// <param name="ReturnRcptHeader">The return receipt header to be inserted.</param> /// <param name="SalesHeader">The source sales header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> [IntegrationEvent(false, false)] local procedure OnBeforeReturnRcptHeaderInsert(var ReturnRcptHeader: Record "Return Receipt Header"; SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; WhseReceive: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; WhseShip: Boolean) begin end; /// <summary> /// Raised before inserting a return receipt line. /// </summary> /// <param name="ReturnRcptLine">The return receipt line to be inserted.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="SalesLine">The source sales line.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="xSalesLine">The original sales line before modification.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="SalesHeader">The sales header being posted.</param> [IntegrationEvent(false, false)] local procedure OnBeforeReturnRcptLineInsert(var ReturnRcptLine: Record "Return Receipt Line"; ReturnRcptHeader: Record "Return Receipt Header"; SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; xSalesLine: record "Sales Line"; var TempSalesLineGlobal: record "Sales Line" temporary; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before posting the job contract line for a sales document. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="IsHandled">Set to true to skip the default job contract line posting.</param> /// <param name="JobContractLine">Indicates whether this is a job contract line.</param> /// <param name="InvoicePostingInterface">The invoice posting interface.</param> /// <param name="SalesLineACY">The sales line in additional currency.</param> /// <param name="SalesInvHeader">The posted sales invoice header.</param> /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostJobContractLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; var JobContractLine: Boolean; var InvoicePostingInterface: Interface "Invoice Posting"; SalesLineACY: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; /// <summary> /// Raised before posting the associated item journal line for drop shipments. /// </summary> /// <param name="ItemJournalLine">The item journal line to be posted.</param> /// <param name="PurchaseLine">The associated purchase line.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="IsHandled">Set to true to skip the default posting logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostAssocItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var PurchaseLine: Record "Purchase Line"; CommitIsSuppressed: Boolean; var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before posting the item journal line for a sales line. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="QtyToBeShipped">The quantity to be shipped.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param> /// <param name="ItemChargeNo">The item charge number.</param> /// <param name="TrackingSpecification">The tracking specification.</param> /// <param name="IsATO">Indicates whether this is an assemble-to-order line.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default posting logic.</param> /// <param name="Result">The result of the posting operation.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="TempHandlingSpecification">The temporary handling specification.</param> /// <param name="TempValueEntryRelation">The temporary value entry relation.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostItemJnlLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var QtyToBeShipped: Decimal; var QtyToBeShippedBase: Decimal; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer; var ItemChargeNo: Code[20]; var TrackingSpecification: Record "Tracking Specification"; var IsATO: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean; var Result: Integer; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempHandlingSpecification: Record "Tracking Specification" temporary; var TempValueEntryRelation: Record "Value Entry Relation" temporary; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line") begin end; /// <summary> /// Raised before copying document fields to the item journal line. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="QtyToBeShipped">The quantity to be shipped.</param> /// <param name="QtyToBeShippedIsZero">Indicates whether the quantity to be shipped is zero.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostItemJnlLineCopyDocumentFields(SalesHeader: Record "Sales Header"; QtyToBeShipped: Decimal; var QtyToBeShippedIsZero: Boolean) begin end; /// <summary> /// Raised before posting item charges per order. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="ItemJnlLine2">The item journal line for the item charge.</param> /// <param name="ItemChargeSalesLine">The sales line containing the item charge.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemChargePerOrder(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var ItemJnlLine2: Record "Item Journal Line"; var ItemChargeSalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised before updating posting numbers for the sales document. /// </summary> /// <param name="SalesHeader">The sales header to update.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdatePostingNos(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var ModifyHeader: Boolean) begin end; /// <summary> /// Raised after preparing the item journal line but before posting it. /// </summary> /// <param name="ItemJournalLine">The item journal line to be posted.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> /// <param name="CheckApplFromItemEntry">Indicates whether to check application from item entry.</param> /// <param name="TrackingSpecification">The tracking specification.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostItemJnlLineBeforePost(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShippedBase: Decimal; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var CheckApplFromItemEntry: Boolean; var TrackingSpecification: Record "Tracking Specification") begin end; /// <summary> /// Raised after posting the item journal line warehouse line. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="ItemLedgEntryNo">The item ledger entry number.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostItemJnlLineWhseLine(SalesLine: Record "Sales Line"; ItemLedgEntryNo: Integer; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after posting item tracking for return receipt. /// </summary> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesShipmentLine">The sales shipment line.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="ReturnReceiptLine">The return receipt line.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostItemTrackingReturnRcpt(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin end; /// <summary> /// Raised after posting item tracking for shipment. /// </summary> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesShipmentLine">The sales shipment line.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostItemTrackingForShipment(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin end; /// <summary> /// Raised after posting the item line. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="QtyToInvoice">The quantity to invoice.</param> /// <param name="QtyToInvoiceBase">The quantity to invoice in base unit of measure.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostItemLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyToInvoice: Decimal; QtyToInvoiceBase: Decimal; CommitIsSuppressed: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line") begin end; /// <summary> /// Raised after posting an item charge. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="TempItemChargeAssignmentSales">The temporary item charge assignment.</param> /// <param name="ItemLedgEntryNo">The item ledger entry number.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostItemCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; ItemLedgEntryNo: Integer) begin end; /// <summary> /// Raised after testing the sales line for posting readiness. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line that was tested.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnAfterTestSalesLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised after updating and modifying the temporary order line during post update. /// </summary> /// <param name="SalesLine">The sales line that was modified.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesHeader">The sales header being processed.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostUpdateOrderLineModifyTempLine(SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after posting G/L entries and customer ledger entries. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="TotalSalesLine">The total sales line amounts.</param> /// <param name="TotalSalesLineLCY">The total sales line amounts in local currency.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="WhseShptHeader">The warehouse shipment header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> /// <param name="SalesInvHeader">The posted sales invoice header.</param> /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param> /// <param name="CustLedgEntry">The customer ledger entry that was created.</param> /// <param name="SrcCode">The source code.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param> /// <param name="GenJnlLineDocType">The general journal line document type.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="DropShipOrder">Indicates whether this is a drop shipment order.</param> [IntegrationEvent(true, false)] local procedure OnAfterPostGLAndCustomer(var SalesHeader: Record "Sales Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; TotalSalesLine: Record "Sales Line"; TotalSalesLineLCY: Record "Sales Line"; CommitIsSuppressed: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; WhseShip: Boolean; var TempWhseShptHeader: Record "Warehouse Shipment Header"; var SalesInvHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var CustLedgEntry: Record "Cust. Ledger Entry"; var SrcCode: Code[10]; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; PreviewMode: Boolean; DropShipOrder: Boolean) begin end; /// <summary> /// Raised after posting the resource journal line. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="JobTaskSalesLine">The job task sales line.</param> /// <param name="ResJnlLine">The resource journal line that was posted.</param> [IntegrationEvent(false, false)] local procedure OnAfterPostResJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; JobTaskSalesLine: Record "Sales Line"; ResJnlLine: Record "Res. Journal Line") begin end; /// <summary> /// Raised after reversing the amount on a sales line. /// </summary> /// <param name="SalesLine">The sales line with reversed amounts.</param> [IntegrationEvent(false, false)] local procedure OnAfterReverseAmount(var SalesLine: Record "Sales Line") begin end; /// <summary> /// Raised after dividing amounts on a sales line for VAT calculation. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line with divided amounts.</param> /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param> /// <param name="SalesLineQty">The sales line quantity.</param> /// <param name="TempVATAmountLine">The temporary VAT amount line.</param> /// <param name="TempVATAmountLineRemainder">The temporary VAT amount line remainder.</param> [IntegrationEvent(false, false)] local procedure OnAfterDivideAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary) begin end; /// <summary> /// Raised after rounding amounts on a sales line. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line with rounded amounts.</param> /// <param name="SalesLineQty">The sales line quantity.</param> [IntegrationEvent(false, false)] local procedure OnAfterRoundAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal) begin end; /// <summary> /// Raised after updating the blanket order line. /// </summary> /// <param name="BlanketOrderSalesLine">The blanket order sales line that was updated.</param> /// <param name="SalesLine">The sales line used to update the blanket order.</param> /// <param name="Ship">Indicates whether the document is being shipped.</param> /// <param name="Receive">Indicates whether the document is being received.</param> /// <param name="Invoice">Indicates whether the document is being invoiced.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateBlanketOrderLine(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean) begin end; /// <summary> /// Raised after updating the prepayment sales line with rounding. /// </summary> /// <param name="PrepmtSalesLine">The prepayment sales line that was updated.</param> /// <param name="TotalRoundingAmount">The total rounding amounts.</param> /// <param name="TotalPrepmtAmount">The total prepayment amounts.</param> /// <param name="FinalInvoice">Indicates whether this is the final invoice.</param> /// <param name="PricesInclVATRoundingAmount">The prices including VAT rounding amounts.</param> /// <param name="TotalSalesLine">The total sales line amounts.</param> /// <param name="TotalSalesLineLCY">The total sales line amounts in local currency.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdatePrepmtSalesLineWithRounding(var PrepmtSalesLine: Record "Sales Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line") begin end; /// <summary> /// Raised after updating warehouse documents. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="WhseShptHeader">The warehouse shipment header.</param> /// <param name="WhseRcptHeader">The warehouse receipt header.</param> /// <param name="EverythingInvoiced">Indicates whether everything has been invoiced.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateWhseDocuments(SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; EverythingInvoiced: Boolean) begin end; /// <summary> /// Raised after updating associated order posting numbers. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempSalesLine">The temporary sales lines.</param> /// <param name="DropShipment">Indicates whether this is a drop shipment.</param> [IntegrationEvent(false, false)] local procedure OnAfterUpdateAssosOrderPostingNos(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var DropShipment: Boolean) begin end; /// <summary> /// Raised after releasing the sales document. /// </summary> /// <param name="SalesHeader">The sales header that was released.</param> [IntegrationEvent(false, false)] local procedure OnAfterReleaseSalesDoc(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after validating the posting and document dates. /// </summary> /// <param name="SalesHeader">The sales header that was validated.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="ReplacePostingDate">Indicates whether the posting date should be replaced.</param> /// <param name="ReplaceDocumentDate">Indicates whether the document date should be replaced.</param> [IntegrationEvent(false, false)] local procedure OnAfterValidatePostingAndDocumentDate(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; ReplacePostingDate: Boolean; ReplaceDocumentDate: Boolean) begin end; /// <summary> /// Raised before calculating the invoice. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="NewInvoice">Indicates whether a new invoice will be created.</param> /// <param name="IsHandled">Set to true to skip the default calculation logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCalcInvoice(SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var NewInvoice: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before calculating item journal line amounts from quantity to be shipped. /// </summary> /// <param name="ItemJnlLine">The item journal line.</param> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeShipped">The quantity to be shipped.</param> /// <param name="IsHandled">Set to true to skip the default calculation logic.</param> /// <param name="InvDiscAmountPerShippedQty">The invoice discount amount per shipped quantity.</param> /// <param name="RemAmt">The remaining amount.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCalcItemJnlAmountsFromQtyToBeShipped(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; var IsHandled: Boolean; var InvDiscAmountPerShippedQty: Decimal; RemAmt: Decimal) begin end; /// <summary> /// Raised before checking associated order lines. /// </summary> /// <param name="SalesHeader">The sales header being checked.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckAssosOrderLines(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking customer blockage. /// </summary> /// <param name="SalesHeader">The sales header being checked.</param> /// <param name="CustCode">The customer code to check.</param> /// <param name="ExecuteDocCheck">Indicates whether to execute document check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> /// <param name="TempSalesLine">The temporary sales lines.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckCustBlockage(SalesHeader: Record "Sales Header"; CustCode: Code[20]; var ExecuteDocCheck: Boolean; var IsHandled: Boolean; var TempSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised before checking if job number on shipment line equals sales line. /// </summary> /// <param name="SalesShipmentLine">The sales shipment line.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckJobNoOnShptLineEqualToSales(SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking G/L account direct posting settings. /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckGLAccountDirectPosting(SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking whether to insert the return receipt header. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckInsertReturnReceiptHeader(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking item reservation disruption. /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckItemReservDisruption(SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking mandatory header fields. /// </summary> /// <param name="SalesHeader">The sales header to check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckMandatoryHeaderFields(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking whether to post warehouse receipt line from shipment line. /// </summary> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckPostWhseRcptLineFromShipmentLine(var SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking whether to post warehouse shipment lines. /// </summary> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> /// <param name="WhseShptHeader">The warehouse shipment header.</param> /// <param name="WhseRcptHeader">The warehouse receipt header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckPostWhseShptLines(var SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean; WhseShptHeader: Record "Warehouse Shipment Header"; WhseRcptHeader: Record "Warehouse Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean) begin end; /// <summary> /// Raised before checking posting flags. /// </summary> /// <param name="SalesHeader">The sales header to check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckPostingFlags(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking prepayment amount to deduct. /// </summary> /// <param name="TempSalesLine">The temporary sales lines.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> /// <param name="Fraction">The fraction for calculation.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckPrepmtAmtToDeduct(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; Fraction: Decimal) begin end; /// <summary> /// Raised before checking header shipping advice. /// </summary> /// <param name="SalesHeader">The sales header to check.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckHeaderShippingAdvice(SalesHeader: Record "Sales Header"; WhseShip: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking header posting type. /// </summary> /// <param name="SalesHeader">The sales header to check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckHeaderPostingType(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking if sales line is invoiced more than shipped. /// </summary> /// <param name="SalesOrderLine">The sales order line.</param> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckSalesLineInvoiceMoreThanShipped(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var SalesShptLine: Record "Sales Shipment Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking the total invoice amount. /// </summary> /// <param name="SalesHeader">The sales header to check.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckTotalInvoiceAmount(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking the total prepayment amount to deduct. /// </summary> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="TempTotalSalesLine">The temporary total sales line.</param> /// <param name="MaxAmtToDeduct">The maximum amount to deduct.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckTotalPrepmtAmtToDeduct(var TempSalesLine: Record "Sales Line" temporary; var TempTotalSalesLine: Record "Sales Line" temporary; var MaxAmtToDeduct: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking warehouse requirements. /// </summary> /// <param name="TempItemSalesLine">The temporary item sales line.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeCheckWarehouse(var TempItemSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; /// <summary> /// Raised before clearing remaining amount if not item journal roll rounding. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="ItemJnlRollRndg">Indicates whether item journal roll rounding is used.</param> /// <param name="RemAmt">The remaining amount.</param> /// <param name="RemDiscAmt">The remaining discount amount.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeClearRemAmtIfNotItemJnlRollRndg(SalesLine: Record "Sales Line"; ItemJnlRollRndg: Boolean; var RemAmt: Decimal; var RemDiscAmt: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before dividing amounts on a sales line for VAT calculation. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line to process.</param> /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param> /// <param name="SalesLineQty">The sales line quantity.</param> /// <param name="TempVATAmountLine">The temporary VAT amount line.</param> /// <param name="TempVATAmountLineRemainder">The temporary VAT amount line remainder.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="TempPrepmtDeductLCYSalesLine">The temporary prepayment deduct LCY sales line.</param> [IntegrationEvent(false, false)] local procedure OnBeforeDivideAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; var IsHandled: Boolean; var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary) begin end; /// <summary> /// Raised before initializing line amount and line discount amount during divide amount. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line to process.</param> /// <param name="SalesLineQty">The sales line quantity.</param> /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="TempPrepmtDeductLCYSalesLine">The temporary prepayment deduct LCY sales line.</param> /// <param name="TempVATAmountLine">The temporary VAT amount line.</param> [IntegrationEvent(true, false)] local procedure OnBeforeDivideAmountInitLineAmountAndLineDiscountAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesLineQty: Decimal; IncludePrepayments: Boolean; var IsHandled: Boolean; var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; var TempVATAmountLine: Record "VAT Amount Line" temporary) begin end; /// <summary> /// Raised before getting the invoice posting setup. /// </summary> /// <param name="InvoicePostingInterface">The invoice posting interface.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetInvoicePostingSetup(var InvoicePostingInterface: Interface "Invoice Posting"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before rounding amounts on a sales line. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="SalesLine">The sales line to round.</param> /// <param name="SalesLineQty">The sales line quantity.</param> /// <param name="CurrExchRate">The currency exchange rate.</param> [IntegrationEvent(false, false)] local procedure OnBeforeRoundAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesLineQty: Decimal; var CurrExchRate: Record "Currency Exchange Rate") begin end; /// <summary> /// Raised before posting assemble-to-order. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="TempPostedATOLink">The temporary posted assemble-to-order link.</param> /// <param name="AsmPost">The assembly post codeunit instance.</param> /// <param name="ItemJnlPostLine">The item journal post line codeunit instance.</param> /// <param name="ResJnlPostLine">The resource journal post line codeunit instance.</param> /// <param name="WhseJnlPostLine">The warehouse journal register line codeunit instance.</param> /// <param name="HideProgressWindow">Indicates whether to hide the progress window.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var AsmPost: Codeunit "Assembly-Post"; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var ResJnlPostLine: Codeunit "Res. Jnl.-Post Line"; var WhseJnlPostLine: Codeunit "Whse. Jnl.-Register Line"; HideProgressWindow: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before posting the drop shipment order. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="TempDropShptPostBuffer">The temporary drop shipment post buffer.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostDropOrderShipment(var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) begin end; /// <summary> /// Raised before posting the invoice. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="CustLedgerEntry">The customer ledger entry to be created.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="GenJnlPostLine">The general journal post line codeunit instance.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param> /// <param name="GenJnlLineDocType">The general journal line document type.</param> /// <param name="SrcCode">The source code.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostInvoice(var SalesHeader: Record "Sales Header"; var CustLedgerEntry: Record "Cust. Ledger Entry"; CommitIsSuppressed: Boolean; PreviewMode: Boolean; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; SrcCode: Code[10]) begin end; /// <summary> /// Raised before posting an item charge. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line containing the item charge.</param> /// <param name="TempItemChargeAssignmentSales">The temporary item charge assignment.</param> /// <param name="ItemLedgEntryNo">The item ledger entry number.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; ItemLedgEntryNo: Integer) begin end; /// <summary> /// Raised before posting item tracking. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="TempItemLedgEntryNotInvoiced">The temporary item ledger entries not invoiced.</param> /// <param name="HasATOShippedNotInvoiced">Indicates whether ATO has been shipped but not invoiced.</param> /// <param name="PreciseTotalChargeAmt">The precise total charge amount.</param> /// <param name="RoundedPrevTotalChargeAmt">The rounded previous total charge amount.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="ItemJnlRollRndg">Indicates whether item journal roll rounding is used.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostItemTracking(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean; TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean; var PreciseTotalChargeAmt: Decimal; var RoundedPrevTotalChargeAmt: Decimal; RemQtyToBeInvoiced: Decimal; var ItemJnlRollRndg: Boolean) begin end; /// <summary> /// Raised before checking item tracking for return receipt posting. /// </summary> /// <param name="SalesLine">The sales line being checked.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostItemTrackingCheckReturnReceipt(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before checking item tracking for shipment posting. /// </summary> /// <param name="SalesLine">The sales line being checked.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="IsHandled">Set to true to skip the default check logic.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostItemTrackingCheckShipment(SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before posting item tracking for return receipt. /// </summary> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesShipmentLine">The sales shipment line.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="ReturnReceiptLine">The return receipt line.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemTrackingReturnRcpt(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin end; /// <summary> /// Raised before posting item tracking for shipment. /// </summary> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesShipmentLine">The sales shipment line.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemTrackingForShipment(var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesShipmentLine: Record "Sales Shipment Line"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin end; /// <summary> /// Raised before posting the resource journal line. /// </summary> /// <param name="SalesHeader">The sales header being posted.</param> /// <param name="SalesLine">The sales line being posted.</param> /// <param name="JobTaskSalesLine">The job task sales line.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="DocNo">The document number.</param> /// <param name="ExtDocNo">The external document number.</param> /// <param name="SourceCode">The source code.</param> /// <param name="SalesShptHeader">The sales shipment header.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="ResJnlPostLine">The resource journal post line codeunit instance.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostResJnlLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var JobTaskSalesLine: Record "Sales Line"; var IsHandled: Boolean; DocNo: Code[20]; ExtDocNo: Code[35]; SourceCode: Code[10]; SalesShptHeader: Record "Sales Shipment Header"; ReturnRcptHeader: Record "Return Receipt Header"; var ResJnlPostLine: Codeunit "Res. Jnl.-Post Line") begin end; /// <summary> /// Raised before updating the order line during post processing. /// </summary> /// <param name="SalesHeader">The sales header being processed.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="SalesSetup">The sales and receivables setup.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostUpdateOrderLine(SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; CommitIsSuppressed: Boolean; var SalesSetup: Record "Sales & Receivables Setup") begin end; /// <summary> /// Raised before modifying the temporary order line during post update. /// </summary> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="SalesHeader">The sales header being processed.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostUpdateOrderLineModifyTempLine(var TempSalesLine: Record "Sales Line" temporary; WhseShip: Boolean; WhseReceive: Boolean; CommitIsSuppressed: Boolean; var IsHandled: Boolean; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before posting warehouse receipt line from shipment line. /// </summary> /// <param name="WhseRcptLine">The warehouse receipt line.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="PostedWhseRcptHeader">The posted warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostWhseRcptLineFromShipmentLine(var WhseRcptLine: Record "Warehouse Receipt Line"; SalesShptLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header") begin end; /// <summary> /// Raised before validating posting and document dates. /// </summary> /// <param name="SalesHeader">The sales header to validate.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default validation logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeValidatePostingAndDocumentDate(var SalesHeader: Record "Sales Header"; CommitIsSuppressed: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating invoiced quantity on shipment line. /// </summary> /// <param name="SalesShipmentLine">The sales shipment line to update.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateInvoicedQtyOnShipmentLine(var SalesShipmentLine: Record "Sales Shipment Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised before the update invoiced quantity on shipment line procedure. /// </summary> /// <param name="SalesShptLine">The sales shipment line to update.</param> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateInvoicedQtyOnShipmentLineProcedure(var SalesShptLine: Record "Sales Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin end; /// <summary> /// Raised before sending the intercompany document. /// </summary> /// <param name="SalesHeader">The sales header to send.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> /// <param name="IsHandled">Set to true to skip the default send logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSendICDocument(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before setting posting flags. /// </summary> /// <param name="SalesHeader">The sales header to set flags for.</param> /// <param name="IsHandled">Set to true to skip the default flag setting logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSetPostingFlags(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before testing fields by document type. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line to test.</param> /// <param name="IsHandled">Set to true to skip the default test logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestFieldsByDocType(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before testing the sales line for posting readiness. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line to test.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="IsHandled">Set to true to skip the default test logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestSalesLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; CommitIsSuppressed: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before testing the sales line for fixed asset posting. /// </summary> /// <param name="SalesLine">The sales line to test.</param> /// <param name="IsHandled">Set to true to skip the default test logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestSalesLineFixedAsset(SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before testing the sales line for item charge posting. /// </summary> /// <param name="SalesLine">The sales line to test.</param> /// <param name="IsHandled">Set to true to skip the default test logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestSalesLineItemCharge(SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before testing the sales line for job posting. /// </summary> /// <param name="SalesLine">The sales line to test.</param> /// <param name="SkipTestJobNo">Set to true to skip the job number test.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestSalesLineJob(SalesLine: Record "Sales Line"; var SkipTestJobNo: Boolean) begin end; /// <summary> /// Raised before testing the updated sales line. /// </summary> /// <param name="SalesLine">The sales line to test.</param> /// <param name="IsHandled">Set to true to skip the default test logic.</param> /// <param name="ErrorMessageManagement">The error message management codeunit for handling errors.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestUpdatedSalesLine(SalesLine: Record "Sales Line"; var IsHandled: Boolean; var ErrorMessageManagement: Codeunit "Error Message Management") begin end; /// <summary> /// Raised before testing the sales line for other posting scenarios. /// </summary> /// <param name="SalesLine">The sales line to test.</param> /// <param name="SkipTestJobNo">Set to true to skip the job number test.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestSalesLineOthers(SalesLine: Record "Sales Line"; var SkipTestJobNo: Boolean) begin end; /// <summary> /// Raised before testing the status for release. /// </summary> /// <param name="SalesHeader">The sales header to test.</param> /// <param name="IsHandled">Set to true to skip the default status test logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTestStatusRelease(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before inserting the temporary prepayment sales line. /// </summary> /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line to insert.</param> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="CompleteFunctionality">Indicates whether to use complete functionality.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTempPrepmtSalesLineInsert(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean) begin end; /// <summary> /// Raised before modifying the temporary prepayment sales line. /// </summary> /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line to modify.</param> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="CompleteFunctionality">Indicates whether to use complete functionality.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTempPrepmtSalesLineModify(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean) begin end; /// <summary> /// Raised before transferring reservation to item journal line. /// </summary> /// <param name="SalesOrderLine">The sales order line.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> /// <param name="IsHandled">Set to true to skip the default transfer logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeTransferReservToItemJnlLine(var SalesOrderLine: Record "Sales Line"; var QtyToBeShippedBase: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before releasing the sales document. /// </summary> /// <param name="SalesHeader">The sales header to release.</param> [IntegrationEvent(false, false)] local procedure OnBeforeReleaseSalesDoc(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before updating associated order posting numbers. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="DropShipment">Indicates whether this is a drop shipment.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateAssosOrderPostingNos(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; PreviewMode: Boolean; var DropShipment: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating associated lines. /// </summary> /// <param name="SalesOrderLine">The sales order line.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateAssocLines(var SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating the blanket order line. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="Ship">Indicates whether the document is being shipped.</param> /// <param name="Receive">Indicates whether the document is being received.</param> /// <param name="Invoice">Indicates whether the document is being invoiced.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateBlanketOrderLine(SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating the handled intercompany inbox transaction. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateHandledICInboxTransaction(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating the posting number. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> /// <param name="DateOrderSeriesUsed">Indicates whether date order series is used.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdatePostingNo(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean; var ModifyHeader: Boolean; var IsHandled: Boolean; var DateOrderSeriesUsed: Boolean) begin end; /// <summary> /// Raised before updating the prepayment sales line with rounding. /// </summary> /// <param name="PrepmtSalesLine">The prepayment sales line.</param> /// <param name="TotalRoundingAmount">The total rounding amounts.</param> /// <param name="TotalPrepmtAmount">The total prepayment amounts.</param> /// <param name="FinalInvoice">Indicates whether this is the final invoice.</param> /// <param name="PricesInclVATRoundingAmount">The prices including VAT rounding amounts.</param> /// <param name="TotalSalesLine">The total sales line amounts.</param> /// <param name="TotalSalesLineLCY">The total sales line amounts in local currency.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdatePrepmtSalesLineWithRounding(var PrepmtSalesLine: Record "Sales Line"; TotalRoundingAmount: array[2] of Decimal; TotalPrepmtAmount: array[2] of Decimal; FinalInvoice: Boolean; PricesInclVATRoundingAmount: array[2] of Decimal; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line") begin end; /// <summary> /// Raised before updating quantity to be invoiced for shipment. /// </summary> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="HasATOShippedNotInvoiced">Indicates whether ATO has been shipped but not invoiced.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateQtyToBeInvoicedForShipment(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; InvoicingTrackingSpecification: Record "Tracking Specification") begin end; /// <summary> /// Raised before updating quantity to be invoiced for return receipt. /// </summary> /// <param name="QtyToBeInvoiced">The quantity to be invoiced.</param> /// <param name="QtyToBeInvoicedBase">The quantity to be invoiced in base unit of measure.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="ReturnReceiptLine">The return receipt line.</param> /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateQtyToBeInvoicedForReturnReceipt(var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; SalesLine: Record "Sales Line"; ReturnReceiptLine: Record "Return Receipt Line"; InvoicingTrackingSpecification: Record "Tracking Specification"; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating the return receipt number. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateReturnReceiptNo(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean; var IsHandled: Boolean; PreviewMode: Boolean) begin end; /// <summary> /// Raised before updating the sales header. /// </summary> /// <param name="CustLedgerEntry">The customer ledger entry.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> /// <param name="GenJnlLineDocType">The general journal line document type.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateSalesHeader(var CustLedgerEntry: Record "Cust. Ledger Entry"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; GenJnlLineDocType: Option; var IsHandled: Boolean; GenJnlLineDocNo: Code[20]; PreviewMode: Boolean; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before updating the sales line before posting. /// </summary> /// <param name="SalesLine">The sales line to update.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="RoundingLineInserted">Indicates whether a rounding line was inserted.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateSalesLineBeforePost(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; RoundingLineInserted: Boolean; CommitIsSuppressed: Boolean) begin end; /// <summary> /// Raised before updating the shipping number. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="InvtPickPutaway">Indicates whether inventory pick/put-away is involved.</param> /// <param name="PreviewMode">Indicates whether the posting is in preview mode.</param> /// <param name="ModifyHeader">Indicates whether the header should be modified.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateShippingNo(var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; PreviewMode: Boolean; var ModifyHeader: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before updating warehouse documents. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="IsHandled">Set to true to skip the default update logic.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseRcptHeader">The warehouse receipt header.</param> /// <param name="WhseShptHeader">The warehouse shipment header.</param> /// <param name="TempWhseRcptHeader">The temporary warehouse receipt header.</param> /// <param name="TempWhseShptHeader">The temporary warehouse shipment header.</param> [IntegrationEvent(false, false)] local procedure OnBeforeUpdateWhseDocuments(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; WhseReceive: Boolean; WhseShip: Boolean; WhseRcptHeader: Record "Warehouse Receipt Header"; WhseShptHeader: Record "Warehouse Shipment Header"; var TempWhseRcptHeader: Record "Warehouse Receipt Header" temporary; var TempWhseShptHeader: Record "Warehouse Shipment Header" temporary) begin end; /// <summary> /// Raised before determining if warehouse handling is required. /// </summary> /// <param name="SalesLine">The sales line to check.</param> /// <param name="Required">Indicates whether warehouse handling is required.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeWhseHandlingRequired(SalesLine: Record "Sales Line"; var Required: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised when invoicing a sales shipment line. /// </summary> /// <param name="SalesShipmentLine">The sales shipment line being invoiced.</param> /// <param name="InvoiceNo">The invoice number.</param> /// <param name="InvoiceLineNo">The invoice line number.</param> /// <param name="QtyToInvoice">The quantity to invoice.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnInvoiceSalesShptLine(SalesShipmentLine: Record "Sales Shipment Line"; InvoiceNo: Code[20]; InvoiceLineNo: Integer; QtyToInvoice: Decimal; CommitIsSuppressed: Boolean) begin end; local procedure PostResJnlLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var JobTaskSalesLine2: Record "Sales Line") var ResJnlLine: Record "Res. Journal Line"; IsHandled: Boolean; ShouldExit: Boolean; begin IsHandled := false; OnBeforePostResJnlLine(SalesHeader, SalesLine, JobTaskSalesLine2, IsHandled, GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesShptHeader, ReturnRcptHeader, ResJnlPostLine); if IsHandled then exit; ShouldExit := SalesLine."Qty. to Invoice" = 0; OnPostResJnlLineOnShouldExit(SalesLine, ShouldExit); if ShouldExit then exit; ResJnlLine.Init(); ResJnlLine.CopyFromSalesHeader(SalesHeader); ResJnlLine.CopyDocumentFields(GenJnlLineDocNo, GenJnlLineExtDocNo, SrcCode, SalesHeader."Posting No. Series"); ResJnlLine.CopyFromSalesLine(SalesLine); OnPostResJnlLineOnAfterInit(ResJnlLine, SalesLine); ResJnlPostLine.RunWithCheck(ResJnlLine); if JobTaskSalesLine2."Job Contract Entry No." > 0 then PostJobContractLine(SalesHeader, JobTaskSalesLine2); OnAfterPostResJnlLine(SalesHeader, SalesLine, JobTaskSalesLine2, ResJnlLine); end; local procedure ValidatePostingAndDocumentDate(var SalesHeader: Record "Sales Header") var BatchProcessingMgt: Codeunit "Batch Processing Mgt."; PostingDate, VATDate : Date; ModifyHeader: Boolean; PostingDateExists, VATDateExists : Boolean; ReplacePostingDate: Boolean; ReplaceDocumentDate: Boolean; ReplaceVATDate: Boolean; SkipTestPostingDate: Boolean; IsHandled: Boolean; begin IsHandled := false; OnBeforeValidatePostingAndDocumentDate(SalesHeader, SuppressCommit, IsHandled); if IsHandled then exit; PostingDateExists := BatchProcessingMgt.GetBooleanParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace Posting Date", ReplacePostingDate) and BatchProcessingMgt.GetBooleanParameter( SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace Document Date", ReplaceDocumentDate) and BatchProcessingMgt.GetDateParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Posting Date", PostingDate); VATDateExists := BatchProcessingMgt.GetBooleanParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"Replace VAT Date", ReplaceVATDate); BatchProcessingMgt.GetDateParameter(SalesHeader.RecordId, Enum::"Batch Posting Parameter Type"::"VAT Date", VATDate); OnValidatePostingAndDocumentDateOnAfterCalcPostingDateExists(PostingDateExists, ReplacePostingDate, ReplaceDocumentDate, PostingDate, SalesHeader, ModifyHeader, VATDateExists, ReplaceVATDate, VATDate); if PostingDateExists and (ReplacePostingDate or (SalesHeader."Posting Date" = 0D)) then begin SalesHeader."Posting Date" := PostingDate; SalesHeader.SynchronizeAsmHeader(); SalesHeader.Validate("Currency Code"); ModifyHeader := true; end; OnValidatePostingAndDocumentDateOnBeforeValidateDocumentDate(PostingDateExists, ReplaceDocumentDate, PostingDate, SalesHeader); if PostingDateExists and (ReplaceDocumentDate or (SalesHeader."Document Date" = 0D)) then begin SalesHeader.Validate("Document Date", PostingDate); ModifyHeader := true; end; if VATDateExists and (ReplaceVATDate) then begin SalesHeader."VAT Reporting Date" := VATDate; ModifyHeader := true; end; if not ReplacePostingDate then begin SkipTestPostingDate := false; OnValidatePostingAndDocumentDateOnBeforeTestPostingDate(SalesHeader, PostingDateExists, SkipTestPostingDate); if not SkipTestPostingDate then SalesHeader.TestPostingDate(PostingDateExists); end; OnValidatePostingAndDocumentDateOnBeforeSalesHeaderModify(SalesHeader, ModifyHeader); if ModifyHeader then SalesHeader.Modify(); OnAfterValidatePostingAndDocumentDate(SalesHeader, SuppressCommit, PreviewMode, ReplacePostingDate, ReplaceDocumentDate); end; local procedure UpdateItemJnlLineDimSetIDFromAppliedShipmentEntry(var ItemJnlLine2: Record "Item Journal Line") var ItemLedgerEntry: Record "Item Ledger Entry"; DimensionMgt: Codeunit DimensionManagement; DimSetID: array[10] of Integer; begin if ItemJnlLine2."Item Shpt. Entry No." <> 0 then begin ItemLedgerEntry.SetLoadFields("Dimension Set ID"); ItemLedgerEntry.Get(ItemJnlLine2."Item Shpt. Entry No."); DimSetID[1] := ItemLedgerEntry."Dimension Set ID"; DimSetID[2] := ItemJnlLine2."Dimension Set ID"; ItemJnlLine2."Dimension Set ID" := DimensionMgt.GetCombinedDimensionSetID(DimSetID, ItemJnlLine2."Shortcut Dimension 1 Code", ItemJnlLine2."Shortcut Dimension 2 Code"); end; end; local procedure UpdateSalesLineDimSetIDFromAppliedEntry(var SalesLineToPost: Record "Sales Line"; SalesLine: Record "Sales Line") var ItemLedgEntry: Record "Item Ledger Entry"; DimensionMgt: Codeunit DimensionManagement; DimSetID: array[10] of Integer; begin DimSetID[1] := SalesLine."Dimension Set ID"; if SalesLineToPost."Appl.-to Item Entry" <> 0 then begin ItemLedgEntry.Get(SalesLineToPost."Appl.-to Item Entry"); DimSetID[2] := ItemLedgEntry."Dimension Set ID"; end; SalesLineToPost."Dimension Set ID" := DimensionMgt.GetCombinedDimensionSetID(DimSetID, SalesLineToPost."Shortcut Dimension 1 Code", SalesLineToPost."Shortcut Dimension 2 Code"); OnAfterUpdateSalesLineDimSetIDFromAppliedEntry(SalesLineToPost, ItemLedgEntry, DimSetID); end; /// <summary> /// Raised when sending the sales document. /// </summary> /// <param name="ShipAndInvoice">Indicates whether to ship and invoice.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> [IntegrationEvent(false, false)] local procedure OnSendSalesDocument(ShipAndInvoice: Boolean; CommitIsSuppressed: Boolean) begin end; local procedure GetAmountRoundingPrecisionInLCY(DocType: Enum "Sales Document Type"; DocNo: Code[20]; CurrencyCode: Code[10]) AmountRoundingPrecision: Decimal var SalesHeader: Record "Sales Header"; begin if CurrencyCode = '' then exit(GLSetup."Amount Rounding Precision"); SalesHeader.Get(DocType, DocNo); AmountRoundingPrecision := Currency."Amount Rounding Precision" / SalesHeader."Currency Factor"; if AmountRoundingPrecision < GLSetup."Amount Rounding Precision" then exit(GLSetup."Amount Rounding Precision"); exit(AmountRoundingPrecision); end; local procedure UpdateEmailParameters(SalesHeader: Record "Sales Header") var FindEmailParameter: Record "Email Parameter"; RenameEmailParameter: Record "Email Parameter"; IsHandled: Boolean; begin IsHandled := false; OnBeforeUpdateEmailParameters(SalesHeader, IsHandled); if IsHandled then exit; if SalesHeader."Last Posting No." = '' then exit; FindEmailParameter.SetRange("Document No", SalesHeader."No."); FindEmailParameter.SetRange("Document Type", SalesHeader."Document Type"); if FindEmailParameter.FindSet() then repeat RenameEmailParameter.Copy(FindEmailParameter); RenameEmailParameter.Rename( SalesHeader."Last Posting No.", FindEmailParameter."Document Type", FindEmailParameter."Parameter Type"); until FindEmailParameter.Next() = 0; end; local procedure ArchivePurchaseOrders(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) var PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; begin if TempDropShptPostBuffer.FindSet() then repeat PurchOrderHeader.Get(PurchOrderHeader."Document Type"::Order, TempDropShptPostBuffer."Order No."); TempDropShptPostBuffer.SetRange("Order No.", TempDropShptPostBuffer."Order No."); repeat PurchOrderLine.Get( PurchOrderLine."Document Type"::Order, TempDropShptPostBuffer."Order No.", TempDropShptPostBuffer."Order Line No."); PurchOrderLine."Qty. to Receive" := TempDropShptPostBuffer.Quantity; PurchOrderLine."Qty. to Receive (Base)" := TempDropShptPostBuffer."Quantity (Base)"; OnArchivePurchaseOrdersOnBeforePurchOrderLineModify(PurchOrderLine, TempDropShptPostBuffer); PurchOrderLine.Modify(); until TempDropShptPostBuffer.Next() = 0; PurchPost.ArchiveUnpostedOrder(PurchOrderHeader); TempDropShptPostBuffer.SetRange("Order No."); until TempDropShptPostBuffer.Next() = 0; end; /// <summary> /// Raises the OnBeforePostResJnlLine event. /// </summary> /// <param name="ItemJnlLine">The item journal line that is posted.</param> /// <param name="SalesLine">The sales line of the document that is posted.</param> /// <param name="SalesHeader">The sales header of the document that is posted.</param> /// <returns>Value of the IsHandled variable that is exposed by the event. False by default</returns> procedure IsItemJnlPostLineHandled(var ItemJnlLine: Record "Item Journal Line"; var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header") IsHandled: Boolean begin IsHandled := false; OnBeforeItemJnlPostLine(ItemJnlLine, SalesLine, SalesHeader, SuppressCommit, IsHandled, TempItemChargeAssgntSales); exit(IsHandled); end; local procedure CalcVATBaseAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary) var IsHandled: Boolean; begin IsHandled := false; OnBeforeCalcVATBaseAmount(SalesHeader, SalesLine, TempVATAmountLine, TempVATAmountLineRemainder, Currency, IsHandled); if IsHandled then exit; SalesLine."VAT Base Amount" := Round( SalesLine.Amount * (1 - SalesLine.GetVatBaseDiscountPct(SalesHeader) / 100), Currency."Amount Rounding Precision"); end; local procedure SalesShptLineInsert(var SalesShptLine: Record "Sales Shipment Line"; SalesShptHeader: Record "Sales Shipment Header"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeSalesShptLineInsert( SalesShptLine, SalesShptHeader, SalesLine, SuppressCommit, PostedWhseShptLine, SalesHeader, WhseShip, WhseReceive, ItemLedgShptEntryNo, xSalesLine, TempSalesLineGlobal, IsHandled); if IsHandled then exit; SalesShptLine.Insert(true); OnAfterSalesShptLineInsert(SalesShptLine, SalesLine, ItemLedgShptEntryNo, WhseShip, WhseReceive, SuppressCommit, SalesInvHeader, TempWhseShptHeader, TempWhseRcptHeader, SalesShptHeader, SalesHeader); end; local procedure SalesInvHeaderInsert(var SalesInvHeader: Record "Sales Invoice Header"; var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeSalesInvHeaderInsert(SalesInvHeader, SalesHeader, SuppressCommit, IsHandled, WhseShip, WhseShptHeader, InvtPickPutaway); if IsHandled then exit; SalesInvHeader.Insert(true); OnAfterSalesInvHeaderInsert(SalesInvHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader, PreviewMode); end; local procedure SalesShptHeaderInsert(var SalesShptHeader: Record "Sales Shipment Header"; var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeSalesShptHeaderInsert(SalesShptHeader, SalesHeader, SuppressCommit, IsHandled, TempWhseRcptHeader, WhseReceive, TempWhseShptHeader, WhseShip, InvtPickPutaway); if IsHandled then exit; SalesShptHeader.Insert(true); OnAfterSalesShptHeaderInsert(SalesShptHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader, PreviewMode); end; local procedure SalesCrMemoHeaderInsert(var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesHeader: Record "Sales Header") var IsHandled: Boolean; begin IsHandled := false; OnBeforeSalesCrMemoHeaderInsert(SalesCrMemoHeader, SalesHeader, SuppressCommit, IsHandled, SalesInvHeader); if IsHandled then exit; SalesCrMemoHeader.Insert(true); OnAfterSalesCrMemoHeaderInsert(SalesCrMemoHeader, SalesHeader, SuppressCommit, WhseShip, WhseReceive, TempWhseShptHeader, TempWhseRcptHeader); end; /// <summary> /// Updates the Gen. Prod. Posting Group on the return receipt line with the value from the item charge. /// Only lines for item charges that don't have a Gen. Prod. Posting Group are updated. /// </summary> /// <param name="ReturnReceiptLine">The return receipt line that is updated.</param> procedure UpdateChargeItemReturnRcptLineGenProdPostingGroup(var ReturnReceiptLine: Record "Return Receipt Line"); var ItemCharge: Record "Item Charge"; begin if not NeedUpdateGenProdPostingGroupOnItemChargeOnReturnRecepitLine(ReturnReceiptLine) then exit; ItemCharge.Get(ReturnReceiptLine."No."); ItemCharge.TestField("Gen. Prod. Posting Group"); ReturnReceiptLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group"; ReturnReceiptLine.Modify(false); end; /// <summary> /// Updates the Gen. Prod. Posting Group on the sales shipment line with the value from the item charge. /// </summary> /// <param name="SalesShipmentLine">The sales shipment line that is updated.</param> procedure UpdateChargeItemSalesShptLineGenProdPostingGroup(var SalesShipmentLine: Record "Sales Shipment Line"); var ItemCharge: Record "Item Charge"; begin if not NeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine) then exit; ItemCharge.Get(SalesShipmentLine."No."); ItemCharge.TestField("Gen. Prod. Posting Group"); SalesShipmentLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group"; SalesShipmentLine.Modify(false); end; /// <summary> /// Updates the Gen. Prod. Posting Group on the sales line with the value from the item charge. /// </summary> /// <param name="SalesLine">The sales line that is updated.</param> procedure UpdateChargeItemSalesLineGenProdPostingGroup(var SalesLine: Record "Sales Line"); var ItemCharge: Record "Item Charge"; begin if not NeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine) then exit; ItemCharge.Get(SalesLine."No."); ItemCharge.TestField("Gen. Prod. Posting Group"); SalesLine."Gen. Prod. Posting Group" := ItemCharge."Gen. Prod. Posting Group"; SalesLine.Modify(false); end; local procedure CreatePrepaymentLineForCreditMemo(var SalesHeader: Record "Sales Header") var GLAccount: Record "G/L Account"; SalesLine: Record "Sales Line"; SalesInvoiceLine: Record "Sales Invoice Line"; GeneralPostingSetup: Record "General Posting Setup"; TempPrepmtSalesLine: Record "Sales Line" temporary; TempExtendedTextLine: Record "Extended Text Line" temporary; TransferExtendedText: Codeunit "Transfer Extended Text"; LineNo: Integer; IsHandled: Boolean; begin if not CheckApplicationExistForCreditMemo(SalesHeader) then exit; SalesLine.SetRange("Document Type", SalesHeader."Document Type"); SalesLine.SetRange("Document No.", SalesHeader."No."); if SalesLine.FindLast() then LineNo := SalesLine."Line No." + 10000 else LineNo := 10000; TempPrepmtSalesLine.SetHasBeenShown(); SalesInvoiceLine.SetRange("Document No.", SalesHeader."Applies-to Doc. No."); SalesInvoiceLine.SetRange("Prepayment Line", true); if SalesInvoiceLine.FindSet() then repeat IsHandled := false; GeneralPostingSetup.Get(SalesInvoiceLine."Gen. Bus. Posting Group", SalesInvoiceLine."Gen. Prod. Posting Group"); OnCreatePrepaymentLineForCreditMemoOnBeforeGetSalesPrepmtAccount(GLAccount, SalesInvoiceLine, IsHandled); if not IsHandled then GLAccount.Get(GeneralPostingSetup.GetSalesPrepmtAccount()); TempPrepmtSalesLine.Init(); TempPrepmtSalesLine."Document Type" := SalesHeader."Document Type"; TempPrepmtSalesLine."Document No." := SalesHeader."No."; TempPrepmtSalesLine."Line No." := LineNo; TempPrepmtSalesLine."System-Created Entry" := true; TempPrepmtSalesLine.Validate(Type, TempPrepmtSalesLine.Type::"G/L Account"); TempPrepmtSalesLine.Validate("No.", GLAccount."No."); TempPrepmtSalesLine.Validate(Quantity, -1); TempPrepmtSalesLine.Validate("Qty. to Ship", TempPrepmtSalesLine.Quantity); TempPrepmtSalesLine.Validate("Qty. to Invoice", TempPrepmtSalesLine.Quantity); TempPrepmtSalesLine.Validate("Unit Price", SalesInvoiceLine."Unit Price"); TempPrepmtSalesLine.Validate("Prepayment Line", true); TempPrepmtSalesLine.Validate("Shortcut Dimension 1 Code", SalesInvoiceLine."Shortcut Dimension 1 Code"); TempPrepmtSalesLine.Validate("Shortcut Dimension 2 Code", SalesInvoiceLine."Shortcut Dimension 2 Code"); TempPrepmtSalesLine.Validate("Dimension Set ID", SalesInvoiceLine."Dimension Set ID"); LineNo := LineNo + 10000; TempPrepmtSalesLine.Insert(true); TransferExtendedText.PrepmtGetAnyExtText( TempPrepmtSalesLine."No.", DATABASE::"Sales Cr.Memo Line", SalesHeader."Document Date", SalesHeader."Language Code", TempExtendedTextLine); if TempExtendedTextLine.FindSet() then repeat TempPrepmtSalesLine.Init(); TempPrepmtSalesLine.Validate(Description, TempExtendedTextLine.Text); TempPrepmtSalesLine.Validate("System-Created Entry", true); TempPrepmtSalesLine.Validate("Prepayment Line", true); TempPrepmtSalesLine.Validate("Line No.", LineNo); LineNo := LineNo + 10000; TempPrepmtSalesLine.Insert(true); until TempExtendedTextLine.Next() = 0; until SalesInvoiceLine.Next() = 0; if TempPrepmtSalesLine.FindSet() then repeat TempSalesLineGlobal := TempPrepmtSalesLine; TempSalesLineGlobal.Insert(true); until TempPrepmtSalesLine.Next() = 0; end; local procedure CheckApplicationExistForCreditMemo(SalesHeader: Record "Sales Header"): Boolean begin if not (SalesHeader."Document Type" = SalesHeader."Document Type"::"Credit Memo") then exit(false); if (SalesHeader."Applies-to Doc. Type" <> SalesHeader."Applies-to Doc. Type"::" ") and (SalesHeader."Applies-to Doc. No." <> '') then exit(true); end; local procedure AssignPostedDocumentNo(var PostedDocumentNo: Code[20]; DocumentNo: Code[20]) begin if PreviewMode then PostedDocumentNo := PostingPreviewNoTok + Format(Random(999999), 0, PostingPreviewNoFormatTxt) else PostedDocumentNo := DocumentNo; end; local procedure SyncSurPlusItemTracking(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") var Location2: Record Location; ReservEntry: Record "Reservation Entry"; TempTrackingSpecification2: Record "Tracking Specification" temporary; TempWarehouseActivityLine: Record "Warehouse Activity Line" temporary; WarehouseAvailabilityMgt: Codeunit "Warehouse Availability Mgt."; QtyReservedForCurrLine: Decimal; SurplusQtyToHandle: Decimal; IsHandled: Boolean; begin if not SalesHeader.Ship then exit; if not (SalesHeader."Document Type" in [SalesHeader."Document Type"::Invoice, SalesHeader."Document Type"::Order]) then exit; if (SalesLine."Location Code" = '') or not Location2.Get(SalesLine."Location Code") or not Location2."Require Shipment" then exit; TempTrackingSpecification2.SetSourceFromSalesLine(SalesLine); QtyReservedForCurrLine := Abs(WarehouseAvailabilityMgt.CalcLineReservedQtyOnInvt( TempTrackingSpecification2."Source Type", TempTrackingSpecification2."Source Subtype", TempTrackingSpecification2."Source ID", TempTrackingSpecification2."Source Ref. No.", 0, false, TempWarehouseActivityLine)); if QtyReservedForCurrLine = 0 then exit; ReservEntry.SetSourceFilter( TempTrackingSpecification2."Source Type", TempTrackingSpecification2."Source Subtype", TempTrackingSpecification2."Source ID", TempTrackingSpecification2."Source Ref. No.", true); ReservEntry.SetSourceFilter('', TempTrackingSpecification2."Source Prod. Order Line"); ReservEntry.SetRange("Reservation Status", ReservEntry."Reservation Status"::Surplus); if not ReservEntry.FindSet() then exit; ReservEntry.CalcSums("Qty. to Handle (Base)"); SurplusQtyToHandle := Abs(ReservEntry."Qty. to Handle (Base)"); if (QtyReservedForCurrLine + SurplusQtyToHandle) <= SalesLine."Qty. to Ship (Base)" then exit; IsHandled := false; OnSyncSurPlusItemTrackingOnBeforeModifyQtyToHandleInvoice(SalesLine, SalesHeader, IsHandled, ReservEntry); if IsHandled then exit; ReservEntry.ModifyAll("Qty. to Handle (Base)", 0); ReservEntry.ModifyAll("Qty. to Invoice (Base)", 0); end; [EventSubscriber(ObjectType::Codeunit, Codeunit::"Item Jnl.-Post Line", 'OnBeforePostValueEntryToGL', '', false, false)] local procedure OnBeforePostValueEntryToGL(var ValueEntry: Record "Value Entry"; var IsHandled: Boolean; PostToGL: Boolean) var InventorySetup: Record "Inventory Setup"; begin if not PostToGL then exit; if InventorySetup.UseLegacyPosting() then exit; PostponedValueEntries.Add(ValueEntry."Entry No."); IsHandled := true; end; [EventSubscriber(ObjectType::Codeunit, Codeunit::"Item Jnl.-Post Line", 'OnSetItemAdjmtPropertiesOnBeforeCheckModifyItem', '', false, false)] local procedure OnSetItemAdjmtPropertiesOnBeforeCheckModifyItem(var Item2: Record Item) var InventorySetup: Record "Inventory Setup"; begin if InventorySetup.UseLegacyPosting() then exit; if not ItemsToAdjust.Contains(Item2."No.") then ItemsToAdjust.Add(Item2."No."); end; /// <summary> /// Raised before modifying the purchase order line during archive purchase orders. /// </summary> /// <param name="PurchOrderLine">The purchase order line.</param> /// <param name="TempDropShptPostBuffer">The temporary drop shipment post buffer.</param> [IntegrationEvent(false, false)] local procedure OnArchivePurchaseOrdersOnBeforePurchOrderLineModify(var PurchOrderLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) begin end; /// <summary> /// Raised before posting the item journal line before post. /// </summary> /// <param name="SalesLine">The sales line being processed.</param> /// <param name="ItemJnlLine">The item journal line.</param> /// <param name="TempWhseJnlLine">The temporary warehouse journal line.</param> /// <param name="Location">The location record.</param> /// <param name="PostWhseJnlLine">Indicates whether to post warehouse journal line.</param> /// <param name="QtyToBeShippedBase">The quantity to be shipped in base unit of measure.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="TrackingSpecification">The tracking specification.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemJnlLineBeforePost(SalesLine: Record "Sales Line"; var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; Location: Record Location; var PostWhseJnlLine: Boolean; QtyToBeShippedBase: Decimal; var IsHandled: Boolean; TrackingSpecification: Record "Tracking Specification") begin end; /// <summary> /// Raised before deleting the sales document after posting. /// </summary> /// <param name="SalesHeader">The sales header to delete.</param> /// <param name="SalesInvoiceHeader">The posted sales invoice header.</param> /// <param name="SalesCrMemoHeader">The posted sales credit memo header.</param> /// <param name="SkipDelete">Set to true to skip the delete operation.</param> /// <param name="CommitIsSuppressed">Indicates whether database commits are suppressed.</param> /// <param name="EverythingInvoiced">Indicates whether everything has been invoiced.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> [IntegrationEvent(false, false)] local procedure OnBeforeDeleteAfterPosting(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SkipDelete: Boolean; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary) begin end; /// <summary> /// Raised before deleting approval entries. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="IsHandled">Set to true to skip the default delete logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeDeleteApprovalEntries(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before finding the customer ledger entry. /// </summary> /// <param name="CustLedgEntry">The customer ledger entry to find.</param> [IntegrationEvent(false, false)] local procedure OnBeforeFindCustLedgEntry(var CustLedgEntry: Record "Cust. Ledger Entry") begin end; /// <summary> /// Raised before getting the country code. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="CountryRegionCode">The country/region code to return.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetCountryCode(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var CountryRegionCode: Code[10]; var IsHandled: Boolean) begin end; /// <summary> /// Raised before getting the country/region code. /// </summary> /// <param name="CustNo">The customer number.</param> /// <param name="ShipToCode">The ship-to code.</param> /// <param name="SellToCountryRegionCode">The sell-to country/region code.</param> /// <param name="Result">The result country/region code.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetCountryRegionCode(CustNo: Code[20]; ShipToCode: Code[10]; SellToCountryRegionCode: Code[10]; var Result: Code[10]; var IsHandled: Boolean) begin end; /// <summary> /// Raised before getting the item entry relation. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="ItemEntryRelation">The item entry relation.</param> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetItemEntryRelation(var SalesHeader: Record "Sales Header"; var ItemEntryRelation: Record "Item Entry Relation"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean) begin end; /// <summary> /// Raised before getting the sales line quantity. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param> /// <param name="SalesLineQty">The sales line quantity to return.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetSalesLineQty(SalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; var SalesLineQty: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before getting return receipt line from tracking or updating item entry relation. /// </summary> /// <param name="TempTrackingSpecification">The temporary tracking specification.</param> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="ItemEntryRelation">The item entry relation.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="TrackingSpecificationExists">Indicates whether tracking specification exists.</param> [IntegrationEvent(false, false)] local procedure OnBeforeGetReturnRcptLineFromTrackingOrUpdateItemEntryRelation(var TempTrackingSpecification: Record "Tracking Specification" temporary; var ReturnRcptLine: Record "Return Receipt Line"; var ItemEntryRelation: Record "Item Entry Relation"; var IsHandled: Boolean; TrackingSpecificationExists: Boolean) begin end; /// <summary> /// Raised before initializing sales line quantity to invoice. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line to initialize.</param> /// <param name="IsHandled">Set to true to skip the default initialization logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInitSalesLineQtyToInvoice(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before initializing post assemble-to-order. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="AsmPost">The assembly post codeunit instance.</param> /// <param name="HideProgressWindow">Indicates whether to hide the progress window.</param> /// <param name="IsHandled">Set to true to skip the default initialization logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInitPostATO(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var AsmPost: Codeunit "Assembly-Post"; HideProgressWindow: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before inserting the return receipt line. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="ReturnRcptLine">The return receipt line to insert.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param> /// <param name="IsHandled">Set to true to skip the default insert logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeInsertReturnReceiptLine(SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var IsHandled: Boolean) begin end; /// <summary> /// Raised before posting ATO associated item journal line. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="PostedATOLink">The posted assemble-to-order link.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param> /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostATOAssocItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PostedATOLink: Record "Posted Assemble-to-Order Link"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer; var IsHandled: Boolean) begin end; /// <summary> /// Raised before evaluating the condition for posting item tracking for receipt. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="Condition">The condition result.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemTrackingForReceiptCondition(SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; var Condition: Boolean) begin end; /// <summary> /// Raised before evaluating the condition for posting item tracking for shipment. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="Condition">The condition result.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostItemTrackingForShipmentCondition(SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; var Condition: Boolean) begin end; /// <summary> /// Raised before posting the item tracking line. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="TempItemLedgEntryNotInvoiced">The temporary item ledger entries not invoiced.</param> /// <param name="HasATOShippedNotInvoiced">Indicates whether ATO has been shipped but not invoiced.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="ItemLedgShptEntryNo">The item ledger shipment entry number.</param> /// <param name="RemQtyToBeInvoiced">The remaining quantity to be invoiced.</param> /// <param name="RemQtyToBeInvoicedBase">The remaining quantity to be invoiced in base unit of measure.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> [IntegrationEvent(true, false)] local procedure OnBeforePostItemTrackingLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempItemLedgEntryNotInvoiced: Record "Item Ledger Entry" temporary; HasATOShippedNotInvoiced: Boolean; var IsHandled: Boolean; var ItemLedgShptEntryNo: Integer; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; /// <summary> /// Raised before posting the sales lines. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="TempSalesLineGlobal">The temporary global sales lines.</param> /// <param name="TempVATAmountLine">The temporary VAT amount line.</param> /// <param name="EverythingInvoiced">Indicates whether everything has been invoiced.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostSalesLines(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var TempVATAmountLine: Record "VAT Amount Line" temporary; var EverythingInvoiced: Boolean) begin end; /// <summary> /// Raised before setting the item entry relation. /// </summary> /// <param name="ItemEntryRelation">The item entry relation to set.</param> /// <param name="SalesShptLine">The sales shipment line.</param> /// <param name="InvoicingTrackingSpecification">The invoicing tracking specification.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSetItemEntryRelation(var ItemEntryRelation: Record "Item Entry Relation"; var SalesShptLine: Record "Sales Shipment Line"; var InvoicingTrackingSpecification: Record "Tracking Specification"; var IsHandled: Boolean) begin end; /// <summary> /// Raised before determining if warehouse journal line should be posted. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="Result">The result of the determination.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeShouldPostWhseJnlLine(SalesLine: Record "Sales Line"; var Result: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before summing sales lines (variant 2). /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="NewSalesLine">The new sales line for totals.</param> /// <param name="OldSalesLine">The old sales line being processed.</param> /// <param name="QtyType">The quantity type (General, Invoicing, or Shipping).</param> /// <param name="InsertSalesLine">Indicates whether to insert the sales line.</param> /// <param name="CalcAdCostLCY">Indicates whether to calculate adjusted cost in LCY.</param> /// <param name="TotalAdjCostLCY">The total adjusted cost in LCY.</param> /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSumSalesLines2(SalesHeader: Record "Sales Header"; var NewSalesLine: Record "Sales Line"; var OldSalesLine: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; InsertSalesLine: Boolean; CalcAdCostLCY: Boolean; var TotalAdjCostLCY: Decimal; IncludePrepayments: Boolean; var IsHandled: Boolean) begin end; /// <summary> /// Raised before summing temporary sales lines. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="OldSalesLine">The old sales line.</param> [IntegrationEvent(false, false)] local procedure OnBeforeSumSalesLinesTemp(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line") begin end; /// <summary> /// Raised before posting warehouse shipment lines. /// </summary> /// <param name="WhseShptLine2">The warehouse shipment line.</param> /// <param name="SalesShptLine2">The sales shipment line.</param> /// <param name="SalesLine2">The sales line.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="PostedWhseShptHeader">The posted warehouse shipment header.</param> [IntegrationEvent(false, false)] local procedure OnBeforePostWhseShptLines(var WhseShptLine2: Record "Warehouse Shipment Line"; SalesShptLine2: Record "Sales Shipment Line"; var SalesLine2: Record "Sales Line"; var IsHandled: Boolean; PostedWhseShptHeader: Record "Posted Whse. Shipment Header") begin end; /// <summary> /// Raised when setting filters for calculating invoice discount. /// </summary> /// <param name="SalesLine">The sales line to set filters on.</param> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnCalcInvDiscountSetFilter(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after setting factor during calculation of item journal amounts from quantity to be invoiced. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="Factor">The calculated factor.</param> /// <param name="ItemJournalLine">The item journal line.</param> [IntegrationEvent(false, false)] local procedure OnCalcItemJnlAmountsFromQtyToBeInvoicedOnAfterSetFactor(SalesLine: Record "Sales Line"; var Factor: Decimal; var ItemJournalLine: Record "Item Journal Line") begin end; /// <summary> /// Raised after processing sales lines during create prepayment lines. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line.</param> /// <param name="NextLineNo">The next line number.</param> [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnAfterProcessSalesLines(SalesHeader: Record "Sales Header"; var TempPrepmtSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineModify(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineInsert(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before inserting temporary line for extended text during create prepayment lines. /// </summary> /// <param name="TempPrepmtSalesLine">The temporary prepayment sales line.</param> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="TempExtTextLine">The temporary extended text line.</param> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnBeforeInsertTempLineForExtText(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; var TempExtTextLine: Record "Extended Text Line" temporary; var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before filling temporary lines in the main code procedure. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="CalledBy">Identifies the caller of the posting routine.</param> [IntegrationEvent(false, false)] local procedure OnCodeOnBeforeFillTempLines(var SalesHeader: Record "Sales Header"; CalledBy: Integer) begin end; /// <summary> /// Raised before loop during copy and check item charge. /// </summary> /// <param name="TempSalesLine">The temporary sales line.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="SkipTestJobNo">Set to true to skip the job number test.</param> [IntegrationEvent(false, false)] local procedure OnCopyAndCheckItemChargeOnBeforeLoop(var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; var SkipTestJobNo: Boolean) begin end; /// <summary> /// Raised after setting filters during copy to temporary lines. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnCopyToTempLinesOnAfterSetFilters(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised before inserting new item charge assignment during insert associated order charge. /// </summary> /// <param name="TempItemChargeAssgntSales">The temporary item charge assignment.</param> /// <param name="NewItemChargeAssgntSales">The new item charge assignment to insert.</param> [IntegrationEvent(false, false)] local procedure OnInsertAssocOrderChargeOnBeforeNewItemChargeAssgntSalesInsert(TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; var NewItemChargeAssgntSales: Record "Item Charge Assignment (Sales)") begin end; /// <summary> /// Raised after transferring fields to sales credit memo header during insert credit memo header. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesCrMemoHeader">The sales credit memo header.</param> [IntegrationEvent(false, false)] local procedure OnInsertCrMemoHeaderOnAfterSalesCrMemoHeaderTransferFields(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; /// <summary> /// Raised before transferring fields to sales credit memo header during insert credit memo header. /// </summary> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnInsertCrMemoHeaderOnBeforeSalesCrMemoHeaderTransferFields(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after calculating whether to insert shipment header during insert posted headers. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="TempWarehouseShipmentHeader">The temporary warehouse shipment header.</param> /// <param name="TempWarehouseReceiptHeader">The temporary warehouse receipt header.</param> /// <param name="InsertShipmentHeaderNeeded">Indicates whether inserting shipment header is needed.</param> [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnAfterCalcInsertShipmentHeaderNeeded(var SalesHeader: Record "Sales Header"; var TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWarehouseReceiptHeader: Record "Warehouse Receipt Header" temporary; var InsertShipmentHeaderNeeded: Boolean) begin end; /// <summary> /// Raised before inserting the invoice header during insert posted headers. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="IsHandled">Set to true to skip the default insert logic.</param> /// <param name="SalesInvHeader">The sales invoice header.</param> /// <param name="GenJnlLineDocType">The general journal line document type.</param> /// <param name="GenJnlLineDocNo">The general journal line document number.</param> /// <param name="GenJnlLineExtDocNo">The general journal line external document number.</param> /// <param name="InvoicePostingInterface">The invoice posting interface.</param> [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnBeforeInsertInvoiceHeader(SalesHeader: Record "Sales Header"; var IsHandled: Boolean; SalesInvHeader: Record "Sales Invoice Header"; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; var InvoicePostingInterface: Interface "Invoice Posting") begin end; /// <summary> /// Raised before creating posted receipt line during insert return receipt line. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="WhseRcptLine">The warehouse receipt line.</param> /// <param name="PostedWhseRcptHeader">The posted warehouse receipt header.</param> [IntegrationEvent(false, false)] local procedure OnInsertReturnReceiptLineOnBeforeCreatePostedRcptLine(SalesLine: record "Sales Line"; var ReturnRcptLine: record "Return Receipt Line"; var WhseRcptLine: Record "Warehouse Receipt Line"; PostedWhseRcptHeader: Record "Posted Whse. Receipt Header") begin end; /// <summary> /// Raised after calculating whether to get warehouse receipt line during insert return receipt line warehouse post. /// </summary> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="ShouldGetWhseRcptLine">Indicates whether to get warehouse receipt line.</param> [IntegrationEvent(false, false)] local procedure OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseRcptLine(var ReturnRcptLine: Record "Return Receipt Line"; SalesLine: Record "Sales line"; WhseShip: Boolean; WhseReceive: Boolean; ReturnRcptHeader: Record "Return Receipt Header"; var ShouldGetWhseRcptLine: Boolean) begin end; /// <summary> /// Raised after calculating whether to get warehouse shipment line during insert return receipt line warehouse post. /// </summary> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="WhseShip">Indicates whether warehouse shipment is involved.</param> /// <param name="WhseReceive">Indicates whether warehouse receipt is involved.</param> /// <param name="ReturnRcptHeader">The return receipt header.</param> /// <param name="ShouldGetWhseShptLine">Indicates whether to get warehouse shipment line.</param> [IntegrationEvent(false, false)] local procedure OnInsertReturnReceiptLineWhsePostOnAfterCalcShouldGetWhseShptLine(var ReturnRcptLine: Record "Return Receipt Line"; SalesLine: Record "Sales line"; WhseShip: Boolean; WhseReceive: Boolean; ReturnRcptHeader: Record "Return Receipt Header"; var ShouldGetWhseShptLine: Boolean) begin end; /// <summary> /// Raised before creating posted shipment line during insert return receipt line warehouse post. /// </summary> /// <param name="ReturnRcptLine">The return receipt line.</param> /// <param name="WhseShptLine">The warehouse shipment line.</param> /// <param name="PostedWhseShptHeader">The posted warehouse shipment header.</param> [IntegrationEvent(false, false)] local procedure OnInsertReturnReceiptLineWhsePostOnBeforeCreatePostedShptLine(var ReturnRcptLine: Record "Return Receipt Line"; var WhseShptLine: Record "Warehouse Shipment Line"; PostedWhseShptHeader: Record "Posted Whse. Shipment Header") begin end; /// <summary> /// Raised after transferring fields to sales shipment header during insert shipment header. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesShptHeader">The sales shipment header.</param> [IntegrationEvent(false, false)] local procedure OnInsertShipmentHeaderOnAfterTransferfieldsToSalesShptHeader(SalesHeader: Record "Sales Header"; var SalesShptHeader: Record "Sales Shipment Header") begin end; /// <summary> /// Raised before transferring fields to sales shipment header during insert shipment header. /// </summary> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnInsertShipmentHeaderOnBeforeTransferfieldsToSalesShptHeader(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after initializing quantity fields during insert shipment line. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="xSalesLine">The previous sales line.</param> /// <param name="SalesShptLine">The sales shipment line.</param> [IntegrationEvent(false, false)] local procedure OnInsertShipmentLineOnAfterInitQuantityFields(var SalesLine: Record "Sales Line"; var xSalesLine: Record "Sales Line"; var SalesShptLine: Record "Sales Shipment Line") begin end; /// <summary> /// Raised after calculating whether to process shipment relation during insert shipment line. /// </summary> /// <param name="SalesLine">The sales line.</param> /// <param name="ShouldProcessShipmentRelation">Indicates whether to process shipment relation.</param> [IntegrationEvent(false, false)] local procedure OnInsertShipmentLineOnAfterCalcShouldProcessShipmentRelation(var SalesLine: Record "Sales Line"; var ShouldProcessShipmentRelation: Boolean) begin end; /// <summary> /// Raised before transferring fields to sales invoice header during insert invoice header. /// </summary> /// <param name="SalesHeader">The sales header.</param> [IntegrationEvent(false, false)] local procedure OnInsertInvoiceHeaderOnBeforeSalesInvHeaderTransferFields(var SalesHeader: Record "Sales Header") begin end; /// <summary> /// Raised after transferring fields to sales invoice header during insert invoice header. /// </summary> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesInvoiceHeader">The sales invoice header.</param> [IntegrationEvent(false, false)] local procedure OnInsertInvoiceHeaderOnAfterSalesInvHeaderTransferFields(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header") begin end; /// <summary> /// Raised before dividing amount during sum sales lines 2. /// </summary> /// <param name="OldSalesLine">The old sales line.</param> /// <param name="IsHandled">Set to true to skip the default logic.</param> /// <param name="SalesHeader">The sales header.</param> /// <param name="SalesLine">The sales line.</param> /// <param name="QtyType">The quantity type.</param> /// <param name="SalesLineQty">The sales line quantity.</param> /// <param name="TempVATAmountLine">The temporary VAT amount line.</param> /// <param name="TempVATAmountLineRemainder">The temporary VAT amount line remainder.</param> /// <param name="IncludePrepayments">Indicates whether to include prepayments.</param> /// <param name="RoundingLineInserted">Indicates whether a rounding line was inserted.</param> [IntegrationEvent(false, false)] local procedure OnSumSalesLines2OnBeforeDivideAmount(var OldSalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; QtyType: Option; var SalesLineQty: Decimal; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; IncludePrepayments: Boolean; RoundingLineInserted: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnSumSalesLines2OnAfterDivideAmount(var OldSalesLine: Record "Sales Line"; var SalesLineQty: Decimal; QtyType: Option General,Invoicing,Shipping) begin end; [IntegrationEvent(false, false)] local procedure OnSumSalesLines2OnAfterCalcTotalAdjCostLCY(var TotalAdjCostLCY: decimal; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnSumSalesLines2OnBeforeCalcVATAmountLines(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; InsertSalesLine: Boolean; var TempVATAmountLine: Record "VAT Amount Line" temporary; QtyType: Option General,Invoicing,Shipping; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnSumSalesLines2OnBeforeNewSalesLineInsert(var NewSalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnSumSalesLines2SetFilter(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; InsertSalesLine: Boolean; var QtyType: Option) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineWhseLineOnBeforePostTempWhseJnlLine2(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterTestUpdatedSalesLine(var SalesLine: Record "Sales Line"; var EverythingInvoiced: Boolean; SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineBeforeInitQtyToInvoice(var TempSalesLine: Record "Sales Line" temporary; WhseShip: Boolean; WhseReceive: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnBeforeInitOutstanding(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnBeforeInitTempSalesLineQuantities(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnAfterUpdateInvoicedValues(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnAfterModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; TempSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnBeforeModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; TempSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnAfterInsertSalesOrderHeader(var SalesOrderLine: Record "Sales Line"; TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnAfterInitQtyToReceiveOrShip(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; WhseShip: Boolean; WhseReceive: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnBeforeUpdateInvoicedValues(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(true, false)] local procedure OnPostUpdateOrderLineOnSetDefaultQtyBlank(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; SalesSetup: Record "Sales & Receivables Setup"; var SetDefaultQtyBlank: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCalcInvoiceOnAfterTempSalesLineSetFilters(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(true, false)] local procedure OnCheckAndUpdateOnAfterCalcInvDiscount(SalesHeader: Record "Sales Header"; TempWhseShptHeader: Record "Warehouse Shipment Header" temporary; PreviewMode: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary; SuppressCommit: Boolean; WhseReceive: Boolean; WhseShip: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnCheckAndUpdateOnAfterReleaseSalesDocument(SalesHeader: Record "Sales Header"; PreviewMode: Boolean) begin end; [IntegrationEvent(true, false)] local procedure OnCheckAndUpdateOnBeforeSetPostingFlags(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var ModifyHeader: Boolean; var HideProgressWindow: Boolean); begin end; [IntegrationEvent(true, false)] local procedure OnCheckAndUpdateOnAfterSetPostingFlags(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var ModifyHeader: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnCheckAndUpdateOnAfterSetSourceCode(var SalesHeader: Record "Sales Header"; SourceCodeSetup: Record "Source Code Setup"; var SrcCode: Code[10]); begin end; [IntegrationEvent(false, false)] local procedure OnCheckAndUpdateOnAfterSetPoszingFromWhseRef(var SalesHeader: Record "Sales Header"; var InvtPickPutaway: Boolean; var PostingFromWhseRef: Integer); begin end; [IntegrationEvent(false, false)] local procedure OnCheckAndUpdateOnBeforeCalcInvDiscount(var SalesHeader: Record "Sales Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; WhseReceive: Boolean; WhseShip: Boolean; var RefreshNeeded: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCheckAndUpdateOnBeforeCheckPostRestrictions(var SalesHeader: Record "Sales Header"; PreviewMode: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCheckAssosOrderLinesOnAfterSetFilters(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(true, false)] local procedure OnCheckSalesDocumentOnAfterCalcShouldCheckItemCharge(var SalesHeader: Record "Sales Header"; WhseReceive: Boolean; WhseShip: Boolean; var ShouldCheckItemCharge: Boolean; var ModifyHeader: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCheckTrackingAndWarehouseForShipOnBeforeCheck(var SalesHeader: Record "Sales Header"; var TempWhseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWhseReceiptHeader: Record "Warehouse Receipt Header" temporary; var Ship: Boolean; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(true, false)] local procedure OnCheckTrackingAndWarehouseForReceiveOnBeforeCheck(var SalesHeader: Record "Sales Header"; var TempWhseShipmentHeader: Record "Warehouse Shipment Header" temporary; var TempWhseReceiptHeader: Record "Warehouse Receipt Header" temporary; var Receive: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCheckTrackingSpecificationOnAfterTempItemSalesLineLoop(var TempItemSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnCheckCustBlockageOnAfterTempLinesSetFilters(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary); begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnAfterTempPrepmtSalesLineSetFilters(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnAfterGetSalesPrepmtAccount(var GLAcc: Record "G/L Account"; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnBeforeGetSalesPrepmtAccount(var GLAcc: Record "G/L Account"; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; var GenPostingSetup: Record "General Posting Setup"; CompleteFunctionality: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnAfterTempSalesLineSetFilters(var TempSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempPrepmtSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnFinalizePostingOnAfterUpdateItemChargeAssgnt(var SalesHeader: Record "Sales Header"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line") begin end; [IntegrationEvent(false, false)] local procedure OnFinalizePostingOnBeforeInsertTrackingSpecification(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; SalesHeader: Record "Sales Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; EverythingInvoiced: Boolean; var TempSalesLine: Record "Sales Line" temporary; var TempSalesLineGlobal: Record "Sales Line" temporary; SalesPost: Codeunit "Sales-Post") begin end; [IntegrationEvent(false, false)] local procedure OnFinalizePostingOnBeforeCreateOutboxSalesTrans(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; EverythingInvoiced: Boolean; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; [IntegrationEvent(false, false)] local procedure OnFinalizePostingOnBeforeDeleteApprovalEntries(var SalesHeader: Record "Sales Header"; var EverythingInvoiced: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnFinalizePostingOnBeforeGenJnlPostPreviewThrowError(SalesHeader: Record "Sales Header"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostAssocItemJnlLineOnBeforePost(var ItemJournalLine: Record "Item Journal Line"; PurchOrderLine: Record "Purchase Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostATOOnBeforePostedATOLinkInsert(var PostedATOLink: Record "Posted Assemble-to-Order Link"; var AssemblyHeader: Record "Assembly Header"; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostATOAssocItemJnlLineOnBeforeRemainingPost(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PostedATOLink: Record "Posted Assemble-to-Order Link"; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var ItemLedgShptEntryNo: Integer) begin end; [IntegrationEvent(false, false)] local procedure OnPostDropOrderShipmentOnAfterUpdateBlanketOrderLine(PurchOrderHeader: Record "Purchase Header"; PurchOrderLine: Record "Purchase Line"; TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesShptHeader: Record "Sales Shipment Header"; SalesHeader: Record "Sales Header"; PurchRcptHeader: Record "Purch. Rcpt. Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; SrcCode: Code[10]) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnAfterCopyDocumentFields(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnAfterCalcShouldPostItemJnlLineItemCharges(SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; var ShouldPostItemJnlLineItemCharges: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnAfterPrepareItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; WhseShip: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; var QtyToBeShipped: Decimal; TrackingSpecification: Record "Tracking Specification"; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; var QtyToBeShippedBase: Decimal; var RemAmt: Decimal; var RemDiscAmt: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnAfterCopyItemCharge(var ItemJournalLine: Record "Item Journal Line"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnBeforeIsJobContactLineCheck(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var ShouldPostItemJnlLine: Boolean; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; QtyToBeShipped: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnAfterItemJnlPostLineRunWithCheck(var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnBeforePostItemJnlLineWhseLine(var ItemJnlLine: Record "Item Journal Line"; var TempWhseJnlLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnBeforeTransferReservToItemJnlLine(SalesLine: Record "Sales Line"; ItemJnlLine: Record "Item Journal Line"; var CheckApplFromItemEntry: Boolean; var TrackingSpecification: Record "Tracking Specification"; QtyToBeShippedBase: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnBeforeCopyTrackingFromSpec(TrackingSpecification: Record "Tracking Specification"; var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; IsATO: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineItemChargesOnAfterGetItemChargeLine(var ItemChargeSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLinePrepareJournalLineOnBeforeCalcItemJnlAmounts(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; IsATO: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargeOnBeforePostItemJnlLine(var SalesLineToPost: Record "Sales Line"; var SalesLine: Record "Sales Line"; QtyToAssign: Decimal; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerOrderOnAfterCopyToItemJnlLine(var ItemJournalLine: Record "Item Journal Line"; var SalesLine: Record "Sales Line"; GeneralLedgerSetup: Record "General Ledger Setup"; QtyToInvoice: Decimal; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerOrderOnAfterTempTrackingSpecificationInvSetFilters(SalesHeader: record "Sales Header"; var ItemJnlLine2: record "Item Journal Line"; var TempTrackingSpecificationInv: Record "Tracking Specification" temporary; SalesLine: Record "Sales Line"; var IsHandled: Boolean; var TotalSalesLineLCY: Record "Sales Line"; var TotalSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerOrderOnBeforeTestJobNo(SalesLine: Record "Sales Line"; var SkipTestJobNo: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerOrderOnBeforeLastRunWithCheck(NonDistrItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerOrderOnBeforeRunWithCheck(ItemJnlLine2: Record "Item Journal Line"; var IsHandled: Boolean; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerShptOnBeforeTestJobNo(SalesShipmentLine: Record "Sales Shipment Line"; var SkipTestJobNo: Boolean; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerShptOnAfterCheckItemChargePerShpt(SalesShipmentLine: Record "Sales Shipment Line"; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; DistributeCharge: Boolean; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerShptOnAfterCalcDistributeCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; TempItemLedgEntry: Record "Item Ledger Entry" temporary; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var DistributeCharge: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerRetRcptOnAfterCalcDistributeCharge(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; ReturnRcptLine: Record "Return Receipt Line"; TempItemLedgEntry: Record "Item Ledger Entry" temporary; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var DistributeCharge: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargePerRetRcptOnBeforeTestFieldJobNo(ReturnReceiptLine: Record "Return Receipt Line"; var IsHandled: Boolean; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingLineOnAfterRetrieveInvoiceSpecification(var SalesLine: Record "Sales Line"; var TempInvoicingSpecification: Record "Tracking Specification" temporary; var TrackingSpecificationExists: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForShipmentOnAfterSetFilters(var SalesShipmentLine: Record "Sales Shipment Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForShipmentOnAfterUpdateSalesShptLineFields(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForShipmentOnBeforeAdjustQuantityRounding(SalesShptLine: Record "Sales Shipment Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; var ShouldAdjustQuantityRounding: Boolean) begin end; [IntegrationEvent(true, false)] local procedure OnPostItemTrackingForShipmentOnBeforeShipmentInvoiceErr(SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var ItemJnlRollRndg: Boolean; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal) begin end; [IntegrationEvent(true, false)] local procedure OnPostItemTrackingForShipmentOnBeforeReturnReceiptInvoiceErr(SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesHeader: Record "Sales Header"; var ItemJnlRollRndg: Boolean; TrackingSpecificationExists: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForReceiptOnAfterSetFilters(var ReturnReceiptLine: Record "Return Receipt Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeInsertCrMemoLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; xSalesLine: Record "Sales Line"; SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeInsertInvoiceLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; xSalesLine: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; var ShouldInsertInvoiceLine: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeInsertReturnReceiptLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeInsertShipmentLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean; SalesLineACY: Record "Sales Line"; DocType: Option; DocNo: Code[20]; ExtDocNo: Code[35]) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterSetEverythingInvoiced(SalesLine: Record "Sales Line"; var EverythingInvoiced: Boolean; var IsHandled: Boolean; SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterRoundAmount(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; GenJnlLineDocNo: Code[20]) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeTestJobNo(SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(true, false)] local procedure OnPostSalesLineOnAfterPostItemTrackingLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterTestSalesLine(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; var WhseShptHeader: Record "Warehouse Shipment Header"; WhseShip: Boolean; PreviewMode: Boolean; var CostBaseAmount: Decimal) begin end; [IntegrationEvent(true, false)] local procedure OnPostSalesLineOnBeforePostItemTrackingLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; WhseShip: Boolean; WhseReceive: Boolean; InvtPickPutaway: Boolean; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ItemLedgShptEntryNo: Integer; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; GenJnlLineDocNo: Code[20]; SrcCode: Code[10]; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeTestUnitOfMeasureCode(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterAdjustPrepmtAmountLCY(var SalesLine: record "Sales Line"; var xSalesLine: record "Sales Line"; TempTrackingSpecification: record "Tracking Specification" temporary; SalesHeader: record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterInsertReturnReceiptLine(var SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var xSalesLine: Record "Sales Line"; ReturnRcptHeader: Record "Return Receipt Header"; RoundingLineInserted: Boolean; var TempTrackingSpecification: Record "Tracking Specification" temporary; var ItemLedgShptEntryNo: Integer; SalesShipmentHeader: Record "Sales Shipment Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnAfterGetSalesOrderLine(var TempSalesLine: Record "Sales Line" temporary; SalesShptLine: Record "Sales Shipment Line"; SalesOrderLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnBeforeInitQtyToInvoice(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnBeforeCalcQuantityInvoiced(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateReturnReceiptLineOnAfterGetSalesOrderLine(var TempSalesLine: Record "Sales Line" temporary; ReturnRcptLine: Record "Return Receipt Line"; SalesOrderLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateReturnReceiptLineOnBeforeInitQtyToInvoice(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateReturnReceiptLineOnAfterModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateReturnReceiptLineOnBeforeModifySalesOrderLine(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateReturnReceiptLineOnBeforeCalcQuantityInvoiced(var SalesOrderLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnProcessAssocItemJnlLineOnBeforeTempDropShptPostBufferInsert(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnProcessAssocItemJnlLineOnBeforePostAssocItemJnlLine(var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnRoundAmountOnBeforeIncrAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line"; var xSalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnRunOnBeforeCheckTotalInvoiceAmount(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnRunOnBeforeFinalizePosting(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ReturnReceiptHeader: Record "Return Receipt Header"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; CommitIsSuppressed: Boolean; GenJnlLineExtDocNo: Code[35]; var EverythingInvoiced: Boolean; GenJnlLineDocNo: Code[20]; SrcCode: Code[10]; PreviewMode: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnRunOnBeforePostSalesLineEndLoop(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var LastLineRetrieved: Boolean; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; RecSalesHeader: Record "Sales Header"; xSalesLine: Record "Sales Line"; var SalesShipmentHeader: Record "Sales Shipment Header"; var ReturnReceiptHeader: Record "Return Receipt Header") begin end; [IntegrationEvent(false, false)] local procedure OnGetATOItemLedgEntriesNotInvoicedOnBeforeItemLedgEntryNotInvoicedInsert(var ItemLedgEntry: Record "Item Ledger Entry") begin end; [IntegrationEvent(false, false)] local procedure OnGetPostedDocumentRecordElseCase(SalesHeader: Record "Sales Header"; var PostedSalesDocumentVariant: Variant; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnGetSalesLinesOnAfterFillTempLines(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemLineOnAfterMakeSalesLineToShip(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemLineOnBeforeMakeSalesLineToShip(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var ItemLedgShptEntryNo: Integer; var IsHandled: Boolean; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; ReturnReceiptHeader: Record "Return Receipt Header"; var TempHandlingSpecification: Record "Tracking Specification" temporary; var TempHandlingSpecificationInv: Record "Tracking Specification" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemLineOnBeforePostItemInvoiceLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var TempPostedATOLink: Record "Posted Assemble-to-Order Link" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargeOnAfterPostItemJnlLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(true, false)] local procedure OnPostItemChargeLineOnAfterTempItemChargeAssgntSalesLoop(var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineParam: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargeLineOnBeforePostItemCharge(var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForReceiptOnBeforeReturnRcptLineModify(SalesHeader: Record "Sales Header"; var ReturnRcptLine: Record "Return Receipt Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForReceiptOnBeforeAdjustQuantityRounding(ReturnRcptLine: Record "Return Receipt Line"; RemQtyToInvoiceCurrLine: Decimal; var QtyToBeInvoiced: Decimal; RemQtyToInvoiceCurrLineBase: Decimal; QtyToBeInvoicedBase: Decimal; TrackingSpecificationExists: Boolean; var ShouldAdjustQuantityRounding: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnReleaseSalesDocumentOnBeforeSetStatus(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; SavedStatus: Enum "Sales Document Status"; PreviewMode: Boolean; SuppressCommit: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnRoundAmountOnAfterAssignSalesLines(var xSalesLine: Record "Sales Line"; var SalesLineACY: Record "Sales Line"; SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var TotalSalesLines: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line"; var SalesLine: Record "Sales Line"); begin end; [IntegrationEvent(false, false)] local procedure OnSaveInvoiceSpecificationOnAfterUpdateTempTrackingSpecification(var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempInvoicingSpecification: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnSaveInvoiceSpecificationOnBeforeAssignTempInvoicingSpecification(var TempInvoicingSpecification: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnSendICDocumentOnBeforeSetICStatus(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnSendPostedDocumentRecordElseCase(SalesHeader: Record "Sales Header"; var DocumentSendingProfile: Record "Document Sending Profile"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnTestSalesLineOnAfterTestSalesLineJob(var SalesLine: record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnTestSalesLineOnAfterCalcShouldTestReturnQty(SalesLine: Record "Sales Line"; var ShouldTestReturnQty: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeTestGenPostingGroups(var SalesLine: record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateSalesLineBeforePostOnAfterPostJobContractLine(SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssosOrderOnAfterPurchOrderHeaderModify(var PurchOrderHeader: Record "Purchase Header") begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssocOrderOnAfterModifyPurchLine(var PurchOrderLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssocOrderOnBeforeModifyPurchLine(var PurchOrderLine: Record "Purchase Line"; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssosOrderPostingNosOnAfterReleasePurchaseDocument(var PurchOrderHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssosOrderPostingNosOnBeforeReleasePurchaseDocument(var PurchOrderHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAfterPostingOnBeforeFindSetForUpdate(var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnUpdateBlanketOrderLineOnBeforeCheck(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateBlanketOrderLineOnBeforeCheckSellToCustomerNo(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateBlanketOrderLineOnBeforeInitOutstanding(var BlanketOrderSalesLine: Record "Sales Line"; SalesLine: Record "Sales Line"; Ship: Boolean; Receive: Boolean; Invoice: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateInvoicedQtyOnShipmentLineOnBeforeModifySalesShptLine(var SalesShptLine: Record "Sales Shipment Line"; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnDivideAmountOnAfterInitAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnDivideAmountOnAfterInitLineDiscountAmount(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; SalesLineQty: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnDivideAmountOnBeforeTempVATAmountLineRemainderModify(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcVATBaseAmount(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostUpdateInvoiceLine(var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(true, false)] local procedure OnBeforePostUpdateReturnReceiptLine(var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeInsertTrackingSpecification(SalesHeader: Record "Sales Header"; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSendPostedDocumentRecord(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var DocumentSendingProfile: Record "Document Sending Profile") begin end; [IntegrationEvent(false, false)] local procedure OnAfterPostItemChargeLine(var SalesLine: Record "Sales Line"; SalesLineACY: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnDeleteAfterPostingOnAfterDeleteLinks(var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnDeleteAfterPostingOnBeforeDeleteSalesHeader(var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnDeleteAfterPostingOnBeforeDeleteLinks(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnRunOnBeforeCheckAndUpdate(var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnUpdateWonOpportunitiesOnBeforeOpportunityModify(var SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; var Opportunity: Record Opportunity) begin end; [IntegrationEvent(false, false)] local procedure OnCheckAndUpdateOnBeforeCheckShip(var IsHandled: Boolean; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeUpdateReceiveAndCheckIfInvPutawayExists(var IsHandled: Boolean; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnModifyTempLineOnAfterSalesLineModify(var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnModifyTempLineOnBeforeTransferFields(var SalesLine: Record "Sales Line"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnModifyTempLineOnBeforeSalesLineModify(var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesLine(SalesLine: Record "Sales Line"; var NeedUpdate: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnSalesShipmentLine(SalesShipmentLine: Record "Sales Shipment Line"; var NeedUpdate: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnNeedUpdateGenProdPostingGroupOnItemChargeOnReturnReceiptLine(ReturnReceiptLine: Record "Return Receipt Line"; var NeedUpdate: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterUpdateSalesLineDimSetIDFromAppliedEntry(var SalesLineToPost: Record "Sales Line"; var ItemLedgEntry: Record "Item Ledger Entry"; DimSetID: array[10] of Integer) begin end; [IntegrationEvent(false, false)] local procedure OnDeleteAfterPostingOnAfterSetupSalesHeader(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnDeleteAfterPostingOnAfterSalesLineDeleteAll(SalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header"; CommitIsSuppressed: Boolean; EverythingInvoiced: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForShipmentConditionOnBeforeUpdateBlanketOrderLine(var TempSalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostResJnlLineOnAfterInit(var ResJnlLine: Record "Res. Journal Line"; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnValidatePostingAndDocumentDateOnAfterCalcPostingDateExists(var PostingDateExists: Boolean; var ReplacePostingDate: Boolean; var ReplaceDocumentDate: Boolean; var PostingDate: Date; var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean; var VATDateExists: Boolean; var ReplaceVATDate: Boolean; var VATDate: Date) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeValidateICPartnerBusPostingGroups(var TempICGenJnlLine: Record "Gen. Journal Line" temporary; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterGetCurrency(CurrencyCode: Code[10]; var Currency: Record Currency) begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostItemLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean; var TempSalesLineGlobal: Record "Sales Line" temporary; var TempDropShptPostBuffer: Record "Drop Shpt. Post. Buffer" temporary; var RemQtyToBeInvoiced: Decimal; var RemQtyToBeInvoicedBase: Decimal; var ItemJnlPostLine: Codeunit "Item Jnl.-Post Line") begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostItemChargeLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnBeforeInsertedPrepmtVATBaseToDeduct(var TempPrepmtSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnAfterInsertReturnReceiptHeader(var SalesHeader: Record "Sales Header"; var ReturnReceiptHeader: Record "Return Receipt Header") begin end;#if not CLEAN27 [Obsolete('This event is never raised.', '27.0')] [IntegrationEvent(false, false)] local procedure OnAfterGetAmountsForDeferral(SalesLine: Record "Sales Line"; var AmtToDefer: Decimal; var AmtToDeferACY: Decimal; var DeferralAccount: Code[20]) begin end;#endif [IntegrationEvent(false, false)] local procedure OnPostJobContractLineBeforeTestFields(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnInsertCrMemoHeaderOnAfterCalcShouldProcessAsReturnOrder(SalesHeader: Record "Sales Header"; var ShouldProcessAsReturnOrder: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateQtyToBeInvoicedForShipmentOnAfterSetQtyToBeInvoiced(TrackingSpecificationExists: Boolean; HasATOShippedNotInvoiced: Boolean; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostItemJnlLineItemCharges(var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateReturnReceiptLineOnBeforeInitOutstanding(var SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForShipmentOnBeforeGetATOItemLedgEntriesNotInvoiced(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCheckSalesDocumentOnBeforeCheckDueDate(var SalesHeader: Record "Sales Header"; var ShouldCheckDueDate: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineTrackingOnAfterCalcShouldInsertTrkgSpecInv(var SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; var ShouldInsertTrkgSpecInv: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateSalesLineBeforePostOnBeforeGetUnitCost(var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcItemJnlAmountsFromQtyToBeInvoiced(var ItemJnlLine: Record "Item Journal Line"; SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; QtyToBeInvoiced: Decimal; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCheckTrackingAndWarehouseForReceiveOnAfterSetFilters(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnRunOnBeforeCalcVATAmountLines(var TempSalesLineGlobal: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnTestSalesLineOnBeforeTestFieldQtyToShip(SalesLine: Record "Sales Line"; var ShouldTestQtyToShip: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeInsertShipmentLine(var SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnIsEndLoopForShippedNotInvoicedOnBeforeExit(SalesLine: Record "Sales Line"; SalesShptLine: Record "Sales Shipment Line"; RemQtyToBeInvoiced: Decimal; var Result: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLinePrepareJournalLineOnBeforeCalcQuantities(var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; QtyToBeShippedBase: Decimal; QtyToBeInvoiced: Decimal; QtyToBeInvoicedBase: Decimal; var IsHandled: Boolean; IsATO: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeInvoiceRounding(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineOnAfterCopyTrackingFromSpec(var ItemJnlLine: Record "Item Journal Line"; SalesLine: Record "Sales Line"; QtyToBeShipped: Decimal; IsATO: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnBeforeValidateQtyToInvoice(var SalesHeader: Record "Sales Header"; var ShouldValidateQtyToInvoice: Boolean; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssosOrderPostingNosOnAfterSetFilterTempSalesLine(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnCheckTrackingSpecificationOnBeforeGetItemTrackingSettings(var TempItemSalesLine: Record "Sales Line" temporary; var ItemTrackingSetup: Record "Item Tracking Setup"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostItemTrackingForReceipt(var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemJnlLineTrackingOnBeforeInsertTempTrkgSpec(var TempTrackingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpec: Record "Tracking Specification" temporary; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnInsertInvoiceHeaderOnBeforeCheckDocumentType(SalesHeader: Record "Sales Header"; var SalesInvHeader: Record "Sales Invoice Header"; SalesSetup: Record "Sales & Receivables Setup"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostInvoiceOnBeforePostBalancingEntry(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var TotalSalesLine: Record "Sales Line"; var TotalSalesLineLCY: Record "Sales Line"; SuppressCommit: Boolean; PreviewMode: Boolean; InvoicePostingParameters: Record "Invoice Posting Parameters"; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; SalesInvHeader: Record "Sales Invoice Header"; SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeFindNotShippedLines(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforePostSalesLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; SrcCode: Code[10]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line"; var IsHandled: Boolean; SalesLineACY: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnAfterUpdateInvoiceRounding(var SalesHeader: Record "Sales Header"; var TotalSalesLine: Record "Sales Line"; var SalesLine: Record "Sales Line"; var Currency: Record Currency; var BiggestLineNo: Integer; var LastLineRetrieved: Boolean; var RoundingLineInserted: Boolean; var RoundingLineNo: Integer; UseTempData: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnAfterSetFilters(var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(true, false)] local procedure OnPostItemLineOnBeforePostItemJnlLineForInvoiceDoc(SalesHeader: Record "Sales Header"; var SalesLineToShip: Record "Sales Line"; Ship: Boolean; var ItemLedgShptEntryNo: Integer; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; SalesShptHeader: Record "Sales Shipment Header"; var TempHandlingSpecification: Record "Tracking Specification" temporary; var TempTrackingSpecificationInv: Record "Tracking Specification" temporary; var TempTrackingSpecification: Record "Tracking Specification" temporary; var IsHandled: Boolean; QtyToInvoice: Decimal; TempAssembletoOrderLink: Record "Posted Assemble-to-Order Link" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForReceipt(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; QtyToInvoiceBaseInTrackingSpec: Decimal; var ShouldPostItemTrackingForReceipt: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingOnAfterCalcShouldPostItemTrackingForShipment(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; RemQtyToBeInvoiced: Decimal; QtyToInvoiceBaseInTrackingSpec: Decimal; var ShouldPostItemTrackingForShipment: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnBeforeGetQuantityShipped(var TempSalesLine: Record "Sales Line"; var IsHandled: Boolean; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnBeforeGetReturnQtyReceived(var TempSalesLine: Record "Sales Line"; var IsHandled: Boolean; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingOnAfterCalcShouldProcessReceipt(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var ShouldProcessReceipt: Boolean; var ItemJnlRollRndg: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateInvoiceLineOnBeforeInitOutstanding(var SalesOrderLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostInvoiceOnBeforeBalAccountNoWindowUpdate(HideProgressWindow: Boolean; var IsHandled: Boolean; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnAfterCalcShouldCalcPrepmtAmounts(var TempSalesLine: Record "Sales Line" temporary; var ShouldCalcPrepmtAmounts: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterGetGeneralPostingSetup(var GeneralPostingSetup: Record "General Posting Setup"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnCheckItemTrackingQuantityOnDocumentTypeCaseElse(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnSetCommitBehavior(var ErrorOnCommit: Boolean) begin end;#if not CLEAN27 [IntegrationEvent(false, false)] [Obsolete('This event is no longer used.', '27.0')] local procedure OnSetPostingPreviewDocumentNo(var PreviewDocumentNo: Code[20]; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] [Obsolete('This event is no longer used.', '27.0')] local procedure OnGetPostingPreviewDocumentNos(var PreviewDocumentNos: List of [Code[20]]) begin end;#endif [IntegrationEvent(false, false)] local procedure OnPostInvoiceOnAfterPostLines(var SalesHeader: Record "Sales Header"; SrcCode: Code[10]; GenJnlLineDocType: Enum "Gen. Journal Document Type"; GenJnlLineDocNo: Code[20]; GenJnlLineExtDocNo: Code[35]; var GenJnlPostLine: Codeunit "Gen. Jnl.-Post Line") begin end; [IntegrationEvent(false, false)] local procedure OnCopyAndCheckItemChargeOnBeforeAssignQtyToInvoice(var TempSalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeItemLedgerEntryExist(var SalesLine: Record "Sales Line"; ShipOrReceive: Boolean; var HasItemLedgerEntry: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnAfterCalcShouldInsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var ShouldInsertInvoiceHeader: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnInsertShptEntryRelationOnAfterItemEntryRelationInsert(SalesShipmentLine: Record "Sales Shipment Line"; var ItemEntryRelation: Record "Item Entry Relation"; xSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostItemChargePerRetRcpt(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostUpdateOrderLineOnBeforeSetInvoiceFields(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line"; var ShouldSetInvoiceFields: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCopyAndCheckItemChargeOnBeforeError(SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var InvoiceEverything: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeGetSalesLineAdjCostLCY(SalesLine2: Record "Sales Line"; QtyType: Option General,Invoicing,Shipping; AdjCostLCY: Decimal; var Result: Decimal; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnBeforeShouldTestGetShipmentPPmtAmtToDeduct(SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean; var ShouldTestGetShipmentPPmtAmtToDeduct: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterDeleteApprovalEntries(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var ReturnReceiptHeader: Record "Return Receipt Header") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeUpdateSalesLineBeforePost(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; WhseShip: Boolean; WhseReceive: Boolean; RoundingLineInserted: Boolean; CommitIsSuppressed: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnAfterSumSalesLines2(var SalesHeader: Record "Sales Header"; var OldSalesLine: Record "Sales Line"; var NewSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnCheckPostWhseShptLinesOnAfterWhseShptLinesFound(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var WhseShptLinesFound: Boolean; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; WarehouseReceiptHeader: Record "Warehouse Receipt Header"; WhseShip: Boolean; WhseReceive: Boolean; var WarehouseShipmentLine: Record "Warehouse Shipment Line") begin end; [IntegrationEvent(false, false)] local procedure OnAfterDecrementPrepmtAmtInvLCY(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var PrepmtAmountInvLCY: Decimal; var PrepmtVATAmountInvLCY: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnDivideAmountOnBeforeTempVATAmountLineGet(SalesLine: Record "Sales Line"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeAdjustPrepmtAmountLCY(SalesHeader: Record "Sales Header"; var PrepmtSalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostResJnlLineOnShouldExit(var SalesLine: Record "Sales Line"; var ShouldExit: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnDivideAmountOnBeforeUpdateTempVATAmountLineRemainder(var SalesLine: Record "Sales Line"; SalesHeader: Record "Sales Header"; var TempVATAmountLine: Record "VAT Amount Line" temporary; var TempVATAmountLineRemainder: Record "VAT Amount Line" temporary; Currency: Record Currency; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemChargeOnAfterCalcTotalChargeAmt(var SalesLineToPost: Record "Sales Line"; QtyToAssign: Decimal; var SalesLine: Record "Sales Line"; xSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCheckPostRestrictions(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLinesOnBeforeValidateType(var TempPrepmtSalesLine: Record "Sales Line" temporary; var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnValidatePostingAndDocumentDateOnBeforeValidateDocumentDate(var PostingDateExists: Boolean; var ReplaceDocumentDate: Boolean; var PostingDate: Date; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnCheckSalesDocumentOnBeforeCheckSalesDim(var SalesHeader: Record "Sales Header"; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCreatePrepaymentTextLines(var TempPrepmtSalesLine: Record "Sales Line" temporary; var TempSalesLine: Record "Sales Line" temporary; SalesHeader: Record "Sales Header"; CompleteFunctionality: Boolean; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCheckAndUpdate(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeCollectValueEntryRelation(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesInvoiceLine: Record "Sales Invoice Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnBeforeCollectValueEntryRelationForCrMemo(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesInvoiceLine: Record "Sales Invoice Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterCollectValueEntryRelation(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var SalesInvoiceHeader: Record "Sales Invoice Header"; var SalesInvoiceLine: Record "Sales Invoice Line") begin end; [IntegrationEvent(false, false)] local procedure OnPostSalesLineOnAfterCreatePostedDeferralSchedule(var SalesInvLine: Record "Sales Invoice Line"; SalesInvHeader: Record "Sales Invoice Header") begin end; [IntegrationEvent(false, false)] local procedure OnInvoiceRoundingOnAfterValidateQuantity(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnInvoiceRoundingOnAfterSetLineNo(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line") begin end; /// <summary> /// Raised before updating won opportunities after posting a sales invoice. /// </summary> /// <param name="SalesHeader">The sales header that was posted.</param> /// <param name="SalesInvHeader">The posted sales invoice header.</param> /// <param name="IsHandled">Set to true to skip the default opportunity update logic.</param> [IntegrationEvent(false, false)] procedure OnBeforeUpdateWonOpportunities(var SalesHeader: Record "Sales Header"; SalesInvHeader: Record "Sales Invoice Header"; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnBeforeDeleteServItemOnSaleCreditMemo(var SalesHeader: Record "Sales Header"; var SalesShipmentHeader: Record "Sales Shipment Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnAfterInsertInvoiceHeader(var SalesHeader: Record "Sales Header"; var SalesInvoiceHeader: Record "Sales Invoice Header") begin end; [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnAfterInsertCrMemoHeader(var SalesHeader: Record "Sales Header"; var SalesCrMemoHeader: Record "Sales Cr.Memo Header") begin end; /// <summary> /// Raised before making inventory adjustments after posting. /// </summary> /// <param name="InvtSetup">The inventory setup record.</param> /// <param name="InvtAdjmtHandler">The inventory adjustment handler codeunit.</param> /// <param name="IsHandled">Set to true to skip the default inventory adjustment logic.</param> [IntegrationEvent(false, false)] procedure OnBeforeMakeInventoryAdjustment(var InvtSetup: Record "Inventory Setup"; var InvtAdjmtHandler: Codeunit "Inventory Adjustment Handler"; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnProcessPostingLinesOnBeforePostDropOrderShipment(SalesHeader: Record "Sales Header"; TotalSalesLine: Record "Sales Line"; TotalSalesLineLCY: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnAfterArchiveUnpostedOrder(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; OrderArchived: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCheckReturnRcptLine(var ReturnReceiptLine: Record "Return Receipt Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnInsertReturnReceiptHeaderOnBeforeReturnReceiptHeaderTransferFields(var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCopyAndCheckItemCharge(var SalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var SalesLine: Record "Sales Line"; var InvoiceEverything: Boolean; var AssignError: Boolean; var QtyNeeded: Decimal; var TempItemChargeAssgntSales: Record "Item Charge Assignment (Sales)" temporary; var ItemChargeAssgntSales: Record "Item Charge Assignment (Sales)"; var TempSalesLineGlobal: Record "Sales Line" temporary; var IsHandled: Boolean); begin end; [IntegrationEvent(false, false)] local procedure OnValidatePostingAndDocumentDateOnBeforeTestPostingDate(var SalesHeader: Record "Sales Header"; ReplacePostingDate: Boolean; var SkipTestPostingDate: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnValidatePostingAndDocumentDateOnBeforeSalesHeaderModify(var SalesHeader: Record "Sales Header"; var ModifyHeader: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostItemTrackingForShipmentOnBeforeTestLineFields(var SalesShipmentLine: Record "Sales Shipment Line"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateQtyToBeInvoicedForReturnReceiptOnAfterSetQtyToBeInvoiced(TrackingSpecificationExists: Boolean; var QtyToBeInvoiced: Decimal; var QtyToBeInvoicedBase: Decimal; RemQtyToBeInvoiced: Decimal; RemQtyToBeInvoicedBase: Decimal; var SalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersOnAfterInsertShipmentHeader(var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnInsertPostedHeadersDeleteServItemOnSaleCreditMemo(var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnRunWithCheckOnAfterFinalize(var SalesHeader: Record "Sales Header"); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeFinalizePostATO(var SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeDeleteATOLinks(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCheckATOLink(SalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnSumSalesLinesTempOnAfterVatAmountSet(var VATAmount: Decimal; var TotalSalesLine: Record "Sales Line") begin end; [IntegrationEvent(false, false)] local procedure OnInsertShptEntryRelationOnBeforeDeleteTempHandlingSpecification(var TempHandlingTrackingSpecification: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnUpdateAssosOrderPostingNosOnBeforeModifyPurchOrderHeader(var PurchaseOrderHeader: Record "Purchase Header"; var SalesHeader: Record "Sales Header") begin end; [IntegrationEvent(false, false)] local procedure OnAfterPostJobContractLine(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var GenJnlLineDocType: Enum "Gen. Journal Document Type"; var GenJnlLineDocNo: Code[20]; var GenJnlLineExtDocNo: Code[35]; var SrcCode: Code[10]) begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostDistributeItemCharge(var SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var TempItemLedgerEntry: Record "Item Ledger Entry"; NonDistrQuantity: Decimal; NonDistrQtyToAssign: Decimal; NonDistrAmountToAssign: Decimal; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnPostDistributeItemChargeOnAfterSetFactor(TempItemLedgerEntry: Record "Item Ledger Entry"; var Factor: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeCalcPrepmtAmtToDeduct(var SalesLine: Record "Sales Line"; Ship: Boolean; var IsHandled: Boolean; var PrepmtAmtToDeduct: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostItemJournalLineWarehouseLine(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnAfterPostItemJournalLineWarehouseLine(var TempWarehouseJournalLine: Record "Warehouse Journal Line" temporary; var TempWhseTrackingSpecification: Record "Tracking Specification" temporary) begin end; [IntegrationEvent(false, false)] local procedure OnAdjustPrepmtAmountLCYOnAfterGetOrderLine(var SalesLine: Record "Sales Line"; var SalesInvoiceLine: Record "Sales Line"); begin end; [IntegrationEvent(false, false)] local procedure OnBeforeGetQtyToInvoice(SalesLine: Record "Sales Line"; Ship: Boolean; var IsHandled: Boolean; var QtyToInvoice: Decimal) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeAdjustFinalInvWith100PctPrepmt(var TempPrepmtDeductLCYSalesLine: Record "Sales Line" temporary; var CombinedSalesLine: Record "Sales Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeUpdateRemainingQtyToBeInvoiced(SalesShptLine: Record "Sales Shipment Line"; var RemQtyToInvoiceCurrLine: Decimal; var RemQtyToInvoiceCurrLineBase: Decimal; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnCreatePrepaymentLineForCreditMemoOnBeforeGetSalesPrepmtAccount(var GLAccount: Record "G/L Account"; var SalesInvoiceLine: Record "Sales Invoice Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeUpdateEmailParameters(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforePostUpdateOrderNo(var SalesInvoiceHeader: Record "Sales Invoice Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeSetInvoiceOrderNo(SalesLine: Record "Sales Line"; var SalesInvLine: Record "Sales Invoice Line"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnBeforeArchiveRelatedJob(SalesHeader: Record "Sales Header"; var IsHandled: Boolean) begin end; [IntegrationEvent(false, false)] local procedure OnSyncSurPlusItemTrackingOnBeforeModifyQtyToHandleInvoice(var SalesLine: Record "Sales Line"; var SalesHeader: Record "Sales Header"; var IsHandled: Boolean; var ReservationEntry: Record "Reservation Entry") begin end;}