Codeunit 5940 ServContractManagement

Base Application, Microsoft.Service.Contract

src/Layers/W1/BaseApp/Service/Contract/ServContractManagement.Codeunit.al3,233 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.Service.Contract;using Microsoft.CRM.Team;using Microsoft.Finance.Currency;using Microsoft.Finance.Dimension;using Microsoft.Finance.GeneralLedger.Account;using Microsoft.Finance.GeneralLedger.Journal;using Microsoft.Finance.GeneralLedger.Setup;using Microsoft.Foundation.AuditCodes;using Microsoft.Foundation.ExtendedText;using Microsoft.Foundation.NoSeries;using Microsoft.Inventory.Item;using Microsoft.Inventory.Location;using Microsoft.Sales.Customer;using Microsoft.Service.Document;using Microsoft.Service.Item;using Microsoft.Service.Ledger;using Microsoft.Service.Setup;using Microsoft.Utilities;using System.Reflection;using System.Security.User;using System.Utilities;codeunit 5940 ServContractManagement{    Permissions = TableData "Service Ledger Entry" = rimd,                  TableData "Warranty Ledger Entry" = rimd,                  TableData "Service Register" = rimd,                  TableData "Contract Change Log" = rimd,                  TableData "Contract Gain/Loss Entry" = rimd;    TableNo = "Service Contract Header";    trigger OnRun()    begin    end;    var        GLAcc: Record "G/L Account";        ServLine: Record "Service Line";        ServMgtSetup: Record "Service Mgt. Setup";        ServLedgEntry: Record "Service Ledger Entry";        ServLedgEntry2: Record "Service Ledger Entry";        TempServLedgEntry: Record "Service Ledger Entry" temporary;        ServiceRegister: Record "Service Register";        GenJournalTemplate: Record "Gen. Journal Template";        Salesperson: Record "Salesperson/Purchaser";        DimMgt: Codeunit DimensionManagement;        NextLine: Integer;        PostingDate: Date;        WDate: Date;        ServLineNo: Integer;        NextEntryNo: Integer;        PrevEntryNo: Integer;        AppliedEntryNo: Integer;        AmountType: Option ,Amount,DiscAmount,UnitPrice,UnitCost;        TempServLedgEntriesIsSet: Boolean;#pragma warning disable AA0074#pragma warning disable AA0470        Text000: Label '%1 cannot be created for service contract  %2, because %3 and %4 are not equal.';        Text002: Label 'Service Contract: %1';        Text003: Label 'Service contract line(s) included in:';        Text004: Label 'A credit memo cannot be created, because the %1 %2 is after the work date.';        Text005: Label '%1 %2 removed';        Text006: Label 'Do you want to create a service invoice for the period %1 .. %2 ?';        InvoiceCannotBeCreatedZeroAmountErr: Label 'Invoice cannot be created because amount to invoice for this invoice period is zero.';        Text008: Label 'The combination of dimensions used in %1 %2 is blocked. %3';        Text009: Label 'The dimensions used in %1 %2 are invalid. %3';        InvoicingStartingPeriod: Boolean;        Text010: Label 'You cannot create an invoice for contract %1 before the service under this contract is completed because the %2 check box is selected.';        MustFillNewCustomerNoErr: Label 'You must fill in the New Customer No. field.';        Text013: Label '%1 cannot be created because the %2 is too long. Please shorten the %3 %4 %5 by removing %6 character(s).';        TempServLineDescription: Text[250];        Text014: Label 'A %1 cannot be created because %2 %3 has at least one unposted %4 linked to it.';        Text015: Label '%1 %2 for the existing %3 %4 for %5 %6 differs from the newly calculated %1 %7. Do you want to use the existing %1?', Comment = 'Location Code SILVER for the existing Service Credit Memo 1001 for Service Contract 1002 differs from the newly calculated Location Code BLUE. Do you want to use the existing Location Code?';        AppliedGLAccount: Code[20];        CheckMParts: Boolean;        CombinedCurrenciesErr1: Label 'Customer %1 has service contracts with different currency codes %2 and %3, which cannot be combined on one invoice.';        CombinedCurrenciesErr2: Label 'Limit the Create Contract Invoices batch job to certain currency codes or clear the Combine Invoices field on the involved service contracts.';        BlankTxt: Label '<blank>';        ErrorSplitErr: Label '%1\\%2.';#pragma warning restore AA0074#pragma warning restore AA0470    procedure CreateInvoice(ServiceContractHeader: Record "Service Contract Header") InvNo: Code[20]    var        InvoicedAmount: Decimal;        InvoiceFromDate: Date;        InvoiceToDate: Date;    begin        OnBeforeCreateInvoice(ServiceContractHeader);        ServiceContractHeader.TestField("Change Status", ServiceContractHeader."Change Status"::Locked);        GetNextInvoicePeriod(ServiceContractHeader, InvoiceFromDate, InvoiceToDate);        CreateInvoiceSetPostingDate(ServiceContractHeader, InvoiceFromDate, InvoiceToDate, PostingDate);        InvoicedAmount := CalcContractAmount(ServiceContractHeader, InvoiceFromDate, InvoiceToDate);        if InvoicedAmount = 0 then            Error(InvoiceCannotBeCreatedZeroAmountErr);        InvNo := CreateRemainingPeriodInvoice(ServiceContractHeader);        if InvNo = '' then            InvNo := CreateServHeader(ServiceContractHeader, PostingDate, false);        if InvoicingStartingPeriod then begin            GetNextInvoicePeriod(ServiceContractHeader, InvoiceFromDate, InvoiceToDate);            PostingDate := InvoiceFromDate;            InvoicedAmount := CalcContractAmount(ServiceContractHeader, InvoiceFromDate, InvoiceToDate);        end;        if not CheckIfServiceExist(ServiceContractHeader) then            Error(              Text010,              ServiceContractHeader."Contract No.",              ServiceContractHeader.FieldCaption("Invoice after Service"));        OnCreateInvoiceOnBeforeCreateAllServLines(ServiceContractHeader, InvoiceFromDate, InvoiceToDate, InvoicedAmount, PostingDate, InvoicingStartingPeriod, InvNo);        CreateAllServLines(InvNo, ServiceContractHeader);        OnAfterCreateInvoice(ServiceContractHeader, PostingDate);    end;    local procedure CreateInvoiceSetPostingDate(ServiceContractHeader: Record "Service Contract Header"; InvoiceFromDate: Date; InvoiceToDate: Date; var PostingDate2: Date)    begin        if ServiceContractHeader.Prepaid then            PostingDate2 := InvoiceFromDate        else            PostingDate2 := InvoiceToDate;        OnAfterCreateInvoiceSetPostingDate(ServiceContractHeader, InvoiceFromDate, InvoiceToDate, PostingDate);    end;    procedure CreateServiceLedgEntry(ServHeader2: Record "Service Header"; ContractType: Enum "Service Contract Type"; ContractNo: Code[20]; InvFromDate: Date; InvToDate: Date; SigningContract: Boolean; AddingNewLines: Boolean; LineNo: Integer) ReturnLedgerEntry: Integer    var        ServContractLine: Record "Service Contract Line";        ServContractHeader: Record "Service Contract Header";        Currency: Record Currency;        LastEntry: Integer;        FirstLineEntry: Integer;        NoOfPayments: Integer;        DueDate: Date;        Days: Integer;        InvToDate2: Date;        LineInvFrom: Date;        PartInvFrom: Date;        PartInvTo: Date;        NewInvFrom: Date;        NextInvDate: Date;        ProcessSigningSLECreation: Boolean;        NonDistrAmount: array[4] of Decimal;        InvAmount: array[4] of Decimal;        InvRoundedAmount: array[4] of Decimal;        CountOfEntryLoop: Integer;        YearContractCorrection: Boolean;        ServiceContractHeaderFound: Boolean;        DateExpression: Text;        IsHandled: Boolean;    begin        ServiceContractHeaderFound := ServContractHeader.Get(ContractType, ContractNo);        if not ServiceContractHeaderFound or (ServContractHeader."Invoice Period" = ServContractHeader."Invoice Period"::None) then            exit;        ServContractHeader.CalcFields("Calcd. Annual Amount");        CheckServiceContractHeaderAmts(ServContractHeader);        Currency.InitRoundingPrecision();        ReturnLedgerEntry := NextEntryNo;        Clear(ServLedgEntry);        InitServLedgEntry(ServLedgEntry, ServContractHeader, ServHeader2."No.");        OnCreateServiceLedgerEntryOnAfterInitServLedgEntry(            ServLedgEntry, ServContractHeader, ContractType.AsInteger(), ContractNo, LineNo);        Clear(NonDistrAmount);        Clear(InvAmount);        Clear(InvRoundedAmount);        if ServContractHeader.Prepaid and not SigningContract then begin            ServLedgEntry."Moved from Prepaid Acc." := false;            FirstLineEntry := NextEntryNo;            FilterServiceContractLine(              ServContractLine, ServContractHeader."Contract No.", ServContractHeader."Contract Type", LineNo);            if AddingNewLines then                ServContractLine.SetRange("New Line", true)            else                ServContractLine.SetFilter("Starting Date", '<=%1|%2..%3', ServContractHeader."Next Invoice Date",                  ServContractHeader."Next Invoice Period Start", ServContractHeader."Next Invoice Period End");            OnCreateServiceLedgEntryOnPrepaidOnAfterServContractLineSetFilters(ServContractLine, AddingNewLines);            if ServContractLine.Find('-') then begin                repeat                    YearContractCorrection := false;                    Days := 0;                    WDate := CalcDate('<-CM>', InvFromDate);                    DateExpression := '<1M>';                    OnCreateServiceLedgerEntryOnBeforeLoopPeriods(                        ServContractHeader, ServContractLine, InvFromDate, WDate, DateExpression);                    if (InvFromDate <= ServContractLine."Contract Expiration Date") or                       (ServContractLine."Contract Expiration Date" = 0D)                    then begin                        NoOfPayments := 0;                        repeat                            NoOfPayments := NoOfPayments + 1;                            WDate := CalcDate(DateExpression, WDate);                            OnCreateServiceLedgEntryOnAfterWDateLoop(ServContractHeader, WDate);                        until (WDate > InvToDate) or                              ((WDate > ServContractLine."Contract Expiration Date") and                               (ServContractLine."Contract Expiration Date" <> 0D));                        CountOfEntryLoop := NoOfPayments;                        OnCreateServiceLedgerEntryOnBeforeCheckServContractLineStartingDate(ServContractHeader, CountOfEntryLoop);                        // Partial period ranged by "Starting Date" and end of month. Full period is shifted by one month                        if ServContractLine."Starting Date" > InvFromDate then begin                            Days := CalcDate('<CM>', InvFromDate) - ServContractLine."Starting Date";                            PartInvFrom := ServContractLine."Starting Date";                            PartInvTo := CalcDate('<CM>', InvFromDate);                            InvFromDate := PartInvFrom;                            NewInvFrom := CalcDate('<CM+1D>', InvFromDate);                            CountOfEntryLoop := CountOfEntryLoop - 1;                            NoOfPayments := NoOfPayments - 1;                        end;                        if ServContractLine."Contract Expiration Date" <> 0D then                            if ServContractLine."Contract Expiration Date" <= WDate then                                if Days = 0 then begin                                    Days := Date2DMY(ServContractLine."Contract Expiration Date", 1);                                    CountOfEntryLoop := CountOfEntryLoop - 1;                                    PartInvFrom := CalcDate('<-CM>', ServContractLine."Contract Expiration Date");                                    PartInvTo := ServContractLine."Contract Expiration Date";                                end else                                    if ServContractLine."Contract Expiration Date" < PartInvTo then begin                                        // partial period ranged by "Starting Date" from the beginning and "Contract Expiration Date" from the end                                        PartInvTo := ServContractLine."Contract Expiration Date";                                        Days := PartInvTo - PartInvFrom;                                        CountOfEntryLoop := 0;                                    end else begin                                        // Post previous partial period before new one with Contract Expiration Date                                        PostPartialServLedgEntry(                                          InvRoundedAmount, ServContractLine, ServHeader2, PartInvFrom, PartInvTo,                                          ServContractHeader."Next Invoice Date", Currency."Amount Rounding Precision");                                        Days := Date2DMY(ServContractLine."Contract Expiration Date", 1);                                        CountOfEntryLoop := CountOfEntryLoop - 1;                                        NoOfPayments := NoOfPayments - 1;                                        PartInvFrom := CalcDate('<-CM>', ServContractLine."Contract Expiration Date");                                        PartInvTo := ServContractLine."Contract Expiration Date";                                    end;                        WDate := InvToDate;                        if (WDate > ServContractLine."Contract Expiration Date") and                           (ServContractLine."Contract Expiration Date" <> 0D)                        then                            WDate := ServContractLine."Contract Expiration Date";                        DueDate := WDate;                        // Calculate invoice amount for initial period and go ahead with shifted InvFrom                        OnCreateServiceLedgEntryOnPrepaidOnBeforeCalcInvAmounts(ServContractLine, ServLedgEntry);                        CalcInvAmounts(InvAmount, ServContractLine, InvFromDate, WDate);                        if NewInvFrom = 0D then                            NextInvDate := ServContractHeader."Next Invoice Date"                        else begin                            InvFromDate := NewInvFrom;                            NextInvDate := CalcDate('<1M>', ServContractHeader."Next Invoice Date");                        end;                        OnCreateServiceLedgerEntryOnBeforeInsertMultipleServLedgEntries(NextInvDate, ServContractHeader, ServContractLine, NoOfPayments, DueDate, InvFromDate, AddingNewLines, CountOfEntryLoop);                        InsertMultipleServLedgEntries(                          NoOfPayments, DueDate, NonDistrAmount, InvRoundedAmount, ServHeader2, InvFromDate, NextInvDate,                          AddingNewLines, CountOfEntryLoop, ServContractLine, Currency."Amount Rounding Precision");                        if Days = 0 then                            YearContractCorrection := false                        else                            YearContractCorrection :=                              PostPartialServLedgEntry(                                InvRoundedAmount, ServContractLine, ServHeader2,                                PartInvFrom, PartInvTo, PartInvFrom, Currency."Amount Rounding Precision");                        LastEntry := ServLedgEntry."Entry No.";                        CalcInvoicedToDate(ServContractLine, InvFromDate, InvToDate);                        ServContractLine.Modify();                    end else begin                        YearContractCorrection := false;                        ReturnLedgerEntry := 0;                    end;                until ServContractLine.Next() = 0;                UpdateApplyUntilEntryNoInServLedgEntry(ServContractHeader, SigningContract, ReturnLedgerEntry, FirstLineEntry, LastEntry);            end;        end else begin            YearContractCorrection := false;            ServLedgEntry."Moved from Prepaid Acc." := true;            if InvFromDate = InvToDate then                ServLedgEntry."Posting Date" := InvFromDate            else                ServLedgEntry."Posting Date" := ServHeader2."Posting Date";            FilterServiceContractLine(              ServContractLine, ServContractHeader."Contract No.", ServContractHeader."Contract Type", LineNo);            if AddingNewLines then                ServContractLine.SetRange("New Line", true)            else                if not SigningContract then begin                    if ServContractHeader."Last Invoice Date" <> 0D then                        ServContractLine.SetFilter("Invoiced to Date", '%1|%2', ServContractHeader."Last Invoice Date", 0D)                    else                        ServContractLine.SetRange("Invoiced to Date", 0D);                    ServContractLine.SetFilter("Starting Date", '<=%1|%2..%3', InvFromDate,                      ServContractHeader."Next Invoice Period Start", ServContractHeader."Next Invoice Period End");                end else                    ServContractLine.SetFilter("Starting Date", '<=%1', InvToDate);            FirstLineEntry := NextEntryNo;            InvToDate2 := InvToDate;            OnCreateServiceLedgEntryOnNotPrepaidOnAfterServContractLineSetFilters(ServContractLine, ServContractHeader, AddingNewLines);            if ServContractLine.Find('-') then begin                repeat                    if SigningContract then begin                        if ServContractLine."Invoiced to Date" = 0D then                            ProcessSigningSLECreation := true                        else                            if (ServContractLine."Invoiced to Date" <> 0D) and                               (ServContractLine."Invoiced to Date" <> CalcDate('<CM>', ServContractLine."Invoiced to Date"))                            then                                ProcessSigningSLECreation := true                    end else                        ProcessSigningSLECreation := true;                    if ((InvFromDate <= ServContractLine."Contract Expiration Date") or                        (ServContractLine."Contract Expiration Date" = 0D)) and ProcessSigningSLECreation                    then begin                        if (ServContractLine."Contract Expiration Date" >= InvFromDate) and                           (ServContractLine."Contract Expiration Date" < InvToDate)                        then                            InvToDate := ServContractLine."Contract Expiration Date";                        ServLedgEntry."Service Item No. (Serviced)" := ServContractLine."Service Item No.";                        ServLedgEntry."Item No. (Serviced)" := ServContractLine."Item No.";                        ServLedgEntry."Serial No. (Serviced)" := ServContractLine."Serial No.";                        OnCreateServiceLedgerEntryBeforeCountLineInvFrom(ServLedgEntry, ServContractLine);                        LineInvFrom := CountLineInvFrom(SigningContract, ServContractLine, InvFromDate);                        if (LineInvFrom <> 0D) and (LineInvFrom <= InvToDate) then begin                            UpdateServLedgEntryAmounts(ServContractLine, Currency, InvRoundedAmount, LineInvFrom, InvToDate);                            ServLedgEntry."Cost Amount" := ServLedgEntry."Unit Cost" * ServLedgEntry."Charged Qty.";                            UpdateServLedgEntryAmount(ServLedgEntry, ServHeader2);                            ServLedgEntry."Entry No." := NextEntryNo;                            CalcInvAmounts(InvAmount, ServContractLine, LineInvFrom, InvToDate);                            OnCreateServiceLedgerEntryOnBeforeServLedgEntryInsert(ServLedgEntry, ServContractHeader, ServContractLine);                            ServLedgEntry."Service Register No." := ServiceRegister."No.";                            ServLedgEntry.Insert();                            LastEntry := ServLedgEntry."Entry No.";                            PrevEntryNo := NextEntryNo;                            if ServMgtSetup.UseLegacyPosting() then                                NextEntryNo := NextEntryNo + 1                            else                                NextEntryNo := ServLedgEntry.GetNextEntryNo();                            InvToDate := InvToDate2;                        end else                            ReturnLedgerEntry := 0;                        CalcInvoicedToDate(ServContractLine, InvFromDate, InvToDate);                        ServContractLine.Modify();                    end else                        ReturnLedgerEntry := 0;                until ServContractLine.Next() = 0;                UpdateApplyUntilEntryNoInServLedgEntry(ServContractHeader, SigningContract, ReturnLedgerEntry, FirstLineEntry, LastEntry);            end;        end;        if ServLedgEntry.Get(LastEntry) and (not YearContractCorrection) then begin            IsHandled := false;            OnCreateServiceLedgEntryOnBeforeCalcCurrencyAmountRoundingPrecision(ServContractHeader, ServLedgEntry, InvRoundedAmount, InvAmount, AmountType, Currency, ServHeader2, IsHandled);            if not IsHandled then                ServLedgEntry."Amount (LCY)" := ServLedgEntry."Amount (LCY)" + InvRoundedAmount[AmountType::Amount] -                  Round(InvAmount[AmountType::Amount], Currency."Amount Rounding Precision");            ServLedgEntry."Unit Price" := ServLedgEntry."Unit Price" + InvRoundedAmount[AmountType::UnitPrice] -              Round(InvAmount[AmountType::UnitPrice], Currency."Unit-Amount Rounding Precision");            ServLedgEntry."Cost Amount" := ServLedgEntry."Cost Amount" + InvRoundedAmount[AmountType::UnitCost] -              Round(InvAmount[AmountType::UnitCost], Currency."Amount Rounding Precision");            SetServiceLedgerEntryUnitCost(ServLedgEntry);            ServLedgEntry."Contract Disc. Amount" :=              ServLedgEntry."Contract Disc. Amount" - InvRoundedAmount[AmountType::DiscAmount] +              Round(InvAmount[AmountType::DiscAmount], Currency."Amount Rounding Precision");            ServLedgEntry."Discount Amount" := ServLedgEntry."Contract Disc. Amount";            OnCreateServiceLedgEntryOnAfterSetDiscountAmount(ServContractHeader, ServLedgEntry, InvRoundedAmount, InvAmount, AmountType, Currency, ServHeader2);            CalcServLedgEntryDiscountPct(ServLedgEntry);            UpdateServLedgEntryAmount(ServLedgEntry, ServHeader2);            ServLedgEntry.Modify();        end;    end;    procedure UpdateServLedgEntryAmounts(var ServContractLine: Record "Service Contract Line"; var Currency: Record Currency; var InvRoundedAmount: array[4] of Decimal; LineInvFrom: Date; InvTo: Date)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateServLedgEntryAmounts(ServContractLine, ServLedgEntry, InvRoundedAmount, LineInvFrom, InvTo, IsHandled);        if IsHandled then            exit;        SetServLedgEntryAmounts(          ServLedgEntry, InvRoundedAmount,          -CalcContractLineAmount(ServContractLine."Line Amount", LineInvFrom, InvTo),          -CalcContractLineAmount(ServContractLine."Line Value", LineInvFrom, InvTo),          CalcContractLineAmount(ServContractLine."Line Cost", LineInvFrom, InvTo),          CalcContractLineAmount(ServContractLine."Line Discount Amount", LineInvFrom, InvTo),          Currency."Amount Rounding Precision");    end;    procedure CalcServLedgEntryDiscountPct(var ServiceLedgerEntry: Record "Service Ledger Entry")    var        IsHandled: Boolean;    begin        OnBeforeCalcServLedgEntryDiscountPct(ServiceLedgerEntry, IsHandled);        if IsHandled then            exit;        ServiceLedgerEntry."Discount %" := 0;        if ServiceLedgerEntry."Unit Price" <> 0 then            ServiceLedgerEntry."Discount %" :=              -Round(ServiceLedgerEntry."Discount Amount" / ServiceLedgerEntry."Unit Price" * 100, 0.00001);    end;    procedure CreateServHeader(ServContract2: Record "Service Contract Header"; PostDate: Date; ContractExists: Boolean) ServInvNo: Code[20]    var        ServHeader2: Record "Service Header";        Cust: Record Customer;        ServDocReg: Record "Service Document Register";        CurrExchRate: Record "Currency Exchange Rate";        GLSetup: Record "General Ledger Setup";        Cust2: Record Customer;        UserMgt: Codeunit "User Setup Management";        RecordLinkManagement: Codeunit "Record Link Management";        NoSeries: Codeunit "No. Series";        IsHandled: Boolean;    begin        if ServContract2."Invoice Period" = ServContract2."Invoice Period"::None then            exit;        if PostDate = 0D then            PostDate := WorkDate();        Clear(ServHeader2);        ServHeader2.Init();        ServHeader2.SetHideValidationDialog(true);        ServHeader2."Document Type" := ServHeader2."Document Type"::Invoice;        ServMgtSetup.Get();        GLSetup.Get();        if GLSetup."Journal Templ. Name Mandatory" then begin            ServMgtSetup.TestField("Serv. Contr. Inv. Templ. Name");            GenJournalTemplate.Get(ServMgtSetup."Serv. Contr. Inv. Templ. Name");            GenJournalTemplate.TestField("Posting No. Series");            ServHeader2."Posting No. Series" := GenJournalTemplate."Posting No. Series";            ServHeader2."Journal Templ. Name" := ServMgtSetup."Serv. Contr. Inv. Templ. Name";        end;        ServMgtSetup.TestField("Contract Invoice Nos.");        IsHandled := false;        OnCreateServHeaderOnBeforeInitSeries(ServHeader2, ServMgtSetup, ServContract2, IsHandled);        if not IsHandled then begin            ServHeader2."No. Series" := ServMgtSetup."Contract Invoice Nos.";            ServHeader2."No." := NoSeries.GetNextNo(ServHeader2."No. Series", PostDate);        end;        InsertServiceHeader(ServHeader2, ServContract2);        ServInvNo := ServHeader2."No.";        ServHeader2."Order Date" := WorkDate();        ServHeader2."Posting Description" :=          Format(ServHeader2."Document Type") + ' ' + ServHeader2."No.";        ServHeader2.Validate("Bill-to Customer No.", ServContract2."Bill-to Customer No.");        ServHeader2."Prices Including VAT" := false;        ServHeader2."Customer No." := ServContract2."Customer No.";        ServHeader2.Validate("Ship-to Code", ServContract2."Ship-to Code");        Cust.Get(ServHeader2."Customer No.");        ServHeader2."Responsibility Center" := ServContract2."Responsibility Center";        IsHandled := false;        OnCreateServHeaderOnBeforeCheckBlockedCustOnDocs(ServHeader2, ServContract2, IsHandled);        if not IsHandled then            Cust.CheckBlockedCustOnDocs(Cust, ServHeader2."Document Type", false, false);        if CheckCustomerBusPostingGroup() then            Cust.TestField("Gen. Bus. Posting Group");        ServHeader2.Name := Cust.Name;        ServHeader2."Name 2" := Cust."Name 2";        ServHeader2.Address := Cust.Address;        ServHeader2."Address 2" := Cust."Address 2";        ServHeader2.City := Cust.City;        ServHeader2."Post Code" := Cust."Post Code";        ServHeader2.County := Cust.County;        ServHeader2."Country/Region Code" := Cust."Country/Region Code";        ServHeader2."Contact Name" := ServContract2."Contact Name";        ServHeader2."Contact No." := ServContract2."Contact No.";        ServHeader2."Bill-to Contact No." := ServContract2."Bill-to Contact No.";        ServHeader2."Bill-to Contact" := ServContract2."Bill-to Contact";        ServHeader2."Tax Area Code" := Cust."Tax Area Code";        ServHeader2."Tax Liable" := Cust."Tax Liable";        OnCreateServHeaderOnAfterCopyFromCustomer(ServHeader2, ServContract2, Cust);        if not ContractExists then            if ServHeader2."Customer No." = ServContract2."Customer No." then                ServHeader2.Validate("Ship-to Code", ServContract2."Ship-to Code");        ServHeader2.Validate("Posting Date", PostDate);        ServHeader2.Validate("Document Date", PostDate);        ServHeader2."Contract No." := ServContract2."Contract No.";        GLSetup.Get();        if GLSetup."Bill-to/Sell-to VAT Calc." = GLSetup."Bill-to/Sell-to VAT Calc."::"Bill-to/Pay-to No." then begin            Cust2.Get(ServContract2."Bill-to Customer No.");            ServHeader2."VAT Bus. Posting Group" := Cust2."VAT Bus. Posting Group";            ServHeader2."VAT Registration No." := Cust2."VAT Registration No.";            ServHeader2."VAT Country/Region Code" := Cust2."Country/Region Code";            ServHeader2."Gen. Bus. Posting Group" := Cust2."Gen. Bus. Posting Group";        end else begin            ServHeader2."VAT Bus. Posting Group" := Cust."VAT Bus. Posting Group";            ServHeader2."VAT Registration No." := Cust."VAT Registration No.";            ServHeader2."VAT Country/Region Code" := Cust."Country/Region Code";            ServHeader2."Gen. Bus. Posting Group" := Cust."Gen. Bus. Posting Group";        end;        ServHeader2."Currency Code" := ServContract2."Currency Code";        OnCreateServHeaderOnBeforeCalcCurrencyFactor(ServHeader2, CurrExchRate);        ServHeader2."Currency Factor" :=          CurrExchRate.ExchangeRate(            ServHeader2."Posting Date", ServHeader2."Currency Code");        ServHeader2.Validate("Payment Terms Code", ServContract2."Payment Terms Code");        ServHeader2.Validate("Payment Method Code", ServContract2."Payment Method Code");        if ServContract2."Direct Debit Mandate ID" <> '' then            ServHeader2.Validate("Direct Debit Mandate ID", ServContract2."Direct Debit Mandate ID");        ServHeader2."Your Reference" := ServContract2."Your Reference";        SetSalespersonCode(ServContract2."Salesperson Code", ServHeader2."Salesperson Code");        ServHeader2.Validate("Location Code",          UserMgt.GetLocation(2, Cust."Location Code", ServContract2."Responsibility Center"));        ServHeader2."Shortcut Dimension 1 Code" := ServContract2."Shortcut Dimension 1 Code";        ServHeader2."Shortcut Dimension 2 Code" := ServContract2."Shortcut Dimension 2 Code";        ServHeader2."Dimension Set ID" := ServContract2."Dimension Set ID";        OnBeforeServHeaderModify(ServHeader2, ServContract2);        ServHeader2.Modify();        RecordLinkManagement.CopyLinks(ServContract2, ServHeader2);        Clear(ServDocReg);        ServDocReg.InsertServiceSalesDocument(          ServDocReg."Source Document Type"::Contract, ServContract2."Contract No.",          ServDocReg."Destination Document Type"::Invoice, ServHeader2."No.");        OnAfterCreateServHeader(ServHeader2, ServContract2);    end;    local procedure InsertServiceHeader(var ServiceHeader: Record "Service Header"; var ServiceContractHeader: Record "Service Contract Header")    begin        OnBeforeInsertServiceHeader(ServiceHeader, ServiceContractHeader);        ServiceHeader.Insert(true);        OnAfterInsertServiceHeader(ServiceHeader, ServiceContractHeader);    end;    procedure CreateServiceLine(ServHeader: Record "Service Header"; ContractType: Enum "Service Contract Type"; ContractNo: Code[20]; InvFromDate: Date; InvToDate: Date; ServiceApplyEntry: Integer; SignningContract: Boolean)    var        ServContractHeader: Record "Service Contract Header";        ServDocReg: Record "Service Document Register";        ServiceLedgerEntry: Record "Service Ledger Entry";        TotalServLine: Record "Service Line";        TotalServLineLCY: Record "Service Line";        ServContractAccGr: Record "Service Contract Account Group";        IsHandled: Boolean;        LatestInvToDate: Date;    begin        IsHandled := false;        OnBeforeCreateServiceLine(ServHeader, ContractType, ContractNo, InvFromDate, InvToDate, ServiceApplyEntry, SignningContract, IsHandled);        if IsHandled then            exit;        ServContractHeader.Get(ContractType, ContractNo);        if ServContractHeader."Invoice Period" = ServContractHeader."Invoice Period"::None then            exit;        ServLineNo := 0;        ServLine.Reset();        ServLine.SetRange("Document Type", ServLine."Document Type"::Invoice);        ServLine.SetRange("Document No.", ServHeader."No.");        if ServLine.FindLast() then            ServLineNo := ServLine."Line No.";        if ServContractHeader.Prepaid and not SignningContract then begin            ServContractHeader.TestField("Serv. Contract Acc. Gr. Code");            ServContractAccGr.Get(ServContractHeader."Serv. Contract Acc. Gr. Code");            ServContractAccGr.TestField("Prepaid Contract Acc.");            GLAcc.Get(ServContractAccGr."Prepaid Contract Acc.");            GLAcc.TestField("Direct Posting");        end else begin            ServContractHeader.TestField("Serv. Contract Acc. Gr. Code");            ServContractAccGr.Get(ServContractHeader."Serv. Contract Acc. Gr. Code");            ServContractAccGr.TestField("Non-Prepaid Contract Acc.");            GLAcc.Get(ServContractAccGr."Non-Prepaid Contract Acc.");            GLAcc.TestField("Direct Posting");        end;        AppliedGLAccount := GLAcc."No.";        LatestInvToDate := InvToDate;        if ServiceLedgerEntry.Get(ServiceApplyEntry) then begin            ServiceLedgerEntry.SetRange("Entry No.", ServiceApplyEntry, ServiceLedgerEntry."Apply Until Entry No.");            if ServiceLedgerEntry.FindSet() then begin                repeat                    if ServiceLedgerEntry.Prepaid then begin                        InvFromDate := ServiceLedgerEntry."Posting Date";                        InvToDate := CalcDate('<CM>', InvFromDate);                        if InvToDate > LatestInvToDate then                            InvToDate := LatestInvToDate;                    end;                    OnCreateServiceLineOnBeforeServLedgEntryToServiceLine(ServHeader, ServContractHeader, ServiceLedgerEntry, InvFromDate, InvToDate);                    ServLedgEntryToServiceLine(                      TotalServLine,                      TotalServLineLCY,                      ServHeader,                      ServiceLedgerEntry,                      ContractNo,                      InvFromDate,                      InvToDate);                until ServiceLedgerEntry.Next() = 0;                OnCreateServiceLineOnAfterServLedgEntryToServiceLine(ServHeader, InvFromDate, InvToDate);            end;        end else begin            Clear(ServiceLedgerEntry);            OnCreateServiceLineOnBeforeServLedgEntryToServiceLine(ServHeader, ServContractHeader, ServiceLedgerEntry, InvFromDate, InvToDate);            ServLedgEntryToServiceLine(              TotalServLine,              TotalServLineLCY,              ServHeader,              ServiceLedgerEntry,              ContractNo,              InvFromDate,              InvToDate);        end;        Clear(ServDocReg);        ServDocReg.InsertServiceSalesDocument(          ServDocReg."Source Document Type"::Contract, ContractNo,          ServDocReg."Destination Document Type"::Invoice, ServLine."Document No.");    end;    procedure CreateDetailedServiceLine(ServHeader: Record "Service Header"; ServContractLine: Record "Service Contract Line"; ContractType: Enum "Service Contract Type"; ContractNo: Code[20])    var        ServContractHeader: Record "Service Contract Header";        Cust: Record Customer;        StdText: Record "Standard Text";        FirstLine: Boolean;        NewContract: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateDetailedServiceLine(ServHeader, IsHandled, ContractType, ContractNo);        if not IsHandled then begin            ServContractHeader.Get(ContractType, ContractNo);            if ServContractHeader."Invoice Period" = ServContractHeader."Invoice Period"::None then                exit;            ServLineNo := 0;            ServLine.SetRange("Document Type", ServLine."Document Type"::Invoice);            ServLine.SetRange("Document No.", ServHeader."No.");            if ServLine.FindLast() then begin                ServLineNo := ServLine."Line No.";                NewContract := ServLine."Contract No." <> ServContractHeader."Contract No.";                ServLine.Init();            end else begin                FirstLine := true;                NewContract := true;            end;            OnCreateDetailedServLineOnAfterSetFirstLineAndNewContract(FirstLine, NewContract, ServContractHeader);            Cust.Get(ServContractHeader."Bill-to Customer No.");            ServLine.Reset();            if FirstLine or NewContract then                ServMgtSetup.Get();            if FirstLine then begin                ServLine.Init();                ServLineNo := ServLineNo + 10000;                ServLine."Document Type" := ServHeader."Document Type";                ServLine."Document No." := ServHeader."No.";                ServLine."Line No." := ServLineNo;                ServLine.Type := ServLine.Type::" ";                if ServMgtSetup."Contract Line Inv. Text Code" <> '' then begin                    StdText.Get(ServMgtSetup."Contract Line Inv. Text Code");                    ServLine.Description := StdText.Description;                end else                    ServLine.Description := Text003;                OnCreateDetailedServLineOnBeforeServLineInsertFirstLine(ServLine, ServContractHeader);                ServLine.Insert();            end;            if NewContract then begin                OnBeforeCreateServLineForNewContract(ServHeader, ServContractHeader, ServLineNo);                ServLine.Init();                ServLineNo := ServLineNo + 10000;                ServLine."Document Type" := ServHeader."Document Type";                ServLine."Document No." := ServHeader."No.";                ServLine."Line No." := ServLineNo;                ServLine.Type := ServLine.Type::" ";                if ServMgtSetup."Contract Inv. Line Text Code" <> '' then begin                    StdText.Get(ServMgtSetup."Contract Inv. Line Text Code");                    TempServLineDescription := StrSubstNo('%1 %2', StdText.Description, ServContractHeader."Contract No.");                    if StrLen(TempServLineDescription) > MaxStrLen(ServLine.Description) then                        Error(                          Text013,                          ServLine.TableCaption(), ServLine.FieldCaption(Description),                          StdText.TableCaption(), StdText.Code, StdText.FieldCaption(Description),                          Format(StrLen(TempServLineDescription) - MaxStrLen(ServLine.Description)));                    ServLine.Description := CopyStr(TempServLineDescription, 1, MaxStrLen(ServLine.Description));                end else                    ServLine.Description := StrSubstNo(Text002, ServContractHeader."Contract No.");                OnCreateDetailedServLineOnBeforeServLineInsertNewContract(ServLine, ServContractHeader);                ServLine.Insert();            end;            OnCreateDetailedServLineOnBeforeCreateDescriptionServiceLines(ServContractHeader, ServContractLine, ServHeader);            CreateDescriptionServiceLines(ServContractLine."Service Item No.", ServContractLine.Description, ServContractLine."Serial No.");        end;        OnAfterCreateDetailedServiceLine(ServHeader, ServContractLine, NewContract, ServContractHeader, ServLineNo);    end;    procedure CreateLastServiceLines(ServHeader: Record "Service Header"; ContractType: Enum "Service Contract Type"; ContractNo: Code[20])    var        ServContractHeader: Record "Service Contract Header";        StdText: Record "Standard Text";        Cust: Record Customer;        ServiceTransferExtText: Codeunit "Service Transfer Ext. Text";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateLastServLines(ServHeader, ContractType.AsInteger(), ContractNo, IsHandled);        if IsHandled then            exit;        ServContractHeader.Get(ContractType, ContractNo);        if ServContractHeader."Invoice Period" = ServContractHeader."Invoice Period"::None then            exit;        Cust.Get(ServContractHeader."Bill-to Customer No.");        if ServContractHeader."Print Increase Text" then            if ServContractHeader."Price Inv. Increase Code" <> '' then                if StdText.Get(ServContractHeader."Price Inv. Increase Code") then begin                    ServLine.Init();                    ServLine."Document Type" := ServHeader."Document Type";                    ServLine."Document No." := ServHeader."No.";                    ServLine.Type := ServLine.Type::" ";                    ServLine."No." := ServContractHeader."Price Inv. Increase Code";                    ServLine."Contract No." := ContractNo;                    ServLine.Description := StdText.Description;                    if ServLine.Description <> '' then begin                        ServLineNo := ServLineNo + 10000;                        ServLine."Line No." := ServLineNo;                        ServLine.Insert();                        if ServiceTransferExtText.ServCheckIfAnyExtText(ServLine, true) then                            ServiceTransferExtText.InsertServExtText(ServLine);                        ServLine."No." := '';                        OnBeforeLastServLineModify(ServLine);                        ServLine.Modify();                    end;                end;    end;    local procedure CreateOrGetCreditHeader(ServContract: Record "Service Contract Header"; CrMemoDate: Date) ServInvoiceNo: Code[20]    var        GLSetup: Record "General Ledger Setup";        ServHeader2: Record "Service Header";        Cust: Record Customer;        ServDocReg: Record "Service Document Register";        CurrExchRate: Record "Currency Exchange Rate";        UserMgt: Codeunit "User Setup Management";        ConfirmManagement: Codeunit "Confirm Management";        NoSeries: Codeunit "No. Series";        CreditMemoForm: Page "Service Credit Memo";        ServContractForm: Page "Service Contract";        LocationCode: Code[10];        IsHandled: Boolean;    begin        Clear(ServHeader2);        ServDocReg.Reset();        ServDocReg.SetRange("Source Document Type", ServDocReg."Source Document Type"::Contract);        ServDocReg.SetRange("Source Document No.", ServContract."Contract No.");        ServDocReg.SetRange("Destination Document Type", ServDocReg."Destination Document Type"::"Credit Memo");        ServInvoiceNo := '';        if ServDocReg.Find('-') then            repeat                ServInvoiceNo := ServDocReg."Destination Document No.";            until (ServDocReg.Next() = 0) or (ServDocReg."Destination Document No." <> '');        if ServInvoiceNo <> '' then begin            ServHeader2.Get(ServHeader2."Document Type"::"Credit Memo", ServInvoiceNo);            Cust.Get(ServHeader2."Bill-to Customer No.");            LocationCode := UserMgt.GetLocation(2, Cust."Location Code", ServContract."Responsibility Center");            if ServHeader2."Location Code" <> LocationCode then                if not ConfirmManagement.GetResponseOrDefault(                     StrSubstNo(                       Text015,                       ServHeader2.FieldCaption("Location Code"),                       ServHeader2."Location Code",                       CreditMemoForm.Caption,                       ServInvoiceNo,                       ServContractForm.Caption,                       ServContract."Contract No.",                       LocationCode), true)                then                    Error('');            exit;        end;        Clear(ServHeader2);        ServHeader2.Init();        ServHeader2.SetHideValidationDialog(true);        ServHeader2."Document Type" := ServHeader2."Document Type"::"Credit Memo";        ServMgtSetup.Get();        GLSetup.Get();        if GLSetup."Journal Templ. Name Mandatory" then begin            ServMgtSetup.TestField("Serv. Contr. Cr.M. Templ. Name");            GenJournalTemplate.Get(ServMgtSetup."Serv. Contr. Cr.M. Templ. Name");            GenJournalTemplate.TestField("Posting No. Series");            ServHeader2."Posting No. Series" := GenJournalTemplate."Posting No. Series";            ServHeader2."Journal Templ. Name" := ServMgtSetup."Serv. Contr. Cr.M. Templ. Name";        end;        ServMgtSetup.TestField("Contract Credit Memo Nos.");        IsHandled := false;        OnCreateOrGetCreditHeaderOnBeforeInitSeries(ServHeader2, ServMgtSetup, IsHandled, ServContract);        if not IsHandled then begin            ServHeader2."No. Series" := ServMgtSetup."Contract Credit Memo Nos.";            ServHeader2."No." := NoSeries.GetNextNo(ServHeader2."No. Series");        end;        InsertServiceHeader(ServHeader2, ServContract);        ServInvoiceNo := ServHeader2."No.";        ServHeader2.Correction := GLSetup."Mark Cr. Memos as Corrections";        ServHeader2."Posting Description" := Format(ServHeader2."Document Type") + ' ' + ServHeader2."No.";        ServHeader2.Validate("Bill-to Customer No.", ServContract."Bill-to Customer No.");        ServHeader2."Prices Including VAT" := false;        ServHeader2."Customer No." := ServContract."Customer No.";        ServHeader2."Responsibility Center" := ServContract."Responsibility Center";        Cust.Get(ServHeader2."Customer No.");        IsHandled := false;        OnCreateOrGetCreditHeaderOnBeforeCheckBlockedCustOnDocs(ServHeader2, ServContract, IsHandled);        if not IsHandled then            Cust.CheckBlockedCustOnDocs(Cust, ServHeader2."Document Type", false, false);        if CheckCustomerBusPostingGroup() then            Cust.TestField("Gen. Bus. Posting Group");        ServHeader2.Name := Cust.Name;        ServHeader2."Name 2" := Cust."Name 2";        ServHeader2.Address := Cust.Address;        ServHeader2."Address 2" := Cust."Address 2";        ServHeader2.City := Cust.City;        ServHeader2."Post Code" := Cust."Post Code";        ServHeader2.County := Cust.County;        ServHeader2."Country/Region Code" := Cust."Country/Region Code";        ServHeader2."Contact Name" := ServContract."Contact Name";        ServHeader2."Contact No." := ServContract."Contact No.";        ServHeader2."Bill-to Contact No." := ServContract."Bill-to Contact No.";        ServHeader2."Bill-to Contact" := ServContract."Bill-to Contact";        ServHeader2."Gen. Bus. Posting Group" := Cust."Gen. Bus. Posting Group";        ServHeader2."Tax Area Code" := Cust."Tax Area Code";        ServHeader2."Tax Liable" := Cust."Tax Liable";        if GLSetup."Bill-to/Sell-to VAT Calc." = GLSetup."Bill-to/Sell-to VAT Calc."::"Sell-to/Buy-from No." then            ServHeader2."VAT Bus. Posting Group" := Cust."VAT Bus. Posting Group";        OnCreateOrGetCreditHeaderOnAfterCopyFromCustomer(ServHeader2, ServContract, Cust);        ServHeader2.Validate("Ship-to Code", ServContract."Ship-to Code");        if CrMemoDate <> 0D then            ServHeader2.Validate("Posting Date", CrMemoDate)        else            ServHeader2.Validate("Posting Date", WorkDate());        ServHeader2."Contract No." := ServContract."Contract No.";        ServHeader2."Currency Code" := ServContract."Currency Code";        OnCreateOrGetCreditHeaderOnBeforeCalcCurrencyFactor(ServHeader2, CurrExchRate);        ServHeader2."Currency Factor" :=          CurrExchRate.ExchangeRate(            ServHeader2."Posting Date", ServHeader2."Currency Code");        ServHeader2."Payment Terms Code" := ServContract."Payment Terms Code";        ServHeader2."Your Reference" := ServContract."Your Reference";        ServHeader2."Salesperson Code" := ServContract."Salesperson Code";        ServHeader2."Shortcut Dimension 1 Code" := ServContract."Shortcut Dimension 1 Code";        ServHeader2."Shortcut Dimension 2 Code" := ServContract."Shortcut Dimension 2 Code";        ServHeader2."Dimension Set ID" := ServContract."Dimension Set ID";        ServHeader2.Validate("Location Code",          UserMgt.GetLocation(2, Cust."Location Code", ServContract."Responsibility Center"));        OnBeforeServHeaderModify(ServHeader2, ServContract);        ServHeader2.Modify();        Clear(ServDocReg);        ServDocReg.InsertServiceSalesDocument(          ServDocReg."Source Document Type"::Contract, ServContract."Contract No.",          ServDocReg."Destination Document Type"::"Credit Memo", ServHeader2."No.");        OnAfterCreateOrGetCreditHeader(ServHeader2, ServContract);    end;    local procedure CreateCreditLine(CreditNo: Code[20]; AccountNo: Code[20]; CreditAmount: Decimal; PeriodStarts: Date; PeriodEnds: Date; LineDescription: Text[100]; ServItemNo: Code[20]; ServContract: Record "Service Contract Header"; CreditCost: Decimal; CreditUnitPrice: Decimal; DiscAmount: Decimal; ApplyDiscAmt: Boolean; ServLedgEntryNo: Integer)    var        ServHeader2: Record "Service Header";        ServLine2: Record "Service Line";        Cust: Record Customer;        IsHandled: Boolean;    begin        ServHeader2.Get(ServHeader2."Document Type"::"Credit Memo", CreditNo);        Cust.Get(ServHeader2."Bill-to Customer No.");        Clear(ServLine2);        ServLine2.SetRange("Document Type", ServHeader2."Document Type");        ServLine2.SetRange("Document No.", CreditNo);        if ServLine2.FindLast() then            NextLine := ServLine2."Line No." + 10000        else            NextLine := 10000;        Clear(ServLine2);        ServLine2.Init();        ServLine2."Document Type" := ServHeader2."Document Type";        ServLine2."Document No." := ServHeader2."No.";        ServLine2.Type := ServLine2.Type::" ";        ServLine2.Description := StrSubstNo('%1 - %2', Format(PeriodStarts), Format(PeriodEnds));        ServLine2."Line No." := NextLine;        ServLine2."Posting Date" := PeriodStarts;        OnCreateCreditLineOnBeforeServLineHeadingInsert(ServLine2, ServHeader2, ServContract);        ServLine2.Insert();        NextLine := NextLine + 10000;        ServLine2."Customer No." := ServHeader2."Customer No.";        ServLine2."Location Code" := ServHeader2."Location Code";        ServLine2."Shortcut Dimension 1 Code" := ServHeader2."Shortcut Dimension 1 Code";        ServLine2."Shortcut Dimension 2 Code" := ServHeader2."Shortcut Dimension 2 Code";        ServLine2."Dimension Set ID" := ServHeader2."Dimension Set ID";        ServLine2."Gen. Bus. Posting Group" := ServHeader2."Gen. Bus. Posting Group";        ServLine2."Transaction Specification" := ServHeader2."Transaction Specification";        ServLine2."Transport Method" := ServHeader2."Transport Method";        ServLine2."Exit Point" := ServHeader2."Exit Point";        ServLine2.Area := ServHeader2.Area;        ServLine2."Transaction Specification" := ServHeader2."Transaction Specification";        ServLine2."Line No." := NextLine;        ServLine2.Type := ServLine.Type::"G/L Account";        ServLine2.Validate("No.", AccountNo);        ServLine2.Validate(Quantity, 1);        if ServHeader2."Currency Code" <> '' then begin            ServLine2.Validate("Unit Price", AmountToFCY(CreditUnitPrice, ServHeader2));            ServLine2.Validate("Line Amount", AmountToFCY(CreditAmount, ServHeader2));        end else begin            ServLine2.Validate("Unit Price", CreditUnitPrice);            ServLine2.Validate("Line Amount", CreditAmount);        end;        ServLine2.Description := LineDescription;        ServLine2."Contract No." := ServContract."Contract No.";        ServLine2."Service Item No." := ServItemNo;        ServLine2."Appl.-to Service Entry" := ServLedgEntryNo;        ServLine2."Unit Cost (LCY)" := CreditCost;        ServLine2."Posting Date" := PeriodStarts;        if ApplyDiscAmt then            ServLine2.Validate("Line Discount Amount", DiscAmount);        IsHandled := false;        OnCreateCreditLineOnBeforeCreateDim(ServLine2, IsHandled);        if not IsHandled then            ServLine2.CreateDimFromDefaultDim(0);        OnBeforeServLineInsert(ServLine2, ServHeader2, ServContract);        ServLine2.Insert();    end;    procedure CreateContractLineCreditMemo(var FromServiceContractLine: Record "Service Contract Line"; Deleting: Boolean) CreditMemoNo: Code[20]    var        ServItem: Record "Service Item";        ServContractHeader: Record "Service Contract Header";        StdText: Record "Standard Text";        Currency: Record Currency;        ServiceContract: Page "Service Contract";        ServiceCreditMemo: Page "Service Credit Memo";        ServiceInvoice: Page "Service Invoice";        CreditAmount: Decimal;        FirstPrepaidPostingDate: Date;        LastIncomePostingDate: Date;        WDate: Date;        LineDescription: Text[100];    begin        OnBeforeCreateContractLineCreditMemo(FromServiceContractLine, Deleting);        CreditMemoNo := '';        ServContractHeader.Get(FromServiceContractLine."Contract Type", FromServiceContractLine."Contract No.");        FromServiceContractLine.TestField("Contract Expiration Date");        FromServiceContractLine.TestField("Credit Memo Date");        if FromServiceContractLine."Credit Memo Date" > WorkDate() then            Error(              Text004,              FromServiceContractLine.FieldCaption("Credit Memo Date"), FromServiceContractLine."Credit Memo Date");        ServContractHeader.CalcFields("No. of Unposted Invoices");        if ServContractHeader."No. of Unposted Invoices" <> 0 then            Error(              Text014,              ServiceCreditMemo.Caption,              ServiceContract.Caption,              ServContractHeader."Contract No.",              ServiceInvoice.Caption);        CheckContractGroupAccounts(ServContractHeader);        FillTempServiceLedgerEntries(ServContractHeader);        Currency.InitRoundingPrecision();        if FromServiceContractLine."Line Amount" > 0 then begin            ServMgtSetup.Get();            if ServMgtSetup."Contract Credit Line Text Code" <> '' then begin                StdText.Get(ServMgtSetup."Contract Credit Line Text Code");                LineDescription := CopyStr(StrSubstNo('%1 %2', StdText.Description, FromServiceContractLine."Service Item No."), 1, 50);            end else                if FromServiceContractLine."Service Item No." <> '' then                    LineDescription := CopyStr(StrSubstNo(Text005, ServItem.TableCaption(), FromServiceContractLine."Service Item No."), 1, 50)                else                    LineDescription := CopyStr(StrSubstNo(Text005, FromServiceContractLine.TableCaption(), FromServiceContractLine."Line No."), 1, 50);            if FromServiceContractLine."Invoiced to Date" >= FromServiceContractLine."Contract Expiration Date" then begin                if ServContractHeader.Prepaid then                    FirstPrepaidPostingDate := FindFirstPrepaidTransaction(FromServiceContractLine."Contract No.")                else                    FirstPrepaidPostingDate := 0D;                LastIncomePostingDate := FromServiceContractLine."Invoiced to Date";                if FirstPrepaidPostingDate <> 0D then                    LastIncomePostingDate := FirstPrepaidPostingDate - 1;                WDate := FromServiceContractLine."Contract Expiration Date";                OnCreateContractLineCreditMemoOnBeforeCalcCreditAmount(WDate, ServContractHeader, FromServiceContractLine);                CreditAmount :=                  Round(                    CalcContractLineAmount(FromServiceContractLine."Line Amount",                      WDate, FromServiceContractLine."Invoiced to Date"),                    Currency."Amount Rounding Precision");                if CreditAmount > 0 then begin                    CreditMemoNo := CreateOrGetCreditHeader(ServContractHeader, FromServiceContractLine."Credit Memo Date");                    CreateAllCreditLines(                        CreditMemoNo, FromServiceContractLine."Line Amount", WDate, FromServiceContractLine."Invoiced to Date", LineDescription, FromServiceContractLine."Service Item No.", FromServiceContractLine."Item No.",                        ServContractHeader, FromServiceContractLine."Line Cost", FromServiceContractLine."Line Value", LastIncomePostingDate, FromServiceContractLine."Starting Date");                    OnCreateContractLineCreditMemoOnAfterCreateAllCreditLines(ServContractHeader, FromServiceContractLine, CreditMemoNo);                end;            end;        end;        if (CreditMemoNo <> '') and not Deleting then begin            FromServiceContractLine.Credited := true;            FromServiceContractLine.Modify();        end;        OnAfterCreateContractLineCreditMemo(FromServiceContractLine, CreditMemoNo);    end;    procedure CheckContractGroupAccounts(ServContractHeader: Record "Service Contract Header")    var        GLAcc: Record "G/L Account";        ServContractAccGr: Record "Service Contract Account Group";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckContractGroupAccounts(ServContractHeader, IsHandled);        if IsHandled then            exit;        ServContractHeader.TestField("Serv. Contract Acc. Gr. Code");        ServContractAccGr.Get(ServContractHeader."Serv. Contract Acc. Gr. Code");        ServContractAccGr.TestField("Non-Prepaid Contract Acc.");        GLAcc.Get(ServContractAccGr."Non-Prepaid Contract Acc.");        GLAcc.TestField("Direct Posting");        if ServContractHeader.Prepaid then begin            ServContractAccGr.TestField("Prepaid Contract Acc.");            GLAcc.Get(ServContractAccGr."Prepaid Contract Acc.");            GLAcc.TestField("Direct Posting");        end;    end;    procedure FindFirstPrepaidTransaction(ContractNo: Code[20]): Date    var        ServLedgEntry: Record "Service Ledger Entry";    begin        Clear(ServLedgEntry);        ServLedgEntry.SetCurrentKey(Type, "No.", "Entry Type", "Moved from Prepaid Acc.", "Posting Date", Open);        ServLedgEntry.SetRange(Type, ServLedgEntry.Type::"Service Contract");        ServLedgEntry.SetRange("No.", ContractNo);        ServLedgEntry.SetRange("Moved from Prepaid Acc.", false);        ServLedgEntry.SetRange(Prepaid, true);        if ServLedgEntry.FindFirst() then            exit(ServLedgEntry."Posting Date");        exit(0D);    end;    local procedure CreateAllCreditLines(CreditNo: Code[20]; ContractLineAmount: Decimal; PeriodStarts: Date; PeriodEnds: Date; LineDescription: Text[100]; ServItemNo: Code[20]; ItemNo: Code[20]; ServContract: Record "Service Contract Header"; ContractLineCost: Decimal; ContractLineUnitPrice: Decimal; LastIncomePostingDate: Date; ContractLineStartingDate: Date)    var        Currency: Record Currency;        ServContractAccGr: Record "Service Contract Account Group";        AccountNo: Code[20];        WDate: Date;        OldWDate: Date;        i: Integer;        Days: Integer;        InvPeriod: Integer;        AppliedCreditLineAmount: Decimal;        AppliedCreditLineCost: Decimal;        AppliedCreditLineUnitCost: Decimal;        AppliedCreditLineDiscAmount: Decimal;        ApplyServiceLedgerEntryAmounts: Boolean;        ServLedgEntryNo: Integer;    begin        Days := Date2DMY(ContractLineStartingDate, 1);        Currency.InitRoundingPrecision();        if ServContract.Prepaid then            InvPeriod := 1        else            case ServContract."Invoice Period" of                ServContract."Invoice Period"::Month:                    InvPeriod := 1;                ServContract."Invoice Period"::"Two Months":                    InvPeriod := 2;                ServContract."Invoice Period"::Quarter:                    InvPeriod := 3;                ServContract."Invoice Period"::"Half Year":                    InvPeriod := 6;                ServContract."Invoice Period"::Year:                    InvPeriod := 12;                ServContract."Invoice Period"::None:                    InvPeriod := 0;                else                    OnCreateAllCreditLinesCaseElse(ServContract, InvPeriod);            end;        ServContract.TestField("Serv. Contract Acc. Gr. Code");        ServContractAccGr.Get(ServContract."Serv. Contract Acc. Gr. Code");        ServContractAccGr.TestField("Prepaid Contract Acc.");        WDate := ContractLineStartingDate;        repeat            OldWDate := CalcDate('<CM>', WDate);            if Days <> 1 then                Days := 1            else begin                for i := 1 to InvPeriod do                    OldWDate := CalcDate('<CM>', OldWDate) + 1;                OldWDate := OldWDate - 1;            end;            OnCreateAllCreditLinesOnAfterDetermineOldWDate(ServContract, InvPeriod, Days, WDate, OldWDate);            if OldWDate >= PeriodStarts then begin                if WDate < PeriodStarts then                    WDate := PeriodStarts;                if OldWDate > PeriodEnds then                    OldWDate := PeriodEnds;                if OldWDate > LastIncomePostingDate then                    AccountNo := ServContractAccGr."Prepaid Contract Acc."                else                    AccountNo := ServContractAccGr."Non-Prepaid Contract Acc.";                ApplyServiceLedgerEntryAmounts :=                  LookUpAmountToCredit(                    ServItemNo,                    ItemNo,                    WDate,                    AppliedCreditLineAmount,                    AppliedCreditLineCost,                    AppliedCreditLineUnitCost,                    AppliedCreditLineDiscAmount,                    ServLedgEntryNo);                if (not ApplyServiceLedgerEntryAmounts) or (not ServContract.Prepaid) then begin                    AppliedCreditLineAmount :=                      Round(CalcContractLineAmount(ContractLineAmount, WDate, OldWDate), Currency."Amount Rounding Precision");                    AppliedCreditLineCost :=                      Round(CalcContractLineAmount(ContractLineCost, WDate, OldWDate), Currency."Amount Rounding Precision");                    AppliedCreditLineUnitCost :=                      Round(CalcContractLineAmount(ContractLineUnitPrice, WDate, OldWDate), Currency."Amount Rounding Precision");                end;                CreateCreditLine(                  CreditNo,                  AccountNo,                  AppliedCreditLineAmount,                  WDate,                  OldWDate,                  LineDescription,                  ServItemNo,                  ServContract,                  AppliedCreditLineCost,                  AppliedCreditLineUnitCost,                  AppliedCreditLineDiscAmount,                  ApplyServiceLedgerEntryAmounts,                  ServLedgEntryNo);            end;            WDate := CalcDate('<CM>', OldWDate) + 1;        until (OldWDate >= PeriodEnds);    end;    procedure GetNextInvoicePeriod(InvoicedServContractHeader: Record "Service Contract Header"; var InvFrom: Date; var InvTo: Date)    begin        InvFrom := InvoicedServContractHeader."Next Invoice Period Start";        InvTo := InvoicedServContractHeader."Next Invoice Period End";    end;    procedure NoOfDayInYear(InputDate: Date): Integer    var        W1: Date;        W2: Date;        YY: Integer;    begin        YY := Date2DMY(InputDate, 3);        W1 := DMY2Date(1, 1, YY);        W2 := DMY2Date(31, 12, YY);        exit(W2 - W1 + 1);    end;    procedure NoOfMonthsAndDaysInPeriod(Day1: Date; Day2: Date; var NoOfMonthsInPeriod: Integer; var NoOfDaysInPeriod: Integer)    var        Wdate: Date;        FirstDayinCrntMonth: Date;        LastDayinCrntMonth: Date;    begin        NoOfMonthsInPeriod := 0;        NoOfDaysInPeriod := 0;        if Day1 > Day2 then            exit;        if Day1 = 0D then            exit;        if Day2 = 0D then            exit;        Wdate := Day1;        repeat            FirstDayinCrntMonth := CalcDate('<-CM>', Wdate);            LastDayinCrntMonth := CalcDate('<CM>', Wdate);            if (Wdate = FirstDayinCrntMonth) and (LastDayinCrntMonth <= Day2) then begin                NoOfMonthsInPeriod := NoOfMonthsInPeriod + 1;                Wdate := LastDayinCrntMonth + 1;            end else begin                NoOfDaysInPeriod := NoOfDaysInPeriod + 1;                Wdate := Wdate + 1;            end;        until Wdate > Day2;    end;    procedure NoOfMonthsAndMPartsInPeriod(Day1: Date; Day2: Date) MonthsAndMParts: Decimal    var        WDate: Date;        OldWDate: Date;        IsHandled: Boolean;        DateExpression: Text[10];    begin        IsHandled := false;        OnBeforeNoOfMonthsAndMPartsInPeriod(Day1, Day2, CheckMParts, MonthsAndMParts, IsHandled);        if IsHandled then            exit;        if Day1 > Day2 then            exit;        if (Day1 = 0D) or (Day2 = 0D) then            exit;        MonthsAndMParts := 0;        WDate := CalcDate('<-CM>', Day1);        repeat            DateExpression := GetDateExpression(Day1);            OldWDate := CalcDate(DateExpression, WDate);            if WDate < Day1 then                WDate := Day1;            if OldWDate > Day2 then                OldWDate := Day2;            if (WDate <> CalcDate('<-CM>', WDate)) or (OldWDate <> CalcDate('<CM>', OldWDate)) then                MonthsAndMParts := MonthsAndMParts +                  (OldWDate - WDate + 1) / (CalcDate(DateExpression, OldWDate) - CalcDate('<-CM>', WDate) + 1)            else                MonthsAndMParts := MonthsAndMParts + 1;            WDate := CalcDate('<CM>', OldWDate) + 1;            if MonthsAndMParts <> Round(MonthsAndMParts, 1) then                CheckMParts := true;        until WDate > Day2;    end;    procedure CalcContractAmount(ServContractHeader: Record "Service Contract Header"; PeriodStarts: Date; PeriodEnds: Date) AmountCalculated: Decimal    var        ServContractLine: Record "Service Contract Line";        Currency: Record Currency;        LinePeriodStarts: Date;        LinePeriodEnds: Date;        ContractLineIncluded: Boolean;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcContractAmount(ServContractHeader, PeriodStarts, PeriodEnds, AmountCalculated, IsHandled);        if IsHandled then            exit(AmountCalculated);        Currency.InitRoundingPrecision();        AmountCalculated := 0;        if ServContractHeader."Expiration Date" <> 0D then begin            if ServContractHeader."Expiration Date" < PeriodStarts then                exit;            if (ServContractHeader."Expiration Date" >= PeriodStarts) and               (ServContractHeader."Expiration Date" <= PeriodEnds)            then                PeriodEnds := ServContractHeader."Expiration Date";        end;        ServContractLine.Reset();        ServContractLine.SetRange("Contract Type", ServContractHeader."Contract Type");        ServContractLine.SetRange("Contract No.", ServContractHeader."Contract No.");        if ServContractHeader.Prepaid then            ServContractLine.SetFilter("Starting Date", '<=%1', ServContractHeader."Next Invoice Date")        else            if ServContractHeader."Last Invoice Date" <> 0D            then                ServContractLine.SetFilter("Invoiced to Date", '%1|%2', ServContractHeader."Last Invoice Date", 0D);        OnCalcContractAmountOnAfterServContractLineSetFilters(ServContractLine, ServContractHeader, PeriodStarts, PeriodEnds);        if ServContractLine.Find('-') then begin            repeat                ContractLineIncluded := true;                FindLinePeriodStartsByInvoicedToDate(ServContractLine, PeriodStarts, LinePeriodStarts);                LinePeriodEnds := PeriodEnds;                if ServContractLine."Contract Expiration Date" <> 0D then                    if ServContractLine."Contract Expiration Date" < PeriodStarts then                        ContractLineIncluded := false                    else                        if (ServContractLine."Contract Expiration Date" >= PeriodStarts) and                           (ServContractLine."Contract Expiration Date" <= PeriodEnds)                        then                            LinePeriodStarts := PeriodStarts;                if ContractLineIncluded then                    AmountCalculated := AmountCalculated +                      CalcContractLineAmount(ServContractLine."Line Amount", LinePeriodStarts, LinePeriodEnds);            until ServContractLine.Next() = 0;            AmountCalculated := Round(AmountCalculated, Currency."Amount Rounding Precision");        end else begin            ServContractLine.SetRange("Starting Date");            ServContractLine.SetRange("Invoiced to Date");            if ServContractLine.IsEmpty() then                AmountCalculated :=                  Round(                    ServContractHeader."Annual Amount" / 12 * NoOfMonthsAndMPartsInPeriod(PeriodStarts, PeriodEnds),                    Currency."Amount Rounding Precision");        end;    end;    local procedure FindLinePeriodStartsByInvoicedToDate(ServContractLine: Record "Service Contract Line"; PeriodStarts: Date; var LinePeriodStarts: Date)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeFindLinePeriodStartsByInvoicedToDate(ServContractLine, PeriodStarts, LinePeriodStarts, IsHandled);        if IsHandled then            exit;        if ServContractLine."Invoiced to Date" = 0D then            LinePeriodStarts := ServContractLine."Starting Date"        else            LinePeriodStarts := PeriodStarts;    end;    procedure CalcContractLineAmount(AnnualAmount: Decimal; PeriodStarts: Date; PeriodEnds: Date) AmountCalculated: Decimal    begin        AmountCalculated := AnnualAmount / 12 * NoOfMonthsAndMPartsInPeriod(PeriodStarts, PeriodEnds);        OnAfterCalcContractLineAmount(AnnualAmount, PeriodStarts, PeriodEnds, AmountCalculated);    end;    procedure CreateRemainingPeriodInvoice(var CurrServContract: Record "Service Contract Header") InvoiceNo: Code[20]    var        ServHeader: Record "Service Header";        ServContractLine: Record "Service Contract Line";        InvFrom: Date;        InvTo: Date;    begin        OnBeforeCreateRemainingPeriodInvoice(CurrServContract);        CurrServContract.TestField("Change Status", CurrServContract."Change Status"::Locked);        if CurrServContract.Prepaid then            InvTo := CurrServContract."Next Invoice Date" - 1        else            InvTo := CurrServContract."Next Invoice Period Start" - 1;        if (CurrServContract."Last Invoice Date" = 0D) and           (CurrServContract."Starting Date" < CurrServContract."Next Invoice Period Start")        then begin            InvFrom := CurrServContract."Starting Date";            if (InvFrom = CalcDate('<-CM>', InvFrom)) and CurrServContract.Prepaid then                exit;        end else            if CurrServContract."Last Invoice Period End" <> 0D then begin                if CurrServContract."Last Invoice Period End" <> CalcDate('<CM>', CurrServContract."Last Invoice Period End") then                    InvFrom := CalcDate('<+1D>', CurrServContract."Last Invoice Period End");                ServContractLine.Reset();                ServContractLine.SetRange("Contract Type", CurrServContract."Contract Type");                ServContractLine.SetRange("Contract No.", CurrServContract."Contract No.");                ServContractLine.SetRange("Invoiced to Date", 0D);                ServContractLine.SetFilter("Starting Date", '<=%1', InvTo);                OnCreateRemainingPeriodInvoiceOnAfterServContractLineSetFilters(ServContractLine, CurrServContract);                if ServContractLine.Find('-') then                    repeat                        if InvFrom <> 0D then begin                            if ServContractLine."Starting Date" < InvFrom then                                InvFrom := ServContractLine."Starting Date"                        end else                            InvFrom := ServContractLine."Starting Date";                    until ServContractLine.Next() = 0;            end;        if (InvFrom = 0D) or (InvFrom > InvTo) then            exit;        if ConfirmCreateServiceInvoiceForPeriod(CurrServContract, InvFrom, InvTo) then begin            InvoiceNo := CreateServHeader(CurrServContract, PostingDate, false);            ServHeader.Get(ServHeader."Document Type"::Invoice, InvoiceNo);            ServMgtSetup.Get();            if not CurrServContract.Prepaid then                CurrServContract.Validate("Last Invoice Date", InvTo)            else begin                CurrServContract."Last Invoice Date" := CurrServContract."Starting Date";                CurrServContract.Validate("Last Invoice Period End", InvTo);            end;            CreateRemainingPeriodInvoiceServiceLines(CurrServContract, ServHeader, InvFrom, InvTo);            CurrServContract.Modify();            InvoicingStartingPeriod := true;            OnAfterCreateRemainingPeriodInvoice(CurrServContract);        end;    end;    local procedure CreateRemainingPeriodInvoiceServiceLines(var CurrServContract: Record "Service Contract Header"; var ServHeader: Record "Service Header"; InvFrom: Date; InvTo: Date)    var        ServContractLine: Record "Service Contract Line";        LineInvFrom: Date;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateRemainingPeriodInvoiceServiceLines(CurrServContract, ServHeader, InvFrom, InvTo, AppliedEntryNo, IsHandled);        if IsHandled then            exit;        if CurrServContract."Contract Lines on Invoice" then begin            ServContractLine.Reset();            ServContractLine.SetRange("Contract Type", CurrServContract."Contract Type");            ServContractLine.SetRange("Contract No.", CurrServContract."Contract No.");            ServContractLine.SetFilter("Starting Date", '<=%1', InvTo);            OnCreateRemainingPeriodInvoiceOnAfterServContractLineSetFilters(ServContractLine, CurrServContract);            if ServContractLine.Find('-') then                repeat                    if ServContractLine."Invoiced to Date" = 0D then                        CreateDetailedServiceLine(                          ServHeader, ServContractLine, CurrServContract."Contract Type", CurrServContract."Contract No.");                    if ServContractLine."Invoiced to Date" <> 0D then                        if ServContractLine."Invoiced to Date" <> CalcDate('<CM>', ServContractLine."Invoiced to Date") then                            CreateDetailedServiceLine(                              ServHeader, ServContractLine, CurrServContract."Contract Type", CurrServContract."Contract No.");                    AppliedEntryNo :=                      CreateServiceLedgEntry(                        ServHeader, CurrServContract."Contract Type",                        CurrServContract."Contract No.", InvFrom, InvTo, true, false, ServContractLine."Line No.");                    if AppliedEntryNo <> 0 then begin                        if ServContractLine."Invoiced to Date" = 0D then                            LineInvFrom := ServContractLine."Starting Date"                        else                            LineInvFrom := ServContractLine."Invoiced to Date" + 1;                    end else                        LineInvFrom := InvFrom;                    CreateServiceLine(                      ServHeader, CurrServContract."Contract Type",                      CurrServContract."Contract No.", LineInvFrom, InvTo, AppliedEntryNo, true);                until ServContractLine.Next() = 0;        end else begin            CreateHeadingServiceLine(              ServHeader, CurrServContract."Contract Type", CurrServContract."Contract No.");            AppliedEntryNo :=              CreateServiceLedgEntry(                ServHeader, CurrServContract."Contract Type",                CurrServContract."Contract No.", InvFrom, InvTo, true, false, 0);            CreateServiceLine(              ServHeader, CurrServContract."Contract Type",              CurrServContract."Contract No.", InvFrom, InvTo, AppliedEntryNo, true);        end;    end;    local procedure ConfirmCreateServiceInvoiceForPeriod(var CurrServContract: Record "Service Contract Header"; InvFrom: Date; InvTo: Date) Result: Boolean    var        ConfirmManagement: Codeunit "Confirm Management";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeConfirmCreateServiceInvoiceForPeriod(CurrServContract, InvFrom, InvTo, Result, IsHandled);        if IsHandled then            exit(Result);        exit(ConfirmManagement.GetResponseOrDefault(StrSubstNo(Text006, InvFrom, InvTo), true));    end;    procedure InitCodeUnit()    var        ServiceLedgEntry: Record "Service Ledger Entry";        SourceCodeSetup: Record "Source Code Setup";        SequenceNoMgt: Codeunit "Sequence No. Mgt.";        KeepFromWarrEntryNo: Integer;        KeepToWarrEntryNo: Integer;    begin        if ServiceRegister."No." = 0 then            SequenceNoMgt.ClearSequenceNoCheck();        if ServMgtSetup.UseLegacyPosting() then begin            ServiceLedgEntry.LockTable();            if ServiceLedgEntry.FindLast() then                NextEntryNo := ServiceLedgEntry."Entry No." + 1            else                NextEntryNo := 1;        end else            NextEntryNo := ServiceLedgEntry.GetNextEntryNo();        PrevEntryNo := 0;        ServiceRegister.Reset();        if ServiceRegister.FindLast() then begin            KeepFromWarrEntryNo := ServiceRegister."From Warranty Entry No.";            KeepToWarrEntryNo := ServiceRegister."To Warranty Entry No.";        end;        ServiceRegister.Init();        ServiceRegister."No." := ServiceRegister.GetNextEntryNo(ServMgtSetup.UseLegacyPosting());        ServiceRegister."From Entry No." := NextEntryNo;        ServiceRegister."From Warranty Entry No." := KeepFromWarrEntryNo;        ServiceRegister."To Warranty Entry No." := KeepToWarrEntryNo;        ServiceRegister."Creation Date" := Today();        ServiceRegister."Creation Time" := Time();        SourceCodeSetup.Get();        SourceCodeSetup.TestField("Service Management");        ServiceRegister."Source Code" := SourceCodeSetup."Service Management";        ServiceRegister."User ID" := CopyStr(UserId(), 1, MaxStrLen(ServiceLedgEntry."User ID"));        OnAfterInitCodeUnit(ServiceRegister);    end;    procedure FinishCodeunit()    begin        ServiceRegister."To Entry No." := PrevEntryNo;        ServiceRegister.Insert();        OnAfterFinishCodeunit(ServiceRegister);    end;    procedure CopyCheckSCDimToTempSCDim(ServContract: Record "Service Contract Header")    begin        OnBeforeCopyCheckSCDimToTempSCDim(ServContract);        CheckDimComb(ServContract, 0);        CheckDimValuePosting(ServContract, 0);    end;    local procedure CheckDimComb(ServContract: Record "Service Contract Header"; LineNo: Integer)    begin        if not DimMgt.CheckDimIDComb(ServContract."Dimension Set ID") then            if LineNo = 0 then                Error(                  Text008,                  ServContract."Contract Type", ServContract."Contract No.", DimMgt.GetDimCombErr());    end;    local procedure CheckDimValuePosting(ServContract: Record "Service Contract Header"; LineNo: Integer)    var        TableIDArr: array[10] of Integer;        NumberArr: array[10] of Code[20];        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckDimValuePosting(ServContract, LineNo, IsHandled);        if IsHandled then            exit;        if LineNo = 0 then begin            TableIDArr[1] := DATABASE::Customer;            NumberArr[1] := ServContract."Bill-to Customer No.";            TableIDArr[2] := DATABASE::"Salesperson/Purchaser";            NumberArr[2] := ServContract."Salesperson Code";            TableIDArr[3] := DATABASE::"Responsibility Center";            NumberArr[3] := ServContract."Responsibility Center";            TableIDArr[4] := DATABASE::"Service Contract Template";            NumberArr[4] := ServContract."Template No.";            if not DimMgt.CheckDimValuePosting(TableIDArr, NumberArr, ServContract."Dimension Set ID") then                Error(                  Text009,                  ServContract."Contract Type", ServContract."Contract No.", DimMgt.GetDimValuePostingErr());        end;    end;    procedure CreateAllServLines(InvNo: Code[20]; ServContractToInvoice: Record "Service Contract Header")    var        ServContractLine: Record "Service Contract Line";        ServHeader: Record "Service Header";        InvoiceFrom: Date;        InvoiceTo: Date;        PartInvoiceFrom: Date;        PartInvoiceTo: Date;        ServiceApplyEntry: Integer;        ShouldCraeteServiceApplyEntry: Boolean;    begin        GetNextInvoicePeriod(ServContractToInvoice, InvoiceFrom, InvoiceTo);        if ServHeader.Get(ServHeader."Document Type"::Invoice, InvNo) then begin            ServContractLine.Reset();            ServContractLine.SetRange("Contract Type", ServContractToInvoice."Contract Type");            ServContractLine.SetRange("Contract No.", ServContractToInvoice."Contract No.");            OnCreateAllServLinesOnAfterServContractLineSetFilters(ServContractLine, ServContractToInvoice);            if not ServContractToInvoice."Contract Lines on Invoice" then                CreateHeadingServiceLine(ServHeader, ServContractToInvoice."Contract Type", ServContractToInvoice."Contract No.");            if ServContractLine.Find('-') then                repeat                    OnCreateAllServLinesOnBeforeServContractLineLoop(InvoiceFrom, ServContractLine, ServContractToInvoice);                    CheckServiceItemBlockedForAll(ServContractLine);                    CheckItemServiceBlocked(ServContractLine);                    if ServContractToInvoice."Contract Lines on Invoice" and (ServContractLine."Starting Date" <= InvoiceTo) then                        if ServContractToInvoice.Prepaid and (ServContractLine."Starting Date" <= ServContractToInvoice."Next Invoice Date") or                           ((not ServContractToInvoice.Prepaid) and                            ((ServContractLine."Invoiced to Date" = ServContractToInvoice."Last Invoice Date") or                             (ServContractLine."Invoiced to Date" = 0D)))                        then                            if (ServContractLine."Contract Expiration Date" = 0D) or                               (ServContractLine."Contract Expiration Date" >= InvoiceFrom)                            then                                CreateDetailedServiceLine(ServHeader, ServContractLine, ServContractToInvoice."Contract Type", ServContractToInvoice."Contract No.");                    OnCreateAllServLinesOnAfterCreateDetailedServLine(ServContractToInvoice, ServHeader, ServContractLine);                    if ServContractToInvoice.Prepaid then                        CheckAndCreateServiceLinesForPartOfTheMonth(                            ServContractToInvoice,                            ServContractLine,                            ServHeader,                            PartInvoiceFrom,                            PartInvoiceTo);                    ServiceApplyEntry :=                      CreateServiceLedgEntry(                        ServHeader, ServContractToInvoice."Contract Type", ServContractToInvoice."Contract No.", InvoiceFrom, InvoiceTo,                        false, false, ServContractLine."Line No.");                    ShouldCraeteServiceApplyEntry := ServiceApplyEntry <> 0;                    OnCreateAllServLinesOnAfterCalcShouldCraeteServiceApplyEntry(ServHeader, ServContractToInvoice, ServContractLine, PartInvoiceFrom, PartInvoiceTo, ServiceApplyEntry, ShouldCraeteServiceApplyEntry);                    if ShouldCraeteServiceApplyEntry then                        CreateServiceLine(                          ServHeader, ServContractToInvoice."Contract Type", ServContractToInvoice."Contract No.",                          CountLineInvFrom(false, ServContractLine, InvoiceFrom), InvoiceTo, ServiceApplyEntry, false);                    OnCreateAllServLinesOnAfterCreateServiceLine(ServContractLine, ServHeader, InvoiceFrom, InvoiceTo);                until ServContractLine.Next() = 0;        end;        OnCreateAllServLinesOnBeforeCreateLastServiceLines(ServContractToInvoice, ServLine);        CreateLastServiceLines(ServHeader, ServContractToInvoice."Contract Type", ServContractToInvoice."Contract No.");        ServContractToInvoice.Validate(ServContractToInvoice."Last Invoice Date", ServContractToInvoice."Next Invoice Date");        ServContractToInvoice."Print Increase Text" := false;        ServContractToInvoice.Modify();        OnAfterCreateAllServLines(ServContractToInvoice, ServContractLine, ServHeader);    end;    procedure CheckIfServiceExist(ServContractHeader: Record "Service Contract Header"): Boolean    var        ServContractLine: Record "Service Contract Line";    begin        if ServContractHeader."Invoice after Service" then begin            ServContractLine.Reset();            ServContractLine.SetRange("Contract Type", ServContractHeader."Contract Type");            ServContractLine.SetRange("Contract No.", ServContractHeader."Contract No.");            ServContractLine.SetFilter("Last Service Date", '<%1 | >%2', ServContractHeader."Next Invoice Period Start", ServContractHeader."Next Invoice Period End");            exit(ServContractLine.IsEmpty);        end;        exit(true);    end;    procedure GetAffectedItemsOnContractChange(ContractNoToBeChanged: Code[20]; var TempServContract: Record "Service Contract Header"; var TempServItem: Record "Service Item"; Recursive: Boolean; ContractTypeToBeChanged: Enum "Service Contract Type")    var        ServContract: Record "Service Contract Header";        ServItem: Record "Service Item";        ServContractLine: Record "Service Contract Line";        ServContractLine2: Record "Service Contract Line";        IsHandled: Boolean;    begin        if not Recursive then begin            TempServContract.DeleteAll();            TempServItem.DeleteAll();        end;        if TempServContract.Get(ContractTypeToBeChanged, ContractNoToBeChanged) then            exit;        ServContract.Get(ContractTypeToBeChanged, ContractNoToBeChanged);        if (ServContract.Status = "Service Contract Status"::Cancelled) and           (ServContract."Contract Type" = "Service Contract Type"::Contract)        then            exit;        TempServContract := ServContract;        TempServContract.Insert();        ServContractLine.SetRange("Contract Type", ContractTypeToBeChanged);        ServContractLine.SetRange("Contract No.", ServContract."Contract No.");        ServContractLine.SetFilter("Contract Status", '<>%1', ServContractLine."Contract Status"::Cancelled);        ServContractLine.SetFilter("Service Item No.", '<>%1', '');        OnGetAffectedItemsOnContractChangeOnAfterServContractLineSetFilters(ServContractLine);        if ServContractLine.Find('-') then            repeat                if not TempServItem.Get(ServContractLine."Service Item No.") then begin                    ServItem.Get(ServContractLine."Service Item No.");                    ServItem.ErrorIfBlockedForServiceContract();                    TempServItem := ServItem;                    TempServItem.Insert();                end;                IsHandled := false;                OnGetAffectedItemsOnContractChangeOnAfterTempServItemGetOrInsert(IsHandled, ServContractLine, TempServContract, TempServItem);                if not IsHandled then begin                    ServContractLine2.Reset();                    ServContractLine2.SetCurrentKey("Service Item No.", "Contract Status");                    ServContractLine2.SetRange("Service Item No.", ServContractLine."Service Item No.");                    ServContractLine2.SetFilter("Contract Status", '<>%1', ServContractLine."Contract Status"::Cancelled);                    ServContractLine2.SetRange("Contract Type", ServContractLine."Contract Type"::Contract);                    ServContractLine2.SetFilter("Contract No.", '<>%1', ServContractLine."Contract No.");                    OnGetAffectedItemsOnContractChangeOnBeforeOnFindServContractLine2(ServContractLine2);                    if ServContractLine2.Find('-') then                        repeat                            GetAffectedItemsOnContractChange(                              ServContractLine2."Contract No.", TempServContract, TempServItem,                              true, ServContractLine."Contract Type"::Contract);                        until ServContractLine2.Next() = 0;                    ServContractLine2.Reset();                    ServContractLine2.SetCurrentKey("Service Item No.");                    ServContractLine2.SetRange("Service Item No.", ServContractLine."Service Item No.");                    ServContractLine2.SetRange("Contract Type", ServContractLine."Contract Type"::Quote);                    if ServContractLine2.Find('-') then                        repeat                            GetAffectedItemsOnContractChange(                              ServContractLine2."Contract No.", TempServContract, TempServItem,                              true, ServContractLine."Contract Type"::Quote);                        until ServContractLine2.Next() = 0;                end;            until ServContractLine.Next() = 0;    end;    procedure ChangeCustNoOnServContract(NewCustomertNo: Code[20]; NewShipToCode: Code[10]; ServContractHeader: Record "Service Contract Header")    var        ServContractLine: Record "Service Contract Line";        Cust: Record Customer;        ContractChangeLog: Record "Contract Change Log";        ServCheckCreditLimit: Codeunit "Serv. Check Credit Limit";        UserMgt: Codeunit "User Setup Management";        OldSalespersonCode: Code[20];        OldCurrencyCode: Code[10];        IsHandled: Boolean;    begin        if NewCustomertNo = '' then            Error(MustFillNewCustomerNoErr);        ServMgtSetup.Get();        OldSalespersonCode := ServContractHeader."Salesperson Code";        OldCurrencyCode := ServContractHeader."Currency Code";        if ServContractHeader."Customer No." <> NewCustomertNo then begin            if ServMgtSetup."Register Contract Changes" then                ContractChangeLog.LogContractChange(                  ServContractHeader."Contract No.", 0, ServContractHeader.FieldCaption(ServContractHeader."Customer No."), 0, ServContractHeader."Customer No.", NewCustomertNo, '', 0);            ServContractHeader."Customer No." := NewCustomertNo;            ServCheckCreditLimit.OnNewCheckRemoveCustomerNotifications(ServContractHeader.RecordId, true);            Cust.Get(NewCustomertNo);            ServContractHeader.SetHideValidationDialog(true);            IsHandled := false;            OnChangeCustNoOnServContractOnAfterGetCustomer(Cust, ServContractHeader, ServCheckCreditLimit, IsHandled);            if not IsHandled then begin                if Cust."Bill-to Customer No." <> '' then                    ServContractHeader.Validate("Bill-to Customer No.", Cust."Bill-to Customer No.")                else                    ServContractHeader.Validate("Bill-to Customer No.", Cust."No.");                ServContractHeader."Responsibility Center" := UserMgt.GetRespCenter(2, Cust."Responsibility Center");                ServContractHeader.UpdateShiptoCode();                ServContractHeader.CalcFields(Name, "Name 2", Address, "Address 2", "Post Code", City, County, "Country/Region Code");                ServCheckCreditLimit.ServiceContractHeaderCheck(ServContractHeader);            end;        end;        ProcessShiptoCodeChange(ServContractHeader, NewShipToCode, ContractChangeLog);        ServContractHeader.UpdateServZone();        ServContractHeader.UpdateCont(ServContractHeader."Customer No.");        ServContractHeader.UpdateCust(ServContractHeader."Contact No.");        ServContractHeader."Salesperson Code" := OldSalespersonCode;        ServContractHeader."Currency Code" := OldCurrencyCode;        ServContractHeader.CreateDimFromDefaultDim(0);        ServContractLine.Reset();        ServContractLine.SetRange("Contract Type", ServContractHeader."Contract Type");        ServContractLine.SetRange("Contract No.", ServContractHeader."Contract No.");        if ServContractLine.Find('-') then            repeat                ServContractLine."Customer No." := NewCustomertNo;                ServContractLine."Ship-to Code" := NewShipToCode;                ServContractLine.Modify();            until ServContractLine.Next() = 0;        OnBeforeServContractHeaderModify(ServContractHeader);        ServContractHeader.Modify();    end;    local procedure ProcessShiptoCodeChange(var ServContractHeader: Record "Service Contract Header"; NewShipToCode: Code[10]; var ContractChangeLog: Record "Contract Change Log")    begin        if ServContractHeader."Ship-to Code" <> NewShipToCode then begin            if ServMgtSetup."Register Contract Changes" then                ContractChangeLog.LogContractChange(                  ServContractHeader."Contract No.", 0, ServContractHeader.FieldCaption("Ship-to Code"), 0, ServContractHeader."Ship-to Code", NewShipToCode, '', 0);            ServContractHeader."Ship-to Code" := NewShipToCode;            if NewShipToCode = '' then                ServContractHeader.UpdateShiptoCode()            else                ServContractHeader.CalcFields(                  "Ship-to Name", "Ship-to Name 2", "Ship-to Address", "Ship-to Address 2",                  "Ship-to Post Code", "Ship-to City", "Ship-to County", "Ship-to Country/Region Code", "Ship-to Phone No.");        end;        OnAfterProcessShiptoCodeChange(ServContractHeader, NewShipToCode);    end;    procedure ChangeCustNoOnServItem(NewCustomertNo: Code[20]; NewShipToCode: Code[10]; ServItem: Record "Service Item")    var        OldServItem: Record "Service Item";        ServLogMgt: Codeunit ServLogManagement;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeChangeCustNoOnServItem(ServItem, NewCustomertNo, IsHandled);        if IsHandled then            exit;        OldServItem := ServItem;        ServItem."Customer No." := NewCustomertNo;        ServItem."Ship-to Code" := NewShipToCode;        if OldServItem."Customer No." <> NewCustomertNo then begin            ServLogMgt.ServItemCustChange(ServItem, OldServItem);            ServLogMgt.ServItemShipToCodeChange(ServItem, OldServItem);        end else            if OldServItem."Ship-to Code" <> NewShipToCode then                ServLogMgt.ServItemShipToCodeChange(ServItem, OldServItem);        ServItem.Modify();        OnAfterChangeCustNoOnServItem(ServItem);    end;    procedure CreateHeadingServiceLine(ServHeader: Record "Service Header"; ContractType: Enum "Service Contract Type"; ContractNo: Code[20])    var        ServContractHeader: Record "Service Contract Header";        Cust: Record Customer;        StdText: Record "Standard Text";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateHeadingServiceLine(ServHeader, IsHandled, ContractType, ContractNo);        if IsHandled then            exit;        ServContractHeader.Get(ContractType, ContractNo);        if ServContractHeader."Invoice Period" = ServContractHeader."Invoice Period"::None then            exit;        ServLineNo := 0;        ServLine.SetRange("Document Type", ServLine."Document Type"::Invoice);        ServLine.SetRange("Document No.", ServHeader."No.");        if ServLine.FindLast() then            ServLineNo := ServLine."Line No.";        Cust.Get(ServContractHeader."Bill-to Customer No.");        ServMgtSetup.Get();        ServLine.Reset();        ServLine.Init();        ServLineNo := ServLineNo + 10000;        ServLine."Document Type" := ServHeader."Document Type";        ServLine."Document No." := ServHeader."No.";        ServLine."Line No." := ServLineNo;        ServLine.Type := ServLine.Type::" ";        if ServMgtSetup."Contract Inv. Line Text Code" <> '' then begin            StdText.Get(ServMgtSetup."Contract Inv. Line Text Code");            TempServLineDescription := StrSubstNo('%1 %2', StdText.Description, ServContractHeader."Contract No.");            if StrLen(TempServLineDescription) > MaxStrLen(ServLine.Description) then                Error(Text013, ServLine.TableCaption(), ServLine.FieldCaption(Description),                  StdText.TableCaption(), StdText.Code, StdText.FieldCaption(Description),                  Format(StrLen(TempServLineDescription) - MaxStrLen(ServLine.Description)));            ServLine.Description := CopyStr(TempServLineDescription, 1, MaxStrLen(ServLine.Description));        end else            ServLine.Description := StrSubstNo(Text002, ServContractHeader."Contract No.");        OnCreateHeadingServLineOnBeforeServLineInsert(ServLine, ServContractHeader, ServHeader);        ServLine.Insert();    end;    procedure LookupServItemNo(var ServiceContractLine: Record "Service Contract Line")    var        ServContractHeader: Record "Service Contract Header";        ServItem: Record "Service Item";        ServItemList: Page "Service Item List";        IsHandled: Boolean;    begin        Clear(ServItemList);        if ServItem.Get(ServiceContractLine."Service Item No.") then            ServItemList.SetRecord(ServItem);        ServItem.Reset();        ServItem.SetCurrentKey("Customer No.", "Ship-to Code");        ServItem.FilterGroup(2);        ServItem.SetRange(Blocked, ServItem.Blocked::" ");        IsHandled := false;        OnLookupServItemNoOnBeforeFilterByCustomerNo(ServItem, ServiceContractLine, IsHandled);        if not IsHandled then            if ServiceContractLine."Customer No." <> '' then                ServItem.SetRange("Customer No.", ServiceContractLine."Customer No.");        ServItem.FilterGroup(0);        if ServContractHeader.Get(ServiceContractLine."Contract Type", ServiceContractLine."Contract No.") and           (ServiceContractLine."Ship-to Code" = ServContractHeader."Ship-to Code")        then            ServItem.SetRange("Ship-to Code", ServiceContractLine."Ship-to Code");        OnLookupServItemNoOnAfterServItemSetFilters(ServItem, ServiceContractLine);        ServItemList.SetTableView(ServItem);        ServItemList.LookupMode(true);        if ServItemList.RunModal() = ACTION::LookupOK then begin            ServItemList.GetRecord(ServItem);            ServiceContractLine.Validate("Service Item No.", ServItem."No.");        end;    end;    procedure AmountToFCY(AmountLCY: Decimal; var ServHeader3: Record "Service Header"): Decimal    var        CurrExchRate: Record "Currency Exchange Rate";        Currency: Record Currency;    begin        Currency.Get(ServHeader3."Currency Code");        Currency.TestField("Unit-Amount Rounding Precision");        exit(          Round(            CurrExchRate.ExchangeAmtLCYToFCY(              ServHeader3."Posting Date", ServHeader3."Currency Code",              AmountLCY, ServHeader3."Currency Factor"),            Currency."Unit-Amount Rounding Precision"));    end;    procedure IsYearContract(ContractType: Enum "Service Contract Type"; ContrNo: Code[20]): Boolean    var        ServContrHeader: Record "Service Contract Header";    begin        if not ServContrHeader.Get(ContractType, ContrNo) then            exit(false);        exit(ServContrHeader."Expiration Date" = CalcDate('<1Y-1D>', ServContrHeader."Starting Date"));    end;    local procedure FillTempServiceLedgerEntries(ServiceContractHeader: Record "Service Contract Header")    var        ServiceLedgerEntry: Record "Service Ledger Entry";        DoInsertTempServiceLedgerEntry: Boolean;    begin        if TempServLedgEntriesIsSet then            exit;        TempServLedgEntry.DeleteAll();        ServiceLedgerEntry.SetRange("Service Contract No.", ServiceContractHeader."Contract No.");        ServiceLedgerEntry.SetRange("Entry Type", ServiceLedgerEntry."Entry Type"::Sale);        if not ServiceLedgerEntry.FindSet() then            exit;        repeat            DoInsertTempServiceLedgerEntry := true;            OnFillTempServiceLedgerEntriesOAfterCalcDoInsertTempServiceLedgerEntry(ServiceLedgerEntry, DoInsertTempServiceLedgerEntry);            if DoInsertTempServiceLedgerEntry then begin                TempServLedgEntry := ServiceLedgerEntry;                TempServLedgEntry.Insert();            end;        until ServiceLedgerEntry.Next() = 0;        TempServLedgEntriesIsSet := true;    end;    local procedure LookUpAmountToCredit(ServItemNo: Code[20]; ItemNo: Code[20]; PostingDate: Date; var LineAmount: Decimal; var CostAmount: Decimal; var UnitPrice: Decimal; var DiscountAmt: Decimal; var ServLedgEntryNo: Integer): Boolean    begin        LineAmount := 0;        CostAmount := 0;        UnitPrice := 0;        DiscountAmt := 0;        ServLedgEntryNo := 0;        TempServLedgEntry.Reset();        if ServItemNo <> '' then            TempServLedgEntry.SetRange("Service Item No. (Serviced)", ServItemNo);        if ItemNo <> '' then            TempServLedgEntry.SetRange("Item No. (Serviced)", ItemNo);        TempServLedgEntry.SetRange("Posting Date", PostingDate);        if not TempServLedgEntry.FindFirst() then            exit(false);        LineAmount := -TempServLedgEntry."Amount (LCY)";        CostAmount := TempServLedgEntry."Cost Amount";        UnitPrice := -TempServLedgEntry."Unit Price";        DiscountAmt := TempServLedgEntry."Discount Amount";        ServLedgEntryNo := TempServLedgEntry."Entry No.";        TempServLedgEntry.Delete();        exit(true);    end;    procedure CheckServiceContractHeaderAmts(ServiceContractHeader: Record "Service Contract Header")    begin        if ServiceContractHeader."Calcd. Annual Amount" <> ServiceContractHeader."Annual Amount" then            Error(              Text000,              ServLedgEntry2.TableCaption(),              ServiceContractHeader."Contract No.",              ServiceContractHeader.FieldCaption("Calcd. Annual Amount"),              ServiceContractHeader.FieldCaption("Annual Amount"));    end;    procedure SetServiceLedgerEntryUnitCost(var ServiceLedgerEntry: Record "Service Ledger Entry")    begin        if ServiceLedgerEntry."Charged Qty." = 0 then            ServiceLedgerEntry."Unit Cost" := -ServiceLedgerEntry."Cost Amount"        else            ServiceLedgerEntry."Unit Cost" := ServiceLedgerEntry."Cost Amount" / ServiceLedgerEntry."Charged Qty.";    end;    local procedure ServLedgEntryToServiceLine(var TotalServLine: Record "Service Line"; var TotalServLineLCY: Record "Service Line"; ServHeader: Record "Service Header"; ServiceLedgerEntry: Record "Service Ledger Entry"; ContractNo: Code[20]; InvFrom: Date; InvTo: Date)    var        StdText: Record "Standard Text";        IsHandled: Boolean;    begin        OnBeforeServLedgEntryToServiceLine(TotalServLine, TotalServLineLCY, ServHeader, ServLedgEntry, IsHandled, ServiceLedgerEntry, InvFrom, InvTo);        if IsHandled then            exit;        ServLineNo := ServLineNo + 10000;        ServLine.Reset();        ServLine.Init();        ServLine."Document Type" := ServHeader."Document Type";        ServLine."Document No." := ServHeader."No.";        ServLine."Line No." := ServLineNo;        ServLine."Customer No." := ServHeader."Customer No.";        ServLine."Location Code" := ServHeader."Location Code";        ServLine."Gen. Bus. Posting Group" := ServHeader."Gen. Bus. Posting Group";        ServLine."Transaction Specification" := ServHeader."Transaction Specification";        ServLine."Transport Method" := ServHeader."Transport Method";        ServLine."Exit Point" := ServHeader."Exit Point";        ServLine."Area" := ServHeader.Area;        ServLine."Transaction Specification" := ServHeader."Transaction Specification";        InitServiceLineAppliedGLAccount();        ServLine.Validate(ServLine.Quantity, 1);        if ServMgtSetup."Contract Inv. Period Text Code" <> '' then begin            StdText.Get(ServMgtSetup."Contract Inv. Period Text Code");            TempServLineDescription := StrSubstNo('%1 %2 - %3', StdText.Description, Format(InvFrom), Format(InvTo));            if StrLen(TempServLineDescription) > MaxStrLen(ServLine.Description) then                Error(                  Text013,                  ServLine.TableCaption, ServLine.FieldCaption(ServLine.Description),                  StdText.TableCaption(), StdText.Code, StdText.FieldCaption(Description),                  Format(StrLen(TempServLineDescription) - MaxStrLen(ServLine.Description)));            ServLine.Description := CopyStr(TempServLineDescription, 1, MaxStrLen(ServLine.Description));        end else            ServLine.Description :=              StrSubstNo('%1 - %2', Format(InvFrom), Format(InvTo));        ServLine."Contract No." := ContractNo;        ServLine."Appl.-to Service Entry" := ServiceLedgerEntry."Entry No.";        ServLine."Service Item No." := ServiceLedgerEntry."Service Item No. (Serviced)";        ServLine."Unit Cost (LCY)" := ServiceLedgerEntry."Unit Cost";        ServLine."Unit Price" := -ServiceLedgerEntry."Unit Price";        TotalServLine."Unit Price" += ServLine."Unit Price";        TotalServLine."Line Amount" += -ServiceLedgerEntry."Amount (LCY)";        if (ServiceLedgerEntry."Amount (LCY)" <> 0) or (ServiceLedgerEntry."Discount %" > 0) then            if ServHeader."Currency Code" <> '' then begin                ServLine.Validate(ServLine."Unit Price",                  AmountToFCY(TotalServLine."Unit Price", ServHeader) - TotalServLineLCY."Unit Price");                ServLine.Validate(ServLine."Line Amount",                  AmountToFCY(TotalServLine."Line Amount", ServHeader) - TotalServLineLCY."Line Amount");            end else begin                ServLine.Validate(ServLine."Unit Price");                ServLine.Validate(ServLine."Line Amount", -ServiceLedgerEntry."Amount (LCY)");            end;        TotalServLineLCY."Unit Price" += ServLine."Unit Price";        TotalServLineLCY."Line Amount" += ServLine."Line Amount";        IsHandled := false;        OnServLedgEntryToServiceLineOnBeforeDimSet(ServLine, ServiceLedgerEntry, ServHeader, IsHandled);        if IsHandled then            exit;        ServLine."Shortcut Dimension 1 Code" := ServiceLedgerEntry."Global Dimension 1 Code";        ServLine."Shortcut Dimension 2 Code" := ServiceLedgerEntry."Global Dimension 2 Code";        ServLine."Dimension Set ID" := ServiceLedgerEntry."Dimension Set ID";        IsHandled := false;        OnServLedgEntryToServiceLineOnBeforeServLineInsert(ServLine, TotalServLine, TotalServLineLCY, ServHeader, ServLedgEntry, ServiceLedgerEntry, IsHandled, InvFrom, InvTo);        if IsHandled then            exit;        ServLine.Insert();        ServLine.CreateDimFromDefaultDim(0);    end;    local procedure InitServiceLineAppliedGLAccount()    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInitServiceLineAppliedGLAccount(ServLine, AppliedGLAccount, IsHandled);        if IsHandled then            exit;        ServLine.Type := ServLine.Type::"G/L Account";        ServLine.Validate("No.", AppliedGLAccount);    end;    procedure CheckMultipleCurrenciesForCustomers(var ServiceContractHeader: Record "Service Contract Header")    var        ServiceContractHeader2: Record "Service Contract Header";        PrevCustNo: Code[20];        PrevCurrencyCode: Code[10];        IsHandled: Boolean;        IsFirstRecord: Boolean;    begin        IsHandled := false;        OnBeforeCheckMultipleCurrenciesForCustomers(ServiceContractHeader, IsHandled);        if IsHandled then            exit;        PrevCustNo := '';        PrevCurrencyCode := '';        IsFirstRecord := true;        ServiceContractHeader2.Copy(ServiceContractHeader);        ServiceContractHeader2.SetCurrentKey("Bill-to Customer No.", "Contract Type", "Combine Invoices", "Next Invoice Date");        ServiceContractHeader2.SetRange("Combine Invoices", true);        if ServiceContractHeader2.FindSet() then            repeat                if IsFirstRecord or (PrevCustNo <> ServiceContractHeader2."Bill-to Customer No.") then begin                    IsFirstRecord := false;                    PrevCustNo := ServiceContractHeader2."Bill-to Customer No.";                    PrevCurrencyCode := ServiceContractHeader2."Currency Code";                end else                    if PrevCurrencyCode <> ServiceContractHeader2."Currency Code" then                        Error(ErrorSplitErr,                          StrSubstNo(CombinedCurrenciesErr1,                            ServiceContractHeader2."Bill-to Customer No.",                            ShownCurrencyText(PrevCurrencyCode),                            ShownCurrencyText(ServiceContractHeader2."Currency Code")),                          CombinedCurrenciesErr2);            until ServiceContractHeader2.Next() = 0;    end;    procedure CheckCustomerCurrencyCombination(var ServiceContractHeader: Record "Service Contract Header")    var        ServiceContractHeader2: Record "Service Contract Header";    begin        ServiceContractHeader2.Copy(ServiceContractHeader);        ServiceContractHeader2.SetRange("Bill-to Customer No.", ServiceContractHeader."Bill-to Customer No.");        ServiceContractHeader2.SetFilter("Currency Code", '<>%1', ServiceContractHeader."Currency Code");        if ServiceContractHeader2.FindFirst() then            Error(ErrorSplitErr,              StrSubstNo(CombinedCurrenciesErr1,                ServiceContractHeader2."Bill-to Customer No.",                ShownCurrencyText(ServiceContractHeader2."Currency Code"),                ShownCurrencyText(ServiceContractHeader."Currency Code")),              CombinedCurrenciesErr2);    end;    local procedure ShownCurrencyText(CurrCode: Code[10]): Text    begin        if CurrCode = '' then            exit(BlankTxt);        exit(CurrCode);    end;    procedure InitServLedgEntry(var ServLedgEntry: Record "Service Ledger Entry"; ServContractHeader: Record "Service Contract Header"; DocNo: Code[20])    begin        ServLedgEntry.Init();        ServLedgEntry.Type := ServLedgEntry.Type::"Service Contract";        ServLedgEntry."No." := ServContractHeader."Contract No.";        ServLedgEntry."Service Contract No." := ServContractHeader."Contract No.";        ServLedgEntry."Document Type" := ServLedgEntry."Document Type"::" ";        ServLedgEntry."Document No." := DocNo;        ServLedgEntry."Serv. Contract Acc. Gr. Code" := ServContractHeader."Serv. Contract Acc. Gr. Code";        ServLedgEntry."Bill-to Customer No." := ServContractHeader."Bill-to Customer No.";        ServLedgEntry."Customer No." := ServContractHeader."Customer No.";        ServLedgEntry."Ship-to Code" := ServContractHeader."Ship-to Code";        ServLedgEntry."Global Dimension 1 Code" := ServContractHeader."Shortcut Dimension 1 Code";        ServLedgEntry."Global Dimension 2 Code" := ServContractHeader."Shortcut Dimension 2 Code";        ServLedgEntry."Dimension Set ID" := ServContractHeader."Dimension Set ID";        ServLedgEntry."Entry Type" := ServLedgEntry."Entry Type"::Sale;        ServLedgEntry."User ID" := CopyStr(UserId(), 1, MaxStrLen(ServLedgEntry."User ID"));        ServLedgEntry."Contract Invoice Period" := Format(ServContractHeader."Invoice Period");        ServLedgEntry."Contract Group Code" := ServContractHeader."Contract Group Code";        ServLedgEntry."Responsibility Center" := ServContractHeader."Responsibility Center";        ServLedgEntry.Open := true;        ServLedgEntry.Quantity := -1;        ServLedgEntry."Charged Qty." := -1;        OnAfterInitServLedgEntry(ServLedgEntry, ServContractHeader);    end;    procedure GetInvoicePeriodText(InvoicePeriod: Enum "Service Contract Header Invoice Period") InvPeriodText: Text[4]    var        ServiceContractHeader: Record "Service Contract Header";    begin        case InvoicePeriod of            ServiceContractHeader."Invoice Period"::Month:                exit('<1M>');            ServiceContractHeader."Invoice Period"::"Two Months":                exit('<2M>');            ServiceContractHeader."Invoice Period"::Quarter:                exit('<3M>');            ServiceContractHeader."Invoice Period"::"Half Year":                exit('<6M>');            ServiceContractHeader."Invoice Period"::Year:                exit('<1Y>');            else                OnGetInvoicePeriodTextOnCaseElse(InvoicePeriod, InvPeriodText);        end;    end;    procedure FilterServiceContractLine(var ServContractLine: Record "Service Contract Line"; ContractNo: Code[20]; ContractType: Enum "Service Contract Type"; LineNo: Integer)    begin        ServContractLine.Reset();        ServContractLine.SetRange("Contract No.", ContractNo);        ServContractLine.SetRange("Contract Type", ContractType);        if LineNo <> 0 then            ServContractLine.SetRange("Line No.", LineNo);        OnAfterFilterServContractLine(ServContractLine, ContractNo, ContractType.AsInteger());    end;    local procedure CountLineInvFrom(SigningContract: Boolean; ServContractLine: Record "Service Contract Line"; InvFrom: Date) LineInvFrom: Date    begin        if ServContractLine."Invoiced to Date" = 0D then            LineInvFrom := ServContractLine."Starting Date"        else            if SigningContract then begin                if ServContractLine."Invoiced to Date" <> CalcDate('<CM>', ServContractLine."Invoiced to Date") then                    LineInvFrom := ServContractLine."Invoiced to Date" + 1            end else                LineInvFrom := InvFrom;    end;    local procedure CalcServLedgEntryAmounts(var ServContractLine: Record "Service Contract Line"; var InvAmountRounded: array[4] of Decimal)    var        ServLedgEntry2: Record "Service Ledger Entry";        AccumulatedAmts: array[4] of Decimal;        i: Integer;    begin        ServLedgEntry2.SetCurrentKey("Service Contract No.");        ServLedgEntry2.SetRange("Service Contract No.", ServContractLine."Contract No.");        ServLedgEntry2.SetRange("Service Item No. (Serviced)", ServContractLine."Service Item No.");        ServLedgEntry2.SetRange("Entry Type", ServLedgEntry2."Entry Type"::Sale);        for i := 1 to 4 do            AccumulatedAmts[i] := 0;        if ServLedgEntry2.FindSet() then            repeat                AccumulatedAmts[AmountType::UnitCost] :=                  AccumulatedAmts[AmountType::UnitCost] + ServLedgEntry2."Cost Amount";                AccumulatedAmts[AmountType::Amount] :=                  AccumulatedAmts[AmountType::Amount] - ServLedgEntry2."Amount (LCY)";                AccumulatedAmts[AmountType::DiscAmount] :=                  AccumulatedAmts[AmountType::DiscAmount] + ServLedgEntry2."Discount Amount";                AccumulatedAmts[AmountType::UnitPrice] :=                  AccumulatedAmts[AmountType::UnitPrice] - ServLedgEntry2."Unit Price";            until ServLedgEntry2.Next() = 0;        ServLedgEntry."Cost Amount" := -Round(ServContractLine."Line Cost" + AccumulatedAmts[AmountType::UnitCost]);        SetServiceLedgerEntryUnitCost(ServLedgEntry);        ServLedgEntry."Amount (LCY)" := AccumulatedAmts[AmountType::Amount] - ServContractLine."Line Amount";        ServLedgEntry."Discount Amount" := ServContractLine."Line Discount Amount" - AccumulatedAmts[AmountType::DiscAmount];        ServLedgEntry."Contract Disc. Amount" := ServLedgEntry."Discount Amount";        ServLedgEntry."Unit Price" := AccumulatedAmts[AmountType::UnitPrice] - ServContractLine."Line Value";        CalcServLedgEntryDiscountPct(ServLedgEntry);        InvAmountRounded[AmountType::Amount] -= ServLedgEntry."Amount (LCY)";        InvAmountRounded[AmountType::UnitPrice] -= ServLedgEntry."Unit Price";        InvAmountRounded[AmountType::UnitCost] += ServLedgEntry."Unit Cost";        InvAmountRounded[AmountType::DiscAmount] += ServLedgEntry."Contract Disc. Amount";    end;    procedure UpdateServLedgEntryAmount(var ServLedgEntry: Record "Service Ledger Entry"; var ServHeader: Record "Service Header")    begin        if ServHeader."Currency Code" <> '' then            ServLedgEntry.Amount := AmountToFCY(ServLedgEntry."Amount (LCY)", ServHeader)        else            ServLedgEntry.Amount := ServLedgEntry."Amount (LCY)";    end;    procedure CalcInvoicedToDate(var ServContractLine: Record "Service Contract Line"; InvFrom: Date; InvTo: Date)    begin        if ServContractLine."Contract Expiration Date" <> 0D then begin            if (ServContractLine."Contract Expiration Date" >= InvFrom) and               (ServContractLine."Contract Expiration Date" <= InvTo)            then                ServContractLine."Invoiced to Date" := ServContractLine."Contract Expiration Date"            else                if ServContractLine."Contract Expiration Date" > InvTo then                    ServContractLine."Invoiced to Date" := InvTo;        end else            ServContractLine."Invoiced to Date" := InvTo;    end;    local procedure CreateDescriptionServiceLines(ServContractLineItemNo: Code[20]; ServContractLineDesc: Text[100]; ServContractLineItemSerialNo: Code[50])    var        ServLineDescription: Text;        RequiredLength: Integer;        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCreateDescriptionServiceLines(ServContractLineItemNo, ServContractLineDesc, ServContractLineItemSerialNo, IsHandled);        if IsHandled then            exit;        if ServContractLineItemNo <> '' then begin            ServLineDescription := StrSubstNo('%1 %2 %3', ServContractLineItemNo, ServContractLineDesc, ServContractLineItemSerialNo);            OnCreateDescriptionServiceLinesOnAfterCalcServLineDescription(ServLineDescription, ServContractLineItemNo, ServContractLineDesc, ServContractLineItemSerialNo);            RequiredLength := MaxStrLen(ServLine.Description);            InsertDescriptionServiceLine(CopyStr(ServLineDescription, 1, RequiredLength));            if StrLen(ServLineDescription) > RequiredLength then                InsertDescriptionServiceLine(CopyStr(ServLineDescription, RequiredLength + 1, RequiredLength))        end else            InsertDescriptionServiceLine(ServContractLineDesc);    end;    local procedure InsertDescriptionServiceLine(Description: Text[100])    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeInsertDescriptionServiceLine(ServLine, Description, IsHandled);        if IsHandled then            exit;        ServLine.Init();        ServLine."Line No." := ServLine.GetLineNo();        ServLine.Description := Description;        OnInsertDescriptionServiceLineOnBeforeServiceLineInsert(ServLine);        ServLine.Insert();    end;    local procedure UpdateApplyUntilEntryNoInServLedgEntry(ServContractHeader: Record "Service Contract Header"; SigningContract: Boolean; ReturnLedgerEntry: Integer; FirstLineEntry: Integer; LastEntry: Integer)    var        ServLedgEntry: Record "Service Ledger Entry";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeUpdateApplyUntilEntryNoInServLedgEntry(ServContractHeader, SigningContract, ReturnLedgerEntry, FirstLineEntry, LastEntry, IsHandled);        if IsHandled then            exit;        if ReturnLedgerEntry <> 0 then            if ServLedgEntry.Get(FirstLineEntry) then begin                ServLedgEntry."Apply Until Entry No." := LastEntry;                ServLedgEntry.Modify();            end;    end;    local procedure PostPartialServLedgEntry(var InvAmountRounded: array[4] of Decimal; ServContractLine: Record "Service Contract Line"; ServHeader: Record "Service Header"; InvFrom: Date; InvTo: Date; DueDate: Date; AmtRoundingPrecision: Decimal) YearContractCorrection: Boolean    var        AmountLCY: Decimal;        UnitPrice: Decimal;        UnitCost: Decimal;        ContractDiscAmt: Decimal;    begin        OnBeforePostPartialServLedgEntry(ServLedgEntry, ServContractLine);        ServLedgEntry."Service Item No. (Serviced)" := ServContractLine."Service Item No.";        ServLedgEntry."Item No. (Serviced)" := ServContractLine."Item No.";        ServLedgEntry."Serial No. (Serviced)" := ServContractLine."Serial No.";        if IsYearContract(ServContractLine."Contract Type", ServContractLine."Contract No.") then begin            YearContractCorrection := true;            if not YearContractCorrection then                CalcServLedgEntryAmounts(ServContractLine, InvAmountRounded);        end else            YearContractCorrection := false;        CalcAndSetRemainingAmount(            ServLedgEntry, ServContractLine, AmountLCY, UnitPrice, UnitCost,            ContractDiscAmt, InvFrom, InvTo, AmtRoundingPrecision);        SetServLedgEntryAmounts(            ServLedgEntry, InvAmountRounded, AmountLCY, UnitPrice,            UnitCost, ContractDiscAmt, AmtRoundingPrecision);        ServLedgEntry."Entry No." := NextEntryNo;        UpdateServLedgEntryAmount(ServLedgEntry, ServHeader);        ServLedgEntry."Posting Date" := DueDate;        ServLedgEntry.Prepaid := true;        ServLedgEntry."Service Register No." := ServiceRegister."No.";        OnPostPartialServLedgEntryOnBeforeServLedgEntryInsert(ServLedgEntry, ServContractLine, ServHeader);        ServLedgEntry.Insert();        PrevEntryNo := NextEntryNo;        if ServMgtSetup.UseLegacyPosting() then            NextEntryNo := NextEntryNo + 1        else            NextEntryNo := ServLedgEntry.GetNextEntryNo();        exit(YearContractCorrection);    end;    procedure SetServLedgEntryAmounts(var ServLedgEntry: Record "Service Ledger Entry"; var EntryAmount: array[4] of Decimal; Amount: Decimal; UnitPrice: Decimal; CostAmount: Decimal; DiscAmount: Decimal; AmtRoundingPrecision: Decimal)    begin        ServLedgEntry."Amount (LCY)" := Round(Amount, AmtRoundingPrecision);        ServLedgEntry."Unit Price" := Round(UnitPrice, AmtRoundingPrecision);        ServLedgEntry."Unit Cost" := Round(CostAmount, AmtRoundingPrecision);        ServLedgEntry."Contract Disc. Amount" := Round(DiscAmount, AmtRoundingPrecision);        ServLedgEntry."Discount Amount" := ServLedgEntry."Contract Disc. Amount";        CalcServLedgEntryDiscountPct(ServLedgEntry);        EntryAmount[AmountType::Amount] -= ServLedgEntry."Amount (LCY)";        EntryAmount[AmountType::UnitPrice] -= ServLedgEntry."Unit Price";        EntryAmount[AmountType::UnitCost] += ServLedgEntry."Unit Cost";        EntryAmount[AmountType::DiscAmount] += ServLedgEntry."Contract Disc. Amount";    end;    procedure CalcInvAmounts(var InvAmount: array[4] of Decimal; ServContractLine: Record "Service Contract Line"; InvFrom: Date; InvTo: Date)    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCalcInvAmounts(InvAmount, ServContractLine, InvFrom, InvTo, IsHandled);        if IsHandled then            exit;        InvAmount[AmountType::Amount] +=          CalcContractLineAmount(ServContractLine."Line Amount", InvFrom, InvTo);        InvAmount[AmountType::UnitPrice] +=          CalcContractLineAmount(ServContractLine."Line Value", InvFrom, InvTo);        InvAmount[AmountType::UnitCost] +=          CalcContractLineAmount(ServContractLine."Line Cost", InvFrom, InvTo);        InvAmount[AmountType::DiscAmount] +=          CalcContractLineAmount(ServContractLine."Line Discount Amount", InvFrom, InvTo);    end;    procedure InsertMultipleServLedgEntries(var NoOfPayments: Integer; var DueDate: Date; var NonDistrAmount: array[4] of Decimal; var InvRoundedAmount: array[4] of Decimal; var ServHeader: Record "Service Header"; InvFrom: Date; NextInvDate: Date; AddingNewLines: Boolean; CountOfEntryLoop: Integer; ServContractLine: Record "Service Contract Line"; AmountRoundingPrecision: Decimal)    var        ServContractHeader: Record "Service Contract Header";        Index: Integer;        IsHandled, ShouldUpdatePaymentsCount : Boolean;    begin        if CountOfEntryLoop = 0 then            exit;        OnBeforeInsertMultipleServLedgEntries(ServLedgEntry, ServContractLine);        CheckMParts := false;        if DueDate <> CalcDate('<CM>', DueDate) then begin            DueDate := CalcDate('<-CM-1D>', DueDate);            ServContractHeader.Get(ServContractLine."Contract Type", ServContractLine."Contract No.");            CheckMParts := true;        end;        OnInsertMultipleServLedgEntriesOnUpdateDateFieldsBeforeCalcNonDistrAmount(InvFrom, DueDate, NoOfPayments);        NonDistrAmount[AmountType::Amount] :=          -CalcContractLineAmount(ServContractLine."Line Amount", InvFrom, DueDate);        NonDistrAmount[AmountType::UnitPrice] :=          -CalcContractLineAmount(ServContractLine."Line Value", InvFrom, DueDate);        NonDistrAmount[AmountType::UnitCost] :=          CalcContractLineAmount(ServContractLine."Line Cost", InvFrom, DueDate);        NonDistrAmount[AmountType::DiscAmount] :=          CalcContractLineAmount(ServContractLine."Line Discount Amount", InvFrom, DueDate);        ServLedgEntry."Service Item No. (Serviced)" := ServContractLine."Service Item No.";        ServLedgEntry."Item No. (Serviced)" := ServContractLine."Item No.";        ServLedgEntry."Serial No. (Serviced)" := ServContractLine."Serial No.";        DueDate := NextInvDate;        ShouldUpdatePaymentsCount := CheckMParts and (NoOfPayments > 1);        OnInsertMultipleServLedgEntriesOnBeforeUpdatePaymentsCount(CheckMParts, NoOfPayments, CountOfEntryLoop, ShouldUpdatePaymentsCount);        if ShouldUpdatePaymentsCount then begin            NoOfPayments := NoOfPayments - 1;            // the count of invoice lines should never exceed the count of payments            if CountOfEntryLoop > NoOfPayments then                CountOfEntryLoop := NoOfPayments;        end;        if AddingNewLines then            DueDate := InvFrom;        for Index := 1 to CountOfEntryLoop do begin            IsHandled := false;            OnInsertMultipleServLedgEntriesOnBeforeSetServLedgEntryAmounts(ServLedgEntry, InvRoundedAmount, NonDistrAmount, NoOfPayments, Index, CountOfEntryLoop, AmountRoundingPrecision, DueDate, IsHandled);            if not IsHandled then                SetServLedgEntryAmounts(                  ServLedgEntry, InvRoundedAmount,                  NonDistrAmount[AmountType::Amount] / (NoOfPayments + 1 - Index),                  NonDistrAmount[AmountType::UnitPrice] / (NoOfPayments + 1 - Index),                  NonDistrAmount[AmountType::UnitCost] / (NoOfPayments + 1 - Index),                  NonDistrAmount[AmountType::DiscAmount] / (NoOfPayments + 1 - Index),                  AmountRoundingPrecision);            ServLedgEntry."Cost Amount" := ServLedgEntry."Charged Qty." * ServLedgEntry."Unit Cost";            NonDistrAmount[AmountType::Amount] -= ServLedgEntry."Amount (LCY)";            NonDistrAmount[AmountType::UnitPrice] -= ServLedgEntry."Unit Price";            NonDistrAmount[AmountType::UnitCost] -= ServLedgEntry."Unit Cost";            NonDistrAmount[AmountType::DiscAmount] -= ServLedgEntry."Contract Disc. Amount";            ServLedgEntry."Entry No." := NextEntryNo;            UpdateServLedgEntryAmount(ServLedgEntry, ServHeader);            ServLedgEntry."Posting Date" := DueDate;            ServLedgEntry.Prepaid := true;            IsHandled := false;            OnInsertMultipleServLedgEntriesOnBeforeServLedgEntryInsert(ServLedgEntry, ServContractHeader, ServContractLine, NonDistrAmount, IsHandled, ServHeader);            if IsHandled then                exit;            ServLedgEntry."Service Register No." := ServiceRegister."No.";            ServLedgEntry.Insert();            PrevEntryNo := NextEntryNo;            if ServMgtSetup.UseLegacyPosting() then                NextEntryNo := NextEntryNo + 1            else                NextEntryNo := ServLedgEntry.GetNextEntryNo();            DueDate := CalcDate('<1M>', DueDate);            OnInsertMultipleServLedgEntriesOnAfterSetDueDate(Index, DueDate, ServLedgEntry, CountOfEntryLoop, InvRoundedAmount, NonDistrAmount, ServHeader, AmountRoundingPrecision);        end;    end;    local procedure SetSalespersonCode(SalesPersonCodeToCheck: Code[20]; var SalesPersonCodeToAssign: Code[20])    var        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeSetSalespersonCode(SalesPersonCodeToCheck, SalesPersonCodeToAssign, IsHandled);        if IsHandled then            exit;        if SalesPersonCodeToCheck <> '' then            if Salesperson.Get(SalesPersonCodeToCheck) then                if Salesperson.VerifySalesPersonPurchaserPrivacyBlocked(Salesperson) then                    SalesPersonCodeToAssign := ''                else                    SalesPersonCodeToAssign := SalesPersonCodeToCheck;    end;    local procedure CheckAndCreateServiceLinesForPartOfTheMonth(        ServiceContractHeader: Record "Service Contract Header";        ServiceContractLine: Record "Service Contract Line";        ServiceHeader: Record "Service Header";        var PartInvoiceFrom: Date;        var PartInvoiceTo: Date)    var        ServiceApplyEntryNo: Integer;    begin        if (ServiceContractLine."Starting Date" < ServiceContractHeader."Next Invoice Date") and           (ServiceContractLine."Invoiced to Date" = 0D) and (WorkDate() < ServiceContractHeader."Next Invoice Date")        then begin            PartInvoiceFrom := ServiceContractLine."Starting Date";            PartInvoiceTo := ServiceContractHeader."Next Invoice Date" - 1;            ServiceApplyEntryNo :=                CreateServiceLedgEntry(                    ServiceHeader,                    ServiceContractHeader."Contract Type",                    ServiceContractHeader."Contract No.",                    CalcDate('<-CM>', PartInvoiceFrom),                    PartInvoiceTo,                    false,                    false,                    ServiceContractLine."Line No.");            if ServiceApplyEntryNo <> 0 then                CreateServiceLine(                    ServiceHeader,                    ServiceContractHeader."Contract Type",                    ServiceContractHeader."Contract No.",                    PartInvoiceFrom,                    PartInvoiceTo,                    ServiceApplyEntryNo,                    false);        end;    end;    local procedure GetDateExpression(Day1: Date): Text[10]    var        TypeHelper: Codeunit "Type Helper";    begin        if (Date2DMY(Day1, 2) = 2) and TypeHelper.IsLeapYear(Day1) then            exit('<CM-1D>');        exit('<CM>');    end;    local procedure CheckCustomerBusPostingGroup(): Boolean    var        ApplicationAreaMgmt: Codeunit System.Environment.Configuration."Application Area Mgmt.";        IsHandled: Boolean;        Result: Boolean;    begin        IsHandled := false;        OnBeforeCheckCustomer(result, IsHandled);        if IsHandled then            exit;        Result := not ApplicationAreaMgmt.IsSalesTaxEnabled();    end;    local procedure CalcAndSetRemainingAmount(ServLedgerEntry: Record "Service Ledger Entry"; ServContractLine: Record "Service Contract Line"; var AmountLCY: Decimal; var UnitPrice: Decimal; var UnitCost: Decimal; var ContractDiscAmt: Decimal; InvFrom: Date; InvTo: Date; AmtRoundingPrecision: Decimal)    var        ServiceLedgerEntry: Record "Service Ledger Entry";        ServiceContractHeader: Record "Service Contract Header";        RemainingAmount: Decimal;    begin        ServiceContractHeader.Get(ServContractLine."Contract Type", ServContractLine."Contract No.");        ServiceLedgerEntry.SetRange("Service Contract No.", ServContractLine."Contract No.");        ServiceLedgerEntry.SetRange("Document No.", ServLedgerEntry."Document No.");        if ServiceLedgerEntry.FindSet() then begin            ServiceLedgerEntry.CalcSums(Amount);            RemainingAmount := ServiceContractHeader."Annual Amount" - Abs(ServiceLedgerEntry.Amount);        end;        AmountLCY := Round(-CalcContractLineAmount(ServContractLine."Line Amount", InvFrom, InvTo), AmtRoundingPrecision);        UnitPrice := Round(-CalcContractLineAmount(ServContractLine."Line Value", InvFrom, InvTo), AmtRoundingPrecision);        UnitCost := Round(-CalcContractLineAmount(ServContractLine."Line Cost", InvFrom, InvTo), AmtRoundingPrecision);        ContractDiscAmt := Round(-CalcContractLineAmount(ServContractLine."Line Discount Amount", InvFrom, InvTo), AmtRoundingPrecision);        if RemainingAmount = 0 then            exit;        if (AmountLCY <> 0) and ((Abs(AmountLCY) - Abs(RemainingAmount)) = AmtRoundingPrecision) then            AmountLCY := -RemainingAmount;        if (UnitPrice <> 0) and ((Abs(UnitPrice) - Abs(RemainingAmount)) = AmtRoundingPrecision) then            UnitPrice := -RemainingAmount;        if (UnitCost <> 0) and ((Abs(UnitCost) - Abs(RemainingAmount)) = AmtRoundingPrecision) then            UnitCost := -RemainingAmount;        if (ContractDiscAmt <> 0) and ((Abs(ContractDiscAmt) - Abs(RemainingAmount)) = AmtRoundingPrecision) then            ContractDiscAmt := -RemainingAmount;    end;    #region Service Item Blocked checks    procedure CheckServiceItemBlockedForServiceContract(var ServiceContractLine: Record "Service Contract Line")    var        ServiceItem: Record "Service Item";    begin        if ServiceContractLine."Service Item No." = '' then            exit;        ServiceItem.SetLoadFields(Blocked);        ServiceItem.Get(ServiceContractLine."Service Item No.");        ServiceItem.ErrorIfBlockedForServiceContract();    end;    procedure CheckServiceItemBlockedForAll(var ServiceContractLine: Record "Service Contract Line")    var        ServiceItem: Record "Service Item";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckServiceItemBlockedForAll(ServiceContractLine, IsHandled);        if IsHandled then            exit;        if ServiceContractLine."Service Item No." = '' then            exit;        ServiceItem.SetLoadFields(Blocked);        ServiceItem.Get(ServiceContractLine."Service Item No.");        ServiceItem.ErrorIfBlockedForAll();    end;    # endregion Service Item Blocked checks    # region Item Service Blocked checks    procedure CheckItemServiceBlocked(var ServiceContractLine: Record "Service Contract Line")    var        Item: Record Item;        ItemVariant: Record "Item Variant";        IsHandled: Boolean;    begin        IsHandled := false;        OnBeforeCheckItemServiceBlocked(ServiceContractLine, IsHandled);        if IsHandled then            exit;        if ServiceContractLine."Item No." = '' then            exit;        Item.SetLoadFields(Blocked, "Service Blocked");        Item.Get(ServiceContractLine."Item No.");        Item.TestField(Blocked, false);        Item.TestField("Service Blocked", false);        if ServiceContractLine."Variant Code" <> '' then begin            ItemVariant.SetLoadFields(Blocked, "Service Blocked");            ItemVariant.Get(ServiceContractLine."Item No.", ServiceContractLine."Variant Code");            ItemVariant.TestField(Blocked, false);            ItemVariant.TestField("Service Blocked", false);        end;    end;    # endregion Item Service Blocked checks    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckServiceItemBlockedForAll(var ServiceContractLine: Record "Service Contract Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckItemServiceBlocked(var ServiceContractLine: Record "Service Contract Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCalcContractLineAmount(AnnualAmount: Decimal; PeriodStarts: Date; PeriodEnds: Date; var AmountCalculated: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateAllServLines(ServiceContractHeader: Record "Service Contract Header"; var ServContractLine: Record "Service Contract Line"; var ServHeader: Record "Service Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateDetailedServiceLine(ServiceHeader: Record "Service Header"; ServiceContractLine: Record "Service Contract Line"; NewContract: Boolean; ServiceContractHeader: Record "Service Contract Header"; var ServLineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateInvoice(var ServiceContractHeader: Record "Service Contract Header"; PostingDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateInvoiceSetPostingDate(ServiceContractHeader: Record "Service Contract Header"; InvoiceFromDate: Date; InvoiceToDate: Date; var PostingDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateServHeader(var ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInsertServiceHeader(var ServiceHeader: Record "Service Header"; var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterProcessShiptoCodeChange(var ServiceContractHeader: Record "Service Contract Header"; NewShipToCode: Code[10])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcInvAmounts(var InvAmount: array[4] of Decimal; var ServiceContractLine: Record "Service Contract Line"; InvFrom: Date; InvTo: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateDescriptionServiceLines(ServContractLineItemNo: Code[20]; ServContractLineDesc: Text[100]; ServContractLineItemSerialNo: Code[50]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateServiceLine(ServiceHeader: Record "Service Header"; ContractType: Enum "Service Contract Type"; ContractNo: Code[20]; InvFromDate: Date; InvToDate: Date; ServiceApplyEntry: Integer; SigningContract: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeChangeCustNoOnServItem(var ServiceItem: Record "Service Item"; NewCustomerNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckContractGroupAccounts(ServContractHeader: Record "Service Contract Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateServLineForNewContract(var ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header"; var ServLineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateDetailedServiceLine(ServiceHeader: Record "Service Header"; var IsHandled: Boolean; ContractType: Enum "Service Contract Type"; ContractNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateHeadingServiceLine(ServiceHeader: Record "Service Header"; var IsHandled: Boolean; ContractType: Enum "Service Contract Type"; ContractNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInitServiceLineAppliedGLAccount(var ServLine: Record "Service Line"; AppliedGLAccount: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertDescriptionServiceLine(var ServLine: Record "Service Line"; Description: Text[100]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertMultipleServLedgEntries(var ServLedgEntry: Record "Service Ledger Entry"; ServContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeServContractHeaderModify(var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeLastServLineModify(var ServiceLine: Record "Service Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeServHeaderModify(var ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeServLineInsert(var ServiceLine: Record "Service Line"; ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateServLedgEntryAmounts(var ServiceContractLine: Record "Service Contract Line"; var ServLedgEntry: Record "Service Ledger Entry"; var InvRoundedAmount: array[4] of Decimal; LineInvoiceFrom: Date; InvoiceTo: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCalcContractAmountOnAfterServContractLineSetFilters(var ServiceContractLine: Record "Service Contract Line"; var ServiceContractHeader: Record "Service Contract Header"; PeriodStarts: Date; PeriodEnds: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateDetailedServLineOnBeforeServLineInsertFirstLine(var ServiceLine: Record "Service Line"; var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateDetailedServLineOnBeforeServLineInsertNewContract(var ServiceLine: Record "Service Line"; var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateDetailedServLineOnBeforeCreateDescriptionServiceLines(ServContractHeader: Record "Service Contract Header"; var ServContractLine: Record "Service Contract Line"; ServHeader: Record "Service Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateHeadingServLineOnBeforeServLineInsert(var ServiceLine: Record "Service Line"; ServiceContractHeader: Record "Service Contract Header"; ServiceHeader: Record "Service Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateOrGetCreditHeaderOnBeforeCalcCurrencyFactor(ServiceHeader: Record "Service Header"; var CurrExchRate: Record "Currency Exchange Rate")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateOrGetCreditHeaderOnBeforeInitSeries(var ServiceHeader: Record "Service Header"; ServMgtSetup: Record "Service Mgt. Setup"; var IsHandled: Boolean; ServiceContract: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServHeaderOnBeforeInitSeries(var ServiceHeader: Record "Service Header"; var ServMgtSetup: Record "Service Mgt. Setup"; ServContract2: Record "Service Contract Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServHeaderOnBeforeCalcCurrencyFactor(ServiceHeader: Record "Service Header"; var CurrExchRate: Record "Currency Exchange Rate")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateContractLineCreditMemo(var ServiceContractLine: Record "Service Contract Line"; Deleting: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateInvoice(var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateRemainingPeriodInvoice(var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateLastServLines(ServiceHeader: Record "Service Header"; ContractType: Integer; ContractNo: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcContractAmount(var ServiceContractHeader: Record "Service Contract Header"; PeriodStarts: Date; PeriodEnds: Date; var AmountCalculated: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeInsertServiceHeader(var ServiceHeader: Record "Service Header"; var ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgerEntryOnBeforeServLedgEntryInsert(var ServiceLedgerEntry: Record "Service Ledger Entry"; ServiceContractHeader: Record "Service Contract Header"; ServiceContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgerEntryBeforeCountLineInvFrom(var ServLedgEntry: Record "Service Ledger Entry"; ServContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertMultipleServLedgEntriesOnBeforeServLedgEntryInsert(var ServiceLedgerEntry: Record "Service Ledger Entry"; ServiceContractHeader: Record "Service Contract Header"; ServiceContractLine: Record "Service Contract Line"; var NonDistrAmount: array[4] of Decimal; var IsHandled: Boolean; ServiceHeader: Record "Service Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateContractLineCreditMemoOnBeforeCalcCreditAmount(var WDate: Date; ServiceContractHeader: Record "Service Contract Header"; ServiceContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateContractLineCreditMemo(var ServiceContractLine: Record "Service Contract Line"; ServiceCreditMemoNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFilterServContractLine(var ServContractLine: Record "Service Contract Line"; ContractNo: Code[20]; ContractType: Option)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterFinishCodeunit(ServiceRegister: Record "Service Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCalcServLedgEntryDiscountPct(var ServiceLedgerEntry: Record "Service Ledger Entry"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeNoOfMonthsAndMPartsInPeriod(Day1: Date; Day2: Date; var CheckMParts: Boolean; var MonthsAndMParts: Decimal; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCopyCheckSCDimToTempSCDim(var ServContract: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeConfirmCreateServiceInvoiceForPeriod(var CurrServContract: Record "Service Contract Header"; InvFrom: Date; InvTo: Date; var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCreateRemainingPeriodInvoiceServiceLines(var CurrServContract: Record "Service Contract Header"; var ServHeader: Record "Service Header"; InvFrom: Date; InvTo: Date; var AppliedEntry: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforePostPartialServLedgEntry(var ServLedgEntry: Record "Service Ledger Entry"; ServContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeServLedgEntryToServiceLine(var TotalServiceLine: Record "Service Line"; var TotalServiceLineLCY: Record "Service Line"; ServiceHeader: Record "Service Header"; ServiceLedgerEntry: Record "Service Ledger Entry"; var IsHandled: Boolean; ServiceLedgerEntryParm: Record "Service Ledger Entry"; InvFrom: Date; InvTo: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeFindLinePeriodStartsByInvoicedToDate(ServContractLine: Record "Service Contract Line"; PeriodStarts: Date; var LinePeriodStarts: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertDescriptionServiceLineOnBeforeServiceLineInsert(var ServiceLine: Record "Service Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnServLedgEntryToServiceLineOnBeforeServLineInsert(var ServiceLine: Record "Service Line"; TotalServiceLine: Record "Service Line"; TotalServiceLineLCY: Record "Service Line"; ServiceHeader: Record "Service Header"; ServiceLedgerEntry: Record "Service Ledger Entry"; ServiceLedgerEntryParm: Record "Service Ledger Entry"; var IsHandled: Boolean; InvFrom: Date; InvTo: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateContractLineCreditMemoOnAfterCreateAllCreditLines(ServContractHeader: Record "Service Contract Header"; ServiceContractLine: Record "Service Contract Line"; CreditMemoNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateOrGetCreditHeader(var ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateRemainingPeriodInvoiceOnAfterServContractLineSetFilters(var ServiceContractLine: Record "Service Contract Line"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllServLinesOnAfterServContractLineSetFilters(var ServiceContractLine: Record "Service Contract Line"; ServiceContractHeader: Record "Service Contract Header");    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllServLinesOnAfterCreateDetailedServLine(ServiceContractHeader: Record "Service Contract Header"; ServHeader: Record "Service Header"; ServContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllServLinesOnAfterCalcShouldCraeteServiceApplyEntry(var ServHeader: Record "Service Header"; ServContractToInvoice: Record "Service Contract Header"; var ServContractLine: Record "Service Contract Line"; var PartInvoiceFrom: Date; var PartInvoiceTo: Date; var ServiceApplyEntry: Integer; var ShouldCraeteServiceApplyEntry: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllServLinesOnBeforeCreateLastServiceLines(var ServContractToInvoice: Record "Service Contract Header"; var ServLine: Record "Service Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllServLinesOnBeforeServContractLineLoop(var InvoiceFrom: Date; ServContractLine: Record "Service Contract Line"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllCreditLinesCaseElse(ServiceContractHeader: Record "Service Contract Header"; var InvPeriod: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllCreditLinesOnAfterDetermineOldWDate(ServiceContractHeader: Record "Service Contract Header"; InvPeriod: Integer; Days: Integer; WDate: Date; var OldWDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateDetailedServLineOnAfterSetFirstLineAndNewContract(var FirstLine: Boolean; var NewContract: Boolean; ServContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateInvoiceOnBeforeCreateAllServLines(var ServiceContractHeader: Record "Service Contract Header"; InvoiceFromDate: Date; InvoiceToDate: Date; var InvoicedAmount: Decimal; var PostingDate: Date; InvoicingStartingPeriod: Boolean; InvNo: Code[20])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnLookupServItemNoOnBeforeFilterByCustomerNo(var ServItem: Record "Service Item"; var ServiceContractLine: Record "Service Contract Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnLookupServItemNoOnAfterServItemSetFilters(var ServiceItem: Record "Service Item"; ServiceContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnPostPartialServLedgEntryOnBeforeServLedgEntryInsert(var ServLedgEntry: Record "Service Ledger Entry"; ServContractLine: Record "Service Contract Line"; ServiceHeader: Record "Service Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterCreateRemainingPeriodInvoice(var CurrServContract: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeSetSalespersonCode(SalesPersonCodeToCheck: Code[20]; var SalesPersonCodeToAssign: Code[20]; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeUpdateApplyUntilEntryNoInServLedgEntry(ServContractHeader: Record "Service Contract Header"; SigningContract: Boolean; ReturnLedgerEntry: Integer; FirstLineEntry: Integer; LastEntry: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgerEntryOnAfterInitServLedgEntry(var ServLedgEntry: Record "Service Ledger Entry"; var ServContractHeader: Record "Service Contract Header"; ContractType: Integer; ContractNo: Code[20]; LineNo: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgEntryOnPrepaidOnAfterServContractLineSetFilters(var ServContractLine: Record "Service Contract Line"; AddingNewLines: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgEntryOnNotPrepaidOnAfterServContractLineSetFilters(var ServContractLine: Record "Service Contract Line"; ServContractHeader: Record "Service Contract Header"; AddingNewLines: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgEntryOnPrepaidOnBeforeCalcInvAmounts(var ServContractLine: Record "Service Contract Line"; var ServLedgEntry: Record "Service Ledger Entry")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgEntryOnAfterWDateLoop(var ServContractHeader: Record "Service Contract Header"; var WDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgerEntryOnBeforeCheckServContractLineStartingDate(ServContractHeader: Record "Service Contract Header"; var CountOfEntryLoop: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgerEntryOnBeforeLoopPeriods(ServContractHeader: Record "Service Contract Header"; ServContractLine: Record "Service Contract Line"; var InvFrom: Date; var WDate: Date; var DateExpression: Text)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgerEntryOnBeforeInsertMultipleServLedgEntries(var NextInvDate: Date; ServContractHeader: Record "Service Contract Header"; ServContractLine: Record "Service Contract Line"; var NoOfPayments: Integer; var DueDate: Date; var InvFromDate: Date; var AddingNewLines: Boolean; var CountOfEntryLoop: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateDescriptionServiceLinesOnAfterCalcServLineDescription(var ServLineDescription: Text; var ServContractLineItemNo: Code[20]; var ServContractLineDesc: Text[100]; var ServContractLineItemSerialNo: Code[50])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetInvoicePeriodTextOnCaseElse(InvoicePeriod: Enum "Service Contract Header Invoice Period"; var InvPeriodText: Text[4])    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServHeaderOnAfterCopyFromCustomer(var ServiceHeader: Record "Service Header"; ServiceContract: Record "Service Contract Header"; Customer: Record Customer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetAffectedItemsOnContractChangeOnAfterServContractLineSetFilters(var ServiceContractLine: Record "Service Contract Line")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetAffectedItemsOnContractChangeOnAfterTempServItemGetOrInsert(var IsHandled: Boolean; var ServiceContractLine: Record "Service Contract Line"; var TempServiceContractHeader: Record "Service Contract Header"; var TempServiceItem: Record "Service Item")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnChangeCustNoOnServContractOnAfterGetCustomer(Customer: Record Customer; var ServiceContractHeader: Record "Service Contract Header"; var ServCheckCreditLimit: Codeunit "Serv. Check Credit Limit"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterChangeCustNoOnServItem(var ServiceItem: Record "Service Item")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServHeaderOnBeforeCheckBlockedCustOnDocs(var ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header"; var IsHandled: Boolean);    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckDimValuePosting(ServiceContractHeader: Record "Service Contract Header"; LineNo: Integer; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckMultipleCurrenciesForCustomers(var ServiceContractHeader: Record "Service Contract Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateCreditLineOnBeforeServLineHeadingInsert(var ServiceLine: Record "Service Line"; ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateOrGetCreditHeaderOnBeforeCheckBlockedCustOnDocs(var ServiceHeader: Record "Service Header"; ServiceContractHeader: Record "Service Contract Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitServLedgEntry(var ServiceLedgerEntry: Record "Service Ledger Entry"; ServiceContractHeader: Record "Service Contract Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgEntryOnBeforeCalcCurrencyAmountRoundingPrecision(ServiceContractHeader: Record "Service Contract Header"; var ServiceLedgerEntry: Record "Service Ledger Entry"; var InvRoundedAmount: array[4] of Decimal; var InvAmount: array[4] of Decimal; AmountType: Option ,Amount,DiscAmount,UnitPrice,UnitCost; Currency: Record Currency; ServiceHeader2: Record "Service Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLedgEntryOnAfterSetDiscountAmount(ServiceContractHeader: Record "Service Contract Header"; var ServiceLedgerEntry: Record "Service Ledger Entry"; var InvRoundedAmount: array[4] of Decimal; var InvAmount: array[4] of Decimal; AmountType: Option ,Amount,DiscAmount,UnitPrice,UnitCost; Currency: Record Currency; ServiceHeader2: Record "Service Header")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateCreditLineOnBeforeCreateDim(var ServiceLine2: Record "Service Line"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateAllServLinesOnAfterCreateServiceLine(var ServiceContractLine: Record "Service Contract Line"; ServiceHeader: Record "Service Header"; InvoiceFrom: Date; InvoiceTo: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnGetAffectedItemsOnContractChangeOnBeforeOnFindServContractLine2(var ServiceContractLine2: Record "Service Contract Line")    begin    end;    [IntegrationEvent(true, false)]    local procedure OnServLedgEntryToServiceLineOnBeforeDimSet(var ServiceLine: Record "Service Line"; ServiceLedgerEntry: Record "Service Ledger Entry"; ServiceHeader: Record "Service Header"; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateOrGetCreditHeaderOnAfterCopyFromCustomer(var ServiceHeader: Record "Service Header"; ServiceContract: Record "Service Contract Header"; Customer: Record Customer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnBeforeCheckCustomer(var Result: Boolean; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnAfterInitCodeUnit(var ServiceRegister: Record "Service Register")    begin    end;    [IntegrationEvent(false, false)]    local procedure OnFillTempServiceLedgerEntriesOAfterCalcDoInsertTempServiceLedgerEntry(ServiceLedgerEntry: Record "Service Ledger Entry"; var DoInsertTempServiceLedgerEntry: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertMultipleServLedgEntriesOnUpdateDateFieldsBeforeCalcNonDistrAmount(var InvoiceFrom: Date; var DueDate: Date; NoOfPayments: Integer)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertMultipleServLedgEntriesOnBeforeUpdatePaymentsCount(CheckMonthParts: Boolean; var NoOfPayments: Integer; var CountOfEntryLoop: Integer; var ShouldUpdatePaymentsCount: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertMultipleServLedgEntriesOnBeforeSetServLedgEntryAmounts(var ServiceLedgerEntry: Record "Service Ledger Entry"; var InvRoundedAmount: array[4] of Decimal; NonDistrAmount: array[4] of Decimal; NoOfPayments: Integer; Index: Integer; CountOfEntryLoop: Integer; AmountRoundingPrecision: Decimal; DueDate: Date; var IsHandled: Boolean)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnInsertMultipleServLedgEntriesOnAfterSetDueDate(Index: Integer; var DueDate: Date; ServiceLedgerEntry: Record "Service Ledger Entry"; CountOfEntryLoop: Integer; InvRoundedAmount: array[4] of Decimal; var NonDistrAmount: array[4] of Decimal; var ServiceHeader: Record "Service Header"; AmountRoundingPrecision: Decimal)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLineOnBeforeServLedgEntryToServiceLine(var ServiceHeader: Record "Service Header"; var ServiceContractHeader: Record "Service Contract Header"; var ServiceLedgerEntry: Record "Service Ledger Entry"; var InvFromDate: Date; var InvToDate: Date)    begin    end;    [IntegrationEvent(false, false)]    local procedure OnCreateServiceLineOnAfterServLedgEntryToServiceLine(ServiceHeader: Record "Service Header"; InvoiceFromDate: Date; InvoiceToDate: Date)    begin    end;}