Codeunit 5940 ServContractManagement, source in 29
Source29
src/Layers/W1/BaseApp/Service/Contract/ServContractManagement.Codeunit.al3233 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;
}