taxtank-core 0.31.61 → 0.32.0

package/esm2022/lib/models/loan/loan.mjs

@@ -0,0 +1,84 @@
+import { __decorate } from "tslib";
+import { Loan as LoanBase } from '../../db/Models/loan/loan';
+import { LoanVehicleTypeEnum, LoanRepaymentFrequencyEnum, LoanInterestTypeLabelEnum, LoanInterestTypeEnum, LoanRepaymentTypeLabelEnum, LoanRepaymentTypeEnum } from '../../db/Enums/bank/loan';
+import { Type } from 'class-transformer';
+import { LoanPayment } from './loan-payment';
+import { LoanPayout } from './loan-payout';
+import { FinancialYear } from '../financial-year';
+import last from 'lodash/last';
+import { LoanPaymentCollection } from '../../collections';
+export class Loan extends LoanBase {
+    /**
+     * 30 years is default mortgage term
+     */
+    static { this.mortgageDefaultTerm = 360; }
+    /**
+     * 5 years is default bank loan term
+     */
+    static { this.loanDefaultTerm = 60; }
+    /**
+     * Check if loan type is related to LoanVehicleTypeEnum
+     */
+    isVehicle() {
+        return !this.bankAccount && this.type in LoanVehicleTypeEnum;
+    }
+    /**
+     * Get the last payment for passed financial year
+     * @param year financial year for filter
+     */
+    getLastPaymentByYear(year) {
+        const finYear = new FinancialYear(new Date(year.toString()));
+        return last(this.payments.filter((payment) => payment.date > finYear.startDate && payment.date < finYear.endDate));
+    }
+    /**
+     * The size of loan interest
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/212369955/Loans+vehicle+loans
+     * @TODO Vik/Nicole: need to update documentation. Derek gave the right formulas to Mikhail
+     */
+    getInterest() {
+        return new LoanPaymentCollection(this.payments).paymentDue - this.amount;
+    }
+    /**
+     * The last payment size
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/212369955/Loans+vehicle+loans
+     * @TODO Vik/Nicole: need to update documentation. Derek gave the right formulas to Mikhail
+     */
+    getBalloonPayment() {
+        const lastPaymentDueAmount = new LoanPaymentCollection(this.payments).last.paymentDue;
+        return (lastPaymentDueAmount - this.repaymentAmount) > 0 ? lastPaymentDueAmount - this.repaymentAmount : 0;
+    }
+    /**
+     * Percent of ballon payment from all payments
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/212369955/Loans+vehicle+loans
+     * @TODO Vik/Nicole: need to update documentation. Derek gave the right formulas to Mikhail
+     */
+    getBalloonPaymentPercentage() {
+        return this.getBalloonPayment() / new LoanPaymentCollection(this.payments).paymentDue * 100;
+    }
+    get monthlyRepaymentAmount() {
+        switch (this.repaymentFrequency) {
+            case LoanRepaymentFrequencyEnum.WEEKLY:
+                return this.repaymentAmount * FinancialYear.weeksInYear / FinancialYear.monthsInYear;
+            case LoanRepaymentFrequencyEnum.FORTNIGHTLY:
+                return this.repaymentAmount * FinancialYear.weeksInYear / FinancialYear.monthsInYear / 2;
+            default:
+                return this.repaymentAmount;
+        }
+    }
+    get interestTypeLabel() {
+        return LoanInterestTypeLabelEnum[LoanInterestTypeEnum[this.interestType]];
+    }
+    get repaymentTypeLabel() {
+        return LoanRepaymentTypeLabelEnum[LoanRepaymentTypeEnum[this.repaymentType]];
+    }
+}
+__decorate([
+    Type(() => LoanPayment)
+], Loan.prototype, "payments", void 0);
+__decorate([
+    Type(() => Date)
+], Loan.prototype, "commencementDate", void 0);
+__decorate([
+    Type(() => LoanPayout)
+], Loan.prototype, "payout", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/property/property.mjs

@@ -0,0 +1,265 @@
+import { __decorate } from "tslib";
+import { Property as PropertyBase } from '../../db/Models/property/property';
+import { PropertySubscription } from './property-subscription';
+import { Exclude, Type } from 'class-transformer';
+import { Address } from '../address';
+import { PropertyCategory } from './property-category';
+import { PropertyValuation } from './property-valuation';
+import { PropertyForecast } from './property-forecast';
+import { PropertyCategoryMovement } from './property-category-movement';
+import { User } from '../user';
+import { FinancialYear } from '../financial-year';
+import { TaxExemptionEnum } from '../../db/Enums/property/property-sale/tax-exemption.enum';
+import { PropertyCategoryListEnum } from '../../db/Enums/property/property-category-list.enum';
+import moment from 'moment';
+import { PropertySaleTaxExemptionMetaFieldCollection } from '../../collections';
+import round from 'lodash/round';
+import { AppFile } from '../file';
+/**
+ * propertySale docs - https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4209508353/Property+Sold+button
+ */
+export class Property extends PropertyBase {
+    /**
+     * Property acquired before 20 September 1985 will generally be treated as pre-Capital Gains Tax (CGT) assets.
+     * Any assets acquired before this day are CGT exempt (because the tax didn't exist before this date).
+     */
+    static { this.preCGTAssetDate = new Date(1985, 9, 20); }
+    get name() {
+        return this.address.name;
+    }
+    get isActive() {
+        return !!this.subscriptions?.length;
+    }
+    isOwn() {
+        return this.user.id === +localStorage.getItem('userId');
+    }
+    isSold() {
+        return !!this.myShare?.sale;
+    }
+    get capitalCostsTotalAmount() {
+        return this.stampDuty + this.legalFees + this.otherCapitalCosts;
+    }
+    get currentYearValuations() {
+        return this.valuations.filter((valuation) => valuation.isCurrentYear());
+    }
+    get marketValue() {
+        return this.actualValuation?.marketValue || 0;
+    }
+    get currentYearForecast() {
+        return this.forecasts.find((forecast) => forecast.isCurrentYear());
+    }
+    get forecastedRentalReturn() {
+        return this.currentYearForecast?.rentalReturn || 0;
+    }
+    get forecastedTaxPosition() {
+        return this.currentYearForecast?.taxPosition || 0;
+    }
+    get forecastedCashPosition() {
+        return this.currentYearForecast?.cashPosition || 0;
+    }
+    get firstForecastYear() {
+        return this.forecasts.reduce((min, forecast) => min > forecast.financialYear ? forecast.financialYear : min, new FinancialYear().year);
+    }
+    get marketValueGrowth() {
+        return (this.marketValue - this.purchasePrice) / this.marketValue;
+    }
+    get myShare() {
+        return this.shares.find((share) => share.user.id === +localStorage.getItem('userId'));
+    }
+    get actualValuation() {
+        return this.valuations.reduce((maxDateValuation, valuation) => maxDateValuation.date > valuation.date ? maxDateValuation : valuation, this.valuations[0]);
+    }
+    get claimPercent() {
+        return this.currentYearForecast.claimPercent;
+    }
+    get claimCoefficient() {
+        return this.claimPercent / 100;
+    }
+    get sharePercent() {
+        return this.myShare.percent;
+    }
+    get shareRatio() {
+        return this.myShare.percent / 100;
+    }
+    get previousCategory() {
+        let previousCategory;
+        const movementsCount = this.categoryMovements.length;
+        if (movementsCount > 1) {
+            previousCategory = this.categoryMovements[movementsCount - 2].propertyCategory;
+        }
+        return previousCategory;
+    }
+    getCurrentSubscription() {
+        // always return first element because subscriptions array contains only one element
+        return this.subscriptions[0];
+    }
+    getForecastByYear(year) {
+        return this.forecasts.find((forecast) => forecast.financialYear === year);
+    }
+    get isShared() {
+        return this.shares.length > 1;
+    }
+    /**
+     * @TODO consider to move methods related with propertySale to separated class, since used just in one module yet
+     * purchase costs - claimed costs, except `ppr to investment` exemption,
+     * in that case it's equal to market value, when property became an investment property
+     */
+    calculateCostBase(sale) {
+        const marketValue = new PropertySaleTaxExemptionMetaFieldCollection(sale.taxExemptionMetaFields).getMarketValue();
+        if (marketValue) {
+            return marketValue;
+        }
+        return this.purchasePrice + this.capitalCostsTotalAmount + sale.holdingCosts + sale.structuralImprovementsWDV - sale.buildingAtCostClaimed;
+    }
+    calculateGrossCapitalGain(sale) {
+        return round((sale.netPrice - this.calculateCostBase(sale)) * this.getPartialCGTExemptionRatio(sale) * this.shareRatio, 2);
+    }
+    /**
+     * net capital gain includes tax exemption
+     */
+    calculateNetCapitalGain(sale) {
+        return this.getCGTExemptionRatio(sale) * sale.grossCapitalGain;
+    }
+    /**
+     * guess tax exemption based on property details
+     */
+    getCGTExemption(sale) {
+        if (sale.taxExemption) {
+            return sale.taxExemption.id;
+        }
+        switch (true) {
+            // exemption for main residence properties
+            case this.category.id === PropertyCategoryListEnum.OWNER_OCCUPIED:
+                return TaxExemptionEnum.PPR;
+            // exemption for investment properties owned for at least one year
+            case this.isOneYearExemptionApplicable(sale):
+                return TaxExemptionEnum.ONE_YEAR_RULE;
+            default:
+                return null;
+        }
+    }
+    getPartialCGTExemptionRatio(sale) {
+        const metaFields = new PropertySaleTaxExemptionMetaFieldCollection(sale.taxExemptionMetaFields);
+        switch (sale.taxExemption?.id) {
+            case TaxExemptionEnum.INVESTMENT_TO_PPR:
+                const ownershipDays = this.getOwnershipDuration(sale);
+                return (ownershipDays - metaFields.getPPRDays()) / ownershipDays;
+            case TaxExemptionEnum.PPR_TO_INVESTMENT:
+                return metaFields.getClaimPercent() / 100;
+            default:
+                return 1;
+        }
+    }
+    /**
+     * tax exemption can reduce cgt from 100% to less (up to zero)
+     */
+    getCGTExemptionRatio(sale) {
+        switch (sale.taxExemption?.id) {
+            // 50% exemption for investments owned for at least one year
+            case TaxExemptionEnum.ONE_YEAR_RULE:
+                return 0.5;
+            case TaxExemptionEnum.INVESTMENT_TO_PPR:
+            case TaxExemptionEnum.PPR_TO_INVESTMENT:
+                return this.isOneYearExemptionApplicable(sale) ? 0.5 : 1;
+            // full exemption
+            case TaxExemptionEnum.PPR:
+            case TaxExemptionEnum.SIX_YEARS_RULE:
+            case TaxExemptionEnum.TRANSFER:
+            case TaxExemptionEnum.OTHER:
+                return 0;
+            // no exemption
+            default:
+                return 1;
+        }
+    }
+    /**
+     * in cgt report we apply losses, which can reset 1 year rule (in case if there is no profit after loss)
+     */
+    isOneYearExemptionApplicable(sale) {
+        return sale.grossCapitalGain > 0 && this.getOwnershipDuration(sale, 'years') > 0;
+    }
+    /**
+     * CGT is not applicable for properties acquired before 20.09.1985 (tax didn't exist before this date).
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4644110466/Tax+Return+MyTax+-+Online+Form ("Capital gains or losses" section)
+     */
+    isCGTApplicable() {
+        return this.contractDate >= Property.preCGTAssetDate;
+    }
+    /**
+     * ownership duration from purchase till sale
+     */
+    getOwnershipDuration(sale, unitOfTime = 'days') {
+        return moment(sale.date).diff(moment(this.contractDate), unitOfTime);
+    }
+    /**
+     * Tax Position = Income - Expense - Interest - Depreciation
+     * Where (Income - Expense - Interest) is cash position.
+     * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217415928/Dashboard+Property
+     */
+    getTaxPosition(transactions, depreciations) {
+        return transactions.grossClaimAmount - Math.abs(depreciations.claimAmount);
+    }
+    get monthlyIncome() {
+        return this.currentYearForecast.income / 12;
+    }
+    get monthlyExpense() {
+        return this.currentYearForecast.expense / 12;
+    }
+    getMpData() {
+        return {
+            'Category': this.category.name,
+            'Taxable': this.category.isTaxInclusive ? 'Yes' : 'No',
+            'Shared': this.isShared ? 'Yes' : 'No',
+            'Ownership %': `${this.myShare.percent}%`
+        };
+    }
+}
+__decorate([
+    Type(() => Number)
+], Property.prototype, "purchasePrice", void 0);
+__decorate([
+    Type(() => Number)
+], Property.prototype, "growthPercent", void 0);
+__decorate([
+    Type(() => Date)
+], Property.prototype, "contractDate", void 0);
+__decorate([
+    Type(() => Date)
+], Property.prototype, "settlementDate", void 0);
+__decorate([
+    Type(() => Address)
+], Property.prototype, "address", void 0);
+__decorate([
+    Type(() => PropertyCategory)
+], Property.prototype, "category", void 0);
+__decorate([
+    Type(() => Number)
+], Property.prototype, "stampDuty", void 0);
+__decorate([
+    Type(() => Number)
+], Property.prototype, "legalFees", void 0);
+__decorate([
+    Type(() => Number)
+], Property.prototype, "otherCapitalCosts", void 0);
+__decorate([
+    Type(() => PropertyValuation)
+], Property.prototype, "valuations", void 0);
+__decorate([
+    Type(() => PropertyForecast)
+], Property.prototype, "forecasts", void 0);
+__decorate([
+    Type(() => PropertyCategoryMovement)
+], Property.prototype, "categoryMovements", void 0);
+__decorate([
+    Type(() => User)
+], Property.prototype, "user", void 0);
+__decorate([
+    Type(() => PropertySubscription)
+], Property.prototype, "subscriptions", void 0);
+__decorate([
+    Type(() => AppFile)
+], Property.prototype, "file", void 0);
+__decorate([
+    Exclude()
+], Property.prototype, "documentFile", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/models/property/property.ts"],"names":[],"mappings":"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","sourcesContent":["import { Property as PropertyBase } from '../../db/Models/property/property';\nimport { PropertyShare } from '../../db/Models';\nimport { PropertySubscription } from './property-subscription';\nimport { Exclude, Type } from 'class-transformer';\nimport { Address } from '../address';\nimport { PropertyCategory } from './property-category';\nimport { PropertyValuation } from './property-valuation';\nimport { PropertyForecast } from './property-forecast';\nimport { PropertyCategoryMovement } from './property-category-movement';\nimport { User } from '../user';\nimport { FinancialYear } from '../financial-year';\nimport { TaxExemptionEnum } from '../../db/Enums/property/property-sale/tax-exemption.enum';\nimport { PropertyCategoryListEnum } from '../../db/Enums/property/property-category-list.enum';\nimport moment from 'moment';\nimport { PropertySale } from './property-sale';\nimport { unitOfTime } from 'moment';\nimport {\n  DepreciationCollection, PropertySaleTaxExemptionMetaFieldCollection, TransactionCollection\n} from '../../collections';\nimport round from 'lodash/round';\nimport { AppFile } from '../file';\nimport { MpTrackableInterface } from '../../interfaces';\n\n/**\n * propertySale docs - https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4209508353/Property+Sold+button\n */\nexport class Property extends PropertyBase implements MpTrackableInterface {\n  /**\n   * Property acquired before 20 September 1985 will generally be treated as pre-Capital Gains Tax (CGT) assets.\n   * Any assets acquired before this day are CGT exempt (because the tax didn't exist before this date).\n   */\n  static preCGTAssetDate: Date = new Date(1985, 9, 20);\n\n  @Type(() => Number)\n    purchasePrice: number;\n\n  @Type(() => Number)\n    growthPercent: number\n\n  @Type(() => Date)\n    contractDate: Date;\n\n  @Type(() => Date)\n    settlementDate: Date;\n\n  @Type(() => Address)\n    address: Address;\n\n  @Type(() => PropertyCategory)\n    category: PropertyCategory;\n\n  @Type(() => Number)\n    stampDuty?: number;\n\n  @Type(() => Number)\n    legalFees?: number;\n\n  @Type(() => Number)\n    otherCapitalCosts?: number;\n\n  @Type(() => PropertyValuation)\n    valuations: PropertyValuation[];\n\n  @Type(() => PropertyForecast)\n    forecasts: PropertyForecast[];\n\n  @Type(() => PropertyCategoryMovement)\n    categoryMovements: PropertyCategoryMovement[];\n\n  @Type(() => User)\n    user: User;\n\n  @Type(() => PropertySubscription)\n    subscriptions: PropertySubscription[];\n\n  @Type(() => AppFile)\n    file: AppFile;\n\n  // could be File when just added new image\n  @Exclude()\n    documentFile: File;\n\n  get name(): string {\n    return this.address.name;\n  }\n\n  get isActive(): boolean {\n    return !!this.subscriptions?.length;\n  }\n\n  isOwn(): boolean {\n    return this.user.id === +localStorage.getItem('userId');\n  }\n\n  isSold(): boolean {\n    return !!this.myShare?.sale;\n  }\n\n  get capitalCostsTotalAmount(): number {\n    return this.stampDuty + this.legalFees + this.otherCapitalCosts;\n  }\n\n  get currentYearValuations(): PropertyValuation[] {\n    return this.valuations.filter((valuation: PropertyValuation): boolean => valuation.isCurrentYear());\n  }\n\n  get marketValue(): number {\n    return this.actualValuation?.marketValue || 0;\n  }\n\n  get currentYearForecast(): PropertyForecast {\n    return this.forecasts.find((forecast: PropertyForecast): boolean => forecast.isCurrentYear());\n  }\n\n  get forecastedRentalReturn(): number {\n    return this.currentYearForecast?.rentalReturn || 0;\n  }\n\n  get forecastedTaxPosition(): number {\n    return this.currentYearForecast?.taxPosition || 0;\n  }\n\n  get forecastedCashPosition(): number {\n    return this.currentYearForecast?.cashPosition || 0;\n  }\n\n  get firstForecastYear(): number {\n    return this.forecasts.reduce((min: number, forecast: PropertyForecast): number => min > forecast.financialYear ? forecast.financialYear : min, new FinancialYear().year);\n  }\n\n  get marketValueGrowth(): number {\n    return (this.marketValue - this.purchasePrice) / this.marketValue;\n  }\n\n  get myShare(): PropertyShare {\n    return this.shares.find((share: PropertyShare): boolean => share.user.id === +localStorage.getItem('userId'));\n  }\n\n  get actualValuation(): PropertyValuation {\n    return this.valuations.reduce((maxDateValuation: PropertyValuation, valuation: PropertyValuation) => maxDateValuation.date > valuation.date ? maxDateValuation : valuation, this.valuations[0]);\n  }\n\n  get claimPercent(): number {\n    return this.currentYearForecast.claimPercent;\n  }\n\n  get claimCoefficient(): number {\n    return this.claimPercent / 100;\n  }\n\n  get sharePercent(): number {\n    return this.myShare.percent;\n  }\n\n  get shareRatio(): number {\n    return this.myShare.percent / 100;\n  }\n\n  get previousCategory(): PropertyCategory {\n    let previousCategory: PropertyCategory;\n\n    const movementsCount: number = this.categoryMovements.length;\n\n    if (movementsCount > 1) {\n      previousCategory = this.categoryMovements[movementsCount - 2].propertyCategory;\n    }\n\n    return previousCategory;\n  }\n\n  getCurrentSubscription(): PropertySubscription {\n    // always return first element because subscriptions array contains only one element\n    return this.subscriptions[0];\n  }\n\n  getForecastByYear(year: number): PropertyForecast {\n    return this.forecasts.find((forecast: PropertyForecast): boolean => forecast.financialYear === year);\n  }\n\n  get isShared(): boolean {\n    return this.shares.length > 1;\n  }\n\n  /**\n   * @TODO consider to move methods related with propertySale to separated class, since used just in one module yet\n   * purchase costs - claimed costs, except `ppr to investment` exemption,\n   * in that case it's equal to market value, when property became an investment property\n   */\n  calculateCostBase(sale: PropertySale): number {\n    const marketValue: number = new PropertySaleTaxExemptionMetaFieldCollection(sale.taxExemptionMetaFields).getMarketValue();\n    if (marketValue) {\n      return marketValue;\n    }\n\n    return this.purchasePrice + this.capitalCostsTotalAmount + sale.holdingCosts + sale.structuralImprovementsWDV - sale.buildingAtCostClaimed;\n  }\n\n  calculateGrossCapitalGain(sale: PropertySale): number {\n    return round((sale.netPrice - this.calculateCostBase(sale)) * this.getPartialCGTExemptionRatio(sale) * this.shareRatio, 2);\n  }\n\n  /**\n   * net capital gain includes tax exemption\n   */\n  calculateNetCapitalGain(sale: PropertySale): number {\n    return this.getCGTExemptionRatio(sale) * sale.grossCapitalGain;\n  }\n\n  /**\n   * guess tax exemption based on property details\n   */\n  getCGTExemption(sale: PropertySale): TaxExemptionEnum {\n    if (sale.taxExemption) {\n      return sale.taxExemption.id;\n    }\n\n    switch (true) {\n      // exemption for main residence properties\n      case this.category.id === PropertyCategoryListEnum.OWNER_OCCUPIED:\n        return TaxExemptionEnum.PPR;\n      // exemption for investment properties owned for at least one year\n      case this.isOneYearExemptionApplicable(sale):\n        return TaxExemptionEnum.ONE_YEAR_RULE;\n      default:\n        return null;\n    }\n  }\n\n  getPartialCGTExemptionRatio(sale: PropertySale): number {\n    const metaFields: PropertySaleTaxExemptionMetaFieldCollection = new PropertySaleTaxExemptionMetaFieldCollection(sale.taxExemptionMetaFields);\n\n    switch (sale.taxExemption?.id) {\n      case TaxExemptionEnum.INVESTMENT_TO_PPR:\n        const ownershipDays = this.getOwnershipDuration(sale);\n        return (ownershipDays - metaFields.getPPRDays()) / ownershipDays;\n      case TaxExemptionEnum.PPR_TO_INVESTMENT:\n        return metaFields.getClaimPercent() / 100;\n      default:\n        return 1;\n    }\n  }\n\n  /**\n   * tax exemption can reduce cgt from 100% to less (up to zero)\n   */\n  getCGTExemptionRatio(sale: PropertySale): number {\n    switch (sale.taxExemption?.id) {\n      // 50% exemption for investments owned for at least one year\n      case TaxExemptionEnum.ONE_YEAR_RULE:\n        return 0.5;\n      case TaxExemptionEnum.INVESTMENT_TO_PPR:\n      case TaxExemptionEnum.PPR_TO_INVESTMENT:\n        return this.isOneYearExemptionApplicable(sale) ? 0.5 : 1;\n      // full exemption\n      case TaxExemptionEnum.PPR:\n      case TaxExemptionEnum.SIX_YEARS_RULE:\n      case TaxExemptionEnum.TRANSFER:\n      case TaxExemptionEnum.OTHER:\n        return 0;\n      // no exemption\n      default:\n        return 1;\n    }\n  }\n\n  /**\n   * in cgt report we apply losses, which can reset 1 year rule (in case if there is no profit after loss)\n   */\n  isOneYearExemptionApplicable(sale: PropertySale): boolean {\n    return sale.grossCapitalGain > 0 && this.getOwnershipDuration(sale, 'years') > 0;\n  }\n\n  /**\n   * CGT is not applicable for properties acquired before 20.09.1985 (tax didn't exist before this date).\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4644110466/Tax+Return+MyTax+-+Online+Form (\"Capital gains or losses\" section)\n   */\n  isCGTApplicable(): boolean {\n    return this.contractDate >= Property.preCGTAssetDate;\n  }\n\n  /**\n   * ownership duration from purchase till sale\n   */\n  getOwnershipDuration(sale: PropertySale, unitOfTime: unitOfTime.Diff = 'days'): number {\n    return moment(sale.date).diff(moment(this.contractDate), unitOfTime);\n  }\n\n  /**\n   * Tax Position = Income - Expense - Interest - Depreciation\n   * Where (Income - Expense - Interest) is cash position.\n   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/217415928/Dashboard+Property\n   */\n  getTaxPosition(transactions: TransactionCollection, depreciations: DepreciationCollection): number {\n    return transactions.grossClaimAmount - Math.abs(depreciations.claimAmount);\n  }\n\n  get monthlyIncome(): number {\n    return this.currentYearForecast.income / 12;\n  }\n\n  get monthlyExpense(): number {\n    return this.currentYearForecast.expense / 12;\n  }\n\n  getMpData() {\n    return {\n      'Category': this.category.name,\n      'Taxable': this.category.isTaxInclusive ? 'Yes' : 'No',\n      'Shared': this.isShared ? 'Yes' : 'No',\n      'Ownership %': `${this.myShare.percent}%`\n    }\n  }\n}\n"]}

package/esm2022/lib/models/report/my-tax/my-tax-deductions/my-tax-deductions.mjs

@@ -0,0 +1,96 @@
+import { TransactionCollection } from '../../../../collections';
+import { DEDUCTION_CATEGORIES } from './deduction-fields.const';
+import { ChartAccountsHeadingListEnum } from '../../../../db/Enums';
+import { DeductionClothingTypeEnum } from './deduction-clothing-type.enum';
+import { DeductionSelfEducationTypeEnum } from './deduction-self-education-type.enum';
+import { TankTypeEnum } from '../../../../db/Enums/tank-type.enum';
+export class MyTaxDeductions {
+    /**
+     * can't claim the first $250 of self-education expenses (Item code D4)
+     */
+    static { this.selfEducationNotDeductibleAmount = -250; }
+    constructor(transactions, depreciations, vehicleClaim, vehicleClaimDetails, vehicleClaimRate) {
+        this.transactions = transactions;
+        this.depreciations = depreciations;
+        this.vehicleClaim = vehicleClaim;
+        this.vehicleClaimDetails = vehicleClaimDetails;
+        this.vehicleClaimRate = vehicleClaimRate;
+        // user can have no selected vehicle claim
+        if (this.vehicleClaim) {
+            this.setVehicleClaimData();
+        }
+        this.setOtherWorkRelatedExpensesTotalAmount();
+        this.workRelatedClothingExpenses = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.workRelatedClothingExpenses);
+        this.personalSuperContributions = this.transactions
+            .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.personalSuperContributions);
+        this.workRelatedSelfEducationExpenses = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.workRelatedSelfEducationExpenses);
+        this.vehicleExpensesTotalAmount = this.getVehicleExpensesTotalAmount();
+        this.workRelatedTravelExpensesTotalAmount = this.transactions
+            .filterBy('chartAccounts.heading.id', ChartAccountsHeadingListEnum.WORK_RELATED_TRAVEL_EXPENSES)
+            .sumBy('claimAmount');
+        this.workRelatedClothingType = this.workRelatedClothingExpenses.length ? DeductionClothingTypeEnum.COMPULSORY_C : null;
+        this.workRelatedClothingTotalAmount = this.workRelatedClothingExpenses.sumBy('claimAmount');
+        this.workRelatedSelfEducationType = this.workRelatedSelfEducationExpenses.length ?
+            DeductionSelfEducationTypeEnum.IMPROVE_SKILLS_FOR_CURRENT_EARNINGS_K : null;
+        this.workRelatedSelfEducationTotalAmount = this.calculateWorkRelatedSelfEducationTotalAmount();
+        this.lowValuePoolDeductionTotalAmount = this.depreciations.getByTankType(TankTypeEnum.WORK)
+            .getLVPDepreciations().sumBy('claimAmount');
+        this.interestExpensesTotalAmount = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.interestExpenses)
+            .sumBy('claimAmount');
+        this.dividendExpensesTotalAmount = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.dividendExpenses)
+            .sumBy('claimAmount');
+        this.donationsTotalAmount = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.donations)
+            .sumBy('claimAmount');
+        this.interestsChargedByATOTotalAmount = this.transactions
+            .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.interestsChargedByATO)
+            .sumBy('claimAmount');
+        this.litigationCostsTotalAmount = this.transactions
+            .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.litigationCosts)
+            .sumBy('claimAmount');
+        this.otherManagingCostsTotalAmount = this.transactions
+            .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.otherManagingCosts)
+            .sumBy('claimAmount');
+        this.personalSuperContributionsTotalAmount = this.personalSuperContributions.sumBy('claimAmount');
+        this.forestryManagedInvestmentSchemesDeductionsTotalAmount = this.transactions
+            .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.forestryManagedInvestmentSchemesDeductions)
+            .sumBy('claimAmount');
+        this.otherDeductionsTotalAmount = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.otherDeductions)
+            .sumBy('claimAmount');
+        this.depreciationAndCapitalAllowancesTotalAmount = this.depreciations
+            .filter((depreciation) => !depreciation.isLVP())
+            .sumBy('claimAmount');
+    }
+    getVehicleExpensesTotalAmount() {
+        if (this.vehicleClaimDetails) {
+            return this.vehicleClaimDetails.isLogbookMethod() ? this.totalExpensesAmount : this.klmsMethodClaimAmount;
+        }
+        return 0;
+    }
+    setVehicleClaimData() {
+        this.klmsMethodClaimAmount = this.vehicleClaim.getKMSClaimAmount(this.vehicleClaimRate);
+        this.totalExpensesAmount = this.vehicleClaim.getLogbookClaimAmount(new TransactionCollection([
+            ...this.transactions.getByTankType(this.vehicleClaim.tankType),
+            ...this.depreciations.getByTankType(this.vehicleClaim.tankType).toTransactions().toArray()
+        ]));
+    }
+    /**
+     * Total amount from Other work related expenses and Tools & equipment depreciations
+     */
+    setOtherWorkRelatedExpensesTotalAmount() {
+        const otherIncomeRelatedExpenses = this.transactions
+            .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.otherIncomeRelatedExpenses);
+        this.otherWorkRelatedExpensesTotalAmount = -Math.abs(otherIncomeRelatedExpenses.sumBy('claimAmount')) -
+            this.depreciations.filterBy('chartAccounts.heading.id', ChartAccountsHeadingListEnum.TOOLS_EQUIPMENT).sumBy('claimAmount');
+    }
+    calculateWorkRelatedSelfEducationTotalAmount() {
+        return !this.workRelatedSelfEducationExpenses ? 0 :
+            this.workRelatedSelfEducationExpenses.sumBy('claimAmount') - MyTaxDeductions.selfEducationNotDeductibleAmount;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"my-tax-deductions.js","sourceRoot":"","sources":["../../../../../../../../projects/tt-core/src/lib/models/report/my-tax/my-tax-deductions/my-tax-deductions.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionCollection } from '../../../../collections';\nimport { DepreciationCollection } from '../../../../collections/depreciation.collection';\nimport { DEDUCTION_CATEGORIES } from './deduction-fields.const';\nimport { ChartAccountsHeadingListEnum } from '../../../../db/Enums';\nimport { DeductionClothingTypeEnum } from './deduction-clothing-type.enum';\nimport { DeductionSelfEducationTypeEnum } from './deduction-self-education-type.enum';\nimport { TankTypeEnum } from '../../../../db/Enums/tank-type.enum';\nimport { VehicleClaim, VehicleClaimDetails } from '../../../vehicle';\nimport { Depreciation } from '../../../depreciation/depreciation';\n\nexport class MyTaxDeductions {\n  /**\n   * can't claim the first $250 of self-education expenses (Item code D4)\n   */\n  static selfEducationNotDeductibleAmount = -250;\n\n  transactions: TransactionCollection;\n  depreciations: DepreciationCollection;\n  vehicleClaim: VehicleClaim;\n  vehicleClaimDetails: VehicleClaimDetails;\n  vehicleClaimRate: number;\n  workRelatedClothingExpenses: TransactionCollection;\n  workRelatedSelfEducationExpenses: TransactionCollection;\n  personalSuperContributions: TransactionCollection;\n  otherWorkRelatedExpensesTotalAmount: number;\n  klmsMethodClaimAmount: number;\n  totalExpensesAmount: number;\n  vehicleExpensesTotalAmount: number;\n  workRelatedTravelExpensesTotalAmount: number;\n  workRelatedClothingType: DeductionClothingTypeEnum;\n  workRelatedClothingTotalAmount: number;\n  workRelatedSelfEducationType: DeductionSelfEducationTypeEnum;\n  workRelatedSelfEducationTotalAmount: number;\n  lowValuePoolDeductionTotalAmount: number;\n  interestExpensesTotalAmount: number;\n  dividendExpensesTotalAmount: number;\n  donationsTotalAmount: number;\n  interestsChargedByATOTotalAmount: number;\n  litigationCostsTotalAmount: number;\n  otherManagingCostsTotalAmount: number;\n  personalSuperContributionsTotalAmount: number;\n  forestryManagedInvestmentSchemesDeductionsTotalAmount: number;\n  otherDeductionsTotalAmount: number;\n  depreciationAndCapitalAllowancesTotalAmount: number;\n\n  constructor(\n    transactions: TransactionCollection,\n    depreciations: DepreciationCollection,\n    vehicleClaim: VehicleClaim,\n    vehicleClaimDetails: VehicleClaimDetails,\n    vehicleClaimRate: number\n  ) {\n    this.transactions = transactions;\n    this.depreciations = depreciations;\n    this.vehicleClaim = vehicleClaim;\n    this.vehicleClaimDetails = vehicleClaimDetails;\n    this.vehicleClaimRate = vehicleClaimRate;\n\n    // user can have no selected vehicle claim\n    if (this.vehicleClaim) {\n      this.setVehicleClaimData();\n    }\n\n    this.setOtherWorkRelatedExpensesTotalAmount();\n\n    this.workRelatedClothingExpenses = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.workRelatedClothingExpenses);\n    this.personalSuperContributions = this.transactions\n      .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.personalSuperContributions);\n    this.workRelatedSelfEducationExpenses = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.workRelatedSelfEducationExpenses);\n    this.vehicleExpensesTotalAmount = this.getVehicleExpensesTotalAmount();\n    this.workRelatedTravelExpensesTotalAmount = this.transactions\n      .filterBy('chartAccounts.heading.id', ChartAccountsHeadingListEnum.WORK_RELATED_TRAVEL_EXPENSES)\n      .sumBy('claimAmount');\n    this.workRelatedClothingType = this.workRelatedClothingExpenses.length ? DeductionClothingTypeEnum.COMPULSORY_C : null;\n    this.workRelatedClothingTotalAmount = this.workRelatedClothingExpenses.sumBy('claimAmount');\n    this.workRelatedSelfEducationType = this.workRelatedSelfEducationExpenses.length ?\n      DeductionSelfEducationTypeEnum.IMPROVE_SKILLS_FOR_CURRENT_EARNINGS_K : null;\n    this.workRelatedSelfEducationTotalAmount = this.calculateWorkRelatedSelfEducationTotalAmount();\n    this.lowValuePoolDeductionTotalAmount = this.depreciations.getByTankType(TankTypeEnum.WORK)\n      .getLVPDepreciations().sumBy('claimAmount');\n    this.interestExpensesTotalAmount = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.interestExpenses)\n      .sumBy('claimAmount');\n    this.dividendExpensesTotalAmount = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.dividendExpenses)\n      .sumBy('claimAmount');\n    this.donationsTotalAmount = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.donations)\n      .sumBy('claimAmount');\n    this.interestsChargedByATOTotalAmount = this.transactions\n      .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.interestsChargedByATO)\n      .sumBy('claimAmount');\n    this.litigationCostsTotalAmount = this.transactions\n      .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.litigationCosts)\n      .sumBy('claimAmount');\n    this.otherManagingCostsTotalAmount = this.transactions\n      .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.otherManagingCosts)\n      .sumBy('claimAmount');\n    this.personalSuperContributionsTotalAmount = this.personalSuperContributions.sumBy('claimAmount');\n    this.forestryManagedInvestmentSchemesDeductionsTotalAmount = this.transactions\n      .filterBy('chartAccounts.id', DEDUCTION_CATEGORIES.forestryManagedInvestmentSchemesDeductions)\n      .sumBy('claimAmount');\n    this.otherDeductionsTotalAmount = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.otherDeductions)\n      .sumBy('claimAmount');\n    this.depreciationAndCapitalAllowancesTotalAmount = this.depreciations\n      .filter((depreciation: Depreciation) => !depreciation.isLVP())\n      .sumBy('claimAmount');\n  }\n\n  private getVehicleExpensesTotalAmount(): number {\n    if (this.vehicleClaimDetails) {\n      return this.vehicleClaimDetails.isLogbookMethod() ? this.totalExpensesAmount : this.klmsMethodClaimAmount;\n    }\n\n    return 0;\n  }\n\n  private setVehicleClaimData(): void {\n    this.klmsMethodClaimAmount = this.vehicleClaim.getKMSClaimAmount(this.vehicleClaimRate);\n    this.totalExpensesAmount = this.vehicleClaim.getLogbookClaimAmount(\n      new TransactionCollection([\n        ...this.transactions.getByTankType(this.vehicleClaim.tankType),\n        ...this.depreciations.getByTankType(this.vehicleClaim.tankType).toTransactions().toArray()\n      ])\n    );\n  }\n\n  /**\n   * Total amount from Other work related expenses and Tools & equipment depreciations\n   */\n  private setOtherWorkRelatedExpensesTotalAmount(): void {\n    const otherIncomeRelatedExpenses: TransactionCollection = this.transactions\n      .filterBy('chartAccounts.heading.id', DEDUCTION_CATEGORIES.otherIncomeRelatedExpenses);\n    this.otherWorkRelatedExpensesTotalAmount = -Math.abs(otherIncomeRelatedExpenses.sumBy('claimAmount')) -\n      this.depreciations.filterBy('chartAccounts.heading.id', ChartAccountsHeadingListEnum.TOOLS_EQUIPMENT).sumBy('claimAmount');\n  }\n\n  private calculateWorkRelatedSelfEducationTotalAmount(): number {\n    return !this.workRelatedSelfEducationExpenses ? 0 :\n      this.workRelatedSelfEducationExpenses.sumBy('claimAmount') - MyTaxDeductions.selfEducationNotDeductibleAmount;\n  }\n}\n"]}

package/esm2022/lib/models/service-subscription/service-payment.mjs

@@ -0,0 +1,22 @@
+import { __decorate } from "tslib";
+import { ServicePayment as BaseServicePayment } from '../../db/Models/subscription/service-payment';
+import { ServiceSubscription } from './service-subscription';
+import { Type } from 'class-transformer';
+export class ServicePayment extends BaseServicePayment {
+    static { this.daysToInvoiceUrlExpired = 30; }
+    /**
+     * Stripe stores actual links to payment invoices for 30 days.
+     * Link expires after 30 days
+     */
+    isInvoiceLinkExpired() {
+        const expirationDate = new Date(this.date.setDate(this.date.getDate() + ServicePayment.daysToInvoiceUrlExpired));
+        return expirationDate.getTime() < new Date().getTime();
+    }
+}
+__decorate([
+    Type(() => ServiceSubscription)
+], ServicePayment.prototype, "subscription", void 0);
+__decorate([
+    Type(() => Date)
+], ServicePayment.prototype, "date", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmljZS1wYXltZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy9zZXJ2aWNlLXN1YnNjcmlwdGlvbi9zZXJ2aWNlLXBheW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxjQUFjLElBQUksa0JBQWtCLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUNwRyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM3RCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFekMsTUFBTSxPQUFPLGNBQWUsU0FBUSxrQkFBa0I7YUFDN0MsNEJBQXVCLEdBQUcsRUFBRSxDQUFDO0lBUXBDOzs7T0FHRztJQUNILG9CQUFvQjtRQUNsQixNQUFNLGNBQWMsR0FBUyxJQUFJLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxHQUFHLGNBQWMsQ0FBQyx1QkFBdUIsQ0FBQyxDQUFDLENBQUM7UUFFdkgsT0FBTyxjQUFjLENBQUMsT0FBTyxFQUFFLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUN6RCxDQUFDOztBQWJDO0lBREQsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLG1CQUFtQixDQUFDO29EQUNJO0FBR2xDO0lBREQsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQzs0Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFNlcnZpY2VQYXltZW50IGFzIEJhc2VTZXJ2aWNlUGF5bWVudCB9IGZyb20gJy4uLy4uL2RiL01vZGVscy9zdWJzY3JpcHRpb24vc2VydmljZS1wYXltZW50JztcbmltcG9ydCB7IFNlcnZpY2VTdWJzY3JpcHRpb24gfSBmcm9tICcuL3NlcnZpY2Utc3Vic2NyaXB0aW9uJztcbmltcG9ydCB7IFR5cGUgfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XG5cbmV4cG9ydCBjbGFzcyBTZXJ2aWNlUGF5bWVudCBleHRlbmRzIEJhc2VTZXJ2aWNlUGF5bWVudCB7XG4gIHN0YXRpYyBkYXlzVG9JbnZvaWNlVXJsRXhwaXJlZCA9IDMwO1xuXG4gIEBUeXBlKCgpID0+IFNlcnZpY2VTdWJzY3JpcHRpb24pXG4gICAgc3Vic2NyaXB0aW9uOiBTZXJ2aWNlU3Vic2NyaXB0aW9uO1xuXG4gIEBUeXBlKCgpID0+IERhdGUpXG4gICAgZGF0ZTogRGF0ZTtcblxuICAvKipcbiAgICogU3RyaXBlIHN0b3JlcyBhY3R1YWwgbGlua3MgdG8gcGF5bWVudCBpbnZvaWNlcyBmb3IgMzAgZGF5cy5cbiAgICogTGluayBleHBpcmVzIGFmdGVyIDMwIGRheXNcbiAgICovXG4gIGlzSW52b2ljZUxpbmtFeHBpcmVkKCk6IGJvb2xlYW4ge1xuICAgIGNvbnN0IGV4cGlyYXRpb25EYXRlOiBEYXRlID0gbmV3IERhdGUodGhpcy5kYXRlLnNldERhdGUodGhpcy5kYXRlLmdldERhdGUoKSArIFNlcnZpY2VQYXltZW50LmRheXNUb0ludm9pY2VVcmxFeHBpcmVkKSk7XG5cbiAgICByZXR1cm4gZXhwaXJhdGlvbkRhdGUuZ2V0VGltZSgpIDwgbmV3IERhdGUoKS5nZXRUaW1lKCk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/models/service-subscription/service-product.mjs

@@ -0,0 +1,27 @@
+import { ServiceProduct as BaseServiceProduct } from '../../db/Models/subscription/service-product';
+import { ServiceProductStatusEnum } from '../../db/Enums/subscription/service-product-status.enum';
+import { ServiceProductIdEnum } from '../../db/Enums/subscription/service-product-id.enum';
+export class ServiceProduct extends BaseServiceProduct {
+    static { this.quantity = 4; }
+    isProperties() {
+        return [ServiceProductIdEnum.PROPERTY_OLD, ServiceProductIdEnum.PROPERTIES].includes(this.id);
+    }
+    isWorkTank() {
+        return [ServiceProductIdEnum.WORK_TANK_OLD, ServiceProductIdEnum.WORK_TANK].includes(this.id);
+    }
+    isSoleTank() {
+        return this.id === ServiceProductIdEnum.SOLE_TANK;
+    }
+    isHoldingsTank() {
+        return this.id === ServiceProductIdEnum.HOLDINGS_TANK;
+    }
+    isArchived() {
+        return this.status === ServiceProductStatusEnum.ARCHIVED;
+    }
+}
+// const TestEnum = {
+//   4: 4,
+//   5: 7,
+//   6: 6
+// }
+//# sourceMappingURL=data:application/json;base64,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