Codeunit 5980 Service-Post

// ------------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// ------------------------------------------------------------------------------------------------
namespace Microsoft.Service.Posting;

using Microsoft.Finance.Analysis;
using Microsoft.Finance.GeneralLedger.Journal;
using Microsoft.Finance.GeneralLedger.Ledger;
using Microsoft.Finance.GeneralLedger.Preview;
using Microsoft.Finance.GeneralLedger.Setup;
using Microsoft.Foundation.AuditCodes;
using Microsoft.Foundation.Reporting;
using Microsoft.Inventory.Analysis;
using Microsoft.Inventory.Setup;
using Microsoft.Inventory.Tracking;
using Microsoft.Service.Archive;
using Microsoft.Service.Document;
using Microsoft.Service.History;
using Microsoft.Service.Setup;
using Microsoft.Utilities;
using Microsoft.Warehouse.Document;
using Microsoft.Warehouse.History;

codeunit 5980 "Service-Post"
{
    Permissions = TableData "Service Header" = rimd,
                  TableData "Service Item Line" = rimd,
                  TableData "Service Line" = rimd,
                  TableData "Service Shipment Item Line" = rimd,
                  TableData "Service Shipment Header" = rimd,
                  TableData "Service Shipment Line" = rimd,
                  TableData "Service Invoice Header" = rimd,
                  TableData "Service Invoice Line" = rimd,
                  TableData "Service Cr.Memo Header" = rimd,
                  TableData "Service Cr.Memo Line" = rimd,
                  tabledata "G/L Entry" = r;
    TableNo = "Service Header";

    trigger OnRun()
    var
        TempServiceLine: Record "Service Line" temporary;
    begin
        OnBeforeRun(Rec);

        PostWithLines(Rec, TempServiceLine, Ship, Consume, Invoice);
    end;

    var
        ServiceShptLine: Record "Service Shipment Line";
        SourceCodeSetup: Record "Source Code Setup";
        SourceCode: Record "Source Code";
        ServiceSetup: Record "Service Mgt. Setup";
        ServiceInvLine: Record "Service Invoice Line";
        ServiceCrMemoLine: Record "Service Cr.Memo Line";
        TempWarehouseShipmentHeader: Record "Warehouse Shipment Header" temporary;
        WarehouseShipmentHeader: Record "Warehouse Shipment Header";
        TempWarehouseShipmentLine: Record "Warehouse Shipment Line" temporary;
        GLSetup: Record "General Ledger Setup";
        ServDocumentsMgt: Codeunit "Serv-Documents Mgt.";
        DocumentErrorsMgt: Codeunit "Document Errors Mgt.";
        WhsePostShpt: Codeunit "Whse.-Post Shipment";
        Window: Dialog;
        PostingDate: Date;
        OrderArchived: Boolean;
        ReplaceDocumentDate: Boolean;
        ReplacePostingDate: Boolean;
        PostingDateExists: Boolean;
        Ship: Boolean;
        Consume: Boolean;
        Invoice: Boolean;
#pragma warning disable AA0074
#pragma warning disable AA0470
        Text002: Label 'Posting lines              #2######\';
        Text003: Label 'Posting serv. and VAT      #3######\';
        Text004: Label 'Posting to customers       #4######\';
        Text005: Label 'Posting to bal. account    #5######';
        Text006: Label 'Posting lines              #2######';
#pragma warning restore AA0470
        Text007: Label 'is not within your range of allowed posting dates';
#pragma warning restore AA0074
        WhseShip: Boolean;
        PreviewMode: Boolean;
        SuppressCommit: Boolean;
        NotSupportedDocumentTypeErr: Label 'Document type %1 is not supported.', Comment = '%1=Document Type e.g. Invoice';
        HideValidationDialog: Boolean;

    procedure PostWithLines(var PassedServHeader: Record "Service Header"; var PassedServLine: Record "Service Line"; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean)
    var
        ServiceHeader: Record "Service Header";
        UpdateAnalysisView: Codeunit "Update Analysis View";
        UpdateItemAnalysisView: Codeunit "Update Item Analysis View";
        WhseServiceRelease: Codeunit "Whse.-Service Release";
        ServInvoiceNo: Code[20];
        ServCrMemoNo: Code[20];
        ServShipmentNo: Code[20];
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforePostWithLines(PassedServHeader, PassedServLine, PassedShip, PassedConsume, PassedInvoice, PostingDateExists, HideValidationDialog, IsHandled, PreviewMode, ReplacePostingDate, PostingDate, ReplaceDocumentDate, SuppressCommit);
        if not IsHandled then begin

            ServiceHeader := PassedServHeader;

            Clear(ServDocumentsMgt);

            ValidatePostingAndDocumentDate(ServiceHeader);

            Initialize(ServiceHeader, PassedServLine, PassedShip, PassedConsume, PassedInvoice);

            if GuiAllowed() then begin
                if Invoice then
                    Window.Open('#1#################################\\' + Text002 + Text003 + Text004 + Text005)
                else
                    Window.Open('#1#################################\\' + Text006);
                Window.Update(1, StrSubstNo('%1 %2', ServiceHeader."Document Type", ServiceHeader."No."));
            end;

            if ServDocumentsMgt.SetNoSeries(ServiceHeader, PreviewMode) then begin
                ServiceHeader.Modify();
                if not SuppressCommit and not PreviewMode then
                    Commit();
            end;

            if PreviewMode then
                ServiceHeader.Consistent(false); // Safety net to prevent commits

            ServDocumentsMgt.CalcInvDiscount();
            ServiceHeader.Find();

            CollectWhseShipmentInformation(PassedServHeader);

            ProcessPosting(
                ServiceHeader,
                PassedServHeader, PassedServLine,
                PassedShip, PassedConsume, PassedInvoice,
                ServShipmentNo, ServInvoiceNo, ServCrMemoNo);

            if WhseShip then
                WhseServiceRelease.Release(ServiceHeader);

            if not SuppressCommit then
                Commit();

            OnAfterPostServiceDoc(ServiceHeader, ServShipmentNo, ServInvoiceNo, ServCrMemoNo, ServDocumentsMgt, SuppressCommit, PassedShip, PassedConsume, PassedInvoice, WhseShip, Invoice);

            if GuiAllowed() then
                Window.Close();

            UpdateAnalysisView.UpdateAll(0, true);
            UpdateItemAnalysisView.UpdateAll(0, true);

            PassedServHeader := ServiceHeader;
        end;

        OnAfterPostWithLines(PassedServHeader, IsHandled);
    end;

    /// <summary>
    /// A wrapper procedure to delegate to either a procedure that allows commit or a procedure that ignores commit.
    /// By default, commits are suppressed during the critical posting window to prevent duplicate-key races
    /// on G/L Entry (table 17). Subscribers can opt out by setting IgnoreCommit to false via OnSetCommitBehavior.
    /// </summary>
    /// <param name="ServiceHeader">The service header of the document that is being posted.</param>
    /// <param name="PassedServHeader">The original service header passed to PostWithLines.</param>
    /// <param name="PassedServLine">The service line passed to PostWithLines.</param>
    /// <param name="PassedShip">Indicates whether the document is being shipped.</param>
    /// <param name="PassedConsume">Indicates whether the document is being consumed.</param>
    /// <param name="PassedInvoice">Indicates whether the document is being invoiced.</param>
    /// <param name="ServShipmentNo">Set to the posted shipment number during posting.</param>
    /// <param name="ServInvoiceNo">Set to the posted invoice number during posting.</param>
    /// <param name="ServCrMemoNo">Set to the posted credit memo number during posting.</param>
    local procedure ProcessPosting(
        var ServiceHeader: Record "Service Header";
        var PassedServHeader: Record "Service Header";
        var PassedServLine: Record "Service Line";
        var PassedShip: Boolean;
        var PassedConsume: Boolean;
        var PassedInvoice: Boolean;
        var ServShipmentNo: Code[20];
        var ServInvoiceNo: Code[20];
        var ServCrMemoNo: Code[20])
    var
        IgnoreCommit: Boolean;
    begin
        IgnoreCommit := true;
        OnSetCommitBehavior(IgnoreCommit);

        if IgnoreCommit then
            PostDocumentLinesCommitBehaviorIgnore(
                ServiceHeader,
                PassedServHeader, PassedServLine,
                PassedShip, PassedConsume, PassedInvoice,
                ServShipmentNo, ServInvoiceNo, ServCrMemoNo)
        else
            PostDocumentLines(
                ServiceHeader,
                PassedServHeader, PassedServLine,
                PassedShip, PassedConsume, PassedInvoice,
                ServShipmentNo, ServInvoiceNo, ServCrMemoNo);
    end;

    /// <summary>
    /// A wrapper procedure to delegate to PostDocumentLines in order to ignore commits.
    /// While this procedure is on the call stack, the platform turns every Commit() into a no-op,
    /// preventing intermittent duplicate-key errors on G/L Entry (table 17).
    /// </summary>
    /// <param name="ServiceHeader">The service header of the document that is being posted.</param>
    /// <param name="PassedServHeader">The original service header passed to PostWithLines.</param>
    /// <param name="PassedServLine">The service line passed to PostWithLines.</param>
    /// <param name="PassedShip">Indicates whether the document is being shipped.</param>
    /// <param name="PassedConsume">Indicates whether the document is being consumed.</param>
    /// <param name="PassedInvoice">Indicates whether the document is being invoiced.</param>
    /// <param name="ServShipmentNo">Set to the posted shipment number during posting.</param>
    /// <param name="ServInvoiceNo">Set to the posted invoice number during posting.</param>
    /// <param name="ServCrMemoNo">Set to the posted credit memo number during posting.</param>
    [CommitBehavior(CommitBehavior::Ignore)]
    local procedure PostDocumentLinesCommitBehaviorIgnore(
        var ServiceHeader: Record "Service Header";
        var PassedServHeader: Record "Service Header";
        var PassedServLine: Record "Service Line";
        PassedShip: Boolean;
        PassedConsume: Boolean;
        PassedInvoice: Boolean;
        var ServShipmentNo: Code[20];
        var ServInvoiceNo: Code[20];
        var ServCrMemoNo: Code[20])
    begin
        PostDocumentLines(
            ServiceHeader,
            PassedServHeader, PassedServLine,
            PassedShip, PassedConsume, PassedInvoice,
            ServShipmentNo, ServInvoiceNo, ServCrMemoNo);
    end;

    /// <summary>
    /// The main procedure that processes the service document lines.
    /// Covers line posting via ServDocumentsMgt, warehouse shipments, finalization, and the
    /// OnAfterFinalizePostingOnBeforeCommit integration event. Also covers MakeInventoryAdjustment
    /// called transitively through ServDocumentsMgt.PostDocumentLines.
    /// </summary>
    /// <param name="ServiceHeader">The service header of the document that is being posted.</param>
    /// <param name="PassedServHeader">The original service header passed to PostWithLines.</param>
    /// <param name="PassedServLine">The service line passed to PostWithLines.</param>
    /// <param name="PassedShip">Indicates whether the document is being shipped.</param>
    /// <param name="PassedConsume">Indicates whether the document is being consumed.</param>
    /// <param name="PassedInvoice">Indicates whether the document is being invoiced.</param>
    /// <param name="ServShipmentNo">Set to the posted shipment number during posting.</param>
    /// <param name="ServInvoiceNo">Set to the posted invoice number during posting.</param>
    /// <param name="ServCrMemoNo">Set to the posted credit memo number during posting.</param>
    local procedure PostDocumentLines(
        var ServiceHeader: Record "Service Header";
        var PassedServHeader: Record "Service Header";
        var PassedServLine: Record "Service Line";
        PassedShip: Boolean;
        PassedConsume: Boolean;
        PassedInvoice: Boolean;
        var ServShipmentNo: Code[20];
        var ServInvoiceNo: Code[20];
        var ServCrMemoNo: Code[20])
    var
        ServiceLine: Record "Service Line";
        [SecurityFiltering(SecurityFilter::Ignored)]
        GLEntry: Record "G/L Entry";
        WarehouseShipmentLine: Record "Warehouse Shipment Line";
        PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header";
        PostedWhseShipmentLine: Record "Posted Whse. Shipment Line";
        TempTrackingSpecification: Record "Tracking Specification" temporary;
        GenJnlPostPreview: Codeunit "Gen. Jnl.-Post Preview";
        ServiceDocumentArchiveMgmt: Codeunit "Service Document Archive Mgmt.";
        IsHandled: Boolean;
    begin
        LockTables(ServiceLine, GLEntry);
        // update quantities upon posting options and test related fields.
        ServDocumentsMgt.CheckAndBlankQtys(GetServDocType(ServiceHeader));
        // create posted documents (both header and lines).
        WhseShip := false;
        if Ship then begin
            ServShipmentNo := ServDocumentsMgt.PrepareShipmentHeader();
            WhseShip := not TempWarehouseShipmentHeader.IsEmpty();
        end;
        IsHandled := false;
        OnPostDocumentLinesOnBeforeInsertPostedHeaders(ServiceHeader, ServDocumentsMgt, IsHandled, ServInvoiceNo, ServCrMemoNo);
        if not IsHandled then
            if Invoice then
                if ServiceHeader."Document Type" in [ServiceHeader."Document Type"::Order, ServiceHeader."Document Type"::Invoice] then begin
                    ServInvoiceNo := ServDocumentsMgt.PrepareInvoiceHeader(Window);
                    ServDocumentsMgt.UpdateIncomingDocument(ServiceHeader."Incoming Document Entry No.", ServiceHeader."Posting Date", ServInvoiceNo);
                end else begin
                    ServCrMemoNo := ServDocumentsMgt.PrepareCrMemoHeader(Window);
                    ServDocumentsMgt.UpdateIncomingDocument(ServiceHeader."Incoming Document Entry No.", ServiceHeader."Posting Date", ServCrMemoNo);
                end;

        if WhseShip then begin
            WarehouseShipmentHeader.Get(TempWarehouseShipmentHeader."No.");
            OnBeforeCreatePostedWhseShptHeader(PostedWhseShipmentHeader, WarehouseShipmentHeader, ServiceHeader);
            WhsePostShpt.CreatePostedShptHeader(PostedWhseShipmentHeader, WarehouseShipmentHeader, ServiceHeader."Shipping No.", ServiceHeader."Posting Date");
        end;
        // main lines posting routine via Journals
        ServDocumentsMgt.PostDocumentLines(Window);
        ServDocumentsMgt.CollectTrackingSpecification(TempTrackingSpecification);

        ServDocumentsMgt.SetLastNos(ServiceHeader);
        ServiceHeader.Modify();

        if not OrderArchived then begin
            ServiceDocumentArchiveMgmt.AutoArchiveServiceDocument(ServiceHeader);
            OrderArchived := true;
        end;

        // handling afterposting modification/deletion of documents
        ServDocumentsMgt.UpdateDocumentLines();

        ServDocumentsMgt.InsertValueEntryRelation();

        if WhseShip then begin
            if TempWarehouseShipmentLine.FindSet() then
                repeat
                    WarehouseShipmentLine.Get(TempWarehouseShipmentLine."No.", TempWarehouseShipmentLine."Line No.");
                    WhsePostShpt.CreatePostedShptLine(WarehouseShipmentLine, PostedWhseShipmentHeader,
                      PostedWhseShipmentLine, TempTrackingSpecification);
                until TempWarehouseShipmentLine.Next() = 0;
            if WarehouseShipmentHeader.Get(WarehouseShipmentHeader."No.") then
                UpdateWhseDocuments();
        end;

        if PreviewMode then begin
            if GuiAllowed() then
                Window.Close();
            GenJnlPostPreview.ThrowError();
        end;

        Finalize(ServiceHeader);

        OnAfterFinalizePostingOnBeforeCommit(
          PassedServHeader, PassedServLine, ServDocumentsMgt, PassedShip, PassedConsume, PassedInvoice, ServInvoiceNo, ServCrMemoNo, ServShipmentNo);
    end;

    local procedure GetServDocType(var ServiceHeader: Record "Service Header"): Integer
    var
        ServDocReg: Record "Service Document Register";
        ServDocType: Integer;
        ServDocNo: Code[20]; // required by ServiceDocument signature, not used here
    begin
        ServDocReg.ServiceDocument(ServiceHeader."Document Type".AsInteger(), ServiceHeader."No.", ServDocType, ServDocNo);
        exit(ServDocType);
    end;

    local procedure UpdateWhseDocuments()
    var
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeUpdateWhseDocuments(WarehouseShipmentHeader, IsHandled);
        if IsHandled then
            exit;

        WhsePostShpt.PostUpdateWhseDocuments(WarehouseShipmentHeader);
    end;

    local procedure Initialize(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line"; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean)
    begin
        OnBeforeInitialize(PassedServiceHeader, PassedServiceLine, PassedShip, PassedConsume, PassedInvoice, PreviewMode);
        CheckServiceDocument(PassedServiceHeader, PassedServiceLine);
        SetPostingOptions(PassedShip, PassedConsume, PassedInvoice);

        ServDocumentsMgt.Initialize(PassedServiceHeader, PassedServiceLine);

        // Also calls procedure of the same name from ServDocMgt.
        // Might change the value of global Ship,Consume,Invoice vars.
        CheckAndSetPostingConstants(PassedServiceHeader, PassedShip, PassedConsume, PassedInvoice);

        OnInitializeOnAfterCheckAndSetPostingConstants(
            PassedServiceHeader, PassedServiceLine, PassedShip, PassedConsume, PassedInvoice, PreviewMode);

        // check for service lines with adjusted price
        if (not HideValidationDialog or not GuiAllowed) and
           Invoice and (PassedServiceHeader."Document Type" = PassedServiceHeader."Document Type"::Order)
        then
            ServDocumentsMgt.CheckAdjustedLines();

        OnAfterInitialize(PassedServiceHeader, PassedServiceLine);
    end;

    procedure CheckServiceDocument(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line")
    var
        ServReportDistributionMgt: Codeunit "Serv. Report Distribution Mgt.";
    begin
        TestMandatoryFields(PassedServiceHeader, PassedServiceLine);
        ServReportDistributionMgt.RunDefaultCheckServiceElectronicDocument(PassedServiceHeader);
        ServDocumentsMgt.CheckServiceDocument(PassedServiceHeader, PassedServiceLine);
    end;

    local procedure Finalize(var PassedServiceHeader: Record "Service Header")
    begin
        ServDocumentsMgt.Finalize(PassedServiceHeader);
    end;

    local procedure CheckAndSetPostingConstants(var ServiceHeader: Record "Service Header"; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean)
    var
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeCheckAndSetPostingConstants(ServiceHeader, ServDocumentsMgt, PassedShip, PassedConsume, PassedInvoice, IsHandled);
        if IsHandled then
            exit;

        case ServiceHeader."Document Type" of
            ServiceHeader."Document Type"::Invoice:
                begin
                    PassedShip := true;
                    PassedInvoice := true;
                end;
            ServiceHeader."Document Type"::"Credit Memo":
                begin
                    PassedShip := false;
                    PassedInvoice := true;
                end;
        end;

        ServDocumentsMgt.CheckAndSetPostingConstants(PassedShip, PassedConsume, PassedInvoice);

        if not (PassedShip or PassedInvoice or PassedConsume) then
            Error(DocumentErrorsMgt.GetNothingToPostErrorMsg());

        if Invoice and (ServiceHeader."Document Type" <> ServiceHeader."Document Type"::"Credit Memo") then
            ServiceHeader.TestField(ServiceHeader."Due Date");
        OnCheckAndSetConstantsOnBeforeSetPostingOptions(ServiceHeader, Invoice, Ship);
        SetPostingOptions(PassedShip, PassedConsume, PassedInvoice);
    end;

    local procedure ValidatePostingAndDocumentDate(var ServiceHeader: Record "Service Header")
    begin
        OnBeforeValidatePostingAndDocumentDate(ServiceHeader, PostingDateExists, ReplacePostingDate, ReplaceDocumentDate, PostingDate);
        if PostingDateExists and (ReplacePostingDate or (ServiceHeader."Posting Date" = 0D)) then begin
            ServiceHeader.Validate("Posting Date", PostingDate);
            ServiceHeader.Validate("Currency Code");
        end;
        if PostingDateExists and (ReplaceDocumentDate or (ServiceHeader."Document Date" = 0D)) then begin
            ServiceHeader.Validate("Document Date", PostingDate);
            OnValidatePostingAndDocumentDateOnAfterValidateDocumentDate(ServiceHeader);
        end;

        OnAfterValidatePostingAndDocumentDate(ServiceHeader, PreviewMode);
    end;

    local procedure TestMandatoryFields(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line")
    var
        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeTestMandatoryFields(PassedServiceHeader, PassedServiceLine, Invoice, IsHandled);
        if IsHandled then
            exit;

        PassedServiceHeader.TestField("Document Type", ErrorInfo.Create());
        PassedServiceHeader.TestField("Customer No.", ErrorInfo.Create());
        PassedServiceHeader.TestField("Bill-to Customer No.", ErrorInfo.Create());
        PassedServiceHeader.TestField("Posting Date", ErrorInfo.Create());
        PassedServiceHeader.TestField("Document Date", ErrorInfo.Create());
        GLSetup.Get();
        if GLSetup."Journal Templ. Name Mandatory" then
            PassedServiceHeader.TestField("Journal Templ. Name", ErrorInfo.Create());
        if PassedServiceLine.IsEmpty() then
            TestServLinePostingDate(PassedServiceHeader."Document Type", PassedServiceHeader."No.", PassedServiceHeader."Journal Templ. Name")
        else
            if PassedServiceHeader."Posting Date" <> PassedServiceLine."Posting Date" then begin
                CheckDateNotAllowedForServiceLine(PassedServiceHeader, PassedServiceLine);
                if GenJnlCheckLine.DateNotAllowed(PassedServiceHeader."Posting Date", PassedServiceHeader."Journal Templ. Name") then
                    PassedServiceHeader.FieldError(PassedServiceHeader."Posting Date", ErrorInfo.Create(Text007, true));
            end;
        PassedServiceHeader.TestMandatoryFields(PassedServiceLine);
    end;

    local procedure CheckDateNotAllowedForServiceLine(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line")
    var
        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";
        IsHandled: Boolean;
    begin
        IsHandled := false;
        OnBeforeCheckDateNotAllowedForServiceLine(PassedServiceLine, IsHandled);
        if IsHandled then
            exit;

        if PassedServiceLine.Type <> PassedServiceLine.Type::" " then
            if GenJnlCheckLine.DateNotAllowed(PassedServiceLine."Posting Date", PassedServiceHeader."Journal Templ. Name") then
                PassedServiceLine.FieldError("Posting Date", ErrorInfo.Create(Text007, true));
    end;

    procedure SetPostingDate(NewReplacePostingDate: Boolean; NewReplaceDocumentDate: Boolean; NewPostingDate: Date)
    var
        IsHandled: Boolean;
        SavedSuppressCommit: Boolean;
        SavedHideValidationDialog: Boolean;
    begin
        IsHandled := false;
        OnBeforeSetPostingDate(PostingDateExists, ReplacePostingDate, ReplaceDocumentDate, PostingDate, IsHandled);
        if IsHandled then
            exit;

        SavedSuppressCommit := SuppressCommit;
        SavedHideValidationDialog := HideValidationDialog;
        ClearAll();
        SuppressCommit := SavedSuppressCommit;
        HideValidationDialog := SavedHideValidationDialog;

        PostingDateExists := true;
        ReplacePostingDate := NewReplacePostingDate;
        ReplaceDocumentDate := NewReplaceDocumentDate;
        PostingDate := NewPostingDate;
    end;

    procedure SetPostingOptions(PassedShip: Boolean; PassedConsume: Boolean; PassedInvoice: Boolean)
    begin
        Ship := PassedShip;
        Consume := PassedConsume;
        Invoice := PassedInvoice;
        ServDocumentsMgt.SetPostingOptions(Ship, Consume, Invoice);
    end;

    procedure SetHideValidationDialog(NewHideValidationDialog: Boolean)
    begin
        HideValidationDialog := NewHideValidationDialog;
    end;

    procedure SetSuppressCommit(NewSuppressCommit: Boolean)
    begin
        SuppressCommit := NewSuppressCommit;
    end;

    procedure TestDeleteHeader(ServiceHeader: Record "Service Header"; var ServiceShptHeader: Record "Service Shipment Header"; var ServiceInvHeader: Record "Service Invoice Header"; var ServiceCrMemoHeader: Record "Service Cr.Memo Header")
    begin
        Clear(ServiceShptHeader);
        Clear(ServiceInvHeader);
        Clear(ServiceCrMemoHeader);
        ServiceSetup.Get();

        SourceCodeSetup.Get();
        SourceCodeSetup.TestField("Deleted Document");
        SourceCode.Get(SourceCodeSetup."Deleted Document");

        if (ServiceHeader."Shipping No. Series" <> '') and (ServiceHeader."Shipping No." <> '') then begin
            ServiceHeader.CalcFields("Work Description");
            ServiceShptHeader.TransferFields(ServiceHeader);
            OnTestDeleteHeaderOnAfterServiceShptHeaderTransferFields(ServiceShptHeader, ServiceHeader);
            ServiceShptHeader."No." := ServiceHeader."Shipping No.";
            ServiceShptHeader."Posting Date" := Today;
            ServiceShptHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(ServiceShptHeader."User ID"));
            ServiceShptHeader."Source Code" := SourceCode.Code;
        end;

        if (ServiceHeader."Posting No. Series" <> '') and
           ((ServiceHeader."Document Type" in [ServiceHeader."Document Type"::Order, ServiceHeader."Document Type"::Invoice]) and
            (ServiceHeader."Posting No." <> '') or
            (ServiceHeader."Document Type" = ServiceHeader."Document Type"::Invoice) and
            (ServiceHeader."No. Series" = ServiceHeader."Posting No. Series"))
        then begin
            ServiceHeader.CalcFields("Work Description");
            ServiceInvHeader.TransferFields(ServiceHeader);
            OnTestDeleteHeaderOnAfterServiceInvHeaderTransferFields(ServiceInvHeader, ServiceHeader);
            if ServiceHeader."Posting No." <> '' then
                ServiceInvHeader."No." := ServiceHeader."Posting No.";
            if ServiceHeader."Document Type" = ServiceHeader."Document Type"::Invoice then begin
                ServiceInvHeader."Pre-Assigned No. Series" := ServiceHeader."No. Series";
                ServiceInvHeader."Pre-Assigned No." := ServiceHeader."No.";
            end else begin
                ServiceInvHeader."Pre-Assigned No. Series" := '';
                ServiceInvHeader."Pre-Assigned No." := '';
                ServiceInvHeader."Order No. Series" := ServiceHeader."No. Series";
                ServiceInvHeader."Order No." := ServiceHeader."No.";
            end;
            ServiceInvHeader."Posting Date" := Today;
            ServiceInvHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(ServiceInvHeader."User ID"));
            ServiceInvHeader."Source Code" := SourceCode.Code;
        end;

        if (ServiceHeader."Posting No. Series" <> '') and
           ((ServiceHeader."Document Type" in [ServiceHeader."Document Type"::"Credit Memo"]) and
            (ServiceHeader."Posting No." <> '') or
            (ServiceHeader."Document Type" = ServiceHeader."Document Type"::"Credit Memo") and
            (ServiceHeader."No. Series" = ServiceHeader."Posting No. Series"))
        then begin
            ServiceHeader.CalcFields("Work Description");
            ServiceCrMemoHeader.TransferFields(ServiceHeader);
            OnTestDeleteHeaderOnAfterServiceCrMemoHeaderTransferFields(ServiceCrMemoHeader, ServiceHeader);
            if ServiceHeader."Posting No." <> '' then
                ServiceCrMemoHeader."No." := ServiceHeader."Posting No.";
            ServiceCrMemoHeader."Pre-Assigned No. Series" := ServiceHeader."No. Series";
            ServiceCrMemoHeader."Pre-Assigned No." := ServiceHeader."No.";
            ServiceCrMemoHeader."Posting Date" := Today;
            ServiceCrMemoHeader."User ID" := CopyStr(UserId(), 1, MaxStrLen(ServiceCrMemoHeader."User ID"));
            ServiceCrMemoHeader."Source Code" := SourceCode.Code;
        end;
    end;

    local procedure LockTables(var ServiceLine: Record "Service Line"; var GLEntry: Record "G/L Entry")
    var
        InvSetup: Record "Inventory Setup";
    begin
        ServiceLine.LockTable();

        if not InvSetup.OptimGLEntLockForMultiuserEnv() then begin
            GLEntry.LockTable();
            OnLockTablesOnBeforeGLEntryFindLast(GLEntry);
            GLEntry.GetLastEntryNo();
        end;
    end;

    procedure DeleteHeader(ServiceHeader: Record "Service Header"; var ServiceShptHeader: Record "Service Shipment Header"; var ServiceInvHeader: Record "Service Invoice Header"; var ServiceCrMemoHeader: Record "Service Cr.Memo Header")
    begin
        TestDeleteHeader(ServiceHeader, ServiceShptHeader, ServiceInvHeader, ServiceCrMemoHeader);
        if ServiceShptHeader."No." <> '' then begin
            OnBeforeServiceShptHeaderInsert(ServiceShptHeader, ServiceHeader);
            ServiceShptHeader.Insert();
            ServiceShptLine.Init();
            ServiceShptLine."Document No." := ServiceShptHeader."No.";
            ServiceShptLine."Line No." := 10000;
            ServiceShptLine.Description := SourceCode.Description;
            OnDeleteHeaderOnBeforeServiceShptLineInsert(ServiceHeader, ServiceShptHeader, ServiceShptLine);
            ServiceShptLine.Insert();
        end;

        if ServiceInvHeader."No." <> '' then begin
            OnBeforeServiceInvHeaderInsert(ServiceInvHeader, ServiceHeader);
            ServiceInvHeader.Insert();
            ServiceInvLine.Init();
            ServiceInvLine."Document No." := ServiceInvHeader."No.";
            ServiceInvLine."Line No." := 10000;
            ServiceInvLine.Description := SourceCode.Description;
            OnDeleteHeaderOnBeforeServiceInvLineInsert(ServiceHeader, ServiceInvHeader, ServiceInvLine);
            ServiceInvLine.Insert();
        end;

        if ServiceCrMemoHeader."No." <> '' then begin
            OnBeforeServiceCrMemoHeaderInsert(ServiceCrMemoHeader, ServiceHeader);
            ServiceCrMemoHeader.Insert();
            ServiceCrMemoLine.Init();
            ServiceCrMemoLine."Document No." := ServiceCrMemoHeader."No.";
            ServiceCrMemoLine."Line No." := 10000;
            ServiceCrMemoLine.Description := SourceCode.Description;
            OnDeleteHeaderOnBeforeServiceCrMemoLineInsert(ServiceHeader, ServiceCrMemoHeader, ServiceCrMemoLine);
            ServiceCrMemoLine.Insert();
        end;
        OnAfterDeleteHeader(ServiceHeader, ServiceShptHeader, ServiceInvHeader, ServiceCrMemoHeader);
    end;

    local procedure CollectWhseShipmentInformation(ServiceHeader: Record "Service Header")
    var
        WarehouseShipmentHeaderLocal: Record "Warehouse Shipment Header";
        WarehouseShipmentLineLocal: Record "Warehouse Shipment Line";
        ServiceLine: Record "Service Line";
    begin
        TempWarehouseShipmentHeader.DeleteAll();
        TempWarehouseShipmentLine.DeleteAll();
        ServiceLine.SetRange("Document Type", ServiceHeader."Document Type");
        ServiceLine.SetRange("Document No.", ServiceHeader."No.");
        ServiceLine.SetRange(Type, ServiceLine.Type::Item);
        ServiceLine.SetFilter("Qty. to Ship", '<>%1', 0);
        if not ServiceLine.FindSet() then
            exit;
        WarehouseShipmentLineLocal.SetCurrentKey("Source Type", "Source Subtype", "Source No.", "Source Line No.");
        WarehouseShipmentLineLocal.SetRange("Source Type", DATABASE::"Service Line");
        WarehouseShipmentLineLocal.SetRange("Source Subtype", ServiceHeader."Document Type");
        WarehouseShipmentLineLocal.SetRange("Source No.", ServiceHeader."No.");
        repeat
            WarehouseShipmentLineLocal.SetRange("Source Line No.", ServiceLine."Line No.");
            if WarehouseShipmentLineLocal.FindSet() then
                repeat
                    if WarehouseShipmentLineLocal."Qty. to Ship" <> 0 then begin
                        TempWarehouseShipmentLine := WarehouseShipmentLineLocal;
                        TempWarehouseShipmentLine.Insert();
                        WarehouseShipmentHeaderLocal.Get(WarehouseShipmentLineLocal."No.");
                        TempWarehouseShipmentHeader := WarehouseShipmentHeaderLocal;
                        if TempWarehouseShipmentHeader.Insert() then;
                    end;
                until WarehouseShipmentLineLocal.Next() = 0;
        until ServiceLine.Next() = 0;
    end;

    local procedure TestServLinePostingDate(ServHeaderDocType: Enum "Service Document Type"; ServHeaderNo: Code[20]; JnlTemplateName: Code[10])
    var
        ServLine: Record "Service Line";
        GenJnlCheckLine: Codeunit "Gen. Jnl.-Check Line";
    begin
        ServLine.SetRange("Document Type", ServHeaderDocType);
        ServLine.SetRange("Document No.", ServHeaderNo);
        ServLine.SetFilter(Type, '<>%1', ServLine.Type::" ");
        if ServLine.FindSet() then
            repeat
                if GenJnlCheckLine.DateNotAllowed(ServLine."Posting Date", JnlTemplateName) then
                    ServLine.FieldError("Posting Date", ErrorInfo.Create(Text007, true));
            until ServLine.Next() = 0;
    end;

    procedure SetPreviewMode(NewPreviewMode: Boolean)
    begin
        PreviewMode := NewPreviewMode;
    end;

    procedure GetPostedDocumentRecord(ServiceHeader: Record "Service Header"; var PostedServiceDocumentVariant: Variant)
    var
        ServiceInvHeader: Record "Service Invoice Header";
        ServiceCrMemoHeader: Record "Service Cr.Memo Header";
    begin
        case ServiceHeader."Document Type" of
            ServiceHeader."Document Type"::Order:
                if Invoice then begin
                    ServiceInvHeader.Get(ServiceHeader."Last Posting No.");
                    ServiceInvHeader.SetRecFilter();
                    PostedServiceDocumentVariant := ServiceInvHeader;
                end;
            ServiceHeader."Document Type"::Invoice:
                begin
                    if ServiceHeader."Last Posting No." = '' then
                        ServiceInvHeader.Get(ServiceHeader."No.")
                    else
                        ServiceInvHeader.Get(ServiceHeader."Last Posting No.");

                    ServiceInvHeader.SetRecFilter();
                    PostedServiceDocumentVariant := ServiceInvHeader;
                end;
            ServiceHeader."Document Type"::"Credit Memo":
                begin
                    if ServiceHeader."Last Posting No." = '' then
                        ServiceCrMemoHeader.Get(ServiceHeader."No.")
                    else
                        ServiceCrMemoHeader.Get(ServiceHeader."Last Posting No.");
                    ServiceCrMemoHeader.SetRecFilter();
                    PostedServiceDocumentVariant := ServiceCrMemoHeader;
                end;
            else
                Error(NotSupportedDocumentTypeErr, ServiceHeader."Document Type");
        end;
    end;

    procedure SendPostedDocumentRecord(ServiceHeader: Record "Service Header"; var DocumentSendingProfile: Record "Document Sending Profile")
    var
        ServiceInvHeader: Record "Service Invoice Header";
        ServiceCrMemoHeader: Record "Service Cr.Memo Header";
    begin
        case ServiceHeader."Document Type" of
            ServiceHeader."Document Type"::Order:
                if Invoice then begin
                    ServiceInvHeader.Get(ServiceHeader."Last Posting No.");
                    ServiceInvHeader.SetRecFilter();
                    ServiceInvHeader.SendProfile(DocumentSendingProfile);
                end;
            ServiceHeader."Document Type"::Invoice:
                begin
                    if ServiceHeader."Last Posting No." = '' then
                        ServiceInvHeader.Get(ServiceHeader."No.")
                    else
                        ServiceInvHeader.Get(ServiceHeader."Last Posting No.");

                    ServiceInvHeader.SetRecFilter();
                    ServiceInvHeader.SendProfile(DocumentSendingProfile);
                end;
            ServiceHeader."Document Type"::"Credit Memo":
                begin
                    if ServiceHeader."Last Posting No." = '' then
                        ServiceCrMemoHeader.Get(ServiceHeader."No.")
                    else
                        ServiceCrMemoHeader.Get(ServiceHeader."Last Posting No.");
                    ServiceCrMemoHeader.SetRecFilter();
                    ServiceCrMemoHeader.SendProfile(DocumentSendingProfile);
                end;
            else
                Error(NotSupportedDocumentTypeErr, ServiceHeader."Document Type");
        end;
    end;

    [IntegrationEvent(true, false)]
    local procedure OnAfterFinalizePostingOnBeforeCommit(var ServiceHeader: Record "Service Header"; var ServiceLine: Record "Service Line"; var ServDocumentsMgt: Codeunit "Serv-Documents Mgt."; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean; ServInvoiceNo: Code[20]; ServCrMemoNo: Code[20]; ServShipmentNo: Code[20])
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnAfterInitialize(var ServiceHeader: Record "Service Header"; var ServiceLine: Record "Service Line")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnAfterPostServiceDoc(var ServiceHeader: Record "Service Header"; ServShipmentNo: Code[20]; ServInvoiceNo: Code[20]; ServCrMemoNo: Code[20]; var ServDocumentsMgt: Codeunit "Serv-Documents Mgt."; CommitIsSuppressed: Boolean; PassedShip: Boolean; PassedConsume: Boolean; PassedInvoice: Boolean; WhseShip: Boolean; Invoice: Boolean)
    begin
    end;

#pragma warning disable AS0077
    [IntegrationEvent(false, false)]
    local procedure OnAfterPostWithLines(var PassedServiceHeader: Record "Service Header"; var IsHandled: Boolean)
    begin
    end;
#pragma warning restore AS0077

    [IntegrationEvent(false, false)]
    local procedure OnAfterValidatePostingAndDocumentDate(var ServiceHeader: Record "Service Header"; PreviewMode: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnValidatePostingAndDocumentDateOnAfterValidateDocumentDate(var ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeCheckAndSetPostingConstants(var ServiceHeader: Record "Service Header"; var ServDocumentsMgt: Codeunit "Serv-Documents Mgt."; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean; var IsHandled: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeCreatePostedWhseShptHeader(var PostedWhseShipmentHeader: Record "Posted Whse. Shipment Header"; WarehouseShipmentHeader: Record "Warehouse Shipment Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeInitialize(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line"; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean; PreviewMode: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforePostWithLines(var PassedServHeader: Record "Service Header"; var PassedServLine: Record "Service Line"; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean; var PostingDateExists: Boolean; var HideValidationDialog: Boolean; var IsHandled: Boolean; PreviewMode: Boolean; ReplacePostingDate: Boolean; PostingDate: Date; ReplaceDocumentDate: Boolean; SuppressCommit: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeRun(var ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeSetPostingDate(var PostingDateExists: Boolean; var ReplacePostingDate: Boolean; var ReplaceDocumentDate: Boolean; var PostingDate: Date; var IsHandled: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeServiceShptHeaderInsert(var ServiceShipmentHeader: Record "Service Shipment Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeServiceInvHeaderInsert(var ServiceInvoiceHeader: Record "Service Invoice Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeServiceCrMemoHeaderInsert(var ServiceCrMemoHeader: Record "Service Cr.Memo Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeTestMandatoryFields(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line"; var Invoice: Boolean; var IsHandled: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeUpdateWhseDocuments(var WarehouseShipmentHeader: Record "Warehouse Shipment Header"; var IsHandled: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnDeleteHeaderOnBeforeServiceShptLineInsert(var ServiceHeader: Record "Service Header"; var ServiceShipmentHeader: Record "Service Shipment Header"; var ServiceShipmentLine: Record "Service Shipment Line")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnDeleteHeaderOnBeforeServiceInvLineInsert(var ServiceHeader: Record "Service Header"; var ServiceInvoiceHeader: Record "Service Invoice Header"; var ServiceInvoiceLine: Record "Service Invoice Line")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnDeleteHeaderOnBeforeServiceCrMemoLineInsert(var ServiceHeader: Record "Service Header"; var ServiceCrMemoHeader: Record "Service Cr.Memo Header"; var ServiceCrMemoLine: Record "Service Cr.Memo Line")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnLockTablesOnBeforeGLEntryFindLast(var GLEntry: Record "G/L Entry")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnTestDeleteHeaderOnAfterServiceShptHeaderTransferFields(var ServiceShipmentHeader: Record "Service Shipment Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnTestDeleteHeaderOnAfterServiceInvHeaderTransferFields(var ServiceInvoiceHeader: Record "Service Invoice Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnTestDeleteHeaderOnAfterServiceCrMemoHeaderTransferFields(var ServiceCrMemoHeader: Record "Service Cr.Memo Header"; ServiceHeader: Record "Service Header")
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnInitializeOnAfterCheckAndSetPostingConstants(var PassedServiceHeader: Record "Service Header"; var PassedServiceLine: Record "Service Line"; var PassedShip: Boolean; var PassedConsume: Boolean; var PassedInvoice: Boolean; PreviewMode: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnAfterDeleteHeader(var ServiceHeader: Record "Service Header"; var ServiceShipmentHeader: Record "Service Shipment Header"; var ServiceInvoiceHeader: Record "Service Invoice Header"; var ServiceCrMemoHeader: Record "Service Cr.Memo Header");
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeValidatePostingAndDocumentDate(var ServiceHeader: Record "Service Header"; var PostingDateExists: Boolean; var ReplacePostingDate: Boolean; var ReplaceDocumentDate: Boolean; var PostingDate: Date)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnBeforeCheckDateNotAllowedForServiceLine(var PassedServiceLine: Record "Service Line"; var IsHandled: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnCheckAndSetConstantsOnBeforeSetPostingOptions(var ServiceHeader: Record "Service Header"; Invoice: Boolean; Ship: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnSetCommitBehavior(var IgnoreCommit: Boolean)
    begin
    end;

    [IntegrationEvent(false, false)]
    local procedure OnPostDocumentLinesOnBeforeInsertPostedHeaders(var ServiceHeader: Record "Service Header"; var ServDocumentsMgt: Codeunit "Serv-Documents Mgt."; var IsHandled: Boolean; var ServInvoiceNo: Code[20]; var ServCrMemoNo: Code[20])
    begin
    end;
}