Codeunit 5611 Calculate Normal Depreciation, source in 29
Source29
src/Layers/W1/BaseApp/FixedAssets/Depreciation/CalculateNormalDepreciation.Codeunit.al1152 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.FixedAssets.Depreciation;
using Microsoft.FixedAssets.FixedAsset;
using Microsoft.FixedAssets.Ledger;
using Microsoft.FixedAssets.Posting;
using Microsoft.Foundation.Period;
codeunit 5611 "Calculate Normal Depreciation"
{
Permissions = TableData "FA Ledger Entry" = r,
TableData "FA Posting Type Setup" = r;
trigger OnRun()
begin
end;
var
FA: Record "Fixed Asset";
FALedgEntry: Record "FA Ledger Entry";
DeprBook: Record "Depreciation Book";
FADeprBook: Record "FA Depreciation Book";
DepreciationCalc: Codeunit "Depreciation Calculation";
DeprBookCode: Code[10];
DaysInFiscalYear: Integer;
EntryAmounts: array[4] of Decimal;
MinusBookValue: Decimal;
StraightLineBonusBaseReductionAmount: Decimal;
StraightLineBonusBaseReductionCalculated: Boolean;
DateFromProjection: Date;
SkipOnZero: Boolean;
UntilDate: Date;
Sign: Integer;
FirstDeprDate: Date;
NumberOfDays: Integer;
NumberOfDays2: Integer;
DaysInPeriod: Integer;
UseDeprStartingDate: Boolean;
BookValue: Decimal;
BookValue2: Decimal;
DeprBasis: Decimal;
SalvageValue: Decimal;
SalvageValue2: Decimal;
AcquisitionDate: Date;
DisposalDate: Date;
DeprMethod: Enum "FA Depr. Method Internal";
DeprStartingDate: Date;
FirstUserDefinedDeprDate: Date;
SLPercent: Decimal;
DBPercent: Decimal;
FixedAmount: Decimal;
DeprYears: Decimal;
DeprTableCode: Code[10];
FinalRoundingAmount: Decimal;
EndingBookValue: Decimal;
AmountBelowZero: Decimal;
PercentBelowZero: Decimal;
StartingDate: Date;
EndingDate: Date;
Factor: Decimal;
UseHalfYearConvention: Boolean;
NewYearDate: Date;
DeprInTwoFiscalYears: Boolean;
TempDeprAmount: Decimal;
Year365Days: Boolean;
#pragma warning disable AA0074
#pragma warning disable AA0470
Text000: Label 'Force No. of Days must only be specified if %1 %2 = %3.';
Text001: Label '%2 must not be 100 for %1.';
Text002: Label '%2 must be %3 if %4 %5 = %6 for %1.';
Text003: Label '%2 must not be later than %3 for %1.';
Text004: Label '%1 %2 must not be used together with the Half-Year Convention for %3.';
Text005: Label '%1 must not be used together with the Half-Year Convention for %2.';
Text006: Label '%1 must be %2 or later for %3.';
Text007: Label '%1 must not be used together with %2 for %3.';
Text008: Label '%1 must not be used together with %2 = %3 for %4.';
#pragma warning restore AA0470
#pragma warning restore AA0074
procedure Calculate(var DeprAmount: Decimal; var NumberOfDays4: Integer; FANo: Code[20]; DeprBookCode2: Code[10]; UntilDate2: Date; EntryAmounts2: array[4] of Decimal; DateFromProjection2: Date; DaysInPeriod2: Integer)
var
i: Integer;
IsHandled: Boolean;
StorageDecimal: Dictionary of [Text, Decimal];
StorageInteger: Dictionary of [Text, Integer];
StorageDate: Dictionary of [Text, Date];
StorageCode: Dictionary of [Text, Code[10]];
begin
IsHandled := false;
OnBeforeCalculate(DeprAmount, NumberOfDays4, FANo, DeprBookCode2, UntilDate2, EntryAmounts2, DateFromProjection2, DaysInPeriod2, IsHandled);
if IsHandled then
exit;
ClearAll();
DeprAmount := 0;
NumberOfDays4 := 0;
DeprBookCode := DeprBookCode2;
FA.Get(FANo);
DeprBook.Get(DeprBookCode);
if not FADeprBook.Get(FANo, DeprBookCode) then
exit;
OnAfterGetDeprBooks(DeprBook, FADeprBook);
UntilDate := UntilDate2;
for i := 1 to 4 do
EntryAmounts[i] := EntryAmounts2[i];
DateFromProjection := DateFromProjection2;
DaysInPeriod := DaysInPeriod2;
if DaysInPeriod > 0 then
if DeprBook."Periodic Depr. Date Calc." <> DeprBook."Periodic Depr. Date Calc."::"Last Entry" then begin
DeprBook."Periodic Depr. Date Calc." := DeprBook."Periodic Depr. Date Calc."::"Last Entry";
Error(
Text000,
DeprBook.TableCaption, DeprBook.FieldCaption("Periodic Depr. Date Calc."), DeprBook."Periodic Depr. Date Calc.");
end;
OnBeforeCalcTransferValueSetVariables(FirstDeprDate, Year365Days, UseDeprStartingDate, NumberOfDays2, UseHalfYearConvention);
AssignVariablesToStorage(StorageDecimal, StorageInteger, StorageDate, StorageCode, DeprBookCode2, DateFromProjection2, UntilDate2, DaysInPeriod2, NumberOfDays4, DeprAmount);
IsHandled := false;
OnCalculateOnBeforeTransferValue(FANo, StorageDecimal, StorageInteger, StorageDate, StorageCode, EntryAmounts2, EntryAmounts, DeprMethod, Year365Days, IsHandled);
if IsHandled then
AssignStorageToVariables(StorageDecimal, StorageInteger, StorageDate, StorageCode, DeprBookCode2, DateFromProjection2, UntilDate2, DaysInPeriod2, NumberOfDays4, DeprAmount)
else
TransferValues();
if not SkipRecord() then begin
Sign := 1;
if not FADeprBook."Use FA Ledger Check" then begin
if DeprBook."Use FA Ledger Check" then
FADeprBook.TestField("Use FA Ledger Check", true);
FADeprBook.TestField("Fixed Depr. Amount below Zero", 0);
FADeprBook.TestField("Depr. below Zero %", 0);
Sign := DepreciationCalc.GetSign(BookValue, DeprBasis, SalvageValue, MinusBookValue);
if Sign = 0 then
exit;
if Sign = -1 then
DepreciationCalc.GetNewSigns(BookValue, DeprBasis, SalvageValue, MinusBookValue);
end;
if (FADeprBook."Fixed Depr. Amount below Zero" > 0) or
(FADeprBook."Depr. below Zero %" > 0)
then
FADeprBook.TestField("Use FA Ledger Check", true);
IsHandled := false;
OnCalculateOnBeforeAssignSkipOnZeroValue(FANo, FADeprBook, Sign, BookValue, DeprBasis, SalvageValue, MinusBookValue, SkipOnZero, EndingBookValue, IsHandled);
if not IsHandled then begin
if BookValue + SalvageValue <= 0 then
SkipOnZero := true;
if (SalvageValue >= 0) and (BookValue <= EndingBookValue) then
SkipOnZero := true;
end;
if not
(SkipOnZero and
not DeprBook."Allow Depr. below Zero" and
not DeprBook."Use FA Ledger Check")
then begin
IsHandled := false;
OnAfterSkipOnZeroValue(DeprBook, SkipOnZero, IsHandled);
if not IsHandled then
if SkipOnZero then
DeprMethod := DeprMethod::"Below Zero";
DeprAmount := Sign * CalculateDeprAmount();
IsHandled := false;
OnAfterCalcFinalDeprAmount(FANo, FADeprBook, DeprBook, Sign, BookValue, DeprAmount, IsHandled, NumberOfDays2);
if not IsHandled then
if Sign * DeprAmount > 0 then
DeprAmount := 0;
NumberOfDays4 := NumberOfDays2;
end;
end;
end;
local procedure SkipRecord(): Boolean
var
IsHandled: Boolean;
ExitValue: Boolean;
begin
IsHandled := false;
OnBeforeSkipRecord(
FA,
DeprBook,
DisposalDate,
AcquisitionDate,
UntilDate,
DeprMethod,
BookValue,
DeprBasis,
SalvageValue,
MinusBookValue,
ExitValue,
IsHandled);
if IsHandled then
exit(ExitValue);
exit(
(DisposalDate > 0D) or
(AcquisitionDate = 0D) or
(DeprMethod = DeprMethod::Manual) or
(AcquisitionDate > UntilDate) or
FA.Inactive or
FA.Blocked);
end;
local procedure ProcessDaysInPeriod()
begin
if DaysInPeriod > 0 then begin
Factor := DaysInPeriod / NumberOfDays;
NumberOfDays := DaysInPeriod;
end;
OnAfterProcessDaysInPeriod(NumberofDays, DaysInPeriod, Factor, FA, DeprBook, FirstDeprDate, UntilDate, Year365Days);
end;
local procedure CalculateDeprAmount(): Decimal
var
Amount: Decimal;
IsHandled: Boolean;
begin
if DateFromProjection > 0D then
FirstDeprDate := DateFromProjection
else begin
FirstDeprDate := DepreciationCalc.GetFirstDeprDate(FA."No.", DeprBookCode, Year365Days, DeprBook."Use Accounting Period");
if FirstDeprDate > UntilDate then
exit(0);
UseDeprStartingDate := DepreciationCalc.UseDeprStartingDate(FA."No.", DeprBookCode);
if UseDeprStartingDate then
FirstDeprDate := DeprStartingDate;
end;
if FirstDeprDate < DeprStartingDate then
FirstDeprDate := DeprStartingDate;
IsHandled := false;
OnBeforeNumberofDayCalculateNumberofDays(FA, DeprBook, NumberofDays, FirstDeprDate, UntilDate, Year365Days, IsHandled, FADeprBook);
if not IsHandled then
NumberOfDays := DepreciationCalc.DeprDays(FirstDeprDate, UntilDate, Year365Days, DeprBook."Use Accounting Period");
Factor := 1;
if NumberOfDays <= 0 then
exit(0);
ProcessDaysInPeriod();
UseHalfYearConvention := SetHalfYearConventionMethod();
UpdateDaysInFiscalYear(FA, DeprBook, NumberOfDays, DaysInFiscalYear, IsHandled);
// Method Last Entry
if UseDeprStartingDate or
(DateFromProjection > 0D) or
(DeprMethod = DeprMethod::"Below Zero") or
(DeprBook."Periodic Depr. Date Calc." = DeprBook."Periodic Depr. Date Calc."::"Last Entry")
then begin
NumberOfDays2 := NumberOfDays;
if UseHalfYearConvention then
Amount := CalcHalfYearConventionDepr()
else
case DeprMethod of
DeprMethod::"Straight-Line":
Amount := CalcSLAmount();
DeprMethod::"Declining-Balance 1":
Amount := CalcDB1Amount();
DeprMethod::"Declining-Balance 2":
Amount := CalcDB2Amount();
DeprMethod::"DB1/SL",
DeprMethod::"DB2/SL":
Amount := CalcDBSLAmount();
DeprMethod::Manual:
Amount := 0;
DeprMethod::"User-Defined":
Amount := CalcUserDefinedAmount(UntilDate);
DeprMethod::"Below Zero":
Amount := DepreciationCalc.CalcRounding(DeprBookCode, CalcBelowZeroAmount());
DeprMethod::"Country Specific":
;
// Reserved for implementation of country specific methods
else
OnCalculateDeprAmountOnDeprMethodCaseLastEntry(
FADeprBook, BookValue, DeprBasis, DeprYears, DaysInFiscalYear, NumberOfDays, Amount, DateFromProjection, UntilDate, DeprMethod);
end;
OnCalculateDeprAmountOnAfterAssignAmountLastEntry(FADeprBook, UntilDate, DateFromProjection, BookValue, UseHalfYearConvention, DaysInFiscalYear, NumberOfDays);
end
// Method Last Depreciation Entry
else begin
if UseHalfYearConvention then
DeprBook.TestField(
"Periodic Depr. Date Calc.", DeprBook."Periodic Depr. Date Calc."::"Last Entry");
Amount := 0;
StartingDate := 0D;
EndingDate := 0D;
DepreciationCalc.GetDeprPeriod(
FA."No.", DeprBookCode, UntilDate, StartingDate, EndingDate, NumberOfDays, Year365Days, DeprBook."Use Accounting Period");
FirstDeprDate := StartingDate;
NumberOfDays2 := DepreciationCalc.DeprDays(FirstDeprDate, UntilDate, Year365Days, DeprBook."Use Accounting Period");
while NumberOfDays > 0 do begin
DepreciationCalc.CalculateDeprInPeriod(
FA."No.", DeprBookCode, EndingDate, Amount, Sign,
BookValue, DeprBasis, SalvageValue, MinusBookValue);
if DepreciationCalc.GetSign(
BookValue, DeprBasis, SalvageValue, MinusBookValue) <> 1
then
exit(0);
case DeprMethod of
DeprMethod::"Straight-Line":
Amount := Amount + CalcSLAmount();
DeprMethod::"Declining-Balance 1":
Amount := Amount + CalcDB1Amount();
DeprMethod::"Declining-Balance 2":
Amount := Amount + CalcDB2Amount();
DeprMethod::Manual:
Amount := 0;
DeprMethod::"User-Defined":
Amount := Amount + CalcUserDefinedAmount(EndingDate);
DeprMethod::"Country Specific":
;
// Reserved for implementation of country specific
else
OnCalculateDeprAmountOnDeprMethodCaseLastDeprEntry(
FADeprBook, BookValue, DeprBasis, DeprYears, DaysInFiscalYear, NumberOfDays, Amount, DateFromProjection, UntilDate, DeprMethod);
end;
DepreciationCalc.GetDeprPeriod(
FA."No.", DeprBookCode, UntilDate, StartingDate, EndingDate, NumberOfDays, Year365Days, DeprBook."Use Accounting Period");
FirstDeprDate := StartingDate;
end;
end;
IsHandled := false;
OnAfterCalculateFinalAmount(DeprBook, Amount, IsHandled, FA, UntilDate, BookValue);
if not IsHandled then
if Amount >= 0 then
exit(0);
IsHandled := false;
OnCalculateDeprAmountOnBeforeCalculateDeprAmount(FA, SkipOnZero, DeprBookCode, Amount, BookValue2, SalvageValue2, EndingBookValue, FinalRoundingAmount, IsHandled);
if IsHandled then
exit(Amount);
if not SkipOnZero then
DepreciationCalc.AdjustDepr(
DeprBookCode, Amount, Abs(BookValue2), -Abs(SalvageValue2),
EndingBookValue, FinalRoundingAmount);
OnAfterCalculateDeprAmount(
FA, SkipOnZero, DeprBookCode, Amount, Abs(BookValue2), -Abs(SalvageValue2), EndingBookValue, FinalRoundingAmount);
exit(Round(Amount));
end;
local procedure CalcTempDeprAmount(var DeprAmount: Decimal): Boolean
begin
DeprAmount := 0;
if FADeprBook."Temp. Ending Date" = 0D then
exit(false);
if (FirstDeprDate <= FADeprBook."Temp. Ending Date") and (UntilDate > FADeprBook."Temp. Ending Date") then
Error(
Text006,
FADeprBook.FieldCaption("Temp. Ending Date"),
UntilDate,
GetFAName());
if FADeprBook."Temp. Ending Date" >= UntilDate then begin
if FADeprBook."Use Half-Year Convention" then
Error(
Text005,
FADeprBook.FieldCaption("Temp. Ending Date"),
GetFAName());
if FADeprBook."Use DB% First Fiscal Year" then
Error(
Text007,
FADeprBook.FieldCaption("Temp. Ending Date"),
FADeprBook.FieldCaption("Use DB% First Fiscal Year"),
GetFAName());
if FADeprBook."Depreciation Method" = FADeprBook."Depreciation Method"::"User-Defined" then
Error(
Text008,
FADeprBook.FieldCaption("Temp. Ending Date"),
FADeprBook.FieldCaption("Depreciation Method"),
FADeprBook."Depreciation Method",
GetFAName());
if DeprMethod = DeprMethod::"Below Zero" then
Error(
Text007,
FADeprBook.FieldCaption("Temp. Ending Date"),
DeprBook.FieldCaption("Allow Depr. below Zero"),
GetFAName());
DeprBook.TestField(
"Periodic Depr. Date Calc.", DeprBook."Periodic Depr. Date Calc."::"Last Entry");
DeprAmount := -(NumberOfDays / DaysInFiscalYear) * FADeprBook."Temp. Fixed Depr. Amount";
exit(true)
end;
exit(false);
end;
local procedure StraightLineBonusBaseReduction(): Decimal
begin
// The reduction only depends on FA/FADeprBook/DeprBookCode and the posted ledger, none of which change during a
// single Calculate run, so cache it to avoid repeating the CalcSums lookups on every period of the depreciation loop.
if not StraightLineBonusBaseReductionCalculated then begin
StraightLineBonusBaseReductionAmount := CalcStraightLineBonusBaseReduction();
StraightLineBonusBaseReductionCalculated := true;
end;
exit(StraightLineBonusBaseReductionAmount);
end;
local procedure CalcStraightLineBonusBaseReduction(): Decimal
begin
// Bonus depreciation reduces the book value but not the depreciable basis, so the straight-line base must be lowered by it.
// Skip the database lookups below for the majority of assets that do not use bonus depreciation.
if not FADeprBook."Use Bonus Depreciation" then
exit(0);
if FADeprBook.BonusDepreciationApplied() then begin
// Depreciation has already been posted: the posted bonus depreciation in the ledger is the source of truth.
FADeprBook.CalcFields("Bonus Depr. Applied Amount");
exit(DepreciationCalc.GetMinusBookValue(FA."No.", DeprBookCode, 0D, 0D) - FADeprBook."Bonus Depr. Applied Amount");
end;
// First depreciation: the bonus depreciation line is created together with this line and is not posted yet.
exit(DepreciationCalc.GetMinusBookValue(FA."No.", DeprBookCode, 0D, 0D) + DepreciationCalc.GetUnpostedBonusDepreciationForCalc(FADeprBook, 0D, 0D));
end;
local procedure CalcSLAmount(): Decimal
var
RemainingLife: Decimal;
IsHandled: Boolean;
Result: Decimal;
begin
if CalcTempDeprAmount(TempDeprAmount) then
exit(TempDeprAmount);
if SLPercent > 0 then begin
Result := (-SLPercent / 100) * (NumberOfDays / DaysInFiscalYear) * (DeprBasis - StraightLineBonusBaseReduction());
OnCalcSLAmountOnAfterCalcFromSLPercent(FA, FADeprBook, BookValue, DeprBasis, DaysInFiscalYear, NumberOfDays, SLPercent, Result);
exit(Result);
end;
IsHandled := false;
OnCalcSLAmountOnBeforeCheckFixedAmount(FA, FixedAmount, NumberOfDays, DaysInFiscalYear, IsHandled, Result);
if IsHandled then
exit(Result);
if FixedAmount > 0 then
exit(-FixedAmount * NumberOfDays / DaysInFiscalYear);
if DeprYears > 0 then begin
if DeprBook."Use Accounting Period" then
RemainingLife := FADeprBook."Depreciation Ending Date" - FADeprBook."Depreciation Starting Date" + 1 -
DepreciationCalc.DeprDays(DeprStartingDate, DepreciationCalc.Yesterday(FirstDeprDate,
Year365Days, DeprBook."Use Accounting Period"),
Year365Days, DeprBook."Use Accounting Period")
else
RemainingLife :=
(DeprYears * DaysInFiscalYear) -
DepreciationCalc.DeprDays(
DeprStartingDate, DepreciationCalc.Yesterday(FirstDeprDate, Year365Days, DeprBook."Use Accounting Period"),
Year365Days, DeprBook."Use Accounting Period");
if RemainingLife < 1 then begin
Result := -BookValue;
OnCalcSLAmountOnAfterCalcResultForRemainingLifeExpired(FA, FADeprBook, BookValue, Result);
exit(Result);
end;
IsHandled := false;
OnAfterCalcSL(FA, FADeprBook, UntilDate, BookValue, DeprBasis, DeprYears, NumberOfDays, DaysInFiscalYear, Result, IsHandled, RemainingLife, FirstDeprDate);
if IsHandled then
exit(Result);
exit(-(BookValue + SalvageValue - MinusBookValue) * NumberOfDays / RemainingLife);
end;
exit(0);
end;
procedure CalcDB1Amount() Result: Decimal
var
DeprInFiscalYear: Decimal;
begin
if CalcTempDeprAmount(TempDeprAmount) then
exit(TempDeprAmount);
if DateFromProjection = 0D then
DeprInFiscalYear := DepreciationCalc.DeprInFiscalYear(FA."No.", DeprBookCode, UntilDate)
else
DeprInFiscalYear := EntryAmounts[3];
if DeprInTwoFiscalYears then
DeprInFiscalYear := 0;
result := -(DBPercent / 100) * (NumberOfDays / DaysInFiscalYear) *
(BookValue + SalvageValue - MinusBookValue - Sign * DeprInFiscalYear);
OnAfterCalcDB1Amount(DBPercent, NumberOfDays, DaysInFiscalYear, BookValue, SalvageValue, MinusBookValue, Sign, DeprInFiscalYear, Result, FADeprBook, FirstDeprDate);
end;
local procedure CalcDB2Amount(): Decimal
begin
if CalcTempDeprAmount(TempDeprAmount) then
exit(TempDeprAmount);
exit(
-(1 - Power(1 - DBPercent / 100, NumberOfDays / DaysInFiscalYear)) *
(BookValue - MinusBookValue));
end;
local procedure CalcDBSLAmount(): Decimal
var
FADateCalc: Codeunit "FA Date Calculation";
SLAmount: Decimal;
DBAmount: Decimal;
begin
if DeprMethod = DeprMethod::"DB1/SL" then
DBAmount := CalcDB1Amount()
else
DBAmount := CalcDB2Amount();
if FADeprBook."Use DB% First Fiscal Year" then
if FADateCalc.GetFiscalYear(DeprBookCode, UntilDate) =
FADateCalc.GetFiscalYear(DeprBookCode, DeprStartingDate)
then
exit(DBAmount);
SLAmount := CalcSLAmount();
if SLAmount < DBAmount then
exit(SLAmount);
OnAfterCalcDBSLAmount(DBAmount, SLAmount, FADeprBook, DateFromProjection);
exit(DBAmount)
end;
local procedure CalcUserDefinedAmount(EndingDate: Date): Decimal
var
TableDeprCalc: Codeunit "Table Depr. Calculation";
begin
if CalcTempDeprAmount(TempDeprAmount) then
Error('');
exit(
-TableDeprCalc.GetTablePercent(DeprBook.Code, DeprTableCode,
FirstUserDefinedDeprDate, FirstDeprDate, EndingDate) *
DeprBasis * Factor);
end;
local procedure CalcBelowZeroAmount(): Decimal
begin
if CalcTempDeprAmount(TempDeprAmount) then
Error('');
if PercentBelowZero > 0 then
exit((-PercentBelowZero / 100) * (NumberOfDays / DaysInFiscalYear) * DeprBasis);
if AmountBelowZero > 0 then
exit(-AmountBelowZero * NumberOfDays / DaysInFiscalYear);
exit(0);
end;
local procedure TransferValues()
var
IsHandled: Boolean;
begin
FADeprBook.TestField("Depreciation Starting Date");
if FADeprBook."Depreciation Method" = FADeprBook."Depreciation Method"::"User-Defined" then begin
FADeprBook.TestField("Depreciation Table Code");
FADeprBook.TestField("First User-Defined Depr. Date");
end;
case FADeprBook."Depreciation Method" of
FADeprBook."Depreciation Method"::"Declining-Balance 1",
FADeprBook."Depreciation Method"::"Declining-Balance 2",
FADeprBook."Depreciation Method"::"DB1/SL",
FADeprBook."Depreciation Method"::"DB2/SL":
if FADeprBook."Declining-Balance %" >= 100 then
Error(Text001, GetFAName(), FADeprBook.FieldCaption("Declining-Balance %"));
end;
if (DeprBook."Periodic Depr. Date Calc." = DeprBook."Periodic Depr. Date Calc."::"Last Depr. Entry") and
(FADeprBook."Depreciation Method" <> FADeprBook."Depreciation Method"::"Straight-Line")
then begin
FADeprBook."Depreciation Method" := FADeprBook."Depreciation Method"::"Straight-Line";
Error(
Text002,
GetFAName(),
FADeprBook.FieldCaption("Depreciation Method"),
FADeprBook."Depreciation Method",
DeprBook.TableCaption(),
DeprBook.FieldCaption("Periodic Depr. Date Calc."),
DeprBook."Periodic Depr. Date Calc.");
end;
SetDeprMethod(FADeprBook);
OnTransferValuesOnAfterSetDeprMethod(FADeprBook, UntilDate);
if DateFromProjection = 0D then begin
FADeprBook.CalcFields("Book Value");
BookValue := FADeprBook."Book Value";
end else
BookValue := EntryAmounts[1];
MinusBookValue := DepreciationCalc.GetMinusBookValue(FA."No.", DeprBookCode, 0D, 0D) + DepreciationCalc.GetUnpostedBonusDepreciationForCalc(FADeprBook, 0D, 0D);
FADeprBook.CalcFields("Depreciable Basis", "Salvage Value");
DeprBasis := FADeprBook."Depreciable Basis";
SalvageValue := FADeprBook."Salvage Value";
OnAfterBookValueRecalculateBookValue(FA, DeprBook, FALedgEntry, DeprBasis, BookValue, EndingDate, FADeprBook."Disposal Date", FADeprBook, DateFromProjection, SalvageValue);
BookValue2 := BookValue;
SalvageValue2 := SalvageValue;
DeprStartingDate := FADeprBook."Depreciation Starting Date";
DeprTableCode := FADeprBook."Depreciation Table Code";
FirstUserDefinedDeprDate := FADeprBook."First User-Defined Depr. Date";
if (FADeprBook."Depreciation Method" = FADeprBook."Depreciation Method"::"User-Defined") and
(FirstUserDefinedDeprDate > DeprStartingDate)
then
Error(
Text003,
GetFAName(), FADeprBook.FieldCaption("First User-Defined Depr. Date"), FADeprBook.FieldCaption("Depreciation Starting Date"));
SLPercent := FADeprBook."Straight-Line %";
DBPercent := FADeprBook."Declining-Balance %";
OnAfterBookValueCheckAddedDeprApplicable(FADeprBook, DeprBook, FALedgEntry, UntilDate, DBPercent, SLPercent);
DeprYears := FADeprBook."No. of Depreciation Years";
if FADeprBook."Depreciation Ending Date" > 0D then begin
if FADeprBook."Depreciation Starting Date" > FADeprBook."Depreciation Ending Date" then
Error(
Text003,
GetFAName(), FADeprBook.FieldCaption("Depreciation Starting Date"), FADeprBook.FieldCaption("Depreciation Ending Date"));
DeprYears :=
DepreciationCalc.DeprDays(
FADeprBook."Depreciation Starting Date", FADeprBook."Depreciation Ending Date", false, DeprBook."Use Accounting Period") / 360;
end;
FixedAmount := FADeprBook."Fixed Depr. Amount";
FinalRoundingAmount := FADeprBook."Final Rounding Amount";
if FinalRoundingAmount = 0 then
FinalRoundingAmount := DeprBook."Default Final Rounding Amount";
EndingBookValue := FADeprBook."Ending Book Value";
if not FADeprBook."Ignore Def. Ending Book Value" and (EndingBookValue = 0) then
EndingBookValue := DeprBook."Default Ending Book Value";
AcquisitionDate := FADeprBook."Acquisition Date";
DisposalDate := FADeprBook."Disposal Date";
PercentBelowZero := FADeprBook."Depr. below Zero %";
AmountBelowZero := FADeprBook."Fixed Depr. Amount below Zero";
DaysInFiscalYear := DeprBook."No. of Days in Fiscal Year";
if DaysInFiscalYear = 0 then
DaysInFiscalYear := 360;
Year365Days := DeprBook."Fiscal Year 365 Days";
IsHandled := false;
OnAfterDaysinFYRecalculateDaysInFiscalYear(FADeprBook, DeprBook, UntilDate, DaysInFiscalYear, Year365Days, IsHandled);
if Year365Days then begin
if not IsHandled then
DaysInFiscalYear := 365;
DeprYears :=
DepreciationCalc.DeprDays(
FADeprBook."Depreciation Starting Date", FADeprBook."Depreciation Ending Date", true, false) / DaysInFiscalYear;
end;
OnAfterTransferValues2(FA, FADeprBook, Year365Days, DeprYears, DeprMethod, DeprBasis, BookValue);
end;
local procedure GetFAName(): Text[200]
begin
exit(DepreciationCalc.FAName(FA, DeprBookCode));
end;
local procedure SetHalfYearConventionMethod(): Boolean
var
AccountingPeriod: Record "Accounting Period";
Result: Boolean;
IsHandled: Boolean;
NewYearDateOverride: Date;
begin
IsHandled := false;
OnBeforeSetHalfYearConventionMethod(FADeprBook, DeprMethod, Year365Days, FirstDeprDate, NewYearDate, Result, IsHandled, NewYearDateOverride);
if IsHandled then
exit(Result);
if not FADeprBook."Use Half-Year Convention" then
exit(false);
if FADeprBook."Depreciation Method" = FADeprBook."Depreciation Method"::Manual then
exit(false);
if DeprMethod = DeprMethod::"Below Zero" then
exit(false);
if AccountingPeriod.IsEmpty() then
exit(false);
AccountingPeriod.SetRange("New Fiscal Year", true);
AccountingPeriod.SetFilter(
"Starting Date", '>=%1',
DepreciationCalc.ToMorrow(FADeprBook."Depreciation Starting Date", Year365Days, DeprBook."Use Accounting Period"));
AccountingPeriod.FindFirst();
if NewYearDateOverride <> 0D then
NewYearDate := NewYearDateOverride
else
NewYearDate := AccountingPeriod."Starting Date";
if FirstDeprDate >= NewYearDate then
exit(false);
if DeprBook."No. of Days in Fiscal Year" <> 0 then
DeprBook.TestField("No. of Days in Fiscal Year", 360);
if DeprMethod in
[DeprMethod::"Declining-Balance 2",
DeprMethod::"DB2/SL",
DeprMethod::"User-Defined"]
then
Error(
Text004,
FADeprBook.FieldCaption("Depreciation Method"),
FADeprBook."Depreciation Method",
GetFAName());
exit(true);
end;
local procedure CalcHalfYearConventionDepr(): Decimal
var
DeprAmount: Decimal;
HalfYearPercent: Decimal;
HalfYearFactor: Decimal;
OriginalNumberOfDays: Integer;
OriginalBookValue: Decimal;
OriginalFirstDeprDate: Date;
begin
if CalcTempDeprAmount(TempDeprAmount) then
Error('');
HalfYearPercent := CalcHalfYearPercent();
HalfYearFactor :=
DaysInFiscalYear / 2 /
DepreciationCalc.DeprDays(
FADeprBook."Depreciation Starting Date",
DepreciationCalc.Yesterday(NewYearDate, Year365Days, DeprBook."Use Accounting Period"),
Year365Days, DeprBook."Use Accounting Period");
DeprInTwoFiscalYears := UntilDate >= NewYearDate;
OriginalNumberOfDays := NumberOfDays;
OriginalBookValue := BookValue;
OriginalFirstDeprDate := FirstDeprDate;
if DeprInTwoFiscalYears then
NumberOfDays :=
DepreciationCalc.DeprDays(
FirstDeprDate, DepreciationCalc.Yesterday(NewYearDate, Year365Days, DeprBook."Use Accounting Period"), Year365Days);
if FixedAmount > 0 then
DeprAmount := -FixedAmount * NumberOfDays / DaysInFiscalYear * HalfYearFactor
else
DeprAmount :=
(-HalfYearPercent / 100) * (NumberOfDays / DaysInFiscalYear) * DeprBasis * HalfYearFactor;
OnCalcHalfYearConventionDeprOnAfterFirstCalcDeprAmount(
FADeprBook, FixedAmount, NumberOfDays, DaysInFiscalYear,
HalfYearFactor, UntilDate, HalfYearPercent, NewYearDate, FirstDeprDate, DeprAmount);
if DeprInTwoFiscalYears then begin
NumberOfDays := DepreciationCalc.DeprDays(NewYearDate, UntilDate, Year365Days, DeprBook."Use Accounting Period");
FirstDeprDate := NewYearDate;
BookValue := BookValue + DeprAmount;
case DeprMethod of
DeprMethod::"Straight-Line":
DeprAmount := DeprAmount + CalcSLAmount();
DeprMethod::"Declining-Balance 1":
DeprAmount := DeprAmount + CalcDB1Amount();
DeprMethod::"DB1/SL":
DeprAmount := DeprAmount + CalcDBSLAmount();
DeprMethod::"Country Specific":
; // Reserved for implementation of country specific
end;
end;
NumberOfDays := OriginalNumberOfDays;
BookValue := OriginalBookValue;
FirstDeprDate := OriginalFirstDeprDate;
DeprInTwoFiscalYears := false;
exit(DeprAmount);
end;
local procedure CalcHalfYearPercent() HalfYearPercent: Decimal
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeCalcHalfYearPercent(FADeprBook, NewYearDate, Year365Days, DaysInFiscalYear, DeprMethod, SLPercent, HalfYearPercent, IsHandled);
if IsHandled then
exit(HalfYearPercent);
if (DeprMethod = DeprMethod::"Declining-Balance 1") or (DeprMethod = DeprMethod::"DB1/SL") then
HalfYearPercent := DBPercent
else
if SLPercent > 0 then
HalfYearPercent := SLPercent
else
if DeprYears > 0 then
HalfYearPercent :=
100 /
(DepreciationCalc.DeprDays(
NewYearDate, FADeprBook."Depreciation Ending Date", Year365Days, DeprBook."Use Accounting Period") +
DaysInFiscalYear / 2) * DaysInFiscalYear
else
HalfYearPercent := 0;
end;
local procedure SetDeprMethod(FADeprBook: Record "FA Depreciation Book")
begin
DeprMethod := FADeprBook."Depreciation Method";
end;
local procedure AssignVariablesToStorage(
var StorageDecimal: Dictionary of [Text, Decimal];
var StorageInteger: Dictionary of [Text, Integer];
var StorageDate: Dictionary of [Text, Date];
var StorageCode: Dictionary of [Text, Code[10]];
DeprBookCode2: Code[10];
DateFromProjection2: Date;
UntilDate2: Date;
DaysInPeriod2: Integer;
NumberOfDays4: Integer;
DeprAmount: Decimal)
var
DeprBookCodeLbl: label 'DeprBookCode';
DeprTableCodeLbl: Label 'DeprTableCode';
DateFromProjectionLbl: Label 'DateFromProjection';
EndDateDateLbl: Label 'EndDate';
DeprStartingDateLbl: Label 'DeprStartingDate';
FirstUserDefinedDeprDateLbl: Label 'FirstUserDefinedDeprDate';
AcquisitionDateLbl: Label 'AcquisitionDate';
DisposalDateLbl: Label 'DisposalDate';
DaysInPeriodLbl: Label 'DaysInPeriod';
NumberOfDays4Lbl: Label 'NumberOfDays4';
DaysInFiscalYearLbl: Label 'DaysInFiscalYear';
DeprAmountLbl: Label 'DeprAmount';
BookValueLbl: Label 'BookValue';
MinusBookValueLbl: Label 'MinusBookValue';
DeprBasisLbl: Label 'DeprBasis';
SalvageValueLbl: Label 'SalvageValue';
CopyBookValueLbl: Label 'CopyBookValue';
SLPercentLbl: Label 'SLPercent';
DBPercentLbl: Label 'DBPercent';
DeprYearsLbl: Label 'DeprYears';
FixedAmountLbl: Label 'FixedAmount';
FinalRoundingAmountLbl: Label 'FinalRoundingAmount';
EndingBookValueLbl: Label 'EndingBookValue';
PercentBelowZeroLbl: Label 'PercentBelowZero';
AmountBelowZeroLbl: Label 'AmountBelowZero';
begin
Clear(StorageCode);
Clear(StorageDate);
Clear(StorageDecimal);
Clear(StorageInteger);
StorageCode.Set(DeprBookCodeLbl, DeprBookCode2);
StorageCode.Set(DeprTableCodeLbl, DeprTableCode);
StorageDate.Set(DateFromProjectionLbl, DateFromProjection2);
StorageDate.Set(EndDateDateLbl, UntilDate2);
StorageDate.Set(DeprStartingDateLbl, DeprStartingDate);
StorageDate.Set(FirstUserDefinedDeprDateLbl, FirstUserDefinedDeprDate);
StorageDate.Set(AcquisitionDateLbl, AcquisitionDate);
StorageDate.Set(DisposalDateLbl, DisposalDate);
StorageInteger.Set(DaysInPeriodLbl, DaysInPeriod2);
StorageInteger.Set(NumberOfDays4Lbl, NumberOfDays4);
StorageInteger.Set(DaysInFiscalYearLbl, DaysInFiscalYear);
StorageDecimal.Set(DeprAmountLbl, DeprAmount);
StorageDecimal.Set(BookValueLbl, BookValue);
StorageDecimal.Set(MinusBookValueLbl, MinusBookValue);
StorageDecimal.Set(DeprBasisLbl, DeprBasis);
StorageDecimal.Set(SalvageValueLbl, SalvageValue);
StorageDecimal.set(CopyBookValueLbl, BookValue2);
StorageDecimal.set(SLPercentLbl, SLPercent);
StorageDecimal.Set(DBPercentLbl, DBPercent);
StorageDecimal.Set(DeprYearsLbl, DeprYears);
StorageDecimal.Set(FixedAmountLbl, FixedAmount);
StorageDecimal.Set(FinalRoundingAmountLbl, FinalRoundingAmount);
StorageDecimal.Set(EndingBookValueLbl, EndingBookValue);
StorageDecimal.Set(PercentBelowZeroLbl, PercentBelowZero);
StorageDecimal.Set(AmountBelowZeroLbl, AmountBelowZero);
end;
local procedure AssignStorageToVariables(
var StorageDecimal: Dictionary of [Text, Decimal];
var StorageInteger: Dictionary of [Text, Integer];
var StorageDate: Dictionary of [Text, Date];
var StorageCode: Dictionary of [Text, Code[10]];
var DeprBookCode2: Code[10];
var DateFromProjection2: Date;
var UntilDate2: Date;
var DaysInPeriod2: Integer;
var NumberOfDays4: Integer;
var DeprAmount: Decimal)
var
DeprBookCodeLbl: label 'DeprBookCode';
DeprTableCodeLbl: Label 'DeprTableCode';
DateFromProjectionLbl: Label 'DateFromProjection';
EndDateLbl: Label 'EndDate';
DeprStartingDateLbl: Label 'DeprStartingDate';
FirstUserDefinedDeprDateLbl: Label 'FirstUserDefinedDeprDate';
AcquisitionDateLbl: Label 'AcquisitionDate';
DisposalDateLbl: Label 'DisposalDate';
DaysInPeriodLbl: Label 'DaysInPeriod';
NumberOfDays4Lbl: Label 'NumberOfDays4';
DaysInFiscalYearLbl: Label 'DaysInFiscalYear';
DeprAmountLbl: Label 'DeprAmount';
BookValueLbl: Label 'BookValue';
MinusBookValueLbl: Label 'MinusBookValue';
DeprBasisLbl: Label 'DeprBasis';
SalvageValueLbl: Label 'SalvageValue';
CopyBookValueLbl: Label 'CopyBookValue';
SLPercentLbl: Label 'SLPercent';
DBPercentLbl: Label 'DBPercent';
DeprYearsLbl: Label 'DeprYears';
FixedAmountLbl: Label 'FixedAmount';
FinalRoundingAmountLbl: Label 'FinalRoundingAmount';
EndingBookValueLbl: Label 'EndingBookValue';
PercentBelowZeroLbl: Label 'PercentBelowZero';
AmountBelowZeroLbl: Label 'AmountBelowZero';
begin
DeprBookCode2 := StorageCode.Get(DeprBookCodeLbl);
DeprTableCode := StorageCode.Get(DeprTableCodeLbl);
DateFromProjection2 := StorageDate.Get(DateFromProjectionLbl);
UntilDate2 := StorageDate.Get(EndDateLbl);
DeprStartingDate := StorageDate.Get(DeprStartingDateLbl);
FirstUserDefinedDeprDate := StorageDate.Get(FirstUserDefinedDeprDateLbl);
AcquisitionDate := StorageDate.Get(AcquisitionDateLbl);
DisposalDate := StorageDate.Get(DisposalDateLbl);
DaysInPeriod2 := StorageInteger.Get(DaysInPeriodLbl);
NumberOfDays4 := StorageInteger.Get(NumberOfDays4Lbl);
DaysInFiscalYear := StorageInteger.Get(DaysInFiscalYearLbl);
DeprAmount := StorageDecimal.Get(DeprAmountLbl);
BookValue := StorageDecimal.Get(BookValueLbl);
MinusBookValue := StorageDecimal.Get(MinusBookValueLbl);
DeprBasis := StorageDecimal.Get(DeprBasisLbl);
SalvageValue := StorageDecimal.Get(SalvageValueLbl);
BookValue2 := StorageDecimal.Get(CopyBookValueLbl);
SLPercent := StorageDecimal.Get(SLPercentLbl);
DBPercent := StorageDecimal.Get(DBPercentLbl);
DeprYears := StorageDecimal.Get(DeprYearsLbl);
FixedAmount := StorageDecimal.Get(FixedAmountLbl);
FinalRoundingAmount := StorageDecimal.Get(FinalRoundingAmountLbl);
EndingBookValue := StorageDecimal.Get(EndingBookValueLbl);
PercentBelowZero := StorageDecimal.Get(PercentBelowZeroLbl);
AmountBelowZero := StorageDecimal.Get(AmountBelowZeroLbl);
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalculate(var DeprAmount: Decimal; var NumberOfDays4: Integer; FANo: Code[20]; DeprBookCode2: Code[10]; UntilDate2: Date; EntryAmounts2: array[4] of Decimal; DateFromProjection2: Date; DaysInPeriod2: Integer; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterGetDeprBooks(var DepreciationBook: Record "Depreciation Book"; var FADepreciationBook: Record "FA Depreciation Book")
begin
end;
[IntegrationEvent(true, false)]
local procedure OnCalculateOnBeforeTransferValue(
FANo: Code[20];
var StorageDecimal: Dictionary of [Text, Decimal];
var StorageInterger: Dictionary of [Text, Integer];
var StorageDate: Dictionary of [Text, Date];
var StorageCode: Dictionary of [Text, Code[10]];
var EntryAmounts2: array[4] of Decimal;
var EntryAmounts: array[4] of Decimal;
var DeprMethod: Enum "FA Depr. Method Internal";
var Year365Days: Boolean;
var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSkipRecord(
FixedAsset: Record "Fixed Asset";
DeprBook: Record "Depreciation Book";
DisposalDate: date;
AcquisitionDate: date;
UntilDate: Date;
FADeprMethod: Enum "FA Depreciation Method";
BookValue: Decimal;
DeprBasis: Decimal;
SalvageValue: Decimal;
MinusBookValue: Decimal;
var ReturnValue: Boolean;
var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcTransferValueSetVariables(
var FirstDate: date;
var Year365Days: Boolean;
var UseDeprStartingDate: Boolean;
var NumberOfDays2: integer;
var UseHalfYearConvention: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeNumberofDayCalculateNumberofDays(
FixedAsset: Record "Fixed Asset";
DeprBook: Record "Depreciation Book";
var NumberofDays: Integer;
FirstDeprDate: date;
var UntilDate: Date;
Year365Days: Boolean;
var IsHandled: Boolean;
FADepreciationBook: Record "FA Depreciation Book")
begin
end;
[IntegrationEvent(false, false)]
local procedure UpdateDaysInFiscalYear(
FixedAsset: Record "Fixed Asset";
DeprBook: Record "Depreciation Book";
var NumberofDays: Integer;
var DaysInFiscalYear: Integer;
var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterBookValueRecalculateBookValue(FixedAsset: Record "Fixed Asset"; DeprBook: Record "Depreciation Book"; FAledgEntry2: Record "FA Ledger Entry"; var DeprBasis: Decimal; var BookValue: Decimal; var DeprEndingDate: Date; DisposalDate: Date; var FADepreciationBook: Record "FA Depreciation Book"; DateFromProjection: Date; var SalvageValue: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterBookValueCheckAddedDeprApplicable(
FADepBook: Record "FA Depreciation Book";
DeprBook: Record "Depreciation Book";
FALedgerEntry: Record "FA Ledger Entry";
UntilDate: Date;
var DBPercent: Decimal;
var SlPercent: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterDaysinFYRecalculateDaysInFiscalYear(
FADepBook: Record "FA Depreciation Book";
DeprBook: Record "Depreciation Book";
UntilDate: Date;
var DaysInFiscalYear: Integer;
Year365Days: Boolean;
var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalculateFinalAmount(DepreBook: Record "Depreciation Book"; var Amount: Decimal; var IsHandled: Boolean; FA: Record "Fixed Asset"; UntilDate: Date; BookValue: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSkipOnZeroValue(DepreBook: Record "Depreciation Book"; var SkipOnZero: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcFinalDeprAmount(FANo: Code[20]; FADeprBook: Record "FA Depreciation Book"; DepreBook: Record "Depreciation Book"; Sign: Integer; BookValue: Decimal; var DeprAmount: Decimal; var IsHandled: Boolean; var NumberOfDays: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalculateDeprAmount(FixedAsset: Record "Fixed Asset"; SkipOnZero: Boolean; DeprBookCode: Code[20]; var Amount: Decimal; BookValue: Decimal; SalvageValue: Decimal; EndingBookValue: Decimal; FinalRoundingAmount: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcSL(FixedAsset: Record "Fixed Asset"; FADepreciationBook: Record "FA Depreciation Book"; UntilDate: Date; BookValue: Decimal; DeprBasis: Decimal; DeprYears: Decimal; NumberOfDays: Integer; DaysInFiscalYear: Integer; var ExitValue: Decimal; var IsHandled: Boolean; var RemainingLife: Decimal; var FirstDeprDate: Date)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcDB1Amount(DBPercent: Decimal; NumberOfDays: Integer; DaysInFiscalYear: Integer; BookValue: Decimal; SalvageValue: Decimal; MinusBookValue: Decimal; Sign: Integer; DeprInFiscalYear: Decimal; var Result: Decimal; FADepreciationBook: Record "FA Depreciation Book"; FirstDeprDate: Date)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterTransferValues2(FixedAsset: Record "Fixed Asset"; FADepreciationBook: Record "FA Depreciation Book"; Year365Days: Boolean; var DeprYears: Decimal; var DeprMethod: Enum "FA Depr. Method Internal"; var DeprBasis: Decimal; var BookValue: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterProcessDaysInPeriod(var NumberofDays: Integer; var DaysInPeriod: Integer; var Factor: Decimal; FixedAsset: Record "Fixed Asset"; DeprBook: Record "Depreciation Book"; var FirstDeprDate: date; UntilDate: Date; Year365Days: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeCalcHalfYearPercent(FADeprBook: Record "FA Depreciation Book"; NewYearDate: Date; Year365Days: Boolean; DaysInFiscalYear: Integer; DeprMethod: Enum "FA Depr. Method Internal"; SLPercent: Decimal; var HalfYearPercent: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateDeprAmountOnAfterAssignAmountLastEntry(FADepreciationBook: Record "FA Depreciation Book"; UntilDate: Date; DateFromProjection: Date; BookValue: Decimal; UseHalfYearConvention: Boolean; DaysInFiscalYear: Integer; NumberOfDays: Integer)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcSLAmountOnAfterCalcFromSLPercent(FixedAsset: Record "Fixed Asset"; FADepreciationBook: Record "FA Depreciation Book"; BookValue: Decimal; DeprBasis: Decimal; DaysInFiscalYear: Integer; NumberOfDays: Integer; SLPercent: Decimal; var Result: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcSLAmountOnAfterCalcResultForRemainingLifeExpired(FixedAsset: Record "Fixed Asset"; FADepreciationBook: Record "FA Depreciation Book"; BookValue: Decimal; var Result: Decimal)
begin
end;
[IntegrationEvent(true, false)]
local procedure OnCalculateDeprAmountOnDeprMethodCaseLastEntry(FADepreciationBook: Record "FA Depreciation Book"; BookValue: Decimal; DeprBasis: Decimal; DeprYears: Decimal; DaysInFiscalYear: Integer; NumberOfDays: Integer; var Amount: Decimal; DateFromProjection: Date; UntilDate: Date; DeprMethod: Enum "FA Depr. Method Internal")
begin
end;
[IntegrationEvent(true, false)]
local procedure OnCalculateDeprAmountOnDeprMethodCaseLastDeprEntry(FADepreciationBook: Record "FA Depreciation Book"; BookValue: Decimal; DeprBasis: Decimal; DeprYears: Decimal; DaysInFiscalYear: Integer; NumberOfDays: Integer; var Amount: Decimal; DateFromProjection: Date; UntilDate: Date; DeprMethod: Enum "FA Depr. Method Internal")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcHalfYearConventionDeprOnAfterFirstCalcDeprAmount(FADeprBook: Record "FA Depreciation Book"; FixedAmount: Decimal; NumberOfDays: Integer; DaysInFiscalYear: Integer; HalfYearFactor: Decimal; UntilDate: Date; HalfYearPercent: Decimal; NewYearDate: Date; FirstDeprDate: Date; var DeprAmount: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnTransferValuesOnAfterSetDeprMethod(var FADepreciationBook: Record "FA Depreciation Book"; UntilDate: Date)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateDeprAmountOnBeforeCalculateDeprAmount(FixedAsset: Record "Fixed Asset"; SkipOnZero: Boolean; DeprBookCode: Code[20]; var Amount: Decimal; BookValue: Decimal; SalvageValue2: Decimal; EndingBookValue: Decimal; FinalRoundingAmount: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalculateOnBeforeAssignSkipOnZeroValue(FANo: Code[20]; FADepreciationBook: Record "FA Depreciation Book"; var Sign: Integer; var BookValue: Decimal; var DeprBasis: Decimal; var SalvageValue: Decimal; var MinusBookValue: Decimal; var SkipOnZero: Boolean; EndingBookValue: Decimal; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCalcDBSLAmount(var DBAmount: Decimal; SLAmount: Decimal; FADepreciationBook: Record "FA Depreciation Book"; DateFromProjection: Date)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnCalcSLAmountOnBeforeCheckFixedAmount(FixedAsset: Record "Fixed Asset"; FixedAmount: Decimal; NumberOfDays: Integer; DaysInFiscalYear: Integer; var IsHandled: Boolean; var Result: Decimal)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeSetHalfYearConventionMethod(FADeprBook: Record "FA Depreciation Book"; DeprMethod: Enum "FA Depr. Method Internal"; Year365Days: Boolean; FirstDeprDate: Date; NewYearDate: Date; var Result: Boolean; var IsHandled: Boolean; var NewYearDateOverride: Date)
begin
end;
}