Codeunit 6620 Copy Document Mgt., source in 29
Source29
src/Layers/W1/BaseApp/Utilities/CopyDocumentMgt.Codeunit.al12538 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.Utilities;
using Microsoft.Assembly.Document;
using Microsoft.Assembly.History;
using Microsoft.CRM.Team;
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.Setup;
using Microsoft.Finance.VAT.Setup;
using Microsoft.FixedAssets.FixedAsset;
using Microsoft.Foundation.Enums;
using Microsoft.Foundation.ExtendedText;
using Microsoft.Foundation.NoSeries;
using Microsoft.Foundation.PaymentTerms;
using Microsoft.Foundation.UOM;
using Microsoft.Inventory.Availability;
using Microsoft.Inventory.Item;
using Microsoft.Inventory.Ledger;
using Microsoft.Inventory.Tracking;
using Microsoft.Projects.Project.Planning;
using Microsoft.Projects.Resources.Resource;
using Microsoft.Purchases.Archive;
using Microsoft.Purchases.Comment;
using Microsoft.Purchases.Document;
using Microsoft.Purchases.History;
using Microsoft.Purchases.Payables;
using Microsoft.Purchases.Setup;
using Microsoft.Purchases.Vendor;
using Microsoft.Sales.Archive;
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 System.IO;
using System.Utilities;
codeunit 6620 "Copy Document Mgt."
{
trigger OnRun()
begin
end;
var
Currency: Record Currency;
TempAsmHeader: Record "Assembly Header" temporary;
TempAsmLine: Record "Assembly Line" temporary;
TempSalesInvLine: Record "Sales Invoice Line" temporary;
GLSetup: Record "General Ledger Setup";
TranslationHelper: Codeunit "Translation Helper";
CustCheckCreditLimit: Codeunit "Cust-Check Cr. Limit";
ItemCheckAvail: Codeunit "Item-Check Avail.";
TransferExtendedText: Codeunit "Transfer Extended Text";
TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines";
ItemTrackingDocMgt: Codeunit "Item Tracking Doc. Management";
UOMMgt: Codeunit "Unit of Measure Management";
ErrorMessageMgt: Codeunit "Error Message Management";
Window: Dialog;
HideProcessWindow: Boolean;
WindowUpdateDateTime: DateTime;
InsertCancellationLine: Boolean;
QtyToAsmToOrder: Decimal;
QtyToAsmToOrderBase: Decimal;
IncludeHeader: Boolean;
RecalculateLines: Boolean;
MoveNegLines: Boolean;
#pragma warning disable AA0074
Text008: Label 'There are no negative sales lines to move.';
#pragma warning disable AA0470
Text009: Label 'NOTE: A Payment Discount was Received by %1 %2.';
#pragma warning restore AA0470
Text010: Label 'There are no negative purchase lines to move.';
#pragma warning restore AA0074
CreateToHeader: Boolean;
#pragma warning disable AA0074
Text011: Label 'Please enter a Vendor No.';
#pragma warning restore AA0074
HideDialog: Boolean;
#pragma warning disable AA0074
Text012: Label 'There are no sales lines to copy.';
Text013: Label 'Shipment No.,Invoice No.,Return Receipt No.,Credit Memo No.';
Text014: Label 'Receipt No.,Invoice No.,Return Shipment No.,Credit Memo No.';
#pragma warning disable AA0470
Text015: Label '%1 %2:';
#pragma warning restore AA0470
Text016: Label 'Inv. No. ,Shpt. No. ,Cr. Memo No. ,Rtrn. Rcpt. No. ';
Text017: Label 'Inv. No. ,Rcpt. No. ,Cr. Memo No. ,Rtrn. Shpt. No. ';
#pragma warning disable AA0470
Text018: Label '%1 - %2:';
#pragma warning restore AA0470
Text019: Label 'Exact Cost Reversing Link has not been created for all copied document lines.';
Text022: Label 'Copying document lines...\';
#pragma warning disable AA0470
Text023: Label 'Processing source lines #1######\';
Text024: Label 'Creating new lines #2######';
#pragma warning restore AA0470
#pragma warning restore AA0074
ExactCostRevMandatory: Boolean;
ApplyFully: Boolean;
AskApply: Boolean;
ReappDone: Boolean;
#pragma warning disable AA0074
Text025: Label 'For one or more return document lines, you chose to return the original quantity, which is already fully applied. Therefore, when you post the return document, the program will reapply relevant entries. Beware that this may change the cost of existing entries. To avoid this, you must delete the affected return document lines before posting.';
#pragma warning restore AA0074
SkippedLine: Boolean;
#pragma warning disable AA0074
Text029: Label 'One or more return document lines were not inserted or they contain only the remaining quantity of the original document line. This is because quantities on the posted document line are already fully or partially applied. If you want to reverse the full quantity, you must select Return Original Quantity before getting the posted document lines.';
Text030: Label 'One or more return document lines were not copied. This is because quantities on the posted document line are already fully or partially applied, so the Exact Cost Reversing link could not be created.';
Text031: Label 'Return document line contains only the original document line quantity, that is not already manually applied.';
#pragma warning restore AA0074
SomeAreFixed: Boolean;
AsmHdrExistsForFromDocLine: Boolean;
#pragma warning disable AA0074
#pragma warning disable AA0470
Text032: Label 'The posted sales invoice %1 covers more than one shipment of linked assembly orders that potentially have different assembly components. Select Posted Shipment as document type, and then select a specific shipment of assembled items.';
#pragma warning restore AA0470
#pragma warning restore AA0074
FromDocOccurrenceNo: Integer;
FromDocVersionNo: Integer;
SkipCopyFromDescription: Boolean;
SkipTestCreditLimit: Boolean;
WarningDone: Boolean;
DiffPostDateOrderQst: Label 'The Posting Date of the copied document is different from the Posting Date of the original document. The original document already has a Posting No. based on a number series with date order. When you post the copied document, you may have the wrong date order in the posted documents.\Do you want to continue?';
CopyPostedDeferral: Boolean;
CrMemoCancellationMsg: Label 'Cancellation of credit memo %1.', Comment = '%1 = Document No.';
CopyExtText: Boolean;
CopyJobData: Boolean;
SkipWarningNotification: Boolean;
SkipOldInvoiceDesc: Boolean;
IsBlockedErr: Label '%1 %2 is blocked.', Comment = '%1 - type of entity, e.g. Item; %2 - entity''s No.';
IsSalesBlockedItemErr: Label 'You cannot sell %1 %2 because the %3 check box is selected on the %1 card.', Comment = '%1 - Table Caption (item/variant), %2 - Entity Code, %3 - Field Caption';
IsPurchBlockedItemErr: Label 'You cannot purchase %1 %2 because the %3 check box is selected on the %1 card.', Comment = '%1 - Table Caption (item/variant), %2 - Entity Code, %3 - Field Caption';
FAIsInactiveErr: Label 'Fixed asset %1 is inactive.', Comment = '%1 - fixed asset no.';
DirectPostingErr: Label 'G/L account %1 does not allow direct posting.', Comment = '%1 - g/l account no.';
SalesErrorContextMsg: Label 'Copying sales document %1', Comment = '%1 - document no.';
PurchErrorContextMsg: Label 'Copying purchase document %1', Comment = '%1 - document no.';
#pragma warning disable AA0074
Text000: Label 'Please enter a Document No.';
#pragma warning disable AA0470
Text001: Label '%1 %2 cannot be copied onto itself.';
#pragma warning restore AA0470
#pragma warning restore AA0074
DeleteLinesQst: Label 'The existing lines for %1 %2 will be deleted.\\Do you want to continue?', Comment = '%1=Document type, e.g. Invoice. %2=Document No., e.g. 001';
#pragma warning disable AA0074
#pragma warning disable AA0470
Text006: Label 'NOTE: A Payment Discount was Granted by %1 %2.';
#pragma warning restore AA0470
#pragma warning restore AA0074
procedure SetProperties(NewIncludeHeader: Boolean; NewRecalculateLines: Boolean; NewMoveNegLines: Boolean; NewCreateToHeader: Boolean; NewHideDialog: Boolean; NewExactCostRevMandatory: Boolean; NewApplyFully: Boolean)
begin
IncludeHeader := NewIncludeHeader;
RecalculateLines := NewRecalculateLines;
MoveNegLines := NewMoveNegLines;
CreateToHeader := NewCreateToHeader;
HideDialog := NewHideDialog;
ExactCostRevMandatory := NewExactCostRevMandatory;
ApplyFully := NewApplyFully;
AskApply := false;
ReappDone := false;
SkippedLine := false;
SomeAreFixed := false;
SkipCopyFromDescription := false;
SkipTestCreditLimit := false;
OnAfterSetProperties(IncludeHeader, RecalculateLines, MoveNegLines, CreateToHeader, HideDialog, ExactCostRevMandatory, ApplyFully);
end;
procedure SetPropertiesForCreditMemoCorrection()
begin
SetProperties(true, false, false, false, true, true, false);
end;
procedure SetPropertiesForInvoiceCorrection(NewSkipCopyFromDescription: Boolean)
begin
SetProperties(true, false, false, false, true, false, false);
SkipTestCreditLimit := true;
SkipCopyFromDescription := NewSkipCopyFromDescription;
end;
procedure GetSalesDocumentType(FromDocType: Enum "Sales Document Type From") ToDocType: Enum "Sales Document Type"
begin
case FromDocType of
FromDocType::Quote:
exit("Sales Document Type"::Quote);
FromDocType::"Blanket Order":
exit("Sales Document Type"::"Blanket Order");
FromDocType::Order:
exit("Sales Document Type"::Order);
FromDocType::Invoice:
exit("Sales Document Type"::Invoice);
FromDocType::"Return Order":
exit("Sales Document Type"::"Return Order");
FromDocType::"Credit Memo":
exit("Sales Document Type"::"Credit Memo");
FromDocType::"Arch. Quote":
exit("Sales Document Type"::Quote);
FromDocType::"Arch. Order":
exit("Sales Document Type"::Order);
FromDocType::"Arch. Blanket Order":
exit("Sales Document Type"::"Blanket Order");
FromDocType::"Arch. Return Order":
exit("Sales Document Type"::"Return Order");
else
OnGetSalesDocumentTypeCaseElse(FromDocType, ToDocType);
end;
end;
procedure GetPurchaseDocumentType(FromDocType: Enum "Purchase Document Type From") ToDocType: Enum "Purchase Document Type"
begin
case FromDocType of
FromDocType::Quote:
exit("Purchase Document Type"::Quote);
FromDocType::"Blanket Order":
exit("Purchase Document Type"::"Blanket Order");
FromDocType::Order:
exit("Purchase Document Type"::Order);
FromDocType::Invoice:
exit("Purchase Document Type"::Invoice);
FromDocType::"Return Order":
exit("Purchase Document Type"::"Return Order");
FromDocType::"Credit Memo":
exit("Purchase Document Type"::"Credit Memo");
FromDocType::"Arch. Quote":
exit("Purchase Document Type"::Quote);
FromDocType::"Arch. Order":
exit("Purchase Document Type"::Order);
FromDocType::"Arch. Blanket Order":
exit("Purchase Document Type"::"Blanket Order");
FromDocType::"Arch. Return Order":
exit("Purchase Document Type"::"Return Order");
else
OnGetPurchaseDocumentTypeCaseElse(FromDocType, ToDocType);
end;
end;
procedure CopySalesDocForInvoiceCancelling(FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header")
begin
CopyJobData := true;
SkipWarningNotification := true;
OnBeforeCopySalesDocForInvoiceCancelling(ToSalesHeader, FromDocNo);
CopySalesDoc("Sales Document Type From"::"Posted Invoice", FromDocNo, ToSalesHeader);
OnAfterCopySalesDocForInvoiceCancelling(FromDocNo, ToSalesHeader, IncludeHeader, RecalculateLines, MoveNegLines, CreateToHeader, HideDialog, ExactCostRevMandatory, ApplyFully, SkipTestCreditLimit, SkipCopyFromDescription);
end;
procedure CopySalesDocForCrMemoCancelling(FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header")
begin
CopyJobData := true;
SkipWarningNotification := true;
InsertCancellationLine := true;
OnBeforeCopySalesDocForCrMemoCancelling(ToSalesHeader, FromDocNo, CopyJobData);
CopySalesDoc("Sales Document Type From"::"Posted Credit Memo", FromDocNo, ToSalesHeader);
InsertCancellationLine := false;
OnAfterCopySalesDocForCrMemoCancelling(FromDocNo, ToSalesHeader, IncludeHeader, RecalculateLines, MoveNegLines, CreateToHeader, HideDialog, ExactCostRevMandatory, ApplyFully, SkipTestCreditLimit, SkipCopyFromDescription);
end;
procedure CopySalesDoc(FromDocType: Enum "Sales Document Type From"; FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header")
var
ToSalesLine: Record "Sales Line";
FromSalesHeader: Record "Sales Header";
FromSalesShptHeader: Record "Sales Shipment Header";
FromSalesInvHeader: Record "Sales Invoice Header";
FromReturnRcptHeader: Record "Return Receipt Header";
FromSalesCrMemoHeader: Record "Sales Cr.Memo Header";
FromSalesHeaderArchive: Record "Sales Header Archive";
ReleaseSalesDocument: Codeunit "Release Sales Document";
ConfirmManagement: Codeunit "Confirm Management";
ErrorContextElement: Codeunit "Error Context Element";
ErrorMessageHandler: Codeunit "Error Message Handler";
NextLineNo: Integer;
LinesNotCopied: Integer;
MissingExCostRevLink: Boolean;
ReleaseDocument: Boolean;
IsHandled, ShouldExit : Boolean;
begin
if not CreateToHeader then begin
ToSalesHeader.TestField(Status, ToSalesHeader.Status::Open);
if FromDocNo = '' then
Error(Text000);
ToSalesHeader.Find();
end;
IsHandled := false;
OnBeforeCopySalesDocument(FromDocType.AsInteger(), FromDocNo, ToSalesHeader, IsHandled);
if IsHandled then
exit;
TransferOldExtLines.ClearLineNumbers();
if not InitAndCheckSalesDocuments(
FromDocType.AsInteger(), FromDocNo, FromSalesHeader, ToSalesHeader, ToSalesLine,
FromSalesShptHeader, FromSalesInvHeader, FromReturnRcptHeader, FromSalesCrMemoHeader,
FromSalesHeaderArchive)
then
exit;
ToSalesLine.LockTable();
ToSalesLine.SetRange("Document Type", ToSalesHeader."Document Type");
if CreateToHeader then begin
OnCopySalesDocOnBeforeToSalesHeaderInsert(ToSalesHeader, FromSalesHeader, MoveNegLines);
ToSalesHeader.Insert(true);
ToSalesLine.SetRange("Document No.", ToSalesHeader."No.");
end else begin
ToSalesLine.SetRange("Document No.", ToSalesHeader."No.");
if IncludeHeader then
if not ToSalesLine.IsEmpty() then begin
Commit();
IsHandled := false;
OnCopySalesDocOnBeforeConfirmDeleteLines(ToSalesHeader, ToSalesLine, IsHandled);
if not IsHandled then
if not ConfirmManagement.GetResponseOrDefault(
StrSubstNo(DeleteLinesQst, ToSalesHeader."Document Type", ToSalesHeader."No."), true)
then
exit;
OnCopySalesDocOnBeforeToSalesLineDeleteAll(ToSalesLine);
ToSalesLine.DeleteAll(true);
OnCopySalesDocOnAfterToSalesLineDeleteAll(ToSalesLine);
end;
end;
if ToSalesLine.FindLast() then
NextLineNo := ToSalesLine."Line No."
else
NextLineNo := 0;
if IncludeHeader then begin
CopySalesDocUpdateHeader(
FromDocType, FromDocNo, ToSalesHeader, FromSalesHeader,
FromSalesShptHeader, FromSalesInvHeader, FromReturnRcptHeader, FromSalesCrMemoHeader, FromSalesHeaderArchive, ReleaseDocument);
OnCopySalesDocOnAfterCopySalesDocUpdateHeader(ToSalesHeader, FromSalesInvHeader, FromDocType);
end else
OnCopySalesDocWithoutHeader(ToSalesHeader, FromDocType.AsInteger(), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo, FromSalesInvHeader, FromSalesCrMemoHeader);
LinesNotCopied := 0;
ErrorMessageMgt.Activate(ErrorMessageHandler);
ErrorMessageMgt.PushContext(ErrorContextElement, ToSalesHeader.RecordId, 0, StrSubstNo(SalesErrorContextMsg, FromDocNo));
IsHandled := false;
OnCopySalesDocOnBeforeCopyLines(FromSalesHeader, ToSalesHeader, IsHandled, FromDocType);
if not IsHandled then
case FromDocType of
"Sales Document Type From"::Quote,
"Sales Document Type From"::"Blanket Order",
"Sales Document Type From"::Order,
"Sales Document Type From"::Invoice,
"Sales Document Type From"::"Return Order",
"Sales Document Type From"::"Credit Memo":
CopySalesDocSalesLine(FromSalesHeader, ToSalesHeader, LinesNotCopied, NextLineNo);
"Sales Document Type From"::"Posted Shipment":
begin
FromSalesHeader.TransferFields(FromSalesShptHeader);
OnCopySalesDocOnBeforeCopySalesDocShptLine(FromSalesShptHeader, ToSalesHeader);
CopySalesDocShptLine(FromSalesShptHeader, ToSalesHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Sales Document Type From"::"Posted Invoice":
begin
FromSalesHeader.TransferFields(FromSalesInvHeader);
ShouldExit := false;
OnCopySalesDocOnBeforeCopySalesDocInvLine(FromSalesInvHeader, ToSalesHeader, ShouldExit);
if ShouldExit then
exit;
CopySalesDocInvLine(FromSalesInvHeader, ToSalesHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Sales Document Type From"::"Posted Return Receipt":
begin
FromSalesHeader.TransferFields(FromReturnRcptHeader);
OnCopySalesDocOnBeforeCopySalesDocReturnRcptLine(FromReturnRcptHeader, ToSalesHeader);
CopySalesDocReturnRcptLine(FromReturnRcptHeader, ToSalesHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Sales Document Type From"::"Posted Credit Memo":
begin
FromSalesHeader.TransferFields(FromSalesCrMemoHeader);
OnCopySalesDocOnBeforeCopySalesDocCrMemoLine(FromSalesCrMemoHeader, ToSalesHeader);
CopySalesDocCrMemoLine(FromSalesCrMemoHeader, ToSalesHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Sales Document Type From"::"Arch. Quote",
"Sales Document Type From"::"Arch. Order",
"Sales Document Type From"::"Arch. Blanket Order",
"Sales Document Type From"::"Arch. Return Order":
CopySalesDocSalesLineArchive(FromSalesHeaderArchive, ToSalesHeader, LinesNotCopied, NextLineNo);
end;
OnCopySalesDocOnBeforeUpdateSalesInvoiceDiscountValue(
ToSalesHeader, FromDocType.AsInteger(), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo, RecalculateLines);
UpdateSalesInvoiceDiscountValue(ToSalesHeader);
if MoveNegLines then begin
OnBeforeDeleteNegSalesLines(FromDocType.AsInteger(), FromDocNo, ToSalesHeader);
DeleteSalesLinesWithNegQty(FromSalesHeader, false);
LinkJobPlanningLine(ToSalesHeader);
end;
IsHandled := false;
OnCopySalesDocOnAfterCopySalesDocLines(
FromDocType.AsInteger(), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo, FromSalesHeader, IncludeHeader, ToSalesHeader, HideDialog, ReleaseDocument, IsHandled);
if IsHandled then
if ReleaseDocument then begin
ToSalesHeader.Status := ToSalesHeader.Status::Released;
ReleaseSalesDocument.Reopen(ToSalesHeader);
end else
if (FromDocType in
["Sales Document Type From"::Quote,
"Sales Document Type From"::"Blanket Order",
"Sales Document Type From"::Order,
"Sales Document Type From"::Invoice,
"Sales Document Type From"::"Return Order",
"Sales Document Type From"::"Credit Memo"])
and not IncludeHeader and not RecalculateLines
then
if FromSalesHeader.Status = FromSalesHeader.Status::Released then begin
ReleaseSalesDocument.SetSkipCheckReleaseRestrictions();
ReleaseSalesDocument.Run(ToSalesHeader);
ReleaseSalesDocument.Reopen(ToSalesHeader);
end;
if ShowWarningNotification(ToSalesHeader, MissingExCostRevLink) then begin
ErrorMessageHandler.NotifyAboutErrors();
ErrorMessageMgt.PopContext(ErrorContextElement);
end;
ToSalesLine.GetCaptionClass(ToSalesHeader.FieldNo("Prices Including VAT"));
OnAfterCopySalesDocument(
FromDocType.AsInteger(), FromDocNo, ToSalesHeader, FromDocOccurrenceNo, FromDocVersionNo, IncludeHeader, RecalculateLines, MoveNegLines);
end;
procedure CopySalesDocSalesLine(FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer; NextLineNo: Integer)
var
AssemblyHeader: Record "Assembly Header";
ToSalesLine: Record "Sales Line";
FromSalesLine: Record "Sales Line";
ItemChargeAssgntNextLineNo: Integer;
ShouldRunIteration: Boolean;
begin
OnBeforeCopySalesDocSalesLine(FromSalesHeader, ToSalesHeader);
ItemChargeAssgntNextLineNo := 0;
FromSalesLine.Reset();
FromSalesLine.SetRange("Document Type", FromSalesHeader."Document Type");
FromSalesLine.SetRange("Document No.", FromSalesHeader."No.");
if MoveNegLines then
FromSalesLine.SetFilter(Quantity, '<=0');
OnCopySalesDocSalesLineOnAfterSetFilters(FromSalesHeader, FromSalesLine, ToSalesHeader, RecalculateLines);
if FromSalesLine.Find('-') then
repeat
ShouldRunIteration := not ExtTxtAttachedToPosSalesLine(FromSalesHeader, FromSalesLine);
OnCopySalesDocSalesLineOnAfterCalcShouldRunIteration(FromSalesHeader, ToSalesHeader, FromSalesLine, ShouldRunIteration);
if ShouldRunIteration then begin
InitAsmCopyHandling(true);
ToSalesLine."Document Type" := ToSalesHeader."Document Type";
AsmHdrExistsForFromDocLine := FromSalesLine.AsmToOrderExists(AssemblyHeader);
if AsmHdrExistsForFromDocLine then begin
case ToSalesLine."Document Type" of
ToSalesLine."Document Type"::Order:
begin
QtyToAsmToOrder := FromSalesLine."Qty. to Assemble to Order";
QtyToAsmToOrderBase := FromSalesLine."Qty. to Asm. to Order (Base)";
end;
ToSalesLine."Document Type"::Quote,
ToSalesLine."Document Type"::"Blanket Order":
begin
QtyToAsmToOrder := FromSalesLine.Quantity;
QtyToAsmToOrderBase := FromSalesLine."Quantity (Base)";
end;
end;
GenerateAsmDataFromNonPosted(AssemblyHeader);
end;
if CopySalesDocLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine,
NextLineNo, LinesNotCopied, false,
ConvertToSalesDocumentTypeFrom(FromSalesHeader."Document Type"),
CopyPostedDeferral, FromSalesLine."Line No.")
then begin
OnCopySalesDocSalesLineOnBeforeCopyFromSalesDocAssgntToLine(FromSalesLine, ToSalesLine, RecalculateLines, NextLineNo, LinesNotCopied);
if FromSalesLine.Type = FromSalesLine.Type::"Charge (Item)" then
CopyFromSalesDocAssgntToLine(
ToSalesLine, FromSalesLine."Document Type", FromSalesLine."Document No.", FromSalesLine."Line No.",
ItemChargeAssgntNextLineNo);
OnAfterCopySalesLineFromSalesDocSalesLine(
ToSalesHeader, ToSalesLine, FromSalesLine, IncludeHeader, RecalculateLines);
end;
end;
OnCopySalesDocSalesLineOnBeforeFinishSalesDocSalesLine(FromSalesHeader, ToSalesHeader, ToSalesLine, FromSalesLine, RecalculateLines);
until FromSalesLine.Next() = 0;
OnAfterCopySalesDocSalesLine(ToSalesLine, TransferOldExtLines, FromSalesHeader, ToSalesHeader);
end;
local procedure ConvertToSalesDocumentTypeFrom(SalesDocType: Enum "Sales Document Type") SalesDocTypeFrom: Enum "Sales Document Type From"
begin
case SalesDocType of
SalesDocType::Quote:
exit(SalesDocTypeFrom::Quote);
SalesDocType::Order:
exit(SalesDocTypeFrom::Order);
SalesDocType::Invoice:
exit(SalesDocTypeFrom::Invoice);
SalesDocType::"Credit Memo":
exit(SalesDocTypeFrom::"Credit Memo");
SalesDocType::"Blanket Order":
exit(SalesDocTypeFrom::"Blanket Order");
SalesDocType::"Return Order":
exit(SalesDocTypeFrom::"Return Order");
end;
end;
/// <summary>
/// Converts a Purchase Document Type enum value to the corresponding Purchase Document Type From enum value.
/// </summary>
/// <param name="PurchaseDocType">The purchase document type to convert.</param>
/// <returns>The corresponding Purchase Document Type From value.</returns>
procedure ConvertToPurchaseDocumentTypeFrom(PurchaseDocType: Enum "Purchase Document Type") PurchaseDocTypeFrom: Enum "Purchase Document Type From"
begin
case PurchaseDocType of
PurchaseDocType::Quote:
exit(PurchaseDocTypeFrom::Quote);
PurchaseDocType::Order:
exit(PurchaseDocTypeFrom::Order);
PurchaseDocType::Invoice:
exit(PurchaseDocTypeFrom::Invoice);
PurchaseDocType::"Credit Memo":
exit(PurchaseDocTypeFrom::"Credit Memo");
PurchaseDocType::"Blanket Order":
exit(PurchaseDocTypeFrom::"Blanket Order");
PurchaseDocType::"Return Order":
exit(PurchaseDocTypeFrom::"Return Order");
end;
end;
local procedure CopySalesDocShptLine(FromSalesShptHeader: Record "Sales Shipment Header"; ToSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromSalesShptLine: Record "Sales Shipment Line";
begin
FromSalesShptLine.Reset();
FromSalesShptLine.SetRange("Document No.", FromSalesShptHeader."No.");
if MoveNegLines then
FromSalesShptLine.SetFilter(Quantity, '<=0');
OnCopySalesDocShptLineOnAfterSetFilters(ToSalesHeader, FromSalesShptHeader, FromSalesShptLine, RecalculateLines);
CopySalesShptLinesToDoc(ToSalesHeader, FromSalesShptLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CopySalesDocInvLine(FromSalesInvHeader: Record "Sales Invoice Header"; ToSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromSalesInvLine: Record "Sales Invoice Line";
begin
FromSalesInvLine.Reset();
FromSalesInvLine.SetRange("Document No.", FromSalesInvHeader."No.");
if MoveNegLines then
FromSalesInvLine.SetFilter(Quantity, '<=0');
OnCopySalesDocInvLineOnAfterSetFilters(ToSalesHeader, FromSalesInvHeader, FromSalesInvLine, RecalculateLines);
CopySalesInvLinesToDoc(ToSalesHeader, FromSalesInvLine, LinesNotCopied, MissingExCostRevLink);
OnAfterCopySalesDocInvLine(FromSalesInvHeader, ToSalesHeader, FromSalesInvLine);
end;
local procedure CopySalesDocCrMemoLine(FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; ToSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromSalesCrMemoLine: Record "Sales Cr.Memo Line";
begin
FromSalesCrMemoLine.Reset();
FromSalesCrMemoLine.SetRange("Document No.", FromSalesCrMemoHeader."No.");
if MoveNegLines then
FromSalesCrMemoLine.SetFilter(Quantity, '<=0');
OnCopySalesDocCrMemoLineOnAfterSetFilters(ToSalesHeader, FromSalesCrMemoHeader, FromSalesCrMemoLine, RecalculateLines);
CopySalesCrMemoLinesToDoc(ToSalesHeader, FromSalesCrMemoLine, LinesNotCopied, MissingExCostRevLink);
OnAfterCopySalesDocCrMemoLine(FromSalesCrMemoHeader, ToSalesHeader, FromSalesCrMemoLine);
end;
local procedure CopySalesDocReturnRcptLine(FromReturnRcptHeader: Record "Return Receipt Header"; ToSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromReturnRcptLine: Record "Return Receipt Line";
begin
FromReturnRcptLine.Reset();
FromReturnRcptLine.SetRange("Document No.", FromReturnRcptHeader."No.");
if MoveNegLines then
FromReturnRcptLine.SetFilter(Quantity, '<=0');
OnCopySalesDocReturnRcptLineOnAfterSetFilters(ToSalesHeader, FromReturnRcptHeader, FromReturnRcptLine);
CopySalesReturnRcptLinesToDoc(ToSalesHeader, FromReturnRcptLine, LinesNotCopied, MissingExCostRevLink);
end;
procedure CopySalesDocSalesLineArchive(FromSalesHeaderArchive: Record "Sales Header Archive"; var ToSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer; NextLineNo: Integer)
var
ToSalesLine: Record "Sales Line";
FromSalesLineArchive: Record "Sales Line Archive";
ItemChargeAssgntNextLineNo: Integer;
begin
OnBeforeCopySalesDocSalesLineArchive(FromSalesHeaderArchive, ToSalesHeader);
ItemChargeAssgntNextLineNo := 0;
FromSalesLineArchive.Reset();
FromSalesLineArchive.SetRange("Document Type", FromSalesHeaderArchive."Document Type");
FromSalesLineArchive.SetRange("Document No.", FromSalesHeaderArchive."No.");
FromSalesLineArchive.SetRange("Doc. No. Occurrence", FromSalesHeaderArchive."Doc. No. Occurrence");
FromSalesLineArchive.SetRange("Version No.", FromSalesHeaderArchive."Version No.");
if MoveNegLines then
FromSalesLineArchive.SetFilter(Quantity, '<=0');
OnCopySalesDocSalesLineArchiveOnAfterSetFilters(FromSalesHeaderArchive, FromSalesLineArchive, ToSalesHeader);
if FromSalesLineArchive.Find('-') then
repeat
if CopyArchSalesLine(
ToSalesHeader, ToSalesLine, FromSalesHeaderArchive, FromSalesLineArchive, NextLineNo, LinesNotCopied, false)
then begin
OnCopyArchSalesLineOnBeforeCopyFromArchSalesDocDimToLine(ToSalesHeader, ToSalesLine, FromSalesHeaderArchive, FromSalesLineArchive, RecalculateLines, LinesNotCopied);
if ToSalesLine."Qty. to Assemble to Order" <> 0 then
ToSalesLine.AutoAsmToOrder();
CopyFromArchSalesDocDimToLine(ToSalesLine, FromSalesLineArchive);
if FromSalesLineArchive.Type = FromSalesLineArchive.Type::"Charge (Item)" then
CopyFromSalesDocAssgntToLine(
ToSalesLine, FromSalesLineArchive."Document Type", FromSalesLineArchive."Document No.", FromSalesLineArchive."Line No.",
ItemChargeAssgntNextLineNo);
OnAfterCopyArchSalesLine(ToSalesHeader, ToSalesLine, FromSalesLineArchive, IncludeHeader, RecalculateLines);
end;
until FromSalesLineArchive.Next() = 0;
OnAfterCopySalesDocSalesLineArchive(FromSalesHeaderArchive, ToSalesHeader, ToSalesLine, TransferOldExtLines);
end;
procedure CopySalesDocUpdateHeader(FromDocType: Enum "Sales Document Type From"; FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; FromSalesShptHeader: Record "Sales Shipment Header"; FromSalesInvHeader: Record "Sales Invoice Header"; FromReturnRcptHeader: Record "Return Receipt Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; FromSalesHeaderArchive: Record "Sales Header Archive"; var ReleaseDocument: Boolean);
var
OldSalesHeader: Record "Sales Header";
SavedDimSetId: Integer;
IsHandled: Boolean;
ShouldValidateDimensionsAndLocation: Boolean;
begin
CheckCustomer(FromSalesHeader, ToSalesHeader);
OldSalesHeader := ToSalesHeader;
OnBeforeCopySalesHeaderDone(ToSalesHeader, FromSalesHeader, FromDocType, OldSalesHeader, FromSalesShptHeader, FromSalesInvHeader, FromReturnRcptHeader, FromSalesCrMemoHeader, FromSalesHeaderArchive);
case FromDocType of
"Sales Document Type From"::Quote,
"Sales Document Type From"::"Blanket Order",
"Sales Document Type From"::Order,
"Sales Document Type From"::Invoice,
"Sales Document Type From"::"Return Order",
"Sales Document Type From"::"Credit Memo":
CopySalesHeaderFromSalesHeader(FromDocType, FromSalesHeader, OldSalesHeader, ToSalesHeader);
"Sales Document Type From"::"Posted Shipment":
CopySalesHeaderFromPostedShipment(FromSalesShptHeader, ToSalesHeader, OldSalesHeader);
"Sales Document Type From"::"Posted Invoice":
CopySalesHeaderFromPostedInvoice(FromSalesInvHeader, ToSalesHeader, OldSalesHeader);
"Sales Document Type From"::"Posted Return Receipt":
CopySalesHeaderFromPostedReturnReceipt(FromReturnRcptHeader, ToSalesHeader, OldSalesHeader);
"Sales Document Type From"::"Posted Credit Memo":
TransferFieldsFromCrMemoToInv(ToSalesHeader, FromSalesCrMemoHeader);
"Sales Document Type From"::"Arch. Quote",
"Sales Document Type From"::"Arch. Order",
"Sales Document Type From"::"Arch. Blanket Order",
"Sales Document Type From"::"Arch. Return Order":
CopySalesHeaderFromSalesHeaderArchive(FromSalesHeaderArchive, ToSalesHeader, OldSalesHeader);
end;
OnAfterCopySalesHeaderDone(
ToSalesHeader, OldSalesHeader, FromSalesHeader, FromSalesShptHeader, FromSalesInvHeader,
FromReturnRcptHeader, FromSalesCrMemoHeader, FromSalesHeaderArchive, FromDocType);
ClearInvoiceAndShip(ToSalesHeader);
if ToSalesHeader.Status = ToSalesHeader.Status::Released then begin
ToSalesHeader.Status := ToSalesHeader.Status::Open;
ReleaseDocument := true;
end;
ShouldValidateDimensionsAndLocation := MoveNegLines or IncludeHeader;
OnCopySalesDocUpdateHeaderOnAfterSetStatusOpen(ToSalesHeader, OldSalesHeader, ShouldValidateDimensionsAndLocation);
IsHandled := false;
OnCopySalesDocUpdateHeaderOnBeforeValidateLocationCode(ToSalesHeader, IsHandled);
if not IsHandled then
if ShouldValidateDimensionsAndLocation then begin
SavedDimSetId := ToSalesHeader."Dimension Set ID";
if not ToSalesHeader.IsCreditDocType() then
ToSalesHeader.Validate(ToSalesHeader."Location Code");
ToSalesHeader.Validate(ToSalesHeader."Dimension Set ID", SavedDimSetId);
end;
CopyShiptoCodeFromInvToCrMemo(ToSalesHeader, FromSalesInvHeader, FromDocType);
CopyFieldsFromOldSalesHeader(ToSalesHeader, OldSalesHeader);
OnAfterCopyFieldsFromOldSalesHeader(ToSalesHeader, OldSalesHeader, MoveNegLines, IncludeHeader, FromDocType, RecalculateLines);
if RecalculateLines then begin
if IncludeHeader then
SavedDimSetId := ToSalesHeader."Dimension Set ID";
ToSalesHeader.CreateDimFromDefaultDim(0);
if IncludeHeader then
ToSalesHeader.Validate("Dimension Set ID", SavedDimSetId);
end;
ToSalesHeader."No. Printed" := 0;
ToSalesHeader."Applies-to Doc. Type" := ToSalesHeader."Applies-to Doc. Type"::" ";
ToSalesHeader."Applies-to Doc. No." := '';
ToSalesHeader."Applies-to ID" := '';
ToSalesHeader."Opportunity No." := '';
ToSalesHeader."Quote No." := '';
OnCopySalesDocUpdateHeaderOnBeforeUpdateCustLedgerEntry(ToSalesHeader, FromDocType.AsInteger(), FromDocNo, OldSalesHeader);
if ((FromDocType = "Sales Document Type From"::"Posted Invoice") and
(ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::"Return Order", ToSalesHeader."Document Type"::"Credit Memo"])) or
((FromDocType = "Sales Document Type From"::"Posted Credit Memo") and
not (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::"Return Order", ToSalesHeader."Document Type"::"Credit Memo"]))
then
UpdateCustLedgerEntry(ToSalesHeader, FromDocType, FromDocNo);
HandleZeroAmountPostedInvoices(FromSalesInvHeader, ToSalesHeader, FromDocType, FromDocNo);
if ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::"Blanket Order", ToSalesHeader."Document Type"::Quote] then
ToSalesHeader."Posting Date" := 0D;
ToSalesHeader.Correction := false;
if ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::"Return Order", ToSalesHeader."Document Type"::"Credit Memo"] then
UpdateSalesCreditMemoHeader(ToSalesHeader);
GLSetup.Get();
if GLSetup."Journal Templ. Name Mandatory" then
if ToSalesHeader.IsCreditDocType() <> IsCreditSalesFromDocType(FromDocType) then
ToSalesHeader."Journal Templ. Name" := OldSalesHeader."Journal Templ. Name";
OnBeforeModifySalesHeader(ToSalesHeader, FromDocType.AsInteger(), FromDocNo, IncludeHeader, FromDocOccurrenceNo, FromDocVersionNo, RecalculateLines,
FromSalesHeader, FromSalesInvHeader, FromSalesCrMemoHeader, OldSalesHeader);
if CreateToHeader then begin
ToSalesHeader.Validate(ToSalesHeader."Payment Terms Code");
ToSalesHeader.Modify(true);
end else
ToSalesHeader.Modify();
OnCopySalesDocWithHeader(FromDocType.AsInteger(), FromDocNo, ToSalesHeader, FromDocOccurrenceNo, FromDocVersionNo, FromSalesHeader);
end;
local procedure IsCreditSalesFromDocType(FromDocType: Enum "Sales Document Type From"): Boolean
begin
exit(FromDocType in ["Sales Document Type From"::"Return Order", "Sales Document Type From"::"Credit Memo"]);
end;
local procedure ClearInvoiceAndShip(var ToSalesHeader: Record "Sales Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeClearInvoiceAndShip(ToSalesHeader, IsHandled);
if IsHandled then
exit;
ToSalesHeader.Invoice := false;
ToSalesHeader.Ship := false;
end;
local procedure CopySalesHeaderFromSalesHeader(FromDocType: Enum "Sales Document Type From"; FromSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header")
begin
FromSalesHeader.CalcFields("Work Description");
ToSalesHeader.TransferFields(FromSalesHeader, false);
UpdateShipToAddress(ToSalesHeader);
UpdateSalesHeaderWhenCopyFromSalesHeader(ToSalesHeader, OldSalesHeader, FromDocType);
SetReceivedFromCountryCode(FromDocType, ToSalesHeader);
OnAfterCopySalesHeader(ToSalesHeader, OldSalesHeader, FromSalesHeader, FromDocType);
end;
local procedure CopySalesHeaderFromPostedShipment(FromSalesShptHeader: Record "Sales Shipment Header"; var ToSalesHeader: Record "Sales Header"; var OldSalesHeader: Record "Sales Header")
begin
FromSalesShptHeader.CalcFields("Work Description");
ToSalesHeader.Validate("Sell-to Customer No.", FromSalesShptHeader."Sell-to Customer No.");
OnCopySalesDocOnBeforeTransferPostedShipmentFields(ToSalesHeader, FromSalesShptHeader);
if ToSalesHeader."Sell-to Customer No." <> FromSalesShptHeader."Sell-to Customer No." then
exit;
ToSalesHeader.TransferFields(FromSalesShptHeader, false);
UpdateShipToAddress(ToSalesHeader);
SetReceivedFromCountryCode(FromSalesShptHeader, ToSalesHeader);
OnAfterCopyPostedShipment(ToSalesHeader, OldSalesHeader, FromSalesShptHeader);
end;
local procedure CopySalesHeaderFromPostedInvoice(FromSalesInvHeader: Record "Sales Invoice Header"; var ToSalesHeader: Record "Sales Header"; var OldSalesHeader: Record "Sales Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopySalesHeaderFromPostedInvoice(ToSalesHeader, FromSalesInvHeader, IsHandled);
if not IsHandled then begin
FromSalesInvHeader.CalcFields("Work Description");
ToSalesHeader.Validate("Sell-to Customer No.", FromSalesInvHeader."Sell-to Customer No.");
OnCopySalesDocOnBeforeTransferPostedInvoiceFields(ToSalesHeader, FromSalesInvHeader, CopyJobData);
if ToSalesHeader."Sell-to Customer No." <> FromSalesInvHeader."Sell-to Customer No." then
exit;
ToSalesHeader.TransferFields(FromSalesInvHeader, false);
UpdateShipToAddress(ToSalesHeader);
SetReceivedFromCountryCode(FromSalesInvHeader, ToSalesHeader);
OnCopySalesDocOnAfterTransferPostedInvoiceFields(ToSalesHeader, FromSalesInvHeader, OldSalesHeader);
end;
end;
local procedure CopySalesHeaderFromPostedReturnReceipt(FromReturnRcptHeader: Record "Return Receipt Header"; var ToSalesHeader: Record "Sales Header"; var OldSalesHeader: Record "Sales Header")
begin
ToSalesHeader.Validate("Sell-to Customer No.", FromReturnRcptHeader."Sell-to Customer No.");
OnCopySalesDocOnBeforeTransferPostedReturnReceiptFields(ToSalesHeader, FromReturnRcptHeader);
if ToSalesHeader."Sell-to Customer No." <> FromReturnRcptHeader."Sell-to Customer No." then
exit;
ToSalesHeader.TransferFields(FromReturnRcptHeader, false);
SetReceivedFromCountryCode(ToSalesHeader);
OnAfterCopyPostedReturnReceipt(ToSalesHeader, OldSalesHeader, FromReturnRcptHeader);
end;
local procedure CopySalesHeaderFromSalesHeaderArchive(FromSalesHeaderArchive: Record "Sales Header Archive"; var ToSalesHeader: Record "Sales Header"; var OldSalesHeader: Record "Sales Header")
begin
FromSalesHeaderArchive.CalcFields("Work Description");
ToSalesHeader.Validate("Sell-to Customer No.", FromSalesHeaderArchive."Sell-to Customer No.");
if ToSalesHeader."Sell-to Customer No." <> FromSalesHeaderArchive."Sell-to Customer No." then
exit;
ToSalesHeader.TransferFields(FromSalesHeaderArchive, false);
OnCopySalesDocOnAfterTransferArchSalesHeaderFields(ToSalesHeader, FromSalesHeaderArchive);
UpdateSalesHeaderWhenCopyFromSalesHeaderArchive(ToSalesHeader);
CopyFromArchSalesDocDimToHdr(ToSalesHeader, FromSalesHeaderArchive);
SetReceivedFromCountryCode(FromSalesHeaderArchive, ToSalesHeader);
OnAfterCopySalesHeaderArchive(ToSalesHeader, OldSalesHeader, FromSalesHeaderArchive)
end;
procedure CheckCustomer(var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header")
var
Cust: Record Customer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckCustomer(FromSalesHeader, ToSalesHeader, IsHandled);
if IsHandled then
exit;
if Cust.Get(FromSalesHeader."Sell-to Customer No.") then
Cust.CheckBlockedCustOnDocs(Cust, ToSalesHeader."Document Type", false, false);
if Cust.Get(FromSalesHeader."Bill-to Customer No.") then
Cust.CheckBlockedCustOnDocs(Cust, ToSalesHeader."Document Type", false, false);
end;
local procedure CheckAsmHdrExistsForFromDocLine(ToSalesHeader: Record "Sales Header"; FromSalesLine2: Record "Sales Line"; var BufferCount: Integer; LineCountsEqual: Boolean)
begin
BufferCount += 1;
AsmHdrExistsForFromDocLine := RetrieveSalesInvLine(FromSalesLine2, BufferCount, LineCountsEqual);
InitAsmCopyHandling(true);
if AsmHdrExistsForFromDocLine then begin
AsmHdrExistsForFromDocLine := GetAsmDataFromSalesInvLine(ToSalesHeader."Document Type");
if AsmHdrExistsForFromDocLine then begin
QtyToAsmToOrder := TempSalesInvLine.Quantity;
QtyToAsmToOrderBase := TempSalesInvLine.Quantity * TempSalesInvLine."Qty. per Unit of Measure";
end;
end;
end;
local procedure HandleZeroAmountPostedInvoices(var FromSalesInvHeader: Record "Sales Invoice Header"; var ToSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From"; FromDocNo: Code[20])
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeHandleZeroAmountPostedInvoices(FromSalesInvHeader, ToSalesHeader, FromDocType, FromDocNo, IsHandled);
if IsHandled then
exit;
// Apply credit memo to invoice in case of Sales Invoices with total amount 0
FromSalesInvHeader.CalcFields(Amount);
if (ToSalesHeader."Applies-to Doc. Type" = ToSalesHeader."Applies-to Doc. Type"::" ") and (ToSalesHeader."Applies-to Doc. No." = '') and
(FromDocType = "Sales Document Type From"::"Posted Invoice") and (FromSalesInvHeader.Amount = 0) and
(ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::"Credit Memo")
then begin
ToSalesHeader."Applies-to Doc. Type" := ToSalesHeader."Applies-to Doc. Type"::Invoice;
ToSalesHeader."Applies-to Doc. No." := FromDocNo;
end;
end;
local procedure HandleZeroAmountPostedPurchaseInvoices(var FromPurchInvHeader: Record "Purch. Inv. Header"; var ToPurchaseHeader: Record "Purchase Header"; FromDocType: Enum "Purchase Document Type From"; FromDocNo: Code[20])
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeHandleZeroAmountPostedPurchaseInvoices(FromPurchInvHeader, ToPurchaseHeader, FromDocType, FromDocNo, IsHandled);
if IsHandled then
exit;
// Apply credit memo to invoice in case of Purchase Invoices with total amount 0
FromPurchInvHeader.CalcFields(Amount);
if (ToPurchaseHeader."Applies-to Doc. Type" = ToPurchaseHeader."Applies-to Doc. Type"::" ") and (ToPurchaseHeader."Applies-to Doc. No." = '') and
(FromDocType = "Purchase Document Type From"::"Posted Invoice") and (FromPurchInvHeader.Amount = 0) and
(ToPurchaseHeader."Document Type" = ToPurchaseHeader."Document Type"::"Credit Memo")
then begin
ToPurchaseHeader."Applies-to Doc. Type" := ToPurchaseHeader."Applies-to Doc. Type"::Invoice;
ToPurchaseHeader."Applies-to Doc. No." := FromDocNo;
end;
end;
procedure CopyPurchaseDocForInvoiceCancelling(FromDocNo: Code[20]; var ToPurchaseHeader: Record "Purchase Header")
begin
SkipWarningNotification := true;
OnBeforeCopyPurchaseDocForInvoiceCancelling(ToPurchaseHeader, FromDocNo);
CopyPurchDoc("Purchase Document Type From"::"Posted Invoice", FromDocNo, ToPurchaseHeader);
end;
procedure CopyPurchDocForCrMemoCancelling(FromDocNo: Code[20]; var ToPurchaseHeader: Record "Purchase Header")
begin
SkipWarningNotification := true;
InsertCancellationLine := true;
OnBeforeCopyPurchaseDocForCrMemoCancelling(ToPurchaseHeader, FromDocNo);
CopyPurchDoc("Sales Document Type From"::"Posted Credit Memo", FromDocNo, ToPurchaseHeader);
InsertCancellationLine := false;
end;
procedure CopyPurchDoc(FromDocType: Enum "Purchase Document Type From"; FromDocNo: Code[20]; var ToPurchHeader: Record "Purchase Header")
begin
CopyPurchDoc(FromDocType, FromDocNo, ToPurchHeader, false);
end;
procedure CopyPurchDoc(FromDocType: Enum "Purchase Document Type From"; FromDocNo: Code[20]; var ToPurchHeader: Record "Purchase Header"; ClearOriginalDocNo: Boolean)
var
ToPurchLine: Record "Purchase Line";
FromPurchHeader: Record "Purchase Header";
FromPurchRcptHeader: Record "Purch. Rcpt. Header";
FromPurchInvHeader: Record "Purch. Inv. Header";
FromReturnShptHeader: Record "Return Shipment Header";
FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.";
FromPurchHeaderArchive: Record "Purchase Header Archive";
ReleasePurchaseDocument: Codeunit "Release Purchase Document";
ConfirmManagement: Codeunit "Confirm Management";
ErrorContextElement: Codeunit "Error Context Element";
ErrorMessageHandler: Codeunit "Error Message Handler";
NextLineNo: Integer;
LinesNotCopied: Integer;
MissingExCostRevLink: Boolean;
ReleaseDocument: Boolean;
IsHandled: Boolean;
DoExit: Boolean;
begin
if not CreateToHeader then begin
ToPurchHeader.TestField(Status, ToPurchHeader.Status::Open);
if FromDocNo = '' then
Error(Text000);
ToPurchHeader.Find();
end;
IsHandled := false;
OnBeforeCopyPurchaseDocument(FromDocType.AsInteger(), FromDocNo, ToPurchHeader, IsHandled);
if IsHandled then
exit;
TransferOldExtLines.ClearLineNumbers();
if not InitAndCheckPurchaseDocuments(
FromDocType.AsInteger(), FromDocNo, FromPurchHeader, ToPurchHeader,
FromPurchRcptHeader, FromPurchInvHeader, FromReturnShptHeader, FromPurchCrMemoHeader,
FromPurchHeaderArchive)
then
exit;
ToPurchLine.LockTable();
IsHandled := false;
OnCopyPurchDocOnBeforeCreateOrIncludeHeader(ToPurchHeader, ToPurchLine, CreateToHeader, IncludeHeader, DoExit, IsHandled);
if IsHandled then
if DoExit then
exit;
if not IsHandled then
if CreateToHeader then begin
OnCopyPurchDocOnBeforeToPurchHeaderInsert(ToPurchHeader, FromPurchHeader, MoveNegLines);
ToPurchHeader.Insert(true);
ToPurchLine.SetRange("Document Type", ToPurchHeader."Document Type");
ToPurchLine.SetRange("Document No.", ToPurchHeader."No.");
end else begin
ToPurchLine.SetRange("Document Type", ToPurchHeader."Document Type");
ToPurchLine.SetRange("Document No.", ToPurchHeader."No.");
if IncludeHeader then
if ToPurchLine.FindFirst() then begin
Commit();
if not ConfirmManagement.GetResponseOrDefault(
StrSubstNo(DeleteLinesQst, ToPurchHeader."Document Type", ToPurchHeader."No."), true)
then
exit;
ToPurchLine.DeleteAll(true);
end;
end;
if ToPurchLine.FindLast() then
NextLineNo := ToPurchLine."Line No."
else
NextLineNo := 0;
if IncludeHeader then
CopyPurchDocUpdateHeader(
FromDocType, FromDocNo, ToPurchHeader, FromPurchHeader,
FromPurchRcptHeader, FromPurchInvHeader, FromReturnShptHeader, FromPurchCrMemoHeader, FromPurchHeaderArchive, ReleaseDocument, ClearOriginalDocNo)
else
OnCopyPurchDocWithoutHeader(ToPurchHeader, FromDocType.AsInteger(), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo, FromPurchInvHeader, FromPurchCrMemoHeader);
LinesNotCopied := 0;
ErrorMessageMgt.Activate(ErrorMessageHandler);
ErrorMessageMgt.PushContext(ErrorContextElement, ToPurchHeader.RecordId, 0, StrSubstNo(PurchErrorContextMsg, FromDocNo));
case FromDocType of
"Purchase Document Type From"::Quote,
"Purchase Document Type From"::"Blanket Order",
"Purchase Document Type From"::Order,
"Purchase Document Type From"::Invoice,
"Purchase Document Type From"::"Return Order",
"Purchase Document Type From"::"Credit Memo":
CopyPurchDocPurchLine(FromPurchHeader, ToPurchHeader, LinesNotCopied, NextLineNo);
"Purchase Document Type From"::"Posted Receipt":
begin
FromPurchHeader.TransferFields(FromPurchRcptHeader);
OnCopyPurchDocOnBeforeCopyPurchDocRcptLine(FromPurchRcptHeader, ToPurchHeader);
CopyPurchDocRcptLine(FromPurchRcptHeader, ToPurchHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Purchase Document Type From"::"Posted Invoice":
begin
FromPurchHeader.TransferFields(FromPurchInvHeader);
OnCopyPurchDocOnBeforeCopyPurchDocInvLine(FromPurchInvHeader, ToPurchHeader);
CopyPurchDocInvLine(FromPurchInvHeader, ToPurchHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Purchase Document Type From"::"Posted Return Shipment":
begin
FromPurchHeader.TransferFields(FromReturnShptHeader);
OnCopyPurchDocOnBeforeCopyPurchDocReturnShptLine(FromReturnShptHeader, ToPurchHeader);
CopyPurchDocReturnShptLine(FromReturnShptHeader, ToPurchHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Purchase Document Type From"::"Posted Credit Memo":
begin
FromPurchHeader.TransferFields(FromPurchCrMemoHeader);
OnCopyPurchDocOnBeforeCopyPurchDocCrMemoLine(FromPurchCrMemoHeader, ToPurchHeader);
CopyPurchDocCrMemoLine(FromPurchCrMemoHeader, ToPurchHeader, LinesNotCopied, MissingExCostRevLink);
end;
"Purchase Document Type From"::"Arch. Order",
"Purchase Document Type From"::"Arch. Quote",
"Purchase Document Type From"::"Arch. Blanket Order",
"Purchase Document Type From"::"Arch. Return Order":
CopyPurchDocPurchLineArchive(FromPurchHeaderArchive, ToPurchHeader, LinesNotCopied, NextLineNo);
end;
OnCopyPurchDocOnBeforeUpdatePurchInvoiceDiscountValue(
ToPurchHeader, FromDocType.AsInteger(), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo, RecalculateLines, FromPurchHeader, LinesNotCopied, NextLineNo, MissingExCostRevLink);
UpdatePurchaseInvoiceDiscountValue(ToPurchHeader);
if MoveNegLines then
DeletePurchLinesWithNegQty(FromPurchHeader, false);
IsHandled := false;
OnCopyPurchDocOnAfterCopyPurchDocLines(FromDocType.AsInteger(), FromDocNo, FromPurchHeader, IncludeHeader, ToPurchHeader, MoveNegLines, ReleaseDocument, IsHandled);
if not IsHandled then
if ReleaseDocument then begin
ToPurchHeader.Status := ToPurchHeader.Status::Released;
ReleasePurchaseDocument.Reopen(ToPurchHeader);
end else
if (FromDocType in
["Purchase Document Type From"::Quote,
"Purchase Document Type From"::"Blanket Order",
"Purchase Document Type From"::Order,
"Purchase Document Type From"::Invoice,
"Purchase Document Type From"::"Return Order",
"Purchase Document Type From"::"Credit Memo"])
and not IncludeHeader and not RecalculateLines
then
if FromPurchHeader.Status = FromPurchHeader.Status::Released then begin
ReleasePurchaseDocument.SetSkipCheckReleaseRestrictions();
ReleasePurchaseDocument.Run(ToPurchHeader);
ReleasePurchaseDocument.Reopen(ToPurchHeader);
end;
if ShowWarningNotification(ToPurchHeader, MissingExCostRevLink) then begin
ErrorMessageHandler.NotifyAboutErrors();
ErrorMessageMgt.PopContext(ErrorContextElement);
end;
ToPurchLine.GetCaptionClass(ToPurchHeader.FieldNo("Prices Including VAT"));
OnAfterCopyPurchaseDocument(
FromDocType.AsInteger(), FromDocNo, ToPurchHeader, FromDocOccurrenceNo, FromDocVersionNo, IncludeHeader, RecalculateLines, MoveNegLines);
end;
procedure CopyPurchDocPurchLine(FromPurchHeader: Record "Purchase Header"; ToPurchHeader: Record "Purchase Header"; var LinesNotCopied: Integer; NextLineNo: Integer)
var
ToPurchLine: Record "Purchase Line";
FromPurchLine: Record "Purchase Line";
ItemChargeAssgntNextLineNo: Integer;
begin
ItemChargeAssgntNextLineNo := 0;
FromPurchLine.Reset();
FromPurchLine.SetRange("Document Type", FromPurchHeader."Document Type");
FromPurchLine.SetRange("Document No.", FromPurchHeader."No.");
if MoveNegLines then
FromPurchLine.SetFilter(Quantity, '<=0');
OnCopyPurchDocPurchLineOnAfterSetFilters(FromPurchHeader, FromPurchLine, ToPurchHeader, RecalculateLines);
if FromPurchLine.Find('-') then
repeat
if not ExtTxtAttachedToPosPurchLine(FromPurchHeader, FromPurchLine) then
if CopyPurchDocLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, NextLineNo, LinesNotCopied, false,
ConvertToPurchaseDocumentTypeFrom(FromPurchHeader."Document Type"),
CopyPostedDeferral, FromPurchLine."Line No.")
then begin
if FromPurchLine.Type = FromPurchLine.Type::"Charge (Item)" then
CopyFromPurchDocAssgntToLine(
ToPurchLine, FromPurchLine."Document Type", FromPurchLine."Document No.", FromPurchLine."Line No.",
ItemChargeAssgntNextLineNo);
OnCopyPurchDocPurchLineOnAfterCopyPurchLine(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, IncludeHeader, RecalculateLines);
end;
OnCopyPurchDocPurchLineOnAfterProcessFromPurchLineInLoop(ToPurchHeader, ToPurchLine, FromPurchLine, RecalculateLines);
until FromPurchLine.Next() = 0;
end;
local procedure CopyPurchDocRcptLine(FromPurchRcptHeader: Record "Purch. Rcpt. Header"; ToPurchHeader: Record "Purchase Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromPurchRcptLine: Record "Purch. Rcpt. Line";
begin
FromPurchRcptLine.Reset();
FromPurchRcptLine.SetRange("Document No.", FromPurchRcptHeader."No.");
if MoveNegLines then
FromPurchRcptLine.SetFilter(Quantity, '<=0');
OnCopyPurchDocRcptLineOnAfterSetFilters(ToPurchHeader, FromPurchRcptHeader, FromPurchRcptLine, RecalculateLines);
CopyPurchRcptLinesToDoc(ToPurchHeader, FromPurchRcptLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CopyPurchDocInvLine(FromPurchInvHeader: Record "Purch. Inv. Header"; ToPurchHeader: Record "Purchase Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromPurchInvLine: Record "Purch. Inv. Line";
begin
FromPurchInvLine.Reset();
FromPurchInvLine.SetRange("Document No.", FromPurchInvHeader."No.");
if MoveNegLines then
FromPurchInvLine.SetFilter(Quantity, '<=0');
OnCopyPurchDocInvLineOnAfterSetFilters(ToPurchHeader, FromPurchInvLine, LinesNotCopied, MissingExCostRevLink, RecalculateLines);
CopyPurchInvLinesToDoc(ToPurchHeader, FromPurchInvLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CopyPurchDocCrMemoLine(FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; ToPurchHeader: Record "Purchase Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromPurchCrMemoLine: Record "Purch. Cr. Memo Line";
begin
FromPurchCrMemoLine.Reset();
FromPurchCrMemoLine.SetRange("Document No.", FromPurchCrMemoHeader."No.");
if MoveNegLines then
FromPurchCrMemoLine.SetFilter(Quantity, '<=0');
OnCopyPurchDocCrMemoLineOnAfterSetFilters(ToPurchHeader, FromPurchCrMemoLine, LinesNotCopied, MissingExCostRevLink, RecalculateLines);
CopyPurchCrMemoLinesToDoc(ToPurchHeader, FromPurchCrMemoLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CopyPurchDocReturnShptLine(FromReturnShptHeader: Record "Return Shipment Header"; ToPurchHeader: Record "Purchase Header"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
FromReturnShptLine: Record "Return Shipment Line";
begin
FromReturnShptLine.Reset();
FromReturnShptLine.SetRange("Document No.", FromReturnShptHeader."No.");
if MoveNegLines then
FromReturnShptLine.SetFilter(Quantity, '<=0');
OnCopyPurchDocReturnShptLineOnAfterSetFilters(ToPurchHeader, FromReturnShptLine, LinesNotCopied, MissingExCostRevLink);
CopyPurchReturnShptLinesToDoc(ToPurchHeader, FromReturnShptLine, LinesNotCopied, MissingExCostRevLink);
end;
procedure CopyPurchDocPurchLineArchive(FromPurchHeaderArchive: Record "Purchase Header Archive"; var ToPurchHeader: Record "Purchase Header"; var LinesNotCopied: Integer; NextLineNo: Integer)
var
ToPurchLine: Record "Purchase Line";
FromPurchLineArchive: Record "Purchase Line Archive";
ItemChargeAssgntNextLineNo: Integer;
begin
ItemChargeAssgntNextLineNo := 0;
FromPurchLineArchive.Reset();
FromPurchLineArchive.SetRange("Document Type", FromPurchHeaderArchive."Document Type");
FromPurchLineArchive.SetRange("Document No.", FromPurchHeaderArchive."No.");
FromPurchLineArchive.SetRange("Doc. No. Occurrence", FromPurchHeaderArchive."Doc. No. Occurrence");
FromPurchLineArchive.SetRange("Version No.", FromPurchHeaderArchive."Version No.");
if MoveNegLines then
FromPurchLineArchive.SetFilter(Quantity, '<=0');
OnCopyPurchDocPurchLineArchiveOnAfterSetFilters(ToPurchHeader, ToPurchLine, FromPurchHeaderArchive, FromPurchLineArchive, NextLineNo, LinesNotCopied);
if FromPurchLineArchive.Find('-') then
repeat
if CopyArchPurchLine(
ToPurchHeader, ToPurchLine, FromPurchHeaderArchive, FromPurchLineArchive, NextLineNo, LinesNotCopied, false)
then begin
CopyFromArchPurchDocDimToLine(ToPurchLine, FromPurchLineArchive);
if FromPurchLineArchive.Type = FromPurchLineArchive.Type::"Charge (Item)" then
CopyFromPurchDocAssgntToLine(
ToPurchLine, FromPurchLineArchive."Document Type", FromPurchLineArchive."Document No.", FromPurchLineArchive."Line No.",
ItemChargeAssgntNextLineNo);
OnAfterCopyArchPurchLine(ToPurchHeader, ToPurchLine, FromPurchLineArchive, IncludeHeader, RecalculateLines);
end;
until FromPurchLineArchive.Next() = 0;
end;
local procedure CopyPurchDocUpdateHeader(FromDocType: Enum "Purchase Document Type From"; FromDocNo: Code[20]; var ToPurchHeader: Record "Purchase Header"; FromPurchHeader: Record "Purchase Header"; FromPurchRcptHeader: Record "Purch. Rcpt. Header"; FromPurchInvHeader: Record "Purch. Inv. Header"; FromReturnShptHeader: Record "Return Shipment Header"; FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; FromPurchHeaderArchive: Record "Purchase Header Archive"; var ReleaseDocument: Boolean; ClearOriginalDocNosOnTarget: Boolean)
var
BuyFromVendor: Record Vendor;
PayToVendor: Record Vendor;
OldPurchHeader: Record "Purchase Header";
SavedDimSetId: Integer;
begin
if BuyFromVendor.Get(FromPurchHeader."Buy-from Vendor No.") then
BuyFromVendor.CheckBlockedVendOnDocs(BuyFromVendor, false);
if PayToVendor.Get(FromPurchHeader."Pay-to Vendor No.") then
PayToVendor.CheckBlockedVendOnDocs(PayToVendor, false);
OldPurchHeader := ToPurchHeader;
OnBeforeCopyPurchHeaderDone(ToPurchHeader, FromPurchHeader, FromDocType, OldPurchHeader, FromPurchRcptHeader, FromPurchInvHeader, FromReturnShptHeader, FromPurchCrMemoHeader, FromPurchHeaderArchive, BuyFromVendor, PayToVendor);
case FromDocType of
"Purchase Document Type From"::Quote,
"Purchase Document Type From"::"Blanket Order",
"Purchase Document Type From"::Order,
"Purchase Document Type From"::Invoice,
"Purchase Document Type From"::"Return Order",
"Purchase Document Type From"::"Credit Memo":
CopyPurchHeaderFromPurchHeader(FromDocType, FromPurchHeader, OldPurchHeader, ToPurchHeader);
"Purchase Document Type From"::"Posted Receipt":
CopyPurchHeaderFromPostedReceipt(FromPurchRcptHeader, ToPurchHeader, OldPurchHeader);
"Purchase Document Type From"::"Posted Invoice":
CopyPurchHeaderFromPostedInvoice(FromPurchInvHeader, ToPurchHeader, OldPurchHeader);
"Purchase Document Type From"::"Posted Return Shipment":
CopyPurchHeaderFromPostedReturnShipment(FromReturnShptHeader, ToPurchHeader, OldPurchHeader);
"Purchase Document Type From"::"Posted Credit Memo":
CopyPurchHeaderFromPostedCreditMemo(FromPurchCrMemoHeader, ToPurchHeader, OldPurchHeader);
"Purchase Document Type From"::"Arch. Order",
"Purchase Document Type From"::"Arch. Quote",
"Purchase Document Type From"::"Arch. Blanket Order",
"Purchase Document Type From"::"Arch. Return Order":
CopyPurchHeaderFromPurchHeaderArchive(FromPurchHeaderArchive, ToPurchHeader, OldPurchHeader);
end;
OnAfterCopyPurchHeaderDone(
ToPurchHeader, OldPurchHeader, FromPurchHeader, FromPurchRcptHeader, FromPurchInvHeader,
FromReturnShptHeader, FromPurchCrMemoHeader, FromPurchHeaderArchive);
ToPurchHeader.Invoice := false;
ToPurchHeader.Receive := false;
if ToPurchHeader.Status = ToPurchHeader.Status::Released then begin
ToPurchHeader.Status := ToPurchHeader.Status::Open;
ReleaseDocument := true;
end;
if MoveNegLines or IncludeHeader then begin
SavedDimSetId := ToPurchHeader."Dimension Set ID";
ToPurchHeader.Validate(ToPurchHeader."Location Code");
ToPurchHeader.Validate(ToPurchHeader."Dimension Set ID", SavedDimSetId);
CopyShippingInfoPurchOrder(ToPurchHeader, FromPurchHeader);
end;
if MoveNegLines then
ToPurchHeader.Validate(ToPurchHeader."Order Address Code");
CopyFieldsFromOldPurchHeader(ToPurchHeader, OldPurchHeader);
OnAfterCopyFieldsFromOldPurchHeader(ToPurchHeader, OldPurchHeader, MoveNegLines, IncludeHeader);
if RecalculateLines then begin
if IncludeHeader then
SavedDimSetId := ToPurchHeader."Dimension Set ID";
ToPurchHeader.CreateDimFromDefaultDim(0);
if IncludeHeader then
ToPurchHeader.Validate("Dimension Set ID", SavedDimSetId);
end;
ToPurchHeader."No. Printed" := 0;
ToPurchHeader."Applies-to Doc. Type" := ToPurchHeader."Applies-to Doc. Type"::" ";
ToPurchHeader."Applies-to Doc. No." := '';
ToPurchHeader."Applies-to ID" := '';
ToPurchHeader."Quote No." := '';
if ClearOriginalDocNosOnTarget then
ClearOriginalDocumentNos(ToPurchHeader);
OnCopyPurchDocUpdateHeaderOnBeforeUpdateVendLedgerEntry(ToPurchHeader, FromDocType.AsInteger(), FromDocNo);
if ((FromDocType = "Purchase Document Type From"::"Posted Invoice") and
(ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::"Return Order", ToPurchHeader."Document Type"::"Credit Memo"])) or
((FromDocType = "Purchase Document Type From"::"Posted Credit Memo") and
not (ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::"Return Order", ToPurchHeader."Document Type"::"Credit Memo"]))
then
UpdateVendLedgEntry(ToPurchHeader, FromDocType, FromDocNo);
HandleZeroAmountPostedPurchaseInvoices(FromPurchInvHeader, ToPurchHeader, FromDocType, FromDocNo);
if ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::"Blanket Order", ToPurchHeader."Document Type"::Quote] then
ToPurchHeader."Posting Date" := 0D;
ToPurchHeader.Correction := false;
if ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::"Return Order", ToPurchHeader."Document Type"::"Credit Memo"] then
UpdatePurchCreditMemoHeader(ToPurchHeader);
GLSetup.Get();
if GLSetup."Journal Templ. Name Mandatory" then
if ToPurchHeader.IsCreditDocType() <> IsCreditPurchFromDocType(FromDocType) then
ToPurchHeader."Journal Templ. Name" := OldPurchHeader."Journal Templ. Name";
OnBeforeModifyPurchHeader(ToPurchHeader, FromDocType.AsInteger(), FromDocNo, IncludeHeader, FromDocOccurrenceNo, FromDocVersionNo, RecalculateLines,
FromPurchHeader, FromPurchInvHeader, FromPurchCrMemoHeader, OldPurchHeader);
if CreateToHeader then begin
ToPurchHeader.Validate(ToPurchHeader."Payment Terms Code");
ToPurchHeader.Modify(true);
end else
ToPurchHeader.Modify();
OnCopyPurchDocWithHeader(FromDocType.AsInteger(), FromDocNo, ToPurchHeader, FromDocOccurrenceNo, FromDocVersionNo);
end;
local procedure IsCreditPurchFromDocType(FromDocType: Enum "Purchase Document Type From"): Boolean
begin
exit(FromDocType in ["Purchase Document Type From"::"Return Order", "Purchase Document Type From"::"Credit Memo"]);
end;
local procedure CopyPurchHeaderFromPurchHeader(FromDocType: Enum "Purchase Document Type From"; FromPurchHeader: Record "Purchase Header"; OldPurchHeader: Record "Purchase Header"; var ToPurchHeader: Record "Purchase Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyPurchHeaderFromPurchHeader(FromDocType, FromPurchHeader, OldPurchHeader, ToPurchHeader, IsHandled);
if IsHandled then
exit;
ToPurchHeader.TransferFields(FromPurchHeader, false);
UpdatePurchHeaderWhenCopyFromPurchHeader(ToPurchHeader, OldPurchHeader, FromDocType);
OnAfterCopyPurchaseHeader(ToPurchHeader, OldPurchHeader, FromPurchHeader);
end;
local procedure CopyPurchHeaderFromPostedReceipt(FromPurchRcptHeader: Record "Purch. Rcpt. Header"; var ToPurchHeader: Record "Purchase Header"; var OldPurchHeader: Record "Purchase Header")
begin
ToPurchHeader.Validate("Buy-from Vendor No.", FromPurchRcptHeader."Buy-from Vendor No.");
OnCopyPurchHeaderFromPostedReceiptOnBeforeTransferFields(ToPurchHeader, OldPurchHeader, FromPurchRcptHeader);
ToPurchHeader.TransferFields(FromPurchRcptHeader, false);
OnAfterCopyPostedReceipt(ToPurchHeader, OldPurchHeader, FromPurchRcptHeader);
end;
local procedure CopyPurchHeaderFromPostedInvoice(FromPurchInvHeader: Record "Purch. Inv. Header"; var ToPurchHeader: Record "Purchase Header"; var OldPurchHeader: Record "Purchase Header")
var
PurchasesPayablesSetup: Record "Purchases & Payables Setup";
begin
PurchasesPayablesSetup.Get();
ToPurchHeader.Validate("Buy-from Vendor No.", FromPurchInvHeader."Buy-from Vendor No.");
if PurchasesPayablesSetup.ShouldDocumentTotalAmountsBeChecked(ToPurchHeader) then begin
FromPurchInvHeader.CalcFields("Amount Including VAT", Amount);
ToPurchHeader.Validate("Doc. Amount Incl. VAT", FromPurchInvHeader."Amount Including VAT");
ToPurchHeader.Validate("Doc. Amount VAT", FromPurchInvHeader."Amount Including VAT" - FromPurchInvHeader.Amount);
end;
OnCopyPurchHeaderFromPostedInvoiceOnBeforeTransferFields(ToPurchHeader, OldPurchHeader, FromPurchInvHeader);
ToPurchHeader.TransferFields(FromPurchInvHeader, false);
OnAfterCopyPostedPurchInvoice(ToPurchHeader, OldPurchHeader, FromPurchInvHeader);
end;
local procedure CopyPurchHeaderFromPostedReturnShipment(FromReturnShptHeader: Record "Return Shipment Header"; var ToPurchHeader: Record "Purchase Header"; var OldPurchHeader: Record "Purchase Header")
begin
ToPurchHeader.Validate("Buy-from Vendor No.", FromReturnShptHeader."Buy-from Vendor No.");
OnCopyPurchHeaderFromPostedReturnShipmentOnBeforeTransferFields(ToPurchHeader, OldPurchHeader, FromReturnShptHeader);
ToPurchHeader.TransferFields(FromReturnShptHeader, false);
OnAfterCopyPostedReturnShipment(ToPurchHeader, OldPurchHeader, FromReturnShptHeader);
end;
local procedure CopyPurchHeaderFromPostedCreditMemo(FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; var ToPurchHeader: Record "Purchase Header"; var OldPurchHeader: Record "Purchase Header")
begin
ToPurchHeader.Validate("Buy-from Vendor No.", FromPurchCrMemoHeader."Buy-from Vendor No.");
OnCopyPurchHeaderFromPostedCreditMemoOnBeforeTransferFields(ToPurchHeader, OldPurchHeader, FromPurchCrMemoHeader);
ToPurchHeader.TransferFields(FromPurchCrMemoHeader, false);
OnAfterCopyPurchHeaderFromPostedCreditMemo(ToPurchHeader, OldPurchHeader, FromPurchCrMemoHeader);
end;
local procedure CopyPurchHeaderFromPurchHeaderArchive(FromPurchHeaderArchive: Record "Purchase Header Archive"; var ToPurchHeader: Record "Purchase Header"; var OldPurchHeader: Record "Purchase Header")
begin
ToPurchHeader.Validate("Buy-from Vendor No.", FromPurchHeaderArchive."Buy-from Vendor No.");
ToPurchHeader.TransferFields(FromPurchHeaderArchive, false);
UpdatePurchHeaderWhenCopyFromPurchHeaderArchive(ToPurchHeader);
CopyFromArchPurchDocDimToHdr(ToPurchHeader, FromPurchHeaderArchive);
OnAfterCopyPurchHeaderArchive(ToPurchHeader, OldPurchHeader, FromPurchHeaderArchive)
end;
procedure ShowSalesDoc(ToSalesHeader: Record "Sales Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeShowSalesDoc(ToSalesHeader, IsHandled);
if IsHandled then
exit;
case ToSalesHeader."Document Type" of
ToSalesHeader."Document Type"::Order:
PAGE.Run(PAGE::"Sales Order", ToSalesHeader);
ToSalesHeader."Document Type"::Invoice:
PAGE.Run(PAGE::"Sales Invoice", ToSalesHeader);
ToSalesHeader."Document Type"::"Return Order":
PAGE.Run(PAGE::"Sales Return Order", ToSalesHeader);
ToSalesHeader."Document Type"::"Credit Memo":
PAGE.Run(PAGE::"Sales Credit Memo", ToSalesHeader);
end;
end;
procedure ShowPurchDoc(ToPurchHeader: Record "Purchase Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeShowPurchDoc(ToPurchHeader, IsHandled);
if IsHandled then
exit;
case ToPurchHeader."Document Type" of
ToPurchHeader."Document Type"::Order:
PAGE.Run(PAGE::"Purchase Order", ToPurchHeader);
ToPurchHeader."Document Type"::Invoice:
PAGE.Run(PAGE::"Purchase Invoice", ToPurchHeader);
ToPurchHeader."Document Type"::"Return Order":
PAGE.Run(PAGE::"Purchase Return Order", ToPurchHeader);
ToPurchHeader."Document Type"::"Credit Memo":
PAGE.Run(PAGE::"Purchase Credit Memo", ToPurchHeader);
end;
end;
local procedure ShowWarningNotification(SourceVariant: Variant; MissingExCostRevLink: Boolean): Boolean
var
TempErrorMessage: Record "Error Message" temporary;
begin
if MissingExCostRevLink then
ErrorMessageMgt.LogWarning(0, Text019, SourceVariant, 0, '');
if ErrorMessageMgt.GetErrors(TempErrorMessage) then begin
TempErrorMessage.SetRange("Message Type", TempErrorMessage."Message Type"::Error);
if TempErrorMessage.FindFirst() then begin
if SkipWarningNotification then
Error(TempErrorMessage."Message");
exit(true);
end;
exit(not SkipWarningNotification);
end;
end;
procedure CopyFromSalesToPurchDoc(VendorNo: Code[20]; FromSalesHeader: Record "Sales Header"; var ToPurchHeader: Record "Purchase Header")
var
FromSalesLine: Record "Sales Line";
ToPurchLine: Record "Purchase Line";
NextLineNo: Integer;
ShouldCopyItemTracking: Boolean;
begin
if VendorNo = '' then
Error(Text011);
ToPurchLine.LockTable();
OnCopyFromSalesToPurchDocOnBeforePurchaseHeaderInsert(ToPurchHeader, FromSalesHeader, VendorNo);
ToPurchHeader.Insert(true);
ToPurchHeader.Validate("Buy-from Vendor No.", VendorNo);
OnCopyFromSalesToPurchDocOnBeforeToPurchHeaderModify(ToPurchHeader, FromSalesHeader);
ToPurchHeader.Modify(true);
FromSalesLine.SetRange("Document Type", FromSalesHeader."Document Type");
FromSalesLine.SetRange("Document No.", FromSalesHeader."No.");
OnCopyFromSalesToPurchDocOnAfterSetFilters(FromSalesLine, FromSalesHeader);
if not FromSalesLine.Find('-') then
Error(Text012);
repeat
NextLineNo := NextLineNo + 10000;
Clear(ToPurchLine);
ToPurchLine.Init();
ToPurchLine."Document Type" := ToPurchHeader."Document Type";
ToPurchLine."Document No." := ToPurchHeader."No.";
ToPurchLine."Line No." := NextLineNo;
if FromSalesLine.Type = FromSalesLine.Type::" " then
ToPurchLine.Description := FromSalesLine.Description
else
TransfldsFromSalesToPurchLine(FromSalesLine, ToPurchLine);
OnBeforeCopySalesToPurchDoc(ToPurchLine, FromSalesLine);
ToPurchLine.Insert(true);
ShouldCopyItemTracking := (FromSalesLine.Type <> FromSalesLine.Type::" ") and (ToPurchLine.Type = ToPurchLine.Type::Item) and (ToPurchLine.Quantity <> 0);
OnCopyFromSalesToPurchDocOnAfterCalcShouldCopyItemTracking(ToPurchLine, ShouldCopyItemTracking);
if ShouldCopyItemTracking then
CopyItemTrackingEntries(
FromSalesLine, ToPurchLine, FromSalesHeader."Prices Including VAT",
ToPurchHeader."Prices Including VAT");
OnAfterCopySalesToPurchDoc(ToPurchLine, FromSalesLine);
until FromSalesLine.Next() = 0;
OnAfterCopyFromSalesToPurchDoc(FromSalesHeader, ToPurchHeader);
end;
procedure TransfldsFromSalesToPurchLine(var FromSalesLine: Record "Sales Line"; var ToPurchLine: Record "Purchase Line")
var
DimMgt: Codeunit DimensionManagement;
DimensionSetIDArr: array[10] of Integer;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeTransfldsFromSalesToPurchLine(FromSalesLine, ToPurchLine, IsHandled);
if IsHandled then
exit;
ToPurchLine.Validate(ToPurchLine.Type, FromSalesLine.Type);
ToPurchLine.Validate(ToPurchLine."No.", FromSalesLine."No.");
ToPurchLine.Validate(ToPurchLine."Variant Code", FromSalesLine."Variant Code");
ToPurchLine.Validate(ToPurchLine."Location Code", FromSalesLine."Location Code");
ToPurchLine.Validate(ToPurchLine."Unit of Measure Code", FromSalesLine."Unit of Measure Code");
if (ToPurchLine.Type = ToPurchLine.Type::Item) and (ToPurchLine."No." <> '') then
ToPurchLine.UpdateUOMQtyPerStockQty();
ToPurchLine."Expected Receipt Date" := FromSalesLine."Shipment Date";
ToPurchLine."Bin Code" := FromSalesLine."Bin Code";
OnTransfldsFromSalesToPurchLineOnBeforeValidateQuantity(FromSalesLine, ToPurchLine);
if (FromSalesLine."Document Type" = FromSalesLine."Document Type"::"Return Order") and
(ToPurchLine."Document Type" = ToPurchLine."Document Type"::"Return Order")
then
ToPurchLine.Validate(ToPurchLine.Quantity, FromSalesLine.Quantity)
else
ToPurchLine.Validate(ToPurchLine.Quantity, FromSalesLine."Outstanding Quantity");
ToPurchLine.Validate(ToPurchLine."Return Reason Code", FromSalesLine."Return Reason Code");
ToPurchLine.Validate(ToPurchLine."Direct Unit Cost");
AssignDescriptionsFromSalesLine(ToPurchLine, FromSalesLine);
if ToPurchLine."Dimension Set ID" <> FromSalesLine."Dimension Set ID" then begin
DimensionSetIDArr[1] := ToPurchLine."Dimension Set ID";
DimensionSetIDArr[2] := FromSalesLine."Dimension Set ID";
ToPurchLine."Dimension Set ID" :=
DimMgt.GetCombinedDimensionSetID(DimensionSetIDArr, ToPurchLine."Shortcut Dimension 1 Code", ToPurchLine."Shortcut Dimension 2 Code");
end;
OnAfterTransfldsFromSalesToPurchLine(FromSalesLine, ToPurchLine);
end;
local procedure AssignDescriptionsFromSalesLine(var PurchaseLine: Record "Purchase Line"; SalesLine: Record "Sales Line")
begin
OnBeforeAssignDescriptionsFromSalesLine(PurchaseLine, SalesLine);
PurchaseLine.Description := SalesLine.Description;
PurchaseLine."Description 2" := SalesLine."Description 2";
end;
local procedure DeleteSalesLinesWithNegQty(FromSalesHeader: Record "Sales Header"; OnlyTest: Boolean)
var
FromSalesLine: Record "Sales Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeDeleteSalesLinesWithNegQty(FromSalesHeader, OnlyTest, IsHandled);
if IsHandled then
exit;
FromSalesLine.SetRange("Document Type", FromSalesHeader."Document Type");
FromSalesLine.SetRange("Document No.", FromSalesHeader."No.");
FromSalesLine.SetFilter(FromSalesLine.Quantity, '<0');
OnDeleteSalesLinesWithNegQtyOnAfterSetFilters(FromSalesLine, OnlyTest);
if OnlyTest then begin
if not FromSalesLine.Find('-') then
Error(Text008);
repeat
FromSalesLine.TestField("Shipment No.", '');
FromSalesLine.TestField("Return Receipt No.", '');
FromSalesLine.TestField("Quantity Shipped", 0);
FromSalesLine.TestField("Quantity Invoiced", 0);
until FromSalesLine.Next() = 0;
end else
FromSalesLine.DeleteAll(true);
OnAfterDeleteSalesLinesWithNegQty(FromSalesLine, OnlyTest);
end;
local procedure DeletePurchLinesWithNegQty(FromPurchHeader: Record "Purchase Header"; OnlyTest: Boolean)
var
FromPurchLine: Record "Purchase Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeDeletePurchLinesWithNegQty(FromPurchHeader, OnlyTest, IsHandled);
if IsHandled then
exit;
FromPurchLine.SetRange("Document Type", FromPurchHeader."Document Type");
FromPurchLine.SetRange("Document No.", FromPurchHeader."No.");
FromPurchLine.SetFilter(Quantity, '<0');
if OnlyTest then begin
if not FromPurchLine.Find('-') then
Error(Text010);
repeat
FromPurchLine.TestField("Receipt No.", '');
FromPurchLine.TestField("Return Shipment No.", '');
FromPurchLine.TestField("Quantity Received", 0);
FromPurchLine.TestField("Quantity Invoiced", 0);
until FromPurchLine.Next() = 0;
end else
FromPurchLine.DeleteAll(true);
end;
procedure CopySalesDocLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var NextLineNo: Integer; var LinesNotCopied: Integer; RecalculateAmount: Boolean; FromSalesDocType: Enum "Sales Document Type From"; var CopyPostedDeferral: Boolean; DocLineNo: Integer) Result: Boolean
var
RoundingLineInserted: Boolean;
CopyThisLine: Boolean;
InvDiscountAmount: Decimal;
IsHandled: Boolean;
ShouldValidateQuantityMoveNegLines: Boolean;
ShouldInitToSalesLine: Boolean;
begin
CopyThisLine := true;
IsHandled := false;
OnBeforeCopySalesLine(ToSalesHeader, FromSalesHeader, FromSalesLine, RecalculateLines, CopyThisLine, MoveNegLines, Result, IsHandled, DocLineNo);
if IsHandled then
exit(Result);
if not CopyThisLine then begin
LinesNotCopied := LinesNotCopied + 1;
exit(false);
end;
CheckSalesRounding(FromSalesLine, RoundingLineInserted);
CopyThisLine := not (((ToSalesHeader."Language Code" <> FromSalesHeader."Language Code") or RecalculateLines) and
FromSalesLine.IsExtendedText() or
FromSalesLine."Prepayment Line" or RoundingLineInserted);
OnCopySalesDocLineOnAfterCalcCopyThisLine(ToSalesHeader, FromSalesHeader, FromSalesLine, RoundingLineInserted, CopyThisLine, RecalculateLines);
if not CopyThisLine then
exit(false);
if IsEntityBlocked(Database::"Sales Line", ToSalesHeader.IsCreditDocType(), FromSalesLine.Type.AsInteger(), FromSalesLine."No.", FromSalesLine."Variant Code") then begin
LinesNotCopied := LinesNotCopied + 1;
exit(false);
end;
OnCopySalesDocLineOnBeforeSetSalesHeader(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, NextLineNo);
ToSalesLine.SetSalesHeader(ToSalesHeader);
ShouldInitToSalesLine := RecalculateLines and not FromSalesLine."System-Created Entry";
OnCopySalesDocLineOnBeforeInitToSalesLine(ToSalesLine, FromSalesLine, ShouldInitToSalesLine);
if ShouldInitToSalesLine then begin
ToSalesLine.Init();
OnAfterInitToSalesLine(ToSalesLine);
end else begin
ToSalesLine := FromSalesLine;
ToSalesLine."Returns Deferral Start Date" := 0D;
OnCopySalesLineOnAfterTransferFieldsToSalesLine(ToSalesLine, FromSalesLine);
if ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Quote, ToSalesHeader."Document Type"::"Blanket Order"] then
ToSalesLine."Deferral Code" := '';
if MoveNegLines and (ToSalesLine.Type <> ToSalesLine.Type::" ") then begin
ToSalesLine.Amount := -ToSalesLine.Amount;
ToSalesLine."Amount Including VAT" := -ToSalesLine."Amount Including VAT";
end
end;
NextLineNo := NextLineNo + 10000;
ToSalesLine."Document Type" := ToSalesHeader."Document Type";
ToSalesLine."Document No." := ToSalesHeader."No.";
ToSalesLine."Line No." := NextLineNo;
if ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Quote then
ToSalesLine."Promised Delivery Date" := 0D;
if not IncludeHeader then
CheckSalesVATBusPostingGroup(ToSalesHeader, ToSalesLine);
ToSalesLine."Copied From Posted Doc." := FromSalesLine."Copied From Posted Doc.";
OnCopySalesDocLineOnAfterAssignCopiedFromPostedDoc(ToSalesLine, ToSalesHeader);
if (ToSalesLine.Type <> ToSalesLine.Type::" ") and
(ToSalesLine."Document Type" in [ToSalesLine."Document Type"::"Return Order", ToSalesLine."Document Type"::"Credit Memo"])
then begin
ToSalesLine."Job Contract Entry No." := 0;
if (ToSalesLine.Amount = 0) or
(ToSalesHeader."Prices Including VAT" <> FromSalesHeader."Prices Including VAT") or
(ToSalesHeader."Currency Factor" <> FromSalesHeader."Currency Factor")
then begin
InvDiscountAmount := ToSalesLine."Inv. Discount Amount";
IsHandled := false;
OnCopySalesDocLineOnBeforeValidateLineDiscountPct(ToSalesLine, IsHandled);
if not IsHandled then
ToSalesLine.Validate("Line Discount %");
IsHandled := false;
OnCopySalesDocLineOnBeforeValidateInvDiscountAmount(ToSalesLine, InvDiscountAmount, IsHandled);
if not IsHandled then
ToSalesLine.Validate("Inv. Discount Amount", InvDiscountAmount);
end;
end;
ToSalesLine.Validate("Currency Code", FromSalesHeader."Currency Code");
UpdateSalesLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine,
CopyThisLine, RecalculateAmount, FromSalesDocType, CopyPostedDeferral);
IsHandled := false;
OnCopySalesDocLineOnBeforeCheckLocationOnWMS(ToSalesHeader, ToSalesLine, FromSalesLine, IsHandled, IncludeHeader, RecalculateLines);
if not IsHandled then
ToSalesLine.CheckLocationOnWMS();
RecalculateAndApplySalesLine(ToSalesHeader, ToSalesLine, FromSalesLine, RecalculateAmount);
ShouldValidateQuantityMoveNegLines := MoveNegLines and (ToSalesLine.Type <> ToSalesLine.Type::" ");
OnCopySalesDocLineOnAfterCalcShouldValidateQuantityMoveNegLines(ToSalesLine, FromSalesLine, ShouldValidateQuantityMoveNegLines);
if ShouldValidateQuantityMoveNegLines then begin
ToSalesLine.Validate(Quantity, -FromSalesLine.Quantity);
OnCopySalesDocLineOnAfterValidateQuantityMoveNegLines(ToSalesLine, FromSalesLine);
ToSalesLine.Validate("Unit Price", FromSalesLine."Unit Price");
ToSalesLine.Validate("Line Discount %", FromSalesLine."Line Discount %");
ToSalesLine."Appl.-to Item Entry" := FromSalesLine."Appl.-to Item Entry";
ToSalesLine."Appl.-from Item Entry" := FromSalesLine."Appl.-from Item Entry";
ToSalesLine."Job No." := FromSalesLine."Job No.";
ToSalesLine."Job Task No." := FromSalesLine."Job Task No.";
ToSalesLine."Job Contract Entry No." := FromSalesLine."Job Contract Entry No.";
OnCopySalesDocLineOnAfterMoveNegLines(ToSalesLine, FromSalesLine);
end;
OnCopySalesDocLineOnBeforeCopySalesJobFields(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, FromSalesDocType);
if CopyJobData then
CopySalesJobFields(ToSalesLine, ToSalesHeader, FromSalesLine);
CopySalesLineExtText(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, DocLineNo, NextLineNo);
if not RecalculateLines then begin
ToSalesLine."Dimension Set ID" := FromSalesLine."Dimension Set ID";
ToSalesLine."Shortcut Dimension 1 Code" := FromSalesLine."Shortcut Dimension 1 Code";
ToSalesLine."Shortcut Dimension 2 Code" := FromSalesLine."Shortcut Dimension 2 Code";
OnCopySalesLineOnAfterSetDimensions(ToSalesLine, FromSalesLine);
end;
IsHandled := false;
OnCopySalesDocLineOnBeforeCopyThisLine(ToSalesHeader, ToSalesLine, FromSalesLine, FromSalesDocType, RecalculateLines, CopyThisLine, LinesNotCopied, Result, IsHandled, NextLineNo, DocLineNo, MoveNegLines);
if IsHandled then
exit(Result);
if CopyThisLine then begin
IsHandled := false;
OnBeforeInsertToSalesLine(
ToSalesLine, FromSalesLine, FromSalesDocType.AsInteger(), RecalculateLines, ToSalesHeader, DocLineNo, NextLineNo, RecalculateAmount, IsHandled);
if not IsHandled then
ToSalesLine.Insert();
OnCopySalesDocLineOnAfterInsertToSalesLine(ToSalesLine, FromSalesLine, FromSalesDocType, MoveNegLines);
HandleAsmAttachedToSalesLine(ToSalesLine);
IsHandled := false;
OnCopySalesDocLineOnBeforeAutoReserve(ToSalesHeader, ToSalesLine, IsHandled);
if not IsHandled then
if ToSalesLine.Reserve = ToSalesLine.Reserve::Always then
ToSalesLine.AutoReserve();
OnAfterInsertToSalesLine(ToSalesLine, FromSalesLine, RecalculateLines, DocLineNo, FromSalesDocType, FromSalesHeader, NextLineNo, ToSalesHeader);
end else
LinesNotCopied := LinesNotCopied + 1;
exit(CopyThisLine);
end;
local procedure RecalculateAndApplySalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; var RecalculateAmount: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeRecalculateAndApplySalesLine(ToSalesHeader, ToSalesLine, FromSalesLine, Currency, ExactCostRevMandatory, RecalculateAmount, CreateToHeader, MoveNegLines, IsHandled);
if IsHandled then
exit;
if ExactCostRevMandatory and
(FromSalesLine.Type = FromSalesLine.Type::Item) and
(FromSalesLine."Appl.-from Item Entry" <> 0) and
not MoveNegLines
then begin
if RecalculateAmount then
RecalculateSalesLineAmounts(FromSalesLine, ToSalesLine);
ToSalesLine.Validate("Appl.-from Item Entry", FromSalesLine."Appl.-from Item Entry");
if not CreateToHeader then
if ToSalesLine."Shipment Date" = 0D then
InitShipmentDateInLine(ToSalesHeader, ToSalesLine);
end;
end;
local procedure RecalculateSalesLineAmounts(FromSalesLine: Record "Sales Line"; var ToSalesLine: Record "Sales Line")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeRecalculateSalesLineAmounts(FromSalesLine, ToSalesLine, Currency, IsHandled);
if IsHandled then
exit;
ToSalesLine.Validate("Unit Price", FromSalesLine."Unit Price");
ToSalesLine.Validate("Line Discount %", FromSalesLine."Line Discount %");
ToSalesLine.Validate(
"Line Discount Amount",
Round(FromSalesLine."Line Discount Amount", Currency."Amount Rounding Precision"));
ToSalesLine.Validate(
"Inv. Discount Amount",
Round(FromSalesLine."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
procedure UpdateSalesHeaderWhenCopyFromSalesHeader(var SalesHeader: Record "Sales Header"; OriginalSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdateSalesHeaderWhenCopyFromSalesHeader(SalesHeader, OriginalSalesHeader, FromDocType, IsHandled);
if IsHandled then
exit;
ClearSalesLastNoSFields(SalesHeader);
SalesHeader.Status := SalesHeader.Status::Open;
if SalesHeader."Document Type" <> SalesHeader."Document Type"::Order then
SalesHeader."Prepayment %" := 0;
if FromDocType = "Sales Document Type From"::"Return Order" then begin
SalesHeader.CopySellToAddressToShipToAddress();
OnUpdateSalesHeaderWhenCopyFromSalesHeaderOnBeforeValidateShipToCode(SalesHeader);
SalesHeader.Validate(SalesHeader."Ship-to Code");
end;
if FromDocType in ["Sales Document Type From"::Quote, "Sales Document Type From"::"Blanket Order"] then
if OriginalSalesHeader."Posting Date" = 0D then
SalesHeader."Posting Date" := WorkDate()
else
SalesHeader."Posting Date" := OriginalSalesHeader."Posting Date";
end;
local procedure UpdateSalesHeaderWhenCopyFromSalesHeaderArchive(var SalesHeader: Record "Sales Header")
begin
ClearSalesLastNoSFields(SalesHeader);
SalesHeader.Status := SalesHeader.Status::Open;
end;
procedure ClearSalesLastNoSFields(var SalesHeader: Record "Sales Header")
begin
SalesHeader."Last Shipping No." := '';
SalesHeader."Last Posting No." := '';
SalesHeader."Last Prepayment No." := '';
SalesHeader."Last Prepmt. Cr. Memo No." := '';
SalesHeader."Last Return Receipt No." := '';
end;
local procedure UpdateSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var CopyThisLine: Boolean; RecalculateAmount: Boolean; FromSalesDocType: Enum "Sales Document Type From"; var DoCopyPostedDeferral: Boolean)
var
SalesItem: Record Item;
VATPostingSetup: Record "VAT Posting Setup";
FromSalesCommentDocTypeInt: Integer;
ShouldGetUnitCost: Boolean;
IsHandled: Boolean;
ShouldRecalculateSalesLine: Boolean;
begin
OnBeforeUpdateSalesLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine,
CopyThisLine, RecalculateAmount, FromSalesDocType.AsInteger(), DoCopyPostedDeferral);
FromSalesCommentDocTypeInt := DeferralTypeForSalesDoc(FromSalesDocType.AsInteger());
DoCopyPostedDeferral := false;
ShouldRecalculateSalesLine := RecalculateLines and not FromSalesLine."System-Created Entry";
OnUpdateSalesLineOnBeforeValidateToSalesLine(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, ShouldRecalculateSalesLine);
if ShouldRecalculateSalesLine then begin
OnUpdateSalesLineOnBeforeRecalculateSalesLine(ToSalesLine, FromSalesLine);
RecalculateSalesLine(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, CopyThisLine);
if IsDeferralToBeCopied(
"Deferral Document Type"::Sales, ToSalesLine."Document Type".AsInteger(), FromSalesCommentDocTypeInt)
then
ToSalesLine.Validate("Deferral Code", FromSalesLine."Deferral Code");
OnUpdateSalesLineOnAfterRecalculateSalesLine(ToSalesLine, FromSalesLine);
end else begin
SetDefaultValuesToSalesLine(ToSalesLine, ToSalesHeader, FromSalesLine);
if IsDeferralToBeCopied(
"Deferral Document Type"::Sales, ToSalesLine."Document Type".AsInteger(), FromSalesCommentDocTypeInt)
then
if IsDeferralPosted("Deferral Document Type"::Sales, FromSalesCommentDocTypeInt) then
DoCopyPostedDeferral := true
else
ToSalesLine."Returns Deferral Start Date" :=
CopyDeferrals("Deferral Document Type"::Sales, FromSalesLine."Document Type".AsInteger(), FromSalesLine."Document No.",
FromSalesLine."Line No.", ToSalesLine."Document Type".AsInteger(), ToSalesLine."Document No.", ToSalesLine."Line No.")
else
if IsDeferralToBeDefaulted("Deferral Document Type"::Sales, ToSalesLine."Document Type".AsInteger(), FromSalesCommentDocTypeInt) then
InitSalesDeferralCode(ToSalesLine);
OnUpdateSalesLineOnBeforeClearDropShipmentAndSpecialOrder(ToSalesLine, FromSalesLine);
if not (ToSalesLine."Document Type" in ["Sales Document Type"::Order, "Sales Document Type"::Quote, "Sales Document Type"::"Blanket Order"]) then begin
ToSalesLine."Drop Shipment" := false;
ToSalesLine."Special Order" := false;
end else
if FromSalesLine."Purchasing Code" <> '' then
ToSalesLine.Validate("Purchasing Code", FromSalesLine."Purchasing Code");
OnUpdateSalesLineBeforeRecalculateAmount(ToSalesLine, FromSalesLine);
if RecalculateAmount and (FromSalesLine."Appl.-from Item Entry" = 0) then begin
if (ToSalesLine.Type <> ToSalesLine.Type::" ") and (ToSalesLine."No." <> '') then begin
ToSalesLine.Validate("Line Discount %", FromSalesLine."Line Discount %");
ToSalesLine.Validate(
"Inv. Discount Amount", Round(FromSalesLine."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
IsHandled := false;
OnUpdateSalesLineOnBeforeToSalesLineValidateUnitCostLcy(ToSalesLine, FromSalesLine, IsHandled);
if not IsHandled then
ToSalesLine.Validate("Unit Cost (LCY)", FromSalesLine."Unit Cost (LCY)");
end;
if VATPostingSetup.Get(ToSalesLine."VAT Bus. Posting Group", ToSalesLine."VAT Prod. Posting Group") then begin
ToSalesLine."VAT Identifier" := VATPostingSetup."VAT Identifier";
ToSalesLine."VAT Clause Code" := VATPostingSetup."VAT Clause Code";
end;
ToSalesLine.UpdateWithWarehouseShip();
if (ToSalesLine.Type = ToSalesLine.Type::Item) and (ToSalesLine."No." <> '') then begin
SalesItem.Get(ToSalesLine."No.");
ShouldGetUnitCost := (SalesItem."Costing Method" = SalesItem."Costing Method"::Standard) and not ToSalesLine.IsShipment() and not IsCreatedFromJob(FromSalesLine);
OnUpdateSalesLineOnAfterCalcShouldGetUnitCost(SalesItem, ShouldGetUnitCost);
if ShouldGetUnitCost then
ToSalesLine.GetUnitCost();
if SalesItem.Reserve = SalesItem.Reserve::Optional then
ToSalesLine.Reserve := ToSalesHeader.Reserve
else
ToSalesLine.Reserve := SalesItem.Reserve;
OnUpdateSalesLineOnAfterSetReserve(ToSalesLine, FromSalesLine, FromSalesDocType);
if ToSalesLine.Reserve = ToSalesLine.Reserve::Always then
InitShipmentDateInLine(ToSalesHeader, ToSalesLine);
end;
OnUpdateSalesLineOnAfterUpdateWithWarehouseShip(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine);
end;
OnAfterUpdateSalesLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine,
CopyThisLine, RecalculateAmount, FromSalesDocType.AsInteger(), DoCopyPostedDeferral,
ExactCostRevMandatory, MoveNegLines, RecalculateLines);
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 RecalculateSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var CopyThisLine: Boolean)
var
GLAcc: Record "G/L Account";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeRecalculateSalesLine(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, CopyThisLine, IsHandled);
if not IsHandled then begin
ToSalesLine.Validate(Type, FromSalesLine.Type);
ToSalesLine.Description := FromSalesLine.Description;
ToSalesLine.Validate("Description 2", FromSalesLine."Description 2");
if FromSalesLine.Type = FromSalesLine.Type::Item then
ToSalesLine.ExcludeDefaultItemQuantity(true);
OnUpdateSalesLine(ToSalesLine, FromSalesLine);
if (FromSalesLine.Type <> FromSalesLine.Type::" ") and (FromSalesLine."No." <> '') then begin
if ToSalesLine.Type = ToSalesLine.Type::"G/L Account" then begin
ToSalesLine."No." := FromSalesLine."No.";
GLAcc.Get(FromSalesLine."No.");
CopyThisLine := GLAcc."Direct Posting";
OnRecalculateSalesLineOnBeforeCopyThisLine(ToSalesLine, FromSalesLine);
if CopyThisLine then
ToSalesLine.Validate("No.", FromSalesLine."No.");
end else
ToSalesLine.Validate("No.", FromSalesLine."No.");
if FromSalesLine.Type = FromSalesLine.Type::Item then
ToSalesLine.ExcludeDefaultItemQuantity(false);
OnRecalculateSalesLineOnAfterValidateNo(ToSalesLine, FromSalesLine);
ToSalesLine.Validate("Variant Code", FromSalesLine."Variant Code");
IsHandled := false;
OnRecalculateSalesLineOnBeforeValidateLocationCode(ToSalesLine, IsHandled);
if not IsHandled then
ToSalesLine.Validate("Location Code", FromSalesLine."Location Code");
ToSalesLine.Validate("Unit of Measure", FromSalesLine."Unit of Measure");
ToSalesLine.Validate("Unit of Measure Code", FromSalesLine."Unit of Measure Code");
ToSalesLine.Validate(Quantity, FromSalesLine.Quantity);
OnRecalculateSalesLineOnAfterValidateQuantity(ToSalesLine, FromSalesLine);
if not (FromSalesLine.Type in [FromSalesLine.Type::Item, FromSalesLine.Type::Resource]) then begin
if (FromSalesHeader."Currency Code" <> ToSalesHeader."Currency Code") or
(FromSalesHeader."Prices Including VAT" <> ToSalesHeader."Prices Including VAT")
then begin
ToSalesLine."Unit Price" := 0;
ToSalesLine."Line Discount %" := 0;
end else begin
ToSalesLine.Validate("Unit Price", FromSalesLine."Unit Price");
ToSalesLine.Validate("Line Discount %", FromSalesLine."Line Discount %");
end;
if ToSalesLine.Quantity <> 0 then
ToSalesLine.Validate("Line Discount Amount", FromSalesLine."Line Discount Amount");
OnRecalculateSalesLineOnAfterValidateLineDiscountAmount(ToSalesLine, FromSalesLine);
end;
OnRecalculateSalesLineOnBeforeValidateWorkTypeCode(ToSalesLine, FromSalesLine);
ToSalesLine.Validate("Work Type Code", FromSalesLine."Work Type Code");
if (ToSalesLine."Document Type" in [ToSalesLine."Document Type"::Order, ToSalesLine."Document Type"::Quote, ToSalesLine."Document Type"::"Blanket Order"]) and
(FromSalesLine."Purchasing Code" <> '')
then
ToSalesLine.Validate("Purchasing Code", FromSalesLine."Purchasing Code");
end;
if (FromSalesLine.Type = FromSalesLine.Type::" ") and (FromSalesLine."No." <> '') then
ToSalesLine.Validate("No.", FromSalesLine."No.");
end;
OnAfterRecalculateSalesLine(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, CopyThisLine);
end;
procedure HandleAsmAttachedToSalesLine(var ToSalesLine: Record "Sales Line")
var
AssemblyItem: Record Item;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeHandleAsmAttachedToSalesLine(ToSalesLine, IsHandled);
if IsHandled then
exit;
if ToSalesLine.Type <> ToSalesLine.Type::Item then
exit;
if not (ToSalesLine."Document Type" in [ToSalesLine."Document Type"::Quote, ToSalesLine."Document Type"::Order, ToSalesLine."Document Type"::"Blanket Order"]) then
exit;
if AsmHdrExistsForFromDocLine then begin
ToSalesLine."Qty. to Assemble to Order" := QtyToAsmToOrder;
ToSalesLine."Qty. to Asm. to Order (Base)" := QtyToAsmToOrderBase;
ToSalesLine.Modify();
CopyAsmOrderToAsmOrder(
TempAsmHeader, TempAsmLine, ToSalesLine, GetAsmOrderType(ToSalesLine."Document Type"), '', true);
end else begin
AssemblyItem.Get(ToSalesLine."No.");
if (AssemblyItem."Assembly Policy" = AssemblyItem."Assembly Policy"::"Assemble-to-Order") and
AssemblyItem.IsAssemblyItem() and ToSalesLine.IsAsmToOrderAllowed()
then begin
ToSalesLine.Validate("Qty. to Assemble to Order", ToSalesLine.Quantity);
ToSalesLine.Modify();
end;
end;
OnAfterHandleAsmAttachedToSalesLine(ToSalesLine);
end;
procedure CopyPurchDocLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var NextLineNo: Integer; var LinesNotCopied: Integer; RecalculateAmount: Boolean; FromPurchDocType: Enum "Purchase Document Type From"; var CopyPostedDeferral: Boolean; DocLineNo: Integer) Result: Boolean
var
RoundingLineInserted: Boolean;
CopyThisLine: Boolean;
ShouldRevertQuantitySign: Boolean;
IsHandled: Boolean;
begin
CopyThisLine := true;
IsHandled := false;
OnBeforeCopyPurchLine(
ToPurchHeader, FromPurchHeader, FromPurchLine, RecalculateLines, CopyThisLine, ToPurchLine, MoveNegLines,
RoundingLineInserted, Result, IsHandled, FromPurchDocType, DocLineNo, RecalculateLines, LinesNotCopied, CopyPostedDeferral, NextLineNo);
if IsHandled then
exit(Result);
if not CopyThisLine then begin
LinesNotCopied := LinesNotCopied + 1;
exit(false);
end;
CheckPurchRounding(FromPurchLine, RoundingLineInserted);
if ((ToPurchHeader."Language Code" <> FromPurchHeader."Language Code") or RecalculateLines) and
FromPurchLine.IsExtendedText() or
FromPurchLine."Prepayment Line" or RoundingLineInserted
then
exit(false);
if IsEntityBlocked(Database::"Purchase Line", ToPurchHeader.IsCreditDocType(), FromPurchLine.Type.AsInteger(), FromPurchLine."No.", FromPurchLine."Variant Code") then begin
LinesNotCopied := LinesNotCopied + 1;
exit(false);
end;
OnCopyPurchDocLineOnBeforeRecalculateLines(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, NextLineNo);
if RecalculateLines and not FromPurchLine."System-Created Entry" then begin
ToPurchLine.Init();
OnAfterInitToPurchLine(ToPurchLine);
end else begin
ToPurchLine := FromPurchLine;
ToPurchLine."Returns Deferral Start Date" := 0D;
if ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::Quote, ToPurchHeader."Document Type"::"Blanket Order"] then
ToPurchLine."Deferral Code" := '';
if MoveNegLines and (ToPurchLine.Type <> ToPurchLine.Type::" ") then begin
ToPurchLine.Amount := -ToPurchLine.Amount;
ToPurchLine."Amount Including VAT" := -ToPurchLine."Amount Including VAT";
end
end;
NextLineNo := NextLineNo + 10000;
OnCopyPurchDocLineOnAfterSetNextLineNo(ToPurchLine, FromPurchLine, NextLineNo);
ToPurchLine."Document Type" := ToPurchHeader."Document Type";
ToPurchLine."Document No." := ToPurchHeader."No.";
ToPurchLine."Line No." := NextLineNo;
if not IncludeHeader then
CheckPurchVATBusPostingGroup(ToPurchHeader, ToPurchLine);
ToPurchLine."Copied From Posted Doc." := FromPurchLine."Copied From Posted Doc.";
ToPurchLine.Validate("Currency Code", FromPurchHeader."Currency Code");
ValidatePurchLineDiscountFields(FromPurchHeader, ToPurchHeader, ToPurchLine);
UpdatePurchLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine,
CopyThisLine, RecalculateAmount, FromPurchDocType, CopyPostedDeferral);
IsHandled := false;
OnCopyPurchDocLineOnBeforeCheckLocationOnWMS(ToPurchHeader, ToPurchLine, FromPurchLine, IsHandled);
if not IsHandled then
ToPurchLine.CheckLocationOnWMS();
RecalculateAndApplyPurchLine(ToPurchHeader, ToPurchLine, FromPurchLine, RecalculateAmount);
ShouldRevertQuantitySign := MoveNegLines and (ToPurchLine.Type <> ToPurchLine.Type::" ");
OnCopyPurchLineOnBeforeValidateQuantity(ToPurchLine, RecalculateLines, FromPurchLine, MoveNegLines, ShouldRevertQuantitySign);
if ShouldRevertQuantitySign then begin
ToPurchLine.Validate(Quantity, -FromPurchLine.Quantity);
OnCopyPurchLineOnAfterValidateQuantityMoveNegLines(ToPurchLine, FromPurchLine);
ToPurchLine."Appl.-to Item Entry" := FromPurchLine."Appl.-to Item Entry"
end;
CopyPurchLineExtText(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, DocLineNo, NextLineNo);
if FromPurchLine."Job No." <> '' then
CopyPurchaseJobFields(ToPurchLine, FromPurchLine);
if not RecalculateLines then begin
ToPurchLine."Dimension Set ID" := FromPurchLine."Dimension Set ID";
ToPurchLine."Shortcut Dimension 1 Code" := FromPurchLine."Shortcut Dimension 1 Code";
ToPurchLine."Shortcut Dimension 2 Code" := FromPurchLine."Shortcut Dimension 2 Code";
OnCopyPurchLineOnAfterSetDimensions(ToPurchLine, FromPurchLine);
end;
IsHandled := false;
OnCopyPurchDocLineOnBeforeCopyThisLine(ToPurchLine, FromPurchLine, MoveNegLines, FromPurchDocType, LinesNotCopied, CopyThisLine, Result, IsHandled, ToPurchHeader, RecalculateLines, NextLineNo);
if IsHandled then
exit(Result);
if CopyThisLine then begin
OnBeforeInsertToPurchLine(
ToPurchLine, FromPurchLine, FromPurchDocType.AsInteger(), RecalculateLines, ToPurchHeader, DocLineNo, NextLineNo);
ToPurchLine.Insert();
OnAfterInsertToPurchLine(ToPurchLine, FromPurchLine, RecalculateLines, DocLineNo, FromPurchDocType, ToPurchHeader, MoveNegLines, FromPurchHeader);
end else
LinesNotCopied := LinesNotCopied + 1;
exit(CopyThisLine);
end;
local procedure RecalculateAndApplyPurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line"; RecalculateAmount: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeRecalculateAndApplyPurchLine(ToPurchHeader, ToPurchLine, FromPurchLine, Currency, RecalculateAmount, ExactCostRevMandatory, CreateToHeader, MoveNegLines, IsHandled);
if IsHandled then
exit;
if ExactCostRevMandatory and
(FromPurchLine.Type = FromPurchLine.Type::Item) and
(FromPurchLine."Appl.-to Item Entry" <> 0) and
not MoveNegLines
then begin
if RecalculateAmount then begin
ToPurchLine.Validate("Direct Unit Cost", FromPurchLine."Direct Unit Cost");
ToPurchLine.Validate("Line Discount %", FromPurchLine."Line Discount %");
ToPurchLine.Validate(
"Line Discount Amount",
Round(FromPurchLine."Line Discount Amount", Currency."Amount Rounding Precision"));
ToPurchLine.Validate(
"Inv. Discount Amount",
Round(FromPurchLine."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
ToPurchLine.Validate("Appl.-to Item Entry", FromPurchLine."Appl.-to Item Entry");
if not CreateToHeader then
if ToPurchLine."Expected Receipt Date" = 0D then
if ToPurchHeader."Expected Receipt Date" <> 0D then
ToPurchLine."Expected Receipt Date" := ToPurchHeader."Expected Receipt Date"
else
ToPurchLine."Expected Receipt Date" := WorkDate();
end;
end;
local procedure ValidatePurchLineDiscountFields(FromPurchHeader: Record "Purchase Header"; ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line")
var
InvDiscountAmount: Decimal;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeValidatePurchLineDiscountFields(FromPurchHeader, ToPurchHeader, ToPurchLine, InvDiscountAmount, IsHandled, RecalculateLines);
if IsHandled then
exit;
if (ToPurchLine.Type <> ToPurchLine.Type::" ") and
((ToPurchLine.Amount = 0) or
(ToPurchHeader."Prices Including VAT" <> FromPurchHeader."Prices Including VAT") or
(ToPurchHeader."Currency Factor" <> FromPurchHeader."Currency Factor"))
then begin
InvDiscountAmount := ToPurchLine."Inv. Discount Amount";
ToPurchLine.Validate("Line Discount %");
ToPurchLine.Validate("Inv. Discount Amount", InvDiscountAmount);
end;
end;
procedure UpdatePurchHeaderWhenCopyFromPurchHeader(var PurchaseHeader: Record "Purchase Header"; OriginalPurchaseHeader: Record "Purchase Header"; FromDocType: Enum "Purchase Document Type From")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdatePurchHeaderWhenCopyFromPurchHeader(PurchaseHeader, OriginalPurchaseHeader, FromDocType, IsHandled);
if IsHandled then
exit;
ClearPurchLastNoSFields(PurchaseHeader);
PurchaseHeader.Receive := false;
PurchaseHeader.Status := PurchaseHeader.Status::Open;
PurchaseHeader."IC Status" := PurchaseHeader."IC Status"::New;
if PurchaseHeader."Document Type" <> PurchaseHeader."Document Type"::Order then
PurchaseHeader."Prepayment %" := 0;
if FromDocType in ["Purchase Document Type From"::Quote, "Purchase Document Type From"::"Blanket Order"] then
if OriginalPurchaseHeader."Posting Date" = 0D then
PurchaseHeader."Posting Date" := WorkDate()
else
PurchaseHeader."Posting Date" := OriginalPurchaseHeader."Posting Date";
end;
local procedure UpdatePurchHeaderWhenCopyFromPurchHeaderArchive(var PurchaseHeader: Record "Purchase Header")
begin
ClearPurchLastNoSFields(PurchaseHeader);
PurchaseHeader.Status := PurchaseHeader.Status::Open;
end;
procedure ClearPurchLastNoSFields(var PurchaseHeader: Record "Purchase Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeClearPurchLastNoSFields(PurchaseHeader, IsHandled);
if IsHandled then
exit;
PurchaseHeader."Last Receiving No." := '';
PurchaseHeader."Last Posting No." := '';
PurchaseHeader."Last Prepayment No." := '';
PurchaseHeader."Last Prepmt. Cr. Memo No." := '';
PurchaseHeader."Last Return Shipment No." := '';
end;
local procedure UpdatePurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean; RecalculateAmount: Boolean; FromPurchDocType: Enum "Purchase Document Type From"; var DoCopyPostedDeferral: Boolean)
var
VATPostingSetup: Record "VAT Posting Setup";
FromPurchCommentDocTypeInt: Integer;
begin
OnBeforeUpdatePurchLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine,
CopyThisLine, RecalculateAmount, FromPurchDocType.AsInteger(), DoCopyPostedDeferral);
FromPurchCommentDocTypeInt := DeferralTypeForPurchDoc(FromPurchDocType.AsInteger());
DoCopyPostedDeferral := false;
if RecalculateLines and not FromPurchLine."System-Created Entry" then begin
RecalculatePurchLine(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, CopyThisLine);
if IsDeferralToBeCopied("Deferral Document Type"::Purchase, ToPurchLine."Document Type".AsInteger(), FromPurchCommentDocTypeInt) then
ToPurchLine.Validate("Deferral Code", FromPurchLine."Deferral Code");
end else begin
SetDefaultValuesToPurchLine(ToPurchLine, ToPurchHeader, FromPurchLine."VAT Difference", FromPurchLine."Non-Deductible VAT Diff.");
if IsDeferralToBeCopied("Deferral Document Type"::Purchase, ToPurchLine."Document Type".AsInteger(), FromPurchCommentDocTypeInt) then
if IsDeferralPosted("Deferral Document Type"::Purchase, FromPurchCommentDocTypeInt) then
DoCopyPostedDeferral := true
else
ToPurchLine."Returns Deferral Start Date" :=
CopyDeferrals("Deferral Document Type"::Purchase, FromPurchLine."Document Type".AsInteger(), FromPurchLine."Document No.",
FromPurchLine."Line No.", ToPurchLine."Document Type".AsInteger(), ToPurchLine."Document No.", ToPurchLine."Line No.")
else
if IsDeferralToBeDefaulted("Deferral Document Type"::Purchase, ToPurchLine."Document Type".AsInteger(), FromPurchCommentDocTypeInt) then
InitPurchDeferralCode(ToPurchLine);
if FromPurchLine."Drop Shipment" or FromPurchLine."Special Order" then
ToPurchLine."Purchasing Code" := '';
ToPurchLine."Drop Shipment" := false;
ToPurchLine."Special Order" := false;
if VATPostingSetup.Get(ToPurchLine."VAT Bus. Posting Group", ToPurchLine."VAT Prod. Posting Group") then
ToPurchLine."VAT Identifier" := VATPostingSetup."VAT Identifier";
OnBeforeCopyPurchLines(ToPurchLine);
CopyDocLines(RecalculateAmount, ToPurchLine, FromPurchLine);
ToPurchLine.UpdateWithWarehouseReceive();
ToPurchLine."Pay-to Vendor No." := ToPurchHeader."Pay-to Vendor No.";
OnUpdatePurchLineOnAfterCopyDocLine(ToPurchLine, FromPurchLine);
end;
ToPurchLine.Validate("Order No.", FromPurchLine."Order No.");
ToPurchLine.Validate("Order Line No.", FromPurchLine."Order Line No.");
OnAfterUpdatePurchLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine,
CopyThisLine, RecalculateAmount, FromPurchDocType.AsInteger(), DoCopyPostedDeferral, RecalculateLines);
end;
local procedure RecalculatePurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean)
var
GLAcc: Record "G/L Account";
IsHandled: Boolean;
begin
OnBeforeRecalculatePurchLine(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, CopyThisLine);
ToPurchLine.Validate(Type, FromPurchLine.Type);
ToPurchLine.Description := FromPurchLine.Description;
ToPurchLine.Validate("Description 2", FromPurchLine."Description 2");
OnUpdatePurchLine(ToPurchLine, FromPurchLine);
if (FromPurchLine.Type <> FromPurchLine.Type::" ") and (FromPurchLine."No." <> '') then begin
if ToPurchLine.Type = ToPurchLine.Type::"G/L Account" then begin
ToPurchLine."No." := FromPurchLine."No.";
GLAcc.Get(FromPurchLine."No.");
CopyThisLine := GLAcc."Direct Posting";
OnRecalculatePurchLineOnAfterCopyThisLine(ToPurchLine, FromPurchLine);
if CopyThisLine then
ToPurchLine.Validate("No.", FromPurchLine."No.");
end else
ToPurchLine.Validate("No.", FromPurchLine."No.");
OnRecalculatePurchLineOnAfterValidateNo(ToPurchLine, FromPurchLine);
ToPurchLine.Validate("Variant Code", FromPurchLine."Variant Code");
IsHandled := false;
OnRecalculatePurchLineOnBeforeValidateLocationCode(ToPurchLine, IsHandled);
if not IsHandled then
ToPurchLine.Validate("Location Code", FromPurchLine."Location Code");
ToPurchLine.Validate("Unit of Measure", FromPurchLine."Unit of Measure");
ToPurchLine.Validate("Unit of Measure Code", FromPurchLine."Unit of Measure Code");
ToPurchLine.Validate(Quantity, FromPurchLine.Quantity);
OnRecalculatePurchLineOnAfterValidateQuantity(ToPurchLine, FromPurchLine);
if not (FromPurchLine.Type in [FromPurchLine.Type::Item, FromPurchLine.Type::Resource]) then begin
ToPurchHeader.TestField("Currency Code", FromPurchHeader."Currency Code");
ToPurchLine.Validate("Direct Unit Cost", FromPurchLine."Direct Unit Cost");
ToPurchLine.Validate("Line Discount %", FromPurchLine."Line Discount %");
if ToPurchLine.Quantity <> 0 then
ToPurchLine.Validate("Line Discount Amount", FromPurchLine."Line Discount Amount");
end;
IsHandled := false;
OnRecalculatePurchLineOnBeforeValidatePurchasingCode(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, CopyThisLine, IsHandled);
if not IsHandled then
if (ToPurchLine."Document Type" = ToPurchLine."Document Type"::Order) and
(FromPurchLine."Purchasing Code" <> '') and not FromPurchLine."Drop Shipment" and not FromPurchLine."Special Order"
then
ToPurchLine.Validate("Purchasing Code", FromPurchLine."Purchasing Code");
OnRecalculatePurchLineOnAfterValidatePurchasingCode(ToPurchLine, FromPurchLine);
end;
if (FromPurchLine.Type = FromPurchLine.Type::" ") and (FromPurchLine."No." <> '') then
ToPurchLine.Validate("No.", FromPurchLine."No.");
OnAfterRecalculatePurchLine(ToPurchLine, ToPurchHeader, FromPurchHeader, FromPurchLine, CopyThisLine);
end;
local procedure CheckPurchRounding(FromPurchLine: Record "Purchase Line"; var RoundingLineInserted: Boolean)
var
PurchSetup: Record "Purchases & Payables Setup";
Vendor: Record Vendor;
VendorPostingGroup: Record "Vendor Posting Group";
begin
if (FromPurchLine.Type <> FromPurchLine.Type::"G/L Account") or (FromPurchLine."No." = '') then
exit;
if not FromPurchLine."System-Created Entry" then
exit;
PurchSetup.Get();
if PurchSetup."Invoice Rounding" then begin
GetVendor(FromPurchLine, Vendor);
VendorPostingGroup.Get(Vendor."Vendor Posting Group");
RoundingLineInserted := FromPurchLine."No." = VendorPostingGroup.GetInvRoundingAccount();
end;
end;
local procedure GetVendor(var FromPurchLine: Record "Purchase Line"; var Vendor: Record Vendor)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeGetVendor(FromPurchLine, Vendor, IsHandled);
if not IsHandled then
Vendor.Get(FromPurchLine."Pay-to Vendor No.");
end;
local procedure CheckSalesRounding(FromSalesLine: Record "Sales Line"; var RoundingLineInserted: Boolean)
var
SalesSetup: Record "Sales & Receivables Setup";
Customer: Record Customer;
CustomerPostingGroup: Record "Customer Posting Group";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckSalesRounding(FromSalesLine, RoundingLineInserted, IsHandled);
if IsHandled then
exit;
if (FromSalesLine.Type <> FromSalesLine.Type::"G/L Account") or (FromSalesLine."No." = '') then
exit;
if not FromSalesLine."System-Created Entry" then
exit;
SalesSetup.Get();
if SalesSetup."Invoice Rounding" then begin
Customer.Get(FromSalesLine."Bill-to Customer No.");
CustomerPostingGroup.Get(Customer."Customer Posting Group");
RoundingLineInserted := FromSalesLine."No." = CustomerPostingGroup.GetInvRoundingAccount();
end;
OnAfterCheckSalesRounding(FromSalesLine, RoundingLineInserted);
end;
local procedure CopyFromSalesDocAssgntToLine(var ToSalesLine: Record "Sales Line"; FromDocType: Enum "Sales Document Type"; FromDocNo: Code[20]; FromLineNo: Integer; var ItemChargeAssgntNextLineNo: Integer)
var
FromItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";
ToItemChargeAssgntSales: Record "Item Charge Assignment (Sales)";
ItemChargeAssgntSales: Codeunit "Item Charge Assgnt. (Sales)";
IsHandled: Boolean;
begin
FromItemChargeAssgntSales.Reset();
FromItemChargeAssgntSales.SetRange("Document Type", FromDocType);
FromItemChargeAssgntSales.SetRange("Document No.", FromDocNo);
FromItemChargeAssgntSales.SetRange("Document Line No.", FromLineNo);
FromItemChargeAssgntSales.SetFilter("Applies-to Doc. Type", '<>%1', FromDocType);
OnCopyFromSalesDocAssgntToLineOnAfterSetFilters(FromItemChargeAssgntSales, RecalculateLines);
if FromItemChargeAssgntSales.Find('-') then
repeat
ToItemChargeAssgntSales.Copy(FromItemChargeAssgntSales);
ToItemChargeAssgntSales."Document Type" := ToSalesLine."Document Type";
ToItemChargeAssgntSales."Document No." := ToSalesLine."Document No.";
ToItemChargeAssgntSales."Document Line No." := ToSalesLine."Line No.";
IsHandled := false;
OnCopyFromSalesDocAssgntToLineOnBeforeInsert(FromItemChargeAssgntSales, RecalculateLines, IsHandled);
if not IsHandled then
ItemChargeAssgntSales.InsertItemChargeAssignment(
ToItemChargeAssgntSales, ToItemChargeAssgntSales."Applies-to Doc. Type",
ToItemChargeAssgntSales."Applies-to Doc. No.", ToItemChargeAssgntSales."Applies-to Doc. Line No.",
ToItemChargeAssgntSales."Item No.", ToItemChargeAssgntSales.Description, ItemChargeAssgntNextLineNo);
until FromItemChargeAssgntSales.Next() = 0;
OnAfterCopyFromSalesDocAssgntToLine(ToSalesLine, RecalculateLines);
end;
local procedure CopyFromPurchDocAssgntToLine(var ToPurchLine: Record "Purchase Line"; FromDocType: Enum "Purchase Document Type"; FromDocNo: Code[20]; FromLineNo: Integer; var ItemChargeAssgntNextLineNo: Integer)
var
FromItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";
ToItemChargeAssgntPurch: Record "Item Charge Assignment (Purch)";
ItemChargeAssgntPurch: Codeunit "Item Charge Assgnt. (Purch.)";
IsHandled: Boolean;
begin
FromItemChargeAssgntPurch.Reset();
FromItemChargeAssgntPurch.SetRange("Document Type", FromDocType);
FromItemChargeAssgntPurch.SetRange("Document No.", FromDocNo);
FromItemChargeAssgntPurch.SetRange("Document Line No.", FromLineNo);
FromItemChargeAssgntPurch.SetFilter("Applies-to Doc. Type", '<>%1', FromDocType);
OnCopyFromPurchDocAssgntToLineOnAfterSetFilters(FromItemChargeAssgntPurch, RecalculateLines);
if FromItemChargeAssgntPurch.Find('-') then
repeat
ToItemChargeAssgntPurch.Copy(FromItemChargeAssgntPurch);
ToItemChargeAssgntPurch."Document Type" := ToPurchLine."Document Type";
ToItemChargeAssgntPurch."Document No." := ToPurchLine."Document No.";
ToItemChargeAssgntPurch."Document Line No." := ToPurchLine."Line No.";
IsHandled := false;
OnCopyFromPurchDocAssgntToLineOnBeforeInsert(FromItemChargeAssgntPurch, RecalculateLines, IsHandled);
if not IsHandled then
ItemChargeAssgntPurch.InsertItemChargeAssignment(
ToItemChargeAssgntPurch, ToItemChargeAssgntPurch."Applies-to Doc. Type",
ToItemChargeAssgntPurch."Applies-to Doc. No.", ToItemChargeAssgntPurch."Applies-to Doc. Line No.",
ToItemChargeAssgntPurch."Item No.", ToItemChargeAssgntPurch.Description, ItemChargeAssgntNextLineNo);
until FromItemChargeAssgntPurch.Next() = 0;
OnAfterCopyFromPurchDocAssgntToLine(ToPurchLine, RecalculateLines);
end;
local procedure CopyFromPurchLineItemChargeAssign(FromPurchLine: Record "Purchase Line"; ToPurchLine: Record "Purchase Line"; FromPurchHeader: Record "Purchase Header"; var ItemChargeAssgntNextLineNo: Integer)
var
TempToItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary;
ToItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)";
ValueEntry: Record "Value Entry";
ItemLedgerEntry: Record "Item Ledger Entry";
PurchaseItem: Record Item;
PurchaseCurrency: Record Currency;
ItemChargeAssgntPurch: Codeunit "Item Charge Assgnt. (Purch.)";
CurrencyFactor: Decimal;
QtyToAssign: Decimal;
SumQtyToAssign: Decimal;
RemainingQty: Decimal;
begin
if FromPurchLine."Document Type" = FromPurchLine."Document Type"::"Credit Memo" then
ValueEntry.SetRange("Document Type", ValueEntry."Document Type"::"Purchase Credit Memo")
else
ValueEntry.SetRange("Document Type", ValueEntry."Document Type"::"Purchase Invoice");
ValueEntry.SetRange("Document No.", FromPurchLine."Document No.");
ValueEntry.SetRange("Document Line No.", FromPurchLine."Line No.");
ValueEntry.SetRange("Item Charge No.", FromPurchLine."No.");
ToItemChargeAssignmentPurch."Document Type" := ToPurchLine."Document Type";
ToItemChargeAssignmentPurch."Document No." := ToPurchLine."Document No.";
ToItemChargeAssignmentPurch."Document Line No." := ToPurchLine."Line No.";
ToItemChargeAssignmentPurch."Item Charge No." := FromPurchLine."No.";
ToItemChargeAssignmentPurch."Unit Cost" := FromPurchLine."Unit Cost";
if ValueEntry.FindSet() then begin
repeat
if ItemLedgerEntry.Get(ValueEntry."Item Ledger Entry No.") then
if ItemLedgerEntry."Document Type" = ItemLedgerEntry."Document Type"::"Purchase Receipt" then begin
PurchaseItem.Get(ItemLedgerEntry."Item No.");
CurrencyFactor := FromPurchHeader."Currency Factor";
if not PurchaseCurrency.Get(FromPurchHeader."Currency Code") then begin
CurrencyFactor := 1;
PurchaseCurrency.InitRoundingPrecision();
end;
if ToPurchLine."Unit Cost" = 0 then
QtyToAssign := 0
else
QtyToAssign :=
Sign(ToPurchLine.Quantity) * Abs(ValueEntry."Cost Amount (Actual)") * CurrencyFactor / ToPurchLine."Unit Cost";
SumQtyToAssign += QtyToAssign;
ItemChargeAssgntPurch.InsertItemChargeAssignmentWithValuesTo(
ToItemChargeAssignmentPurch, ToItemChargeAssignmentPurch."Applies-to Doc. Type"::Receipt,
ItemLedgerEntry."Document No.", ItemLedgerEntry."Document Line No.", ItemLedgerEntry."Item No.", PurchaseItem.Description,
QtyToAssign, 0, ItemChargeAssgntNextLineNo, TempToItemChargeAssignmentPurch);
end;
OnCopyFromPurchLineItemChargeAssignOnAfterValueEntryLoop(
FromPurchHeader, ToPurchLine, ValueEntry, TempToItemChargeAssignmentPurch, ToItemChargeAssignmentPurch,
ItemChargeAssgntNextLineNo, SumQtyToAssign);
until ValueEntry.Next() = 0;
ItemChargeAssgntPurch.Summarize(TempToItemChargeAssignmentPurch, ToItemChargeAssignmentPurch);
// Use 2 passes to correct rounding issues
ToItemChargeAssignmentPurch.SetRange("Document Type", ToPurchLine."Document Type");
ToItemChargeAssignmentPurch.SetRange("Document No.", ToPurchLine."Document No.");
ToItemChargeAssignmentPurch.SetRange("Document Line No.", ToPurchLine."Line No.");
if ToItemChargeAssignmentPurch.FindSet(true) then begin
RemainingQty := (FromPurchLine.Quantity - SumQtyToAssign) / ValueEntry.Count();
SumQtyToAssign := 0;
repeat
AddRemainingQtyToPurchItemCharge(ToItemChargeAssignmentPurch, RemainingQty);
SumQtyToAssign += ToItemChargeAssignmentPurch."Qty. to Assign";
until ToItemChargeAssignmentPurch.Next() = 0;
RemainingQty := FromPurchLine.Quantity - SumQtyToAssign;
if RemainingQty <> 0 then
AddRemainingQtyToPurchItemCharge(ToItemChargeAssignmentPurch, RemainingQty);
end;
end;
end;
local procedure CopyFromSalesLineItemChargeAssign(FromSalesLine: Record "Sales Line"; ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; var ItemChargeAssgntNextLineNo: Integer)
var
ValueEntry: Record "Value Entry";
SalesCurrency: Record Currency;
TempToItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary;
ToItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)";
ItemLedgerEntry: Record "Item Ledger Entry";
SalesItem: Record Item;
ItemChargeAssgntSales: Codeunit "Item Charge Assgnt. (Sales)";
CurrencyFactor: Decimal;
QtyToAssign: Decimal;
SumQtyToAssign: Decimal;
RemainingQty: Decimal;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyFromSalesLineItemChargeAssign(FromSalesLine, ToSalesLine, FromSalesHeader, ItemChargeAssgntNextLineNo, IsHandled);
if IsHandled then
exit;
if FromSalesLine."Document Type" = FromSalesLine."Document Type"::"Credit Memo" then
ValueEntry.SetRange("Document Type", ValueEntry."Document Type"::"Sales Credit Memo")
else
ValueEntry.SetRange("Document Type", ValueEntry."Document Type"::"Sales Invoice");
ValueEntry.SetRange("Document No.", FromSalesLine."Document No.");
ValueEntry.SetRange("Document Line No.", FromSalesLine."Line No.");
ValueEntry.SetRange("Item Charge No.", FromSalesLine."No.");
ToItemChargeAssignmentSales."Document Type" := ToSalesLine."Document Type";
ToItemChargeAssignmentSales."Document No." := ToSalesLine."Document No.";
ToItemChargeAssignmentSales."Document Line No." := ToSalesLine."Line No.";
ToItemChargeAssignmentSales."Item Charge No." := FromSalesLine."No.";
ToItemChargeAssignmentSales."Unit Cost" := FromSalesLine."Unit Price";
if ValueEntry.FindSet() then begin
repeat
if ItemLedgerEntry.Get(ValueEntry."Item Ledger Entry No.") then
if ItemLedgerEntry."Document Type" = ItemLedgerEntry."Document Type"::"Sales Shipment" then begin
SalesItem.Get(ItemLedgerEntry."Item No.");
CurrencyFactor := FromSalesHeader."Currency Factor";
if not SalesCurrency.Get(FromSalesHeader."Currency Code") then begin
CurrencyFactor := 1;
SalesCurrency.InitRoundingPrecision();
end;
QtyToAssign :=
Sign(ToSalesLine.Quantity) * Abs(ValueEntry."Sales Amount (Actual)") * CurrencyFactor / ToSalesLine."Unit Price";
SumQtyToAssign += QtyToAssign;
ItemChargeAssgntSales.InsertItemChargeAssignmentWithValuesTo(
ToItemChargeAssignmentSales, ToItemChargeAssignmentSales."Applies-to Doc. Type"::Shipment,
ItemLedgerEntry."Document No.", ItemLedgerEntry."Document Line No.", ItemLedgerEntry."Item No.", SalesItem.Description,
QtyToAssign, 0, ItemChargeAssgntNextLineNo, TempToItemChargeAssignmentSales);
end;
OnCopyFromSalesLineItemChargeAssignOnAfterValueEntryLoop(
FromSalesHeader, ToSalesLine, ValueEntry, TempToItemChargeAssignmentSales, ToItemChargeAssignmentSales,
ItemChargeAssgntNextLineNo, SumQtyToAssign);
until ValueEntry.Next() = 0;
ItemChargeAssgntSales.Summarize(TempToItemChargeAssignmentSales, ToItemChargeAssignmentSales);
// Use 2 passes to correct rounding issues
ToItemChargeAssignmentSales.SetRange("Document Type", ToSalesLine."Document Type");
ToItemChargeAssignmentSales.SetRange("Document No.", ToSalesLine."Document No.");
ToItemChargeAssignmentSales.SetRange("Document Line No.", ToSalesLine."Line No.");
if ToItemChargeAssignmentSales.FindSet(true) then begin
RemainingQty := (FromSalesLine.Quantity - SumQtyToAssign) / ValueEntry.Count();
SumQtyToAssign := 0;
repeat
AddRemainingQtyToSalesItemCharge(ToItemChargeAssignmentSales, RemainingQty);
SumQtyToAssign += ToItemChargeAssignmentSales."Qty. to Assign";
until ToItemChargeAssignmentSales.Next() = 0;
RemainingQty := FromSalesLine.Quantity - SumQtyToAssign;
if RemainingQty <> 0 then
AddRemainingQtyToSalesItemCharge(ToItemChargeAssignmentSales, RemainingQty);
end;
end;
end;
local procedure AddRemainingQtyToPurchItemCharge(var ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)"; RemainingQty: Decimal)
begin
ItemChargeAssignmentPurch.Validate(
"Qty. to Assign", Round(ItemChargeAssignmentPurch."Qty. to Assign" + RemainingQty, UOMMgt.QtyRndPrecision()));
ItemChargeAssignmentPurch.Modify(true);
end;
local procedure AddRemainingQtyToSalesItemCharge(var ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)"; RemainingQty: Decimal)
begin
ItemChargeAssignmentSales.Validate(
"Qty. to Assign", Round(ItemChargeAssignmentSales."Qty. to Assign" + RemainingQty, UOMMgt.QtyRndPrecision()));
ItemChargeAssignmentSales.Modify(true);
end;
local procedure WarnSalesInvoicePmtDisc(var ToSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From"; FromDocNo: Code[20])
var
CustLedgEntry: Record "Cust. Ledger Entry";
begin
if HideDialog then
exit;
if IncludeHeader and
(ToSalesHeader."Document Type" in
[ToSalesHeader."Document Type"::"Return Order", ToSalesHeader."Document Type"::"Credit Memo"])
then begin
CustLedgEntry.SetCurrentKey("Document No.");
CustLedgEntry.SetRange("Document Type", CustLedgEntry."Document Type"::Invoice);
CustLedgEntry.SetRange("Document No.", FromDocNo);
if CustLedgEntry.FindFirst() then
if (CustLedgEntry."Pmt. Disc. Given (LCY)" <> 0) and
(CustLedgEntry."Journal Batch Name" = '')
then
Message(Text006, FromDocType, FromDocNo);
end;
if IncludeHeader and
(ToSalesHeader."Document Type" in
[ToSalesHeader."Document Type"::Invoice, ToSalesHeader."Document Type"::Order,
ToSalesHeader."Document Type"::Quote, ToSalesHeader."Document Type"::"Blanket Order"]) and
(FromDocType = "Sales Document Type From"::"Posted Return Receipt")
then begin
CustLedgEntry.SetCurrentKey("Document No.");
CustLedgEntry.SetRange("Document Type", CustLedgEntry."Document Type"::"Credit Memo");
CustLedgEntry.SetRange("Document No.", FromDocNo);
if CustLedgEntry.FindFirst() then
if (CustLedgEntry."Pmt. Disc. Given (LCY)" <> 0) and
(CustLedgEntry."Journal Batch Name" = '')
then
Message(Text006, FromDocType, FromDocNo);
end;
end;
local procedure WarnPurchInvoicePmtDisc(var ToPurchHeader: Record "Purchase Header"; FromDocType: Enum "Purchase Document Type From"; FromDocNo: Code[20])
var
VendLedgEntry: Record "Vendor Ledger Entry";
begin
if HideDialog then
exit;
if IncludeHeader and
(ToPurchHeader."Document Type" in
[ToPurchHeader."Document Type"::"Return Order", ToPurchHeader."Document Type"::"Credit Memo"])
then begin
VendLedgEntry.SetCurrentKey("Document No.");
VendLedgEntry.SetRange("Document Type", VendLedgEntry."Document Type"::Invoice);
VendLedgEntry.SetRange("Document No.", FromDocNo);
if VendLedgEntry.FindFirst() then
if (VendLedgEntry."Pmt. Disc. Rcd.(LCY)" <> 0) and
(VendLedgEntry."Journal Batch Name" = '')
then
Message(Text009, FromDocType, FromDocNo);
end;
if IncludeHeader and
(ToPurchHeader."Document Type" in
[ToPurchHeader."Document Type"::Invoice, ToPurchHeader."Document Type"::Order,
ToPurchHeader."Document Type"::Quote, ToPurchHeader."Document Type"::"Blanket Order"]) and
(FromDocType = "Purchase Document Type From"::"Posted Return Shipment")
then begin
VendLedgEntry.SetCurrentKey("Document No.");
VendLedgEntry.SetRange("Document Type", VendLedgEntry."Document Type"::"Credit Memo");
VendLedgEntry.SetRange("Document No.", FromDocNo);
if VendLedgEntry.FindFirst() then
if (VendLedgEntry."Pmt. Disc. Rcd.(LCY)" <> 0) and
(VendLedgEntry."Journal Batch Name" = '')
then
Message(Text006, FromDocType, FromDocNo);
end;
end;
local procedure CheckCopyFromSalesHeaderAvail(FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header")
var
FromSalesLine: Record "Sales Line";
ToSalesLine: Record "Sales Line";
begin
if ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice] then begin
FromSalesLine.SetRange("Document Type", FromSalesHeader."Document Type");
FromSalesLine.SetRange("Document No.", FromSalesHeader."No.");
FromSalesLine.SetRange(Type, FromSalesLine.Type::Item);
FromSalesLine.SetFilter("No.", '<>%1', '');
FromSalesLine.SetFilter(Quantity, '>0');
OnCheckCopyFromSalesHeaderAvailOnAfterSetFilters(FromSalesLine, FromSalesHeader, ToSalesHeader);
if FromSalesLine.FindSet() then
repeat
if not IsItemOrVariantBlocked(FromSalesLine."No.", FromSalesLine."Variant Code") then begin
ToSalesLine.CopyFromSalesLine(FromSalesLine);
if ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Order then
ToSalesLine."Outstanding Quantity" := FromSalesLine.Quantity - FromSalesLine."Qty. to Assemble to Order";
CheckItemAvailability(ToSalesHeader, ToSalesLine);
OnCheckCopyFromSalesHeaderAvailOnAfterCheckItemAvailability(
ToSalesHeader, ToSalesLine, FromSalesHeader, IncludeHeader, FromSalesLine);
if ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Order then begin
ToSalesLine."Outstanding Quantity" := FromSalesLine.Quantity;
if ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Order then
ToSalesLine."Outstanding Quantity" := FromSalesLine.Quantity - FromSalesLine."Qty. to Assemble to Order";
ToSalesLine."Qty. to Assemble to Order" := 0;
ToSalesLine."Drop Shipment" := FromSalesLine."Drop Shipment";
CheckItemAvailability(ToSalesHeader, ToSalesLine);
if ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Order then begin
ToSalesLine."Outstanding Quantity" := FromSalesLine.Quantity;
ToSalesLine."Qty. to Assemble to Order" := FromSalesLine."Qty. to Assemble to Order";
CheckATOItemAvailable(FromSalesLine, ToSalesLine);
end;
end;
end;
until FromSalesLine.Next() = 0;
end;
end;
local procedure CheckCopyFromSalesShptAvail(FromSalesShptHeader: Record "Sales Shipment Header"; ToSalesHeader: Record "Sales Header")
var
FromSalesShptLine: Record "Sales Shipment Line";
ToSalesLine: Record "Sales Line";
FromPostedAsmHeader: Record "Posted Assembly Header";
begin
if not (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]) then
exit;
FromSalesShptLine.SetRange("Document No.", FromSalesShptHeader."No.");
FromSalesShptLine.SetRange(Type, FromSalesShptLine.Type::Item);
FromSalesShptLine.SetFilter("No.", '<>%1', '');
FromSalesShptLine.SetFilter(Quantity, '>0');
OnCheckCopyFromSalesShptAvailOnAfterSetFilters(FromSalesShptLine, FromSalesShptHeader, ToSalesHeader);
if FromSalesShptLine.FindSet() then
repeat
if not IsItemOrVariantBlocked(FromSalesShptLine."No.", FromSalesShptLine."Variant Code") then begin
ToSalesLine.CopyFromSalesShptLine(FromSalesShptLine);
if ToSalesLine."Document Type" = ToSalesLine."Document Type"::Order then
if FromSalesShptLine.AsmToShipmentExists(FromPostedAsmHeader) then
ToSalesLine."Outstanding Quantity" := FromSalesShptLine.Quantity - FromPostedAsmHeader.Quantity;
CheckItemAvailability(ToSalesHeader, ToSalesLine);
OnCheckCopyFromSalesShptAvailOnAfterCheckItemAvailability(
ToSalesHeader, ToSalesLine, FromSalesShptHeader, IncludeHeader, FromSalesShptLine);
if ToSalesLine."Document Type" = ToSalesLine."Document Type"::Order then
if FromSalesShptLine.AsmToShipmentExists(FromPostedAsmHeader) then begin
ToSalesLine."Qty. to Assemble to Order" := FromPostedAsmHeader.Quantity;
CheckPostedATOItemAvailable(FromSalesShptLine, ToSalesLine);
end;
end;
until FromSalesShptLine.Next() = 0;
end;
local procedure CheckCopyFromSalesInvoiceAvail(FromSalesInvHeader: Record "Sales Invoice Header"; ToSalesHeader: Record "Sales Header")
var
FromSalesInvLine: Record "Sales Invoice Line";
ToSalesLine: Record "Sales Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckCopyFromSalesInvoiceAvail(FromSalesInvHeader, ToSalesHeader, FromSalesInvLine, ToSalesLine, IsHandled);
if IsHandled then
exit;
if not (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]) then
exit;
FromSalesInvLine.SetRange("Document No.", FromSalesInvHeader."No.");
FromSalesInvLine.SetRange(Type, FromSalesInvLine.Type::Item);
FromSalesInvLine.SetFilter("No.", '<>%1', '');
FromSalesInvLine.SetRange("Prepayment Line", false);
FromSalesInvLine.SetFilter(Quantity, '>0');
OnCheckCopyFromSalesInvoiceAvailOnAfterSetFilters(FromSalesInvLine, FromSalesInvHeader, ToSalesHeader);
if FromSalesInvLine.FindSet() then
repeat
if not IsItemOrVariantBlocked(FromSalesInvLine."No.", FromSalesInvLine."Variant Code") then begin
ToSalesLine.CopyFromSalesInvLine(FromSalesInvLine);
CheckCopyFromSalesInvoiceAvailOnBeforeCheckItemAvailability(ToSalesLine, FromSalesInvLine, ToSalesHeader, FromSalesInvHeader);
CheckItemAvailability(ToSalesHeader, ToSalesLine);
OnCheckCopyFromSalesInvoiceAvailOnAfterCheckItemAvailability(
ToSalesHeader, ToSalesLine, FromSalesInvHeader, IncludeHeader, FromSalesInvLine);
end;
until FromSalesInvLine.Next() = 0;
end;
local procedure CheckCopyFromSalesRetRcptAvail(FromReturnRcptHeader: Record "Return Receipt Header"; ToSalesHeader: Record "Sales Header")
var
FromReturnRcptLine: Record "Return Receipt Line";
ToSalesLine: Record "Sales Line";
begin
if not (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]) then
exit;
FromReturnRcptLine.SetRange("Document No.", FromReturnRcptHeader."No.");
FromReturnRcptLine.SetRange(Type, FromReturnRcptLine.Type::Item);
FromReturnRcptLine.SetFilter("No.", '<>%1', '');
FromReturnRcptLine.SetFilter(Quantity, '>0');
OnCheckCopyFromSalesRetRcptAvailOnAfterSetFilters(FromReturnRcptLine, FromReturnRcptHeader, ToSalesHeader);
if FromReturnRcptLine.FindSet() then
repeat
if not IsItemOrVariantBlocked(FromReturnRcptLine."No.", FromReturnRcptLine."Variant Code") then begin
ToSalesLine.CopyFromReturnRcptLine(FromReturnRcptLine);
CheckItemAvailability(ToSalesHeader, ToSalesLine);
OnCheckCopyFromSalesRetRcptAvailOnAfterCheckItemAvailability(
ToSalesHeader, ToSalesLine, FromReturnRcptHeader, IncludeHeader, FromReturnRcptLine);
end;
until FromReturnRcptLine.Next() = 0;
end;
local procedure CheckCopyFromSalesCrMemoAvail(FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; ToSalesHeader: Record "Sales Header")
var
FromSalesCrMemoLine: Record "Sales Cr.Memo Line";
ToSalesLine: Record "Sales Line";
begin
if not (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]) then
exit;
FromSalesCrMemoLine.SetRange("Document No.", FromSalesCrMemoHeader."No.");
FromSalesCrMemoLine.SetRange(Type, FromSalesCrMemoLine.Type::Item);
FromSalesCrMemoLine.SetFilter("No.", '<>%1', '');
FromSalesCrMemoLine.SetRange("Prepayment Line", false);
FromSalesCrMemoLine.SetFilter(Quantity, '>0');
OnCheckCopyFromSalesCrMemoAvailOnAfterSetFilters(FromSalesCrMemoLine, FromSalesCrMemoHeader, ToSalesHeader);
if FromSalesCrMemoLine.FindSet() then
repeat
if not IsItemOrVariantBlocked(FromSalesCrMemoLine."No.", FromSalesCrMemoLine."Variant Code") then begin
ToSalesLine.CopyFromSalesCrMemoLine(FromSalesCrMemoLine);
OnCheckCopyFromSalesCrMemoAvailOnBeforeCheckItemAvailability(FromSalesCrMemoLine, ToSalesLine);
CheckItemAvailability(ToSalesHeader, ToSalesLine);
OnCheckCopyFromSalesCrMemoAvailOnAfterCheckItemAvailability(
ToSalesHeader, ToSalesLine, FromSalesCrMemoHeader, IncludeHeader, FromSalesCrMemoLine);
end;
until FromSalesCrMemoLine.Next() = 0;
end;
local procedure CheckCopyFromSalesHeaderArchiveAvail(FromSalesHeaderArchive: Record "Sales Header Archive"; ToSalesHeader: Record "Sales Header")
var
FromSalesLineArchive: Record "Sales Line Archive";
ToSalesLine: Record "Sales Line";
begin
OnBeforeCheckCopyFromSalesHeaderArchiveAvail(FromSalesHeaderArchive, ToSalesHeader, MoveNegLines);
if not (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]) then
exit;
FromSalesLineArchive.SetRange("Document Type", FromSalesHeaderArchive."Document Type");
FromSalesLineArchive.SetRange("Document No.", FromSalesHeaderArchive."No.");
FromSalesLineArchive.SetRange("Doc. No. Occurrence", FromSalesHeaderArchive."Doc. No. Occurrence");
FromSalesLineArchive.SetRange("Version No.", FromSalesHeaderArchive."Version No.");
FromSalesLineArchive.SetRange(Type, FromSalesLineArchive.Type::Item);
FromSalesLineArchive.SetFilter("No.", '<>%1', '');
OnCheckCopyFromSalesHeaderArchiveAvailOnAfterSetFilters(FromSalesLineArchive, FromSalesHeaderArchive, ToSalesHeader);
if FromSalesLineArchive.FindSet() then
repeat
if FromSalesLineArchive.Quantity > 0 then begin
ToSalesLine."No." := FromSalesLineArchive."No.";
ToSalesLine."Variant Code" := FromSalesLineArchive."Variant Code";
ToSalesLine."Location Code" := FromSalesLineArchive."Location Code";
ToSalesLine."Bin Code" := FromSalesLineArchive."Bin Code";
ToSalesLine."Unit of Measure Code" := FromSalesLineArchive."Unit of Measure Code";
ToSalesLine."Qty. per Unit of Measure" := FromSalesLineArchive."Qty. per Unit of Measure";
ToSalesLine."Outstanding Quantity" := FromSalesLineArchive.Quantity;
CheckItemAvailability(ToSalesHeader, ToSalesLine);
OnCheckCopyFromSalesHeaderArchiveAvailOnAfterCheckItemAvailability(ToSalesHeader, ToSalesLine,
FromSalesHeaderArchive, FromSalesLineArchive, IncludeHeader);
end;
until FromSalesLineArchive.Next() = 0;
end;
local procedure CheckItemAvailability(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line")
var
IsHandled: Boolean;
begin
OnBeforeCheckItemAvailability(ToSalesHeader, ToSalesLine, HideDialog, IsHandled, RecalculateLines);
if IsHandled then
exit;
if HideDialog then
exit;
ToSalesLine."Document Type" := ToSalesHeader."Document Type";
ToSalesLine."Document No." := ToSalesHeader."No.";
ToSalesLine.Type := ToSalesLine.Type::Item;
ToSalesLine."Purchase Order No." := '';
ToSalesLine."Purch. Order Line No." := 0;
ToSalesLine."Drop Shipment" :=
not RecalculateLines and ToSalesLine."Drop Shipment" and
(ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Order);
SetShipmentDateInLine(ToSalesHeader, ToSalesLine);
IsHandled := false;
OnCheckItemAvailabilityOnBeforeRunSalesLineCheck(ToSalesHeader, ToSalesLine, IsHandled);
if not IsHandled then
if ItemCheckAvail.SalesLineCheck(ToSalesLine) then
ItemCheckAvail.RaiseUpdateInterruptedError();
end;
local procedure InitShipmentDateInLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")
begin
if SalesHeader."Shipment Date" <> 0D then
SalesLine."Shipment Date" := SalesHeader."Shipment Date"
else
SalesLine."Shipment Date" := WorkDate();
OnAfterInitShipmentDateInLine(SalesHeader, SalesLine);
end;
local procedure SetShipmentDateInLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")
begin
OnBeforeSetShipmentDateInLine(SalesHeader, SalesLine);
if SalesLine."Shipment Date" = 0D then begin
InitShipmentDateInLine(SalesHeader, SalesLine);
SalesLine.Validate("Shipment Date");
end;
end;
local procedure CheckATOItemAvailable(var FromSalesLine: Record "Sales Line"; ToSalesLine: Record "Sales Line")
var
ATOLink: Record "Assemble-to-Order Link";
AssemblyHeader: Record "Assembly Header";
TempAssemblyHeader: Record "Assembly Header" temporary;
TempAssemblyLine: Record "Assembly Line" temporary;
begin
if HideDialog then
exit;
if ATOLink.ATOCopyCheckAvailShowWarning(
AssemblyHeader, ToSalesLine, TempAssemblyHeader, TempAssemblyLine,
not FromSalesLine.AsmToOrderExists(AssemblyHeader))
then
if ItemCheckAvail.ShowAsmWarningYesNo(TempAssemblyHeader, TempAssemblyLine) then
ItemCheckAvail.RaiseUpdateInterruptedError();
end;
local procedure CheckPostedATOItemAvailable(var FromSalesShptLine: Record "Sales Shipment Line"; ToSalesLine: Record "Sales Line")
var
ATOLink: Record "Assemble-to-Order Link";
PostedAssemblyHeader: Record "Posted Assembly Header";
TempAssemblyHeader: Record "Assembly Header" temporary;
TempAssemblyLine: Record "Assembly Line" temporary;
begin
if HideDialog then
exit;
if ATOLink.PstdATOCopyCheckAvailShowWarn(
PostedAssemblyHeader, ToSalesLine, TempAssemblyHeader, TempAssemblyLine,
not FromSalesShptLine.AsmToShipmentExists(PostedAssemblyHeader))
then
if ItemCheckAvail.ShowAsmWarningYesNo(TempAssemblyHeader, TempAssemblyLine) then
ItemCheckAvail.RaiseUpdateInterruptedError();
end;
procedure CopySalesShptLinesToDoc(ToSalesHeader: Record "Sales Header"; var FromSalesShptLine: Record "Sales Shipment Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
ItemLedgEntry: Record "Item Ledger Entry";
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromSalesHeader: Record "Sales Header";
FromSalesLine: Record "Sales Line";
ToSalesLine: Record "Sales Line";
TempFromSalesLineBuf: Record "Sales Line" temporary;
FromSalesShptHeader: Record "Sales Shipment Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocSalesLine: Record "Sales Line" temporary;
PostedAssemblyHeader: Record "Posted Assembly Header";
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
CopyLine: Boolean;
InsertDocNoLine: Boolean;
IsHandled: Boolean;
begin
MissingExCostRevLink := false;
InitCurrency(ToSalesHeader."Currency Code");
OpenWindow();
OnBeforeCopySalesShptLinesToDoc(TempDocSalesLine, ToSalesHeader, FromSalesShptLine);
if FromSalesShptLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromSalesShptHeader."No." <> FromSalesShptLine."Document No." then begin
FromSalesShptHeader.Get(FromSalesShptLine."Document No.");
TransferOldExtLines.ClearLineNumbers();
end;
IsHandled := false;
OnCopySalesShptLinesToDocOnBeforeTestPricesInclVAT(ToSalesHeader, IncludeHeader, RecalculateLines, IsHandled);
if not IsHandled then
FromSalesShptHeader.TestField("Prices Including VAT", ToSalesHeader."Prices Including VAT");
OnCopySalesShptLinesToDocOnBeforeFromSalesHeaderTransferFields(FromSalesShptHeader, FromSalesHeader, ToSalesHeader, FromSalesShptLine);
FromSalesHeader.TransferFields(FromSalesShptHeader);
OnCopySalesShptLinesToDocOnAfterFromSalesHeaderTransferFields(FromSalesShptHeader, FromSalesHeader);
FillExactCostRevLink :=
IsSalesFillExactCostRevLink(ToSalesHeader, 0, FromSalesHeader."Currency Code");
FromSalesLine.TransferFields(FromSalesShptLine);
FromSalesLine."Appl.-from Item Entry" := 0;
FromSalesLine."Copied From Posted Doc." := true;
CheckUpdateOldDocumentNoFromSalesShptLine(FromSalesShptLine, OldDocNo, InsertDocNoLine);
OnBeforeCopySalesShptLinesToBuffer(FromSalesLine, FromSalesShptLine, ToSalesHeader);
SplitLine := true;
FromSalesShptLine.FilterPstdDocLnItemLedgEntries(ItemLedgEntry);
OnCopySalesShptLinesToDocOnBeforeSplitPstdSalesLinesPerILE(ItemLedgEntry, FromSalesShptLine);
if not SplitPstdSalesLinesPerILE(
ToSalesHeader, FromSalesHeader, ItemLedgEntry, TempFromSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, true)
then
if CopyItemTrkg then
SplitLine :=
SplitSalesDocLinesPerItemTrkg(
ItemLedgEntry, TempItemTrkgEntry, TempFromSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, true)
else
SplitLine := false;
if not SplitLine then begin
TempFromSalesLineBuf := FromSalesLine;
CopyLine := true;
end else
CopyLine := TempFromSalesLineBuf.FindSet() and FillExactCostRevLink;
OnCopySalesShptLinesToDocOnAfterSplitPstdSalesLinesPerILE(TempFromSalesLineBuf, FromSalesShptLine);
UpdateWindow(1, FromLineCounter);
if CopyLine then begin
NextLineNo := GetLastToSalesLineNo(ToSalesHeader);
OnCopySalesShptLinesToDocOnAfterCalcNextLineNo(ToSalesHeader, FromSalesShptLine, FromSalesHeader, NextLineNo, InsertDocNoLine, FromLineCounter, TempFromSalesLineBuf);
AsmHdrExistsForFromDocLine := FromSalesShptLine.AsmToShipmentExists(PostedAssemblyHeader);
InitAsmCopyHandling(true);
if AsmHdrExistsForFromDocLine then begin
QtyToAsmToOrder := FromSalesShptLine.Quantity;
QtyToAsmToOrderBase := FromSalesShptLine."Quantity (Base)";
GenerateAsmDataFromPosted(PostedAssemblyHeader, ToSalesHeader."Document Type");
end;
if InsertDocNoLine then begin
InsertOldSalesDocNoLine(ToSalesHeader, FromSalesShptLine."Document No.", 1, NextLineNo);
InsertDocNoLine := false;
end;
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
OnCopySalesShptLinesToDocOnBeforeCopySalesLine(ToSalesHeader, TempFromSalesLineBuf, FromSalesShptLine, CopyItemTrkg);
if CopySalesDocLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, TempFromSalesLineBuf, NextLineNo, LinesNotCopied, false,
"Sales Document Type From"::"Posted Shipment", CopyPostedDeferral, TempFromSalesLineBuf."Line No.")
then begin
if CopyItemTrkg then begin
if SplitLine then
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, false, TempFromSalesLineBuf."Document No.", TempFromSalesLineBuf."Line No.")
else
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, ItemLedgEntry);
ItemTrackingMgt.CopyItemLedgEntryTrkgToSalesLn(
TempTrkgItemLedgEntry, ToSalesLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromSalesHeader."Prices Including VAT", ToSalesHeader."Prices Including VAT", true);
end;
OnAfterCopySalesLineFromSalesShptLineBuffer(
ToSalesLine, FromSalesShptLine, IncludeHeader, RecalculateLines, TempDocSalesLine, ToSalesHeader, TempFromSalesLineBuf, ExactCostRevMandatory, FromSalesHeader, LinesNotCopied);
end;
OnCopySalesShptLinesToDocOnAfterCopySalesLine(ToSalesHeader, ToSalesLine, FromSalesShptLine);
until TempFromSalesLineBuf.Next() = 0;
end;
OnCopySalesShptLinesToDocOnAfterCopySalesShptLineToSalesLine(FromSalesShptLine, ToSalesLine);
until FromSalesShptLine.Next() = 0;
CloseWindow();
OnAfterCopySalesShptLinesToDoc(ToSalesHeader, FromSalesShptLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CheckUpdateOldDocumentNoFromSalesShptLine(FromSalesShptLine: Record "Sales Shipment Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckUpdateOldDocumentNoFromSalesShptLine(FromSalesShptLine, OldDocNo, InsertDocNoLine, IsHandled);
if IsHandled then
exit;
if FromSalesShptLine."Document No." <> OldDocNo then begin
OldDocNo := FromSalesShptLine."Document No.";
InsertDocNoLine := true;
end;
end;
procedure CopySalesInvLinesToDoc(ToSalesHeader: Record "Sales Header"; var FromSalesInvLine: Record "Sales Invoice Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
TempItemLedgEntryBuf: Record "Item Ledger Entry" temporary;
FromSalesHeader: Record "Sales Header";
FromSalesLine: Record "Sales Line";
FromSalesLine2: Record "Sales Line";
ToSalesLine: Record "Sales Line";
TempSalesLineBuf: Record "Sales Line" temporary;
FromSalesInvHeader: Record "Sales Invoice Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocSalesLine: Record "Sales Line" temporary;
OldInvDocNo: Code[20];
OldShptDocNo: Code[20];
OldBufDocNo: Code[20];
NextLineNo: Integer;
SalesCombDocLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
SalesInvLineCount: Integer;
SalesLineCount: Integer;
BufferCount: Integer;
FirstLineShipped: Boolean;
IsHandled: Boolean;
FirstLineText: Boolean;
ItemChargeAssgntNextLineNo: Integer;
ShouldInsertOldSalesDocNoLine: Boolean;
ShouldGetNextLineNo, ShouldIncrementNextLineNo : Boolean;
begin
IsHandled := false;
OnBeforeCopySalesInvLinesToDoc(ToSalesHeader, FromSalesInvLine, CopyJobData, RecalculateLines, IsHandled);
if IsHandled then
exit;
MissingExCostRevLink := false;
InitCurrency(ToSalesHeader."Currency Code");
TempSalesLineBuf.Reset();
TempSalesLineBuf.DeleteAll();
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.DeleteAll();
OpenWindow();
InitAsmCopyHandling(true);
TempSalesInvLine.DeleteAll();
OnBeforeCopySalesInvLines(TempDocSalesLine, ToSalesHeader, FromSalesInvLine, CopyJobData);
// Fill sales line buffer
SalesInvLineCount := 0;
FirstLineText := false;
if FromSalesInvLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
SetTempSalesInvLine(FromSalesInvLine, TempSalesInvLine, SalesInvLineCount, NextLineNo, FirstLineText);
if FromSalesInvHeader."No." <> FromSalesInvLine."Document No." then begin
FromSalesInvHeader.Get(FromSalesInvLine."Document No.");
TransferOldExtLines.ClearLineNumbers();
OnCopySalesInvLinesToDocOnAfterGetFromSalesInvHeader(ToSalesHeader, FromSalesInvHeader);
end;
IsHandled := false;
OnCopySalesInvLinesToDocOnBeforeTestPricesInclVAT(ToSalesHeader, IncludeHeader, RecalculateLines, IsHandled);
if not IsHandled then
FromSalesInvHeader.TestField("Prices Including VAT", ToSalesHeader."Prices Including VAT");
OnCopySalesInvLinesToDocOnBeforeFromSalesHeaderTransferFields(FromSalesHeader, FromSalesInvHeader, ToSalesHeader, FromSalesInvLine);
FromSalesHeader.TransferFields(FromSalesInvHeader);
OnCopySalesInvLinesToDocOnAfterFromSalesHeaderTransferFields(FromSalesHeader, FromSalesInvHeader);
FillExactCostRevLink := IsSalesFillExactCostRevLink(ToSalesHeader, 1, FromSalesHeader."Currency Code");
FromSalesLine.TransferFields(FromSalesInvLine);
FromSalesLine."Appl.-from Item Entry" := 0;
// Reuse fields to buffer invoice line information
FromSalesLine."Shipment No." := FromSalesInvLine."Document No.";
FromSalesLine."Shipment Line No." := 0;
FromSalesLine."Return Receipt No." := '';
FromSalesLine."Return Receipt Line No." := FromSalesInvLine."Line No.";
FromSalesLine."Copied From Posted Doc." := true;
OnBeforeCopySalesInvLinesToBuffer(FromSalesLine, FromSalesInvLine, ToSalesHeader);
SplitLine := true;
FromSalesInvLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if not SplitPstdSalesLinesPerILE(
ToSalesHeader, FromSalesHeader, TempItemLedgEntryBuf, TempSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, false)
then
if CopyItemTrkg then
SplitLine := SplitSalesDocLinesPerItemTrkg(
TempItemLedgEntryBuf, TempItemTrkgEntry, TempSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, false)
else
SplitLine := false;
if not SplitLine then
CopySalesLinesToBuffer(
FromSalesHeader, FromSalesLine, FromSalesLine2, TempSalesLineBuf,
ToSalesHeader, TempDocSalesLine, FromSalesInvLine."Document No.", NextLineNo);
if TempSalesLineBuf."Shipment Line No." <> 0 then
SkipOldInvoiceDescription(true);
OnAfterCopySalesInvLine(TempDocSalesLine, ToSalesHeader, TempSalesLineBuf, FromSalesInvLine);
until FromSalesInvLine.Next() = 0;
OnCopySalesInvLinesToDocOnAfterFillSalesLinesBuffer(ToSalesHeader);
// Create sales line from buffer
UpdateWindow(1, FromLineCounter);
BufferCount := 0;
FirstLineShipped := true;
OnCopySalesInvLinesToDocOnBeforeTempSalesLineBufLoop(ToSalesHeader, TempSalesLineBuf);
// Sorting according to Sales Line Document No.,Line No.
TempSalesLineBuf.SetCurrentKey("Line No.");
SalesLineCount := 0;
if TempSalesLineBuf.FindSet() then
repeat
if TempSalesLineBuf.Type = TempSalesLineBuf.Type::Item then
SalesLineCount += 1;
until TempSalesLineBuf.Next() = 0;
if TempSalesLineBuf.FindSet() then begin
ShouldGetNextLineNo := true;
OnCopySalesInvLinesToDocOnBeforeGetNextLineNo(ToSalesHeader, TempSalesLineBuf, ShouldGetNextLineNo, NextLineNo);
if ShouldGetNextLineNo then
NextLineNo := GetLastToSalesLineNo(ToSalesHeader);
Clear(OldInvDocNo);
Clear(OldBufDocNo);
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
ShouldInsertOldSalesDocNoLine := TempSalesLineBuf."Shipment No." <> OldInvDocNo;
OnCopySalesInvLinesToDocOnAfterCalcShouldInsertOldSalesDocNoLine(TempSalesLineBuf, ToSalesHeader, ShouldInsertOldSalesDocNoLine);
if ShouldInsertOldSalesDocNoLine then begin
OldInvDocNo := TempSalesLineBuf."Shipment No.";
OldShptDocNo := '';
FirstLineShipped := true;
OnCopySalesInvLinesToDocOnBeforeInsertOldSalesDocNoLine(ToSalesHeader, SkipCopyFromDescription);
InsertOldSalesDocNoLine(ToSalesHeader, OldInvDocNo, 2, NextLineNo);
OnCopySalesInvLinesToDocOnAfterInsertOldSalesDocNoLine(ToSalesHeader, SkipCopyFromDescription);
end;
CheckFirstLineShipped(ToSalesHeader, TempSalesLineBuf, SalesCombDocLineNo, NextLineNo, FirstLineShipped);
OnCopySalesInvLinesToDocOnAfterCheckFirstLineShipped(ToSalesHeader, 2, TempSalesLineBuf."Document No.", OldShptDocNo);
if (TempSalesLineBuf."Document No." <> OldShptDocNo) and (TempSalesLineBuf."Shipment Line No." > 0) then begin
if FirstLineShipped then
SalesCombDocLineNo := NextLineNo;
OldShptDocNo := TempSalesLineBuf."Document No.";
InsertOldSalesCombDocNoLine(ToSalesHeader, OldInvDocNo, OldShptDocNo, SalesCombDocLineNo, true);
ShouldIncrementNextLineNo := true;
OnCopySalesInvLinesToDocOnBeforeIncrementNextLineNo(ToSalesHeader, TempSalesLineBuf, ShouldIncrementNextLineNo, NextLineNo);
if ShouldIncrementNextLineNo then
NextLineNo := NextLineNo + 10000;
FirstLineShipped := true;
end;
InitFromSalesLine(FromSalesLine2, TempSalesLineBuf);
if GetSalesDocNo(TempDocSalesLine, TempSalesLineBuf."Line No.") <> OldBufDocNo then begin
OldBufDocNo := GetSalesDocNo(TempDocSalesLine, TempSalesLineBuf."Line No.");
TransferOldExtLines.ClearLineNumbers();
end;
OnCopySalesInvLinesToDocOnBeforeCopySalesLine(ToSalesHeader, FromSalesLine2, TempSalesLineBuf,
ToSalesLine, FromSalesInvLine, IncludeHeader, RecalculateLines,
TempDocSalesLine, FromSalesLine, ExactCostRevMandatory);
AsmHdrExistsForFromDocLine := false;
if (TempSalesLineBuf.Type = TempSalesLineBuf.Type::Item) and (ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Quote, ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::"Blanket Order"]) then
CheckAsmHdrExistsForFromDocLine(ToSalesHeader, FromSalesLine2, BufferCount, SalesLineCount = SalesInvLineCount);
if CopySalesDocLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine2, NextLineNo, LinesNotCopied, TempSalesLineBuf."Return Receipt No." = '',
"Sales Document Type From"::"Posted Invoice", CopyPostedDeferral, GetSalesLineNo(TempDocSalesLine, FromSalesLine2."Line No."))
then begin
if CopyPostedDeferral then
CopySalesPostedDeferrals(ToSalesLine, "Deferral Document Type"::Sales,
DeferralTypeForSalesDoc("Sales Document Type From"::"Posted Invoice".AsInteger()), TempSalesLineBuf."Shipment No.", TempSalesLineBuf."Return Receipt Line No.",
ToSalesLine."Document Type".AsInteger(), ToSalesLine."Document No.", ToSalesLine."Line No.");
FromSalesInvLine.Get(TempSalesLineBuf."Shipment No.", TempSalesLineBuf."Return Receipt Line No.");
OnCopySalesInvLinesToDocOnAfterCopySalesPostedDeferrals(FromSalesInvLine, NextLineNo, ToSalesLine, TempSalesLineBuf);
// copy item charges
if TempSalesLineBuf.Type = TempSalesLineBuf.Type::"Charge (Item)" then begin
FromSalesLine.TransferFields(FromSalesInvLine);
FromSalesLine."Document Type" := FromSalesLine."Document Type"::Invoice;
CopyFromSalesLineItemChargeAssign(FromSalesLine, ToSalesLine, FromSalesHeader, ItemChargeAssgntNextLineNo);
end;
IsHandled := false;
OnCopySalesInvLinesToDocOnBeforeCopyItemTracking(TempSalesLineBuf, ToSalesHeader, FromSalesInvLine, TempItemLedgEntryBuf, TempItemTrkgEntry, IsHandled);
// copy item tracking
if not IsHandled then
if (TempSalesLineBuf.Type = TempSalesLineBuf.Type::Item) and (TempSalesLineBuf.Quantity <> 0) and SalesDocCanReceiveTracking(ToSalesHeader) then begin
FromSalesInvLine."Document No." := OldInvDocNo;
FromSalesInvLine."Line No." := TempSalesLineBuf."Return Receipt Line No.";
FromSalesInvLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if IsCopyItemTrkg(TempItemLedgEntryBuf, CopyItemTrkg, FillExactCostRevLink) then begin
CopyItemLedgEntryTrackingToSalesLine(
TempItemLedgEntryBuf, TempItemTrkgEntry, TempSalesLineBuf, ToSalesLine, ToSalesHeader."Prices Including VAT",
FromSalesHeader."Prices Including VAT", FillExactCostRevLink, MissingExCostRevLink);
OnCopySalesInvLinesToDocOnAfterCopyItemLedgEntryTrackingToSalesLine(ToSalesLine);
end;
end;
OnAfterCopySalesLineFromSalesLineBuffer(
ToSalesLine, FromSalesInvLine, IncludeHeader, RecalculateLines, TempDocSalesLine, ToSalesHeader, TempSalesLineBuf,
FromSalesLine2, FromSalesLine, ExactCostRevMandatory, FromSalesInvHeader, LinesNotCopied);
end;
OnCopySalesInvLinesToDocOnAfterCopySalesDocLine(ToSalesLine, FromSalesInvLine);
OnCopySalesInvLinesToDocOnEndOfCopyLineIteration(ToSalesHeader, ToSalesLine, FromSalesInvLine, TempSalesLineBuf, LinesNotCopied, NextLineNo);
until TempSalesLineBuf.Next() = 0;
end;
CloseWindow();
OnAfterCopySalesInvLinesToDoc(ToSalesHeader, FromSalesInvLine, LinesNotCopied, MissingExCostRevLink);
end;
procedure CopySalesCrMemoLinesToDoc(ToSalesHeader: Record "Sales Header"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
TempItemLedgEntryBuf: Record "Item Ledger Entry" temporary;
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromSalesHeader: Record "Sales Header";
FromSalesLine: Record "Sales Line";
FromSalesLine2: Record "Sales Line";
ToSalesLine: Record "Sales Line";
TempFromSalesLineBuf: Record "Sales Line" temporary;
FromSalesCrMemoHeader: Record "Sales Cr.Memo Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocSalesLine: Record "Sales Line" temporary;
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldCrMemoDocNo: Code[20];
OldReturnRcptDocNo: Code[20];
OldBufDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
ItemChargeAssgntNextLineNo: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
ShouldCopyItemTracking: Boolean;
ShouldGetNextLineNo: Boolean;
begin
MissingExCostRevLink := false;
InitCurrency(ToSalesHeader."Currency Code");
TempFromSalesLineBuf.Reset();
TempFromSalesLineBuf.DeleteAll();
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.DeleteAll();
OpenWindow();
OnBeforeCopySalesCrMemoLinesToDoc(TempDocSalesLine, ToSalesHeader, FromSalesCrMemoLine, CopyJobData);
// Fill sales line buffer
if FromSalesCrMemoLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromSalesCrMemoHeader."No." <> FromSalesCrMemoLine."Document No." then begin
FromSalesCrMemoHeader.Get(FromSalesCrMemoLine."Document No.");
TransferOldExtLines.ClearLineNumbers();
end;
OnCopySalesCrMemoLinesToDocOnBeforeFromSalesHeaderTransferFields(FromSalesCrMemoHeader, FromSalesHeader, ToSalesHeader, FromSalesCrMemoLine);
FromSalesHeader.TransferFields(FromSalesCrMemoHeader);
OnCopySalesCrMemoLinesToDocOnAfterFromSalesHeaderTransferFields(FromSalesCrMemoHeader, FromSalesHeader);
FillExactCostRevLink :=
IsSalesFillExactCostRevLink(ToSalesHeader, 3, FromSalesHeader."Currency Code");
FromSalesLine.TransferFields(FromSalesCrMemoLine);
FromSalesLine."Appl.-from Item Entry" := 0;
// Reuse fields to buffer credit memo line information
FromSalesLine."Shipment No." := FromSalesCrMemoLine."Document No.";
FromSalesLine."Shipment Line No." := 0;
FromSalesLine."Return Receipt No." := '';
FromSalesLine."Return Receipt Line No." := FromSalesCrMemoLine."Line No.";
FromSalesLine."Copied From Posted Doc." := true;
OnBeforeCopySalesCrMemoLinesToBuffer(FromSalesLine, FromSalesCrMemoLine, ToSalesHeader);
SplitLine := true;
FromSalesCrMemoLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if not SplitPstdSalesLinesPerILE(
ToSalesHeader, FromSalesHeader, TempItemLedgEntryBuf, TempFromSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, false)
then
if CopyItemTrkg then
SplitLine :=
SplitSalesDocLinesPerItemTrkg(
TempItemLedgEntryBuf, TempItemTrkgEntry, TempFromSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, false)
else
SplitLine := false;
if not SplitLine then
CopySalesLinesToBuffer(
FromSalesHeader, FromSalesLine, FromSalesLine2, TempFromSalesLineBuf,
ToSalesHeader, TempDocSalesLine, FromSalesCrMemoLine."Document No.", NextLineNo);
OnAfterCopySalesCrMemoLine(TempDocSalesLine, ToSalesHeader, TempFromSalesLineBuf, FromSalesCrMemoLine, FromSalesLine, SplitLine);
until FromSalesCrMemoLine.Next() = 0;
OnCopySalesCrMemoLinesToDocOnAfterFillSalesLineBuffer(ToSalesHeader, TempFromSalesLineBuf);
// Create sales line from buffer
UpdateWindow(1, FromLineCounter);
// Sorting according to Sales Line Document No.,Line No.
TempFromSalesLineBuf.SetCurrentKey("Document Type", "Document No.", "Line No.");
if TempFromSalesLineBuf.FindSet() then begin
ShouldGetNextLineNo := true;
OnCopySalesCrMemoLinesToDocOnBeforeGetNextLineNo(ToSalesHeader, TempFromSalesLineBuf, ShouldGetNextLineNo, NextLineNo);
if ShouldGetNextLineNo then
NextLineNo := GetLastToSalesLineNo(ToSalesHeader);
Clear(OldCrMemoDocNo);
Clear(OldBufDocNo);
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
if TempFromSalesLineBuf."Shipment No." <> OldCrMemoDocNo then begin
OldCrMemoDocNo := TempFromSalesLineBuf."Shipment No.";
OldReturnRcptDocNo := '';
InsertOldSalesDocNoLine(ToSalesHeader, OldCrMemoDocNo, 4, NextLineNo);
end;
if (TempFromSalesLineBuf."Document No." <> OldReturnRcptDocNo) and (TempFromSalesLineBuf."Shipment Line No." > 0) then begin
OldReturnRcptDocNo := TempFromSalesLineBuf."Document No.";
InsertOldSalesCombDocNoLine(ToSalesHeader, OldCrMemoDocNo, OldReturnRcptDocNo, NextLineNo, false);
end;
// Empty buffer fields
FromSalesLine2 := TempFromSalesLineBuf;
FromSalesLine2."Shipment No." := '';
FromSalesLine2."Shipment Line No." := 0;
FromSalesLine2."Return Receipt No." := '';
FromSalesLine2."Return Receipt Line No." := 0;
if GetSalesDocNo(TempDocSalesLine, TempFromSalesLineBuf."Line No.") <> OldBufDocNo then begin
OldBufDocNo := GetSalesDocNo(TempDocSalesLine, TempFromSalesLineBuf."Line No.");
TransferOldExtLines.ClearLineNumbers();
end;
OnCopySalesCrMemoLinesToDocOnBeforeCopySalesLine(ToSalesHeader, FromSalesLine2, TempFromSalesLineBuf);
if CopySalesDocLine(
ToSalesHeader, ToSalesLine, FromSalesHeader,
FromSalesLine2, NextLineNo, LinesNotCopied, TempFromSalesLineBuf."Return Receipt No." = '',
"Sales Document Type From"::"Posted Credit Memo", CopyPostedDeferral, GetSalesLineNo(TempDocSalesLine, FromSalesLine2."Line No."))
then begin
if CopyPostedDeferral then
CopySalesPostedDeferrals(ToSalesLine, "Deferral Document Type"::Sales,
DeferralTypeForSalesDoc("Sales Document Type From"::"Posted Credit Memo".AsInteger()), TempFromSalesLineBuf."Shipment No.",
TempFromSalesLineBuf."Return Receipt Line No.", ToSalesLine."Document Type".AsInteger(), ToSalesLine."Document No.", ToSalesLine."Line No.");
FromSalesCrMemoLine.Get(TempFromSalesLineBuf."Shipment No.", TempFromSalesLineBuf."Return Receipt Line No.");
// copy item charges
if TempFromSalesLineBuf.Type = TempFromSalesLineBuf.Type::"Charge (Item)" then begin
FromSalesLine.TransferFields(FromSalesCrMemoLine);
FromSalesLine."Document Type" := FromSalesLine."Document Type"::"Credit Memo";
CopyFromSalesLineItemChargeAssign(FromSalesLine, ToSalesLine, FromSalesHeader, ItemChargeAssgntNextLineNo);
end;
// copy item tracking
ShouldCopyItemTracking := (TempFromSalesLineBuf.Type = TempFromSalesLineBuf.Type::Item) and (TempFromSalesLineBuf.Quantity <> 0);
OnCopySalesCrMemoLinesToDocOnAfterCalcShouldCopyItemTracking(ToSalesHeader, ShouldCopyItemTracking, ToSalesLine);
if ShouldCopyItemTracking then begin
FromSalesCrMemoLine."Document No." := OldCrMemoDocNo;
FromSalesCrMemoLine."Line No." := TempFromSalesLineBuf."Return Receipt Line No.";
FromSalesCrMemoLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if IsCopyItemTrkg(TempItemLedgEntryBuf, CopyItemTrkg, FillExactCostRevLink) then begin
if MoveNegLines or not ExactCostRevMandatory then
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, TempItemLedgEntryBuf)
else
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, false, TempFromSalesLineBuf."Document No.", TempFromSalesLineBuf."Line No.");
ItemTrackingMgt.CopyItemLedgEntryTrkgToSalesLn(
TempTrkgItemLedgEntry, ToSalesLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromSalesHeader."Prices Including VAT", ToSalesHeader."Prices Including VAT", false);
OnCopySalesCrMemoLinesToDocOnAfterCopyItemLedgEntryTrkgToSalesLn(ToSalesLine);
end;
end;
OnAfterCopySalesLineFromSalesCrMemoLineBuffer(
ToSalesLine, FromSalesCrMemoLine, IncludeHeader, RecalculateLines, TempDocSalesLine, ToSalesHeader, TempFromSalesLineBuf, FromSalesLine);
end;
until TempFromSalesLineBuf.Next() = 0;
end;
CloseWindow();
OnAfterCopySalesCrMemoLinesToDoc(ToSalesHeader, FromSalesCrMemoLine, LinesNotCopied, MissingExCostRevLink);
end;
procedure CopySalesReturnRcptLinesToDoc(ToSalesHeader: Record "Sales Header"; var FromReturnRcptLine: Record "Return Receipt Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
ItemLedgEntry: Record "Item Ledger Entry";
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromSalesHeader: Record "Sales Header";
FromSalesLine: Record "Sales Line";
ToSalesLine: Record "Sales Line";
TempFromSalesLineBuf: Record "Sales Line" temporary;
FromReturnRcptHeader: Record "Return Receipt Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocSalesLine: Record "Sales Line" temporary;
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
CopyLine: Boolean;
InsertDocNoLine: Boolean;
begin
MissingExCostRevLink := false;
InitCurrency(ToSalesHeader."Currency Code");
OpenWindow();
OnBeforeCopySalesReturnRcptLinesToDoc(TempDocSalesLine, ToSalesHeader, FromReturnRcptLine);
if FromReturnRcptLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromReturnRcptHeader."No." <> FromReturnRcptLine."Document No." then begin
FromReturnRcptHeader.Get(FromReturnRcptLine."Document No.");
TransferOldExtLines.ClearLineNumbers();
end;
OnCopySalesReturnRcptLinesToDocOnBeforeFromSalesHeaderTransferFields(FromReturnRcptHeader, FromSalesHeader, ToSalesHeader, FromReturnRcptLine);
FromSalesHeader.TransferFields(FromReturnRcptHeader);
OnCopySalesReturnRcptLinesToDocOnAfterFromSalesHeaderTransferFields(FromReturnRcptHeader, FromSalesHeader);
FillExactCostRevLink :=
IsSalesFillExactCostRevLink(ToSalesHeader, 2, FromSalesHeader."Currency Code");
FromSalesLine.TransferFields(FromReturnRcptLine);
FromSalesLine."Appl.-from Item Entry" := 0;
FromSalesLine."Copied From Posted Doc." := true;
CheckUpdateOldDocumentNoFromReturnRcptLine(FromReturnRcptLine, OldDocNo, InsertDocNoLine);
OnBeforeCopySalesReturnRcptLinesToBuffer(FromSalesLine, FromReturnRcptLine, ToSalesHeader);
SplitLine := true;
FromReturnRcptLine.FilterPstdDocLnItemLedgEntries(ItemLedgEntry);
if not SplitPstdSalesLinesPerILE(
ToSalesHeader, FromSalesHeader, ItemLedgEntry, TempFromSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, true)
then
if CopyItemTrkg then
SplitLine :=
SplitSalesDocLinesPerItemTrkg(
ItemLedgEntry, TempItemTrkgEntry, TempFromSalesLineBuf,
FromSalesLine, TempDocSalesLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, true)
else
SplitLine := false;
if not SplitLine then begin
TempFromSalesLineBuf := FromSalesLine;
CopyLine := true;
end else
CopyLine := TempFromSalesLineBuf.FindSet() and FillExactCostRevLink;
UpdateWindow(1, FromLineCounter);
OnCopySalesReturnRcptLinesToDocOnBeforeCopyLines(ToSalesHeader, FromReturnRcptLine, TempFromSalesLineBuf);
if CopyLine then begin
NextLineNo := GetLastToSalesLineNo(ToSalesHeader);
OnCopySalesReturnRcptLinesToDocOnAfterCalcNextLineNo(ToSalesHeader, FromReturnRcptLine, FromSalesHeader, NextLineNo, InsertDocNoLine, FromLineCounter, TempFromSalesLineBuf);
if InsertDocNoLine then begin
InsertOldSalesDocNoLine(ToSalesHeader, FromReturnRcptLine."Document No.", 3, NextLineNo);
InsertDocNoLine := false;
end;
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
OnCopySalesReturnRcptLinesToDocOnBeforeCopySalesDocLine(ToSalesHeader, TempFromSalesLineBuf, CopyItemTrkg);
if CopySalesDocLine(
ToSalesHeader, ToSalesLine, FromSalesHeader, TempFromSalesLineBuf, NextLineNo, LinesNotCopied, false,
"Sales Document Type From"::"Posted Return Receipt", CopyPostedDeferral, TempFromSalesLineBuf."Line No.")
then begin
if CopyItemTrkg then begin
if SplitLine then
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, false, TempFromSalesLineBuf."Document No.", TempFromSalesLineBuf."Line No.")
else
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, ItemLedgEntry);
ItemTrackingMgt.CopyItemLedgEntryTrkgToSalesLn(
TempTrkgItemLedgEntry, ToSalesLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromSalesHeader."Prices Including VAT", ToSalesHeader."Prices Including VAT", true);
end;
OnAfterCopySalesLineFromReturnRcptLineBuffer(
ToSalesLine, FromReturnRcptLine, IncludeHeader, RecalculateLines,
TempDocSalesLine, ToSalesHeader, TempFromSalesLineBuf, CopyItemTrkg);
end;
until TempFromSalesLineBuf.Next() = 0
end;
OnCopySalesReturnRcptLinesToDocOnAfterCopySalesDocLine(FromReturnRcptLine, ToSalesLine);
until FromReturnRcptLine.Next() = 0;
CloseWindow();
OnAfterCopySalesReturnRcptLinesToDoc(ToSalesHeader, FromReturnRcptLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CheckUpdateOldDocumentNoFromReturnRcptLine(FromReturnRcptLine: Record "Return Receipt Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckUpdateOldDocumentNoFromReturnRcptLine(FromReturnRcptLine, OldDocNo, InsertDocNoLine, IsHandled);
if IsHandled then
exit;
if FromReturnRcptLine."Document No." <> OldDocNo then begin
OldDocNo := FromReturnRcptLine."Document No.";
InsertDocNoLine := true;
end;
end;
local procedure CopySalesLinesToBuffer(FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; var FromSalesLine2: Record "Sales Line"; var TempSalesLineBuf: Record "Sales Line" temporary; ToSalesHeader: Record "Sales Header"; var TempDocSalesLine: Record "Sales Line" temporary; DocNo: Code[20]; var NextLineNo: Integer)
begin
FromSalesLine2 := TempSalesLineBuf;
TempSalesLineBuf := FromSalesLine;
TempSalesLineBuf."Document No." := '';
TempSalesLineBuf."Line No." := NextLineNo;
OnAfterCopySalesLinesToBufferFields(TempSalesLineBuf, FromSalesLine2, FromSalesLine);
NextLineNo := NextLineNo + 10000;
if not IsRecalculateAmount(
FromSalesHeader."Currency Code", ToSalesHeader."Currency Code",
FromSalesHeader."Prices Including VAT", ToSalesHeader."Prices Including VAT")
then
TempSalesLineBuf."Return Receipt No." := DocNo;
ReCalcSalesLine(FromSalesHeader, ToSalesHeader, TempSalesLineBuf);
OnCopySalesLinesToBufferTransferFields(FromSalesHeader, FromSalesLine, TempSalesLineBuf);
TempSalesLineBuf.Insert();
AddSalesDocLine(TempDocSalesLine, TempSalesLineBuf."Line No.", DocNo, FromSalesLine."Line No.");
end;
local procedure CopyItemLedgEntryTrackingToSalesLine(var TempItemLedgEntry: Record "Item Ledger Entry" temporary; var TempReservationEntry: Record "Reservation Entry" temporary; TempFromSalesLine: Record "Sales Line" temporary; ToSalesLine: Record "Sales Line"; ToSalesPricesInctVAT: Boolean; FromSalesPricesInctVAT: Boolean; FillExactCostRevLink: Boolean; var MissingExCostRevLink: Boolean)
var
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
AssemblyHeader: Record "Assembly Header";
ItemTrackingMgt: Codeunit "Item Tracking Management";
begin
if MoveNegLines or not ExactCostRevMandatory then
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, TempItemLedgEntry)
else
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempReservationEntry, TempTrkgItemLedgEntry, false, TempFromSalesLine."Document No.", TempFromSalesLine."Line No.");
if ToSalesLine.AsmToOrderExists(AssemblyHeader) then
SetTrackingOnAssemblyReservation(AssemblyHeader, TempItemLedgEntry)
else
ItemTrackingMgt.CopyItemLedgEntryTrkgToSalesLn(
TempTrkgItemLedgEntry, ToSalesLine, FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromSalesPricesInctVAT, ToSalesPricesInctVAT, false);
end;
procedure SplitPstdSalesLinesPerILE(ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; var ItemLedgEntry: Record "Item Ledger Entry"; var TempSalesLineBuf: Record "Sales Line" temporary; FromSalesLine: Record "Sales Line"; var TempDocSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer; var CopyItemTrkg: Boolean; var MissingExCostRevLink: Boolean; FillExactCostRevLink: Boolean; FromShptOrRcpt: Boolean) Result: Boolean
var
OrgQtyBase: Decimal;
OneRecord: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSplitPstdSalesLinesPerILE(ToSalesHeader, FromSalesHeader, FromSalesLine, TempSalesLineBuf, FromShptOrRcpt, IsHandled);
if IsHandled then
exit(Result);
if FromShptOrRcpt then begin
TempSalesLineBuf.Reset();
TempSalesLineBuf.DeleteAll();
end else
TempSalesLineBuf.Init();
CopyItemTrkg := false;
if (FromSalesLine.Type <> FromSalesLine.Type::Item) or (FromSalesLine.Quantity = 0) then
exit(false);
if IsCopyItemTrkg(ItemLedgEntry, CopyItemTrkg, FillExactCostRevLink) or
not FillExactCostRevLink or MoveNegLines or
not ExactCostRevMandatory
then
exit(false);
OneRecord := ItemLedgEntry.count() = 1;
ItemLedgEntry.FindSet();
if ItemLedgEntry.Quantity >= 0 then begin
TempSalesLineBuf."Document No." := ItemLedgEntry."Document No.";
if GetSalesDocTypeForItemLedgEntry(ItemLedgEntry) in
[TempSalesLineBuf."Document Type"::Order, TempSalesLineBuf."Document Type"::"Return Order"]
then
TempSalesLineBuf."Shipment Line No." := 1;
OnSplitPstdSalesLinesPerILEOnAfterAssignShipmentLineNo(ItemLedgEntry, TempSalesLineBuf);
exit(false);
end;
OrgQtyBase := FromSalesLine."Quantity (Base)";
repeat
OnSplitPstdSalesLinesPerILEOnBeforeItemLedgEntryLoop(ItemLedgEntry, FromSalesLine);
if ItemLedgEntry."Shipped Qty. Not Returned" = 0 then
SkippedLine := true;
if ItemLedgEntry."Shipped Qty. Not Returned" < 0 then begin
TempSalesLineBuf := FromSalesLine;
if -ItemLedgEntry."Shipped Qty. Not Returned" < Abs(FromSalesLine."Quantity (Base)") then begin
if FromSalesLine."Quantity (Base)" > 0 then
TempSalesLineBuf."Quantity (Base)" := -ItemLedgEntry."Shipped Qty. Not Returned"
else
TempSalesLineBuf."Quantity (Base)" := ItemLedgEntry."Shipped Qty. Not Returned";
if TempSalesLineBuf."Qty. per Unit of Measure" = 0 then
TempSalesLineBuf.Quantity := TempSalesLineBuf."Quantity (Base)"
else
TempSalesLineBuf.Quantity :=
Round(
TempSalesLineBuf."Quantity (Base)" / TempSalesLineBuf."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision());
end;
FromSalesLine."Quantity (Base)" := FromSalesLine."Quantity (Base)" - TempSalesLineBuf."Quantity (Base)";
FromSalesLine.Quantity := FromSalesLine.Quantity - TempSalesLineBuf.Quantity;
TempSalesLineBuf."Appl.-from Item Entry" := ItemLedgEntry."Entry No.";
NextLineNo := NextLineNo + 1;
TempSalesLineBuf."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
TempSalesLineBuf."Document No." := ItemLedgEntry."Document No.";
if GetSalesDocTypeForItemLedgEntry(ItemLedgEntry) in
[TempSalesLineBuf."Document Type"::Order, TempSalesLineBuf."Document Type"::"Return Order"]
then
TempSalesLineBuf."Shipment Line No." := 1;
if not FromShptOrRcpt then
UpdateRevSalesLineAmount(
TempSalesLineBuf, OrgQtyBase,
FromSalesHeader."Prices Including VAT", ToSalesHeader."Prices Including VAT");
OnSplitPstdSalesLinesPerILETransferFields(FromSalesHeader, FromSalesLine, TempSalesLineBuf, ToSalesHeader, ItemLedgEntry);
TempSalesLineBuf.Insert();
if OneRecord then
AddSalesDocLine(TempDocSalesLine, TempSalesLineBuf."Line No.", FromSalesLine."Document No.", FromSalesLine."Line No.")
else
AddSalesDocLine(TempDocSalesLine, TempSalesLineBuf."Line No.", ItemLedgEntry."Document No.", TempSalesLineBuf."Line No.");
end;
until (ItemLedgEntry.Next() = 0) or (FromSalesLine."Quantity (Base)" = 0);
if (FromSalesLine."Quantity (Base)" <> 0) and FillExactCostRevLink then
MissingExCostRevLink := true;
OnSplitPstdSalesLinesPerILEOnBeforeCheckUnappliedLines(ToSalesHeader, SkippedLine, MissingExCostRevLink);
CheckUnappliedLines(SkippedLine, MissingExCostRevLink);
exit(true);
end;
local procedure SplitSalesDocLinesPerItemTrkg(var ItemLedgEntry: Record "Item Ledger Entry"; var TempItemTrkgEntry: Record "Reservation Entry" temporary; var TempSalesLineBuf: Record "Sales Line" temporary; FromSalesLine: Record "Sales Line"; var TempDocSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer; var NextItemTrkgEntryNo: Integer; var MissingExCostRevLink: Boolean; FromShptOrRcpt: Boolean): Boolean
var
SalesLineBuf: array[2] of Record "Sales Line" temporary;
Tracked: Boolean;
ReversibleQtyBase: Decimal;
SignFactor: Integer;
i: Integer;
Result: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSplitSalesDocLinesPerItemTrkg(ItemLedgEntry, TempItemTrkgEntry, TempSalesLineBuf, FromSalesLine, TempDocSalesLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, FromShptOrRcpt, Result, IsHandled);
if IsHandled then
exit(Result);
if FromShptOrRcpt then begin
TempSalesLineBuf.Reset();
TempSalesLineBuf.DeleteAll();
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.DeleteAll();
end else
TempSalesLineBuf.Init();
if MoveNegLines or not ExactCostRevMandatory then
exit(false);
if FromSalesLine."Quantity (Base)" < 0 then
SignFactor := -1
else
SignFactor := 1;
OnSplitSalesDocLinesPerItemTrkgOnAfterCalcSignFactor(FromSalesLine, SignFactor);
ItemLedgEntry.SetCurrentKey("Document No.", "Document Type", "Document Line No.");
ItemLedgEntry.FindSet();
repeat
SalesLineBuf[1] := FromSalesLine;
SalesLineBuf[1]."Line No." := NextLineNo;
SalesLineBuf[1]."Quantity (Base)" := 0;
SalesLineBuf[1].Quantity := 0;
SalesLineBuf[1]."Document No." := ItemLedgEntry."Document No.";
if GetSalesDocTypeForItemLedgEntry(ItemLedgEntry) in
[SalesLineBuf[1]."Document Type"::Order, SalesLineBuf[1]."Document Type"::"Return Order"]
then
SalesLineBuf[1]."Shipment Line No." := 1;
OnSplitSalesDocLinesPerItemTrkgOnAfterInitSalesLineBuf1(SalesLineBuf[1], ItemLedgEntry);
SalesLineBuf[2] := SalesLineBuf[1];
SalesLineBuf[2]."Line No." := SalesLineBuf[2]."Line No." + 1;
if not FromShptOrRcpt then begin
ItemLedgEntry.SetRange("Document No.", ItemLedgEntry."Document No.");
ItemLedgEntry.SetRange("Document Type", ItemLedgEntry."Document Type");
ItemLedgEntry.SetRange("Document Line No.", ItemLedgEntry."Document Line No.");
end;
repeat
i := 1;
CalcReversibleQtyBaseSalesDoc(ItemLedgEntry, FromSalesLine, SalesLineBuf, TempItemTrkgEntry, ReversibleQtyBase, SignFactor);
if ReversibleQtyBase <> 0 then begin
if not FromShptOrRcpt then
if not ItemLedgEntry.Positive then
if IsSplitItemLedgEntry(ItemLedgEntry) then
i := 2;
UpdateSalesLineQtyBaseFromReversibleQtyBase(FromSalesLine, SalesLineBuf[i], ReversibleQtyBase);
// Fill buffer with exact cost reversing link
InsertTempReservationEntry(
ItemLedgEntry, TempItemTrkgEntry, -Abs(ReversibleQtyBase),
SalesLineBuf[i]."Line No.", NextItemTrkgEntryNo, true);
Tracked := true;
end;
until (ItemLedgEntry.Next() = 0) or (FromSalesLine."Quantity (Base)" = 0);
for i := 1 to 2 do
if SalesLineBuf[i]."Quantity (Base)" <> 0 then begin
TempSalesLineBuf := SalesLineBuf[i];
TempSalesLineBuf.Insert();
AddSalesDocLine(TempDocSalesLine, TempSalesLineBuf."Line No.", ItemLedgEntry."Document No.", TempSalesLineBuf."Line No.");
NextLineNo := SalesLineBuf[i]."Line No." + 1;
end;
if not FromShptOrRcpt then begin
ItemLedgEntry.SetRange("Document No.");
ItemLedgEntry.SetRange("Document Type");
ItemLedgEntry.SetRange("Document Line No.");
end;
until (ItemLedgEntry.Next() = 0) or FromShptOrRcpt;
if (FromSalesLine."Quantity (Base)" <> 0) and not Tracked then
MissingExCostRevLink := true;
CheckUnappliedLines(SkippedLine, MissingExCostRevLink);
exit(true);
end;
local procedure CalcReversibleQtyBaseSalesDoc(var ItemLedgEntry: Record "Item Ledger Entry"; FromSalesLine: Record "Sales Line"; var SalesLineBuf: array[2] of Record "Sales Line" temporary; var TempItemTrkgEntry: Record "Reservation Entry" temporary; var ReversibleQtyBase: Decimal; SignFactor: Integer)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcReversibleQtyBaseSalesDoc(FromSalesLine, ItemLedgEntry, ReversibleQtyBase, IsHandled);
if IsHandled then
exit;
if not ItemLedgEntry.Positive then
ItemLedgEntry."Shipped Qty. Not Returned" :=
ItemLedgEntry."Shipped Qty. Not Returned" -
CalcDistributedQty(TempItemTrkgEntry, ItemLedgEntry, SalesLineBuf[2]."Line No." + 1);
if ItemLedgEntry."Shipped Qty. Not Returned" = 0 then
SkippedLine := true;
if ItemLedgEntry."Document Type" in [ItemLedgEntry."Document Type"::"Sales Return Receipt", ItemLedgEntry."Document Type"::"Sales Credit Memo"] then
if ItemLedgEntry."Remaining Quantity" < FromSalesLine."Quantity (Base)" * SignFactor then
ReversibleQtyBase := ItemLedgEntry."Remaining Quantity" * SignFactor
else
ReversibleQtyBase := FromSalesLine."Quantity (Base)"
else
if ItemLedgEntry.Positive then begin
ReversibleQtyBase := ItemLedgEntry."Remaining Quantity";
if ReversibleQtyBase < FromSalesLine."Quantity (Base)" * SignFactor then
ReversibleQtyBase := ReversibleQtyBase * SignFactor
else
ReversibleQtyBase := FromSalesLine."Quantity (Base)";
end else
if -ItemLedgEntry."Shipped Qty. Not Returned" < FromSalesLine."Quantity (Base)" * SignFactor then
ReversibleQtyBase := -ItemLedgEntry."Shipped Qty. Not Returned" * SignFactor
else
ReversibleQtyBase := FromSalesLine."Quantity (Base)";
end;
local procedure UpdateSalesLineQtyBaseFromReversibleQtyBase(var FromSalesLine: Record "Sales Line"; var SalesLineBuf: Record "Sales Line" temporary; ReversibleQtyBase: Decimal)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdateSalesLineQtyBaseFromReversibleQtyBase(FromSalesLine, SalesLineBuf, ReversibleQtyBase, IsHandled);
if IsHandled then
exit;
SalesLineBuf."Quantity (Base)" := SalesLineBuf."Quantity (Base)" + ReversibleQtyBase;
if SalesLineBuf."Qty. per Unit of Measure" = 0 then
SalesLineBuf.Quantity := SalesLineBuf."Quantity (Base)"
else
SalesLineBuf.Quantity :=
Round(
SalesLineBuf."Quantity (Base)" / SalesLineBuf."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision());
FromSalesLine."Quantity (Base)" := FromSalesLine."Quantity (Base)" - ReversibleQtyBase;
end;
procedure CopyPurchRcptLinesToDoc(ToPurchHeader: Record "Purchase Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
ItemLedgEntry: Record "Item Ledger Entry";
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromPurchHeader: Record "Purchase Header";
FromPurchLine: Record "Purchase Line";
OriginalPurchHeader: Record "Purchase Header";
ToPurchLine: Record "Purchase Line";
TempFromPurchLineBuf: Record "Purchase Line" temporary;
FromPurchRcptHeader: Record "Purch. Rcpt. Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocPurchaseLine: Record "Purchase Line" temporary;
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
CopyItemTrkg: Boolean;
FillExactCostRevLink: Boolean;
SplitLine: Boolean;
CopyLine: Boolean;
InsertDocNoLine: Boolean;
IsHandled: Boolean;
begin
OnBeforeCopyPurchRcptLinesToDoc(ToPurchHeader, FromPurchRcptLine);
MissingExCostRevLink := false;
InitCurrency(ToPurchHeader."Currency Code");
OpenWindow();
if FromPurchRcptLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromPurchRcptHeader."No." <> FromPurchRcptLine."Document No." then begin
FromPurchRcptHeader.Get(FromPurchRcptLine."Document No.");
IsHandled := false;
OnCopyPurchRcptLinesToDocOnBeforeTestFieldPricesIncludingVAT(ToPurchHeader, IncludeHeader, RecalculateLines, FromPurchRcptHeader, IsHandled);
if not IsHandled then
if OriginalPurchHeader.Get(OriginalPurchHeader."Document Type"::Order, FromPurchRcptHeader."Order No.") then
OriginalPurchHeader.TestField("Prices Including VAT", ToPurchHeader."Prices Including VAT");
TransferOldExtLines.ClearLineNumbers();
end;
FromPurchHeader.TransferFields(FromPurchRcptHeader);
FillExactCostRevLink :=
IsPurchFillExactCostRevLink(ToPurchHeader, 0, FromPurchHeader."Currency Code");
FromPurchLine.TransferFields(FromPurchRcptLine);
FromPurchLine."Appl.-to Item Entry" := 0;
FromPurchLine."Copied From Posted Doc." := true;
OnCopyPurchRcptLinesToDocOnAfterTransferFields(FromPurchLine, FromPurchHeader, ToPurchHeader, FromPurchRcptHeader, FromPurchRcptLine, RecalculateLines);
CheckUpdateOldDocumentNoFromPurchRcptLine(FromPurchRcptLine, OldDocNo, InsertDocNoLine);
SplitLine := true;
FromPurchRcptLine.FilterPstdDocLnItemLedgEntries(ItemLedgEntry);
OnCopyPurchRcptLinesToDocOnAfterFilterPstdDocLnItemLedgEntries(FromPurchLine, ItemLedgEntry);
if not SplitPstdPurchLinesPerILE(
ToPurchHeader, FromPurchHeader, ItemLedgEntry, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, true)
then
if CopyItemTrkg then
SplitLine :=
SplitPurchDocLinesPerItemTrkg(
ItemLedgEntry, TempItemTrkgEntry, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, true)
else
SplitLine := false;
if not SplitLine then begin
TempFromPurchLineBuf := FromPurchLine;
CopyLine := true;
end else
CopyLine := TempFromPurchLineBuf.FindSet() and FillExactCostRevLink;
UpdateWindow(1, FromLineCounter);
if CopyLine then begin
NextLineNo := GetLastToPurchLineNo(ToPurchHeader);
OnCopyPurchRcptLinesToDocOnBeforeCheckInsertDocNoLine(ToPurchHeader, FromPurchRcptLine, FromPurchHeader, NextLineNo, InsertDocNoLine);
if InsertDocNoLine then begin
InsertOldPurchDocNoLine(ToPurchHeader, FromPurchRcptLine."Document No.", 1, NextLineNo);
InsertDocNoLine := false;
end;
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
if FromPurchLine.IsProdOrder() then
FromPurchLine."Quantity (Base)" := 0;
OnCopyPurchRcptLinesToDocOnBeforeCopyPurchLine(ToPurchHeader, TempFromPurchLineBuf, CopyItemTrkg);
if CopyPurchDocLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, TempFromPurchLineBuf, NextLineNo, LinesNotCopied, false,
"Purchase Document Type From"::"Posted Receipt", CopyPostedDeferral, TempFromPurchLineBuf."Line No.")
then begin
OnCopyPurchRcptLinesToDocOnBeforeCopyItemTrkg(ToPurchHeader, ToPurchLine, TempFromPurchLineBuf, RecalculateLines);
if CopyItemTrkg then begin
if SplitLine then
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, true, TempFromPurchLineBuf."Document No.", TempFromPurchLineBuf."Line No.")
else
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, ItemLedgEntry);
ItemTrackingMgt.CopyItemLedgEntryTrkgToPurchLn(
TempTrkgItemLedgEntry, ToPurchLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT", true);
end;
OnAfterCopyPurchLineFromPurchRcptLineBuffer(
ToPurchLine, FromPurchRcptLine, IncludeHeader, RecalculateLines,
TempDocPurchaseLine, ToPurchHeader, TempFromPurchLineBuf, CopyItemTrkg, NextLineNo);
end;
until TempFromPurchLineBuf.Next() = 0;
OnAfterCopyPurchRcptLine(FromPurchRcptLine, ToPurchLine);
end;
until FromPurchRcptLine.Next() = 0;
CloseWindow();
OnAfterCopyPurchRcptLinesToDoc(ToPurchHeader, FromPurchRcptLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CheckUpdateOldDocumentNoFromPurchRcptLine(FromPurchRcptLine: Record "Purch. Rcpt. Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckUpdateOldDocumentNoFromPurchRcptLine(FromPurchRcptLine, OldDocNo, InsertDocNoLine, IsHandled);
if IsHandled then
exit;
if FromPurchRcptLine."Document No." <> OldDocNo then begin
OldDocNo := FromPurchRcptLine."Document No.";
InsertDocNoLine := true;
end;
end;
procedure CopyPurchInvLinesToDoc(ToPurchHeader: Record "Purchase Header"; var FromPurchInvLine: Record "Purch. Inv. Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
TempItemLedgEntryBuf: Record "Item Ledger Entry" temporary;
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromPurchHeader: Record "Purchase Header";
FromPurchLine: Record "Purchase Line";
FromPurchLine2: Record "Purchase Line";
ToPurchLine: Record "Purchase Line";
TempFromPurchLineBuf: Record "Purchase Line" temporary;
FromPurchInvHeader: Record "Purch. Inv. Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocPurchaseLine: Record "Purchase Line" temporary;
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldInvDocNo: Code[20];
OldRcptDocNo: Code[20];
OldBufDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
ItemChargeAssgntNextLineNo: Integer;
ShouldInsertOldPurchDocNoLine: Boolean;
ShouldCopyItemTrackingEntries: Boolean;
IsHandled: Boolean;
begin
MissingExCostRevLink := false;
InitCurrency(ToPurchHeader."Currency Code");
TempFromPurchLineBuf.Reset();
TempFromPurchLineBuf.DeleteAll();
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.DeleteAll();
OpenWindow();
OnBeforeCopyPurchInvLines(TempDocPurchaseLine, ToPurchHeader, FromPurchInvLine);
// Fill purchase line buffer
if FromPurchInvLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromPurchInvHeader."No." <> FromPurchInvLine."Document No." then begin
FromPurchInvHeader.Get(FromPurchInvLine."Document No.");
IsHandled := false;
OnCopyPurchInvLinesToDocOnBeforeTestFieldPricesIncludingVAT(ToPurchHeader, IncludeHeader, RecalculateLines, FromPurchInvHeader, IsHandled);
if not IsHandled then
FromPurchInvHeader.TestField("Prices Including VAT", ToPurchHeader."Prices Including VAT");
TransferOldExtLines.ClearLineNumbers();
end;
FromPurchHeader.TransferFields(FromPurchInvHeader);
FillExactCostRevLink := IsPurchFillExactCostRevLink(ToPurchHeader, 1, FromPurchHeader."Currency Code");
FromPurchLine.TransferFields(FromPurchInvLine);
FromPurchLine."Appl.-to Item Entry" := 0;
// Reuse fields to buffer invoice line information
FromPurchLine."Receipt No." := FromPurchInvLine."Document No.";
FromPurchLine."Receipt Line No." := 0;
FromPurchLine."Return Shipment No." := '';
FromPurchLine."Return Shipment Line No." := FromPurchInvLine."Line No.";
FromPurchLine."Copied From Posted Doc." := true;
OnCopyPurchInvLinesToDocOnAfterTransferFields(FromPurchLine, FromPurchHeader, ToPurchHeader, FromPurchInvHeader, FromPurchInvLine, RecalculateLines);
SplitLine := true;
FromPurchInvLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if not SplitPstdPurchLinesPerILE(
ToPurchHeader, FromPurchHeader, TempItemLedgEntryBuf, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, false)
then
if CopyItemTrkg then
SplitLine := SplitPurchDocLinesPerItemTrkg(
TempItemLedgEntryBuf, TempItemTrkgEntry, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, false)
else
SplitLine := false;
if not SplitLine then
CopyPurchLinesToBuffer(
FromPurchHeader, FromPurchLine, FromPurchLine2, TempFromPurchLineBuf, ToPurchHeader, TempDocPurchaseLine,
FromPurchInvLine."Document No.", NextLineNo);
if TempFromPurchLineBuf."Receipt Line No." <> 0 then
SkipOldInvoiceDescription(true);
OnAfterCopyPurchInvLines(TempDocPurchaseLine, ToPurchHeader, TempFromPurchLineBuf, FromPurchInvLine);
until FromPurchInvLine.Next() = 0;
OnCopyPurchInvLinesToDocOnAfterFillPurchLineBuffer(ToPurchHeader);
// Create purchase line from buffer
UpdateWindow(1, FromLineCounter);
// Sorting according to Purchase Line Document No.,Line No.
TempFromPurchLineBuf.SetCurrentKey("Line No.");
if TempFromPurchLineBuf.FindSet() then begin
NextLineNo := GetLastToPurchLineNo(ToPurchHeader);
Clear(OldBufDocNo);
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
IsHandled := false;
OnCopyPurchInvLinesToDocOnBeforeInsertOldPurchLine(ToPurchHeader, TempFromPurchLineBuf, OldInvDocNo, OldRcptDocNo, NextLineNo, SkipCopyFromDescription, InsertCancellationLine, IsHandled);
if not IsHandled then begin
ShouldInsertOldPurchDocNoLine := TempFromPurchLineBuf."Receipt No." <> OldInvDocNo;
OnCopyPurchInvLinesToDocOnAfterCalcShouldInsertOldPurchDocNoLine(ToPurchHeader, FromPurchInvHeader, FromPurchHeader, NextLineNo, OldInvDocNo, OldRcptDocNo, ShouldInsertOldPurchDocNoLine);
if ShouldInsertOldPurchDocNoLine then begin
OldInvDocNo := TempFromPurchLineBuf."Receipt No.";
OldRcptDocNo := '';
InsertOldPurchDocNoLine(ToPurchHeader, OldInvDocNo, 2, NextLineNo);
end;
if (TempFromPurchLineBuf."Document No." <> OldRcptDocNo) and (TempFromPurchLineBuf."Receipt Line No." > 0) then begin
OldRcptDocNo := TempFromPurchLineBuf."Document No.";
InsertOldPurchCombDocNoLine(ToPurchHeader, OldInvDocNo, OldRcptDocNo, NextLineNo, true);
end;
end;
// Empty buffer fields
FromPurchLine2 := TempFromPurchLineBuf;
FromPurchLine2."Receipt No." := '';
FromPurchLine2."Receipt Line No." := 0;
FromPurchLine2."Return Shipment No." := '';
FromPurchLine2."Return Shipment Line No." := 0;
if GetPurchDocNo(TempDocPurchaseLine, TempFromPurchLineBuf."Line No.") <> OldBufDocNo then begin
OldBufDocNo := GetPurchDocNo(TempDocPurchaseLine, TempFromPurchLineBuf."Line No.");
TransferOldExtLines.ClearLineNumbers();
end;
OnCopyPurchInvLinesToDocOnBeforeCopyPurchLine(ToPurchHeader, FromPurchLine2, TempFromPurchLineBuf);
if CopyPurchDocLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine2, NextLineNo, LinesNotCopied,
TempFromPurchLineBuf."Return Shipment No." = '',
"Purchase Document Type From"::"Posted Invoice", CopyPostedDeferral, GetPurchLineNo(TempDocPurchaseLine, FromPurchLine2."Line No."))
then begin
if CopyPostedDeferral then
CopyPurchPostedDeferrals(
ToPurchLine, "Deferral Document Type"::Purchase,
DeferralTypeForPurchDoc("Purchase Document Type From"::"Posted Invoice".AsInteger()), TempFromPurchLineBuf."Receipt No.",
TempFromPurchLineBuf."Return Shipment Line No.", ToPurchLine."Document Type".AsInteger(), ToPurchLine."Document No.", ToPurchLine."Line No.");
FromPurchInvLine.Get(TempFromPurchLineBuf."Receipt No.", TempFromPurchLineBuf."Return Shipment Line No.");
OnCopyPurchInvLinesToDocOnBeforeCopyItemCharges(FromPurchInvLine, NextLineNo, ToPurchLine, TempDocPurchaseLine, RecalculateLines);
// copy item charges
if TempFromPurchLineBuf.Type = TempFromPurchLineBuf.Type::"Charge (Item)" then begin
FromPurchLine.TransferFields(FromPurchInvLine);
FromPurchLine."Document Type" := FromPurchLine."Document Type"::Invoice;
CopyFromPurchLineItemChargeAssign(FromPurchLine, ToPurchLine, FromPurchHeader, ItemChargeAssgntNextLineNo);
end;
// copy item tracking
ShouldCopyItemTrackingEntries := (TempFromPurchLineBuf.Type = TempFromPurchLineBuf.Type::Item) and (TempFromPurchLineBuf.Quantity <> 0) and (not TempFromPurchLineBuf.IsProdOrder()) and PurchaseDocCanReceiveTracking(ToPurchHeader);
OnCopyPurchInvLinesToDocOnAfterCalcShouldCopyItemTrackingEntries(ToPurchLine, ShouldCopyItemTrackingEntries);
if ShouldCopyItemTrackingEntries then begin
FromPurchInvLine."Document No." := OldInvDocNo;
FromPurchInvLine."Line No." := TempFromPurchLineBuf."Return Shipment Line No.";
FromPurchInvLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if IsCopyItemTrkg(TempItemLedgEntryBuf, CopyItemTrkg, FillExactCostRevLink) then begin
if TempFromPurchLineBuf."Job No." <> '' then
TempItemLedgEntryBuf.SetFilter("Entry Type", '<> %1', TempItemLedgEntryBuf."Entry Type"::"Negative Adjmt.");
if MoveNegLines or not ExactCostRevMandatory then
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, TempItemLedgEntryBuf)
else
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, true, TempFromPurchLineBuf."Document No.", TempFromPurchLineBuf."Line No.");
ItemTrackingMgt.CopyItemLedgEntryTrkgToPurchLn(TempTrkgItemLedgEntry, ToPurchLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT", false);
end;
end;
OnAfterCopyPurchLineFromPurchLineBuffer(
ToPurchLine, FromPurchInvLine, IncludeHeader, RecalculateLines, TempDocPurchaseLine, ToPurchHeader, TempFromPurchLineBuf);
end;
OnAfterCopyPurchInvLine(FromPurchInvLine, ToPurchLine, ToPurchHeader);
until TempFromPurchLineBuf.Next() = 0;
end;
CloseWindow();
OnAfterCopyPurchInvLinesToDoc(ToPurchHeader, FromPurchInvLine, LinesNotCopied, MissingExCostRevLink);
end;
procedure CopyPurchCrMemoLinesToDoc(ToPurchHeader: Record "Purchase Header"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
TempItemLedgEntryBuf: Record "Item Ledger Entry" temporary;
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromPurchHeader: Record "Purchase Header";
FromPurchLine: Record "Purchase Line";
FromPurchLine2: Record "Purchase Line";
ToPurchLine: Record "Purchase Line";
TempFromPurchLineBuf: Record "Purchase Line" temporary;
FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocPurchaseLine: Record "Purchase Line" temporary;
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldCrMemoDocNo: Code[20];
OldReturnShptDocNo: Code[20];
OldBufDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
ItemChargeAssgntNextLineNo: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
ShouldCopyItemTrackingEntries: Boolean;
IsHandled: Boolean;
begin
MissingExCostRevLink := false;
InitCurrency(ToPurchHeader."Currency Code");
TempFromPurchLineBuf.Reset();
TempFromPurchLineBuf.DeleteAll();
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.DeleteAll();
OpenWindow();
OnBeforeCopyPurchCrMemoLinesToDoc(TempDocPurchaseLine, ToPurchHeader, FromPurchCrMemoLine);
// Fill purchase line buffer
if FromPurchCrMemoLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromPurchCrMemoHeader."No." <> FromPurchCrMemoLine."Document No." then begin
FromPurchCrMemoHeader.Get(FromPurchCrMemoLine."Document No.");
IsHandled := false;
OnCopyPurchCrMemoLinesToDocOnBeforeTestFieldPricesIncludingVAT(ToPurchHeader, IncludeHeader, RecalculateLines, FromPurchCrMemoHeader, IsHandled);
if not IsHandled then
FromPurchCrMemoHeader.TestField("Prices Including VAT", ToPurchHeader."Prices Including VAT");
TransferOldExtLines.ClearLineNumbers();
end;
FromPurchHeader.TransferFields(FromPurchCrMemoHeader);
FillExactCostRevLink :=
IsPurchFillExactCostRevLink(ToPurchHeader, 3, FromPurchHeader."Currency Code");
FromPurchLine.TransferFields(FromPurchCrMemoLine);
FromPurchLine."Appl.-to Item Entry" := 0;
// Reuse fields to buffer credit memo line information
FromPurchLine."Receipt No." := FromPurchCrMemoLine."Document No.";
FromPurchLine."Receipt Line No." := 0;
FromPurchLine."Return Shipment No." := '';
FromPurchLine."Return Shipment Line No." := FromPurchCrMemoLine."Line No.";
FromPurchLine."Copied From Posted Doc." := true;
OnCopyPurchCrMemoLinesToDocOnAfterTransferFields(FromPurchLine, FromPurchHeader, ToPurchHeader, FromPurchCrMemoHeader, FromPurchCrMemoLine, RecalculateLines);
SplitLine := true;
FromPurchCrMemoLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if not SplitPstdPurchLinesPerILE(
ToPurchHeader, FromPurchHeader, TempItemLedgEntryBuf, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, false)
then
if CopyItemTrkg then
SplitLine :=
SplitPurchDocLinesPerItemTrkg(
TempItemLedgEntryBuf, TempItemTrkgEntry, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, false)
else
SplitLine := false;
if not SplitLine then
CopyPurchLinesToBuffer(
FromPurchHeader, FromPurchLine, FromPurchLine2, TempFromPurchLineBuf, ToPurchHeader, TempDocPurchaseLine,
FromPurchCrMemoLine."Document No.", NextLineNo);
OnCopyPurchCrMemoLinesToDocOnAfterFromPurchCrMemoLineLoop(TempDocPurchaseLine, ToPurchHeader, TempFromPurchLineBuf, FromPurchCrMemoLine, SplitLine);
until FromPurchCrMemoLine.Next() = 0;
OnCopyPurchCrMemoLinesToDocOnAfterFillPurchLineBuffer(ToPurchHeader);
// Create purchase line from buffer
UpdateWindow(1, FromLineCounter);
// Sorting according to Purchase Line Document No.,Line No.
TempFromPurchLineBuf.SetCurrentKey("Document Type", "Document No.", "Line No.");
if TempFromPurchLineBuf.FindSet() then begin
NextLineNo := GetLastToPurchLineNo(ToPurchHeader);
Clear(OldBufDocNo);
Clear(OldCrMemoDocNo);
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
if TempFromPurchLineBuf."Receipt No." <> OldCrMemoDocNo then begin
OldCrMemoDocNo := TempFromPurchLineBuf."Receipt No.";
OldReturnShptDocNo := '';
InsertOldPurchDocNoLine(ToPurchHeader, OldCrMemoDocNo, 4, NextLineNo);
end;
if TempFromPurchLineBuf."Document No." <> OldReturnShptDocNo then begin
OldReturnShptDocNo := TempFromPurchLineBuf."Document No.";
InsertOldPurchCombDocNoLine(ToPurchHeader, OldCrMemoDocNo, OldReturnShptDocNo, NextLineNo, false);
end;
// Empty buffer fields
FromPurchLine2 := TempFromPurchLineBuf;
FromPurchLine2."Receipt No." := '';
FromPurchLine2."Receipt Line No." := 0;
FromPurchLine2."Return Shipment No." := '';
FromPurchLine2."Return Shipment Line No." := 0;
if GetPurchDocNo(TempDocPurchaseLine, TempFromPurchLineBuf."Line No.") <> OldBufDocNo then begin
OldBufDocNo := GetPurchDocNo(TempDocPurchaseLine, TempFromPurchLineBuf."Line No.");
TransferOldExtLines.ClearLineNumbers();
end;
OnCopyPurchCrMemoLinesToDocOnBeforeCopyPurchLine(ToPurchHeader, FromPurchLine2);
if CopyPurchDocLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine2, NextLineNo, LinesNotCopied, TempFromPurchLineBuf."Return Shipment No." = '',
"Purchase Document Type From"::"Posted Credit Memo", CopyPostedDeferral, GetPurchLineNo(TempDocPurchaseLine, FromPurchLine2."Line No."))
then begin
if CopyPostedDeferral then
CopyPurchPostedDeferrals(
ToPurchLine, "Deferral Document Type"::Purchase,
DeferralTypeForPurchDoc("Purchase Document Type From"::"Posted Credit Memo".AsInteger()), TempFromPurchLineBuf."Receipt No.",
TempFromPurchLineBuf."Return Shipment Line No.", ToPurchLine."Document Type".AsInteger(), ToPurchLine."Document No.", ToPurchLine."Line No.");
FromPurchCrMemoLine.Get(TempFromPurchLineBuf."Receipt No.", TempFromPurchLineBuf."Return Shipment Line No.");
OnCopyPurchCrMemoLinesToDocOnBeforeCopyItemCharges(ToPurchLine, TempFromPurchLineBuf, RecalculateLines);
// copy item charges
if TempFromPurchLineBuf.Type = TempFromPurchLineBuf.Type::"Charge (Item)" then begin
FromPurchLine.TransferFields(FromPurchCrMemoLine);
FromPurchLine."Document Type" := FromPurchLine."Document Type"::"Credit Memo";
CopyFromPurchLineItemChargeAssign(FromPurchLine, ToPurchLine, FromPurchHeader, ItemChargeAssgntNextLineNo);
end;
// copy item tracking
ShouldCopyItemTrackingEntries := (TempFromPurchLineBuf.Type = TempFromPurchLineBuf.Type::Item) and (TempFromPurchLineBuf.Quantity <> 0) and (not TempFromPurchLineBuf.IsProdOrder());
OnCopyPurchCrMemoLinesToDocOnAfterCalcShouldCopyItemTrackingEntries(ToPurchLine, ShouldCopyItemTrackingEntries);
if ShouldCopyItemTrackingEntries then begin
FromPurchCrMemoLine."Document No." := OldCrMemoDocNo;
FromPurchCrMemoLine."Line No." := TempFromPurchLineBuf."Return Shipment Line No.";
FromPurchCrMemoLine.GetItemLedgEntries(TempItemLedgEntryBuf, true);
if IsCopyItemTrkg(TempItemLedgEntryBuf, CopyItemTrkg, FillExactCostRevLink) then begin
if TempFromPurchLineBuf."Job No." <> '' then
TempItemLedgEntryBuf.SetFilter("Entry Type", '<> %1', TempItemLedgEntryBuf."Entry Type"::"Negative Adjmt.");
OnCopyPurchCrMemoLinesToDocOnAfterFilterEntryType(TempFromPurchLineBuf, TempItemLedgEntryBuf);
if MoveNegLines or not ExactCostRevMandatory then
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, TempItemLedgEntryBuf)
else
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, true, TempFromPurchLineBuf."Document No.", TempFromPurchLineBuf."Line No.");
ItemTrackingMgt.CopyItemLedgEntryTrkgToPurchLn(
TempTrkgItemLedgEntry, ToPurchLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT", false);
end;
end;
OnAfterCopyPurchLineFromPurchCrMemoLineBuffer(
ToPurchLine, FromPurchCrMemoLine, IncludeHeader, RecalculateLines, TempDocPurchaseLine, ToPurchHeader, TempFromPurchLineBuf);
end;
OnAfterCopyPurchCrMemoLine(FromPurchCrMemoLine, ToPurchLine, ToPurchHeader);
until TempFromPurchLineBuf.Next() = 0;
end;
CloseWindow();
OnAfterCopyPurchCrMemoLinesToDoc(ToPurchHeader, FromPurchCrMemoLine, LinesNotCopied, MissingExCostRevLink);
end;
procedure CopyPurchReturnShptLinesToDoc(ToPurchHeader: Record "Purchase Header"; var FromReturnShptLine: Record "Return Shipment Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
ItemLedgEntry: Record "Item Ledger Entry";
TempTrkgItemLedgEntry: Record "Item Ledger Entry" temporary;
FromPurchHeader: Record "Purchase Header";
FromPurchLine: Record "Purchase Line";
OriginalPurchHeader: Record "Purchase Header";
ToPurchLine: Record "Purchase Line";
TempFromPurchLineBuf: Record "Purchase Line" temporary;
FromReturnShptHeader: Record "Return Shipment Header";
TempItemTrkgEntry: Record "Reservation Entry" temporary;
TempDocPurchaseLine: Record "Purchase Line" temporary;
ItemTrackingMgt: Codeunit "Item Tracking Management";
OldDocNo: Code[20];
NextLineNo: Integer;
NextItemTrkgEntryNo: Integer;
FromLineCounter: Integer;
ToLineCounter: Integer;
CopyItemTrkg: Boolean;
SplitLine: Boolean;
FillExactCostRevLink: Boolean;
CopyLine: Boolean;
InsertDocNoLine: Boolean;
IsHandled: Boolean;
begin
MissingExCostRevLink := false;
InitCurrency(ToPurchHeader."Currency Code");
OpenWindow();
OnBeforeCopyPurchReturnShptLinesToDoc(TempDocPurchaseLine, ToPurchHeader, FromReturnShptLine);
if FromReturnShptLine.FindSet() then
repeat
FromLineCounter := FromLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(1, FromLineCounter);
if FromReturnShptHeader."No." <> FromReturnShptLine."Document No." then begin
FromReturnShptHeader.Get(FromReturnShptLine."Document No.");
IsHandled := false;
OnCopyPurchReturnShptLinesToDocOnBeforeTestFieldPricesIncludingVAT(ToPurchHeader, IncludeHeader, RecalculateLines, FromReturnShptHeader, IsHandled);
if not IsHandled then
if OriginalPurchHeader.Get(OriginalPurchHeader."Document Type"::"Return Order", FromReturnShptHeader."Return Order No.") then
OriginalPurchHeader.TestField("Prices Including VAT", ToPurchHeader."Prices Including VAT");
TransferOldExtLines.ClearLineNumbers();
end;
FromPurchHeader.TransferFields(FromReturnShptHeader);
FillExactCostRevLink :=
IsPurchFillExactCostRevLink(ToPurchHeader, 2, FromPurchHeader."Currency Code");
FromPurchLine.TransferFields(FromReturnShptLine);
FromPurchLine.Validate("Order No.", FromReturnShptLine."Return Order No.");
FromPurchLine.Validate("Order Line No.", FromReturnShptLine."Return Order Line No.");
FromPurchLine."Appl.-to Item Entry" := 0;
FromPurchLine."Copied From Posted Doc." := true;
OnCopyPurchReturnShptLinesToDocOnAfterTransferFields(FromPurchLine, FromPurchHeader, ToPurchHeader, FromReturnShptHeader, FromReturnShptLine, RecalculateLines);
CheckUpdateOldDocumentNoFromReturnShptLine(FromReturnShptLine, OldDocNo, InsertDocNoLine);
SplitLine := true;
FromReturnShptLine.FilterPstdDocLnItemLedgEntries(ItemLedgEntry);
if not SplitPstdPurchLinesPerILE(
ToPurchHeader, FromPurchHeader, ItemLedgEntry, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, CopyItemTrkg, MissingExCostRevLink, FillExactCostRevLink, true)
then
if CopyItemTrkg then
SplitLine :=
SplitPurchDocLinesPerItemTrkg(
ItemLedgEntry, TempItemTrkgEntry, TempFromPurchLineBuf,
FromPurchLine, TempDocPurchaseLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, true)
else
SplitLine := false;
if not SplitLine then begin
TempFromPurchLineBuf := FromPurchLine;
CopyLine := true;
end else
CopyLine := TempFromPurchLineBuf.FindSet() and FillExactCostRevLink;
UpdateWindow(1, FromLineCounter);
if CopyLine then begin
NextLineNo := GetLastToPurchLineNo(ToPurchHeader);
OnCopyPurchReturnShptLinesToDocOnAfterCalcNextLineNo(ToPurchHeader, FromReturnShptLine, FromPurchHeader, NextLineNo, InsertDocNoLine);
if InsertDocNoLine then begin
InsertOldPurchDocNoLine(ToPurchHeader, FromReturnShptLine."Document No.", 3, NextLineNo);
InsertDocNoLine := false;
end;
repeat
ToLineCounter := ToLineCounter + 1;
if IsTimeForUpdate() then
UpdateWindow(2, ToLineCounter);
OnCopyPurchReturnShptLinesToDocOnBeforeCopyPurchLine(ToPurchHeader, TempFromPurchLineBuf, CopyItemTrkg);
if CopyPurchDocLine(
ToPurchHeader, ToPurchLine, FromPurchHeader, TempFromPurchLineBuf, NextLineNo, LinesNotCopied, false,
"Purchase Document Type From"::"Posted Return Shipment", CopyPostedDeferral, TempFromPurchLineBuf."Line No.")
then begin
OnCopyPurchReturnShptLinesToDocOnBeforeCopyItemTrkg(ToPurchLine, TempFromPurchLineBuf, RecalculateLines);
if CopyItemTrkg then begin
if SplitLine then
ItemTrackingDocMgt.CollectItemTrkgPerPostedDocLine(
TempItemTrkgEntry, TempTrkgItemLedgEntry, true, TempFromPurchLineBuf."Document No.", TempFromPurchLineBuf."Line No.")
else
ItemTrackingDocMgt.CopyItemLedgerEntriesToTemp(TempTrkgItemLedgEntry, ItemLedgEntry);
ItemTrackingMgt.CopyItemLedgEntryTrkgToPurchLn(
TempTrkgItemLedgEntry, ToPurchLine,
FillExactCostRevLink and ExactCostRevMandatory, MissingExCostRevLink,
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT", true);
end;
OnAfterCopyPurchLineFromReturnShptLineBuffer(
ToPurchLine, FromReturnShptLine, IncludeHeader, RecalculateLines,
TempDocPurchaseLine, ToPurchHeader, TempFromPurchLineBuf, CopyItemTrkg);
end;
until TempFromPurchLineBuf.Next() = 0;
end;
OnAfterCopyReturnShptLine(FromReturnShptLine, ToPurchLine);
until FromReturnShptLine.Next() = 0;
CloseWindow();
OnAfterCopyPurchReturnShptLinesToDoc(ToPurchHeader, FromReturnShptLine, LinesNotCopied, MissingExCostRevLink);
end;
local procedure CheckUpdateOldDocumentNoFromReturnShptLine(FromReturnShptLine: Record "Return Shipment Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckUpdateOldDocumentNoFromReturnShptLine(FromReturnShptLine, OldDocNo, InsertDocNoLine, IsHandled);
if IsHandled then
exit;
if FromReturnShptLine."Document No." <> OldDocNo then begin
OldDocNo := FromReturnShptLine."Document No.";
InsertDocNoLine := true;
end;
end;
local procedure CopyPurchLinesToBuffer(FromPurchHeader: Record "Purchase Header"; FromPurchLine: Record "Purchase Line"; var FromPurchLine2: Record "Purchase Line"; var TempPurchLineBuf: Record "Purchase Line" temporary; ToPurchHeader: Record "Purchase Header"; var TempDocPurchaseLine: Record "Purchase Line" temporary; DocNo: Code[20]; var NextLineNo: Integer)
begin
FromPurchLine2 := TempPurchLineBuf;
TempPurchLineBuf := FromPurchLine;
TempPurchLineBuf."Document No." := '';
TempPurchLineBuf."Line No." := NextLineNo;
OnAfterCopyPurchLinesToBufferFields(TempPurchLineBuf, FromPurchLine2, FromPurchLine, ToPurchHeader);
NextLineNo := NextLineNo + 10000;
if not IsRecalculateAmount(
FromPurchHeader."Currency Code", ToPurchHeader."Currency Code",
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT")
then
TempPurchLineBuf."Return Shipment No." := DocNo;
ReCalcPurchLine(FromPurchHeader, ToPurchHeader, TempPurchLineBuf);
TempPurchLineBuf.Insert();
AddPurchDocLine(TempDocPurchaseLine, TempPurchLineBuf."Line No.", DocNo, FromPurchLine."Line No.");
OnAfterCopyPurchLinesToBuffer(TempPurchLineBuf, FromPurchLine2, FromPurchLine);
end;
local procedure CreateJobPlanningLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; JobContractEntryNo: Integer): Integer
var
JobPlanningLine: Record "Job Planning Line";
NewJobPlanningLine: Record "Job Planning Line";
JobPlanningLineInvoice: Record "Job Planning Line Invoice";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCreateJobPlanningLine(SalesHeader, SalesLine, JobContractEntryNo, IsHandled);
if IsHandled then
exit;
JobPlanningLine.SetCurrentKey("Job Contract Entry No.");
JobPlanningLine.SetRange("Job Contract Entry No.", JobContractEntryNo);
if JobPlanningLine.FindFirst() then begin
NewJobPlanningLine.InitFromJobPlanningLine(JobPlanningLine, SalesLine.Quantity);
OnCreateJobPlanningLineOnAfterInitFromJobPlanningLine(NewJobPlanningLine, JobPlanningLine, SalesLine);
JobPlanningLineInvoice.InitFromJobPlanningLine(NewJobPlanningLine);
JobPlanningLineInvoice.InitFromSales(SalesHeader, SalesHeader."Posting Date", SalesLine."Line No.");
JobPlanningLineInvoice.Insert();
NewJobPlanningLine.UpdateQtyToTransfer();
NewJobPlanningLine.Insert();
end;
exit(NewJobPlanningLine."Job Contract Entry No.");
end;
local procedure SplitPstdPurchLinesPerILE(ToPurchHeader: Record "Purchase Header"; FromPurchHeader: Record "Purchase Header"; var ItemLedgEntry: Record "Item Ledger Entry"; var FromPurchLineBuf: Record "Purchase Line"; FromPurchLine: Record "Purchase Line"; var TempDocPurchaseLine: Record "Purchase Line" temporary; var NextLineNo: Integer; var CopyItemTrkg: Boolean; var MissingExCostRevLink: Boolean; FillExactCostRevLink: Boolean; FromShptOrRcpt: Boolean) Result: Boolean
var
PurchaseItem: Record Item;
ApplyRec: Record "Item Application Entry";
OrgQtyBase: Decimal;
OneRecord: Boolean;
IsHandled: Boolean;
begin
if FromShptOrRcpt then begin
FromPurchLineBuf.Reset();
FromPurchLineBuf.DeleteAll();
end else
FromPurchLineBuf.Init();
CopyItemTrkg := false;
if (FromPurchLine.Type <> FromPurchLine.Type::Item) or (FromPurchLine.Quantity = 0) or FromPurchLine.IsProdOrder() then
exit(false);
PurchaseItem.Get(FromPurchLine."No.");
if PurchaseItem.IsNonInventoriableType() then
exit(false);
if IsCopyItemTrkg(ItemLedgEntry, CopyItemTrkg, FillExactCostRevLink) or
not FillExactCostRevLink or MoveNegLines or
not ExactCostRevMandatory
then
exit(false);
IsHandled := false;
OnSplitPstdPurchLinesPerILEOnBeforeCheckJobNo(FromPurchLine, Result, IsHandled);
if IsHandled then
exit(Result);
if FromPurchLine."Job No." <> '' then
exit(false);
OneRecord := ItemLedgEntry.count() = 1;
ItemLedgEntry.FindSet();
if ItemLedgEntry.Quantity <= 0 then begin
FromPurchLineBuf."Document No." := ItemLedgEntry."Document No.";
if GetPurchDocTypeForItemLedgEntry(ItemLedgEntry) in
[FromPurchLineBuf."Document Type"::Order, FromPurchLineBuf."Document Type"::"Return Order"]
then
FromPurchLineBuf."Receipt Line No." := 1;
exit(false);
end;
OrgQtyBase := FromPurchLine."Quantity (Base)";
repeat
if not ApplyFully then begin
ApplyRec.AppliedOutbndEntryExists(ItemLedgEntry."Entry No.", false, false);
if ApplyRec.Find('-') then
SkippedLine := SkippedLine or ApplyRec.Find('-');
end;
if ApplyFully then begin
ApplyRec.AppliedOutbndEntryExists(ItemLedgEntry."Entry No.", false, false);
if ApplyRec.Find('-') then
repeat
SomeAreFixed := SomeAreFixed or ApplyRec.Fixed();
until ApplyRec.Next() = 0;
end;
if AskApply and (ItemLedgEntry."Item Tracking" = ItemLedgEntry."Item Tracking"::None) then
if not (ItemLedgEntry."Remaining Quantity" > 0) or (ItemLedgEntry."Item Tracking" <> ItemLedgEntry."Item Tracking"::None) then
ConfirmApply();
if AskApply then
if ItemLedgEntry."Remaining Quantity" < Abs(FromPurchLine."Quantity (Base)") then
ConfirmApply();
if (ItemLedgEntry."Remaining Quantity" > 0) or ApplyFully then begin
FromPurchLineBuf := FromPurchLine;
if ItemLedgEntry."Remaining Quantity" < Abs(FromPurchLine."Quantity (Base)") then
if not ApplyFully then begin
if FromPurchLine."Quantity (Base)" > 0 then
FromPurchLineBuf."Quantity (Base)" := ItemLedgEntry."Remaining Quantity"
else
FromPurchLineBuf."Quantity (Base)" := -ItemLedgEntry."Remaining Quantity";
ConvertFromBase(
FromPurchLineBuf.Quantity, FromPurchLineBuf."Quantity (Base)", FromPurchLineBuf."Qty. per Unit of Measure");
end else begin
ReappDone := true;
FromPurchLineBuf."Quantity (Base)" := Sign(ItemLedgEntry.Quantity) * ItemLedgEntry.Quantity - ApplyRec.Returned(ItemLedgEntry."Entry No.");
ConvertFromBase(
FromPurchLineBuf.Quantity, FromPurchLineBuf."Quantity (Base)", FromPurchLineBuf."Qty. per Unit of Measure");
end;
FromPurchLine."Quantity (Base)" := FromPurchLine."Quantity (Base)" - FromPurchLineBuf."Quantity (Base)";
FromPurchLine.Quantity := FromPurchLine.Quantity - FromPurchLineBuf.Quantity;
FromPurchLineBuf."Appl.-to Item Entry" := ItemLedgEntry."Entry No.";
NextLineNo := NextLineNo + 1;
FromPurchLineBuf."Line No." := NextLineNo;
NextLineNo := NextLineNo + 1;
FromPurchLineBuf."Document No." := ItemLedgEntry."Document No.";
if GetPurchDocTypeForItemLedgEntry(ItemLedgEntry) in
[FromPurchLineBuf."Document Type"::Order, FromPurchLineBuf."Document Type"::"Return Order"]
then
FromPurchLineBuf."Receipt Line No." := 1;
if not FromShptOrRcpt then
UpdateRevPurchLineAmount(
FromPurchLineBuf, OrgQtyBase,
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT");
if FromPurchLineBuf.Quantity <> 0 then begin
OnSplitPstdPurchLinesPerILEOnBeforeFromPurchLineBufInsert(FromPurchHeader, FromPurchLine, FromPurchLineBuf, ToPurchHeader);
FromPurchLineBuf.Insert();
if OneRecord then
AddPurchDocLine(TempDocPurchaseLine, FromPurchLineBuf."Line No.", FromPurchLine."Document No.", FromPurchLine."Line No.")
else
AddPurchDocLine(TempDocPurchaseLine, FromPurchLineBuf."Line No.", ItemLedgEntry."Document No.", FromPurchLineBuf."Line No.");
end else
SkippedLine := true;
end else
if ItemLedgEntry."Remaining Quantity" = 0 then
SkippedLine := true;
until (ItemLedgEntry.Next() = 0) or (FromPurchLine."Quantity (Base)" = 0);
if (FromPurchLine."Quantity (Base)" <> 0) and FillExactCostRevLink then
MissingExCostRevLink := true;
OnSplitPstdPurchLinesPerILEOnBeforeCheckUnappliedLines(ToPurchHeader, SkippedLine, MissingExCostRevLink);
CheckUnappliedLines(SkippedLine, MissingExCostRevLink);
exit(true);
end;
local procedure SplitPurchDocLinesPerItemTrkg(var ItemLedgEntry: Record "Item Ledger Entry"; var TempItemTrkgEntry: Record "Reservation Entry" temporary; var FromPurchLineBuf: Record "Purchase Line"; FromPurchLine: Record "Purchase Line"; var TempDocPurchaseLine: Record "Purchase Line" temporary; var NextLineNo: Integer; var NextItemTrkgEntryNo: Integer; var MissingExCostRevLink: Boolean; FromShptOrRcpt: Boolean): Boolean
var
PurchLineBuf: array[2] of Record "Purchase Line" temporary;
ApplyRec: Record "Item Application Entry";
Tracked: Boolean;
RemainingQtyBase: Decimal;
SignFactor: Integer;
i: Integer;
Result: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeSplitPurchDocLinesPerItemTrkg(ItemLedgEntry, TempItemTrkgEntry, FromPurchLineBuf, FromPurchLine, TempDocPurchaseLine, NextLineNo, NextItemTrkgEntryNo, MissingExCostRevLink, FromShptOrRcpt, Result, IsHandled);
if IsHandled then
exit(Result);
if FromShptOrRcpt then begin
FromPurchLineBuf.Reset();
FromPurchLineBuf.DeleteAll();
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.DeleteAll();
end else
FromPurchLineBuf.Init();
if MoveNegLines or not ExactCostRevMandatory then
exit(false);
if FromPurchLine."Quantity (Base)" < 0 then
SignFactor := -1
else
SignFactor := 1;
ItemLedgEntry.SetCurrentKey("Document No.", "Document Type", "Document Line No.");
ItemLedgEntry.FindSet();
repeat
PurchLineBuf[1] := FromPurchLine;
PurchLineBuf[1]."Line No." := NextLineNo;
PurchLineBuf[1]."Quantity (Base)" := 0;
PurchLineBuf[1].Quantity := 0;
PurchLineBuf[1]."Document No." := ItemLedgEntry."Document No.";
if GetPurchDocTypeForItemLedgEntry(ItemLedgEntry) in
[PurchLineBuf[1]."Document Type"::Order, PurchLineBuf[1]."Document Type"::"Return Order"]
then
PurchLineBuf[1]."Receipt Line No." := 1;
PurchLineBuf[2] := PurchLineBuf[1];
PurchLineBuf[2]."Line No." := PurchLineBuf[2]."Line No." + 1;
if not FromShptOrRcpt then begin
ItemLedgEntry.SetRange("Document No.", ItemLedgEntry."Document No.");
ItemLedgEntry.SetRange("Document Type", ItemLedgEntry."Document Type");
ItemLedgEntry.SetRange("Document Line No.", ItemLedgEntry."Document Line No.");
end;
repeat
i := 1;
if ItemLedgEntry.Positive then
ItemLedgEntry."Remaining Quantity" :=
ItemLedgEntry."Remaining Quantity" -
CalcDistributedQty(TempItemTrkgEntry, ItemLedgEntry, PurchLineBuf[2]."Line No." + 1);
if ItemLedgEntry."Document Type" in [ItemLedgEntry."Document Type"::"Purchase Return Shipment", ItemLedgEntry."Document Type"::"Purchase Credit Memo"] then
if -ItemLedgEntry."Shipped Qty. Not Returned" < FromPurchLine."Quantity (Base)" * SignFactor then
RemainingQtyBase := -ItemLedgEntry."Shipped Qty. Not Returned" * SignFactor
else
RemainingQtyBase := FromPurchLine."Quantity (Base)"
else
if not ItemLedgEntry.Positive then begin
RemainingQtyBase := -ItemLedgEntry."Shipped Qty. Not Returned";
if RemainingQtyBase < FromPurchLine."Quantity (Base)" * SignFactor then
RemainingQtyBase := RemainingQtyBase * SignFactor
else
RemainingQtyBase := FromPurchLine."Quantity (Base)";
end else
if ItemLedgEntry."Remaining Quantity" < FromPurchLine."Quantity (Base)" * SignFactor then begin
if (ItemLedgEntry."Item Tracking" = ItemLedgEntry."Item Tracking"::None) and AskApply then
ConfirmApply();
if (not ApplyFully) or (ItemLedgEntry."Item Tracking" <> ItemLedgEntry."Item Tracking"::None) then
RemainingQtyBase := GetQtyOfPurchILENotShipped(ItemLedgEntry."Entry No.", FromPurchLine) * SignFactor
else
RemainingQtyBase := FromPurchLine."Quantity (Base)" - ApplyRec.Returned(ItemLedgEntry."Entry No.");
end else
RemainingQtyBase := FromPurchLine."Quantity (Base)";
if RemainingQtyBase <> 0 then begin
if ItemLedgEntry.Positive then
if IsSplitItemLedgEntry(ItemLedgEntry) then
i := 2;
PurchLineBuf[i]."Quantity (Base)" := PurchLineBuf[i]."Quantity (Base)" + RemainingQtyBase;
if PurchLineBuf[i]."Qty. per Unit of Measure" = 0 then
PurchLineBuf[i].Quantity := PurchLineBuf[i]."Quantity (Base)"
else
PurchLineBuf[i].Quantity :=
Round(
PurchLineBuf[i]."Quantity (Base)" / PurchLineBuf[i]."Qty. per Unit of Measure", UOMMgt.QtyRndPrecision());
FromPurchLine."Quantity (Base)" := FromPurchLine."Quantity (Base)" - RemainingQtyBase;
// Fill buffer with exact cost reversing link for remaining quantity
if ItemLedgEntry."Document Type" in [ItemLedgEntry."Document Type"::"Purchase Return Shipment", ItemLedgEntry."Document Type"::"Purchase Credit Memo"] then
InsertTempReservationEntry(
ItemLedgEntry, TempItemTrkgEntry, -Abs(RemainingQtyBase),
PurchLineBuf[i]."Line No.", NextItemTrkgEntryNo, true)
else
InsertTempReservationEntry(
ItemLedgEntry, TempItemTrkgEntry, Abs(RemainingQtyBase),
PurchLineBuf[i]."Line No.", NextItemTrkgEntryNo, true);
Tracked := true;
end else
SkippedLine := true;
until (ItemLedgEntry.Next() = 0) or (FromPurchLine."Quantity (Base)" = 0);
for i := 1 to 2 do
if PurchLineBuf[i]."Quantity (Base)" <> 0 then begin
FromPurchLineBuf := PurchLineBuf[i];
FromPurchLineBuf.Insert();
AddPurchDocLine(TempDocPurchaseLine, FromPurchLineBuf."Line No.", ItemLedgEntry."Document No.", FromPurchLine."Line No.");
NextLineNo := PurchLineBuf[i]."Line No." + 1;
end;
if not FromShptOrRcpt then begin
ItemLedgEntry.SetRange("Document No.");
ItemLedgEntry.SetRange("Document Type");
ItemLedgEntry.SetRange("Document Line No.");
end;
until (ItemLedgEntry.Next() = 0) or FromShptOrRcpt;
if (FromPurchLine."Quantity (Base)" <> 0) and not Tracked then
MissingExCostRevLink := true;
CheckUnappliedLines(SkippedLine, MissingExCostRevLink);
exit(true);
end;
local procedure CalcDistributedQty(var TempItemTrkgEntry: Record "Reservation Entry" temporary; ItemLedgEntry: Record "Item Ledger Entry"; NextLineNo: Integer): Decimal
begin
TempItemTrkgEntry.Reset();
TempItemTrkgEntry.SetCurrentKey("Source ID", "Source Ref. No.");
TempItemTrkgEntry.SetRange("Source ID", ItemLedgEntry."Document No.");
TempItemTrkgEntry.SetFilter("Source Ref. No.", '<%1', NextLineNo);
TempItemTrkgEntry.SetRange("Item Ledger Entry No.", ItemLedgEntry."Entry No.");
TempItemTrkgEntry.CalcSums("Quantity (Base)");
TempItemTrkgEntry.Reset();
exit(TempItemTrkgEntry."Quantity (Base)");
end;
[Scope('OnPrem')]
procedure IsEntityBlocked(TableNo: Integer; CreditDocType: Boolean; Type: Option; EntityNo: Code[20]; EntityCode: Code[10]) EntityIsBlocked: Boolean
var
GLAccount: Record "G/L Account";
FixedAsset: Record "Fixed Asset";
Item: Record Item;
ItemVariant: Record "Item Variant";
Resource: Record Resource;
ForwardLinkMgt: Codeunit "Forward Link Mgt.";
MessageType: Option Error,Warning,Information;
BlockedForSalesPurch: Boolean;
IsHandled: Boolean;
ItemItemVariantLbl: Label '%1 %2', Comment = '%1 - Item No., %2 - Variant Code';
begin
OnBeforeIsEntityBlocked(TableNo, CreditDocType, Type, EntityNo, EntityIsBlocked, IsHandled, EntityCode);
if IsHandled then
exit(EntityIsBlocked);
if SkipWarningNotification then
MessageType := MessageType::Error
else
MessageType := MessageType::Warning;
case Type of
"Sales Line Type"::"G/L Account".AsInteger():
if GLAccount.Get(EntityNo) then begin
if not GLAccount."Direct Posting" then
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(DirectPostingErr, GLAccount."No."), GLAccount, GLAccount.FieldNo("Direct Posting"), '')
else
if GLAccount.Blocked then
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsBlockedErr, GLAccount.TableCaption(), GLAccount."No.")
, GLAccount, GLAccount.FieldNo(Blocked), '');
exit(not GLAccount."Direct Posting" or GLAccount.Blocked);
end;
"Sales Line Type"::Item.AsInteger():
if Item.Get(EntityNo) then begin
if Item.Blocked then begin
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsBlockedErr, Item.TableCaption(), Item."No."),
Item, Item.FieldNo(Blocked), ForwardLinkMgt.GetHelpCodeForBlockedItem());
exit(true);
end;
if not CreditDocType then
case TableNo of
Database::"Sales Line":
if Item."Sales Blocked" then begin
BlockedForSalesPurch := true;
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsSalesBlockedItemErr, Item.TableCaption(), Item."No.", Item.FieldCaption("Sales Blocked")), Item,
Item.FieldNo("Sales Blocked"), ForwardLinkMgt.GetHelpCodeForBlockedItem());
end;
Database::"Purchase Line":
if Item."Purchasing Blocked" then begin
BlockedForSalesPurch := true;
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsPurchBlockedItemErr, Item.TableCaption(), Item."No.", Item.FieldCaption("Purchasing Blocked")), Item,
Item.FieldNo("Purchasing Blocked"), ForwardLinkMgt.GetHelpCodeForBlockedItem());
end;
else
BlockedForSalesPurch := false;
end;
if not BlockedForSalesPurch then
if (EntityCode <> '') and ItemVariant.Get(EntityNo, EntityCode) then begin
if ItemVariant.Blocked then begin
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsBlockedErr, ItemVariant.TableCaption(), StrSubstNo(ItemItemVariantLbl, ItemVariant."Item No.", ItemVariant.Code)),
ItemVariant, ItemVariant.FieldNo(Blocked), ForwardLinkMgt.GetHelpCodeForBlockedItem());
exit(true);
end;
if not CreditDocType then
case TableNo of
Database::"Sales Line":
if ItemVariant."Sales Blocked" then begin
BlockedForSalesPurch := true;
ErrorMessageMgt.LogMessage(
MessageType, 0,
StrSubstNo(IsSalesBlockedItemErr, ItemVariant.TableCaption(), StrSubstNo(ItemItemVariantLbl, ItemVariant."Item No.", ItemVariant.Code), ItemVariant.FieldCaption("Sales Blocked")),
ItemVariant, ItemVariant.FieldNo("Sales Blocked"), ForwardLinkMgt.GetHelpCodeForBlockedItem());
end;
Database::"Purchase Line":
if ItemVariant."Purchasing Blocked" then begin
BlockedForSalesPurch := true;
ErrorMessageMgt.LogMessage(
MessageType, 0,
StrSubstNo(IsPurchBlockedItemErr, ItemVariant.TableCaption(), StrSubstNo(ItemItemVariantLbl, ItemVariant."Item No.", ItemVariant.Code), ItemVariant.FieldCaption("Purchasing Blocked")),
ItemVariant, ItemVariant.FieldNo("Purchasing Blocked"), ForwardLinkMgt.GetHelpCodeForBlockedItem());
end;
end;
end;
exit(BlockedForSalesPurch);
end;
"Sales Line Type"::Resource.AsInteger():
if Resource.Get(EntityNo) then begin
if Resource.Blocked then
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsBlockedErr, Resource.TableCaption(), Resource."No."), Resource, Resource.FieldNo(Blocked), '');
exit(Resource.Blocked);
end;
"Sales Line Type"::"Fixed Asset".AsInteger():
if FixedAsset.Get(EntityNo) then begin
if FixedAsset.Blocked then
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(IsBlockedErr, FixedAsset.TableCaption(), FixedAsset."No."),
FixedAsset, FixedAsset.FieldNo(Blocked), '')
else
if FixedAsset.Inactive then
ErrorMessageMgt.LogMessage(
MessageType, 0, StrSubstNo(FAIsInactiveErr, FixedAsset."No."), FixedAsset, FixedAsset.FieldNo(Inactive), '');
exit(FixedAsset.Blocked or FixedAsset.Inactive);
end;
end;
end;
local procedure IsItemOrVariantBlocked(ItemNo: Code[20]; VariantCode: Code[10]): Boolean
var
Item: Record Item;
ItemVariant: Record "Item Variant";
begin
if (Item.Get(ItemNo) and Item.Blocked) then
exit(true);
if VariantCode <> '' then begin
ItemVariant.SetLoadFields(Blocked);
exit(ItemVariant.Get(ItemNo, VariantCode) and ItemVariant.Blocked);
end;
end;
local procedure IsSplitItemLedgEntry(OrgItemLedgEntry: Record "Item Ledger Entry"): Boolean
var
ItemLedgEntry: Record "Item Ledger Entry";
begin
ItemLedgEntry.SetCurrentKey("Document No.");
ItemLedgEntry.SetRange("Document No.", OrgItemLedgEntry."Document No.");
ItemLedgEntry.SetRange("Document Type", OrgItemLedgEntry."Document Type");
ItemLedgEntry.SetRange("Document Line No.", OrgItemLedgEntry."Document Line No.");
ItemLedgEntry.SetTrackingFilterFromItemLedgEntry(OrgItemLedgEntry);
ItemLedgEntry.SetFilter("Entry No.", '<%1', OrgItemLedgEntry."Entry No.");
OnIsSplitItemLedgEntryOnAfterItemLedgEntrySetFilters(ItemLedgEntry, OrgItemLedgEntry);
exit(not ItemLedgEntry.IsEmpty());
end;
procedure IsCopyItemTrkg(var ItemLedgEntry: Record "Item Ledger Entry"; var CopyItemTrkg: Boolean; FillExactCostRevLink: Boolean) Result: Boolean
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeIsCopyItemTrkg(ItemLedgEntry, CopyItemTrkg, FillExactCostRevLink, Result, IsHandled);
if IsHandled then
exit(Result);
if ItemLedgEntry.IsEmpty() then
exit(true);
ItemLedgEntry.SetFilter("Serial No.", '<>%1', '');
if not ItemLedgEntry.IsEmpty() then begin
if FillExactCostRevLink then
CopyItemTrkg := true;
exit(true);
end;
ItemLedgEntry.SetRange("Serial No.");
ItemLedgEntry.SetFilter("Lot No.", '<>%1', '');
if not ItemLedgEntry.IsEmpty() then begin
if FillExactCostRevLink then
CopyItemTrkg := true;
exit(true);
end;
ItemLedgEntry.SetRange("Lot No.");
OnAfterIsCopyItemTrkg(ItemLedgEntry, FillExactCostRevLink, CopyItemTrkg, IsHandled);
if IsHandled then
exit(true);
exit(false);
end;
local procedure InsertTempReservationEntry(ItemLedgEntry: Record "Item Ledger Entry"; var TempReservationEntry: Record "Reservation Entry"; QtyBase: Decimal; DocLineNo: Integer; var NextEntryNo: Integer; FillExactCostRevLink: Boolean)
begin
if QtyBase = 0 then
exit;
TempReservationEntry.Init();
TempReservationEntry."Entry No." := NextEntryNo;
NextEntryNo := NextEntryNo + 1;
if not FillExactCostRevLink then
TempReservationEntry."Reservation Status" := TempReservationEntry."Reservation Status"::Prospect;
TempReservationEntry."Source ID" := ItemLedgEntry."Document No.";
TempReservationEntry."Source Ref. No." := DocLineNo;
TempReservationEntry."Item Ledger Entry No." := ItemLedgEntry."Entry No.";
TempReservationEntry."Quantity (Base)" := QtyBase;
OnInsertTempReservationEntryOnBeforeInsert(TempReservationEntry, ItemLedgEntry);
TempReservationEntry.Insert();
end;
procedure GetLastToSalesLineNo(ToSalesHeader: Record "Sales Header"): Decimal
var
ToSalesLine: Record "Sales Line";
begin
ToSalesLine.LockTable();
ToSalesLine.SetRange("Document Type", ToSalesHeader."Document Type");
ToSalesLine.SetRange("Document No.", ToSalesHeader."No.");
if ToSalesLine.FindLast() then
exit(ToSalesLine."Line No.");
exit(0);
end;
procedure GetLastToPurchLineNo(ToPurchHeader: Record "Purchase Header"): Decimal
var
ToPurchLine: Record "Purchase Line";
begin
ToPurchLine.LockTable();
ToPurchLine.SetRange("Document Type", ToPurchHeader."Document Type");
ToPurchLine.SetRange("Document No.", ToPurchHeader."No.");
if ToPurchLine.FindLast() then
exit(ToPurchLine."Line No.");
exit(0);
end;
procedure InsertOldSalesDocNoLine(ToSalesHeader: Record "Sales Header"; OldDocNo: Code[20]; OldDocType: Integer; var NextLineNo: Integer)
var
ToSalesLine2: Record "Sales Line";
ShouldIncrementNextLineNo: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertOldSalesDocNoLineProcedure(ToSalesHeader, ToSalesLine2, OldDocType, OldDocNo, IsHandled);
if IsHandled then
exit;
if ShouldSkipCopyFromDescription() then
exit;
ShouldIncrementNextLineNo := true;
OnInsertOldSalesDocNoLineOnBeforeIncrementNextLineNo(ToSalesHeader, ShouldIncrementNextLineNo, NextLineNo);
if ShouldIncrementNextLineNo then
NextLineNo := NextLineNo + 10000;
ToSalesLine2.Init();
ToSalesLine2."Line No." := NextLineNo;
ToSalesLine2."Document Type" := ToSalesHeader."Document Type";
ToSalesLine2."Document No." := ToSalesHeader."No.";
TranslationHelper.SetGlobalLanguageByCode(ToSalesHeader."Language Code");
if InsertCancellationLine then
ToSalesLine2.Description := StrSubstNo(CrMemoCancellationMsg, OldDocNo)
else
ToSalesLine2.Description := StrSubstNo(Text015, SelectStr(OldDocType, Text013), OldDocNo);
TranslationHelper.RestoreGlobalLanguage();
IsHandled := false;
OnBeforeInsertOldSalesDocNoLine(ToSalesHeader, ToSalesLine2, OldDocType, OldDocNo, NextLineNo, IsHandled);
if not IsHandled then
ToSalesLine2.Insert();
end;
local procedure ShouldSkipCopyFromDescription() Result: Boolean
begin
Result := SkipCopyFromDescription;
OnAfterShouldSkipCopyFromDescription(Result);
end;
local procedure InsertOldSalesCombDocNoLine(ToSalesHeader: Record "Sales Header"; OldDocNo: Code[20]; OldDocNo2: Code[20]; var NextLineNo: Integer; CopyFromInvoice: Boolean)
var
ToSalesLine2: Record "Sales Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertOldSalesCombDocNoLineProcedure(ToSalesHeader, ToSalesLine2, CopyFromInvoice, OldDocNo, OldDocNo2, NextLineNo, IsHandled);
if IsHandled then
exit;
NextLineNo := NextLineNo + 10000;
ToSalesLine2.Init();
ToSalesLine2."Line No." := NextLineNo;
ToSalesLine2."Document Type" := ToSalesHeader."Document Type";
ToSalesLine2."Document No." := ToSalesHeader."No.";
TranslationHelper.SetGlobalLanguageByCode(ToSalesHeader."Language Code");
if CopyFromInvoice then
ToSalesLine2.Description :=
StrSubstNo(
Text018,
CopyStr(SelectStr(1, Text016) + OldDocNo, 1, 48),
CopyStr(SelectStr(2, Text016) + OldDocNo2, 1, 48))
else
ToSalesLine2.Description :=
StrSubstNo(
Text018,
CopyStr(SelectStr(3, Text016) + OldDocNo, 1, 48),
CopyStr(SelectStr(4, Text016) + OldDocNo2, 1, 48));
TranslationHelper.RestoreGlobalLanguage();
IsHandled := false;
OnBeforeInsertOldSalesCombDocNoLine(ToSalesHeader, ToSalesLine2, CopyFromInvoice, OldDocNo, OldDocNo2, IsHandled);
if not IsHandled then
ToSalesLine2.Insert();
end;
local procedure InsertOldPurchDocNoLine(ToPurchHeader: Record "Purchase Header"; OldDocNo: Code[20]; OldDocType: Integer; var NextLineNo: Integer)
var
ToPurchLine2: Record "Purchase Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInsertOldPurchDocNoLineProcedure(ToPurchHeader, ToPurchLine2, OldDocType, OldDocNo, IsHandled);
if IsHandled then
exit;
if ShouldSkipCopyFromDescription() then
exit;
NextLineNo := NextLineNo + 10000;
ToPurchLine2.Init();
ToPurchLine2."Line No." := NextLineNo;
ToPurchLine2."Document Type" := ToPurchHeader."Document Type";
ToPurchLine2."Document No." := ToPurchHeader."No.";
TranslationHelper.SetGlobalLanguageByCode(ToPurchHeader."Language Code");
if InsertCancellationLine then
ToPurchLine2.Description := StrSubstNo(CrMemoCancellationMsg, OldDocNo)
else
ToPurchLine2.Description := StrSubstNo(Text015, SelectStr(OldDocType, Text014), OldDocNo);
TranslationHelper.RestoreGlobalLanguage();
IsHandled := false;
OnBeforeInsertOldPurchDocNoLine(ToPurchHeader, ToPurchLine2, OldDocType, OldDocNo, NextLineNo, IsHandled);
if not IsHandled then
ToPurchLine2.Insert();
end;
local procedure InsertOldPurchCombDocNoLine(ToPurchHeader: Record "Purchase Header"; OldDocNo: Code[20]; OldDocNo2: Code[20]; var NextLineNo: Integer; CopyFromInvoice: Boolean)
var
ToPurchLine2: Record "Purchase Line";
begin
NextLineNo := NextLineNo + 10000;
ToPurchLine2.Init();
ToPurchLine2."Line No." := NextLineNo;
ToPurchLine2."Document Type" := ToPurchHeader."Document Type";
ToPurchLine2."Document No." := ToPurchHeader."No.";
TranslationHelper.SetGlobalLanguageByCode(ToPurchHeader."Language Code");
if CopyFromInvoice then
ToPurchLine2.Description :=
StrSubstNo(
Text018,
CopyStr(SelectStr(1, Text017) + OldDocNo, 1, 48),
CopyStr(SelectStr(2, Text017) + OldDocNo2, 1, 48))
else
ToPurchLine2.Description :=
StrSubstNo(
Text018,
CopyStr(SelectStr(3, Text017) + OldDocNo, 1, 48),
CopyStr(SelectStr(4, Text017) + OldDocNo2, 1, 48));
TranslationHelper.RestoreGlobalLanguage();
OnBeforeInsertOldPurchCombDocNoLine(ToPurchHeader, ToPurchLine2, CopyFromInvoice, OldDocNo, OldDocNo2);
ToPurchLine2.Insert();
end;
procedure IsSalesFillExactCostRevLink(ToSalesHeader: Record "Sales Header"; FromDocType: Option "Sales Shipment","Sales Invoice","Sales Return Receipt","Sales Credit Memo"; CurrencyCode: Code[10]) Result: Boolean
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeIsSalesFillExactCostRevLink(ToSalesHeader, FromDocType, CurrencyCode, Result, IsHandled);
if IsHandled then
exit(Result);
case FromDocType of
FromDocType::"Sales Shipment":
exit(ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::"Return Order", ToSalesHeader."Document Type"::"Credit Memo"]);
FromDocType::"Sales Invoice":
exit(
(ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::"Return Order", ToSalesHeader."Document Type"::"Credit Memo"]) and
(ToSalesHeader."Currency Code" = CurrencyCode));
FromDocType::"Sales Return Receipt":
exit(ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]);
FromDocType::"Sales Credit Memo":
exit(
(ToSalesHeader."Document Type" in [ToSalesHeader."Document Type"::Order, ToSalesHeader."Document Type"::Invoice]) and
(ToSalesHeader."Currency Code" = CurrencyCode));
end;
exit(false);
end;
procedure IsPurchFillExactCostRevLink(ToPurchHeader: Record "Purchase Header"; FromDocType: Option "Purchase Receipt","Purchase Invoice","Purchase Return Shipment","Purchase Credit Memo"; CurrencyCode: Code[10]) Result: Boolean
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeIsPurchFillExactCostRevLink(ToPurchHeader, FromDocType, CurrencyCode, Result, IsHandled);
if IsHandled then
exit(Result);
case FromDocType of
FromDocType::"Purchase Receipt":
exit(ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::"Return Order", ToPurchHeader."Document Type"::"Credit Memo"]);
FromDocType::"Purchase Invoice":
exit(
(ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::"Return Order", ToPurchHeader."Document Type"::"Credit Memo"]) and
(ToPurchHeader."Currency Code" = CurrencyCode));
FromDocType::"Purchase Return Shipment":
exit(ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::Order, ToPurchHeader."Document Type"::Invoice]);
FromDocType::"Purchase Credit Memo":
exit(
(ToPurchHeader."Document Type" in [ToPurchHeader."Document Type"::Order, ToPurchHeader."Document Type"::Invoice]) and
(ToPurchHeader."Currency Code" = CurrencyCode));
end;
exit(false);
end;
local procedure GetSalesDocTypeForItemLedgEntry(ItemLedgEntry: Record "Item Ledger Entry"): Enum "Sales Document Type"
begin
case ItemLedgEntry."Document Type" of
ItemLedgEntry."Document Type"::"Sales Shipment":
exit("Sales Document Type"::Order);
ItemLedgEntry."Document Type"::"Sales Invoice":
exit("Sales Document Type"::Invoice);
ItemLedgEntry."Document Type"::"Sales Credit Memo":
exit("Sales Document Type"::"Credit Memo");
ItemLedgEntry."Document Type"::"Sales Return Receipt":
exit("Sales Document Type"::"Return Order");
end;
end;
local procedure GetPurchDocTypeForItemLedgEntry(ItemLedgEntry: Record "Item Ledger Entry"): Enum "Purchase Document Type"
begin
case ItemLedgEntry."Document Type" of
ItemLedgEntry."Document Type"::"Purchase Receipt":
exit("Purchase Document Type"::Order);
ItemLedgEntry."Document Type"::"Purchase Invoice":
exit("Purchase Document Type"::Invoice);
ItemLedgEntry."Document Type"::"Purchase Credit Memo":
exit("Purchase Document Type"::"Credit Memo");
ItemLedgEntry."Document Type"::"Purchase Return Shipment":
exit("Purchase Document Type"::"Return Order");
end;
end;
local procedure CalcVAT(var Value: Decimal; VATPercentage: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean; RndgPrecision: Decimal)
begin
if (ToPricesInclVAT = FromPricesInclVAT) or (Value = 0) then
exit;
if ToPricesInclVAT then
Value := Round(Value * (100 + VATPercentage) / 100, RndgPrecision)
else
Value := Round(Value * 100 / (100 + VATPercentage), RndgPrecision);
end;
local procedure ReCalcSalesLine(FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")
var
CurrExchRate: Record "Currency Exchange Rate";
SalesLineAmount: Decimal;
IsHandled: Boolean;
begin
if not IsRecalculateAmount(
FromSalesHeader."Currency Code", ToSalesHeader."Currency Code",
FromSalesHeader."Prices Including VAT", ToSalesHeader."Prices Including VAT")
then
exit;
if FromSalesHeader."Currency Code" <> ToSalesHeader."Currency Code" then begin
if SalesLine.Quantity <> 0 then
SalesLineAmount := SalesLine."Unit Price" * SalesLine.Quantity
else
SalesLineAmount := SalesLine."Unit Price";
if FromSalesHeader."Currency Code" <> '' then begin
SalesLineAmount :=
CurrExchRate.ExchangeAmtFCYToLCY(
FromSalesHeader."Posting Date", FromSalesHeader."Currency Code",
SalesLineAmount, FromSalesHeader."Currency Factor");
SalesLine."Line Discount Amount" :=
CurrExchRate.ExchangeAmtFCYToLCY(
FromSalesHeader."Posting Date", FromSalesHeader."Currency Code",
SalesLine."Line Discount Amount", FromSalesHeader."Currency Factor");
SalesLine."Inv. Discount Amount" :=
CurrExchRate.ExchangeAmtFCYToLCY(
FromSalesHeader."Posting Date", FromSalesHeader."Currency Code",
SalesLine."Inv. Discount Amount", FromSalesHeader."Currency Factor");
end;
if ToSalesHeader."Currency Code" <> '' then begin
SalesLineAmount :=
CurrExchRate.ExchangeAmtLCYToFCY(
ToSalesHeader."Posting Date", ToSalesHeader."Currency Code", SalesLineAmount, ToSalesHeader."Currency Factor");
SalesLine."Line Discount Amount" :=
CurrExchRate.ExchangeAmtLCYToFCY(
ToSalesHeader."Posting Date", ToSalesHeader."Currency Code", SalesLine."Line Discount Amount", ToSalesHeader."Currency Factor");
SalesLine."Inv. Discount Amount" :=
CurrExchRate.ExchangeAmtLCYToFCY(
ToSalesHeader."Posting Date", ToSalesHeader."Currency Code", SalesLine."Inv. Discount Amount", ToSalesHeader."Currency Factor");
end;
end;
IsHandled := false;
OnRecalcSalesLineOnBeforeRoundUnitPrice(SalesLine, IsHandled);
if not IsHandled then begin
SalesLine."Currency Code" := ToSalesHeader."Currency Code";
if SalesLine.Quantity <> 0 then begin
SalesLineAmount := Round(SalesLineAmount, Currency."Amount Rounding Precision");
SalesLine."Unit Price" := Round(SalesLineAmount / SalesLine.Quantity, Currency."Unit-Amount Rounding Precision");
end else
SalesLine."Unit Price" := Round(SalesLineAmount, Currency."Unit-Amount Rounding Precision");
end;
SalesLine."Line Discount Amount" := Round(SalesLine."Line Discount Amount", Currency."Amount Rounding Precision");
SalesLine."Inv. Discount Amount" := Round(SalesLine."Inv. Discount Amount", Currency."Amount Rounding Precision");
IsHandled := false;
OnReCalcSalesLineOnBeforeCalcVAT(FromSalesHeader, ToSalesHeader, SalesLine, IsHandled);
if not IsHandled then begin
CalcVAT(
SalesLine."Unit Price", SalesLine."VAT %", FromSalesHeader."Prices Including VAT",
ToSalesHeader."Prices Including VAT", Currency."Unit-Amount Rounding Precision");
CalcVAT(
SalesLine."Line Discount Amount", SalesLine."VAT %", FromSalesHeader."Prices Including VAT",
ToSalesHeader."Prices Including VAT", Currency."Amount Rounding Precision");
CalcVAT(
SalesLine."Inv. Discount Amount", SalesLine."VAT %", FromSalesHeader."Prices Including VAT",
ToSalesHeader."Prices Including VAT", Currency."Amount Rounding Precision");
end;
end;
local procedure ReCalcPurchLine(FromPurchHeader: Record "Purchase Header"; ToPurchHeader: Record "Purchase Header"; var PurchLine: Record "Purchase Line")
var
CurrExchRate: Record "Currency Exchange Rate";
PurchLineAmount: Decimal;
begin
if not IsRecalculateAmount(
FromPurchHeader."Currency Code", ToPurchHeader."Currency Code",
FromPurchHeader."Prices Including VAT", ToPurchHeader."Prices Including VAT")
then
exit;
if FromPurchHeader."Currency Code" <> ToPurchHeader."Currency Code" then begin
if PurchLine.Quantity <> 0 then
PurchLineAmount := PurchLine."Direct Unit Cost" * PurchLine.Quantity
else
PurchLineAmount := PurchLine."Direct Unit Cost";
if FromPurchHeader."Currency Code" <> '' then begin
PurchLineAmount :=
CurrExchRate.ExchangeAmtFCYToLCY(
FromPurchHeader."Posting Date", FromPurchHeader."Currency Code",
PurchLineAmount, FromPurchHeader."Currency Factor");
PurchLine."Line Discount Amount" :=
CurrExchRate.ExchangeAmtFCYToLCY(
FromPurchHeader."Posting Date", FromPurchHeader."Currency Code",
PurchLine."Line Discount Amount", FromPurchHeader."Currency Factor");
PurchLine."Inv. Discount Amount" :=
CurrExchRate.ExchangeAmtFCYToLCY(
FromPurchHeader."Posting Date", FromPurchHeader."Currency Code",
PurchLine."Inv. Discount Amount", FromPurchHeader."Currency Factor");
end;
if ToPurchHeader."Currency Code" <> '' then begin
PurchLineAmount :=
CurrExchRate.ExchangeAmtLCYToFCY(
ToPurchHeader."Posting Date", ToPurchHeader."Currency Code", PurchLineAmount, ToPurchHeader."Currency Factor");
PurchLine."Line Discount Amount" :=
CurrExchRate.ExchangeAmtLCYToFCY(
ToPurchHeader."Posting Date", ToPurchHeader."Currency Code", PurchLine."Line Discount Amount", ToPurchHeader."Currency Factor");
PurchLine."Inv. Discount Amount" :=
CurrExchRate.ExchangeAmtLCYToFCY(
ToPurchHeader."Posting Date", ToPurchHeader."Currency Code", PurchLine."Inv. Discount Amount", ToPurchHeader."Currency Factor");
end;
end;
PurchLine."Currency Code" := ToPurchHeader."Currency Code";
if PurchLine.Quantity <> 0 then begin
PurchLineAmount := Round(PurchLineAmount, Currency."Amount Rounding Precision");
PurchLine."Direct Unit Cost" := Round(PurchLineAmount / PurchLine.Quantity, Currency."Unit-Amount Rounding Precision");
end else
PurchLine."Direct Unit Cost" := Round(PurchLineAmount, Currency."Unit-Amount Rounding Precision");
PurchLine."Line Discount Amount" := Round(PurchLine."Line Discount Amount", Currency."Amount Rounding Precision");
PurchLine."Inv. Discount Amount" := Round(PurchLine."Inv. Discount Amount", Currency."Amount Rounding Precision");
OnReCalcPurchLineOnBeforeCalcVAT(FromPurchHeader, ToPurchHeader, PurchLine);
CalcVAT(
PurchLine."Direct Unit Cost", PurchLine."VAT %", FromPurchHeader."Prices Including VAT",
ToPurchHeader."Prices Including VAT", Currency."Unit-Amount Rounding Precision");
CalcVAT(
PurchLine."Line Discount Amount", PurchLine."VAT %", FromPurchHeader."Prices Including VAT",
ToPurchHeader."Prices Including VAT", Currency."Amount Rounding Precision");
CalcVAT(
PurchLine."Inv. Discount Amount", PurchLine."VAT %", FromPurchHeader."Prices Including VAT",
ToPurchHeader."Prices Including VAT", Currency."Amount Rounding Precision");
end;
procedure IsRecalculateAmount(FromCurrencyCode: Code[10]; ToCurrencyCode: Code[10]; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean): Boolean
begin
exit(
(FromCurrencyCode <> ToCurrencyCode) or
(FromPricesInclVAT <> ToPricesInclVAT));
end;
local procedure UpdateRevSalesLineAmount(var SalesLine: Record "Sales Line"; OrgQtyBase: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean)
var
Amount: Decimal;
begin
if (OrgQtyBase = 0) or (SalesLine.Quantity = 0) or
((FromPricesInclVAT = ToPricesInclVAT) and (OrgQtyBase = SalesLine."Quantity (Base)"))
then
exit;
Amount := SalesLine.Quantity * SalesLine."Unit Price";
CalcVAT(
Amount, SalesLine."VAT %", FromPricesInclVAT, ToPricesInclVAT, Currency."Amount Rounding Precision");
SalesLine."Unit Price" := Amount / SalesLine.Quantity;
SalesLine."Line Discount Amount" :=
Round(
Round(SalesLine.Quantity * SalesLine."Unit Price", Currency."Amount Rounding Precision") *
SalesLine."Line Discount %" / 100,
Currency."Amount Rounding Precision");
Amount :=
Round(SalesLine."Inv. Discount Amount" / OrgQtyBase * SalesLine."Quantity (Base)", Currency."Amount Rounding Precision");
CalcVAT(
Amount, SalesLine."VAT %", FromPricesInclVAT, ToPricesInclVAT, Currency."Amount Rounding Precision");
SalesLine."Inv. Discount Amount" := Amount;
OnAfterUpdateRevSalesLineAmount(SalesLine, OrgQtyBase, FromPricesInclVAT, ToPricesInclVAT);
end;
procedure CalculateRevSalesLineAmount(var SalesLine: Record "Sales Line"; OrgQtyBase: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean)
var
UnitPrice: Decimal;
LineDiscAmt: Decimal;
InvDiscAmt: Decimal;
begin
UpdateRevSalesLineAmount(SalesLine, OrgQtyBase, FromPricesInclVAT, ToPricesInclVAT);
UnitPrice := SalesLine."Unit Price";
LineDiscAmt := SalesLine."Line Discount Amount";
InvDiscAmt := SalesLine."Inv. Discount Amount";
SalesLine.Validate("Unit Price", UnitPrice);
SalesLine.Validate("Line Discount Amount", LineDiscAmt);
SalesLine.Validate("Inv. Discount Amount", InvDiscAmt);
end;
local procedure UpdateRevPurchLineAmount(var PurchLine: Record "Purchase Line"; OrgQtyBase: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean)
var
Amount: Decimal;
begin
if (OrgQtyBase = 0) or (PurchLine.Quantity = 0) or
((FromPricesInclVAT = ToPricesInclVAT) and (OrgQtyBase = PurchLine."Quantity (Base)"))
then
exit;
Amount := PurchLine.Quantity * PurchLine."Direct Unit Cost";
CalcVAT(
Amount, PurchLine."VAT %", FromPricesInclVAT, ToPricesInclVAT, Currency."Amount Rounding Precision");
PurchLine."Direct Unit Cost" := Amount / PurchLine.Quantity;
PurchLine."Line Discount Amount" :=
Round(
Round(PurchLine.Quantity * PurchLine."Direct Unit Cost", Currency."Amount Rounding Precision") *
PurchLine."Line Discount %" / 100,
Currency."Amount Rounding Precision");
Amount :=
Round(PurchLine."Inv. Discount Amount" / Abs(OrgQtyBase) * PurchLine."Quantity (Base)", Currency."Amount Rounding Precision");
CalcVAT(
Amount, PurchLine."VAT %", FromPricesInclVAT, ToPricesInclVAT, Currency."Amount Rounding Precision");
PurchLine."Inv. Discount Amount" := Amount;
OnAfterUpdateRevPurchLineAmount(PurchLine, OrgQtyBase, FromPricesInclVAT, ToPricesInclVAT);
end;
procedure CalculateRevPurchLineAmount(var PurchLine: Record "Purchase Line"; OrgQtyBase: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean)
var
DirectUnitCost: Decimal;
LineDiscAmt: Decimal;
InvDiscAmt: Decimal;
begin
UpdateRevPurchLineAmount(PurchLine, OrgQtyBase, FromPricesInclVAT, ToPricesInclVAT);
DirectUnitCost := PurchLine."Direct Unit Cost";
LineDiscAmt := PurchLine."Line Discount Amount";
InvDiscAmt := PurchLine."Inv. Discount Amount";
PurchLine.Validate("Direct Unit Cost", DirectUnitCost);
PurchLine.Validate("Line Discount Amount", LineDiscAmt);
PurchLine.Validate("Inv. Discount Amount", InvDiscAmt);
end;
local procedure InitCurrency(CurrencyCode: Code[10])
begin
if CurrencyCode <> '' then
Currency.Get(CurrencyCode)
else
Currency.InitRoundingPrecision();
Currency.TestField("Unit-Amount Rounding Precision");
Currency.TestField("Amount Rounding Precision");
end;
procedure SetHideProcessWindow(NewHideProcessWindow: Boolean)
begin
HideProcessWindow := NewHideProcessWindow;
end;
local procedure OpenWindow()
begin
if not HideProcessWindow then begin
Window.Open(
Text022 +
Text023 +
Text024);
WindowUpdateDateTime := CurrentDateTime;
end;
end;
local procedure CloseWindow()
begin
if not HideProcessWindow then
Window.Close();
end;
local procedure UpdateWindow(Number: Integer; CounterValue: Integer)
begin
if not HideProcessWindow then
Window.Update(Number, CounterValue);
end;
procedure IsTimeForUpdate(): Boolean
begin
if HideProcessWindow then
exit(false);
if CurrentDateTime - WindowUpdateDateTime >= 1000 then begin
WindowUpdateDateTime := CurrentDateTime;
exit(true);
end;
exit(false);
end;
local procedure ConfirmApply()
begin
AskApply := false;
ApplyFully := false;
end;
local procedure ConvertFromBase(var Quantity: Decimal; QuantityBase: Decimal; QtyPerUOM: Decimal)
begin
if QtyPerUOM = 0 then
Quantity := QuantityBase
else
Quantity := Round(QuantityBase / QtyPerUOM, UOMMgt.QtyRndPrecision());
end;
local procedure Sign(Quantity: Decimal): Decimal
begin
if Quantity < 0 then
exit(-1);
exit(1);
end;
procedure ShowMessageReapply(OriginalQuantity: Boolean)
var
Text: Text[1024];
begin
Text := '';
if SkippedLine then
Text := Text029;
if OriginalQuantity and ReappDone then
if Text = '' then
Text := Text025;
if SomeAreFixed then
Message(Text031);
if Text <> '' then
Message(Text);
end;
procedure LinkJobPlanningLine(SalesHeader: Record "Sales Header")
var
SalesLine: Record "Sales Line";
JobPlanningLine: Record "Job Planning Line";
JobPlanningLineInvoice: Record "Job Planning Line Invoice";
begin
JobPlanningLine.SetCurrentKey("Job Contract Entry No.");
SalesLine.SetRange("Document Type", SalesHeader."Document Type");
SalesLine.SetRange("Document No.", SalesHeader."No.");
repeat
JobPlanningLine.SetRange("Job Contract Entry No.", SalesLine."Job Contract Entry No.");
if JobPlanningLine.FindFirst() then begin
JobPlanningLineInvoice."Job No." := JobPlanningLine."Job No.";
JobPlanningLineInvoice."Job Task No." := JobPlanningLine."Job Task No.";
JobPlanningLineInvoice."Job Planning Line No." := JobPlanningLine."Line No.";
case SalesHeader."Document Type" of
SalesHeader."Document Type"::Invoice:
begin
JobPlanningLineInvoice."Document Type" := JobPlanningLineInvoice."Document Type"::Invoice;
JobPlanningLineInvoice."Quantity Transferred" := SalesLine.Quantity;
end;
SalesHeader."Document Type"::"Credit Memo":
begin
JobPlanningLineInvoice."Document Type" := JobPlanningLineInvoice."Document Type"::"Credit Memo";
JobPlanningLineInvoice."Quantity Transferred" := -SalesLine.Quantity;
end;
else
exit;
end;
JobPlanningLineInvoice."Document No." := SalesHeader."No.";
JobPlanningLineInvoice."Line No." := SalesLine."Line No.";
JobPlanningLineInvoice."Transferred Date" := SalesHeader."Posting Date";
JobPlanningLineInvoice.Insert();
JobPlanningLine.UpdateQtyToTransfer();
JobPlanningLine.Modify();
OnLinkJobPlanningLineOnAfterJobPlanningLineModify(JobPlanningLineInvoice, JobPlanningLine);
end;
until SalesLine.Next() = 0;
end;
local procedure GetQtyOfPurchILENotShipped(ItemLedgerEntryNo: Integer; FromPurchLine: Record "Purchase Line"): Decimal
var
ItemApplicationEntry: Record "Item Application Entry";
ItemLedgerEntryLocal: Record "Item Ledger Entry";
QtyNotShipped: Decimal;
begin
QtyNotShipped := 0;
ItemApplicationEntry.Reset();
ItemApplicationEntry.SetCurrentKey("Inbound Item Entry No.", "Outbound Item Entry No.");
ItemApplicationEntry.SetRange("Inbound Item Entry No.", ItemLedgerEntryNo);
ItemApplicationEntry.SetRange("Outbound Item Entry No.", 0);
if not ItemApplicationEntry.FindFirst() then
exit(QtyNotShipped);
QtyNotShipped := ItemApplicationEntry.Quantity;
ItemApplicationEntry.SetFilter("Outbound Item Entry No.", '<>0');
if not ItemApplicationEntry.FindSet(false) then begin
if FromPurchLine."Copied From Posted Doc." and (FromPurchLine."Receipt No." <> '') then begin
ItemLedgerEntryLocal.SetLoadFields("Invoiced Quantity");
ItemLedgerEntryLocal.Get(ItemLedgerEntryNo);
if Abs(ItemLedgerEntryLocal."Invoiced Quantity") < Abs(QtyNotShipped) then
QtyNotShipped := ItemLedgerEntryLocal."Invoiced Quantity";
end;
exit(QtyNotShipped);
end;
repeat
ItemLedgerEntryLocal.Get(ItemApplicationEntry."Outbound Item Entry No.");
if (ItemLedgerEntryLocal."Entry Type" in
[ItemLedgerEntryLocal."Entry Type"::Sale,
ItemLedgerEntryLocal."Entry Type"::Purchase]) or
((ItemLedgerEntryLocal."Entry Type" in
[ItemLedgerEntryLocal."Entry Type"::"Positive Adjmt.", ItemLedgerEntryLocal."Entry Type"::"Negative Adjmt."]) and
(ItemLedgerEntryLocal."Job No." = ''))
then
QtyNotShipped += ItemApplicationEntry.Quantity;
until ItemApplicationEntry.Next() = 0;
exit(QtyNotShipped);
end;
local procedure CopyAsmOrderToAsmOrder(var TempFromAsmHeader: Record "Assembly Header" temporary; var TempFromAsmLine: Record "Assembly Line" temporary; ToSalesLine: Record "Sales Line"; ToAsmHeaderDocType: Option; ToAsmHeaderDocNo: Code[20]; InclAsmHeader: Boolean)
var
FromAsmHeader: Record "Assembly Header";
ToAsmHeader: Record "Assembly Header";
TempToAsmHeader: Record "Assembly Header" temporary;
AssembleToOrderLink: Record "Assemble-to-Order Link";
ToAsmLine: Record "Assembly Line";
BasicAsmOrderCopy: Boolean;
begin
OnBeforeCopyAsmOrderToAsmOrderProcedure(TempFromAsmHeader, TempFromAsmLine, ToSalesLine, ToAsmHeaderDocType, ToAsmHeaderDocNo, InclAsmHeader);
if ToAsmHeaderDocType = -1 then
exit;
BasicAsmOrderCopy := ToAsmHeaderDocNo <> '';
if BasicAsmOrderCopy then
ToAsmHeader.Get(ToAsmHeaderDocType, ToAsmHeaderDocNo)
else begin
if ToSalesLine.AsmToOrderExists(FromAsmHeader) then
exit;
Clear(ToAsmHeader);
AssembleToOrderLink.InsertAsmHeader(ToAsmHeader, "Assembly Document Type".FromInteger(ToAsmHeaderDocType), '');
InclAsmHeader := true;
end;
if InclAsmHeader then begin
if BasicAsmOrderCopy then begin
TempToAsmHeader := ToAsmHeader;
TempToAsmHeader.Insert();
ProcessToAsmHeader(TempToAsmHeader, TempFromAsmHeader, ToSalesLine, true, true); // Basic, Availabilitycheck
CheckAsmOrderAvailability(TempToAsmHeader, TempFromAsmLine, ToSalesLine);
end;
ProcessToAsmHeader(ToAsmHeader, TempFromAsmHeader, ToSalesLine, BasicAsmOrderCopy, false);
end else
if BasicAsmOrderCopy then
CheckAsmOrderAvailability(ToAsmHeader, TempFromAsmLine, ToSalesLine);
CreateToAsmLines(ToAsmHeader, TempFromAsmLine, ToAsmLine, ToSalesLine, BasicAsmOrderCopy, false);
if not BasicAsmOrderCopy then begin
AssembleToOrderLink."Assembly Document Type" := ToAsmHeader."Document Type";
AssembleToOrderLink."Assembly Document No." := ToAsmHeader."No.";
AssembleToOrderLink.Type := AssembleToOrderLink.Type::Sale;
AssembleToOrderLink."Document Type" := ToSalesLine."Document Type";
AssembleToOrderLink."Document No." := ToSalesLine."Document No.";
AssembleToOrderLink."Document Line No." := ToSalesLine."Line No.";
AssembleToOrderLink.Insert();
if ToSalesLine."Document Type" = ToSalesLine."Document Type"::Order then begin
if ToSalesLine."Shipment Date" = 0D then begin
ToSalesLine."Shipment Date" := ToAsmHeader."Due Date";
OnCopyAsmOrderToAsmOrderOnBeforeModifySalesLine(ToSalesLine);
ToSalesLine.Modify();
end;
AssembleToOrderLink.ReserveAsmToSale(ToSalesLine, ToSalesLine.Quantity, ToSalesLine."Quantity (Base)");
end;
end;
ToAsmHeader.ShowDueDateBeforeWorkDateMsg();
end;
procedure CopyAsmHeaderToAsmHeader(FromAsmHeader: Record "Assembly Header"; ToAsmHeader: Record "Assembly Header"; IncludeHeader: Boolean)
var
EmptyToSalesLine: Record "Sales Line";
begin
InitialToAsmHeaderCheck(ToAsmHeader, IncludeHeader);
GenerateAsmDataFromNonPosted(FromAsmHeader);
Clear(EmptyToSalesLine);
EmptyToSalesLine.Init();
CopyAsmOrderToAsmOrder(
TempAsmHeader, TempAsmLine, EmptyToSalesLine, ToAsmHeader."Document Type".AsInteger(), ToAsmHeader."No.", IncludeHeader);
end;
procedure CopyPostedAsmHeaderToAsmHeader(PostedAsmHeader: Record "Posted Assembly Header"; ToAsmHeader: Record "Assembly Header"; IncludeHeader: Boolean)
var
EmptyToSalesLine: Record "Sales Line";
begin
InitialToAsmHeaderCheck(ToAsmHeader, IncludeHeader);
GenerateAsmDataFromPosted(PostedAsmHeader, "Assembly Document Type"::Quote);
Clear(EmptyToSalesLine);
EmptyToSalesLine.Init();
CopyAsmOrderToAsmOrder(
TempAsmHeader, TempAsmLine, EmptyToSalesLine, ToAsmHeader."Document Type".AsInteger(), ToAsmHeader."No.", IncludeHeader);
end;
local procedure GenerateAsmDataFromNonPosted(AsmHeader: Record "Assembly Header")
var
AsmLine: Record "Assembly Line";
begin
InitAsmCopyHandling(false);
TempAsmHeader := AsmHeader;
TempAsmHeader.Insert();
AsmLine.SetRange("Document Type", AsmHeader."Document Type");
AsmLine.SetRange("Document No.", AsmHeader."No.");
if AsmLine.FindSet() then
repeat
TempAsmLine := AsmLine;
TempAsmLine.Insert();
until AsmLine.Next() = 0;
end;
local procedure GenerateAsmDataFromPosted(PostedAssemblyHeader: Record "Posted Assembly Header"; DocType: Enum "Assembly Document Type")
var
PostedAsmLine: Record "Posted Assembly Line";
begin
InitAsmCopyHandling(false);
TempAsmHeader.TransferFields(PostedAssemblyHeader);
OnAfterTransferTempAsmHeader(TempAsmHeader, PostedAssemblyHeader);
TempAsmHeader."Document Type" := DocType;
TempAsmHeader.Insert();
PostedAsmLine.SetRange("Document No.", PostedAssemblyHeader."No.");
if PostedAsmLine.FindSet() then
repeat
TempAsmLine.TransferFields(PostedAsmLine);
TempAsmLine."Document No." := TempAsmHeader."No.";
TempAsmLine."Cost Amount" := PostedAsmLine.Quantity * PostedAsmLine."Unit Cost";
TempAsmLine.Insert();
until PostedAsmLine.Next() = 0;
end;
local procedure GetAsmDataFromSalesInvLine(DocType: Enum "Sales Document Type"): Boolean
var
ValueEntry: Record "Value Entry";
ValueEntry2: Record "Value Entry";
ItemLedgerEntry: Record "Item Ledger Entry";
ItemLedgerEntry2: Record "Item Ledger Entry";
SalesShipmentLine: Record "Sales Shipment Line";
PostedAssemblyHeader: Record "Posted Assembly Header";
begin
if TempSalesInvLine.Type <> TempSalesInvLine.Type::Item then
exit(false);
ValueEntry.SetCurrentKey("Document No.");
ValueEntry.SetRange("Document No.", TempSalesInvLine."Document No.");
ValueEntry.SetRange("Document Type", ValueEntry."Document Type"::"Sales Invoice");
ValueEntry.SetRange("Document Line No.", TempSalesInvLine."Line No.");
if not ValueEntry.FindFirst() then
exit(false);
if not ItemLedgerEntry.Get(ValueEntry."Item Ledger Entry No.") then
exit(false);
if ItemLedgerEntry."Document Type" <> ItemLedgerEntry."Document Type"::"Sales Shipment" then
exit(false);
SalesShipmentLine.Get(ItemLedgerEntry."Document No.", ItemLedgerEntry."Document Line No.");
if not SalesShipmentLine.AsmToShipmentExists(PostedAssemblyHeader) then
exit(false);
if ValueEntry.Count > 1 then begin
ValueEntry2.Copy(ValueEntry);
ValueEntry2.SetFilter("Item Ledger Entry No.", '<>%1', ValueEntry."Item Ledger Entry No.");
if ValueEntry2.FindSet() then
repeat
ItemLedgerEntry2.Get(ValueEntry2."Item Ledger Entry No.");
if (ItemLedgerEntry2."Document Type" <> ItemLedgerEntry."Document Type") or
(ItemLedgerEntry2."Document No." <> ItemLedgerEntry."Document No.") or
(ItemLedgerEntry2."Document Line No." <> ItemLedgerEntry."Document Line No.")
then
Error(Text032, TempSalesInvLine."Document No.");
until ValueEntry2.Next() = 0;
end;
GenerateAsmDataFromPosted(PostedAssemblyHeader, DocType);
exit(true);
end;
procedure InitAsmCopyHandling(ResetQuantities: Boolean)
begin
if ResetQuantities then begin
QtyToAsmToOrder := 0;
QtyToAsmToOrderBase := 0;
end;
TempAsmHeader.DeleteAll();
TempAsmLine.DeleteAll();
end;
local procedure RetrieveSalesInvLine(SalesLine: Record "Sales Line"; PosNo: Integer; LineCountsEqual: Boolean): Boolean
begin
if not LineCountsEqual then
exit(false);
TempSalesInvLine.FindSet();
if PosNo > 1 then
TempSalesInvLine.Next(PosNo - 1);
exit((SalesLine.Type = TempSalesInvLine.Type) and (SalesLine."No." = TempSalesInvLine."No."));
end;
procedure InitialToAsmHeaderCheck(ToAsmHeader: Record "Assembly Header"; IncludeHeader: Boolean)
begin
ToAsmHeader.TestField("No.");
if IncludeHeader then begin
ToAsmHeader.TestField("Item No.", '');
ToAsmHeader.TestField(Quantity, 0);
end else begin
ToAsmHeader.TestField("Item No.");
ToAsmHeader.TestField(Quantity);
end;
end;
local procedure GetAsmOrderType(SalesLineDocType: Enum "Sales Document Type"): Integer
begin
if SalesLineDocType in [SalesLineDocType::Quote, SalesLineDocType::Order, SalesLineDocType::"Blanket Order"] then
exit(SalesLineDocType.AsInteger());
exit(-1);
end;
local procedure ProcessToAsmHeader(var ToAsmHeader: Record "Assembly Header"; TempFromAsmHeader: Record "Assembly Header" temporary; ToSalesLine: Record "Sales Line"; BasicAsmOrderCopy: Boolean; AvailabilityCheck: Boolean)
begin
if AvailabilityCheck then begin
ToAsmHeader."Item No." := TempFromAsmHeader."Item No.";
ToAsmHeader."Location Code" := TempFromAsmHeader."Location Code";
ToAsmHeader."Variant Code" := TempFromAsmHeader."Variant Code";
ToAsmHeader."Unit of Measure Code" := TempFromAsmHeader."Unit of Measure Code";
end else begin
ToAsmHeader.Validate(ToAsmHeader."Item No.", TempFromAsmHeader."Item No.");
ToAsmHeader.Validate(ToAsmHeader."Location Code", TempFromAsmHeader."Location Code");
ToAsmHeader.Validate(ToAsmHeader."Variant Code", TempFromAsmHeader."Variant Code");
ToAsmHeader.Validate(ToAsmHeader."Unit of Measure Code", TempFromAsmHeader."Unit of Measure Code");
end;
if BasicAsmOrderCopy then begin
ToAsmHeader.Validate(ToAsmHeader."Due Date", TempFromAsmHeader."Due Date");
ToAsmHeader.Quantity := TempFromAsmHeader.Quantity;
ToAsmHeader."Quantity (Base)" := TempFromAsmHeader."Quantity (Base)";
end else begin
if ToSalesLine."Shipment Date" <> 0D then
ToAsmHeader.Validate(ToAsmHeader."Due Date", ToSalesLine."Shipment Date");
ToAsmHeader.Quantity := QtyToAsmToOrder;
ToAsmHeader."Quantity (Base)" := QtyToAsmToOrderBase;
end;
OnProcessToAsmHeaderOnAfterValidateQty(ToAsmHeader, TempFromAsmHeader, ToSalesLine, BasicAsmOrderCopy, AvailabilityCheck);
ToAsmHeader."Bin Code" := TempFromAsmHeader."Bin Code";
ToAsmHeader."Unit Cost" := TempFromAsmHeader."Unit Cost";
ToAsmHeader.RoundQty(ToAsmHeader.Quantity);
ToAsmHeader.RoundQty(ToAsmHeader."Quantity (Base)");
ToAsmHeader."Cost Amount" := Round(ToAsmHeader.Quantity * ToAsmHeader."Unit Cost");
ToAsmHeader.InitRemainingQty();
ToAsmHeader.InitQtyToAssemble();
if not AvailabilityCheck then begin
ToAsmHeader.Validate(ToAsmHeader."Quantity to Assemble");
ToAsmHeader.Validate(ToAsmHeader."Planning Flexibility", TempFromAsmHeader."Planning Flexibility");
end;
CopyFromAsmOrderDimToHdr(ToAsmHeader, TempFromAsmHeader, ToSalesLine);
ToAsmHeader.Modify();
OnAfterProcessToAsmHeader(ToAsmHeader, TempFromAsmHeader, ToSalesLine, BasicAsmOrderCopy, AvailabilityCheck);
end;
local procedure CreateToAsmLines(ToAsmHeader: Record "Assembly Header"; var FromAsmLine: Record "Assembly Line"; var ToAssemblyLine: Record "Assembly Line"; ToSalesLine: Record "Sales Line"; BasicAsmOrderCopy: Boolean; AvailabilityCheck: Boolean)
var
AssemblyLineMgt: Codeunit "Assembly Line Management";
begin
if FromAsmLine.FindSet() then
repeat
ToAssemblyLine.Init();
ToAssemblyLine."Document Type" := ToAsmHeader."Document Type";
ToAssemblyLine."Document No." := ToAsmHeader."No.";
ToAssemblyLine."Line No." := AssemblyLineMgt.GetNextAsmLineNo(ToAssemblyLine, AvailabilityCheck);
ToAssemblyLine.Insert(not AvailabilityCheck);
if AvailabilityCheck then begin
ToAssemblyLine.Type := FromAsmLine.Type;
ToAssemblyLine."No." := FromAsmLine."No.";
ToAssemblyLine."Resource Usage Type" := FromAsmLine."Resource Usage Type";
ToAssemblyLine."Unit of Measure Code" := FromAsmLine."Unit of Measure Code";
ToAssemblyLine."Quantity per" := FromAsmLine."Quantity per";
ToAssemblyLine.Quantity := GetAppliedQuantityForAsmLine(BasicAsmOrderCopy, ToAsmHeader, FromAsmLine, ToSalesLine);
end else begin
ToAssemblyLine.Validate(Type, FromAsmLine.Type);
ToAssemblyLine.Validate("No.", FromAsmLine."No.");
ToAssemblyLine.Validate("Resource Usage Type", FromAsmLine."Resource Usage Type");
ToAssemblyLine.Validate("Unit of Measure Code", FromAsmLine."Unit of Measure Code");
if ToAssemblyLine.Type <> ToAssemblyLine.Type::" " then
ToAssemblyLine.Validate("Quantity per", FromAsmLine."Quantity per");
ToAssemblyLine.Validate(Quantity, GetAppliedQuantityForAsmLine(BasicAsmOrderCopy, ToAsmHeader, FromAsmLine, ToSalesLine));
end;
OnCreateToAsmLinesOnAfterValidateQty(ToAsmHeader, FromAsmLine, ToAssemblyLine, ToSalesLine, BasicAsmOrderCopy, AvailabilityCheck);
ToAssemblyLine.ValidateDueDate(ToAsmHeader, ToAsmHeader."Starting Date", false);
ToAssemblyLine.ValidateLeadTimeOffset(ToAsmHeader, FromAsmLine."Lead-Time Offset", false);
ToAssemblyLine.Description := FromAsmLine.Description;
ToAssemblyLine."Description 2" := FromAsmLine."Description 2";
ToAssemblyLine.Position := FromAsmLine.Position;
ToAssemblyLine."Position 2" := FromAsmLine."Position 2";
ToAssemblyLine."Position 3" := FromAsmLine."Position 3";
if ToAssemblyLine.Type = ToAssemblyLine.Type::Item then
if AvailabilityCheck then begin
ToAssemblyLine."Location Code" := FromAsmLine."Location Code";
ToAssemblyLine."Variant Code" := FromAsmLine."Variant Code";
end else begin
ToAssemblyLine.Validate("Location Code", FromAsmLine."Location Code");
ToAssemblyLine.Validate("Variant Code", FromAsmLine."Variant Code");
end;
if ToAssemblyLine.Type <> ToAssemblyLine.Type::" " then begin
if RecalculateLines then
ToAssemblyLine."Unit Cost" := ToAssemblyLine.GetUnitCost()
else
ToAssemblyLine."Unit Cost" := FromAsmLine."Unit Cost";
ToAssemblyLine."Cost Amount" := ToAssemblyLine.CalcCostAmount(ToAssemblyLine.Quantity, ToAssemblyLine."Unit Cost");
if AvailabilityCheck then begin
ToAssemblyLine."Quantity (Base)" :=
UOMMgt.CalcBaseQty(
ToAssemblyLine."No.", ToAssemblyLine."Variant Code", ToAssemblyLine."Unit of Measure Code",
ToAssemblyLine.Quantity, ToAssemblyLine."Qty. per Unit of Measure");
ToAssemblyLine."Remaining Quantity" := ToAssemblyLine."Quantity (Base)";
ToAssemblyLine.InitQtyToConsume();
end else begin
ToAssemblyLine.InitQtyToConsume();
ToAssemblyLine.Validate("Quantity to Consume");
end;
end;
CopyFromAsmOrderDimToLine(ToAssemblyLine, FromAsmLine, BasicAsmOrderCopy);
OnCreateToAsmLinesOnBeforeToAssemblyLineModify(ToAsmHeader, ToAssemblyLine, FromAsmLine, ToSalesLine, BasicAsmOrderCopy, AvailabilityCheck);
ToAssemblyLine.Modify(not AvailabilityCheck);
until FromAsmLine.Next() = 0;
end;
local procedure CheckAsmOrderAvailability(ToAsmHeader: Record "Assembly Header"; var FromAsmLine: Record "Assembly Line"; ToSalesLine: Record "Sales Line")
var
TempToAsmHeader: Record "Assembly Header" temporary;
TempToAsmLine: Record "Assembly Line" temporary;
AsmLineOnDestinationOrder: Record "Assembly Line";
AssemblyLineMgt: Codeunit "Assembly Line Management";
LineNo: Integer;
begin
TempToAsmHeader := ToAsmHeader;
TempToAsmHeader.Insert();
CreateToAsmLines(TempToAsmHeader, FromAsmLine, TempToAsmLine, ToSalesLine, true, true);
if TempToAsmLine.FindLast() then
LineNo := TempToAsmLine."Line No.";
Clear(TempToAsmLine);
AsmLineOnDestinationOrder.SetRange("Document Type", ToAsmHeader."Document Type");
AsmLineOnDestinationOrder.SetRange("Document No.", ToAsmHeader."No.");
AsmLineOnDestinationOrder.SetRange(Type, AsmLineOnDestinationOrder.Type::Item);
if AsmLineOnDestinationOrder.FindSet() then
repeat
TempToAsmLine := AsmLineOnDestinationOrder;
LineNo += 10000;
TempToAsmLine."Line No." := LineNo;
TempToAsmLine.Insert();
until AsmLineOnDestinationOrder.Next() = 0;
if AssemblyLineMgt.ShowAvailability(false, TempToAsmHeader, TempToAsmLine) then
ItemCheckAvail.RaiseUpdateInterruptedError();
TempToAsmLine.DeleteAll();
end;
local procedure GetAppliedQuantityForAsmLine(BasicAsmOrderCopy: Boolean; ToAsmHeader: Record "Assembly Header"; TempFromAsmLine: Record "Assembly Line" temporary; ToSalesLine: Record "Sales Line"): Decimal
begin
if (TempFromAsmLine.Type = TempFromAsmLine.Type::Resource) and
(TempFromAsmLine."Resource Usage Type" = TempFromAsmLine."Resource Usage Type"::Fixed)
then
exit(TempFromAsmLine."Quantity per");
if BasicAsmOrderCopy then
exit(ToAsmHeader.Quantity * TempFromAsmLine."Quantity per");
case ToSalesLine."Document Type" of
ToSalesLine."Document Type"::Order:
exit(ToSalesLine."Qty. to Assemble to Order" * TempFromAsmLine."Quantity per");
ToSalesLine."Document Type"::Quote,
ToSalesLine."Document Type"::"Blanket Order":
exit(ToSalesLine.Quantity * TempFromAsmLine."Quantity per");
end;
end;
local procedure CopyFromArchSalesDocDimToHdr(var ToSalesHeader: Record "Sales Header"; FromSalesHeaderArchive: Record "Sales Header Archive")
begin
ToSalesHeader."Shortcut Dimension 1 Code" := FromSalesHeaderArchive."Shortcut Dimension 1 Code";
ToSalesHeader."Shortcut Dimension 2 Code" := FromSalesHeaderArchive."Shortcut Dimension 2 Code";
ToSalesHeader."Dimension Set ID" := FromSalesHeaderArchive."Dimension Set ID";
OnAfterCopyFromArchSalesDocDimToHdr(ToSalesHeader, FromSalesHeaderArchive);
end;
local procedure CopyFromArchSalesDocDimToLine(var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive")
begin
if IncludeHeader then begin
ToSalesLine."Shortcut Dimension 1 Code" := FromSalesLineArchive."Shortcut Dimension 1 Code";
ToSalesLine."Shortcut Dimension 2 Code" := FromSalesLineArchive."Shortcut Dimension 2 Code";
ToSalesLine."Dimension Set ID" := FromSalesLineArchive."Dimension Set ID";
end;
OnAfterCopyFromArchSalesDocDimToLine(ToSalesLine, FromSalesLineArchive);
end;
local procedure CopyFromArchPurchDocDimToHdr(var ToPurchHeader: Record "Purchase Header"; FromPurchHeaderArchive: Record "Purchase Header Archive")
begin
ToPurchHeader."Shortcut Dimension 1 Code" := FromPurchHeaderArchive."Shortcut Dimension 1 Code";
ToPurchHeader."Shortcut Dimension 2 Code" := FromPurchHeaderArchive."Shortcut Dimension 2 Code";
ToPurchHeader."Dimension Set ID" := FromPurchHeaderArchive."Dimension Set ID";
end;
local procedure CopyFromArchPurchDocDimToLine(var ToPurchLine: Record "Purchase Line"; FromPurchLineArchive: Record "Purchase Line Archive")
begin
if IncludeHeader then begin
ToPurchLine."Shortcut Dimension 1 Code" := FromPurchLineArchive."Shortcut Dimension 1 Code";
ToPurchLine."Shortcut Dimension 2 Code" := FromPurchLineArchive."Shortcut Dimension 2 Code";
ToPurchLine."Dimension Set ID" := FromPurchLineArchive."Dimension Set ID";
end;
end;
local procedure CopyFromAsmOrderDimToHdr(var ToAssemblyHeader: Record "Assembly Header"; FromAssemblyHeader: Record "Assembly Header"; ToSalesLine: Record "Sales Line")
begin
if RecalculateLines then begin
ToAssemblyHeader."Dimension Set ID" := ToSalesLine."Dimension Set ID";
ToAssemblyHeader."Shortcut Dimension 1 Code" := ToSalesLine."Shortcut Dimension 1 Code";
ToAssemblyHeader."Shortcut Dimension 2 Code" := ToSalesLine."Shortcut Dimension 2 Code";
end else begin
ToAssemblyHeader."Dimension Set ID" := FromAssemblyHeader."Dimension Set ID";
ToAssemblyHeader."Shortcut Dimension 1 Code" := FromAssemblyHeader."Shortcut Dimension 1 Code";
ToAssemblyHeader."Shortcut Dimension 2 Code" := FromAssemblyHeader."Shortcut Dimension 2 Code";
end;
end;
local procedure CopyFromAsmOrderDimToLine(var ToAssemblyLine: Record "Assembly Line"; FromAssemblyLine: Record "Assembly Line"; BasicAsmOrderCopy: Boolean)
begin
if RecalculateLines or BasicAsmOrderCopy then
exit;
ToAssemblyLine."Dimension Set ID" := FromAssemblyLine."Dimension Set ID";
ToAssemblyLine."Shortcut Dimension 1 Code" := FromAssemblyLine."Shortcut Dimension 1 Code";
ToAssemblyLine."Shortcut Dimension 2 Code" := FromAssemblyLine."Shortcut Dimension 2 Code";
end;
procedure SetArchDocVal(DocOccurrencyNo: Integer; DocVersionNo: Integer)
begin
FromDocOccurrenceNo := DocOccurrencyNo;
FromDocVersionNo := DocVersionNo;
end;
procedure CopyArchSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeaderArchive: Record "Sales Header Archive"; var FromSalesLineArchive: Record "Sales Line Archive"; var NextLineNo: Integer; var LinesNotCopied: Integer; RecalculateAmount: Boolean): Boolean
var
SalesItem: Record Item;
LastInsertedSalesLine: Record "Sales Line";
VATPostingSetup: Record "VAT Posting Setup";
FromSalesHeader: Record "Sales Header";
FromSalesLine: Record "Sales Line";
CopyThisLine: Boolean;
IsHandled: Boolean;
ShouldRecalculateAmount: Boolean;
ShouldIncrementLinesNotCopied: Boolean;
begin
CopyThisLine := true;
OnBeforeCopyArchSalesLine(ToSalesHeader, FromSalesHeaderArchive, FromSalesLineArchive, RecalculateLines, CopyThisLine);
if not CopyThisLine then begin
LinesNotCopied := LinesNotCopied + 1;
exit(false);
end;
if ((ToSalesHeader."Language Code" <> FromSalesHeaderArchive."Language Code") or RecalculateLines) and
FromSalesLineArchive.IsExtendedText()
then
exit(false);
ToSalesLine.SetSalesHeader(ToSalesHeader);
if RecalculateLines and not FromSalesLineArchive."System-Created Entry" then
ToSalesLine.Init()
else
ToSalesLine.TransferFields(FromSalesLineArchive);
NextLineNo := NextLineNo + 10000;
OnCopyArchSalesLineOnAfterIncrementNextLineNo(ToSalesLine, FromSalesLineArchive, NextLineNo, ToSalesHeader);
ToSalesLine."Document Type" := ToSalesHeader."Document Type";
ToSalesLine."Document No." := ToSalesHeader."No.";
ToSalesLine."Line No." := NextLineNo;
ToSalesLine.Validate("Currency Code", FromSalesHeaderArchive."Currency Code");
if RecalculateLines and not FromSalesLineArchive."System-Created Entry" then begin
FromSalesHeader.TransferFields(FromSalesHeaderArchive, true);
FromSalesLine.TransferFields(FromSalesLineArchive, true);
RecalculateSalesLine(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, CopyThisLine);
end else begin
InitSalesLineFields(ToSalesLine);
OnCopyArchSalesLineOnAfterInitSalesLineFields(ToSalesLine, FromSalesLineArchive);
ToSalesLine.InitOutstanding();
if ToSalesLine."Document Type" in
[ToSalesLine."Document Type"::"Return Order", ToSalesLine."Document Type"::"Credit Memo"]
then
ToSalesLine.InitQtyToReceive()
else
ToSalesLine.InitQtyToShip();
ToSalesLine."VAT Difference" := FromSalesLineArchive."VAT Difference";
if not CreateToHeader then
ToSalesLine."Shipment Date" := ToSalesHeader."Shipment Date";
ToSalesLine."Appl.-from Item Entry" := 0;
ToSalesLine."Appl.-to Item Entry" := 0;
OnCopyArchSalesLineOnBeforeCleanSpecialOrderDropShipmentInSalesLine(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, CreateToHeader);
CleanSpecialOrderDropShipmentInSalesLine(ToSalesLine);
if RecalculateAmount and (FromSalesLineArchive."Appl.-from Item Entry" = 0) then begin
ToSalesLine.Validate("Line Discount %", FromSalesLineArchive."Line Discount %");
ToSalesLine.Validate(
"Inv. Discount Amount",
Round(FromSalesLineArchive."Inv. Discount Amount", Currency."Amount Rounding Precision"));
ToSalesLine.Validate("Unit Cost (LCY)", FromSalesLineArchive."Unit Cost (LCY)");
end;
if VATPostingSetup.Get(ToSalesLine."VAT Bus. Posting Group", ToSalesLine."VAT Prod. Posting Group") then
ToSalesLine."VAT Identifier" := VATPostingSetup."VAT Identifier";
ToSalesLine.UpdateWithWarehouseShip();
if (ToSalesLine.Type = ToSalesLine.Type::Item) and (ToSalesLine."No." <> '') then begin
SalesItem.Get(ToSalesLine."No.");
if (SalesItem."Costing Method" = SalesItem."Costing Method"::Standard) and not ToSalesLine.IsShipment() then
ToSalesLine.GetUnitCost();
end;
end;
ShouldRecalculateAmount := ExactCostRevMandatory and
(FromSalesLineArchive.Type = FromSalesLineArchive.Type::Item) and
(FromSalesLineArchive."Appl.-from Item Entry" <> 0) and
not MoveNegLines;
OnCopyArchSalesLineOnAfterCalcShouldRecalculateAmount(ToSalesLine, FromSalesLineArchive, ShouldRecalculateAmount);
if ShouldRecalculateAmount then begin
if RecalculateAmount then begin
ToSalesLine.Validate("Unit Price", FromSalesLineArchive."Unit Price");
ToSalesLine.Validate(
"Line Discount Amount",
Round(FromSalesLineArchive."Line Discount Amount", Currency."Amount Rounding Precision"));
ToSalesLine.Validate(
"Inv. Discount Amount",
Round(FromSalesLineArchive."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
ToSalesLine.Validate("Appl.-from Item Entry", FromSalesLineArchive."Appl.-from Item Entry");
if not CreateToHeader then
if ToSalesLine."Shipment Date" = 0D then
InitShipmentDateInLine(ToSalesHeader, ToSalesLine);
end;
if MoveNegLines and (ToSalesLine.Type <> ToSalesLine.Type::" ") then begin
ToSalesLine.Validate(Quantity, -FromSalesLineArchive.Quantity);
OnCopyArchSalesLineOnAfterValidateQuantityMoveNegLines(ToSalesLine, FromSalesLineArchive);
ToSalesLine.Validate("Line Discount %", FromSalesLineArchive."Line Discount %");
ToSalesLine."Appl.-to Item Entry" := FromSalesLineArchive."Appl.-to Item Entry";
ToSalesLine."Appl.-from Item Entry" := FromSalesLineArchive."Appl.-from Item Entry";
end;
IsHandled := false;
OnCopyArchSalesLineOnBeforeTransferExtendedText(ToSalesHeader, ToSalesLine, FromSalesHeaderArchive, FromSalesLineArchive, RecalculateLines, NextLineNo, TransferOldExtLines, IsHandled, MoveNegLines);
if not IsHandled then
if not ((ToSalesHeader."Language Code" <> FromSalesHeaderArchive."Language Code") or RecalculateLines) then begin
if FromSalesLineArchive.IsExtendedText() then
ToSalesLine."Attached to Line No." :=
TransferOldExtLines.TransferExtendedText(
FromSalesLineArchive."Line No.", NextLineNo, FromSalesLineArchive."Attached to Line No.");
end else
if TransferExtendedText.SalesCheckIfAnyExtText(ToSalesLine, false) then begin
TransferExtendedText.InsertSalesExtTextRetLast(ToSalesLine, LastInsertedSalesLine);
NextLineNo := LastInsertedSalesLine."Line No.";
end;
if CopyThisLine then begin
OnCopyArchSalesLineOnBeforeToSalesLineInsert(ToSalesLine, FromSalesLineArchive, RecalculateLines, NextLineNo, TransferOldExtLines, ToSalesHeader);
ToSalesLine.Insert();
OnCopyArchSalesLineOnAfterToSalesLineInsert(ToSalesLine, FromSalesLineArchive, RecalculateLines, NextLineNo);
end else begin
ShouldIncrementLinesNotCopied := true;
OnCopyArchSalesLineOnBeforeIncrementLinesNotCopied(FromSalesLineArchive, ShouldIncrementLinesNotCopied, LinesNotCopied);
if ShouldIncrementLinesNotCopied then
LinesNotCopied := LinesNotCopied + 1;
end;
exit(CopyThisLine);
end;
procedure CopyArchPurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeaderArchive: Record "Purchase Header Archive"; var FromPurchLineArchive: Record "Purchase Line Archive"; var NextLineNo: Integer; var LinesNotCopied: Integer; RecalculateAmount: Boolean): Boolean
var
LastInsertedPurchLine: Record "Purchase Line";
VATPostingSetup: Record "VAT Posting Setup";
FromPurchHeader: Record "Purchase Header";
FromPurchLine: Record "Purchase Line";
CopyThisLine: Boolean;
IsHandled: Boolean;
begin
CopyThisLine := true;
OnBeforeCopyArchPurchLine(ToPurchHeader, FromPurchHeaderArchive, FromPurchLineArchive, RecalculateLines, CopyThisLine);
if not CopyThisLine then begin
LinesNotCopied := LinesNotCopied + 1;
exit(false);
end;
if ((ToPurchHeader."Language Code" <> FromPurchHeaderArchive."Language Code") or RecalculateLines) and
FromPurchLineArchive.IsExtendedText()
then
exit(false);
if RecalculateLines and not FromPurchLineArchive."System-Created Entry" then
ToPurchLine.Init()
else
ToPurchLine.TransferFields(FromPurchLineArchive);
NextLineNo := NextLineNo + 10000;
OnCopyArchPurchLineOnAfterSetNextLineNo(ToPurchLine, FromPurchLineArchive, NextLineNo);
ToPurchLine."Document Type" := ToPurchHeader."Document Type";
ToPurchLine."Document No." := ToPurchHeader."No.";
ToPurchLine."Line No." := NextLineNo;
ToPurchLine.Validate("Currency Code", FromPurchHeaderArchive."Currency Code");
if RecalculateLines and not FromPurchLineArchive."System-Created Entry" then begin
FromPurchHeader.TransferFields(FromPurchHeaderArchive, true);
FromPurchLine.TransferFields(FromPurchLineArchive, true);
RecalculatePurchLine(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, CopyThisLine);
OnCopyArchPurchLineOnAfterRecalculatePurchLine(ToPurchLine, FromPurchLineArchive);
end else begin
InitPurchLineFields(ToPurchLine);
ToPurchLine.InitOutstanding();
if ToPurchLine."Document Type" in
[ToPurchLine."Document Type"::"Return Order", ToPurchLine."Document Type"::"Credit Memo"]
then
ToPurchLine.InitQtyToShip()
else
ToPurchLine.InitQtyToReceive();
ToPurchLine."VAT Difference" := FromPurchLineArchive."VAT Difference";
ToPurchLine."Receipt No." := '';
ToPurchLine."Receipt Line No." := 0;
if not CreateToHeader then
ToPurchLine."Expected Receipt Date" := ToPurchHeader."Expected Receipt Date";
ToPurchLine."Appl.-to Item Entry" := 0;
if FromPurchLineArchive."Drop Shipment" or FromPurchLineArchive."Special Order" then
ToPurchLine."Purchasing Code" := '';
OnCopyArchPurchLineOnBeforeCleanSpecialOrderDropShipmentInPurchLine(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, CreateToHeader);
CleanSpecialOrderDropShipmentInPurchLine(ToPurchLine);
if RecalculateAmount then begin
ToPurchLine.Validate("Line Discount %", FromPurchLineArchive."Line Discount %");
ToPurchLine.Validate(
"Inv. Discount Amount",
Round(FromPurchLineArchive."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
if VATPostingSetup.Get(ToPurchLine."VAT Bus. Posting Group", ToPurchLine."VAT Prod. Posting Group") then
ToPurchLine."VAT Identifier" := VATPostingSetup."VAT Identifier";
ToPurchLine.UpdateWithWarehouseReceive();
ToPurchLine."Pay-to Vendor No." := ToPurchHeader."Pay-to Vendor No.";
end;
OnCopyArchPurchLineOnBeforeCheckExactCostRevMandatory(ToPurchLine, FromPurchLineArchive);
if ExactCostRevMandatory and
(FromPurchLineArchive.Type = FromPurchLineArchive.Type::Item) and
(FromPurchLineArchive."Appl.-to Item Entry" <> 0) and
not MoveNegLines
then begin
if RecalculateAmount then begin
ToPurchLine.Validate("Direct Unit Cost", FromPurchLineArchive."Direct Unit Cost");
ToPurchLine.Validate(
"Line Discount Amount",
Round(FromPurchLineArchive."Line Discount Amount", Currency."Amount Rounding Precision"));
ToPurchLine.Validate(
"Inv. Discount Amount",
Round(FromPurchLineArchive."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
ToPurchLine.Validate("Appl.-to Item Entry", FromPurchLineArchive."Appl.-to Item Entry");
if not CreateToHeader then
if ToPurchLine."Expected Receipt Date" = 0D then
if ToPurchHeader."Expected Receipt Date" <> 0D then
ToPurchLine."Expected Receipt Date" := ToPurchHeader."Expected Receipt Date"
else
ToPurchLine."Expected Receipt Date" := WorkDate();
end;
if MoveNegLines and (ToPurchLine.Type <> ToPurchLine.Type::" ") then begin
ToPurchLine.Validate(Quantity, -FromPurchLineArchive.Quantity);
OnCopyArchPurchLineOnAfterValidateQuantityMoveNegLines(ToPurchLine, FromPurchLineArchive);
ToPurchLine."Appl.-to Item Entry" := FromPurchLineArchive."Appl.-to Item Entry"
end;
IsHandled := false;
OnCopyArchPurchLineOnBeforeCopyArchPurchLineExtText(ToPurchHeader, ToPurchLine, FromPurchHeaderArchive, FromPurchLineArchive, NextLineNo, RecalculateLines, IsHandled, TransferOldExtLines);
if not IsHandled then
if not ((ToPurchHeader."Language Code" <> FromPurchHeaderArchive."Language Code") or RecalculateLines) then begin
if FromPurchLineArchive.IsExtendedText() then
ToPurchLine."Attached to Line No." :=
TransferOldExtLines.TransferExtendedText(
FromPurchLineArchive."Line No.", NextLineNo, FromPurchLineArchive."Attached to Line No.");
end else
if TransferExtendedText.PurchCheckIfAnyExtText(ToPurchLine, false) then begin
TransferExtendedText.InsertPurchExtTextRetLast(ToPurchLine, LastInsertedPurchLine);
NextLineNo := LastInsertedPurchLine."Line No.";
end;
if CopyThisLine then begin
OnCopyArchPurchLineOnBeforeToPurchLineInsert(ToPurchLine, FromPurchLineArchive, RecalculateLines, NextLineNo, TransferOldExtLines);
ToPurchLine.Insert();
OnCopyArchPurchLineOnAfterToPurchLineInsert(ToPurchLine, FromPurchLineArchive, RecalculateLines);
end else
LinesNotCopied := LinesNotCopied + 1;
exit(CopyThisLine);
end;
local procedure CopyDocLines(RecalculateAmount: Boolean; var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
if not RecalculateAmount then
exit;
if (ToPurchLine.Type <> ToPurchLine.Type::" ") and (ToPurchLine."No." <> '') then begin
ToPurchLine.Validate("Line Discount %", FromPurchLine."Line Discount %");
ToPurchLine.Validate(
"Inv. Discount Amount",
Round(FromPurchLine."Inv. Discount Amount", Currency."Amount Rounding Precision"));
end;
end;
local procedure CheckCreditLimit(var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckCreditLimit(FromSalesHeader, ToSalesHeader, SkipTestCreditLimit, IsHandled, IncludeHeader, HideDialog, FromDocType);
if IsHandled then
exit;
if SkipTestCreditLimit then
exit;
if IncludeHeader then
CustCheckCreditLimit.SalesHeaderCheck(FromSalesHeader)
else
CustCheckCreditLimit.SalesHeaderCheck(ToSalesHeader);
end;
local procedure CheckUnappliedLines(IsSkippedLine: Boolean; var MissingExCostRevLink: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckUnappliedLines(IsSkippedLine, MissingExCostRevLink, WarningDone, IsHandled);
if IsHandled then
exit;
if IsSkippedLine and MissingExCostRevLink then begin
if not WarningDone then
Message(Text030);
MissingExCostRevLink := false;
WarningDone := true;
end;
end;
local procedure SetDefaultValuesToSalesLine(var ToSalesLine: Record "Sales Line"; ToSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line")
var
ShouldSetShipmentDate: Boolean;
begin
InitSalesLineFields(ToSalesLine);
ClearSalesBlanketOrderFields(ToSalesLine, ToSalesHeader);
ToSalesLine.InitOutstanding();
if ToSalesLine."Document Type" in
[ToSalesLine."Document Type"::"Return Order", ToSalesLine."Document Type"::"Credit Memo"]
then
ToSalesLine.InitQtyToReceive()
else
ToSalesLine.InitQtyToShip();
ToSalesLine."VAT Difference" := FromSalesLine."VAT Difference";
ToSalesLine."Shipment No." := '';
ToSalesLine."Shipment Line No." := 0;
ToSalesLine."Appl.-from Item Entry" := 0;
ToSalesLine."Appl.-to Item Entry" := 0;
ToSalesLine."Purchase Order No." := '';
ToSalesLine."Purch. Order Line No." := 0;
ToSalesLine."Special Order Purchase No." := '';
ToSalesLine."Special Order Purch. Line No." := 0;
ToSalesLine.Area := ToSalesHeader.Area;
ToSalesLine."Exit Point" := ToSalesHeader."Exit Point";
ToSalesLine."Transaction Specification" := ToSalesHeader."Transaction Specification";
ToSalesLine."Transaction Type" := ToSalesHeader."Transaction Type";
ToSalesLine."Transport Method" := ToSalesHeader."Transport Method";
ShouldSetShipmentDate := (not CreateToHeader) and RecalculateLines;
OnSetDefaultValuesToSalesLineOnBeforeSetShipmentDate(ToSalesHeader, ShouldSetShipmentDate);
if ShouldSetShipmentDate then
ToSalesLine."Shipment Date" := ToSalesHeader."Shipment Date";
OnAfterSetDefaultValuesToSalesLine(ToSalesLine, ToSalesHeader, CreateToHeader, RecalculateLines, FromSalesLine);
end;
local procedure ClearSalesBlanketOrderFields(var ToSalesLine: Record "Sales Line"; ToSalesHeader: Record "Sales Header")
var
IsHandled: Boolean;
begin
OnBeforeClearSalesBlanketOrderFields(ToSalesLine, ToSalesHeader, IsHandled);
if IsHandled then
exit;
if ToSalesLine."Document Type" in
[ToSalesLine."Document Type"::"Blanket Order",
ToSalesLine."Document Type"::"Return Order"]
then begin
ToSalesLine."Blanket Order No." := '';
ToSalesLine."Blanket Order Line No." := 0;
end;
end;
local procedure SetDefaultValuesToPurchLine(var ToPurchLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header"; VATDifference: Decimal; NonDeductibleVATDifference: Decimal)
begin
InitPurchLineFields(ToPurchLine);
ClearPurchaseBlanketOrderFields(ToPurchLine, ToPurchHeader);
ToPurchLine.InitOutstanding();
if ToPurchLine."Document Type" in
[ToPurchLine."Document Type"::"Return Order", ToPurchLine."Document Type"::"Credit Memo"]
then
ToPurchLine.InitQtyToShip()
else
ToPurchLine.InitQtyToReceive();
ToPurchLine."VAT Difference" := VATDifference;
ToPurchLine."Non-Deductible VAT Diff." := NonDeductibleVATDifference;
ToPurchLine."Receipt No." := '';
ToPurchLine."Receipt Line No." := 0;
if not CreateToHeader then
ToPurchLine."Expected Receipt Date" := ToPurchHeader."Expected Receipt Date";
ToPurchLine."Appl.-to Item Entry" := 0;
ToPurchLine."Sales Order No." := '';
ToPurchLine."Sales Order Line No." := 0;
ToPurchLine."Special Order Sales No." := '';
ToPurchLine."Special Order Sales Line No." := 0;
ToPurchLine.Area := ToPurchHeader.Area;
ToPurchLine."Entry Point" := ToPurchHeader."Entry Point";
ToPurchLine."Transaction Specification" := ToPurchHeader."Transaction Specification";
ToPurchLine."Transaction Type" := ToPurchHeader."Transaction Type";
ToPurchLine."Transport Method" := ToPurchHeader."Transport Method";
OnAfterSetDefaultValuesToPurchLine(ToPurchLine, ToPurchHeader, CreateToHeader, RecalculateLines);
end;
local procedure ClearPurchaseBlanketOrderFields(var ToPurchLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header")
var
IsHandled: Boolean;
begin
OnBeforeClearPurchaseBlanketOrderFields(ToPurchLine, ToPurchHeader, IsHandled);
if IsHandled then
exit;
if ToPurchLine."Document Type" in
[ToPurchLine."Document Type"::"Blanket Order",
ToPurchLine."Document Type"::"Return Order"]
then begin
ToPurchLine."Blanket Order No." := '';
ToPurchLine."Blanket Order Line No." := 0;
end;
end;
local procedure CopyItemTrackingEntries(SalesLine: Record "Sales Line"; var PurchLine: Record "Purchase Line"; SalesPricesIncludingVAT: Boolean; PurchPricesIncludingVAT: Boolean)
var
PurchasesPayablesSetup: Record "Purchases & Payables Setup";
TempItemLedgerEntry: Record "Item Ledger Entry" temporary;
TrackingSpecification: Record "Tracking Specification";
ItemTrackingMgt: Codeunit "Item Tracking Management";
MissingExCostRevLink: Boolean;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyItemTrackingEntries(SalesLine, PurchLine, IsHandled);
if IsHandled then
exit;
PurchasesPayablesSetup.Get();
FindTrackingEntries(
TempItemLedgerEntry, DATABASE::"Sales Line", TrackingSpecification."Source Subtype"::"5",
SalesLine."Document No.", '', 0, SalesLine."Line No.", SalesLine."No.");
ItemTrackingMgt.CopyItemLedgEntryTrkgToPurchLn(
TempItemLedgerEntry, PurchLine, PurchasesPayablesSetup."Exact Cost Reversing Mandatory", MissingExCostRevLink,
SalesPricesIncludingVAT, PurchPricesIncludingVAT, true);
end;
local procedure FindTrackingEntries(var TempItemLedgerEntry: Record "Item Ledger Entry" temporary; Type: Integer; Subtype: Integer; ID: Code[20]; BatchName: Code[10]; ProdOrderLine: Integer; RefNo: Integer; ItemNo: Code[20])
var
TrackingSpecification: Record "Tracking Specification";
begin
TrackingSpecification.SetCurrentKey("Source ID", "Source Type", "Source Subtype", "Source Batch Name",
"Source Prod. Order Line", "Source Ref. No.");
TrackingSpecification.SetRange("Source ID", ID);
TrackingSpecification.SetRange("Source Ref. No.", RefNo);
TrackingSpecification.SetRange("Source Type", Type);
TrackingSpecification.SetRange("Source Subtype", Subtype);
TrackingSpecification.SetRange("Source Batch Name", BatchName);
TrackingSpecification.SetRange("Source Prod. Order Line", ProdOrderLine);
TrackingSpecification.SetRange("Item No.", ItemNo);
if TrackingSpecification.FindSet() then
repeat
AddItemLedgerEntry(TempItemLedgerEntry, TrackingSpecification);
until TrackingSpecification.Next() = 0;
end;
local procedure AddItemLedgerEntry(var TempItemLedgerEntry: Record "Item Ledger Entry" temporary; TrackingSpecification: Record "Tracking Specification")
var
ItemLedgerEntry: Record "Item Ledger Entry";
begin
if not TrackingSpecification.TrackingExists() then
exit;
if not ItemLedgerEntry.Get(TrackingSpecification."Entry No.") then
exit;
TempItemLedgerEntry := ItemLedgerEntry;
if TempItemLedgerEntry.Insert() then;
end;
procedure CopyFieldsFromOldSalesHeader(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header")
begin
OnBeforeCopyFieldsFromOldSalesHeader(ToSalesHeader, OldSalesHeader);
ToSalesHeader."No. Series" := OldSalesHeader."No. Series";
ToSalesHeader."Posting Description" := OldSalesHeader."Posting Description";
ToSalesHeader."Posting No." := OldSalesHeader."Posting No.";
ToSalesHeader."Posting No. Series" := OldSalesHeader."Posting No. Series";
ToSalesHeader."Shipping No." := OldSalesHeader."Shipping No.";
ToSalesHeader."Shipping No. Series" := OldSalesHeader."Shipping No. Series";
ToSalesHeader."Return Receipt No." := OldSalesHeader."Return Receipt No.";
ToSalesHeader."Return Receipt No. Series" := OldSalesHeader."Return Receipt No. Series";
ToSalesHeader."Prepayment No. Series" := OldSalesHeader."Prepayment No. Series";
ToSalesHeader."Prepayment No." := OldSalesHeader."Prepayment No.";
ToSalesHeader."Prepmt. Posting Description" := OldSalesHeader."Prepmt. Posting Description";
ToSalesHeader."Prepmt. Cr. Memo No. Series" := OldSalesHeader."Prepmt. Cr. Memo No. Series";
ToSalesHeader."Prepmt. Cr. Memo No." := OldSalesHeader."Prepmt. Cr. Memo No.";
ToSalesHeader."Prepmt. Posting Description" := OldSalesHeader."Prepmt. Posting Description";
SetSalespersonPurchaserCode(ToSalesHeader."Salesperson Code");
ToSalesHeader."Area" := OldSalesHeader.Area;
ToSalesHeader."Exit Point" := OldSalesHeader."Exit Point";
ToSalesHeader."Transaction Type" := OldSalesHeader."Transaction Type";
end;
procedure CopyFieldsFromOldPurchHeader(var ToPurchHeader: Record "Purchase Header"; OldPurchHeader: Record "Purchase Header")
begin
OnBeforeCopyFieldsFromOldPurchHeader(ToPurchHeader, OldPurchHeader, IncludeHeader, MoveNegLines);
ToPurchHeader."No. Series" := OldPurchHeader."No. Series";
ToPurchHeader."Posting Description" := OldPurchHeader."Posting Description";
ToPurchHeader."Posting No." := OldPurchHeader."Posting No.";
ToPurchHeader."Posting No. Series" := OldPurchHeader."Posting No. Series";
ToPurchHeader."Receiving No." := OldPurchHeader."Receiving No.";
ToPurchHeader."Receiving No. Series" := OldPurchHeader."Receiving No. Series";
ToPurchHeader."Return Shipment No." := OldPurchHeader."Return Shipment No.";
ToPurchHeader."Return Shipment No. Series" := OldPurchHeader."Return Shipment No. Series";
ToPurchHeader."Prepayment No. Series" := OldPurchHeader."Prepayment No. Series";
ToPurchHeader."Prepayment No." := OldPurchHeader."Prepayment No.";
ToPurchHeader."Prepmt. Posting Description" := OldPurchHeader."Prepmt. Posting Description";
ToPurchHeader."Prepmt. Cr. Memo No. Series" := OldPurchHeader."Prepmt. Cr. Memo No. Series";
ToPurchHeader."Prepmt. Cr. Memo No." := OldPurchHeader."Prepmt. Cr. Memo No.";
ToPurchHeader."Prepmt. Posting Description" := OldPurchHeader."Prepmt. Posting Description";
SetSalespersonPurchaserCode(ToPurchHeader."Purchaser Code");
ToPurchHeader."Area" := OldPurchHeader.Area;
ToPurchHeader."Entry Point" := OldPurchHeader."Entry Point";
OnAfterCopyFieldsFromOldPurchHeaderProcedure(ToPurchHeader, OldPurchHeader);
end;
local procedure CheckFromSalesHeader(SalesHeaderFrom: Record "Sales Header"; SalesHeaderTo: Record "Sales Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckFromSalesHeader(SalesHeaderFrom, SalesHeaderTo, ISHandled);
if IsHandled then
exit;
SalesHeaderFrom.TestField("Sell-to Customer No.", SalesHeaderTo."Sell-to Customer No.");
SalesHeaderFrom.TestField("Bill-to Customer No.", SalesHeaderTo."Bill-to Customer No.");
SalesHeaderFrom.TestField("Customer Posting Group", SalesHeaderTo."Customer Posting Group");
SalesHeaderFrom.TestField("Gen. Bus. Posting Group", SalesHeaderTo."Gen. Bus. Posting Group");
SalesHeaderFrom.TestField("Currency Code", SalesHeaderTo."Currency Code");
SalesHeaderFrom.TestField("Prices Including VAT", SalesHeaderTo."Prices Including VAT");
OnAfterCheckFromSalesHeader(SalesHeaderFrom, SalesHeaderTo);
end;
local procedure CheckFromSalesShptHeader(SalesShipmentHeaderFrom: Record "Sales Shipment Header"; SalesHeaderTo: Record "Sales Header")
begin
SalesShipmentHeaderFrom.TestField("Sell-to Customer No.", SalesHeaderTo."Sell-to Customer No.");
SalesShipmentHeaderFrom.TestField("Bill-to Customer No.", SalesHeaderTo."Bill-to Customer No.");
SalesShipmentHeaderFrom.TestField("Customer Posting Group", SalesHeaderTo."Customer Posting Group");
SalesShipmentHeaderFrom.TestField("Gen. Bus. Posting Group", SalesHeaderTo."Gen. Bus. Posting Group");
SalesShipmentHeaderFrom.TestField("Currency Code", SalesHeaderTo."Currency Code");
SalesShipmentHeaderFrom.TestField("Prices Including VAT", SalesHeaderTo."Prices Including VAT");
OnAfterCheckFromSalesShptHeader(SalesShipmentHeaderFrom, SalesHeaderTo);
end;
local procedure CheckFromSalesInvHeader(SalesInvoiceHeaderFrom: Record "Sales Invoice Header"; SalesHeaderTo: Record "Sales Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckFromSalesInvHeader(SalesInvoiceHeaderFrom, SalesHeaderTo, IsHandled);
if IsHandled then
exit;
SalesInvoiceHeaderFrom.TestField("Sell-to Customer No.", SalesHeaderTo."Sell-to Customer No.");
SalesInvoiceHeaderFrom.TestField("Bill-to Customer No.", SalesHeaderTo."Bill-to Customer No.");
SalesInvoiceHeaderFrom.TestField("Customer Posting Group", SalesHeaderTo."Customer Posting Group");
SalesInvoiceHeaderFrom.TestField("Gen. Bus. Posting Group", SalesHeaderTo."Gen. Bus. Posting Group");
SalesInvoiceHeaderFrom.TestField("Currency Code", SalesHeaderTo."Currency Code");
SalesInvoiceHeaderFrom.TestField("Prices Including VAT", SalesHeaderTo."Prices Including VAT");
OnAfterCheckFromSalesInvHeader(SalesInvoiceHeaderFrom, SalesHeaderTo);
end;
local procedure CheckFromSalesReturnRcptHeader(ReturnReceiptHeaderFrom: Record "Return Receipt Header"; SalesHeaderTo: Record "Sales Header")
begin
ReturnReceiptHeaderFrom.TestField("Sell-to Customer No.", SalesHeaderTo."Sell-to Customer No.");
ReturnReceiptHeaderFrom.TestField("Bill-to Customer No.", SalesHeaderTo."Bill-to Customer No.");
ReturnReceiptHeaderFrom.TestField("Customer Posting Group", SalesHeaderTo."Customer Posting Group");
ReturnReceiptHeaderFrom.TestField("Gen. Bus. Posting Group", SalesHeaderTo."Gen. Bus. Posting Group");
ReturnReceiptHeaderFrom.TestField("Currency Code", SalesHeaderTo."Currency Code");
ReturnReceiptHeaderFrom.TestField("Prices Including VAT", SalesHeaderTo."Prices Including VAT");
OnAfterCheckFromSalesReturnRcptHeader(ReturnReceiptHeaderFrom, SalesHeaderTo);
end;
local procedure CheckFromSalesCrMemoHeader(SalesCrMemoHeaderFrom: Record "Sales Cr.Memo Header"; SalesHeaderTo: Record "Sales Header")
begin
SalesCrMemoHeaderFrom.TestField("Sell-to Customer No.", SalesHeaderTo."Sell-to Customer No.");
SalesCrMemoHeaderFrom.TestField("Bill-to Customer No.", SalesHeaderTo."Bill-to Customer No.");
SalesCrMemoHeaderFrom.TestField("Customer Posting Group", SalesHeaderTo."Customer Posting Group");
SalesCrMemoHeaderFrom.TestField("Gen. Bus. Posting Group", SalesHeaderTo."Gen. Bus. Posting Group");
SalesCrMemoHeaderFrom.TestField("Currency Code", SalesHeaderTo."Currency Code");
SalesCrMemoHeaderFrom.TestField("Prices Including VAT", SalesHeaderTo."Prices Including VAT");
OnAfterCheckFromSalesCrMemoHeader(SalesCrMemoHeaderFrom, SalesHeaderTo);
end;
local procedure CheckFromPurchaseHeader(PurchaseHeaderFrom: Record "Purchase Header"; PurchaseHeaderTo: Record "Purchase Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCheckFromPurchaseHeader(PurchaseHeaderFrom, PurchaseHeaderTo, IsHandled);
if not IsHandled then begin
PurchaseHeaderFrom.TestField("Buy-from Vendor No.", PurchaseHeaderTo."Buy-from Vendor No.");
PurchaseHeaderFrom.TestField("Pay-to Vendor No.", PurchaseHeaderTo."Pay-to Vendor No.");
PurchaseHeaderFrom.TestField("Vendor Posting Group", PurchaseHeaderTo."Vendor Posting Group");
PurchaseHeaderFrom.TestField("Gen. Bus. Posting Group", PurchaseHeaderTo."Gen. Bus. Posting Group");
PurchaseHeaderFrom.TestField("Currency Code", PurchaseHeaderTo."Currency Code");
end;
OnAfterCheckFromPurchaseHeader(PurchaseHeaderFrom, PurchaseHeaderTo);
end;
local procedure CheckFromPurchaseRcptHeader(PurchRcptHeaderFrom: Record "Purch. Rcpt. Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
PurchRcptHeaderFrom.TestField("Buy-from Vendor No.", PurchaseHeaderTo."Buy-from Vendor No.");
PurchRcptHeaderFrom.TestField("Pay-to Vendor No.", PurchaseHeaderTo."Pay-to Vendor No.");
PurchRcptHeaderFrom.TestField("Vendor Posting Group", PurchaseHeaderTo."Vendor Posting Group");
PurchRcptHeaderFrom.TestField("Gen. Bus. Posting Group", PurchaseHeaderTo."Gen. Bus. Posting Group");
PurchRcptHeaderFrom.TestField("Currency Code", PurchaseHeaderTo."Currency Code");
OnAfterCheckFromPurchaseRcptHeader(PurchRcptHeaderFrom, PurchaseHeaderTo);
end;
local procedure CheckFromPurchaseInvHeader(PurchInvHeaderFrom: Record "Purch. Inv. Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
PurchInvHeaderFrom.TestField("Buy-from Vendor No.", PurchaseHeaderTo."Buy-from Vendor No.");
PurchInvHeaderFrom.TestField("Pay-to Vendor No.", PurchaseHeaderTo."Pay-to Vendor No.");
PurchInvHeaderFrom.TestField("Vendor Posting Group", PurchaseHeaderTo."Vendor Posting Group");
PurchInvHeaderFrom.TestField("Gen. Bus. Posting Group", PurchaseHeaderTo."Gen. Bus. Posting Group");
PurchInvHeaderFrom.TestField("Currency Code", PurchaseHeaderTo."Currency Code");
OnAfterCheckFromPurchaseInvHeader(PurchInvHeaderFrom, PurchaseHeaderTo);
end;
local procedure CheckFromPurchaseReturnShptHeader(ReturnShipmentHeaderFrom: Record "Return Shipment Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
ReturnShipmentHeaderFrom.TestField("Buy-from Vendor No.", PurchaseHeaderTo."Buy-from Vendor No.");
ReturnShipmentHeaderFrom.TestField("Pay-to Vendor No.", PurchaseHeaderTo."Pay-to Vendor No.");
ReturnShipmentHeaderFrom.TestField("Vendor Posting Group", PurchaseHeaderTo."Vendor Posting Group");
ReturnShipmentHeaderFrom.TestField("Gen. Bus. Posting Group", PurchaseHeaderTo."Gen. Bus. Posting Group");
ReturnShipmentHeaderFrom.TestField("Currency Code", PurchaseHeaderTo."Currency Code");
OnAfterCheckFromPurchaseReturnShptHeader(ReturnShipmentHeaderFrom, PurchaseHeaderTo);
end;
local procedure CheckFromPurchaseCrMemoHeader(PurchCrMemoHdrFrom: Record "Purch. Cr. Memo Hdr."; PurchaseHeaderTo: Record "Purchase Header")
begin
PurchCrMemoHdrFrom.TestField("Buy-from Vendor No.", PurchaseHeaderTo."Buy-from Vendor No.");
PurchCrMemoHdrFrom.TestField("Pay-to Vendor No.", PurchaseHeaderTo."Pay-to Vendor No.");
PurchCrMemoHdrFrom.TestField("Vendor Posting Group", PurchaseHeaderTo."Vendor Posting Group");
PurchCrMemoHdrFrom.TestField("Gen. Bus. Posting Group", PurchaseHeaderTo."Gen. Bus. Posting Group");
PurchCrMemoHdrFrom.TestField("Currency Code", PurchaseHeaderTo."Currency Code");
OnAfterCheckFromPurchaseCrMemoHeader(PurchCrMemoHdrFrom, PurchaseHeaderTo);
end;
local procedure CopyDeferrals(DeferralDocType: Enum "Deferral Document Type"; FromDocType: Integer;
FromDocNo: Code[20];
FromLineNo: Integer;
ToDocType: Integer;
ToDocNo: Code[20];
ToLineNo: Integer) StartDate: Date
var
FromDeferralHeader: Record "Deferral Header";
FromDeferralLine: Record "Deferral Line";
ToDeferralHeader: Record "Deferral Header";
ToDeferralLine: Record "Deferral Line";
SalesCommentLine: Record "Sales Comment Line";
begin
StartDate := 0D;
if FromDeferralHeader.Get(
DeferralDocType, '', '',
FromDocType, FromDocNo, FromLineNo)
then begin
RemoveDefaultDeferralCode(DeferralDocType, ToDocType, ToDocNo, ToLineNo);
ToDeferralHeader.Init();
ToDeferralHeader.TransferFields(FromDeferralHeader);
ToDeferralHeader."Document Type" := ToDocType;
ToDeferralHeader."Document No." := ToDocNo;
ToDeferralHeader."Line No." := ToLineNo;
ToDeferralHeader.Insert();
FromDeferralLine.SetRange("Deferral Doc. Type", DeferralDocType);
FromDeferralLine.SetRange("Gen. Jnl. Template Name", '');
FromDeferralLine.SetRange("Gen. Jnl. Batch Name", '');
FromDeferralLine.SetRange("Document Type", FromDocType);
FromDeferralLine.SetRange("Document No.", FromDocNo);
FromDeferralLine.SetRange("Line No.", FromLineNo);
if FromDeferralLine.FindSet() then
repeat
ToDeferralLine.Init();
ToDeferralLine.TransferFields(FromDeferralLine);
ToDeferralLine."Document Type" := ToDocType;
ToDeferralLine."Document No." := ToDocNo;
ToDeferralLine."Line No." := ToLineNo;
ToDeferralLine.Insert();
until FromDeferralLine.Next() = 0;
if ToDocType = SalesCommentLine."Document Type"::"Return Order".AsInteger() then
StartDate := FromDeferralHeader."Start Date"
end;
OnAfterCopyDeferrals(DeferralDocType, FromDocType, FromDocNo, FromLineNo, ToDocType, ToDocNo, ToLineNo, StartDate);
end;
local procedure CopyPostedDeferrals(DeferralDocType: Enum "Deferral Document Type"; FromDocType: Integer;
FromDocNo: Code[20];
FromLineNo: Integer;
ToDocType: Integer;
ToDocNo: Code[20];
ToLineNo: Integer) StartDate: Date
var
PostedDeferralHeader: Record "Posted Deferral Header";
PostedDeferralLine: Record "Posted Deferral Line";
DeferralHeader: Record "Deferral Header";
DeferralLine: Record "Deferral Line";
SalesCommentLine: Record "Sales Comment Line";
InitialAmountToDefer: Decimal;
begin
StartDate := 0D;
if PostedDeferralHeader.Get(DeferralDocType, '', '',
FromDocType, FromDocNo, FromLineNo)
then begin
RemoveDefaultDeferralCode(DeferralDocType, ToDocType, ToDocNo, ToLineNo);
InitialAmountToDefer := 0;
DeferralHeader.Init();
DeferralHeader.TransferFields(PostedDeferralHeader);
DeferralHeader."Document Type" := ToDocType;
DeferralHeader."Document No." := ToDocNo;
DeferralHeader."Line No." := ToLineNo;
OnCopyPostedDeferralsOnBeforeDeferralHeaderInsert(DeferralHeader, PostedDeferralHeader);
DeferralHeader.Insert();
PostedDeferralLine.SetRange("Deferral Doc. Type", DeferralDocType);
PostedDeferralLine.SetRange("Gen. Jnl. Document No.", '');
PostedDeferralLine.SetRange("Account No.", '');
PostedDeferralLine.SetRange("Document Type", FromDocType);
PostedDeferralLine.SetRange("Document No.", FromDocNo);
PostedDeferralLine.SetRange("Line No.", FromLineNo);
if PostedDeferralLine.FindSet() then
repeat
DeferralLine.Init();
DeferralLine.TransferFields(PostedDeferralLine);
DeferralLine."Document Type" := ToDocType;
DeferralLine."Document No." := ToDocNo;
DeferralLine."Line No." := ToLineNo;
if PostedDeferralLine."Amount (LCY)" <> 0.0 then
InitialAmountToDefer := InitialAmountToDefer + PostedDeferralLine."Amount (LCY)"
else
InitialAmountToDefer := InitialAmountToDefer + PostedDeferralLine.Amount;
OnCopyPostedDeferralsOnBeforeDeferralLineInsert(DeferralLine, PostedDeferralLine);
DeferralLine.Insert();
until PostedDeferralLine.Next() = 0;
if ToDocType = SalesCommentLine."Document Type"::"Return Order".AsInteger() then
StartDate := PostedDeferralHeader."Start Date";
if DeferralHeader.Get(DeferralDocType, '', '', ToDocType, ToDocNo, ToLineNo) then begin
DeferralHeader."Initial Amount to Defer" := InitialAmountToDefer;
OnCopyPostedDeferralsOnBeforeDeferralHeaderModify(DeferralHeader);
DeferralHeader.Modify();
end;
end;
OnAfterCopyPostedDeferrals(DeferralDocType, FromDocType, FromDocNo, FromLineNo, ToDocType, ToDocNo, ToLineNo, StartDate);
end;
local procedure IsDeferralToBeCopied(DeferralDocType: Enum "Deferral Document Type"; ToDocType: Option;
FromCommentDocType: Option) Result: Boolean
var
SalesLine: Record "Sales Line";
SalesCommentLine: Record "Sales Comment Line";
PurchLine: Record "Purchase Line";
PurchCommentLine: Record "Purch. Comment Line";
DeferralHeader: Record "Deferral Header";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeIsDeferralToBeCopied(DeferralDocType, ToDocType, FromCommentDocType, Result, IsHandled);
if IsHandled then
exit(Result);
if DeferralDocType = DeferralHeader."Deferral Doc. Type"::Sales then
case ToDocType of
SalesLine."Document Type"::Order.AsInteger(),
SalesLine."Document Type"::Invoice.AsInteger(),
SalesLine."Document Type"::"Credit Memo".AsInteger(),
SalesLine."Document Type"::"Return Order".AsInteger():
case FromCommentDocType of
SalesCommentLine."Document Type"::Order.AsInteger(),
SalesCommentLine."Document Type"::Invoice.AsInteger(),
SalesCommentLine."Document Type"::"Credit Memo".AsInteger(),
SalesCommentLine."Document Type"::"Return Order".AsInteger(),
SalesCommentLine."Document Type"::"Posted Invoice".AsInteger(),
SalesCommentLine."Document Type"::"Posted Credit Memo".AsInteger():
exit(true)
end;
end
else
if DeferralDocType = DeferralHeader."Deferral Doc. Type"::Purchase then
case ToDocType of
PurchLine."Document Type"::Order.AsInteger(),
PurchLine."Document Type"::Invoice.AsInteger(),
PurchLine."Document Type"::"Credit Memo".AsInteger(),
PurchLine."Document Type"::"Return Order".AsInteger():
case FromCommentDocType of
PurchCommentLine."Document Type"::Order.AsInteger(),
PurchCommentLine."Document Type"::Invoice.AsInteger(),
PurchCommentLine."Document Type"::"Credit Memo".AsInteger(),
PurchCommentLine."Document Type"::"Return Order".AsInteger(),
PurchCommentLine."Document Type"::"Posted Invoice".AsInteger(),
PurchCommentLine."Document Type"::"Posted Credit Memo".AsInteger():
exit(true)
end;
end;
exit(false);
end;
local procedure IsDeferralToBeDefaulted(DeferralDocType: Enum "Deferral Document Type"; ToDocType: Option;
FromCommentDocType: Option) Result: Boolean
var
SalesLine: Record "Sales Line";
SalesCommentLine: Record "Sales Comment Line";
PurchLine: Record "Purchase Line";
PurchCommentLine: Record "Purch. Comment Line";
DeferralHeader: Record "Deferral Header";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeIsDeferralToBeDefaulted(DeferralDocType, ToDocType, FromCommentDocType, Result, IsHandled);
if IsHandled then
exit(Result);
if DeferralDocType = DeferralHeader."Deferral Doc. Type"::Sales then
case ToDocType of
SalesLine."Document Type"::Order.AsInteger(),
SalesLine."Document Type"::Invoice.AsInteger(),
SalesLine."Document Type"::"Credit Memo".AsInteger(),
SalesLine."Document Type"::"Return Order".AsInteger():
case FromCommentDocType of
SalesCommentLine."Document Type"::Quote.AsInteger(),
SalesCommentLine."Document Type"::"Blanket Order".AsInteger(),
SalesCommentLine."Document Type"::Shipment.AsInteger(),
SalesCommentLine."Document Type"::"Posted Return Receipt".AsInteger():
exit(true)
end;
end
else
if DeferralDocType = DeferralHeader."Deferral Doc. Type"::Purchase then
case ToDocType of
PurchLine."Document Type"::Order.AsInteger(),
PurchLine."Document Type"::Invoice.AsInteger(),
PurchLine."Document Type"::"Credit Memo".AsInteger(),
PurchLine."Document Type"::"Return Order".AsInteger():
case FromCommentDocType of
PurchCommentLine."Document Type"::Quote.AsInteger(),
PurchCommentLine."Document Type"::"Blanket Order".AsInteger(),
PurchCommentLine."Document Type"::Receipt.AsInteger(),
PurchCommentLine."Document Type"::"Posted Return Shipment".AsInteger():
exit(true)
end;
end;
exit(false);
end;
local procedure IsDeferralPosted(DeferralDocType: Enum "Deferral Document Type"; FromCommentDocType: Option): Boolean
var
SalesCommentLine: Record "Sales Comment Line";
PurchCommentLine: Record "Purch. Comment Line";
DeferralHeader: Record "Deferral Header";
begin
if DeferralDocType = DeferralHeader."Deferral Doc. Type"::Sales then
case FromCommentDocType of
SalesCommentLine."Document Type"::Shipment.AsInteger(),
SalesCommentLine."Document Type"::"Posted Invoice".AsInteger(),
SalesCommentLine."Document Type"::"Posted Credit Memo".AsInteger(),
SalesCommentLine."Document Type"::"Posted Return Receipt".AsInteger():
exit(true);
end
else
if DeferralDocType = DeferralHeader."Deferral Doc. Type"::Purchase then
case FromCommentDocType of
PurchCommentLine."Document Type"::Receipt.AsInteger(),
PurchCommentLine."Document Type"::"Posted Invoice".AsInteger(),
PurchCommentLine."Document Type"::"Posted Credit Memo".AsInteger(),
PurchCommentLine."Document Type"::"Posted Return Shipment".AsInteger():
exit(true);
end;
exit(false);
end;
local procedure InitSalesDeferralCode(var ToSalesLine: Record "Sales Line")
var
GLAccount: Record "G/L Account";
Item: Record Item;
Resource: Record Resource;
begin
if ToSalesLine."No." = '' then
exit;
case ToSalesLine."Document Type" of
ToSalesLine."Document Type"::Order,
ToSalesLine."Document Type"::Invoice,
ToSalesLine."Document Type"::"Credit Memo",
ToSalesLine."Document Type"::"Return Order":
case ToSalesLine.Type of
ToSalesLine.Type::"G/L Account":
begin
GLAccount.Get(ToSalesLine."No.");
ToSalesLine.Validate("Deferral Code", GLAccount."Default Deferral Template Code");
end;
ToSalesLine.Type::Item:
begin
Item.Get(ToSalesLine."No.");
ToSalesLine.Validate("Deferral Code", Item."Default Deferral Template Code");
end;
ToSalesLine.Type::Resource:
begin
Resource.Get(ToSalesLine."No.");
ToSalesLine.Validate("Deferral Code", Resource."Default Deferral Template Code");
end;
end;
end;
end;
local procedure InitFromSalesLine(var FromSalesLine2: Record "Sales Line"; var FromSalesLineBuf: Record "Sales Line")
begin
// Empty buffer fields
FromSalesLine2 := FromSalesLineBuf;
FromSalesLine2."Shipment No." := '';
FromSalesLine2."Shipment Line No." := 0;
FromSalesLine2."Return Receipt No." := '';
FromSalesLine2."Return Receipt Line No." := 0;
OnAfterInitFromSalesLine(FromSalesLine2, FromSalesLineBuf);
end;
local procedure CleanSpecialOrderDropShipmentInSalesLine(var SalesLine: Record "Sales Line")
begin
SalesLine."Purchase Order No." := '';
SalesLine."Purch. Order Line No." := 0;
SalesLine."Special Order Purchase No." := '';
SalesLine."Special Order Purch. Line No." := 0;
OnAfterCleanSpecialOrderDropShipmentInSalesLine(SalesLine);
end;
local procedure CleanSpecialOrderDropShipmentInPurchLine(var PurchaseLine: Record "Purchase Line")
begin
PurchaseLine."Sales Order No." := '';
PurchaseLine."Sales Order Line No." := 0;
PurchaseLine."Special Order Sales No." := '';
PurchaseLine."Special Order Sales Line No." := 0;
PurchaseLine."Drop Shipment" := false;
PurchaseLine."Special Order" := false;
end;
local procedure RemoveDefaultDeferralCode(DeferralDocType: Enum "Deferral Document Type"; DocType: Integer;
DocNo: Code[20];
LineNo: Integer)
var
DeferralHeader: Record "Deferral Header";
DeferralLine: Record "Deferral Line";
begin
if DeferralHeader.Get(DeferralDocType, '', '', DocType, DocNo, LineNo) then
DeferralHeader.Delete();
DeferralLine.SetRange("Deferral Doc. Type", DeferralDocType);
DeferralLine.SetRange("Gen. Jnl. Template Name", '');
DeferralLine.SetRange("Gen. Jnl. Batch Name", '');
DeferralLine.SetRange("Document Type", DocType);
DeferralLine.SetRange("Document No.", DocNo);
DeferralLine.SetRange("Line No.", LineNo);
DeferralLine.DeleteAll();
end;
procedure DeferralTypeForSalesDoc(DocType: Option): Integer
var
SalesCommentLine: Record "Sales Comment Line";
begin
case DocType of
"Sales Document Type From"::Quote.AsInteger():
exit(SalesCommentLine."Document Type"::Quote.AsInteger());
"Sales Document Type From"::"Blanket Order".AsInteger():
exit(SalesCommentLine."Document Type"::"Blanket Order".AsInteger());
"Sales Document Type From"::Order.AsInteger():
exit(SalesCommentLine."Document Type"::Order.AsInteger());
"Sales Document Type From"::Invoice.AsInteger():
exit(SalesCommentLine."Document Type"::Invoice.AsInteger());
"Sales Document Type From"::"Return Order".AsInteger():
exit(SalesCommentLine."Document Type"::"Return Order".AsInteger());
"Sales Document Type From"::"Credit Memo".AsInteger():
exit(SalesCommentLine."Document Type"::"Credit Memo".AsInteger());
"Sales Document Type From"::"Posted Shipment".AsInteger():
exit(SalesCommentLine."Document Type"::Shipment.AsInteger());
"Sales Document Type From"::"Posted Invoice".AsInteger():
exit(SalesCommentLine."Document Type"::"Posted Invoice".AsInteger());
"Sales Document Type From"::"Posted Return Receipt".AsInteger():
exit(SalesCommentLine."Document Type"::"Posted Return Receipt".AsInteger());
"Sales Document Type From"::"Posted Credit Memo".AsInteger():
exit(SalesCommentLine."Document Type"::"Posted Credit Memo".AsInteger());
end;
end;
procedure DeferralTypeForPurchDoc(DocType: Option): Integer
var
PurchCommentLine: Record "Purch. Comment Line";
begin
case DocType of
"Purchase Document Type From"::Quote.AsInteger():
exit(PurchCommentLine."Document Type"::Quote.AsInteger());
"Purchase Document Type From"::"Blanket Order".AsInteger():
exit(PurchCommentLine."Document Type"::"Blanket Order".AsInteger());
"Purchase Document Type From"::Order.AsInteger():
exit(PurchCommentLine."Document Type"::Order.AsInteger());
"Purchase Document Type From"::Invoice.AsInteger():
exit(PurchCommentLine."Document Type"::Invoice.AsInteger());
"Purchase Document Type From"::"Return Order".AsInteger():
exit(PurchCommentLine."Document Type"::"Return Order".AsInteger());
"Purchase Document Type From"::"Credit Memo".AsInteger():
exit(PurchCommentLine."Document Type"::"Credit Memo".AsInteger());
"Purchase Document Type From"::"Posted Receipt".AsInteger():
exit(PurchCommentLine."Document Type"::Receipt.AsInteger());
"Purchase Document Type From"::"Posted Invoice".AsInteger():
exit(PurchCommentLine."Document Type"::"Posted Invoice".AsInteger());
"Purchase Document Type From"::"Posted Return Shipment".AsInteger():
exit(PurchCommentLine."Document Type"::"Posted Return Shipment".AsInteger());
"Purchase Document Type From"::"Posted Credit Memo".AsInteger():
exit(PurchCommentLine."Document Type"::"Posted Credit Memo".AsInteger());
end;
end;
local procedure InitPurchDeferralCode(var ToPurchLine: Record "Purchase Line")
begin
if ToPurchLine."No." = '' then
exit;
case ToPurchLine."Document Type" of
ToPurchLine."Document Type"::Order,
ToPurchLine."Document Type"::Invoice,
ToPurchLine."Document Type"::"Credit Memo",
ToPurchLine."Document Type"::"Return Order":
ToPurchLine.InitDeferralCode();
end;
end;
local procedure CopySalesPostedDeferrals(ToSalesLine: Record "Sales Line"; DeferralDocType: Enum "Deferral Document Type"; FromDocType: Integer;
FromDocNo: Code[20];
FromLineNo: Integer;
ToDocType: Integer;
ToDocNo: Code[20];
ToLineNo: Integer)
begin
ToSalesLine."Returns Deferral Start Date" :=
CopyPostedDeferrals(
DeferralDocType, FromDocType, FromDocNo, FromLineNo, ToDocType, ToDocNo, ToLineNo);
ToSalesLine.Modify();
end;
local procedure CopyPurchPostedDeferrals(ToPurchaseLine: Record "Purchase Line"; DeferralDocType: Enum "Deferral Document Type"; FromDocType: Integer;
FromDocNo: Code[20];
FromLineNo: Integer;
ToDocType: Integer;
ToDocNo: Code[20];
ToLineNo: Integer)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyPurchPostedDeferrals(ToPurchaseLine, IsHandled);
if IsHandled then
exit;
ToPurchaseLine."Returns Deferral Start Date" :=
CopyPostedDeferrals(
DeferralDocType, FromDocType, FromDocNo, FromLineNo, ToDocType, ToDocNo, ToLineNo);
ToPurchaseLine.Modify();
end;
procedure CheckDateOrder(PostingNo: Code[20]; PostingNoSeries: Code[20]; OldPostingDate: Date; NewPostingDate: Date): Boolean
var
NoSeries: Record "No. Series";
ConfirmManagement: Codeunit "Confirm Management";
begin
if IncludeHeader then
if (PostingNo <> '') and (OldPostingDate <> NewPostingDate) then
if NoSeries.Get(PostingNoSeries) then
if NoSeries."Date Order" then
exit(ConfirmManagement.GetResponseOrDefault(DiffPostDateOrderQst, true));
exit(true)
end;
local procedure CheckSalesDocItselfCopy(FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header")
begin
if (FromSalesHeader."Document Type" = ToSalesHeader."Document Type") and
(FromSalesHeader."No." = ToSalesHeader."No.")
then
Error(Text001, ToSalesHeader."Document Type", ToSalesHeader."No.");
end;
local procedure CheckPurchDocItselfCopy(FromPurchHeader: Record "Purchase Header"; ToPurchHeader: Record "Purchase Header")
begin
if (FromPurchHeader."Document Type" = ToPurchHeader."Document Type") and
(FromPurchHeader."No." = ToPurchHeader."No.")
then
Error(Text001, ToPurchHeader."Document Type", ToPurchHeader."No.");
end;
procedure UpdateCustLedgerEntry(var ToSalesHeader: Record "Sales Header"; FromDocType: Enum "Gen. Journal Document Type"; FromDocNo: Code[20])
var
CustLedgEntry: Record "Cust. Ledger Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdateCustLedgEntry(ToSalesHeader, CustLedgEntry, IsHandled, FromDocType, FromDocNo);
if IsHandled then
exit;
CustLedgEntry.SetCurrentKey("Document No.");
if FromDocType = "Sales Document Type From"::"Posted Invoice" then
CustLedgEntry.SetRange("Document Type", CustLedgEntry."Document Type"::Invoice)
else
CustLedgEntry.SetRange("Document Type", CustLedgEntry."Document Type"::"Credit Memo");
CustLedgEntry.SetRange("Document No.", FromDocNo);
CustLedgEntry.SetRange("Customer No.", ToSalesHeader."Bill-to Customer No.");
CustLedgEntry.SetRange(Open, true);
if CustLedgEntry.FindFirst() then begin
ToSalesHeader."Bal. Account No." := '';
if FromDocType = "Sales Document Type From"::"Posted Invoice" then begin
ToSalesHeader."Applies-to Doc. Type" := ToSalesHeader."Applies-to Doc. Type"::Invoice;
ToSalesHeader."Applies-to Doc. No." := FromDocNo;
end else begin
ToSalesHeader."Applies-to Doc. Type" := ToSalesHeader."Applies-to Doc. Type"::"Credit Memo";
ToSalesHeader."Applies-to Doc. No." := FromDocNo;
end;
CustLedgEntry.CalcFields("Remaining Amount");
CustLedgEntry."Amount to Apply" := CustLedgEntry."Remaining Amount";
CustLedgEntry."Accepted Payment Tolerance" := 0;
CustLedgEntry."Accepted Pmt. Disc. Tolerance" := false;
CODEUNIT.Run(CODEUNIT::"Cust. Entry-Edit", CustLedgEntry);
end;
OnAfterUpdateCustLedgerEntry(ToSalesHeader, FromDocType, FromDocNo, CustLedgEntry);
end;
procedure UpdateVendLedgEntry(var ToPurchHeader: Record "Purchase Header"; FromDocType: Enum "Gen. Journal Document Type"; FromDocNo: Code[20])
var
VendLedgEntry: Record "Vendor Ledger Entry";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdateVendLedgEntry(ToPurchHeader, VendLedgEntry, IsHandled, FromDocType, FromDocNo);
if not IsHandled then begin
VendLedgEntry.SetCurrentKey("Document No.");
if FromDocType = "Purchase Document Type From"::"Posted Invoice" then
VendLedgEntry.SetRange("Document Type", VendLedgEntry."Document Type"::Invoice)
else
VendLedgEntry.SetRange("Document Type", VendLedgEntry."Document Type"::"Credit Memo");
VendLedgEntry.SetRange("Document No.", FromDocNo);
VendLedgEntry.SetRange("Vendor No.", ToPurchHeader."Pay-to Vendor No.");
VendLedgEntry.SetRange(Open, true);
if VendLedgEntry.FindFirst() then begin
if FromDocType = "Purchase Document Type From"::"Posted Invoice" then begin
ToPurchHeader."Applies-to Doc. Type" := ToPurchHeader."Applies-to Doc. Type"::Invoice;
ToPurchHeader."Applies-to Doc. No." := FromDocNo;
end else begin
ToPurchHeader."Applies-to Doc. Type" := ToPurchHeader."Applies-to Doc. Type"::"Credit Memo";
ToPurchHeader."Applies-to Doc. No." := FromDocNo;
end;
VendLedgEntry.CalcFields("Remaining Amount");
VendLedgEntry."Amount to Apply" := VendLedgEntry."Remaining Amount";
VendLedgEntry."Accepted Payment Tolerance" := 0;
VendLedgEntry."Accepted Pmt. Disc. Tolerance" := false;
CODEUNIT.Run(CODEUNIT::"Vend. Entry-Edit", VendLedgEntry);
end;
end;
OnAfterUpdateVendLedgEntry(ToPurchHeader, FromDocNo, FromDocType, VendLedgEntry);
end;
local procedure UpdatePurchCreditMemoHeader(var PurchaseHeader: Record "Purchase Header")
var
PaymentTerms: Record "Payment Terms";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdatePurchCreditMemoHeader(PurchaseHeader, IsHandled);
if IsHandled then
exit;
PurchaseHeader."Expected Receipt Date" := 0D;
GLSetup.Get();
PurchaseHeader.Correction := GLSetup."Mark Cr. Memos as Corrections";
if (PurchaseHeader."Payment Terms Code" <> '') and (PurchaseHeader."Document Date" <> 0D) then
PaymentTerms.Get(PurchaseHeader."Payment Terms Code")
else
Clear(PaymentTerms);
if not PaymentTerms."Calc. Pmt. Disc. on Cr. Memos" then begin
PurchaseHeader."Payment Discount %" := 0;
PurchaseHeader."Pmt. Discount Date" := 0D;
end;
OnAfterUpdatePurchCreditMemoHeader(PurchaseHeader);
end;
local procedure UpdateSalesCreditMemoHeader(var SalesHeader: Record "Sales Header")
var
PaymentTerms: Record "Payment Terms";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeUpdateSalesCreditMemoHeader(SalesHeader, IsHandled);
if IsHandled then
exit;
GLSetup.Get();
SalesHeader.Correction := GLSetup."Mark Cr. Memos as Corrections";
IsHandled := false;
OnUpdateSalesCreditMemoHeaderOnBeforeSetShipmentDate(SalesHeader, IsHandled);
if not IsHandled then
SalesHeader."Shipment Date" := 0D;
if (SalesHeader."Payment Terms Code" <> '') and (SalesHeader."Document Date" <> 0D) then
PaymentTerms.Get(SalesHeader."Payment Terms Code")
else
Clear(PaymentTerms);
if not PaymentTerms."Calc. Pmt. Disc. on Cr. Memos" then begin
SalesHeader."Payment Discount %" := 0;
SalesHeader."Pmt. Discount Date" := 0D;
end;
end;
local procedure UpdateSalesInvoiceDiscountValue(var SalesHeader: Record "Sales Header")
begin
if IncludeHeader and RecalculateLines then begin
SalesHeader.CalcFields(Amount);
if SalesHeader."Invoice Discount Value" > SalesHeader.Amount then begin
SalesHeader."Invoice Discount Value" := SalesHeader.Amount;
SalesHeader.Modify();
end;
end;
end;
local procedure UpdatePurchaseInvoiceDiscountValue(var PurchaseHeader: Record "Purchase Header")
begin
if IncludeHeader and RecalculateLines then begin
PurchaseHeader.CalcFields(Amount);
if PurchaseHeader."Invoice Discount Value" > PurchaseHeader.Amount then begin
PurchaseHeader."Invoice Discount Value" := PurchaseHeader.Amount;
PurchaseHeader.Modify();
end;
end;
end;
local procedure ExtTxtAttachedToPosSalesLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"): Boolean
var
AttachedToSalesLine: Record "Sales Line";
begin
if MoveNegLines then
if SalesLine.IsExtendedText() then
if AttachedToSalesLine.Get(SalesHeader."Document Type", SalesHeader."No.", SalesLine."Attached to Line No.") then
if AttachedToSalesLine.Quantity >= 0 then
exit(true);
exit(false);
end;
local procedure ExtTxtAttachedToPosPurchLine(PurchHeader: Record "Purchase Header"; PurchLine: Record "Purchase Line"): Boolean
var
AttachedToPurchLine: Record "Purchase Line";
begin
if MoveNegLines then
if PurchLine.IsExtendedText() then
if AttachedToPurchLine.Get(PurchHeader."Document Type", PurchHeader."No.", PurchLine."Attached to Line No.") then
if AttachedToPurchLine.Quantity >= 0 then
exit(true);
exit(false);
end;
local procedure SalesDocCanReceiveTracking(SalesHeader: Record "Sales Header"): Boolean
begin
exit(
(SalesHeader."Document Type" <> SalesHeader."Document Type"::Quote) and
(SalesHeader."Document Type" <> SalesHeader."Document Type"::"Blanket Order"));
end;
local procedure PurchaseDocCanReceiveTracking(PurchaseHeader: Record "Purchase Header"): Boolean
begin
exit(
(PurchaseHeader."Document Type" <> PurchaseHeader."Document Type"::Quote) and
(PurchaseHeader."Document Type" <> PurchaseHeader."Document Type"::"Blanket Order"));
end;
local procedure CheckFirstLineShipped(ToSalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var SalesCombDocLineNo: Integer; var NextLineNo: Integer; var FirstLineShipped: Boolean)
var
ShouldIncrementNextLineNo: Boolean;
begin
if (TempSalesLine."Document No." = '') and (TempSalesLine."Shipment Line No." = 0) and FirstLineShipped then begin
FirstLineShipped := false;
SalesCombDocLineNo := NextLineNo;
ShouldIncrementNextLineNo := true;
OnCheckFirstLineShippedOnBeforeIncrementNextLineNo(ToSalesHeader, TempSalesLine, ShouldIncrementNextLineNo, NextLineNo);
if ShouldIncrementNextLineNo then
NextLineNo := NextLineNo + 10000;
end;
end;
local procedure SetTempSalesInvLine(FromSalesInvoiceLine: Record "Sales Invoice Line"; var TempSalesInvoiceLine: Record "Sales Invoice Line" temporary; var SalesInvLineCount: Integer; var NextLineNo: Integer; var FirstLineText: Boolean)
begin
if FromSalesInvoiceLine.Type = FromSalesInvoiceLine.Type::Item then begin
SalesInvLineCount += 1;
TempSalesInvoiceLine := FromSalesInvoiceLine;
TempSalesInvoiceLine.Insert();
if FirstLineText then begin
NextLineNo := NextLineNo + 10000;
FirstLineText := false;
end;
end else
if FromSalesInvoiceLine.Type = FromSalesInvoiceLine.Type::" " then
FirstLineText := true;
end;
procedure InitAndCheckSalesDocuments(FromDocType: Option; FromDocNo: Code[20]; var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesShipmentHeader: Record "Sales Shipment Header"; var FromSalesInvoiceHeader: Record "Sales Invoice Header"; var FromReturnReceiptHeader: Record "Return Receipt Header"; var FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var FromSalesHeaderArchive: Record "Sales Header Archive") Result: Boolean
var
FromDocType2: Enum "Sales Document Type From";
IsHandled: Boolean;
SkipFromSalesHeaderArchiveCheck: Boolean;
begin
FromDocType2 := "Sales Document Type From".FromInteger(FromDocType);
IsHandled := false;
OnBeforeInitAndCheckSalesDocuments(FromDocType2, FromDocNo, FromDocOccurrenceNo, FromDocVersionNo, FromSalesHeader, ToSalesHeader, ToSalesLine, MoveNegLines, IncludeHeader, RecalculateLines, Result, IsHandled);
if IsHandled then
exit(Result);
case FromDocType2 of
"Sales Document Type From"::Quote,
"Sales Document Type From"::"Blanket Order",
"Sales Document Type From"::Order,
"Sales Document Type From"::Invoice,
"Sales Document Type From"::"Return Order",
"Sales Document Type From"::"Credit Memo":
begin
FromSalesHeader.Get(GetSalesDocumentType(FromDocType2), FromDocNo);
if not CheckDateOrder(
ToSalesHeader."Posting No.", ToSalesHeader."Posting No. Series",
ToSalesHeader."Posting Date", FromSalesHeader."Posting Date")
then
exit(false);
if MoveNegLines then begin
DeleteSalesLinesWithNegQty(FromSalesHeader, true);
OnInitAndCheckSalesDocumentsOnAfterDelNegLines(ToSalesHeader, FromSalesHeader);
end;
CheckSalesDocItselfCopy(ToSalesHeader, FromSalesHeader);
OnInitAndCheckSalesDocumentsOnAfterCheckSalesDocItselfCopy(ToSalesHeader, FromSalesHeader);
if ToSalesHeader."Document Type".AsInteger() <= ToSalesHeader."Document Type"::Invoice.AsInteger() then begin
FromSalesHeader.CalcFields("Amount Including VAT");
ToSalesHeader."Amount Including VAT" := FromSalesHeader."Amount Including VAT";
IsHandled := false;
OnInitAndCheckSalesDocumentsOnBeforeCheckCreditLimit(FromSalesHeader, ToSalesHeader, IsHandled);
if not IsHandled then
CheckCreditLimit(FromSalesHeader, ToSalesHeader, FromDocType2);
end;
CheckCopyFromSalesHeaderAvail(FromSalesHeader, ToSalesHeader);
if not IncludeHeader and not RecalculateLines then
CheckFromSalesHeader(FromSalesHeader, ToSalesHeader);
end;
"Sales Document Type From"::"Posted Shipment":
begin
FromSalesShipmentHeader.Get(FromDocNo);
if not CheckDateOrder(
ToSalesHeader."Posting No.", ToSalesHeader."Posting No. Series",
ToSalesHeader."Posting Date", FromSalesShipmentHeader."Posting Date")
then
exit(false);
CheckCopyFromSalesShptAvail(FromSalesShipmentHeader, ToSalesHeader);
if not IncludeHeader and not RecalculateLines then
CheckFromSalesShptHeader(FromSalesShipmentHeader, ToSalesHeader);
end;
"Sales Document Type From"::"Posted Invoice":
begin
FromSalesInvoiceHeader.Get(FromDocNo);
FromSalesInvoiceHeader.TestField("Prepayment Invoice", false);
WarnSalesInvoicePmtDisc(ToSalesHeader, FromDocType2, FromDocNo);
if not CheckDateOrder(
ToSalesHeader."Posting No.", ToSalesHeader."Posting No. Series",
ToSalesHeader."Posting Date", FromSalesInvoiceHeader."Posting Date")
then
exit(false);
if ToSalesHeader."Document Type".AsInteger() <= ToSalesHeader."Document Type"::Invoice.AsInteger() then begin
FromSalesInvoiceHeader.CalcFields("Amount Including VAT");
ToSalesHeader."Amount Including VAT" := FromSalesInvoiceHeader."Amount Including VAT";
if IncludeHeader then
FromSalesHeader.TransferFields(FromSalesInvoiceHeader);
CheckCreditLimit(FromSalesHeader, ToSalesHeader, FromDocType2);
end;
CheckCopyFromSalesInvoiceAvail(FromSalesInvoiceHeader, ToSalesHeader);
if not IncludeHeader and not RecalculateLines then
CheckFromSalesInvHeader(FromSalesInvoiceHeader, ToSalesHeader);
end;
"Sales Document Type From"::"Posted Return Receipt":
begin
FromReturnReceiptHeader.Get(FromDocNo);
if not CheckDateOrder(
ToSalesHeader."Posting No.", ToSalesHeader."Posting No. Series",
ToSalesHeader."Posting Date", FromReturnReceiptHeader."Posting Date")
then
exit(false);
CheckCopyFromSalesRetRcptAvail(FromReturnReceiptHeader, ToSalesHeader);
if not IncludeHeader and not RecalculateLines then
CheckFromSalesReturnRcptHeader(FromReturnReceiptHeader, ToSalesHeader);
end;
"Sales Document Type From"::"Posted Credit Memo":
begin
FromSalesCrMemoHeader.Get(FromDocNo);
FromSalesCrMemoHeader.TestField("Prepayment Credit Memo", false);
WarnSalesInvoicePmtDisc(ToSalesHeader, FromDocType2, FromDocNo);
if not CheckDateOrder(
ToSalesHeader."Posting No.", ToSalesHeader."Posting No. Series",
ToSalesHeader."Posting Date", FromSalesCrMemoHeader."Posting Date")
then
exit(false);
if ToSalesHeader."Document Type".AsInteger() <= ToSalesHeader."Document Type"::Invoice.AsInteger() then begin
FromSalesCrMemoHeader.CalcFields("Amount Including VAT");
ToSalesHeader."Amount Including VAT" := FromSalesCrMemoHeader."Amount Including VAT";
if IncludeHeader then
FromSalesHeader.TransferFields(FromSalesCrMemoHeader);
CheckCreditLimit(FromSalesHeader, ToSalesHeader, FromDocType2);
end;
CheckCopyFromSalesCrMemoAvail(FromSalesCrMemoHeader, ToSalesHeader);
if not IncludeHeader and not RecalculateLines then
CheckFromSalesCrMemoHeader(FromSalesCrMemoHeader, ToSalesHeader);
end;
"Sales Document Type From"::"Arch. Quote",
"Sales Document Type From"::"Arch. Order",
"Sales Document Type From"::"Arch. Blanket Order",
"Sales Document Type From"::"Arch. Return Order":
begin
FromSalesHeaderArchive.Get(GetSalesDocumentType(FromDocType2), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo);
if FromDocType2.AsInteger() <= "Sales Document Type From"::Invoice.AsInteger() then begin
FromSalesHeaderArchive.CalcFields("Amount Including VAT");
ToSalesHeader."Amount Including VAT" := FromSalesHeaderArchive."Amount Including VAT";
CustCheckCreditLimit.SalesHeaderCheck(ToSalesHeader);
end;
CheckCopyFromSalesHeaderArchiveAvail(FromSalesHeaderArchive, ToSalesHeader);
SkipFromSalesHeaderArchiveCheck := false;
OnInitAndCheckSalesDocumentsOnBeforeFromSalesHeaderArchiveCheckFields(FromSalesHeaderArchive, ToSalesHeader, IncludeHeader, RecalculateLines, SkipFromSalesHeaderArchiveCheck);
if not IncludeHeader and not RecalculateLines and not SkipFromSalesHeaderArchiveCheck then begin
FromSalesHeaderArchive.TestField("Sell-to Customer No.", ToSalesHeader."Sell-to Customer No.");
FromSalesHeaderArchive.TestField("Bill-to Customer No.", ToSalesHeader."Bill-to Customer No.");
FromSalesHeaderArchive.TestField("Customer Posting Group", ToSalesHeader."Customer Posting Group");
FromSalesHeaderArchive.TestField("Gen. Bus. Posting Group", ToSalesHeader."Gen. Bus. Posting Group");
FromSalesHeaderArchive.TestField("Currency Code", ToSalesHeader."Currency Code");
FromSalesHeaderArchive.TestField("Prices Including VAT", ToSalesHeader."Prices Including VAT");
end;
end;
end;
OnAfterInitAndCheckSalesDocuments(
FromDocType, FromDocNo, FromDocOccurrenceNo, FromDocVersionNo,
FromSalesHeader, ToSalesHeader, ToSalesLine,
FromSalesShipmentHeader, FromSalesInvoiceHeader, FromReturnReceiptHeader, FromSalesCrMemoHeader, FromSalesHeaderArchive,
IncludeHeader, RecalculateLines);
exit(true);
end;
procedure InitAndCheckPurchaseDocuments(FromDocType: Option; FromDocNo: Code[20]; var FromPurchaseHeader: Record "Purchase Header"; var ToPurchaseHeader: Record "Purchase Header"; var FromPurchRcptHeader: Record "Purch. Rcpt. Header"; var FromPurchInvHeader: Record "Purch. Inv. Header"; var FromReturnShipmentHeader: Record "Return Shipment Header"; var FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var FromPurchaseHeaderArchive: Record "Purchase Header Archive"): Boolean
var
FromDocType2: Enum "Purchase Document Type From";
begin
FromDocType2 := "Purchase Document Type From".FromInteger(FromDocType);
case FromDocType2 of
"Purchase Document Type From"::Quote,
"Purchase Document Type From"::"Blanket Order",
"Purchase Document Type From"::Order,
"Purchase Document Type From"::Invoice,
"Purchase Document Type From"::"Return Order",
"Purchase Document Type From"::"Credit Memo":
begin
FromPurchaseHeader.Get(GetPurchaseDocumentType(FromDocType2), FromDocNo);
if not CheckDateOrder(
ToPurchaseHeader."Posting No.", ToPurchaseHeader."Posting No. Series",
ToPurchaseHeader."Posting Date", FromPurchaseHeader."Posting Date")
then
exit(false);
if MoveNegLines then begin
DeletePurchLinesWithNegQty(FromPurchaseHeader, true);
OnInitAndCheckPurchaseDocumentsOnAfterDelNegLines(ToPurchaseHeader, FromPurchaseHeader);
end;
CheckPurchDocItselfCopy(ToPurchaseHeader, FromPurchaseHeader);
OnInitAndCheckPurchaseDocumentsOnAfterCheckPurchDocItselfCopy(ToPurchaseHeader, FromPurchaseHeader);
if not IncludeHeader and not RecalculateLines then
CheckFromPurchaseHeader(FromPurchaseHeader, ToPurchaseHeader);
end;
"Purchase Document Type From"::"Posted Receipt":
begin
FromPurchRcptHeader.Get(FromDocNo);
if not CheckDateOrder(
ToPurchaseHeader."Posting No.", ToPurchaseHeader."Posting No. Series",
ToPurchaseHeader."Posting Date", FromPurchRcptHeader."Posting Date")
then
exit(false);
if not IncludeHeader and not RecalculateLines then
CheckFromPurchaseRcptHeader(FromPurchRcptHeader, ToPurchaseHeader);
end;
"Purchase Document Type From"::"Posted Invoice":
begin
FromPurchInvHeader.Get(FromDocNo);
if not CheckDateOrder(
ToPurchaseHeader."Posting No.", ToPurchaseHeader."Posting No. Series",
ToPurchaseHeader."Posting Date", FromPurchInvHeader."Posting Date")
then
exit(false);
FromPurchInvHeader.TestField("Prepayment Invoice", false);
WarnPurchInvoicePmtDisc(ToPurchaseHeader, FromDocType2, FromDocNo);
if not IncludeHeader and not RecalculateLines then
CheckFromPurchaseInvHeader(FromPurchInvHeader, ToPurchaseHeader);
end;
"Purchase Document Type From"::"Posted Return Shipment":
begin
FromReturnShipmentHeader.Get(FromDocNo);
if not CheckDateOrder(
ToPurchaseHeader."Posting No.", ToPurchaseHeader."Posting No. Series",
ToPurchaseHeader."Posting Date", FromReturnShipmentHeader."Posting Date")
then
exit(false);
if not IncludeHeader and not RecalculateLines then
CheckFromPurchaseReturnShptHeader(FromReturnShipmentHeader, ToPurchaseHeader);
end;
"Purchase Document Type From"::"Posted Credit Memo":
begin
FromPurchCrMemoHdr.Get(FromDocNo);
if not CheckDateOrder(
ToPurchaseHeader."Posting No.", ToPurchaseHeader."Posting No. Series",
ToPurchaseHeader."Posting Date", FromPurchCrMemoHdr."Posting Date")
then
exit(false);
FromPurchCrMemoHdr.TestField("Prepayment Credit Memo", false);
WarnPurchInvoicePmtDisc(ToPurchaseHeader, FromDocType2, FromDocNo);
if not IncludeHeader and not RecalculateLines then
CheckFromPurchaseCrMemoHeader(FromPurchCrMemoHdr, ToPurchaseHeader);
end;
"Purchase Document Type From"::"Arch. Order",
"Purchase Document Type From"::"Arch. Quote",
"Purchase Document Type From"::"Arch. Blanket Order",
"Purchase Document Type From"::"Arch. Return Order":
begin
FromPurchaseHeaderArchive.Get(GetPurchaseDocumentType(FromDocType2), FromDocNo, FromDocOccurrenceNo, FromDocVersionNo);
if not IncludeHeader and not RecalculateLines then begin
FromPurchaseHeaderArchive.TestField("Buy-from Vendor No.", ToPurchaseHeader."Buy-from Vendor No.");
FromPurchaseHeaderArchive.TestField("Pay-to Vendor No.", ToPurchaseHeader."Pay-to Vendor No.");
FromPurchaseHeaderArchive.TestField("Vendor Posting Group", ToPurchaseHeader."Vendor Posting Group");
FromPurchaseHeaderArchive.TestField("Gen. Bus. Posting Group", ToPurchaseHeader."Gen. Bus. Posting Group");
FromPurchaseHeaderArchive.TestField("Currency Code", ToPurchaseHeader."Currency Code");
end;
end;
end;
OnAfterInitAndCheckPurchaseDocuments(
FromDocType, FromDocNo, FromDocOccurrenceNo, FromDocVersionNo,
FromPurchaseHeader, ToPurchaseHeader,
FromPurchRcptHeader, FromPurchInvHeader, FromReturnShipmentHeader, FromPurchCrMemoHdr, FromPurchaseHeaderArchive,
IncludeHeader, RecalculateLines);
exit(true);
end;
procedure InitSalesLineFields(var ToSalesLine: Record "Sales Line")
var
IsHandled: Boolean;
begin
OnBeforeInitSalesLineFields(ToSalesLine);
if ToSalesLine."Document Type" <> ToSalesLine."Document Type"::Order then begin
ToSalesLine."Prepayment %" := 0;
ToSalesLine."Prepayment VAT %" := 0;
ToSalesLine."Prepmt. VAT Calc. Type" := "Tax Calculation Type"::"Normal VAT";
ToSalesLine."Prepayment VAT Identifier" := '';
ToSalesLine."Prepayment VAT %" := 0;
ToSalesLine."Prepayment Tax Group Code" := '';
ToSalesLine."Prepmt. Line Amount" := 0;
ToSalesLine."Prepmt. Amt. Incl. VAT" := 0;
end;
ToSalesLine."Prepmt. Amt. Inv." := 0;
ToSalesLine."Prepmt. Amount Inv. (LCY)" := 0;
ToSalesLine."Prepayment Amount" := 0;
ToSalesLine."Prepmt. VAT Base Amt." := 0;
ToSalesLine."Prepmt Amt to Deduct" := 0;
ToSalesLine."Prepmt Amt Deducted" := 0;
ToSalesLine."Prepmt. Amount Inv. Incl. VAT" := 0;
ToSalesLine."Prepayment VAT Difference" := 0;
ToSalesLine."Prepmt VAT Diff. to Deduct" := 0;
ToSalesLine."Prepmt VAT Diff. Deducted" := 0;
ToSalesLine."Prepmt. Amt. Incl. VAT" := 0;
ToSalesLine."Prepmt. VAT Amount Inv. (LCY)" := 0;
IsHandled := false;
OnInitSalesLineFieldsOnBeforeInitQty(ToSalesLine, IsHandled);
if not IsHandled then begin
ToSalesLine."Quantity Shipped" := 0;
ToSalesLine."Qty. Shipped (Base)" := 0;
ToSalesLine."Return Qty. Received" := 0;
ToSalesLine."Return Qty. Received (Base)" := 0;
ToSalesLine."Quantity Invoiced" := 0;
ToSalesLine."Qty. Invoiced (Base)" := 0;
end;
ToSalesLine."Reserved Quantity" := 0;
ToSalesLine."Reserved Qty. (Base)" := 0;
ToSalesLine."Qty. to Ship" := 0;
ToSalesLine."Qty. to Ship (Base)" := 0;
ToSalesLine."Return Qty. to Receive" := 0;
ToSalesLine."Return Qty. to Receive (Base)" := 0;
ToSalesLine."Qty. to Invoice" := 0;
ToSalesLine."Qty. to Invoice (Base)" := 0;
ToSalesLine."Qty. Shipped Not Invoiced" := 0;
ToSalesLine."Return Qty. Rcd. Not Invd." := 0;
ToSalesLine."Shipped Not Invoiced" := 0;
ToSalesLine."Return Rcd. Not Invd." := 0;
ToSalesLine."Qty. Shipped Not Invd. (Base)" := 0;
ToSalesLine."Ret. Qty. Rcd. Not Invd.(Base)" := 0;
ToSalesLine."Shipped Not Invoiced (LCY)" := 0;
ToSalesLine."Return Rcd. Not Invd. (LCY)" := 0;
InitJobFieldsForSalesLine(ToSalesLine);
OnAfterInitSalesLineFields(ToSalesLine);
end;
procedure InitJobFieldsForSalesLine(var SalesLine: Record "Sales Line")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeInitJobFieldsForSalesLine(SalesLine, IsHandled);
if IsHandled then
exit;
SalesLine."Job No." := '';
SalesLine."Job Task No." := '';
SalesLine."Job Contract Entry No." := 0;
end;
procedure InitPurchLineFields(var ToPurchLine: Record "Purchase Line")
begin
OnBeforeInitPurchLineFields(ToPurchLine);
if ToPurchLine."Document Type" <> ToPurchLine."Document Type"::Order then begin
ToPurchLine."Prepayment %" := 0;
ToPurchLine."Prepayment VAT %" := 0;
ToPurchLine."Prepmt. VAT Calc. Type" := "Tax Calculation Type"::"Normal VAT";
ToPurchLine."Prepayment VAT Identifier" := '';
ToPurchLine."Prepayment VAT %" := 0;
ToPurchLine."Prepayment Tax Group Code" := '';
ToPurchLine."Prepmt. Line Amount" := 0;
ToPurchLine."Prepmt. Amt. Incl. VAT" := 0;
end;
ToPurchLine."Prepmt. Amt. Inv." := 0;
ToPurchLine."Prepmt. Amount Inv. (LCY)" := 0;
ToPurchLine."Prepayment Amount" := 0;
ToPurchLine."Prepmt. VAT Base Amt." := 0;
ToPurchLine."Prepmt Amt to Deduct" := 0;
ToPurchLine."Prepmt Amt Deducted" := 0;
ToPurchLine."Prepmt. Amount Inv. Incl. VAT" := 0;
ToPurchLine."Prepayment VAT Difference" := 0;
ToPurchLine."Prepmt VAT Diff. to Deduct" := 0;
ToPurchLine."Prepmt VAT Diff. Deducted" := 0;
ToPurchLine."Prepmt. Amt. Incl. VAT" := 0;
ToPurchLine."Prepmt. VAT Amount Inv. (LCY)" := 0;
ToPurchLine."Quantity Received" := 0;
ToPurchLine."Qty. Received (Base)" := 0;
ToPurchLine."Return Qty. Shipped" := 0;
ToPurchLine."Return Qty. Shipped (Base)" := 0;
ToPurchLine."Quantity Invoiced" := 0;
ToPurchLine."Qty. Invoiced (Base)" := 0;
ToPurchLine."Reserved Quantity" := 0;
ToPurchLine."Reserved Qty. (Base)" := 0;
ToPurchLine."Qty. Rcd. Not Invoiced" := 0;
ToPurchLine."Qty. Rcd. Not Invoiced (Base)" := 0;
ToPurchLine."Return Qty. Shipped Not Invd." := 0;
ToPurchLine."Ret. Qty. Shpd Not Invd.(Base)" := 0;
ToPurchLine."Qty. to Receive" := 0;
ToPurchLine."Qty. to Receive (Base)" := 0;
ToPurchLine."Return Qty. to Ship" := 0;
ToPurchLine."Return Qty. to Ship (Base)" := 0;
ToPurchLine."Qty. to Invoice" := 0;
ToPurchLine."Qty. to Invoice (Base)" := 0;
ToPurchLine."Amt. Rcd. Not Invoiced" := 0;
ToPurchLine."Amt. Rcd. Not Invoiced (LCY)" := 0;
ToPurchLine."Return Shpd. Not Invd." := 0;
ToPurchLine."Return Shpd. Not Invd. (LCY)" := 0;
OnAfterInitPurchLineFields(ToPurchLine);
end;
local procedure CopySalesJobFields(var ToSalesLine: Record "Sales Line"; ToSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopySalesJobFields(ToSalesLine, FromSalesLine, IsHandled);
if IsHandled then
exit;
ToSalesLine."Job No." := FromSalesLine."Job No.";
ToSalesLine."Job Task No." := FromSalesLine."Job Task No.";
if (ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Invoice) and
(FromSalesLine."Job Contract Entry No." <> 0)
then
ToSalesLine."Job Contract Entry No." :=
CreateJobPlanningLine(ToSalesHeader, ToSalesLine, FromSalesLine."Job Contract Entry No.")
else
ToSalesLine."Job Contract Entry No." := FromSalesLine."Job Contract Entry No.";
end;
local procedure CopySalesLineExtText(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; DocLineNo: Integer; var NextLineNo: Integer)
var
LastInsertedSalesLine: Record "Sales Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopySalesLineExtText(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, DocLineNo, NextLineNo, IsHandled, RecalculateLines, CopyExtText, TransferOldExtLines);
if IsHandled then
exit;
if (ToSalesHeader."Language Code" <> FromSalesHeader."Language Code") or RecalculateLines or CopyExtText then
if TransferExtendedText.SalesCheckIfAnyExtText(ToSalesLine, false) then begin
TransferExtendedText.InsertSalesExtTextRetLast(ToSalesLine, LastInsertedSalesLine);
NextLineNo := LastInsertedSalesLine."Line No.";
exit;
end;
ToSalesLine."Attached to Line No." :=
TransferOldExtLines.TransferExtendedText(DocLineNo, NextLineNo, FromSalesLine."Attached to Line No.");
OnAfterCopySalesLineExtText(ToSalesHeader, ToSalesLine, FromSalesHeader, FromSalesLine, DocLineNo, NextLineNo, TransferOldExtLines, RecalculateLines);
end;
procedure CopySalesLinesToDoc(FromDocType: Option; ToSalesHeader: Record "Sales Header"; var FromSalesShipmentLine: Record "Sales Shipment Line"; var FromSalesInvoiceLine: Record "Sales Invoice Line"; var FromReturnReceiptLine: Record "Return Receipt Line"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopySalesLinesToDoc(
FromDocType, ToSalesHeader, FromSalesShipmentLine, FromSalesInvoiceLine, FromReturnReceiptLine, FromSalesCrMemoLine,
LinesNotCopied, MissingExCostRevLink, IsHandled);
if not IsHandled then begin
CopyExtText := true;
case FromDocType of
"Sales Document Type From"::"Posted Shipment".AsInteger():
CopySalesShptLinesToDoc(ToSalesHeader, FromSalesShipmentLine, LinesNotCopied, MissingExCostRevLink);
"Sales Document Type From"::"Posted Invoice".AsInteger():
CopySalesInvLinesToDoc(ToSalesHeader, FromSalesInvoiceLine, LinesNotCopied, MissingExCostRevLink);
"Sales Document Type From"::"Posted Return Receipt".AsInteger():
CopySalesReturnRcptLinesToDoc(ToSalesHeader, FromReturnReceiptLine, LinesNotCopied, MissingExCostRevLink);
"Sales Document Type From"::"Posted Credit Memo".AsInteger():
CopySalesCrMemoLinesToDoc(ToSalesHeader, FromSalesCrMemoLine, LinesNotCopied, MissingExCostRevLink);
end;
CopyExtText := false;
end;
OnAfterCopySalesLinesToDoc(
FromDocType, ToSalesHeader, FromSalesShipmentLine, FromSalesInvoiceLine, FromReturnReceiptLine, FromSalesCrMemoLine,
LinesNotCopied, MissingExCostRevLink, RecalculateLines, IncludeHeader);
end;
local procedure CopyPurchaseJobFields(var ToPurchLine: Record "Purchase Line"; FromPurchLine: Record "Purchase Line")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyPurchaseJobFields(ToPurchLine, FromPurchLine, IsHandled, RecalculateLines);
if IsHandled then
exit;
ToPurchLine.Validate("Job No.", FromPurchLine."Job No.");
ToPurchLine.Validate("Job Task No.", FromPurchLine."Job Task No.");
ToPurchLine.Validate("Job Planning Line No.", FromPurchLine."Job Planning Line No.");
ToPurchLine.Validate("Job Unit Price", FromPurchLine."Job Unit Price");
ToPurchLine.Validate("Job Total Price", FromPurchLine."Job Total Price");
ToPurchLine.Validate("Job Line Amount", FromPurchLine."Job Line Amount");
ToPurchLine.Validate("Job Line Discount Amount", FromPurchLine."Job Line Discount Amount");
ToPurchLine.Validate("Job Line Discount %", FromPurchLine."Job Line Discount %");
ToPurchLine.Validate("Job Unit Price (LCY)", FromPurchLine."Job Unit Price (LCY)");
ToPurchLine.Validate("Job Total Price (LCY)", FromPurchLine."Job Total Price (LCY)");
ToPurchLine.Validate("Job Line Amount (LCY)", FromPurchLine."Job Line Amount (LCY)");
ToPurchLine.Validate("Job Line Disc. Amount (LCY)", FromPurchLine."Job Line Disc. Amount (LCY)");
ToPurchLine.Validate("Job Currency Factor", FromPurchLine."Job Currency Factor");
ToPurchLine.Validate("Job Currency Code", FromPurchLine."Job Currency Code");
end;
local procedure CopyPurchLineExtText(ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; FromPurchHeader: Record "Purchase Header"; FromPurchLine: Record "Purchase Line"; DocLineNo: Integer; var NextLineNo: Integer)
var
LastInsertedPurchLine: Record "Purchase Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyPurchLineExtText(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, DocLineNo, NextLineNo, IsHandled, RecalculateLines, CopyExtText);
if not IsHandled then begin
if (ToPurchHeader."Language Code" <> FromPurchHeader."Language Code") or RecalculateLines or CopyExtText then
if TransferExtendedText.PurchCheckIfAnyExtText(ToPurchLine, false) then begin
TransferExtendedText.InsertPurchExtTextRetLast(ToPurchLine, LastInsertedPurchLine);
NextLineNo := LastInsertedPurchLine."Line No.";
exit;
end;
ToPurchLine."Attached to Line No." :=
TransferOldExtLines.TransferExtendedText(DocLineNo, NextLineNo, FromPurchLine."Attached to Line No.");
end;
OnAfterCopyPurchLineExtText(ToPurchHeader, ToPurchLine, FromPurchHeader, FromPurchLine, DocLineNo, NextLineNo, TransferOldExtLines, RecalculateLines);
end;
procedure CopyPurchaseLinesToDoc(FromDocType: Option; ToPurchaseHeader: Record "Purchase Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; var FromPurchInvLine: Record "Purch. Inv. Line"; var FromReturnShipmentLine: Record "Return Shipment Line"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCopyPurchaseLinesToDoc(
FromDocType, ToPurchaseHeader, FromPurchRcptLine, FromPurchInvLine, FromReturnShipmentLine, FromPurchCrMemoLine,
LinesNotCopied, MissingExCostRevLink, IsHandled);
if IsHandled then
exit;
CopyExtText := true;
case FromDocType of
"Purchase Document Type From"::"Posted Receipt".AsInteger():
CopyPurchRcptLinesToDoc(ToPurchaseHeader, FromPurchRcptLine, LinesNotCopied, MissingExCostRevLink);
"Purchase Document Type From"::"Posted Invoice".AsInteger():
CopyPurchInvLinesToDoc(ToPurchaseHeader, FromPurchInvLine, LinesNotCopied, MissingExCostRevLink);
"Purchase Document Type From"::"Posted Return Shipment".AsInteger():
CopyPurchReturnShptLinesToDoc(ToPurchaseHeader, FromReturnShipmentLine, LinesNotCopied, MissingExCostRevLink);
"Purchase Document Type From"::"Posted Credit Memo".AsInteger():
CopyPurchCrMemoLinesToDoc(ToPurchaseHeader, FromPurchCrMemoLine, LinesNotCopied, MissingExCostRevLink);
end;
CopyExtText := false;
OnAfterCopyPurchaseLinesToDoc(
FromDocType, ToPurchaseHeader, FromPurchRcptLine, FromPurchInvLine, FromReturnShipmentLine, FromPurchCrMemoLine,
LinesNotCopied, MissingExCostRevLink, RecalculateLines, IncludeHeader);
end;
local procedure CopyShiptoCodeFromInvToCrMemo(var ToSalesHeader: Record "Sales Header"; FromSalesInvHeader: Record "Sales Invoice Header"; FromDocType: Enum "Sales Document Type From")
begin
if (FromDocType = "Sales Document Type From"::"Posted Invoice") and
(FromSalesInvHeader."Ship-to Code" <> '') and
(ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::"Credit Memo")
then
ToSalesHeader."Ship-to Code" := FromSalesInvHeader."Ship-to Code";
OnAfterCopyShiptoCodeFromInvToCrMemo(ToSalesHeader, FromSalesInvHeader, FromDocType);
end;
local procedure TransferFieldsFromCrMemoToInv(var ToSalesHeader: Record "Sales Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header")
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeTransferFieldsFromCrMemoToInv(ToSalesHeader, FromSalesCrMemoHeader, IsHandled);
if not IsHandled then begin
ToSalesHeader.Validate("Sell-to Customer No.", FromSalesCrMemoHeader."Sell-to Customer No.");
if ToSalesHeader."Sell-to Customer No." <> FromSalesCrMemoHeader."Sell-to Customer No." then
exit;
OnTransferFieldsFromCrMemoToInvOnBeforeTransferFields(ToSalesHeader, FromSalesCrMemoHeader);
ToSalesHeader.TransferFields(FromSalesCrMemoHeader, false);
if (ToSalesHeader."Document Type" = ToSalesHeader."Document Type"::Invoice) and IncludeHeader then begin
ToSalesHeader.CopySellToAddressToShipToAddress();
ToSalesHeader.Validate("Ship-to Code", FromSalesCrMemoHeader."Ship-to Code");
end;
SetReceivedFromCountryCode(ToSalesHeader);
end;
OnAfterTransferFieldsFromCrMemoToInv(ToSalesHeader, FromSalesCrMemoHeader, CopyJobData);
end;
procedure CopyShippingInfoPurchOrder(var ToPurchaseHeader: Record "Purchase Header"; FromPurchaseHeader: Record "Purchase Header")
begin
if (ToPurchaseHeader."Document Type" = ToPurchaseHeader."Document Type"::Order) and
(FromPurchaseHeader."Document Type" = FromPurchaseHeader."Document Type"::Order)
then begin
ToPurchaseHeader."Ship-to Address" := FromPurchaseHeader."Ship-to Address";
ToPurchaseHeader."Ship-to Address 2" := FromPurchaseHeader."Ship-to Address 2";
ToPurchaseHeader."Ship-to City" := FromPurchaseHeader."Ship-to City";
ToPurchaseHeader."Ship-to Country/Region Code" := FromPurchaseHeader."Ship-to Country/Region Code";
ToPurchaseHeader."Ship-to County" := FromPurchaseHeader."Ship-to County";
ToPurchaseHeader."Ship-to Name" := FromPurchaseHeader."Ship-to Name";
ToPurchaseHeader."Ship-to Name 2" := FromPurchaseHeader."Ship-to Name 2";
ToPurchaseHeader."Ship-to Post Code" := FromPurchaseHeader."Ship-to Post Code";
ToPurchaseHeader."Ship-to Phone No." := FromPurchaseHeader."Ship-to Phone No.";
ToPurchaseHeader."Ship-to Contact" := FromPurchaseHeader."Ship-to Contact";
ToPurchaseHeader."Inbound Whse. Handling Time" := FromPurchaseHeader."Inbound Whse. Handling Time";
end;
end;
local procedure SetSalespersonPurchaserCode(var SalespersonPurchaserCode: Code[20])
var
SalespersonPurchaser: Record "Salesperson/Purchaser";
begin
if SalespersonPurchaserCode <> '' then
if SalespersonPurchaser.Get(SalespersonPurchaserCode) then
if SalespersonPurchaser.VerifySalesPersonPurchaserPrivacyBlocked(SalespersonPurchaser) then
SalespersonPurchaserCode := ''
end;
local procedure SetReceivedFromCountryCode(FromDocType: Enum "Sales Document Type From"; var ToSalesHeader: Record "Sales Header")
begin
if not ToSalesHeader.IsCreditDocType() then
ToSalesHeader."Rcvd.-from Count./Region Code" := '';
if not (FromDocType in [FromDocType::"Credit Memo", FromDocType::"Return Order"]) then
ToSalesHeader."Rcvd.-from Count./Region Code" := '';
end;
local procedure SetReceivedFromCountryCode(FromSalesHeaderArchive: Record "Sales Header Archive"; var ToSalesHeader: Record "Sales Header")
begin
if not ToSalesHeader.IsCreditDocType() then
ToSalesHeader."Rcvd.-from Count./Region Code" := '';
if not (FromSalesHeaderArchive."Document Type" in [FromSalesHeaderArchive."Document Type"::"Return Order"]) then
ToSalesHeader."Rcvd.-from Count./Region Code" := '';
end;
local procedure SetReceivedFromCountryCode(FromSalesShipmentHeader: Record "Sales Shipment Header"; var ToSalesHeader: Record "Sales Header")
begin
if not ToSalesHeader.IsCreditDocType() then
ToSalesHeader."Rcvd.-from Count./Region Code" := ''
else
ToSalesHeader."Rcvd.-from Count./Region Code" := FromSalesShipmentHeader."Ship-to Country/Region Code";
end;
local procedure SetReceivedFromCountryCode(SalesInvoiceHeader: Record "Sales Invoice Header"; var ToSalesHeader: Record "Sales Header")
begin
if not ToSalesHeader.IsCreditDocType() then
ToSalesHeader."Rcvd.-from Count./Region Code" := ''
else
ToSalesHeader."Rcvd.-from Count./Region Code" := SalesInvoiceHeader."Ship-to Country/Region Code";
end;
local procedure UpdateShipToAddress(var ToSalesHeader: Record "Sales Header")
begin
if not ToSalesHeader.IsCreditDocType() then
exit;
ToSalesHeader.UpdateShipToAddress();
end;
local procedure SetReceivedFromCountryCode(var ToSalesHeader: Record "Sales Header")
begin
if not ToSalesHeader.IsCreditDocType() then
ToSalesHeader."Rcvd.-from Count./Region Code" := '';
end;
procedure SetCopyExtendedText(CopyExtendedText: Boolean)
begin
CopyExtText := CopyExtendedText;
end;
/// <summary>
/// Event triggered before starting the sales document copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the document copy operation begins. This can be useful for implementing validations,
/// pre-processing logic, or altering the behavior of the copy operation.
/// </summary>
/// <param name="FromDocumentType">
/// The type of the sales document being copied, represented as an integer.
/// </param>
/// <param name="FromDocumentNo">
/// The document number of the sales document being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the data is being copied.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default copy behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCopySalesDocument(FromDocumentType: Option; FromDocumentNo: Code[20]; var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyItemTrackingEntries(SalesLine: Record "Sales Line"; var PurchLine: Record "Purchase Line"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before assigning descriptions from a sales line to a purchase line.
/// This allows developers to modify or override the default behavior of the description assignment.
/// </summary>
/// <param name="PurchaseLine">
/// The purchase line record to which descriptions are being assigned.
/// </param>
/// <param name="SalesLine">
/// The sales line record from which descriptions are being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeAssignDescriptionsFromSalesLine(var PurchaseLine: Record "Purchase Line"; SalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered before copying a sales line.
/// This allows developers to modify or override the behavior of copying sales lines.
/// </summary>
/// <param name="ToSalesHeader">The target sales header to which the sales line will be copied.</param>
/// <param name="FromSalesHeader">The source sales header from which the sales line will be copied.</param>
/// <param name="FromSalesLine">The source sales line to be copied.</param>
/// <param name="RecalculateAmount">A boolean variable indicating whether lines need to be recalculated during the copy operation.</param>
/// <param name="CopyThisLine">A boolean flag indicating whether the current line should be copied. Can be overridden.</param>
/// <param name="MoveNegLines">A boolean variable indicating whether negative lines should be moved instead of copied.</param>
/// <param name="Result">The result of the copy operation. Can be overridden.</param>
/// <param name="IsHandled">A boolean variable that allows developers to handle the logic themselves and skip the default copying process if set to true.</param>
/// <param name="DocLineNo">The line number of the document line being processed.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesLine(var ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; RecalculateAmount: Boolean; var CopyThisLine: Boolean; MoveNegLines: Boolean; var Result: Boolean; var IsHandled: Boolean; DocLineNo: Integer)
begin
end;
/// <summary>
/// Event triggered before starting the process of copying archived sales lines from the source sales document archive to the target sales document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the archived sales lines are copied. This can be useful for implementing additional logic,
/// setting up preconditions, or filtering data during the copy process.
/// </summary>
/// <param name="FromSalesHeaderArchive">
/// The source sales header archive record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the archived sales lines are being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesDocSalesLineArchive(FromSalesHeaderArchive: Record "Sales Header Archive"; var ToSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before starting the process of copying sales lines from the source sales document to the target sales document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the sales lines are copied. This can be useful for implementing additional logic,
/// setting up preconditions, or filtering data during the copy process.
/// </summary>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales lines are being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesDocSalesLine(FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyArchSalesLine(var ToSalesHeader: Record "Sales Header"; FromSalesHeaderArchive: Record "Sales Header Archive"; FromSalesLineArchive: Record "Sales Line Archive"; RecalculateAmount: Boolean; var CopyThisLine: Boolean)
begin
end;
/// <summary>
/// Event triggered before starting the process of copying a purchase document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the purchase document copy process has begun. This can be useful for implementing custom logic,
/// applying validations, or altering parameters during the copy operation.
/// </summary>
/// <param name="FromDocumentType">
/// The type of the source purchase document being copied.
/// </param>
/// <param name="FromDocumentNo">
/// The document number of the source purchase document being copied.
/// </param>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which the document is being copied.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default copy behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(true, false)]
local procedure OnBeforeCopyPurchaseDocument(FromDocumentType: Option; FromDocumentNo: Code[20]; var ToPurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before copying a purchase line. Allows overriding or skipping the default logic for copying the purchase line.
/// </summary>
/// <param name="ToPurchHeader">The purchase header of the target document.</param>
/// <param name="FromPurchHeader">The purchase header of the source document.</param>
/// <param name="FromPurchLine">The purchase line from the source document being processed.</param>
/// <param name="RecalculateAmount">A boolean variable indicating if the lines should be recalculated.</param>
/// <param name="CopyThisLine">A boolean variable indicating whether the current line should be copied. Can be modified by subscribers.</param>
/// <param name="ToPurchLine">The purchase line of the target document.</param>
/// <param name="MoveNegLines">A boolean variable indicating if negative lines should be moved.</param>
/// <param name="RoundingLineInserted">A boolean variable indicating if a rounding line was inserted.</param>
/// <param name="Result">The result of the operation, can be overridden by subscribers.</param>
/// <param name="IsHandled">A boolean variable indicating if the event is handled. If set to true, the default logic will be skipped.</param>
/// <param name="FromPurchDocType">The type of the source purchase document.</param>
/// <param name="DocLineNo">The line number of the source document line.</param>
/// <param name="RecalculateLines">A boolean variable indicating if recalculation of lines is required.</param>
/// <param name="LinesNotCopied">Tracks the number of lines that were not copied.</param>
/// <param name="CopyPostedDeferral">A boolean variable indicating if posted deferrals should be copied.</param>
/// <param name="NextLineNo">The next line number for the target document.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchLine(var ToPurchHeader: Record "Purchase Header"; FromPurchHeader: Record "Purchase Header"; FromPurchLine: Record "Purchase Line"; RecalculateAmount: Boolean; var CopyThisLine: Boolean; ToPurchLine: Record "Purchase Line"; MoveNegLines: Boolean; var RoundingLineInserted: Boolean; var Result: Boolean; var IsHandled: Boolean; FromPurchDocType: Enum "Purchase Document Type From"; DocLineNo: Integer;
RecalculateLines: Boolean; var LinesNotCopied: Integer; var CopyPostedDeferral: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchRcptLinesToDoc(ToPurchHeader: Record "Purchase Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyArchPurchLine(var ToPurchHeader: Record "Purchase Header"; FromPurchHeaderArchive: Record "Purchase Header Archive"; FromPurchLineArchive: Record "Purchase Line Archive"; RecalculateAmount: Boolean; var CopyThisLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeModifySalesHeader(var ToSalesHeader: Record "Sales Header"; FromDocType: Option; FromDocNo: Code[20]; IncludeHeader: Boolean; FromDocOccurenceNo: Integer; FromDocVersionNo: Integer; RecalculateLines: Boolean; FromSalesHeader: Record "Sales Header"; FromSalesInvoiceHeader: Record "Sales Invoice Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; OldSalesHeader: Record "Sales Header")
begin
end;
local procedure AddSalesDocLine(var TempDocSalesLine: Record "Sales Line" temporary; BufferLineNo: Integer; DocumentNo: Code[20]; DocumentLineNo: Integer)
begin
OnBeforeAddSalesDocLine(TempDocSalesLine, BufferLineNo, DocumentNo, DocumentLineNo);
TempDocSalesLine."Document No." := DocumentNo;
TempDocSalesLine."Line No." := DocumentLineNo;
TempDocSalesLine."Shipment Line No." := BufferLineNo;
TempDocSalesLine.Insert();
end;
local procedure GetSalesLineNo(var TempDocSalesLine: Record "Sales Line" temporary; BufferLineNo: Integer): Integer
begin
TempDocSalesLine.SetRange("Shipment Line No.", BufferLineNo);
if not TempDocSalesLine.FindFirst() then
exit(0);
exit(TempDocSalesLine."Line No.");
end;
local procedure GetSalesDocNo(var TempDocSalesLine: Record "Sales Line" temporary; BufferLineNo: Integer): Code[20]
begin
TempDocSalesLine.SetRange("Shipment Line No.", BufferLineNo);
if not TempDocSalesLine.FindFirst() then
exit('');
exit(TempDocSalesLine."Document No.");
end;
local procedure AddPurchDocLine(var TempDocPurchaseLine: Record "Purchase Line" temporary; BufferLineNo: Integer; DocumentNo: Code[20]; DocumentLineNo: Integer)
begin
OnBeforeAddPurchDocLine(TempDocPurchaseLine, BufferLineNo, DocumentNo, DocumentLineNo);
TempDocPurchaseLine."Document No." := DocumentNo;
TempDocPurchaseLine."Line No." := DocumentLineNo;
TempDocPurchaseLine."Receipt Line No." := BufferLineNo;
TempDocPurchaseLine.Insert();
end;
local procedure GetPurchLineNo(var TempDocPurchaseLine: Record "Purchase Line" temporary; BufferLineNo: Integer): Integer
begin
TempDocPurchaseLine.SetRange("Receipt Line No.", BufferLineNo);
if not TempDocPurchaseLine.FindFirst() then
exit(0);
exit(TempDocPurchaseLine."Line No.");
end;
local procedure GetPurchDocNo(var TempDocPurchaseLine: Record "Purchase Line" temporary; BufferLineNo: Integer): Code[20]
begin
TempDocPurchaseLine.SetRange("Receipt Line No.", BufferLineNo);
if not TempDocPurchaseLine.FindFirst() then
exit('');
exit(TempDocPurchaseLine."Document No.");
end;
local procedure SetTrackingOnAssemblyReservation(AssemblyHeader: Record "Assembly Header"; var TempItemLedgerEntry: Record "Item Ledger Entry" temporary)
var
ReservationEntry: Record "Reservation Entry";
TempReservationEntry: Record "Reservation Entry" temporary;
TempTrackingSpecification: Record "Tracking Specification" temporary;
ItemTrackingCode: Record "Item Tracking Code";
ReservationEngineMgt: Codeunit "Reservation Engine Mgt.";
QtyToAddAsBlank: Decimal;
begin
TempItemLedgerEntry.SetFilter("Lot No.", '<>%1', '');
if TempItemLedgerEntry.IsEmpty() then
exit;
ReservationEntry.SetRange("Source Type", DATABASE::"Assembly Header");
ReservationEntry.SetRange("Source Subtype", AssemblyHeader."Document Type");
ReservationEntry.SetRange("Source ID", AssemblyHeader."No.");
ReservationEntry.SetRange("Source Ref. No.", 0);
ReservationEntry.SetRange("Reservation Status", ReservationEntry."Reservation Status"::Reservation);
if ReservationEntry.FindSet() then
repeat
TempReservationEntry := ReservationEntry;
TempReservationEntry.Insert();
until ReservationEntry.Next() = 0;
if TempItemLedgerEntry.FindSet() then
repeat
TempTrackingSpecification."Entry No." += 1;
TempTrackingSpecification."Item No." := TempItemLedgerEntry."Item No.";
TempTrackingSpecification."Location Code" := TempItemLedgerEntry."Location Code";
TempTrackingSpecification."Quantity (Base)" := TempItemLedgerEntry.Quantity;
TempTrackingSpecification.CopyTrackingFromItemledgEntry(TempItemLedgerEntry);
TempTrackingSpecification."Warranty Date" := TempItemLedgerEntry."Warranty Date";
TempTrackingSpecification."Expiration Date" := TempItemLedgerEntry."Expiration Date";
OnSetTrackingOnAssemblyReservationOnBeforeTempTrackingSpecificationInsert(TempTrackingSpecification, TempItemLedgerEntry);
TempTrackingSpecification.Insert();
until TempItemLedgerEntry.Next() = 0;
if TempTrackingSpecification.FindSet() then
repeat
if GetItemTrackingCode(ItemTrackingCode, TempTrackingSpecification."Item No.") then
ReservationEngineMgt.AddItemTrackingToTempRecSet(
TempReservationEntry, TempTrackingSpecification, TempTrackingSpecification."Quantity (Base)",
QtyToAddAsBlank, ItemTrackingCode);
until TempTrackingSpecification.Next() = 0;
end;
local procedure GetItemTrackingCode(var ItemTrackingCode: Record "Item Tracking Code"; ItemNo: Code[20]): Boolean
var
Item: Record Item;
begin
Item.SetLoadFields("Item Tracking Code");
if not Item.Get(ItemNo) then
exit(false);
if Item."Item Tracking Code" = '' then
exit(false);
ItemTrackingCode.Get(Item."Item Tracking Code");
exit(true);
end;
local procedure CheckSalesVATBusPostingGroup(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line")
var
CheckVATBusGroup: Boolean;
begin
CheckVATBusGroup := (not RecalculateLines) and (ToSalesLine."No." <> '');
OnCopySalesLineOnBeforeCheckVATBusGroup(ToSalesLine, CheckVATBusGroup);
if CheckVATBusGroup then
ToSalesLine.TestField("VAT Bus. Posting Group", ToSalesHeader."VAT Bus. Posting Group");
end;
local procedure CheckPurchVATBusPostingGroup(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line")
var
CheckVATBusGroup: Boolean;
begin
CheckVATBusGroup := (not RecalculateLines) and (ToPurchLine."No." <> '');
OnCopyPurchLineOnBeforeCheckVATBusGroup(ToPurchLine, CheckVATBusGroup);
if CheckVATBusGroup then
ToPurchLine.TestField("VAT Bus. Posting Group", ToPurchHeader."VAT Bus. Posting Group");
end;
procedure SetPropertiesForCorrectiveCreditMemo(NewSkipCopyFromDescription: Boolean)
begin
SetProperties(true, false, false, false, true, true, false);
SkipOldInvoiceDesc := NewSkipCopyFromDescription;
end;
local procedure SkipOldInvoiceDescription(RcptOrShipLineExist: Boolean)
begin
if SkipOldInvoiceDesc and RcptOrShipLineExist then
SkipCopyFromDescription := true;
end;
local procedure ClearOriginalDocumentNos(var ToPurchHeader: Record "Purchase Header")
begin
ToPurchHeader."Vendor Order No." := '';
ToPurchHeader."Vendor Invoice No." := '';
ToPurchHeader."Vendor Cr. Memo No." := '';
ToPurchHeader."Vendor Shipment No." := '';
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeAddPurchDocLine(var TempDocPurchaseLine: Record "Purchase Line" temporary; BufferLineNo: Integer; DocumentNo: Code[20]; DocumentLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeAddSalesDocLine(var TempDocSalesLine: Record "Sales Line" temporary; BufferLineNo: Integer; DocumentNo: Code[20]; DocumentLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyAsmOrderToAsmOrderProcedure(var TempFromAsmHeader: Record "Assembly Header" temporary; var TempFromAsmLine: Record "Assembly Line" temporary; ToSalesLine: Record "Sales Line"; ToAsmHeaderDocType: Option; ToAsmHeaderDocNo: Code[20]; InclAsmHeader: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchLines(var PurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchInvLines(var TempDocPurchaseLine: Record "Purchase Line" temporary; var ToPurchHeader: Record "Purchase Header"; var FromPurchInvLine: Record "Purch. Inv. Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchCrMemoLinesToDoc(var TempDocPurchaseLine: Record "Purchase Line" temporary; var ToPurchHeader: Record "Purchase Header"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchaseLinesToDoc(FromDocType: Option; var ToPurchaseHeader: Record "Purchase Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; var FromPurchInvLine: Record "Purch. Inv. Line"; var FromReturnShipmentLine: Record "Return Shipment Line"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchReturnShptLinesToDoc(var TempDocPurchaseLine: Record "Purchase Line" temporary; var ToPurchHeader: Record "Purchase Header"; var FromReturnShipmentLine: Record "Return Shipment Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchaseJobFields(var ToPurchaseLine: Record "Purchase Line"; FromPurchaseLine: Record "Purchase Line"; var IsHandled: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchLineExtText(ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; FromPurchHeader: Record "Purchase Header"; FromPurchLine: Record "Purchase Line"; DocLineNo: Integer; var NextLineNo: Integer; var IsHandled: Boolean; RecalculateLines: Boolean; CopyExtText: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesShptLinesToDoc(var TempDocSalesLine: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var FromSalesShptLine: Record "Sales Shipment Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesShptLinesToBuffer(var FromSalesLine: Record "Sales Line"; var FromSalesShptLine: Record "Sales Shipment Line"; var ToSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before handling zero-amount posted invoices during the sales document copy process.
/// Subscribing to this event allows developers to override or extend the default behavior
/// when processing invoices with zero total amount. This can be useful for implementing custom logic
/// or skipping the default handling operation.
/// </summary>
/// <param name="FromSalesInvoiceHeader">
/// The source sales invoice header record being processed.
/// </param>
/// <param name="ToSalesHeader">
/// The target sales header record to which the data is being copied.
/// </param>
/// <param name="FromDocType">
/// The type of the source sales document.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source sales document.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default handling behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeHandleZeroAmountPostedInvoices(var FromSalesInvoiceHeader: Record "Sales Invoice Header"; var ToSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From"; FromDocNo: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeHandleZeroAmountPostedPurchaseInvoices(var FromPurchInvHeader: Record "Purch. Inv. Header"; var ToPurchaseHeader: Record "Purchase Header"; FromDocType: Enum "Purchase Document Type From"; FromDocNo: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnAfterSplitPstdSalesLinesPerILE(var FromSalesLineBuf: Record "Sales Line" temporary; var FromSalesShptLine: Record "Sales Shipment Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnAfterIncrementNextLineNo(var ToSalesLine: Record "Sales Line"; var FromSalesLineArchive: Record "Sales Line Archive"; var NextLineNo: Integer; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnAfterRecalculatePurchLine(var ToPurchaseLine: Record "Purchase Line"; var FromPurchaseLineArchive: Record "Purchase Line Archive")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchRcptLinesToDocOnBeforeCheckInsertDocNoLine(var ToPurchaseHeader: Record "Purchase Header"; FromPurchRcptLine: Record "Purch. Rcpt. Line"; FromPurchaseHeader: Record "Purchase Header"; var NextLineNo: Integer; var InsertDocNoLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnAfterCalcShouldInsertOldPurchDocNoLine(var ToPurchaseHeader: Record "Purchase Header"; FromPurchInvHeader: Record "Purch. Inv. Header"; FromPurchaseHeader: Record "Purchase Header"; var NextLineNo: Integer; var OldInvDocNo: Code[20]; var OldRcptDocNo: Code[20]; var ShouldInsertOldPurchDocNoLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesInvLines(var TempDocSalesLine: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var FromSalesInvLine: Record "Sales Invoice Line"; var CopyJobData: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesInvLinesToDoc(var ToSalesHeader: Record "Sales Header"; var FromSalesInvLine: Record "Sales Invoice Line"; var CopyJobData: Boolean; RecalculateLines: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInitJobFieldsForSalesLine(var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesInvLinesToBuffer(var FromSalesLine: Record "Sales Line"; var FromSalesInvLine: Record "Sales Invoice Line"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesCrMemoLinesToDoc(var TempDocSalesLine: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var CopyJobData: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesCrMemoLinesToBuffer(var FromSalesLine: Record "Sales Line"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesReturnRcptLinesToDoc(var TempDocSalesLine: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var FromReturnReceiptLine: Record "Return Receipt Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesReturnRcptLinesToBuffer(var FromSalesLine: Record "Sales Line"; var FromReturnReceiptLine: Record "Return Receipt Line"; var ToSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before copying data from a sales line to a purchase line.
/// This allows developers to modify or override the default behavior when transferring fields between the sales and purchase lines.
/// </summary>
/// <param name="ToPurchLine">
/// The purchase line record representing the target line being created.
/// </param>
/// <param name="FromSalesLine">
/// The sales line record from which data is being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesToPurchDoc(var ToPurchLine: Record "Purchase Line"; var FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesLinesToDoc(FromDocType: Option; var ToSalesHeader: Record "Sales Header"; var FromSalesShipmentLine: Record "Sales Shipment Line"; var FromSalesInvoiceLine: Record "Sales Invoice Line"; var FromReturnReceiptLine: Record "Return Receipt Line"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesJobFields(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesLineExtText(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; DocLineNo: Integer; var NextLineNo: Integer; var IsHandled: Boolean; RecalculateLines: Boolean; CopyExtText: Boolean; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines")
begin
end;
/// <summary>
/// Event triggered before copying a sales document for invoice cancellation.
/// Subscribing to this event allows developers to extend or customize the behavior
/// prior to the document copy operation. This can be useful for implementing custom logic,
/// validations, or pre-processing related to the invoice cancellation process.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the data is being copied.
/// </param>
/// <param name="FromDocNo">
/// The document number of the sales document being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesDocForInvoiceCancelling(var ToSalesHeader: Record "Sales Header"; FromDocNo: Code[20])
begin
end;
/// <summary>
/// Event triggered before copying a sales document for credit memo cancellation.
/// Subscribing to this event allows developers to extend or customize the behavior
/// prior to the document copy operation. This can be useful for implementing custom logic,
/// validations, or pre-processing related to the credit memo cancellation process.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the data is being copied.
/// </param>
/// <param name="FromDocNo">
/// The document number of the sales document being copied.
/// </param>
/// <param name="CopyJobData">
/// A boolean value indicating whether job data is included during the copy operation, which can be modified by the subscriber.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesDocForCrMemoCancelling(var ToSalesHeader: Record "Sales Header"; FromDocNo: Code[20]; var CopyJobData: Boolean)
begin
end;
/// <summary>
/// Event triggered before starting the process of copying a purchase document for invoice cancellation.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the purchase document has been copied. This can be useful for implementing additional logic,
/// applying custom validations, or altering parameters during the copy process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which the document is being copied.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source purchase document being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchaseDocForInvoiceCancelling(var ToPurchaseHeader: Record "Purchase Header"; FromDocNo: Code[20])
begin
end;
/// <summary>
/// Event triggered before starting the process of copying a purchase document for credit memo cancellation.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the purchase document has been copied. This can be useful for implementing additional logic,
/// applying custom validations, or altering parameters during the copy process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which the document is being copied.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source purchase document being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchaseDocForCrMemoCancelling(var ToPurchaseHeader: Record "Purchase Header"; FromDocNo: Code[20])
begin
end;
/// <summary>
/// Event triggered before copying data from the source purchase header to the target purchase header.
/// Subscribing to this event allows developers to override or extend the default behavior.
/// </summary>
/// <param name="FromDocType">
/// The document type of the source purchase document.
/// </param>
/// <param name="FromPurchHeader">
/// The source purchase header record being copied.
/// </param>
/// <param name="OldPurchHeader">
/// The target purchase header's state before the copying process.
/// </param>
/// <param name="ToPurchHeader">
/// The target purchase header record where the data will be copied.
/// </param>
/// <param name="IsHandled">
/// Set to true to skip the default copying logic.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchHeaderFromPurchHeader(FromDocType: Enum "Purchase Document Type From"; FromPurchHeader: Record "Purchase Header";
OldPurchHeader: Record "Purchase Header"; var ToPurchHeader: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeDeleteNegSalesLines(FromDocType: Option; FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCreateJobPlanningLine(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var JobContractEntryNo: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeIsEntityBlocked(TableNo: Integer; CreditDocType: Boolean; Type: Option; EntityNo: Code[20]; var EntityIsBlocked: Boolean; var IsHandled: Boolean; EntityCode: Code[10]);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeIsDeferralToBeCopied(DeferralDocType: Enum "Deferral Document Type"; ToDocType: Option;
FromDocType: Option; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeIsDeferralToBeDefaulted(DeferralDocType: Enum "Deferral Document Type"; ToDocType: Option;
FromDocType: Option; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSetShipmentDateInLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSplitPstdSalesLinesPerILE(ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; var TempSalesLineBuf: Record "Sales Line" temporary; FromShptOrRcpt: Boolean; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before transferring fields from a sales line to a purchase line during the copying process.
/// This allows developers to modify or override the default behavior of the field transfer.
/// </summary>
/// <param name="FromSalesLine">
/// The sales line record from which fields are being transferred.
/// </param>
/// <param name="ToPurchaseLine">
/// The purchase line record to which fields are being transferred.
/// </param>
/// <param name="IsHandled">
/// A boolean flag indicating whether the event has been handled by a subscriber.
/// If set to true, the default behavior will be skipped.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeTransfldsFromSalesToPurchLine(var FromSalesLine: Record "Sales Line"; var ToPurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before the sales line has been updated during the copy process. This allows custom logic to intervene or override the default behavior.
/// </summary>
/// <param name="ToSalesHeader">The target sales header record being updated.</param>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesHeader">The source sales header record being copied from.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="CopyThisLine">A boolean variable indicating whether the line should be copied.</param>
/// <param name="RecalculateAmount">A boolean variable indicating if the amounts need to be recalculated.</param>
/// <param name="FromSalesDocType">The document type of the source sales document.</param>
/// <param name="CopyPostedDeferral">A boolean variable indicating if posted deferrals should be copied.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var CopyThisLine: Boolean; RecalculateAmount: Boolean; FromSalesDocType: Option; var CopyPostedDeferral: Boolean)
begin
end;
/// <summary>
/// Event triggered before modifying the target purchase header.
/// Subscribing to this event allows developers to intervene in the modification process.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record being modified.
/// </param>
/// <param name="FromDocType">
/// The document type of the source purchase document.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source purchase document.
/// </param>
/// <param name="IncludeHeader">
/// Indicates whether the header is included in the process.
/// </param>
/// <param name="FromDocOccurenceNo">
/// The occurrence number of the source document, if applicable.
/// </param>
/// <param name="FromDocVersionNo">
/// The version number of the source document, if applicable.
/// </param>
/// <param name="RecalculateLines">
/// Indicates whether lines need to be recalculated.
/// </param>
/// <param name="FromPurchaseHeader">
/// The source purchase header record.
/// </param>
/// <param name="FromPurchInvHeader">
/// The source purchase invoice header, if applicable.
/// </param>
/// <param name="FromPurchCrMemoHeader">
/// The source purchase credit memo header, if applicable.
/// </param>
/// <param name="OldPurchaseHeader">
/// The previous state of the target purchase header.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeModifyPurchHeader(var ToPurchHeader: Record "Purchase Header"; FromDocType: Option; FromDocNo: Code[20]; IncludeHeader: Boolean; FromDocOccurenceNo: Integer; FromDocVersionNo: Integer; RecalculateLines: Boolean; FromPurchaseHeader: Record "Purchase Header"; FromPurchInvHeader: Record "Purch. Inv. Header"; FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; OldPurchaseHeader: Record "Purchase Header")
begin
end;
/// <summary>
/// Event triggered before recalculating the sales line. This allows custom logic to intervene or override the default behavior.
/// </summary>
/// <param name="ToSalesHeader">The target sales header record being updated.</param>
/// <param name="ToSalesLine">The target sales line record being recalculated.</param>
/// <param name="FromSalesHeader">The source sales header record being copied from.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="CopyThisLine">A boolean variable indicating whether the line should be copied.</param>
/// <param name="IsHandled">A boolean variable indicating whether the default recalculation logic should be skipped.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeRecalculateSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var CopyThisLine: Boolean; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before updating a purchase line during the document copy process. Allows custom logic or intervention.
/// </summary>
/// <param name="ToPurchHeader">The target purchase header record where the line is being copied to.</param>
/// <param name="ToPurchLine">The target purchase line record being updated.</param>
/// <param name="FromPurchHeader">The source purchase header record where the line is being copied from.</param>
/// <param name="FromPurchLine">The source purchase line record being copied.</param>
/// <param name="CopyThisLine">A boolean variable indicating if the current line should be copied.</param>
/// <param name="RecalculateAmount">A boolean variable indicating if amounts should be recalculated during the update.</param>
/// <param name="FromPurchDocType">The type of the source purchase document.</param>
/// <param name="CopyPostedDeferral">A boolean variable indicating if posted deferrals should be copied.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdatePurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean; RecalculateAmount: Boolean; FromPurchDocType: Option; var CopyPostedDeferral: Boolean)
begin
end;
/// <summary>
/// Event triggered before updating the purchase header during a copy operation. Allows overriding or customizing the update process.
/// </summary>
/// <param name="PurchaseHeader">The target purchase header being updated.</param>
/// <param name="OriginalPurchaseHeader">The original purchase header being copied from.</param>
/// <param name="FromDocType">The document type of the source purchase document.</param>
/// <param name="IsHandled">A boolean variable indicating if the event is handled. If set to true, the default logic will be skipped.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdatePurchHeaderWhenCopyFromPurchHeader(var PurchaseHeader: Record "Purchase Header"; OriginalPurchaseHeader: Record "Purchase Header"; FromDocType: Enum "Purchase Document Type From"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdatePurchCreditMemoHeader(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before validating purchase line discount fields. Allows overriding or customizing the validation process.
/// </summary>
/// <param name="FromPurchHeader">The purchase header of the source document.</param>
/// <param name="ToPurchHeader">The purchase header of the target document.</param>
/// <param name="ToPurchLine">The purchase line of the target document.</param>
/// <param name="InvDiscountAmount">The invoice discount amount being validated.</param>
/// <param name="IsHandled">A boolean variable indicating if the event is handled. If set to true, the default logic will be skipped.</param>
/// <param name="RecalculateLines">A boolean variable indicating if the lines are being recalculated.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeValidatePurchLineDiscountFields(FromPurchHeader: Record "Purchase Header"; ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var InvDiscountAmount: Decimal; var IsHandled: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromSalesHeader(SalesHeaderFrom: Record "Sales Header"; SalesHeaderTo: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromSalesShptHeader(SalesShipmentHeaderFrom: Record "Sales Shipment Header"; SalesHeaderTo: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromSalesInvHeader(SalesInvoiceHeaderFrom: Record "Sales Invoice Header"; SalesHeaderTo: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromSalesCrMemoHeader(SalesCrMemoHeaderFrom: Record "Sales Cr.Memo Header"; SalesHeaderTo: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromSalesReturnRcptHeader(ReturnReceiptHeaderFrom: Record "Return Receipt Header"; SalesHeaderTo: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromPurchaseHeader(PurchaseHeaderFrom: Record "Purchase Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromPurchaseRcptHeader(PurchRcptHeaderFrom: Record "Purch. Rcpt. Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromPurchaseInvHeader(PurchInvHeaderFrom: Record "Purch. Inv. Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromPurchaseCrMemoHeader(PurchCrMemoHdrFrom: Record "Purch. Cr. Memo Hdr."; PurchaseHeaderTo: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckFromPurchaseReturnShptHeader(ReturnShipmentHeaderFrom: Record "Return Shipment Header"; PurchaseHeaderTo: Record "Purchase Header")
begin
end;
/// <summary>
/// Event triggered after copying a sales document for invoice cancellation.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the document copy operation. This can be useful for implementing post-processing logic,
/// validations, or custom workflows related to the invoice cancellation process.
/// </summary>
/// <param name="FromDocNo">
/// The document number of the sales document that was copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the data was copied.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the header was included in the copy operation.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy operation.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines were moved during the copy operation.
/// </param>
/// <param name="CreateToHeader">
/// A boolean value indicating whether a new header was created during the copy operation.
/// </param>
/// <param name="HideDialog">
/// A boolean value indicating whether dialogs were hidden during the copy operation.
/// </param>
/// <param name="ExactCostRevMandatory">
/// A boolean value indicating whether exact cost reversal was mandatory during the copy operation.
/// </param>
/// <param name="ApplyFully">
/// A boolean value indicating whether the "apply fully" option was used during the copy operation.
/// </param>
/// <param name="SkipTestCreditLimit">
/// A boolean value indicating whether the credit limit test was skipped during the copy operation.
/// </param>
/// <param name="SkipCopyFromDescription">
/// A boolean value indicating whether the description was skipped during the copy operation.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocForInvoiceCancelling(FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; MoveNegLines: Boolean; CreateToHeader: Boolean; HideDialog: Boolean; ExactCostRevMandatory: Boolean; ApplyFully: Boolean; SkipTestCreditLimit: Boolean; SkipCopyFromDescription: Boolean)
begin
end;
/// <summary>
/// Event triggered after copying a sales document for credit memo cancellation.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the document copy operation. This can be useful for implementing post-processing logic,
/// validations, or custom workflows related to the credit memo cancellation process.
/// </summary>
/// <param name="FromDocNo">
/// The document number of the sales document that was copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the data was copied.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the header was included in the copy operation.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy operation.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines were moved during the copy operation.
/// </param>
/// <param name="CreateToHeader">
/// A boolean value indicating whether a new header was created during the copy operation.
/// </param>
/// <param name="HideDialog">
/// A boolean value indicating whether dialogs were hidden during the copy operation.
/// </param>
/// <param name="ExactCostRevMandatory">
/// A boolean value indicating whether exact cost reversal was mandatory during the copy operation.
/// </param>
/// <param name="ApplyFully">
/// A boolean value indicating whether the "apply fully" option was used during the copy operation.
/// </param>
/// <param name="SkipTestCreditLimit">
/// A boolean value indicating whether the credit limit test was skipped during the copy operation.
/// </param>
/// <param name="SkipCopyFromDescription">
/// A boolean value indicating whether the description was skipped during the copy operation.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocForCrMemoCancelling(FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; MoveNegLines: Boolean; CreateToHeader: Boolean; HideDialog: Boolean; ExactCostRevMandatory: Boolean; ApplyFully: Boolean; SkipTestCreditLimit: Boolean; SkipCopyFromDescription: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLineExtText(ToPurchaseHeader: Record "Purchase Header"; var ToPurchaseLine: Record "Purchase Line"; FromPurchaseHeader: Record "Purchase Header"; FromPurchaseLine: Record "Purchase Line"; DocLineNo: Integer; var NextLineNo: Integer; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchCrMemoLinesToDoc(ToPurchaseHeader: Record "Purchase Header"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchReturnShptLinesToDoc(ToPurchaseHeader: Record "Purchase Header"; var FromReturnShipmentLine: Record "Return Shipment Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchRcptLinesToDoc(ToPurchaseHeader: Record "Purchase Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchInvLinesToDoc(ToPurchaseHeader: Record "Purchase Header"; var FromPurchInvLine: Record "Purch. Inv. Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
/// <summary>
/// Event triggered after completing the sales invoice line copy process for the sales document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after all sales invoice lines have been copied. This can be useful for implementing post-processing logic,
/// validations, or handling specific workflows related to the copied sales invoice lines.
/// </summary>
/// <param name="FromSalesInvoiceHeader">
/// The source sales invoice header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales invoice lines were copied.
/// </param>
/// <param name="FromSalesInvoiceLine">
/// The source sales invoice line record that was copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocInvLine(FromSalesInvoiceHeader: Record "Sales Invoice Header"; ToSalesHeader: Record "Sales Header"; var FromSalesInvoiceLine: Record "Sales Invoice Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesCrMemoLinesToDoc(var ToSalesHeader: Record "Sales Header"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesInvLinesToDoc(var ToSalesHeader: Record "Sales Header"; var FromSalesInvoiceLine: Record "Sales Invoice Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesReturnRcptLinesToDoc(ToSalesHeader: Record "Sales Header"; var FromReturnReceiptLine: Record "Return Receipt Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesShptLinesToDoc(ToSalesHeader: Record "Sales Header"; var FromSalesShipmentLine: Record "Sales Shipment Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
/// <summary>
/// Event triggered after completing the archived sales line copy process for the sales document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after all archived sales lines have been copied. This can be useful for implementing post-processing logic,
/// validations, or handling specific workflows related to the copied archived sales lines.
/// </summary>
/// <param name="FromSalesHeaderArchive">
/// The source sales header archive record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the archived sales lines were copied.
/// </param>
/// <param name="ToSalesLine">
/// The target sales line record to which the archived sales lines were copied.
/// </param>
/// <param name="TransferOldExtLines">
/// An object codeunit "Transfer Old Ext. Text Lines" handling the transfer of old extended lines, if applicable.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocSalesLineArchive(FromSalesHeaderArchive: Record "Sales Header Archive"; var ToSalesHeader: Record "Sales Header"; ToSalesLine: Record "Sales Line"; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromPurchDocAssgntToLine(var ToPurchaseLine: Record "Purchase Line"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromSalesDocAssgntToLine(var ToSalesLine: Record "Sales Line"; RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after completing the copy of a single archived sales line during the sales document copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after each archived sales line has been copied. This can be useful for implementing post-processing logic,
/// validations, or handling specific workflows related to individual archived sales lines.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the archived sales line was copied.
/// </param>
/// <param name="ToSalesLine">
/// The target sales line record to which the archived sales line was copied.
/// </param>
/// <param name="FromSalesLineArchive">
/// The source sales line archive record that was copied.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the header was included in the copy operation.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyArchSalesLine(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive"; IncludeHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnBeforeCopyFromArchSalesDocDimToLine(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeaderArchive: Record "Sales Header Archive"; FromSalesLineArchive: Record "Sales Line Archive"; RecalculateLines: Boolean; var LinesNotCopied: Integer)
begin
end;
/// <summary>
/// Event triggered after a purchase line has been copied from the archived source to the target purchase document.
/// Subscribing to this event allows developers to implement additional logic, validations,
/// or workflows after copying each archived purchase line. This can be useful for custom handling or integrations.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the line was copied.
/// </param>
/// <param name="ToPurchaseLine">
/// The target purchase line record that was created.
/// </param>
/// <param name="FromPurchaseLineArchive">
/// The source purchase line archive record that was copied.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the source header data was included.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyArchPurchLine(ToPurchHeader: Record "Purchase Header"; var ToPurchaseLine: Record "Purchase Line"; FromPurchaseLineArchive: Record "Purchase Line Archive"; IncludeHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFieldsFromOldPurchHeaderProcedure(var PurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header")
begin
end;
/// <summary>
/// Event triggered after copying data from a posted purchase receipt header to a purchase header.
/// Allows developers to perform additional logic or modifications after the copying process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data was copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchRcptHeader">
/// The source posted purchase receipt header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPostedReceipt(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchRcptHeader: Record "Purch. Rcpt. Header")
begin
end;
/// <summary>
/// Event triggered after completing the copy of a sales shipment header to the target sales header during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the fields have been transferred. This can be useful for implementing additional logic,
/// validations, or workflows based on the copied shipment data.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields were copied.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the field transfer.
/// </param>
/// <param name="FromSalesShipmentHeader">
/// The source sales shipment header record that was copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPostedShipment(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; FromSalesShipmentHeader: Record "Sales Shipment Header")
begin
end;
/// <summary>
/// Event triggered after copying data from a posted purchase invoice header to a purchase header.
/// Allows developers to perform additional logic or modifications after the copying process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data was copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchInvHeader">
/// The source posted purchase invoice header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPostedPurchInvoice(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchInvHeader: Record "Purch. Inv. Header")
begin
end;
/// <summary>
/// Event triggered after completing the transfer of fields from the source return receipt header to the target sales header during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the fields have been transferred. This can be useful for implementing additional logic,
/// validations, or workflows based on the copied return receipt data.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields were copied.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the field transfer.
/// </param>
/// <param name="ReturnReceiptHeader">
/// The source return receipt header record that was copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPostedReturnReceipt(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; ReturnReceiptHeader: Record "Return Receipt Header")
begin
end;
/// <summary>
/// Event triggered after copying data from a posted return shipment header to a purchase header.
/// Allows developers to perform additional logic or modifications after the copying process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data was copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromReturnShipmentHeader">
/// The source posted return shipment header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPostedReturnShipment(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromReturnShipmentHeader: Record "Return Shipment Header")
begin
end;
/// <summary>
/// Event triggered after completing the sales document copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the document copy operation is completed. This can be useful for implementing post-processing logic,
/// validations, or handling specific workflows related to the copy process.
/// </summary>
/// <param name="FromDocumentType">
/// The type of the sales document being copied, represented as an integer.
/// </param>
/// <param name="FromDocumentNo">
/// The document number of the sales document being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the data was copied.
/// </param>
/// <param name="FromDocOccurenceNo">
/// The occurrence number of the source document, if applicable.
/// </param>
/// <param name="FromDocVersionNo">
/// The version number of the source document, if applicable.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the header was included in the copy operation.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy operation.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines were moved during the copy operation.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocument(FromDocumentType: Option; FromDocumentNo: Code[20]; var ToSalesHeader: Record "Sales Header"; FromDocOccurenceNo: Integer; FromDocVersionNo: Integer; IncludeHeader: Boolean; RecalculateLines: Boolean; MoveNegLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after completing the transfer of fields from the source sales header archive to the target sales header.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the archive header has been fully copied. This can be useful for additional processing,
/// validations, or workflows related to archived sales headers.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields were copied.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the field transfer.
/// </param>
/// <param name="FromSalesHeaderArchive">
/// The source sales header archive record that was copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesHeaderArchive(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; FromSalesHeaderArchive: Record "Sales Header Archive")
begin
end;
/// <summary>
/// Event triggered after the sales header has been processed during the sales document update process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the header fields have been copied. This can be useful for post-processing logic,
/// additional validations, or implementing specific workflows.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the data is being copied.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the update.
/// </param>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="FromSalesShipmentHeader">
/// The source sales shipment header, if applicable.
/// </param>
/// <param name="FromSalesInvoiceHeader">
/// The source sales invoice header, if applicable.
/// </param>
/// <param name="FromReturnReceiptHeader">
/// The source return receipt header, if applicable.
/// </param>
/// <param name="FromSalesCrMemoHeader">
/// The source sales credit memo header, if applicable.
/// </param>
/// <param name="FromSalesCrMemoHeader">
/// The source sales header archive, if applicable.
/// </param>
/// <param name="FromDocType">
/// The type of the source sales document.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesHeaderDone(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; FromSalesShipmentHeader: Record "Sales Shipment Header"; FromSalesInvoiceHeader: Record "Sales Invoice Header"; FromReturnReceiptHeader: Record "Return Receipt Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; FromSalesHeaderArchive: Record "Sales Header Archive"; FromDocType: Enum "Sales Document Type From")
begin
end;
/// <summary>
/// Event triggered after sales lines with negative quantities have been deleted or validated during a test.
/// This allows developers to perform additional logic after the deletion or validation process.
/// </summary>
/// <param name="FromSalesLine">
/// The sales line record that was processed during the deletion or validation.
/// </param>
/// <param name="OnlyTest">
/// A boolean flag indicating whether the operation was a test or a real deletion.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterDeleteSalesLinesWithNegQty(FromSalesLine: Record "Sales Line"; OnlyTest: Boolean)
begin
end;
/// <summary>
/// Event triggered before the sales header is processed during the sales document update process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the header fields have been copied. This can be useful for pre-processing logic
/// or validating specific conditions prior to the header update.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the data is being copied.
/// </param>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="FromDocType">
/// The type of the source sales document.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the update.
/// </param>
/// <param name="FromSalesShipmentHeader">
/// The source sales shipment header, if applicable.
/// </param>
/// <param name="FromSalesInvoiceHeader">
/// The source sales invoice header, if applicable.
/// </param>
/// <param name="FromReturnReceiptHeader">
/// The source return receipt header, if applicable.
/// </param>
/// <param name="FromSalesCrMemoHeader">
/// The source sales credit memo header, if applicable.
/// </param>
/// <param name="FromSalesHeaderArchive">
/// The source sales header archive, if applicable.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesHeaderDone(var ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From"; OldSalesHeader: Record "Sales Header";
FromSalesShipmentHeader: Record "Sales Shipment Header";
FromSalesInvoiceHeader: Record "Sales Invoice Header";
FromReturnReceiptHeader: Record "Return Receipt Header";
FromSalesCrMemoHeader: Record "Sales Cr.Memo Header";
FromSalesHeaderArchive: Record "Sales Header Archive")
begin
end;
/// <summary>
/// Event triggered before starting the process of copying fields from the source sales invoice header to the target sales header.
/// Subscribing to this event allows developers to override or extend the default behavior
/// before the fields have been copied. This can be useful for implementing custom logic,
/// skipping the default copy behavior, or applying additional validations.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields are being copied.
/// </param>
/// <param name="SalesInvoiceHeader">
/// The source sales invoice header record being copied.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default copy behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopySalesHeaderFromPostedInvoice(var ToSalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; var IsHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesCrMemoLine(var TempDocSalesLine: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var FromSalesLineBuf: Record "Sales Line"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; FromSalesLine: Record "Sales Line"; SplitLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesInvLine(var TempDocSalesLine: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var FromSalesLineBuf: Record "Sales Line"; var FromSalesInvLine: Record "Sales Invoice Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLinesToBufferFields(var TempSalesLine: Record "Sales Line" temporary; FromSalesLine: Record "Sales Line"; FromSalesLineParam: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLinesToDoc(FromDocType: Option; var ToSalesHeader: Record "Sales Header"; var FromSalesShipmentLine: Record "Sales Shipment Line"; var FromSalesInvoiceLine: Record "Sales Invoice Line"; var FromReturnReceiptLine: Record "Return Receipt Line"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean; var RecalculateLines: Boolean; var IncludeHeader: Boolean)
begin
end;
/// <summary>
/// Event triggered after copying data from a posted purchase credit memo header to a purchase header.
/// Allows developers to perform additional logic or modifications after the copying process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data was copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchCrMemoHeader">
/// The source posted purchase credit memo header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchHeaderFromPostedCreditMemo(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.")
begin
end;
/// <summary>
/// Event triggered after the entire purchase document copy process has been completed.
/// Subscribing to this event allows developers to implement additional logic,
/// custom validations, or workflows after the purchase document has been fully copied.
/// This can be useful for finalizing the operation or integrating with other processes.
/// </summary>
/// <param name="FromDocumentType">
/// The type of the source purchase document.
/// </param>
/// <param name="FromDocumentNo">
/// The document number of the source purchase document.
/// </param>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which the document was copied.
/// </param>
/// <param name="FromDocOccurenceNo">
/// The occurrence number of the source document (if applicable).
/// </param>
/// <param name="FromDocVersionNo">
/// The version number of the source document (if applicable).
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the source header data was included.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy process.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines were moved during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchaseDocument(FromDocumentType: Option; FromDocumentNo: Code[20]; var ToPurchaseHeader: Record "Purchase Header"; FromDocOccurenceNo: Integer; FromDocVersionNo: Integer; IncludeHeader: Boolean; RecalculateLines: Boolean; MoveNegLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after copying data from a purchase header archive to a purchase header.
/// Allows developers to perform additional logic or modifications after the copying process.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data was copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchaseHeaderArchive">
/// The source purchase header archive record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchHeaderArchive(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchaseHeaderArchive: Record "Purchase Header Archive")
begin
end;
/// <summary>
/// Event triggered after the purchase header has been copied from the source to the target purchase document.
/// Subscribing to this event allows developers to extend or customize the copying logic of purchase headers,
/// such as adding additional fields or implementing validations.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record where the header information has been copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The previous state of the target purchase header before the copying process.
/// </param>
/// <param name="FromPurchaseHeader">
/// The source purchase header record from which the information was copied.
/// </param>
/// <param name="FromPurchRcptHeader">
/// The source purchase receipt header, if applicable, for additional data transfer.
/// </param>
/// <param name="FromPurchInvHeader">
/// The source purchase invoice header, if applicable, for additional data transfer.
/// </param>
/// <param name="ReturnShipmentHeader">
/// The source return shipment header, if applicable, for additional data transfer.
/// </param>
/// <param name="FromPurchCrMemoHdr">
/// The source purchase credit memo header, if applicable, for additional data transfer.
/// </param>
/// <param name="FromPurchaseHeaderArchive">
/// The source purchase header archive record, if applicable, for additional data transfer.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchHeaderDone(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchaseHeader: Record "Purchase Header"; FromPurchRcptHeader: Record "Purch. Rcpt. Header"; FromPurchInvHeader: Record "Purch. Inv. Header"; ReturnShipmentHeader: Record "Return Shipment Header"; FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; FromPurchaseHeaderArchive: Record "Purchase Header Archive")
begin
end;
/// <summary>
/// Event triggered before finalizing the header copying process.
/// Subscribing to this event allows developers to modify or add logic during initialization or pre-processing.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record where the header information will be copied.
/// </param>
/// <param name="FromPurchaseHeader">
/// The source purchase header record being copied.
/// </param>
/// <param name="FromDocType">
/// The document type of the source purchase document.
/// </param>
/// <param name="OldPurchaseHeader">
/// The target purchase header's state before the copying process.
/// </param>
/// <param name="FromPurchRcptHeader">
/// The source purchase receipt header, if applicable.
/// </param>
/// <param name="FromPurchInvHeader">
/// The source purchase invoice header, if applicable.
/// </param>
/// <param name="FromReturnShipmentHeader">
/// The source return shipment header, if applicable.
/// </param>
/// <param name="FromPurchCrMemoHdr">
/// The source purchase credit memo header, if applicable.
/// </param>
/// <param name="FromPurchaseHeaderArchive">
/// The source purchase header archive, if applicable.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchHeaderDone(var ToPurchaseHeader: Record "Purchase Header"; FromPurchaseHeader: Record "Purchase Header"; FromDocType: Enum "Purchase Document Type From"; OldPurchaseHeader: Record "Purchase Header";
FromPurchRcptHeader: Record "Purch. Rcpt. Header";
FromPurchInvHeader: Record "Purch. Inv. Header";
FromReturnShipmentHeader: Record "Return Shipment Header";
FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.";
FromPurchaseHeaderArchive: Record "Purchase Header Archive";
BuyFromVendor: Record Vendor;
PayToVendor: Record Vendor)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchInvLines(var TempDocPurchaseLine: Record "Purchase Line" temporary; var ToPurchHeader: Record "Purchase Header"; var FromPurchLineBuf: Record "Purchase Line"; var FromPurchInvLine: Record "Purch. Inv. Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchInvLine(FromPurchInvLine: Record "Purch. Inv. Line"; var ToPurchaseLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLinesToBufferFields(var TempPurchaseLine: Record "Purchase Line" temporary; FromPurchaseLine: Record "Purchase Line"; FromPurchLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchaseLinesToDoc(FromDocType: Option; var ToPurchaseHeader: Record "Purchase Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; var FromPurchInvLine: Record "Purch. Inv. Line"; var FromReturnShipmentLine: Record "Return Shipment Line"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean; var RecalculateLines: Boolean; var IncludeHeader: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchCrMemoLine(FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var ToPurchaseLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchRcptLine(FromPurchRcptLine: Record "Purch. Rcpt. Line"; var ToPurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyReturnShptLine(FromReturnShipmentLine: Record "Return Shipment Line"; var ToPurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitFromSalesLine(var FromSalesLine2: Record "Sales Line"; var FromSalesLineBuf: Record "Sales Line");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitShipmentDateInLine(SalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line");
begin
end;
/// <summary>
/// Event triggered after handling the assembly attached to a sales line. This allows additional modifications or actions after the handling process has been completed.
/// </summary>
/// <param name="ToSalesLine">The sales line record that has been processed.</param>
[IntegrationEvent(false, false)]
local procedure OnAfterHandleAsmAttachedToSalesLine(var ToSalesLine: Record "Sales Line");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterProcessToAsmHeader(var ToAsmHeader: Record "Assembly Header"; TempFromAsmHeader: Record "Assembly Header" temporary; ToSalesLine: Record "Sales Line"; BasicAsmOrderCopy: Boolean; AvailabilityCheck: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterRecalculatePurchLine(var PurchaseLine: Record "Purchase Line"; var ToPurchHeader: Record "Purchase Header"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean)
begin
end;
/// <summary>
/// Event triggered after recalculating the sales line. This allows additional modifications or checks after the recalculation process.
/// </summary>
/// <param name="ToSalesHeader">The target sales header record being updated.</param>
/// <param name="ToSalesLine">The target sales line record being recalculated.</param>
/// <param name="FromSalesHeader">The source sales header record being copied from.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="CopyThisLine">A boolean variable indicating whether the line was copied.</param>
[IntegrationEvent(false, false)]
local procedure OnAfterRecalculateSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var CopyThisLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSetDefaultValuesToSalesLine(var ToSalesLine: Record "Sales Line"; ToSalesHeader: Record "Sales Header"; CreateToHeader: Boolean; RecalculateLines: Boolean; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSetDefaultValuesToPurchLine(var ToPurchaseLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header"; CreateToHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterShouldSkipCopyFromDescription(var Result: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterTransferFieldsFromCrMemoToInv(var ToSalesHeader: Record "Sales Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var CopyJobData: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterTransferTempAsmHeader(var TempAssemblyHeader: Record "Assembly Header" temporary; PostedAssemblyHeader: Record "Posted Assembly Header")
begin
end;
/// <summary>
/// Event triggered after the sales line update process has been completed. This allows additional modifications or checks after all updates have been executed.
/// </summary>
/// <param name="ToSalesHeader">The target sales header record being updated.</param>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesHeader">The source sales header record being copied from.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="CopyThisLine">A boolean variable indicating whether the line was copied.</param>
/// <param name="RecalculateAmount">A boolean variable indicating if the amounts were recalculated.</param>
/// <param name="FromSalesDocType">The document type of the source sales document.</param>
/// <param name="CopyPostedDeferral">A boolean variable indicating if posted deferrals were copied.</param>
/// <param name="ExactCostRevMandatory">A boolean variable indicating if exact cost reversal is mandatory.</param>
/// <param name="MoveNegLines">A boolean variable indicating if negative lines were moved.</param>
/// <param name="RecalculateLines">A boolean variable indicating if lines were recalculated.</param>
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var CopyThisLine: Boolean; RecalculateAmount: Boolean; FromSalesDocType: Option; var CopyPostedDeferral: Boolean; ExactCostRevMandatory: Boolean; MoveNegLines: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdatePurchCreditMemoHeader(var PurchaseHeader: Record "Purchase Header")
begin
end;
/// <summary>
/// Event triggered after updating a purchase line during the document copy process. Allows additional processing or validation.
/// </summary>
/// <param name="ToPurchHeader">The target purchase header record where the line was copied to.</param>
/// <param name="ToPurchLine">The target purchase line record that was updated.</param>
/// <param name="FromPurchHeader">The source purchase header record where the line was copied from.</param>
/// <param name="FromPurchLine">The source purchase line record that was copied.</param>
/// <param name="CopyThisLine">A boolean variable indicating if the current line was copied.</param>
/// <param name="RecalculateAmount">A boolean variable indicating if amounts were recalculated during the update.</param>
/// <param name="FromPurchDocType">The type of the source purchase document.</param>
/// <param name="CopyPostedDeferral">A boolean variable indicating if posted deferrals were copied.</param>
/// <param name="RecalculateLines">A boolean variable indicating if lines were recalculated.</param>
[IntegrationEvent(false, false)]
local procedure OnAfterUpdatePurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean; RecalculateAmount: Boolean; FromPurchDocType: Option; var CopyPostedDeferral: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateRevSalesLineAmount(var SalesLine: Record "Sales Line"; OrgQtyBase: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateVendLedgEntry(var PurchaseHeader: Record "Purchase Header"; FromDocumentNo: Code[20]; FromDocType: Enum "Gen. Journal Document Type"; var VendorLedgerEntry: Record "Vendor Ledger Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLine(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered after setting the reserve property for the sales line. This allows additional customizations of the reserve logic.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="FromSalesDocType">The document type of the source sales document.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnAfterSetReserve(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line"; FromSalesDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdatePurchLine(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered after determining whether to fetch the unit cost for the sales line. This allows custom logic based on the fetched unit cost.
/// </summary>
/// <param name="Item">The item record associated with the sales line.</param>
/// <param name="ShouldGetUnitCost">A boolean variable indicating whether the unit cost should be fetched.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnAfterCalcShouldGetUnitCost(var Item: Record Item; var ShouldGetUnitCost: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocWithHeader(FromDocType: Option; FromDocNo: Code[20]; var ToSalesHeader: Record "Sales Header"; FromDocOccurenceNo: Integer; FromDocVersionNo: Integer; var FromSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPostedDeferralsOnBeforeDeferralHeaderInsert(var DeferralHeader: Record "Deferral Header"; PostedDeferralHeader: Record "Posted Deferral Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPostedDeferralsOnBeforeDeferralHeaderModify(var DeferralHeader: Record "Deferral Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPostedDeferralsOnBeforeDeferralLineInsert(var DeferralLine: Record "Deferral Line"; PostedDeferralLine: Record "Posted Deferral Line")
begin
end;
/// <summary>
/// Event triggered when the header is being processed for copying in a purchase document.
/// Allows developers to implement advanced processing during header inclusion.
/// </summary>
/// <param name="FromDocType">
/// The document type of the source purchase document.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source purchase document.
/// </param>
/// <param name="ToPurchHeader">
/// The target purchase header record being processed.
/// </param>
/// <param name="FromDocOccurenceNo">
/// The occurrence number of the source document, if applicable.
/// </param>
/// <param name="FromDocVersionNo">
/// The version number of the source document, if applicable.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocWithHeader(FromDocType: Option; FromDocNo: Code[20]; var ToPurchHeader: Record "Purchase Header"; FromDocOccurenceNo: Integer; FromDocVersionNo: Integer)
begin
end;
/// <summary>
/// Event triggered after transferring fields from a sales line to a purchase line.
/// This allows developers to apply additional logic or modifications after the field transfer process has been completed.
/// </summary>
/// <param name="FromSalesLine">
/// The sales line record from which fields were transferred.
/// </param>
/// <param name="ToPurchaseLine">
/// The purchase line record to which fields were transferred.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterTransfldsFromSalesToPurchLine(var FromSalesLine: Record "Sales Line"; var ToPurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitAndCheckSalesDocuments(FromDocType: Option; FromDocNo: Code[20]; FromDocOccurrenceNo: Integer; FromDocVersionNo: Integer; var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesShipmentHeader: Record "Sales Shipment Header"; var FromSalesInvoiceHeader: Record "Sales Invoice Header"; var FromReturnReceiptHeader: Record "Return Receipt Header"; var FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var FromSalesHeaderArchive: Record "Sales Header Archive"; IncludeHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitAndCheckPurchaseDocuments(FromDocType: Option; FromDocNo: Code[20]; FromDocOccurrenceNo: Integer; FromDocVersionNo: Integer; var FromPurchaseHeader: Record "Purchase Header"; var ToPurchaseHeader: Record "Purchase Header"; var FromPurchRcptHeader: Record "Purch. Rcpt. Header"; var FromPurchInvHeader: Record "Purch. Inv. Header"; var FromReturnShipmentHeader: Record "Return Shipment Header"; var FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var FromPurchaseHeaderArchive: Record "Purchase Header Archive"; IncludeHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitSalesLineFields(var SalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitPurchLineFields(var PurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitToSalesLine(var ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInitSalesLineFields(var SalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInitPurchLineFields(var PurchaseLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered before inserting the copied sales line into the target sales document.
/// This allows developers to modify the sales line prior to insertion.
/// </summary>
/// <param name="ToSalesLine">The target sales line being inserted.</param>
/// <param name="FromSalesLine">The source sales line being copied.</param>
/// <param name="FromDocType">The document type of the source sales document.</param>
/// <param name="RecalcLines">A boolean variable indicating whether lines need to be recalculated during the copy operation.</param>
/// <param name="ToSalesHeader">The target sales header to which the sales line will be copied.</param>
/// <param name="DocLineNo">The line number of the document line being processed.</param>
/// <param name="NextLineNo">The next line number to be assigned to the target sales line.</param>
/// <param name="RecalculateAmount">A boolean variable indicating whether the amounts need to be recalculated for the copied sales line.</param>
/// <param name="IsHandled">A boolean variable that allows developers to handle the logic themselves and skip the default insertion process if set to true.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertToSalesLine(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; FromDocType: Option; RecalcLines: Boolean; var ToSalesHeader: Record "Sales Header"; DocLineNo: Integer; var NextLineNo: Integer; RecalculateAmount: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnBeforeInsertOldSalesDocNoLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; OldDocType: Option; OldDocNo: Code[20]; var NextLineNo: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckFromSalesInvHeader(SalesInvoiceHeaderFrom: Record "Sales Invoice Header"; SalesHeaderTo: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckCopyFromSalesHeaderArchiveAvail(FromSalesHeaderArchive: Record "Sales Header Archive"; ToSalesHeader: Record "Sales Header"; MoveNegLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckUnappliedLines(SkippedLine: Boolean; var MissingExCostRevLink: Boolean; var WarningDone: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertOldSalesCombDocNoLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; CopyFromInvoice: Boolean; OldDocNo: Code[20]; OldDocNo2: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertOldSalesCombDocNoLineProcedure(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; CopyFromInvoice: Boolean; OldDocNo: Code[20]; OldDocNo2: Code[20]; var NextLineNo: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterInitToPurchLine(var ToPurchaseLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered before inserting the purchase line into the target document. This allows modifications to the line before insertion.
/// </summary>
/// <param name="ToPurchLine">The purchase line of the target document.</param>
/// <param name="FromPurchLine">The purchase line from the source document being processed.</param>
/// <param name="FromDocType">The type of the source purchase document.</param>
/// <param name="RecalcLines">A boolean variable indicating if the lines should be recalculated.</param>
/// <param name="ToPurchHeader">The purchase header of the target document.</param>
/// <param name="DocLineNo">The line number of the source document line.</param>
/// <param name="NexLineNo">The next line number for the target document.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertToPurchLine(var ToPurchLine: Record "Purchase Line"; FromPurchLine: Record "Purchase Line"; FromDocType: Option; RecalcLines: Boolean; var ToPurchHeader: Record "Purchase Header"; DocLineNo: Integer; var NexLineNo: Integer)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnBeforeInsertOldPurchDocNoLine(ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; OldDocType: Option; OldDocNo: Code[20]; var NextLineNo: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInsertOldPurchCombDocNoLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; CopyFromInvoice: Boolean; OldDocNo: Code[20]; OldDocNo2: Code[20])
begin
end;
/// <summary>
/// Event triggered before displaying a purchase document.
/// This allows developers to modify or override the default behavior when showing a purchase document.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The purchase header record representing the document to be displayed.
/// </param>
/// <param name="IsHandled">
/// A variable indicating whether the default behavior should be skipped.
/// Setting this variable to true will skip the default display logic.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeShowPurchDoc(var ToPurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before displaying a sales document.
/// This allows developers to modify or override the default behavior when showing a sales document.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record representing the document to be displayed.
/// </param>
/// <param name="IsHandled">
/// A variable indicating whether the default behavior should be skipped.
/// Setting this variable to true will skip the default display logic.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeShowSalesDoc(var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateCustLedgEntry(var ToSalesHeader: Record "Sales Header"; var CustLedgerEntry: Record "Cust. Ledger Entry"; var IsHandled: Boolean; FromDocType: Enum "Gen. Journal Document Type"; FromDocNo: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateVendLedgEntry(var ToPurchaseHeader: Record "Purchase Header"; VendorLedgerEntry: Record "Vendor Ledger Entry"; var IsHandled: Boolean; FromDocType: Enum "Gen. Journal Document Type"; FromDocNo: Code[20])
begin
end;
/// <summary>
/// Event triggered after inserting the copied sales line into the target sales document.
/// This allows developers to perform final adjustments or actions.
/// </summary>
/// <param name="ToSalesLine">The target sales line that was inserted.</param>
/// <param name="FromSalesLine">The source sales line that was copied.</param>
/// <param name="RecalculateLines">A boolean variable indicating whether lines were recalculated during the copy operation.</param>
/// <param name="DocLineNo">The line number of the document line being processed.</param>
/// <param name="FromSalesDocType">The document type of the source sales document.</param>
/// <param name="FromSalesHeader">The source sales header from which the sales line was copied.</param>
/// <param name="NextLineNo">The next line number assigned to the target sales line.</param>
/// <param name="ToSalesHeader">The target sales header to which the sales line was copied.</param>
[IntegrationEvent(false, false)]
local procedure OnAfterInsertToSalesLine(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line"; RecalculateLines: Boolean; DocLineNo: Integer; FromSalesDocType: Enum "Sales Document Type From"; FromSalesHeader: Record "Sales Header"; var NextLineNo: Integer; var ToSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered after copying a sales line to a purchase line during the copying process from a sales document to a purchase document.
/// This allows developers to apply additional logic or modifications after the line has been copied.
/// </summary>
/// <param name="ToPurchLine">
/// The purchase line record representing the line that was created.
/// </param>
/// <param name="FromSalesLine">
/// The sales line record from which data was copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesToPurchDoc(var ToPurchLine: Record "Purchase Line"; var FromSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered after inserting a purchase line into the target document. Allows further processing or validation after the insertion.
/// </summary>
/// <param name="ToPurchLine">The purchase line of the target document.</param>
/// <param name="FromPurchLine">The purchase line from the source document being processed.</param>
/// <param name="RecalculateLines">A boolean variable indicating if the lines should be recalculated.</param>
/// <param name="DocLineNo">The line number of the source document line.</param>
/// <param name="FromPurchDocType">The type of the source purchase document.</param>
/// <param name="ToPurchHeader">The purchase header of the target document.</param>
/// <param name="MoveNegLines">A boolean variable indicating if negative lines should be moved.</param>
/// <param name="FromPurchaseHeader">The purchase header of the source document.</param>
[IntegrationEvent(true, false)]
local procedure OnAfterInsertToPurchLine(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line"; RecalculateLines: Boolean; DocLineNo: Integer; FromPurchDocType: Enum "Purchase Document Type From"; var ToPurchHeader: Record "Purchase Header"; MoveNegLines: Boolean; FromPurchaseHeader: Record "Purchase Header")
begin
end;
/// <summary>
/// Event triggered after the sales header fields have been transferred from the source sales header to the target sales header during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the fields have transferred. This can be useful for implementing additional logic,
/// validations, or workflows based on the copied data.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields were copied.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the field transfer.
/// </param>
/// <param name="FromSalesHeader">
/// The source sales header record from which the fields were copied.
/// </param>
/// <param name="FromDocType">
/// The type of the source sales document.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesHeader(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCleanSpecialOrderDropShipmentInSalesLine(var SalesLine: Record "Sales Line");
begin
end;
/// <summary>
/// Event triggered after copying data from the source purchase header to the target purchase header.
/// Subscribing to this event allows developers to validate or extend the copied data.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record after data has been copied.
/// </param>
/// <param name="OldPurchaseHeader">
/// The target purchase header's state before the copying process.
/// </param>
/// <param name="FromPurchHeader">
/// The source purchase header record being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchaseHeader(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLineFromSalesDocSalesLine(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; IncludeHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLineFromSalesLineBuffer(var ToSalesLine: Record "Sales Line"; FromSalesInvLine: Record "Sales Invoice Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocSalesLine: Record "Sales Line" temporary; ToSalesHeader: Record "Sales Header"; var FromSalesLineBuf: Record "Sales Line"; var FromSalesLine2: Record "Sales Line"; FromSalesLine: Record "Sales Line"; ExactCostRevMandatory: Boolean; FromSalesInvHeader: Record "Sales Invoice Header"; var LinesNotCopied: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLineFromSalesCrMemoLineBuffer(var ToSalesLine: Record "Sales Line"; FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocSalesLine: Record "Sales Line" temporary; ToSalesHeader: Record "Sales Header"; FromSalesLineBuf: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLineFromSalesShptLineBuffer(var ToSalesLine: Record "Sales Line"; FromSalesShipmentLine: Record "Sales Shipment Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocSalesLine: Record "Sales Line" temporary; ToSalesHeader: Record "Sales Header"; FromSalesLineBuf: Record "Sales Line"; ExactCostRevMandatory: Boolean; FromSalesHeader: Record "Sales Header"; var LinesNotCopied: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLineFromReturnRcptLineBuffer(var ToSalesLine: Record "Sales Line"; FromReturnReceiptLine: Record "Return Receipt Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocSalesLine: Record "Sales Line" temporary; ToSalesHeader: Record "Sales Header"; FromSalesLineBuf: Record "Sales Line"; CopyItemTrkg: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLineFromPurchLineBuffer(var ToPurchLine: Record "Purchase Line"; FromPurchInvLine: Record "Purch. Inv. Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocPurchaseLine: Record "Purchase Line" temporary; ToPurchHeader: Record "Purchase Header"; FromPurchLineBuf: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLineFromPurchCrMemoLineBuffer(var ToPurchaseLine: Record "Purchase Line"; FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocPurchLine: Record "Purchase Line" temporary; ToPurchHeader: Record "Purchase Header"; FromPurchLineBuf: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLineFromPurchRcptLineBuffer(var ToPurchaseLine: Record "Purchase Line"; FromPurchRcptLine: Record "Purch. Rcpt. Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocPurchLine: Record "Purchase Line" temporary; ToPurchHeader: Record "Purchase Header"; FromPurchLineBuf: Record "Purchase Line"; CopyItemTrkg: Boolean; NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLineFromReturnShptLineBuffer(var ToPurchaseLine: Record "Purchase Line"; FromReturnShipmentLine: Record "Return Shipment Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocPurchLine: Record "Purchase Line" temporary; ToPurchHeader: Record "Purchase Header"; FromPurchLineBuf: Record "Purchase Line"; CopyItemTrkg: Boolean)
begin
end;
/// <summary>
/// Event triggered after fields have been copied from the old sales header to the updated sales header during the update process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the fields have been copied. This can be useful for implementing additional logic or workflows
/// based on the updated data.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record being updated.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the update.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines should be moved during the copy process.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the header was included in the copy operation.
/// </param>
/// <param name="FromDocType">
/// The type of the source sales document.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFieldsFromOldSalesHeader(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; MoveNegLines: Boolean; IncludeHeader: Boolean; FromDocType: Enum "Sales Document Type From"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFieldsFromOldPurchHeader(var ToPurchHeader: Record "Purchase Header"; OldPurchHeader: Record "Purchase Header"; MoveNegLines: Boolean; IncludeHeader: Boolean)
begin
end;
/// <summary>
/// Event triggered after completing the copying process from a sales document to a purchase document.
/// This allows developers to apply additional logic or modifications after the entire process has been completed.
/// </summary>
/// <param name="FromSalesHeader">
/// The sales header record from which data was copied.
/// </param>
/// <param name="ToPurchaseHeader">
/// The purchase header record representing the document that was created.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromSalesToPurchDoc(FromSalesHeader: Record "Sales Header"; var ToPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateRevPurchLineAmount(var PurchaseLine: Record "Purchase Line"; OrgQtyBase: Decimal; FromPricesInclVAT: Boolean; ToPricesInclVAT: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcReversibleQtyBaseSalesDoc(FromSalesLine: Record "Sales Line"; var ItemLedgEntry: record "Item Ledger Entry"; var ReversibleQtyBase: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckFromSalesHeader(SalesHeaderFrom: Record "Sales Header"; SalesHeaderTo: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckUpdateOldDocumentNoFromSalesShptLine(FromSalesShptLine: Record "Sales Shipment Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckUpdateOldDocumentNoFromPurchRcptLine(FromPurchRcptLine: Record "Purch. Rcpt. Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckUpdateOldDocumentNoFromReturnRcptLine(FromReturnRcptLine: Record "Return Receipt Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckUpdateOldDocumentNoFromReturnShptLine(FromReturnShptLine: Record "Return Shipment Line"; var OldDocNo: Code[20]; var InsertDocNoLine: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeClearPurchaseBlanketOrderFields(var ToPurchaseLine: Record "Purchase Line"; ToPurchHeader: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before clearing the "Last No." fields in the purchase header. Allows overriding or customizing the clearing process.
/// </summary>
/// <param name="PurchaseHeader">The purchase header record whose "Last No." fields are being cleared.</param>
/// <param name="IsHandled">A boolean variable indicating if the event is handled. If set to true, the default logic will be skipped.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeClearPurchLastNoSFields(var PurchaseHeader: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before clearing the "Invoice" and "Ship" fields in the target sales header during the sales document update process.
/// Subscribing to this event allows developers to override or extend the default behavior
/// when clearing these fields. This can be useful for applying custom logic or skipping the default clearing operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record where the "Invoice" and "Ship" fields are to be cleared.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default clearing behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeClearInvoiceAndShip(var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeClearSalesBlanketOrderFields(var ToSalesLine: Record "Sales Line"; ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckCreditLimit(var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: record "Sales Header"; var SkipTestCreditLimit: Boolean; var IsHandled: Boolean; IncludeHeader: Boolean; HideDialog: Boolean; FromDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeIsCopyItemTrkg(var ItemLedgEntry: Record "Item Ledger Entry"; var CopyItemTrkg: Boolean; var FillExactCostRevLink: Boolean; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeInitAndCheckSalesDocuments(FromDocType: enum "Sales Document Type From"; FromDocNo: Code[20];
FromDocOccurrenceNo: Integer;
FromDocVersionNo: Integer; var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; MoveNegLines: boolean; IncludeHeader: Boolean; var RecalculateLines: Boolean; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeIsPurchFillExactCostRevLink(ToPurchHeader: Record "Purchase Header"; FromDocType: Option "Purchase Receipt","Purchase Invoice","Purchase Return Shipment","Purchase Credit Memo"; CurrencyCode: Code[10]; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeIsSalesFillExactCostRevLink(ToSalesHeader: Record "Sales Header"; FromDocType: Option "Sales Shipment","Sales Invoice","Sales Return Receipt","Sales Credit Memo"; CurrencyCode: Code[10]; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeRecalculatePurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean)
begin
end;
/// <summary>
/// Event triggered before recalculating the sales line amounts.
/// This allows developers to customize or skip the recalculation logic for sales line amounts.
/// </summary>
/// <param name="FromSalesLine">The source sales line from which data is being copied.</param>
/// <param name="ToSalesLine">The target sales line to be recalculated.</param>
/// <param name="Currency">The currency record used for recalculating amounts.</param>
/// <param name="IsHandled">A boolean variable that allows developers to handle the recalculation logic themselves and skip the default processing if set to true.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeRecalculateSalesLineAmounts(FromSalesLine: Record "Sales Line"; var ToSalesLine: Record "Sales Line"; Currency: Record Currency; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before recalculating and applying sales line changes.
/// This allows developers to customize or skip the recalculation logic.
/// </summary>
/// <param name="ToSalesHeader">The target sales header associated with the sales line.</param>
/// <param name="ToSalesLine">The target sales line to be recalculated and applied.</param>
/// <param name="FromSalesLine">The source sales line from which data is being copied.</param>
/// <param name="Currency">The currency record used for recalculating amounts.</param>
/// <param name="ExactCostRevMandatory">A boolean variable indicating whether exact cost reversal is mandatory for the operation.</param>
/// <param name="RecalculateAmount">A boolean variable indicating whether amounts should be recalculated during the operation.</param>
/// <param name="CreateToHeader">A boolean variable indicating whether a new header is being created during the copy operation.</param>
/// <param name="MoveNegLines">A boolean variable indicating whether negative lines should be moved instead of copied.</param>
/// <param name="IsHandled">A boolean variable that allows developers to handle the recalculation logic themselves and skip the default processing if set to true.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeRecalculateAndApplySalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; Currency: Record Currency; var ExactCostRevMandatory: Boolean; var RecalculateAmount: Boolean; var CreateToHeader: Boolean; MoveNegLines: Boolean; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before recalculating and applying purchase line data. Allows overriding or customizing the recalculation process.
/// </summary>
/// <param name="ToPurchHeader">The purchase header of the target document.</param>
/// <param name="ToPurchLine">The purchase line of the target document.</param>
/// <param name="FromPurchLine">The purchase line from the source document being processed.</param>
/// <param name="Currency">The currency record used for rounding calculations.</param>
/// <param name="RecalculateAmount">A boolean variable indicating if the amounts should be recalculated.</param>
/// <param name="ExactCostRevMandatory">A boolean variable indicating if exact cost reversal is mandatory.</param>
/// <param name="CreateToHeader">A boolean variable indicating if a new target header should be created.</param>
/// <param name="MoveNegLines">A boolean variable indicating if negative lines should be moved.</param>
/// <param name="IsHandled">A boolean variable indicating if the event is handled. If set to true, the default logic will be skipped.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeRecalculateAndApplyPurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line"; Currency: Record Currency; var ExactCostRevMandatory: Boolean; var RecalculateAmount: Boolean; var CreateToHeader: Boolean; MoveNegLines: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateSalesLineQtyBaseFromReversibleQtyBase(var FromSalesLine: Record "Sales Line"; var SalesLineBuffer: record "Sales Line"; ReversibleQtyBase: decimal; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before updating the sales header during a copy operation from another sales header.
/// This allows developers to override or extend the default logic when copying sales header data.
/// </summary>
/// <param name="SalesHeader">The sales header being updated.</param>
/// <param name="OriginalSalesHeader">The original sales header from which data is being copied.</param>
/// <param name="FromDocType">The document type of the original sales header.</param>
/// <param name="IsHandled">A boolean variable that, when set to true, skips the default update logic.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateSalesHeaderWhenCopyFromSalesHeader(var SalesHeader: Record "Sales Header"; OriginalSalesHeader: Record "Sales Header"; FromDocType: Enum "Sales Document Type From"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesHeaderAvailOnAfterCheckItemAvailability(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesHeaderAvailOnAfterSetFilters(var FromSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesHeaderArchiveAvailOnAfterCheckItemAvailability(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeaderArchive: Record "Sales Header Archive"; FromSalesLineArchive: Record "Sales Line Archive"; IncludeHeader: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesHeaderArchiveAvailOnAfterSetFilters(var FromSalesLineArchive: Record "Sales Line Archive"; FromSalesHeaderArchive: Record "Sales Header Archive"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesRetRcptAvailOnAfterCheckItemAvailability(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromReturnReceiptHeader: Record "Return Receipt Header"; IncludeHeader: Boolean; FromReturnRcptLine: Record "Return Receipt Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesRetRcptAvailOnAfterSetFilters(var FromReturnReceiptLine: Record "Return Receipt Line"; FromReturnReceiptHeader: Record "Return Receipt Header"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesCrMemoAvailOnAfterCheckItemAvailability(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; IncludeHeader: Boolean; FromSalesCrMemoLine: Record "Sales Cr.Memo Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesCrMemoAvailOnAfterSetFilters(var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesCrMemoAvailOnBeforeCheckItemAvailability(var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesInvoiceAvailOnAfterCheckItemAvailability(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesInvoiceHeader: Record "Sales Invoice Header"; IncludeHeader: Boolean; FromSalesInvLine: Record "Sales Invoice Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesInvoiceAvailOnAfterSetFilters(var FromSalesInvoiceLine: Record "Sales Invoice Line"; FromSalesInvoiceHeader: Record "Sales Invoice Header"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesShptAvailOnAfterCheckItemAvailability(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesShipmentHeader: Record "Sales Shipment Header"; IncludeHeader: Boolean; FromSalesShptLine: Record "Sales Shipment Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckCopyFromSalesShptAvailOnAfterSetFilters(var FromSalesShipmentLine: Record "Sales Shipment Line"; FromSalesShipmentHeader: Record "Sales Shipment Header"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckItemAvailabilityOnBeforeRunSalesLineCheck(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnAfterToSalesLineInsert(var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive"; RecalculateLines: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnBeforeToSalesLineInsert(var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive"; RecalculateLines: Boolean; var NextLineNo: Integer; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnAfterToPurchLineInsert(var ToPurchLine: Record "Purchase Line"; FromPurchLineArchive: Record "Purchase Line Archive"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnBeforeToPurchLineInsert(var ToPurchLine: Record "Purchase Line"; FromPurchLineArchive: Record "Purchase Line Archive"; RecalculateLines: Boolean; var NextLineNo: Integer; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyFromPurchDocAssgntToLineOnAfterSetFilters(var ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyFromPurchDocAssgntToLineOnBeforeInsert(var ItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)"; RecalculateLines: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesDocAssgntToLineOnAfterSetFilters(var ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesDocAssgntToLineOnBeforeInsert(var ItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)"; RecalculateLines: Boolean; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered after calculating whether item tracking entries should be copied from a sales line to a purchase line.
/// This allows developers to modify the logic determining whether item tracking entries should be included.
/// </summary>
/// <param name="ToPurchLine">
/// The purchase line record representing the target line being created.
/// </param>
/// <param name="ShouldCopyItemTracking">
/// A variable indicating whether item tracking entries should be copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesToPurchDocOnAfterCalcShouldCopyItemTracking(ToPurchLine: Record "Purchase Line"; var ShouldCopyItemTracking: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the sales lines during the copying process from a sales document to a purchase document.
/// This allows developers to add or modify the filters applied to the sales lines being processed.
/// </summary>
/// <param name="FromSalesLine">
/// The sales line record being filtered.
/// </param>
/// <param name="FromSalesHeader">
/// The sales header record from which data is being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesToPurchDocOnAfterSetFilters(var FromSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before modifying a purchase header during the copying process from a sales document to a purchase document.
/// This allows developers to apply additional modifications to the purchase header prior to saving.
/// </summary>
/// <param name="ToPurchHeader">
/// The purchase header record representing the document being modified.
/// </param>
/// <param name="FromSalesHeader">
/// The sales header record from which data is being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesToPurchDocOnBeforeToPurchHeaderModify(var ToPurchHeader: Record "Purchase Header"; FromSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before inserting a purchase header during the copying process from a sales document to a purchase document.
/// This allows developers to modify or override the default behavior during the purchase header creation.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The purchase header record representing the document being created.
/// </param>
/// <param name="FromSalesHeader">
/// The sales header record from which data is being copied.
/// </param>
/// <param name="VendorNo">
/// The vendor number associated with the purchase document.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesToPurchDocOnBeforePurchaseHeaderInsert(var ToPurchaseHeader: Record "Purchase Header"; FromSalesHeader: Record "Sales Header"; VendorNo: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchLineOnBeforeCheckVATBusGroup(PurchaseLine: Record "Purchase Line"; var CheckVATBusGroup: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckItemAvailability(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var HideDialog: Boolean; var IsHandled: Boolean; RecalculateLines: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckCopyFromSalesInvoiceAvail(var FromSalesInvHeader: Record "Sales Invoice Header"; var ToSalesHeader: Record "Sales Header"; var FromSalesInvLine: Record "Sales Invoice Line"; var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnAfterValidateQuantityMoveNegLines(var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnBeforeCleanSpecialOrderDropShipmentInSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; CreateToHeader: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnAfterValidateQuantityMoveNegLines(var ToPurchLine: Record "Purchase Line"; FromPurchLineArchive: Record "Purchase Line Archive")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnBeforeCleanSpecialOrderDropShipmentInPurchLine(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; CreateToHeader: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnAfterTransferFields(var FromPurchaseLine: Record "Purchase Line"; var FromPurchaseHeader: Record "Purchase Header"; var ToPurchaseHeader: Record "Purchase Header"; var FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnAfterFromPurchCrMemoLineLoop(var TempDocPurchaseLine: Record "Purchase Line" temporary; var ToPurchHeader: Record "Purchase Header"; var FromPurchLineBuf: Record "Purchase Line"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; SplitLine: Boolean)
begin
end;
/// <summary>
/// Event triggered before deleting sales lines with negative quantities.
/// This allows developers to modify or override the behavior of the deletion process.
/// </summary>
/// <param name="FromSalesHeader">
/// The sales header record associated with the sales lines to be deleted.
/// </param>
/// <param name="OnlyTest">
/// A boolean flag indicating whether the operation is a test (no actual deletion occurs) or a real deletion.
/// </param>
/// <param name="IsHandled">
/// A boolean flag that allows developers to handle the logic themselves and skip the default deletion process if set to true.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeDeleteSalesLinesWithNegQty(FromSalesHeader: Record "Sales Header"; OnlyTest: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnAfterTransferFields(var FromPurchaseLine: Record "Purchase Line"; var FromPurchaseHeader: Record "Purchase Header"; var ToPurchaseHeader: Record "Purchase Header"; FromPurchInvHeader: Record "Purch. Inv. Header"; var FromPurchInvLine: Record "Purch. Inv. Line"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchRcptLinesToDocOnAfterTransferFields(var FromPurchaseLine: Record "Purchase Line"; var FromPurchaseHeader: Record "Purchase Header"; var ToPurchaseHeader: Record "Purchase Header"; var PurchRcptHeader: Record "Purch. Rcpt. Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchReturnShptLinesToDocOnAfterTransferFields(var FromPurchaseLine: Record "Purchase Line"; var FromPurchaseHeader: Record "Purchase Header"; var ToPurchaseHeader: Record "Purchase Header"; var FromReturnShipmentHeader: Record "Return Shipment Header"; var FromReturnShipmentLine: Record "Return Shipment Line"; RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after the purchase document lines have been copied during the document copy process.
/// Subscribing to this event allows developers to implement additional logic or workflows
/// once the lines have been copied. This can be useful for extending functionality,
/// performing validations, or integrating with other processes.
/// </summary>
/// <param name="FromDocType">
/// The type of the source purchase document.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source purchase document.
/// </param>
/// <param name="FromPurchaseHeader">
/// The source purchase header record from which the lines were copied.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the source header data was included.
/// </param>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines were copied.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines should be moved during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnAfterCopyPurchDocLines(FromDocType: Option; FromDocNo: Code[20]; FromPurchaseHeader: Record "Purchase Header"; IncludeHeader: Boolean; var ToPurchHeader: Record "Purchase Header"; MoveNegLines: Boolean; var ReleaseDocument: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeCopyPurchDocRcptLine(var FromPurchRcptHeader: Record "Purch. Rcpt. Header"; var ToPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeCopyPurchDocInvLine(var FromPurchInvHeader: Record "Purch. Inv. Header"; var ToPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeCopyPurchDocReturnShptLine(var FromReturnShipmentHeader: Record "Return Shipment Header"; var ToPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeCopyPurchDocCrMemoLine(var FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr."; var ToPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeToPurchHeaderInsert(var ToPurchaseHeader: Record "Purchase Header"; FromPurchaseHeader: Record "Purchase Header"; MovNegLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeUpdatePurchInvoiceDiscountValue(var ToPurchaseHeader: Record "Purchase Header"; FromDocType: Option; FromDocNo: Code[20]; FromDocOccurrenceNo: Integer; FromDocVersionNo: Integer; RecalculateLines: Boolean; FromPurchHeader: Record "Purchase Header"; LinesNotCopied: Integer; NextLineNo: Integer; MissingExCostRevLink: Boolean)
begin
end;
/// <summary>
/// Event triggered before updating vendor ledger entries.
/// Subscribing to this event allows developers to perform validations or data transformations.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record being processed.
/// </param>
/// <param name="FromDocType">
/// The document type of the source purchase document.
/// </param>
/// <param name="FromDocNo">
/// The document number of the source purchase document.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocUpdateHeaderOnBeforeUpdateVendLedgerEntry(var ToPurchaseHeader: Record "Purchase Header"; FromDocType: Option; FromDocNo: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocWithoutHeader(var ToPurchaseHeader: Record "Purchase Header"; FromDocType: Option; FromDocNo: Code[20]; FromOccurenceNo: Integer; FromVersionNo: Integer; FromPurchInvHeader: Record "Purch. Inv. Header"; FromPurchCrMemoHdr: Record "Purch. Cr. Memo Hdr.")
begin
end;
/// <summary>
/// Event triggered before copying lines of the sales document during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// before the lines are copied. This can be useful for filtering, altering the data,
/// or implementing additional validations during the copy process.
/// </summary>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the data is being copied.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default line copy behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
/// <param name="FromDocType">
/// The type of the sales document being copied.
/// </param>
[IntegrationEvent(true, false)]
local procedure OnCopySalesDocOnBeforeCopyLines(FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean; FromDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnAfterCopySalesDocLines(FromDocType: Option; FromDocNo: Code[20]; FromDocOccurrenceNo: Integer; FromDocVersionNo: Integer; FromSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; var ToSalesHeader: Record "Sales Header"; var HideDialog: Boolean; var ReleaseDocument: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeCopySalesDocShptLine(var FromSalesShipmentHeader: Record "Sales Shipment Header"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeCopySalesDocInvLine(var FromSalesInvoiceHeader: Record "Sales Invoice Header"; var ToSalesHeader: Record "Sales Header"; var ShouldExit: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeCopySalesDocCrMemoLine(var FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeCopySalesDocReturnRcptLine(var FromReturnReceiptHeader: Record "Return Receipt Header"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeToSalesHeaderInsert(var ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header"; MoveNegLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeToSalesLineDeleteAll(ToSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered before transferring fields from the source sales shipment header to the target sales header during the copy process.
/// Subscribing to this event allows developers to modify or extend the behavior
/// before the fields have been transferred. This can be useful for implementing custom logic,
/// validations, or filtering data during the copy operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields are being copied.
/// </param>
/// <param name="SalesShipmentHeader">
/// The source sales shipment header record being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeTransferPostedShipmentFields(var ToSalesHeader: Record "Sales Header"; SalesShipmentHeader: Record "Sales Shipment Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeTransferFieldsFromCrMemoToInv(var ToSalesHeader: Record "Sales Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered after completing the transfer of fields from the source sales invoice header to the target sales header during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the fields have been transferred. This can be useful for implementing additional logic,
/// validations, or workflows based on the copied invoice data.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields were copied.
/// </param>
/// <param name="SalesInvoiceHeader">
/// The source sales invoice header record that was copied.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the field transfer.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnAfterTransferPostedInvoiceFields(var ToSalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; OldSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered after transferring fields from the source sales header archive to the target sales header during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the fields have been transferred. This can be useful for implementing additional logic,
/// validations, or workflows based on the copied archived sales header data.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields were copied.
/// </param>
/// <param name="FromSalesHeaderArchive">
/// The source sales header archive record being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnAfterTransferArchSalesHeaderFields(var ToSalesHeader: Record "Sales Header"; FromSalesHeaderArchive: Record "Sales Header Archive")
begin
end;
/// <summary>
/// Event triggered before transferring fields from the source sales invoice header to the target sales header during the copy process.
/// Subscribing to this event allows developers to modify or extend the behavior
/// before the fields have been transferred. This can be useful for applying custom logic,
/// validations, or altering the data during the transfer operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields are being copied.
/// </param>
/// <param name="SalesInvoiceHeader">
/// The source sales invoice header record being copied.
/// </param>
/// <param name="CopyJobData">
/// A boolean value indicating whether job-related data should be copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeTransferPostedInvoiceFields(var ToSalesHeader: Record "Sales Header"; SalesInvoiceHeader: Record "Sales Invoice Header"; var CopyJobData: Boolean)
begin
end;
/// <summary>
/// Event triggered before transferring fields from the source return receipt header to the target sales header during the copy process.
/// Subscribing to this event allows developers to modify or extend the behavior
/// before the fields have been transferred. This can be useful for implementing custom logic,
/// validations, or altering the data during the transfer operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the fields are being copied.
/// </param>
/// <param name="ReturnReceiptHeader">
/// The source return receipt header record being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeTransferPostedReturnReceiptFields(var ToSalesHeader: Record "Sales Header"; ReturnReceiptHeader: Record "Return Receipt Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeUpdateSalesInvoiceDiscountValue(var ToSalesHeader: Record "Sales Header"; FromDocType: Option; FromDocNo: Code[20]; FromDocOccurrenceNo: Integer; FromDocVersionNo: Integer; RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after applying filters to the sales invoice lines during the sales document copy process.
/// Subscribing to this event allows developers to modify or extend the filtering logic
/// before the sales invoice lines have been processed further. This can be useful for ensuring specific conditions
/// are met or additional filters are applied during the copy operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales invoice lines are being copied.
/// </param>
/// <param name="FromSalesInvoiceHeader">
/// The source sales invoice header record being copied.
/// </param>
/// <param name="FromSalesInvoiceLine">
/// The source sales invoice line record with applied filters.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocInvLineOnAfterSetFilters(var ToSalesHeader: Record "Sales Header"; var FromSalesInvoiceHeader: Record "Sales Invoice Header"; var FromSalesInvoiceLine: Record "Sales Invoice Line"; var RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after applying filters to the sales credit memo lines during the sales document copy process.
/// Subscribing to this event allows developers to modify or extend the filtering logic
/// before the sales credit memo lines have been processed further. This can be useful for ensuring specific conditions
/// are met or additional filters are applied during the copy operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales credit memo lines are being copied.
/// </param>
/// <param name="FromSalesCrMemoHeader">
/// The source sales credit memo header record being copied.
/// </param>
/// <param name="FromSalesCrMemoLine">
/// The source sales credit memo line record with applied filters.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocCrMemoLineOnAfterSetFilters(var ToSalesHeader: Record "Sales Header"; var FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line"; var RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after applying filters to the sales shipment lines during the sales document copy process.
/// Subscribing to this event allows developers to modify or extend the filtering logic
/// before the sales shipment lines have been processed further. This can be useful for ensuring specific conditions
/// are met or additional filters are applied during the copy operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales shipment lines are being copied.
/// </param>
/// <param name="FromSalesShipmentHeader">
/// The source sales shipment header record being copied.
/// </param>
/// <param name="FromSalesShipmentLine">
/// The source sales shipment line record with applied filters.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocShptLineOnAfterSetFilters(var ToSalesHeader: Record "Sales Header"; var FromSalesShipmentHeader: Record "Sales Shipment Header"; var FromSalesShipmentLine: Record "Sales Shipment Line"; var RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the source purchase receipt lines during the purchase document copy process.
/// Subscribing to this event allows developers to extend or modify the filtering logic
/// applied to the source receipt lines. This can be useful for custom filtering or additional checks.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="FromPurchRcptHeader">
/// The source purchase receipt header record being processed.
/// </param>
/// <param name="FromPurchRcptLine">
/// The source purchase receipt line record being filtered.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocRcptLineOnAfterSetFilters(var ToPurchHeader: Record "Purchase Header"; var FromPurchRcptHeader: Record "Purch. Rcpt. Header"; var FromPurchRcptLine: Record "Purch. Rcpt. Line"; var RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the source purchase invoice lines during the purchase document copy process.
/// Subscribing to this event allows developers to extend or modify the filtering logic
/// applied to the source invoice lines. This can be useful for custom filtering or additional checks.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="FromPurchInvLine">
/// The source purchase invoice line record being filtered.
/// </param>
/// <param name="LinesNotCopied">
/// An integer representing the number of lines not copied during the process.
/// </param>
/// <param name="MissingExCostRevLink">
/// A boolean value indicating whether any external cost or revenue links are missing.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocInvLineOnAfterSetFilters(var ToPurchHeader: Record "Purchase Header"; var FromPurchInvLine: Record "Purch. Inv. Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean; RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the source purchase credit memo lines during the purchase document copy process.
/// Subscribing to this event allows developers to extend or modify the filtering logic
/// applied to the source credit memo lines. This can be useful for custom filtering or additional checks.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="FromPurchCrMemoLine">
/// The source purchase credit memo line record being filtered.
/// </param>
/// <param name="LinesNotCopied">
/// An integer representing the number of lines not copied during the process.
/// </param>
/// <param name="MissingExCostRevLink">
/// A boolean value indicating whether any external cost or revenue links are missing.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocCrMemoLineOnAfterSetFilters(var ToPurchHeader: Record "Purchase Header"; var FromPurchCrMemoLine: Record "Purch. Cr. Memo Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean; RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the source purchase return shipment lines during the purchase document copy process.
/// Subscribing to this event allows developers to extend or modify the filtering logic
/// applied to the source return shipment lines. This can be useful for custom filtering or additional checks.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="FromReturnShptLine">
/// The source purchase return shipment line record being filtered.
/// </param>
/// <param name="LinesNotCopied">
/// An integer representing the number of lines not copied during the process.
/// </param>
/// <param name="MissingExCostRevLink">
/// A boolean value indicating whether any external cost or revenue links are missing.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocReturnShptLineOnAfterSetFilters(var ToPurchHeader: Record "Purchase Header"; var FromReturnShptLine: Record "Return Shipment Line"; var LinesNotCopied: Integer; var MissingExCostRevLink: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the source purchase line archive during the purchase document copy process.
/// Subscribing to this event allows developers to extend or modify the filtering logic
/// applied to the source archived purchase lines. This can be useful for custom filtering or additional checks.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="ToPurchLine">
/// The target purchase line record that will be created.
/// </param>
/// <param name="FromPurchHeaderArchive">
/// The source purchase header archive record being processed.
/// </param>
/// <param name="FromPurchLineArchive">
/// The source purchase line archive record being filtered.
/// </param>
/// <param name="NextLineNo">
/// The next available line number in the target purchase document.
/// </param>
/// <param name="LinesNotCopied">
/// An integer representing the number of lines not copied during the process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocPurchLineArchiveOnAfterSetFilters(var ToPurchHeader: Record "Purchase Header"; ToPurchLine: Record "Purchase Line"; FromPurchHeaderArchive: Record "Purchase Header Archive"; var FromPurchLineArchive: Record "Purchase Line Archive"; var NextLineNo: Integer; var LinesNotCopied: Integer)
begin
end;
/// <summary>
/// Event triggered after applying filters to the return receipt lines during the sales document copy process.
/// Subscribing to this event allows developers to modify or extend the filtering logic
/// before the return receipt lines have been processed further. This can be useful for ensuring specific conditions
/// are met or additional filters are applied during the copy operation.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the return receipt lines are being copied.
/// </param>
/// <param name="FromReturnReceiptHeader">
/// The source return receipt header record being copied.
/// </param>
/// <param name="FromReturnReceiptLine">
/// The source return receipt line record with applied filters.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocReturnRcptLineOnAfterSetFilters(var ToSalesHeader: Record "Sales Header"; var FromReturnReceiptHeader: Record "Return Receipt Header"; var FromReturnReceiptLine: Record "Return Receipt Line")
begin
end;
/// <summary>
/// Event triggered after applying filters to the source sales lines during the sales document copy process.
/// Subscribing to this event allows developers to modify or extend the filtering logic
/// before the sales lines have been processed further. This can be useful for ensuring specific conditions
/// are met or additional filters are applied during the copy operation.
/// </summary>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="FromSalesLine">
/// The source sales line record with applied filters.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales lines are being copied.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocSalesLineOnAfterSetFilters(FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var ToSalesHeader: Record "Sales Header"; var RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after determining whether a specific sales line iteration should run during the copy process.
/// Subscribing to this event allows developers to extend or customize the iteration logic
/// based on the current state of the sales line and headers. This can be useful for implementing
/// additional conditions or skipping specific sales lines.
/// </summary>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales lines are being copied.
/// </param>
/// <param name="FromSalesLine">
/// The current sales line record being processed.
/// </param>
/// <param name="ShouldRunIteration">
/// A boolean variable indicating whether the iteration should proceed for the current sales line.
/// This can be modified by the subscriber.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocSalesLineOnAfterCalcShouldRunIteration(FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; var ShouldRunIteration: Boolean)
begin
end;
/// <summary>
/// Event triggered after setting filters on the source purchase lines during the purchase document copy process.
/// Subscribing to this event allows developers to extend or modify the filtering logic
/// applied to the source purchase lines. This can be useful for custom filtering or additional checks.
/// </summary>
/// <param name="FromPurchHeader">
/// The source purchase header record being processed.
/// </param>
/// <param name="FromPurchLine">
/// The source purchase line record being filtered.
/// </param>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocPurchLineOnAfterSetFilters(FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var ToPurchHeader: Record "Purchase Header"; var RecalculateLines: Boolean)
begin
end;
/// <summary>
/// Event triggered after a purchase line has been successfully copied from the source to the target during the document copy process.
/// Subscribing to this event allows developers to implement additional logic,
/// validations, or workflows after each line has been copied. This can be useful for custom handling or integrations.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the line was copied.
/// </param>
/// <param name="ToPurchLine">
/// The target purchase line record that was created.
/// </param>
/// <param name="FromPurchHeader">
/// The source purchase header record from which the line was copied.
/// </param>
/// <param name="FromPurchLine">
/// The source purchase line record that was copied.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the source header data was included.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines were recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocPurchLineOnAfterCopyPurchLine(ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; IncludeHeader: Boolean; RecalculateLines: Boolean);
begin
end;
/// <summary>
/// Event triggered after applying filters to the archived sales lines during the sales document copy process.
/// Subscribing to this event allows developers to modify or extend the filtering logic
/// before the archived sales lines have been processed further. This can be useful for ensuring specific conditions
/// are met or additional filters are applied during the copy operation.
/// </summary>
/// <param name="FromSalesHeaderArchive">
/// The source sales header archive record being copied.
/// </param>
/// <param name="FromSalesLineArchive">
/// The source sales line archive record with applied filters.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the archived sales lines are being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocSalesLineArchiveOnAfterSetFilters(FromSalesHeaderArchive: Record "Sales Header Archive"; var FromSalesLineArchive: Record "Sales Line Archive"; var ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocUpdateHeaderOnBeforeUpdateCustLedgerEntry(var ToSalesHeader: Record "Sales Header"; FromDocType: Option; FromDocNo: Code[20]; OldSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before validating the location code in the target sales header during the update process.
/// Subscribing to this event allows developers to override or extend the default behavior
/// when validating location codes. This can be useful for skipping validation or applying custom logic.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record being updated.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default validation behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocUpdateHeaderOnBeforeValidateLocationCode(var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered after the sales document header status is set to "Open" during the update process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the status has been updated. This can be useful for implementing additional logic
/// or validations based on the updated status.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record being updated.
/// </param>
/// <param name="OldSalesHeader">
/// The existing state of the target sales header prior to the update.
/// </param>
/// <param name="ShouldValidateDimensionsAndLocation">
/// A boolean value indicating whether dimensions and location codes should be validated.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocUpdateHeaderOnAfterSetStatusOpen(var ToSalesHeader: Record "Sales Header"; OldSalesHeader: Record "Sales Header"; var ShouldValidateDimensionsAndLocation: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocWithoutHeader(var ToSalesHeader: Record "Sales Header"; FromDocType: Option; FromDocNo: Code[20]; FromOccurenceNo: Integer; FromVersionNo: Integer; FromSalesInvoiceHeader: Record "Sales Invoice Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header")
begin
end;
/// <summary>
/// Event triggered after the sales document header has been updated during the copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the document header has been updated. This can be useful for implementing additional logic
/// or handling specific workflows after the header update.
/// </summary>
/// <param name="ToSalesHeader">
/// The sales header record to which the data was copied.
/// </param>
/// <param name="FromSalesInvHeader">
/// The source sales invoice header record being copied.
/// </param>
/// <param name="FromDocType">
/// The type of the sales document being copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnAfterCopySalesDocUpdateHeader(var ToSalesHeader: Record "Sales Header"; var FromSalesInvHeader: Record "Sales Invoice Header"; FromDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesLineOnAfterTransferFieldsToSalesLine(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesReturnRcptLinesToDocOnAfterFromSalesHeaderTransferFields(FromReturnRcptHeader: Record "Return Receipt Header"; var FromSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesReturnRcptLinesToDocOnBeforeFromSalesHeaderTransferFields(FromReturnRcptHeader: Record "Return Receipt Header"; var FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header"; var FromReturnRcptLine: Record "Return Receipt Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesReturnRcptLinesToDocOnBeforeCopySalesDocLine(ToSalesHeader: Record "Sales Header"; var FromSalesLineBuf: Record "Sales Line"; var CoptItemTrkg: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesReturnRcptLinesToDocOnAfterCalcNextLineNo(var ToSalesHeader: Record "Sales Header"; FromReturnRcptLine: Record "Return Receipt Line"; FromSalesHeader: Record "Sales Header"; var NextLineNo: Integer; var InsertDocNoLine: Boolean; FromLineCounter: Integer; var FromSalesLineBuf: Record "Sales Line" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesReturnRcptLinesToDocOnAfterCopySalesDocLine(FromReturnRcptLine: Record "Return Receipt Line"; ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchRcptLinesToDocOnBeforeCopyPurchLine(ToPurchaseHeader: Record "Purchase Header"; var FromPurchaseLine: Record "Purchase Line"; var CopyItemTrkg: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnBeforeCopyPurchLine(ToPurchaseHeader: Record "Purchase Header"; var FromPurchaseLine: Record "Purchase Line"; FromPurchaseLineBuf: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnBeforeCopyPurchLine(ToPurchaseHeader: Record "Purchase Header"; var FromPurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchReturnShptLinesToDocOnBeforeCopyPurchLine(ToPurchaseHeader: Record "Purchase Header"; var FromPurchaseLine: Record "Purchase Line"; var CopyItemTrkg: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchReturnShptLinesToDocOnAfterCalcNextLineNo(var ToPurchaseHeader: Record "Purchase Header"; FromReturnShptLine: Record "Return Shipment Line"; FromPurchHeader: Record "Purchase Header"; var NextLineNo: Integer; var InsertDocNoLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnAfterFromSalesHeaderTransferFields(FromSalesShptHeader: Record "Sales Shipment Header"; var FromSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnBeforeFromSalesHeaderTransferFields(FromSalesShipmentHeader: Record "Sales Shipment Header"; var FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header"; var FromSalesShptLine: Record "Sales Shipment Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnBeforeCopySalesLine(var ToSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; FromSalesShptLine: Record "Sales Shipment Line"; var CopyItemTrkg: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnAfterCalcNextLineNo(var ToSalesHeader: Record "Sales Header"; FromSalesShptLine: Record "Sales Shipment Line"; FromSalesHeader: Record "Sales Header"; var NextLineNo: Integer; var InsertDocNoLine: Boolean; FromLineCounter: Integer; FromSalesLineBuf: Record "Sales Line" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnBeforeSplitPstdSalesLinesPerILE(var ItemLedgEntry: record "Item Ledger Entry"; FromSalesShptLine: record "Sales Shipment Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnAfterCopySalesShptLineToSalesLine(FromSalesShptLine: Record "Sales Shipment Line"; ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterCalcShouldInsertOldSalesDocNoLine(var TempSalesLineBuf: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; var ShouldInsertOldSalesDocNoLine: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnEndOfCopyLineIteration(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesInvLine: Record "Sales Invoice Line"; var TempSalesLineBuf: Record "Sales Line" temporary; var LinesNotCopied: Integer; NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeCopySalesLine(var ToSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var TempSalesLineBuf: Record "Sales Line" temporary; var ToSalesLine: Record "Sales Line"; FromSalesInvLine: Record "Sales Invoice Line"; IncludeHeader: Boolean; RecalculateLines: Boolean; var TempDocSalesLine: Record "Sales Line" temporary; var FromSalesLine1: Record "Sales Line"; ExactCostRevMandatory: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeFromSalesHeaderTransferFields(var FromSalesHeader: Record "Sales Header"; FromSalesInvoiceHeader: Record "Sales Invoice Header"; ToSalesHeader: Record "Sales Header"; var FromSalesInvoiceLine: Record "Sales Invoice Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterCheckFirstLineShipped(ToSalesHeader: Record "Sales Header"; OldDocType: Integer; ShptDocNo: Code[20]; var OldShptDocNo: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterGetFromSalesInvHeader(var ToSalesHeader: Record "Sales Header"; FromSalesInvHeader: Record "Sales Invoice Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterInsertOldSalesDocNoLine(ToSalesHeader: Record "Sales Header"; var SkipCopyFromDescription: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeInsertOldSalesDocNoLine(ToSalesHeader: Record "Sales Header"; var SkipCopyFromDescription: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterFromSalesHeaderTransferFields(var FromSalesHeader: Record "Sales Header"; FromSalesInvHeader: Record "Sales Invoice Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnAfterFromSalesHeaderTransferFields(FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var FromSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnBeforeFromSalesHeaderTransferFields(FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnBeforeCopySalesLine(ToSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; FromSalesLineBuf: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnAfterCalcShouldCopyItemTracking(ToSalesHeader: Record "Sales Header"; var ShouldCopyItemTracking: Boolean; var ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesLineOnBeforeCheckVATBusGroup(SalesLine: Record "Sales Line"; var CheckVATBusGroup: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesLinesToBufferTransferFields(SalesHeader: Record "Sales Header"; SalesLine: Record "Sales Line"; var TempSalesLineBuf: Record "Sales Line" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesLineOnAfterSetDimensions(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchLineOnAfterSetDimensions(var ToPurchaseLine: Record "Purchase Line"; FromPurchaseLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered when the provided purchase document type does not match any predefined cases during conversion.
/// Subscribing to this event allows developers to handle custom or unsupported purchase document types
/// during the conversion process. This can be useful for extending functionality to accommodate specific business needs.
/// </summary>
/// <param name="FromDocType">
/// The original purchase document type being converted.
/// </param>
/// <param name="ToDocType">
/// The resulting purchase document type after the conversion, which can be modified by the subscriber.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnGetPurchaseDocumentTypeCaseElse(FromDocType: Enum "Purchase Document Type From"; var ToDocType: Enum "Purchase Document Type")
begin
end;
/// <summary>
/// Event triggered when the provided sales document type does not match any predefined cases during conversion.
/// Subscribing to this event allows developers to handle custom or unsupported sales document types
/// during the conversion process. This can be useful for extending functionality to accommodate specific business needs.
/// </summary>
/// <param name="FromDocType">
/// The original sales document type being converted.
/// </param>
/// <param name="ToDocType">
/// The resulting sales document type after the conversion, which can be modified by the subscriber.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnGetSalesDocumentTypeCaseElse(FromDocType: Enum "Sales Document Type From"; var ToDocType: Enum "Sales Document Type")
begin
end;
/// <summary>
/// Event triggered after setting filters for sales lines with negative quantities.
/// This allows developers to adjust filters or perform additional logic after the filters have been applied.
/// </summary>
/// <param name="FromSalesLine">
/// The sales line record with the applied filters for negative quantities.
/// </param>
/// <param name="OnlyTest">
/// A boolean flag indicating whether the operation is a test (no actual deletion occurs) or a real deletion.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnDeleteSalesLinesWithNegQtyOnAfterSetFilters(var FromSalesLine: Record "Sales Line"; OnlyTest: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnIsSplitItemLedgEntryOnAfterItemLedgEntrySetFilters(var ItemLedgEntry: Record "Item Ledger Entry"; OrgItemLedgEntry: Record "Item Ledger Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdSalesLinesPerILETransferFields(var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var TempSalesLineBuf: Record "Sales Line" temporary; var ToSalesHeader: Record "Sales Header"; ItemLedgEntry: Record "Item Ledger Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdSalesLinesPerILEOnBeforeItemLedgEntryLoop(var ItemLedgEntry: record "Item Ledger Entry"; FromSalesLine: record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdSalesLinesPerILEOnAfterAssignShipmentLineNo(var ItemLedgerEntry: Record "Item Ledger Entry"; var TempSalesLine: Record "Sales Line" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdPurchLinesPerILEOnBeforeCheckUnappliedLines(PurchaseHeader: Record "Purchase Header"; SkippedLine: Boolean; MissingExCostRevLink: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdSalesLinesPerILEOnBeforeCheckUnappliedLines(SalesHeader: Record "Sales Header"; SkippedLine: Boolean; MissingExCostRevLink: Boolean)
begin
end;
/// <summary>
/// Event triggered before validating the quantity field during the field transfer process from a sales line to a purchase line.
/// This allows developers to modify or intervene in the validation process for the quantity field.
/// </summary>
/// <param name="FromSalesLine">
/// The sales line record from which the quantity is being transferred.
/// </param>
/// <param name="ToPurchaseLine">
/// The purchase line record to which the quantity is being transferred.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnTransfldsFromSalesToPurchLineOnBeforeValidateQuantity(FromSalesLine: Record "Sales Line"; var ToPurchaseLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered after recalculating the sales line. This allows additional modifications or checks after the recalculation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnAfterRecalculateSalesLine(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered before recalculating the sales line. This allows custom logic to intervene or modify the recalculation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnBeforeRecalculateSalesLine(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered before clearing drop shipment and special order flags on the sales line. This allows custom handling of these flags during the update process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnBeforeClearDropShipmentAndSpecialOrder(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyFromSalesLineItemChargeAssignOnAfterValueEntryLoop(FromSalesHeader: Record "Sales Header"; ToSalesLine: Record "Sales Line"; ValueEntry: Record "Value Entry"; var TempToItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)" temporary; var ToItemChargeAssignmentSales: Record "Item Charge Assignment (Sales)"; var ItemChargeAssgntNextLineNo: Integer; var SumQtyToAssign: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyFromPurchLineItemChargeAssignOnAfterValueEntryLoop(FromPurchHeader: Record "Purchase Header"; ToPurchLine: Record "Purchase Line"; ValueEntry: Record "Value Entry"; var TempToItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)" temporary; var ToItemChargeAssignmentPurch: Record "Item Charge Assignment (Purch)"; var ItemChargeAssgntNextLineNo: Integer; var SumQtyToAssign: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnLinkJobPlanningLineOnAfterJobPlanningLineModify(var JobPlanningLineInvoice: Record "Job Planning Line Invoice"; var JobPlanningLine: Record "Job Planning Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdPurchLinesPerILEOnBeforeCheckJobNo(FromPurchLine: Record "Purchase Line"; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnAfterFilterEntryType(var FromPurchLineBuf: Record "Purchase Line" temporary; var ItemLedgEntryBuf: Record "Item Ledger Entry" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchLineOnAfterValidateQuantityMoveNegLines(var ToPurchLine: Record "Purchase Line"; FromPurchLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchLineOnBeforeValidateQuantity(var ToPurchLine: Record "Purchase Line"; RecalculateLines: Boolean; FromPurchaseLine: Record "Purchase Line"; MoveNegLines: Boolean; var ShouldRevertQuantitySign: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalculatePurchLineOnAfterValidateQuantity(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnProcessToAsmHeaderOnAfterValidateQty(var ToAsmHeader: Record "Assembly Header"; TempFromAsmHeader: Record "Assembly Header" temporary; ToSalesLine: Record "Sales Line"; BasicAsmOrderCopy: Boolean; AvailabilityCheck: Boolean)
begin
end;
/// <summary>
/// Event triggered after validating the "Quantity" field on the sales line. This allows additional modifications or checks after the validation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnRecalculateSalesLineOnAfterValidateQuantity(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered after validating the "Line Discount Amount" field on the sales line. This allows additional adjustments or logic after the validation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnRecalculateSalesLineOnAfterValidateLineDiscountAmount(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitPstdPurchLinesPerILEOnBeforeFromPurchLineBufInsert(var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var FromPurchLineBuf: Record "Purchase Line"; var ToPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitSalesDocLinesPerItemTrkgOnAfterCalcSignFactor(FromSalesLine: Record "Sales Line"; var SignFactor: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSplitSalesDocLinesPerItemTrkgOnAfterInitSalesLineBuf1(var SalesLineBuf1: Record "Sales Line" temporary; var ItemLedgerEntry: Record "Item Ledger Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSetTrackingOnAssemblyReservationOnBeforeTempTrackingSpecificationInsert(var TempTrackingSpecification: Record "Tracking Specification" temporary; TempItemLedgerEntry: Record "Item Ledger Entry" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateToAsmLinesOnBeforeToAssemblyLineModify(ToAsmHeader: Record "Assembly Header"; var ToAssemblyLine: Record "Assembly Line"; var FromAsmLine: Record "Assembly Line"; ToSalesLine: Record "Sales Line"; BasicAsmOrderCopy: Boolean; AvailabilityCheck: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateToAsmLinesOnAfterValidateQty(ToAsmHeader: Record "Assembly Header"; FromAsmLine: Record "Assembly Line"; var ToAssemblyLine: Record "Assembly Line"; ToSalesLine: Record "Sales Line"; BasicAsmOrderCopy: Boolean; AvailabilityCheck: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesLineExtText(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; DocLineNo: Integer; var NextLineNo: Integer; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnAfterAssignCopiedFromPostedDoc(var ToSalesLine: Record "Sales Line"; ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnAfterValidateQuantityMoveNegLines(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnAfterMoveNegLines(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeCopyItemTracking(var TempSalesLineBuf: Record "Sales Line" temporary; ToSalesHeader: Record "Sales Header"; var FromSalesInvLine: Record "Sales Invoice Line"; var ItemLedgEntryBuf: Record "Item Ledger Entry" temporary; var TempItemTrkgEntry: Record "Reservation Entry" temporary; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeCheckLocationOnWMS(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; var IsHandled: Boolean; IncludeHeader: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeAutoReserve(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered after calculating whether to copy the current sales line.
/// This allows developers to modify the decision to copy the line.
/// </summary>
/// <param name="ToSalesHeader">The target sales header to which the sales line will be copied.</param>
/// <param name="FromSalesHeader">The source sales header from which the sales line will be copied.</param>
/// <param name="ToSalesLine">The source sales line to be copied.</param>
/// <param name="RoundingLineInserted">A boolean variable indicating whether a rounding line was inserted during the process.</param>
/// <param name="CopyThisLine">A boolean flag indicating whether the current line should be copied. Can be modified.</param>
/// <param name="RecalculateLines">A boolean variable indicating whether lines should be recalculated during the copy operation.</param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnAfterCalcCopyThisLine(var ToSalesHeader: Record "Sales Header"; var FromSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; RoundingLineInserted: Boolean; var CopyThisLine: Boolean; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnReCalcSalesLineOnBeforeCalcVAT(FromSalesHeader: Record "Sales Header"; ToSalesHeader: Record "Sales Header"; var SalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnReCalcPurchLineOnBeforeCalcVAT(FromPurchaseHeader: Record "Purchase Header"; ToPurchaseHeader: Record "Purchase Header"; var PurchaseLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered before validating the "Ship-to Code" field when copying a return order to a sales header.
/// This allows developers to intervene or add custom logic before the "Ship-to Code" has been validated.
/// </summary>
/// <param name="SalesHeader">The sales header being updated.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesHeaderWhenCopyFromSalesHeaderOnBeforeValidateShipToCode(var SalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCheckSalesRounding(var FromSalesLine: Record "Sales Line"; var RoundingLineInserted: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterCopySalesDocLine(ToSalesLine: Record "Sales Line"; FromSalesInvLine: Record "Sales Invoice Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnBeforeCopyItemCharges(FromPurchInvLine: Record "Purch. Inv. Line"; NextLineNo: Integer; var ToPurchaseLine: Record "Purchase Line"; TempPurchaseLineBuf: Record "Purchase Line" temporary; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocSalesLineOnBeforeCopyFromSalesDocAssgntToLine(FromSalesLine: Record "Sales Line"; ToSalesLine: Record "Sales Line"; RecalculateLines: Boolean; NextLineNo: Integer; var LinesNotCopied: Integer)
begin
end;
/// <summary>
/// Event triggered after completing the sales line copy process for the sales document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after all sales lines have been copied. This can be useful for implementing post-processing logic,
/// validations, or handling specific workflows related to the copied sales lines.
/// </summary>
/// <param name="ToSalesLine">
/// The target sales line record to which the sales lines were copied.
/// </param>
/// <param name="TransferOldExtLines">
/// An object codeunit "Transfer Old Ext. Text Lines" handling the transfer of old extended lines, if applicable.
/// </param>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales lines were copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocSalesLine(var ToSalesLine: Record "Sales Line"; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines"; FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered after setting properties for a process or operation in the general journal.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after the properties have been initialized. This can be useful for implementing additional logic,
/// validations, or handling specific business rules related to the configured properties.
/// </summary>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the header should be included.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated.
/// </param>
/// <param name="MoveNegLines">
/// A boolean value indicating whether negative lines should be moved.
/// </param>
/// <param name="CreateToHeader">
/// A boolean value indicating whether to create to the header.
/// </param>
/// <param name="HideDialog">
/// A boolean value indicating whether dialogs should be hidden.
/// </param>
/// <param name="ExactCostRevMandatory">
/// A boolean value indicating whether exact cost reversal is mandatory.
/// </param>
/// <param name="ApplyFully">
/// A boolean value indicating whether to apply fully.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterSetProperties(var IncludeHeader: Boolean; var RecalculateLines: Boolean; var MoveNegLines: Boolean; var CreateToHeader: Boolean; var HideDialog: Boolean; var ExactCostRevMandatory: Boolean; var ApplyFully: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeCopyThisLine(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line"; FromSalesDocType: Enum "Sales Document Type From"; var RecalculateLines: Boolean; var CopyThisLine: Boolean; var LinesNotCopied: Integer; var Result: Boolean; var IsHandled: Boolean; var NextLineNo: Integer; DocLineNo: Integer; MoveNegLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure CheckCopyFromSalesInvoiceAvailOnBeforeCheckItemAvailability(var ToSalesLine: Record "Sales Line"; var FromSalesInvLine: Record "Sales Invoice Line"; var ToSalesHeader: Record "Sales Header"; var FromSalesInvHeader: Record "Sales Invoice Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocLineOnBeforeCopyThisLine(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line"; MoveNegLines: Boolean; FromPurchDocType: Enum "Purchase Document Type From"; var LinesNotCopied: Integer; var CopyThisLine: Boolean; var Result: Boolean; var IsHandled: Boolean; ToPurchaseHeader: Record "Purchase Header"; var RecalculateLines: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocLineOnBeforeCheckLocationOnWMS(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterCopySalesPostedDeferrals(var FromSalesInvLine: Record "Sales Invoice Line"; NextLineNo: Integer; var ToSalesLine: Record "Sales Line"; var TempSalesLineBuf: Record "Sales Line" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterIsCopyItemTrkg(var ItemLedgEntry: Record "Item Ledger Entry"; FillExactCostRevLink: Boolean; var CopyItemTrkg: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterUpdateCustLedgerEntry(var ToSalesHeader: Record "Sales Header"; FromDocType: Enum "Gen. Journal Document Type"; FromDocNo: Code[20]; var CustLedgEntry: Record "Cust. Ledger Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeValidateInvDiscountAmount(var ToSalesLine: Record "Sales Line"; InvDiscountAmount: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeValidateLineDiscountPct(var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckSalesRounding(FromSalesLine: Record "Sales Line"; var RoundingLineInserted: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyPurchPostedDeferrals(ToPurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyFieldsFromOldPurchHeader(var ToPurchHeader: Record "Purchase Header"; var OldPurchHeader: Record "Purchase Header"; IncludeHeader: Boolean; MoveNegLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyFieldsFromOldSalesHeader(var ToSalesHeader: Record "Sales Header"; var OldSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnAfterSetNextLineNo(var ToPurchLine: Record "Purchase Line"; var FromPurchLineArchive: Record "Purchase Line Archive"; var NextLineNo: Integer)
begin
end;
/// <summary>
/// Event triggered after setting the next line number for the target purchase line. This allows further adjustments to the line or its data.
/// </summary>
/// <param name="ToPurchLine">The purchase line of the target document.</param>
/// <param name="FromPurchLine">The purchase line from the source document being processed.</param>
/// <param name="NextLineNo">The next line number for the target document.</param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocLineOnAfterSetNextLineNo(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line"; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnBeforeCopyArchPurchLineExtText(ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; FromPurchHeaderArchive: Record "Purchase Header Archive"; FromPurchLineArchive: Record "Purchase Line Archive"; var NextLineNo: Integer; RecalculateLines: Boolean; var IsHandled: Boolean; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPurchLinesToBuffer(var TempPurchaseLine: Record "Purchase Line"; FromPurchaseLine2: Record "Purchase Line"; FromPurchaseLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyShiptoCodeFromInvToCrMemo(var ToSalesHeader: Record "Sales Header"; FromSalesInvHeader: Record "Sales Invoice Header"; FromDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnAfterFillSalesLineBuffer(var ToSalesHeader: Record "Sales Header"; var FromSalesLineBuf: Record "Sales Line" temporary)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterFillSalesLinesBuffer(ToSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnAfterFillPurchLineBuffer(ToPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnAfterFillPurchLineBuffer(ToPurchHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeTestPricesInclVAT(ToSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; var RecalculateLines: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnBeforeTestPricesInclVAT(ToSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; var RecalculateLines: Boolean; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered before validating the "Location Code" field on the sales line. This allows custom handling or skipping the validation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="IsHandled">A boolean variable to skip the default validation logic if set to true.</param>
[IntegrationEvent(false, false)]
local procedure OnRecalculateSalesLineOnBeforeValidateLocationCode(var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalculatePurchLineOnBeforeValidateLocationCode(var ToPurchaseLine: Record "Purchase Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesCreditMemoHeaderOnBeforeSetShipmentDate(SalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchRcptLinesToDocOnAfterFilterPstdDocLnItemLedgEntries(FromPurchLine: Record "Purchase Line"; var ItemLedgEntry: Record "Item Ledger Entry")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnAfterCalcShouldCopyItemTrackingEntries(ToPurchLine: Record "Purchase Line"; var ShouldCopyItemTrackingEntries: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnAfterCalcShouldCopyItemTrackingEntries(ToPurchLine: Record "Purchase Line"; var ShouldCopyItemTrackingEntries: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyAsmOrderToAsmOrderOnBeforeModifySalesLine(var ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnSetDefaultValuesToSalesLineOnBeforeSetShipmentDate(ToSalesHeader: Record "Sales Header"; var ShouldSetShipmentDate: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnAfterToSalesLineDeleteAll(var ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnBeforeTransferExtendedText(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeaderArchive: Record "Sales Header Archive"; FromSalesLineArchive: Record "Sales Line Archive"; RecalculateLines: Boolean; var NextLineNo: Integer; var TransferOldExtLines: Codeunit "Transfer Old Ext. Text Lines"; var IsHandled: Boolean; MoveNegLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyPostedDeferrals(DeferralDocType: Enum "Deferral Document Type"; FromDocType: Integer; FromDocNo: Code[20]; FromLineNo: Integer; ToDocType: Integer; ToDocNo: Code[20]; ToLineNo: Integer; var StartDate: Date)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyDeferrals(DeferralDocType: Enum "Deferral Document Type"; FromDocType: Integer; FromDocNo: Code[20]; FromLineNo: Integer; ToDocType: Integer; ToDocNo: Code[20]; ToLineNo: Integer; var StartDate: Date)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInsertTempReservationEntryOnBeforeInsert(var TempReservationEntry: Record "Reservation Entry"; ItemLedgerEntry: Record "Item Ledger Entry")
begin
end;
[IntegrationEvent(true, false)]
local procedure OnCopySalesDocLineOnBeforeCopySalesJobFields(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; FromSalesDocType: Enum "Sales Document Type From")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalcSalesLineOnBeforeRoundUnitPrice(var SalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnAfterCalcShouldValidateQuantityMoveNegLines(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line"; var ShouldValidateQuantityMoveNegLines: Boolean)
begin
end;
/// <summary>
/// Event triggered before finalizing a sales line during the sales document copy process.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after a sales line has been copied but before the next iteration or completion of the process.
/// This can be useful for implementing additional logic, validations, or post-processing for each line.
/// </summary>
/// <param name="FromSalesHeader">
/// The source sales header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales lines are being copied.
/// </param>
/// <param name="ToSalesLine">
/// The target sales line record being finalized.
/// </param>
/// <param name="FromSalesLine">
/// The source sales line record being processed.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocSalesLineOnBeforeFinishSalesDocSalesLine(FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; RecalculateLines: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesShptLinesToDocOnAfterCopySalesLine(ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesShptLine: Record "Sales Shipment Line")
begin
end;
/// <summary>
/// Event triggered after completing the sales credit memo line copy process for the sales document.
/// Subscribing to this event allows developers to extend or customize the behavior
/// after all sales credit memo lines have been copied. This can be useful for implementing post-processing logic,
/// validations, or handling specific workflows related to the copied sales credit memo lines.
/// </summary>
/// <param name="FromSalesCrMemoHeader">
/// The source sales credit memo header record being copied.
/// </param>
/// <param name="ToSalesHeader">
/// The sales header record to which the sales credit memo lines were copied.
/// </param>
/// <param name="FromSalesCrMemoLine">
/// The source sales credit memo line record that was copied.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnAfterCopySalesDocCrMemoLine(var FromSalesCrMemoHeader: Record "Sales Cr.Memo Header"; var ToSalesHeader: Record "Sales Header"; var FromSalesCrMemoLine: Record "Sales Cr.Memo Line")
begin
end;
/// <summary>
/// Event triggered before handling the assembly attached to a sales line. This allows custom logic to override or skip the default handling.
/// </summary>
/// <param name="ToSalesLine">The sales line record being processed.</param>
/// <param name="IsHandled">A boolean variable to skip the default logic if set to true.</param>
[IntegrationEvent(false, false)]
local procedure OnBeforeHandleAsmAttachedToSalesLine(var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitAndCheckPurchaseDocumentsOnAfterDelNegLines(var ToPurchaseHeader: Record "Purchase Header"; var FromPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitSalesLineFieldsOnBeforeInitQty(var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnAfterCalcShouldRecalculateAmount(var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive"; var ShouldRecalculateAmount: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitAndCheckSalesDocumentsOnAfterDelNegLines(ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header")
begin
end;
/// <summary>
/// Event triggered before deleting purchase lines with negative quantities.
/// This allows developers to modify or override the behavior of the deletion process.
/// </summary>
/// <param name="FromPurchHeader">
/// The purchase header record associated with the purchase lines to be deleted.
/// </param>
/// <param name="OnlyTest">
/// A boolean flag indicating whether the operation is a test (no actual deletion occurs) or a real deletion.
/// </param>
/// <param name="IsHandled">
/// A boolean flag that allows developers to handle the logic themselves and skip the default deletion process if set to true.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeDeletePurchLinesWithNegQty(FromPurchHeader: Record "Purchase Header"; OnlyTest: Boolean; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered after inserting the copied sales line into the target sales document.
/// This allows developers to perform additional actions after the insertion.
/// </summary>
/// <param name="ToSalesLine">The target sales line that was inserted.</param>
/// <param name="FromSalesLine">The source sales line that was copied.</param>
/// <param name="FromSalesDocType">The document type of the source sales document.</param>
/// <param name="MoveNegLines">A boolean variable indicating whether negative lines were moved instead of copied.</param>
[IntegrationEvent(true, false)]
local procedure OnCopySalesDocLineOnAfterInsertToSalesLine(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; FromSalesDocType: Enum "Sales Document Type From"; MoveNegLines: Boolean)
begin
end;
/// <summary>
/// Event triggered before validating the "Work Type Code" field on the sales line. This allows custom logic or skipping the validation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnRecalculateSalesLineOnBeforeValidateWorkTypeCode(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSplitSalesDocLinesPerItemTrkg(var ItemLedgerEntry: Record "Item Ledger Entry"; var TempReservationEntry: Record "Reservation Entry" temporary; var TempSalesLineBuf: Record "Sales Line" temporary; FromSalesLine: Record "Sales Line"; var TempDocSalesLine: Record "Sales Line" temporary; var NextLineNo: Integer; var NextItemTrkgEntryNo: Integer; var MissingExCostRevLink: Boolean; FromShptOrRcpt: Boolean; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSplitPurchDocLinesPerItemTrkg(var ItemLedgerEntry: Record "Item Ledger Entry"; var TempReservationEntry: Record "Reservation Entry" temporary; var FromPurchaseLineBuf: Record "Purchase Line"; FromPurchaseLine: Record "Purchase Line"; var TempDocPurchaseLine: Record "Purchase Line" temporary; var NextLineNo: Integer; var NextItemTrkgEntryNo: Integer; var MissingExCostRevLink: Boolean; FromShptOrRcpt: Boolean; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitAndCheckSalesDocumentsOnAfterCheckSalesDocItselfCopy(ToSalesHeader: Record "Sales Header"; FromSalesHeader: Record "Sales Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitAndCheckPurchaseDocumentsOnAfterCheckPurchDocItselfCopy(ToPurchaseHeader: Record "Purchase Header"; FromPurchaseHeader: Record "Purchase Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchPurchLineOnBeforeCheckExactCostRevMandatory(var ToPurchLine: Record "Purchase Line"; FromPurchLineArchive: Record "Purchase Line Archive")
begin
end;
/// <summary>
/// Event triggered before validating the customer in the sales document copy process.
/// Subscribing to this event allows developers to override or extend the default customer validation logic.
/// This can be useful for applying custom rules, skipping validation, or introducing additional checks.
/// </summary>
/// <param name="FromSalesHeader">
/// The source sales header record being validated.
/// </param>
/// <param name="ToSalesHeader">
/// The target sales header record to which the customer validation is being applied.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default validation behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckCustomer(var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCopyFromSalesLineItemChargeAssign(FromSalesLine: Record "Sales Line"; ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; var ItemChargeAssgntNextLineNo: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesReturnRcptLinesToDocOnBeforeCopyLines(var ToSalesHeader: Record "Sales Header"; FromReturnRcptLine: Record "Return Receipt Line"; var FromSalesLineBuf: Record "Sales Line" temporary);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchRcptLinesToDocOnBeforeCopyItemTrkg(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; FromPurchLineBuf: Record "Purchase Line"; var RecalculateLines: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnBeforeCopyItemCharges(var ToPurchLine: Record "Purchase Line"; var FromPurchLineBuf: Record "Purchase Line" temporary; RecalculateLines: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchReturnShptLinesToDocOnBeforeCopyItemTrkg(var ToPurchLine: Record "Purchase Line"; var FromPurchLineBuf: Record "Purchase Line" temporary; RecalculateLines: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeUpdateSalesCreditMemoHeader(var SalesHeader: Record "Sales Header"; var IsHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitAndCheckSalesDocumentsOnBeforeCheckCreditLimit(var FromSalesHeader: Record "Sales Header"; var ToSalesHeader: Record "Sales Header"; var IsHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnTransferFieldsFromCrMemoToInvOnBeforeTransferFields(var ToSalesHeader: Record "Sales Header"; FromSalesCrMemoHeader: Record "Sales Cr.Memo Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeTempSalesLineBufLoop(var ToSalesHeader: Record "Sales Header"; var TempSalesLineBuf: Record "Sales Line" temporary);
begin
end;
/// <summary>
/// Event triggered before transferring fields from a posted purchase receipt header to a purchase header.
/// Allows developers to customize or modify the data before it has been transferred.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data will be transferred.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchRcptHeader">
/// The source posted purchase receipt header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchHeaderFromPostedReceiptOnBeforeTransferFields(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchRcptHeader: Record "Purch. Rcpt. Header")
begin
end;
/// <summary>
/// Event triggered before transferring fields from a posted purchase invoice header to a purchase header.
/// Allows developers to customize or modify the data before it has been transferred.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data will be transferred.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchInvHeader">
/// The source posted purchase invoice header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchHeaderFromPostedInvoiceOnBeforeTransferFields(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchInvHeader: Record "Purch. Inv. Header")
begin
end;
/// <summary>
/// Event triggered before transferring fields from a posted return shipment header to a purchase header.
/// Allows developers to customize or modify the data before it has been transferred.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data will be transferred.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromReturnShipmentHeader">
/// The source posted return shipment header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchHeaderFromPostedReturnShipmentOnBeforeTransferFields(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromReturnShipmentHeader: Record "Return Shipment Header")
begin
end;
/// <summary>
/// Event triggered before transferring fields from a posted purchase credit memo header to a purchase header.
/// Allows developers to customize or modify the data before it has been transferred.
/// </summary>
/// <param name="ToPurchaseHeader">
/// The target purchase header record to which data will be transferred.
/// </param>
/// <param name="OldPurchaseHeader">
/// The original purchase header record before copying.
/// </param>
/// <param name="FromPurchCrMemoHeader">
/// The source posted purchase credit memo header record.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchHeaderFromPostedCreditMemoOnBeforeTransferFields(var ToPurchaseHeader: Record "Purchase Header"; OldPurchaseHeader: Record "Purchase Header"; FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr.")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocOnBeforeConfirmDeleteLines(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var IsHandled: Boolean);
begin
end;
/// <summary>
/// Event triggered before inserting or updating the purchase header during the document copy process.
/// Subscribing to this event allows developers to modify or extend the behavior
/// before the header has been created or updated. This can be useful for applying additional logic,
/// customizations, or altering the workflow during header processing.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record being created or updated.
/// </param>
/// <param name="ToPurchLine">
/// The purchase line record associated with the target purchase document.
/// </param>
/// <param name="CreateToHeader">
/// A boolean value indicating whether the header will be created.
/// </param>
/// <param name="IncludeHeader">
/// A boolean value indicating whether the source header data should be included.
/// </param>
/// <param name="DoExit">
/// A boolean variable indicating whether the operation should exit early.
/// </param>
/// <param name="IsHandled">
/// A boolean variable indicating whether the default header creation or inclusion behavior should be bypassed.
/// Setting this variable to true will skip the default behavior.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocOnBeforeCreateOrIncludeHeader(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; CreateToHeader: Boolean; IncludeHeader: Boolean; var DoExit: Boolean; var IsHandled: Boolean);
begin
end;
/// <summary>
/// Event triggered after processing each purchase line in the loop during the purchase document copy process.
/// Subscribing to this event allows developers to implement additional logic
/// or workflows after processing each line. This can be useful for tracking progress or applying custom operations.
/// </summary>
/// <param name="ToPurchHeader">
/// The target purchase header record to which the lines are being copied.
/// </param>
/// <param name="ToPurchLine">
/// The current purchase line record in the target document.
/// </param>
/// <param name="FromPurchLine">
/// The current purchase line record in the source document being processed.
/// </param>
/// <param name="RecalculateLines">
/// A boolean value indicating whether the lines should be recalculated during the copy process.
/// </param>
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocPurchLineOnAfterProcessFromPurchLineInLoop(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; FromPurchLine: Record "Purchase Line"; RecalculateLines: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnBeforeInsertOldPurchLine(var ToPurchaseHeader: Record "Purchase Header"; var FromPurchLineBuf: Record "Purchase Line" temporary; var OldInvDocNo: Code[20]; var OldRcptDocNo: Code[20]; var NextLineNo: Integer; SkipCopyFromDescription: Boolean; InsertCancellationLine: Boolean; var IsHandled: Boolean);
begin
end;
/// <summary>
/// Event triggered before recalculating the amount on the sales line. This allows custom adjustments before the amount has been recalculated.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineBeforeRecalculateAmount(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line");
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalculatePurchLineOnBeforeValidatePurchasingCode(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var CopyThisLine: Boolean; var IsHandled: Boolean);
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeSetSalesHeader(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; FromSalesHeader: Record "Sales Header"; FromSalesLine: Record "Sales Line"; var NextLineNo: Integer)
begin
end;
/// <summary>
/// Event triggered before validating the "Unit Cost (LCY)" field on the sales line. This allows custom logic before the validation has been executed.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="IsHandled">A boolean variable to override the default validation if set to true.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnBeforeToSalesLineValidateUnitCostLcy(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line"; var IsHandled: Boolean)
begin
end;
/// <summary>
/// Event triggered after updating the warehouse shipment information for the sales line. This allows custom adjustments or checks after the update.
/// </summary>
/// <param name="ToSalesHeader">The target sales header record being updated.</param>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesHeader">The source sales header record being copied from.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnAfterUpdateWithWarehouseShip(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchDocLineOnBeforeRecalculateLines(var ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; var FromPurchHeader: Record "Purchase Header"; var FromPurchLine: Record "Purchase Line"; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnUpdatePurchLineOnAfterCopyDocLine(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
end;
/// <summary>
/// Event triggered before determining if the sales line should be copied when the type is "G/L Account".
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnRecalculateSalesLineOnBeforeCopyThisLine(ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line")
begin
end;
/// <summary>
/// Event triggered after validating the "No." field on the sales line. This allows additional logic or checks after the validation process.
/// </summary>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
[IntegrationEvent(false, false)]
local procedure OnRecalculateSalesLineOnAfterValidateNo(var ToSalesLine: Record "Sales Line"; var FromSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalculatePurchLineOnAfterCopyThisLine(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalculatePurchLineOnAfterValidateNo(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnRecalculatePurchLineOnAfterValidatePurchasingCode(var ToPurchLine: Record "Purchase Line"; var FromPurchLine: Record "Purchase Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnAfterCopyItemLedgEntryTrackingToSalesLine(ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnAfterCopyItemLedgEntryTrkgToSalesLn(var ToSalesLine: Record "Sales Line")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetVendor(var FromPurchLine: Record "Purchase Line"; var Vendor: Record Vendor; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCheckFromPurchaseHeader(PurchaseHeaderFrom: Record "Purchase Header"; PurchaseHeaderTo: Record "Purchase Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesDocLineOnBeforeInitToSalesLine(var ToSalesLine: Record "Sales Line"; FromSalesLine: Record "Sales Line"; var ShouldInitToSalesLine: Boolean)
begin
end;
/// <summary>
/// Event triggered before validating the target sales line during the update process. This allows additional checks or modifications before validation.
/// </summary>
/// <param name="ToSalesHeader">The target sales header record being updated.</param>
/// <param name="ToSalesLine">The target sales line record being updated.</param>
/// <param name="FromSalesHeader">The source sales header record being copied from.</param>
/// <param name="FromSalesLine">The source sales line record being copied from.</param>
/// <param name="ShouldRecalculateSalesLine">A boolean variable indicating if the sales line should be recalculated.</param>
[IntegrationEvent(false, false)]
local procedure OnUpdateSalesLineOnBeforeValidateToSalesLine(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; var FromSalesHeader: Record "Sales Header"; var FromSalesLine: Record "Sales Line"; var ShouldRecalculateSalesLine: Boolean)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnBeforeInsertOldSalesDocNoLineProcedure(var ToSalesHeader: Record "Sales Header"; var ToSalesLine: Record "Sales Line"; OldDocType: Option; OldDocNo: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnBeforeInsertOldPurchDocNoLineProcedure(ToPurchHeader: Record "Purchase Header"; var ToPurchLine: Record "Purchase Line"; OldDocType: Option; OldDocNo: Code[20]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchRcptLinesToDocOnBeforeTestFieldPricesIncludingVAT(var ToPurchaseHeader: Record "Purchase Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; var FromPurchRcptHeader: Record "Purch. Rcpt. Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchInvLinesToDocOnBeforeTestFieldPricesIncludingVAT(var ToPurchaseHeader: Record "Purchase Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; var FromPurchInvHeader: Record "Purch. Inv. Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchCrMemoLinesToDocOnBeforeTestFieldPricesIncludingVAT(var ToPurchaseHeader: Record "Purchase Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; var FromPurchCrMemoHeader: Record "Purch. Cr. Memo Hdr."; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyPurchReturnShptLinesToDocOnBeforeTestFieldPricesIncludingVAT(var ToPurchaseHeader: Record "Purchase Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; var FromReturnShptHeader: Record "Return Shipment Header"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInitAndCheckSalesDocumentsOnBeforeFromSalesHeaderArchiveCheckFields(var FromSalesHeaderArchive: Record "Sales Header Archive"; var ToSalesHeader: Record "Sales Header"; IncludeHeader: Boolean; RecalculateLines: Boolean; var SkipFromSalesHeaderArchiveCheck: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromArchSalesDocDimToLine(var ToSalesLine: Record "Sales Line"; FromSalesLineArchive: Record "Sales Line Archive")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyFromArchSalesDocDimToHdr(var ToSalesHeader: Record "Sales Header"; FromSalesHeaderArchive: Record "Sales Header Archive")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeGetNextLineNo(var ToSalesHeader: Record "Sales Header"; var TempSalesLineBuf: Record "Sales Line" temporary; var ShouldGetNextLineNo: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesInvLinesToDocOnBeforeIncrementNextLineNo(var ToSalesHeader: Record "Sales Header"; var TempSalesLineBuf: Record "Sales Line" temporary; var ShouldIncrementNextLineNo: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopySalesCrMemoLinesToDocOnBeforeGetNextLineNo(var ToSalesHeader: Record "Sales Header"; var TempFromSalesLineBuf: Record "Sales Line" temporary; var ShouldGetNextLineNo: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnInsertOldSalesDocNoLineOnBeforeIncrementNextLineNo(var ToSalesHeader: Record "Sales Header"; var ShouldIncrementNextLineNo: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCheckFirstLineShippedOnBeforeIncrementNextLineNo(ToSalesHeader: Record "Sales Header"; var TempSalesLine: Record "Sales Line" temporary; var ShouldIncrementNextLineNo: Boolean; var NextLineNo: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnAfterInitSalesLineFields(var ToSalesLine: Record "Sales Line"; var FromSalesLineArchive: Record "Sales Line Archive")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCopyArchSalesLineOnBeforeIncrementLinesNotCopied(FromSalesLineArchive: Record "Sales Line Archive"; var ShouldIncrementLinesNotCopied: Boolean; var LinesNotCopied: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCreateJobPlanningLineOnAfterInitFromJobPlanningLine(var NewJobPlanningLine: Record "Job Planning Line"; JobPlanningLine: Record "Job Planning Line"; SalesLine: Record "Sales Line")
begin
end;
}