taxtank 0.1.0

package/projects/tt-core/src/lib/models/property/property-equity-chart-data.ts

@@ -0,0 +1,205 @@
+import first from 'lodash/first';
+import { PropertyEquityChartItem } from './property-equity-chart-item';
+import {
+  BankAccountCollection,
+  LoanCollection,
+  PropertyCollection,
+  PropertyValuationCollection
+} from '../../collections';
+import { FinancialYear } from '../financial-year';
+import { PropertyEquityChartTypeEnum } from './property-equity-chart-type.enum';
+import { Property } from './property';
+import { BankAccount } from '../bank';
+import { BankAccountTypeEnum } from '../../db/Enums';
+
+// count of years for future values
+const FORECAST_YEARS = 25;
+
+/**
+ * class contain actual and forecasted market values and loan balances for passed properties
+ * X axis - years from the first actual data year to the last forecasted year
+ * Y axis - amounts of market values, loan balances
+ * Also on hover appear equity positions point
+ */
+export class PropertyEquityChartData {
+  // list of equity positions for all years range
+  list: PropertyEquityChartItem[];
+  // current financial year
+  currentYear: number;
+
+  constructor(
+    private properties: PropertyCollection,
+    private valuations: PropertyValuationCollection,
+    private bankAccounts: BankAccountCollection,
+    private loans: LoanCollection,
+    private registerDate: Date
+  ) {
+    this.bankAccounts = bankAccounts.getLoanAndOffsetAccounts();
+    this.currentYear = new FinancialYear(new Date()).year;
+    this.initItems();
+    this.buildHistoryItems();
+    this.buildActualItem();
+    this.buildForecastedItems();
+    this.checkZeroLoanBalance();
+    this.checkZeroMarketValue();
+  }
+
+  /**
+   * get items list in chart series format
+   * @param type
+   */
+  getChartSeries(type: PropertyEquityChartTypeEnum): number[][] {
+    return this.list.map((item: PropertyEquityChartItem) => item.getSerie(type));
+  }
+
+  /**
+   * get prepared chart data
+   */
+  getChartData(): object[] {
+    return [
+      {
+        id: 'marketValue',
+        name: 'Market Value',
+        series: this.getChartSeries(PropertyEquityChartTypeEnum.MARKET_VALUE),
+        // display future market value with dash line and past market value with solid line
+        zones: [{
+          // line style after current calendar year
+          value: this.currentYear,
+          dashStyle: 'Solid'
+        }, {
+          // default line style
+          dashStyle: 'Dash'
+        }]
+      },
+      {
+        // id used to add/remove serie to chart
+        id: 'loanBalance',
+        name: 'Loan Balance',
+        series: this.getChartSeries(PropertyEquityChartTypeEnum.LOAN_BALANCE)
+      }
+    ];
+  }
+
+  /**
+   * create empty equity position item for each year in collection
+   */
+  private initItems(): void {
+    this.list = [];
+    for (let year: number = new FinancialYear(this.registerDate).year - 1; year <= (this.currentYear + FORECAST_YEARS); year++) {
+      this.list.push(new PropertyEquityChartItem(year));
+    }
+  }
+
+  /**
+   * collect equity position items with past values from properties forecasts
+   */
+  private buildHistoryItems(): void {
+    // get items for past and current years
+    const items: PropertyEquityChartItem[] = this.list.filter((item: PropertyEquityChartItem) => item.year <= this.currentYear);
+    items.forEach((item: PropertyEquityChartItem) => {
+      // increase item values with property actual forecasts for item year
+      item.marketValue = this.properties.items.reduce((sum: number, property: Property): number => sum + this.getMarketValueForPropertyByYear(property, item.year), 0);
+
+      item.loanBalance = this.properties.items.reduce((sum: number, property: Property): number => sum + this.getLoanBalanceByYear(property, item.year), 0);
+    });
+  }
+
+  /**
+   * @TODO remove, there is no difference between actual and history calculations
+   * set actual year's real data
+   * @private
+   */
+  private buildActualItem(): void {
+    const item: PropertyEquityChartItem = this.list.find((i: PropertyEquityChartItem) => i.year === this.currentYear);
+    item.marketValue = this.valuations.getMarketValue(new Date());
+    item.loanBalance = 0;
+    this.properties.items.forEach(property => {
+      item.loanBalance += this.getLoanBalanceByYear(property, this.currentYear);
+    });
+  }
+
+  /**
+   * collect equity position items with forecasted (future) calculated values
+   */
+  private buildForecastedItems(): void {
+    // calculate future values for all properties separately
+    this.properties.items.forEach((property: Property) => {
+      const marketValue = this.valuations.filterBy('property.id', property.id).getMarketValue(new Date());
+      let forecastedMarketValue: number = (property.growthPercent / 100) * marketValue + marketValue;
+
+      // calculate future values for each future year for current handling property
+      this.list
+        .filter((item: PropertyEquityChartItem) => item.year > this.currentYear)
+        .forEach((item: PropertyEquityChartItem) => {
+          // increase loan balance amount for handling equity position item
+          item.loanBalance += this.getLoanBalanceByYear(property, item.year);
+
+          // increase market value amount for handling equity position item
+          item.marketValue += forecastedMarketValue;
+
+          // increase current market value forecast for the next cycle iteration
+          forecastedMarketValue += forecastedMarketValue * (property.growthPercent / 100);
+        });
+    });
+  }
+
+  /**
+   * Get property loan balance by financial year
+   * @param property Property instance for filter
+   * @param year Financial year number
+   * @private
+   */
+  private getLoanBalanceByYear(property: Property, year: number): number {
+    if (new FinancialYear(property.contractDate).year > year) {
+      return 0;
+    }
+
+    const bankAccounts = this.bankAccounts.getByPropertyId(property.id);
+    const loans = this.loans.getByBankAccountsIds(bankAccounts.getIds());
+    const offset = bankAccounts.filterBy('type', BankAccountTypeEnum.OFFSET).getPropertyBalanceAmount(property.id);
+
+    if (year > this.currentYear) {
+      return bankAccounts.items.reduce((totalSum: number, bankAccount: BankAccount) => totalSum + (bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.getLastPaymentByYear(year)?.totalOwed || 0)), 0) - offset;
+    }
+
+    if (year == this.currentYear) {
+      return bankAccounts.items.reduce(
+        (totalSum: number, bankAccount: BankAccount) => totalSum + (bankAccount.getPropertyPercentage(property.id) * (Math.abs(loans.getByBankAccountId(bankAccount.id)?.currentBalance) || 0)), 0
+      ) - offset;
+    }
+
+    return Math.abs(property.getForecastByYear(year).loanBalance) - offset;
+    // @TODO TT-4888 no idea why it was calculated like that
+    // return property.getValuationByYear(year).marketValue - offset;
+  }
+
+  getMarketValueForPropertyByYear(property: Property, year: number): number {
+    if (new FinancialYear(property.contractDate).year > year) {
+      return 0;
+    }
+
+    return property.getValuationByYear(year).marketValue;
+  }
+
+  /**
+   * Check if loan balance is 0 and set it as null (to not to draw point on the chart)
+   */
+  private checkZeroLoanBalance(): void {
+    this.list.forEach((item: PropertyEquityChartItem) => {
+      if (item.loanBalance === 0) {
+        item.loanBalance = null;
+      }
+    });
+  }
+
+  /**
+   * Check if market value is 0 and set it as null (to not to draw point on the chart)
+   */
+  private checkZeroMarketValue(): void {
+    this.list.forEach((item: PropertyEquityChartItem) => {
+      if (item.marketValue === 0) {
+        item.marketValue = null;
+      }
+    });
+  }
+}

package/projects/tt-core/src/lib/models/property/property-equity-chart-item.ts

@@ -0,0 +1,35 @@
+import { PropertyEquityChartTypeEnum } from './property-equity-chart-type.enum';
+
+/**
+ * class contains equity information for passed financial year
+ */
+export class PropertyEquityChartItem {
+  year: number;
+  marketValue: number;
+  loanBalance: number;
+
+  constructor(
+    year: number,
+    marketValue?: number,
+    loanBalance?: number
+  ) {
+    this.year = year;
+    this.marketValue = marketValue || 0;
+    this.loanBalance = loanBalance || 0;
+  }
+
+  /**
+   * calculate equity position
+   */
+  get equityPosition(): number {
+    return this.marketValue - this.loanBalance;
+  }
+
+  /**
+   * return this equity position instance as chart serie
+   * @param type
+   */
+  getSerie(type: PropertyEquityChartTypeEnum): number[] {
+    return [this.year, this[type]];
+  }
+}

package/projects/tt-core/src/lib/models/property/property-equity-chart-type.enum.ts

@@ -0,0 +1,4 @@
+export enum PropertyEquityChartTypeEnum {
+  MARKET_VALUE = 'marketValue',
+  LOAN_BALANCE = 'loanBalance'
+}

package/projects/tt-core/src/lib/models/property/property-forecast.ts

@@ -0,0 +1,40 @@
+import { PropertyForecast as PropertyForecastBase } from '../../db/Models/property/property-forecast';
+import { FinancialYear } from '../financial-year';
+import { Transform } from 'class-transformer';
+
+export class PropertyForecast extends PropertyForecastBase {
+  @Transform(({ value }) => +value)
+  income = 0;
+
+  @Transform(({ value }) => -Math.abs(+value))
+  expense = 0;
+
+  @Transform(({ value }) => -Math.abs(+value))
+  interest = 0;
+
+  @Transform(({ value }) => -Math.abs(+value))
+  depreciation = 0;
+
+  @Transform(({ value }) => +value)
+  loanBalance = 0;
+  claimPercent?: number;
+
+  financialYear: number = new FinancialYear(new Date()).year;
+
+  /**
+   * Get cash position
+   * Cash Position = Income - Expense - Interest
+   */
+  get cashPosition(): number {
+    return this.income + this.expense + this.interest;
+  }
+
+
+  /**
+   * Get tax position
+   * Tax Position = Income - Expense - Interest - Depreciation
+   */
+  get taxPosition(): number {
+    return this.cashPosition + this.depreciation;
+  }
+}

package/projects/tt-core/src/lib/models/property/property-sale/index.ts

@@ -0,0 +1,5 @@
+export * from './property-sale';
+export * from './property-sale-cost-base';
+export * from './property-sale-tax-exemption-meta-field';
+export * from './tax-exemption';
+export * from './tax-exemption-meta-field';

package/projects/tt-core/src/lib/models/property/property-sale/property-sale-cost-base.ts

@@ -0,0 +1,25 @@
+import { Property } from '../property';
+import { PropertySale } from './property-sale';
+import { plainToClass } from 'class-transformer';
+import { DepreciationCollection, TransactionCollection } from '../../../collections';
+
+/**
+ * @Todo TT-2143 should be removed when PropertySaleCostBaseForm refactored (cut property to separated form)
+ */
+export class PropertySaleCostBase {
+  property: Property;
+  sale: PropertySale;
+
+  static createFrom(property: Property, propertySale: PropertySale, depreciations: DepreciationCollection, holdingCosts: TransactionCollection = new TransactionCollection()): PropertySaleCostBase {
+    return plainToClass(PropertySaleCostBase, {
+      property: plainToClass(Property, property),
+      sale: plainToClass(PropertySale, Object.assign({}, propertySale,
+        {
+          holdingCosts: propertySale.holdingCosts ?? Math.abs(holdingCosts.sumBy('amount')),
+          structuralImprovementsWDV: propertySale.structuralImprovementsWDV ?? depreciations.getWithCapitalProject().getCloseBalanceByYear(),
+          buildingAtCostClaimed: propertySale.buildingAtCostClaimed ?? depreciations.getWithoutCapitalProject().getClaimedAmountByYear(),
+        }
+      )),
+    })
+  }
+}

package/projects/tt-core/src/lib/models/property/property-sale/property-sale-tax-exemption-meta-field.ts

@@ -0,0 +1,4 @@
+import { PropertySaleTaxExemptionMetaField as BasePropertySaleTaxExemptionMetaField } from '../../../db/Models/property/property-sale/property-sale-tax-exemption-meta-field';
+
+export class PropertySaleTaxExemptionMetaField extends BasePropertySaleTaxExemptionMetaField {
+}

package/projects/tt-core/src/lib/models/property/property-sale/property-sale.ts

@@ -0,0 +1,60 @@
+import { Type } from 'class-transformer';
+import { PropertySaleTaxExemptionMetaField, PropertyShare } from '../../../db/Models';
+import { TaxExemptionEnum } from '../../../db/Enums/property/property-sale/tax-exemption.enum';
+import { TaxExemption } from './tax-exemption';
+import { AssetSale } from '../../asset-sale';
+
+export class PropertySale extends AssetSale {
+  createdAt: Date;
+  updatedAt: Date;
+  share: PropertyShare;
+
+  @Type(() => Number)
+  holdingCosts: number;
+
+  @Type(() => Number)
+  structuralImprovementsWDV: number;
+
+  @Type(() => Number)
+  buildingAtCostClaimed: number;
+
+  @Type(() => Number)
+  price: number;
+
+  @Type(() => Number)
+  commission: number;
+
+  @Type(() => Number)
+  legalFees: number;
+
+  @Type(() => Number)
+  otherCost: number;
+
+  @Type(() => Date)
+  settlementDate: Date;
+
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => TaxExemption)
+  taxExemption: TaxExemption;
+
+  @Type(() => PropertySaleTaxExemptionMetaField)
+  taxExemptionMetaFields: PropertySaleTaxExemptionMetaField[];
+
+  get saleCostsTotalAmount(): number {
+    return this.commission + this.legalFees + this.otherCost;
+  }
+
+  /**
+   * CGT is not applicable for sales with "Principle place of residence" exemption type.
+   * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4644110466/Tax+Return+MyTax+-+Online+Form ("Capital gains or losses" section)
+   */
+  isCGTApplicable(): boolean {
+    return this.taxExemption?.id !== TaxExemptionEnum.PPR;
+  }
+
+  get netPrice(): number {
+    return this.price - this.saleCostsTotalAmount;
+  }
+}

package/projects/tt-core/src/lib/models/property/property-sale/tax-exemption-meta-field.ts

@@ -0,0 +1,4 @@
+import { TaxExemptionMetaField as BaseTaxExemptionMetaField } from '../../../db/Models/property/property-sale/tax-exemption-meta-field';
+
+export class TaxExemptionMetaField extends BaseTaxExemptionMetaField {
+}

package/projects/tt-core/src/lib/models/property/property-sale/tax-exemption.ts

@@ -0,0 +1,8 @@
+import { TaxExemption as BaseTaxExemption } from '../../../db/Models/property/property-sale/tax-exemption';
+import { TaxExemptionEnum } from '../../../db/Enums/property/property-sale/tax-exemption.enum';
+
+export class TaxExemption extends BaseTaxExemption {
+  isPartial(): boolean {
+    return [TaxExemptionEnum.INVESTMENT_TO_PPR, TaxExemptionEnum.PPR_TO_INVESTMENT].includes(this.id);
+  }
+}

package/projects/tt-core/src/lib/models/property/property-share.ts

@@ -0,0 +1,50 @@
+import { PropertyShare as PropertyShareBase } from '../../db/Models/property/property-share';
+import { PropertyShareStatusEnum } from '../../db/Enums/property/property-share-status.enum';
+import { Transform, Type } from 'class-transformer';
+import { User } from '../user';
+import { RegistrationInvite } from '../registration-invite/registration-invite';
+import { Property } from './property';
+
+export class PropertyShare extends PropertyShareBase {
+  @Type(() => Date)
+  fromDate: Date;
+
+  @Type(() => Date)
+  toDate: Date;
+
+  @Type(() => User)
+  user: User;
+
+  @Type(() => RegistrationInvite)
+  invite: RegistrationInvite;
+
+  @Type(() => Property)
+  property: Property;
+
+  @Transform(({ obj }) => obj.user ? obj.user.email : obj.invite.email)
+  email: string;
+
+  isAccepted(): boolean {
+    return this.status === PropertyShareStatusEnum.APPROVED;
+  }
+
+  isPending(): boolean {
+    return this.status === PropertyShareStatusEnum.PENDING;
+  }
+
+  isRejected(): boolean {
+    return this.status === PropertyShareStatusEnum.REJECTED;
+  }
+
+  get statusName(): string {
+    return PropertyShareStatusEnum[this.status]?.toLowerCase();
+  }
+
+  /**
+   * Return full user name if user is already registered.
+   * Otherwise - return first name from invitation
+   */
+  get userName(): string {
+    return this.user ? this.user.fullName : `${this.invite.firstName}`;
+  }
+}

package/projects/tt-core/src/lib/models/property/property-subscription.ts

@@ -0,0 +1,11 @@
+import { PropertySubscription as PropertySubscriptionBase } from '../../db/Models/property/property-subscription';
+import { Type } from 'class-transformer';
+import { User } from '../user';
+
+export class PropertySubscription extends PropertySubscriptionBase {
+  @Type(() => Date)
+  createdAt: Date;
+
+  @Type(() => User)
+  user: User;
+}

package/projects/tt-core/src/lib/models/property/property-valuation.ts

@@ -0,0 +1,27 @@
+import { PropertyValuation as PropertyValuationBase } from '../../db/Models/property/property-valuation';
+import { Transform, Type } from 'class-transformer';
+import { FinancialYear } from '../financial-year';
+import { PropertyCategoryMovement } from './property-category-movement';
+import { FolderDocument } from '../../db/Models';
+
+export class PropertyValuation extends PropertyValuationBase {
+  @Type(() => Date)
+  date = new Date();
+
+  @Transform(({ value }) => !!value)
+  isCorelogic: boolean;
+
+  @Type(() => FolderDocument)
+  document: FolderDocument;
+
+  @Type(() => PropertyCategoryMovement)
+  categoryMovement: PropertyCategoryMovement;
+
+  get financialYear(): number {
+    return new FinancialYear(this.date).year;
+  }
+
+  isCurrentYear(): boolean {
+    return this.financialYear === new FinancialYear(new Date()).year;
+  }
+}