taxtank-core 0.0.1 → 0.1.1

package/src/lib/models/logbook/default-vehicle-expense.ts

@@ -0,0 +1,20 @@
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';
+import { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';
+import { FinancialYear } from '../financial-year/financial-year';
+
+/**
+ * Default vehicle transaction object,
+ * which could be used to create transaction with 'Klms travelled for work' chart accounts category
+ */
+export const DEFAULT_VEHICLE_EXPENSE: object = {
+  source: TransactionSourceEnum.CASH,
+  tankType: TankTypeEnum.WORK,
+  type: TransactionTypeEnum.DEBIT,
+  taxWithheld: 0,
+  description: 'Klm’s method',
+  date: new Date(`${new FinancialYear().year}-06-30`),
+  chartAccounts: {id: ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK},
+  claimPercent: 100
+};

package/src/lib/models/logbook/logbook-period.ts

@@ -0,0 +1,12 @@
+import { Type } from 'class-transformer';
+
+export class LogbookPeriod {
+  @Type(() => Date)
+  from: Date;
+
+  @Type(() => Date)
+  to: Date;
+
+  kilometers: number;
+  workUsage: number;
+}

package/src/lib/models/logbook/logbook-purpose-options.const.ts

@@ -0,0 +1,6 @@
+import { VehicleLogbookPurposeEnum } from '../../db/Enums/vehicle-logbook-purpose.enum';
+
+export const WORK_TANK_LOGBOOK_PURPOSE_OPTIONS: {[key: string]: VehicleLogbookPurposeEnum | string}[] = [
+  { label: 'Business', value: VehicleLogbookPurposeEnum.BUSINESS },
+  { label: 'Personal', value: VehicleLogbookPurposeEnum.PERSONAL }
+];

package/src/lib/models/logbook/vehicle-claim.ts

@@ -0,0 +1,27 @@
+import { VehicleClaim as VehicleClaimBase } from '../../db/Models/vehicle-claim';
+import { VehicleClaimMethodEnum } from '../../db/Enums/vehicle-claim-method.enum';
+import { FinancialYear } from '../financial-year/financial-year';
+
+const WEEKS_IN_YEAR = 52;
+
+export class VehicleClaim extends VehicleClaimBase {
+  // limit for kms claim method
+  kmsLimit: number = 5000;
+  financialYear: number = new FinancialYear().year;
+
+  method: VehicleClaimMethodEnum = VehicleClaimMethodEnum.KMS;
+  kilometers: number = 0;
+  workUsage: number = 0;
+  isManual: boolean = true;
+
+  /**
+   * get amount of kilometres per week
+   */
+  get averageWeeklyTraveledKms(): number {
+    return this.kilometers / WEEKS_IN_YEAR;
+  }
+
+  get isLogbookMethod(): boolean {
+    return this.method === VehicleClaimMethodEnum.LOGBOOK;
+  }
+}

package/src/lib/models/logbook/vehicle-logbook.ts

@@ -0,0 +1,16 @@
+import { VehicleLogbook as VehicleLogbookBase } from '../../db/Models/vehicle-logbook';
+import { VehicleLogbookPurposeEnum } from '../../db/Enums/vehicle-logbook-purpose.enum';
+import { Type } from 'class-transformer';
+
+export class VehicleLogbook extends VehicleLogbookBase {
+  @Type(() => Date)
+  date: Date;
+
+  get kilometres(): number {
+    return this.odometerEnd - this.odometerStart;
+  }
+
+  get isWork(): boolean {
+    return this.purpose === VehicleLogbookPurposeEnum.BUSINESS;
+  }
+}

package/src/lib/models/logbook/vehicle.ts

@@ -0,0 +1,46 @@
+import { Vehicle as VehicleBase } from '../../db/Models/vehicle';
+import { VehicleLogbookPurposeEnum } from '../../db/Enums/vehicle-logbook-purpose.enum';
+import { VehicleLogbook } from './vehicle-logbook';
+import { Type } from 'class-transformer';
+
+export class Vehicle extends VehicleBase {
+  @Type(() => VehicleLogbook)
+  logbook: VehicleLogbook[];
+
+  get workKilometersPercentage(): number {
+    return this.workKilometres / this.totalKilometres * 100;
+  }
+
+  get totalKilometres(): number {
+    let kilometers: number = 0;
+
+    this.logbook.forEach((lb: VehicleLogbook) => {
+      kilometers += lb.kilometres;
+    });
+
+    return kilometers;
+  }
+
+  get workKilometres(): number {
+    let kilometers: number = 0;
+
+    this.logbook.forEach((lb: VehicleLogbook) => {
+      if (lb.purpose === VehicleLogbookPurposeEnum.BUSINESS) {
+        kilometers += lb.kilometres;
+      }
+    });
+
+    return kilometers;
+  }
+
+  get personalKilometres(): number {
+    return this.totalKilometres - this.workKilometres;
+  }
+
+  get lastLogbook(): VehicleLogbook | {odometerEnd: number} {
+    if (!this.logbook.length) {
+      return {odometerEnd: 0};
+    }
+    return this.logbook.slice(-1)[0];
+  }
+}

package/src/lib/models/notification/notification-event-types.const.ts

@@ -0,0 +1,43 @@
+import { UserEventTypeTypeEnum } from '../../db/Enums/user-event-type-type.enum';
+
+/**
+ * Notification events grouped by types
+ */
+export const NOTIFICATION_EVENT_TYPES: {[key: string]: UserEventTypeTypeEnum[]} = {
+  // events from employees to clients
+  employeeInvite: [
+    UserEventTypeTypeEnum.EMPLOYEE_INVITE_TO_REGISTER_ACCEPTED,
+    UserEventTypeTypeEnum.EMPLOYEE_INVITE_TO_JOIN_ACCEPTED,
+    UserEventTypeTypeEnum.EMPLOYEE_INVITE_TO_JOIN_REJECTED,
+    UserEventTypeTypeEnum.EMPLOYEE_INVITE_TO_REGISTER,
+    UserEventTypeTypeEnum.CLIENT_INVITE_TO_JOIN,
+  ],
+  // events from clients to employee
+  employeeInviteFromClient: [
+    UserEventTypeTypeEnum.EMPLOYEE_INVITE_TO_JOIN,
+  ],
+  bankConnection: [
+    UserEventTypeTypeEnum.BASIQ_NEW_ACCOUNTS,
+    UserEventTypeTypeEnum.BASIQ_FIRST_IMPORT_COMPLETE,
+    UserEventTypeTypeEnum.BASIQ_AUTHORIZATION_FAIL
+  ],
+  clientInvite: [
+    UserEventTypeTypeEnum.CLIENT_INVITE_TO_JOIN_ACCEPTED,
+    UserEventTypeTypeEnum.CLIENT_INVITE_TO_JOIN_REJECTED,
+    UserEventTypeTypeEnum.CLIENT_INVITE_TO_REGISTER
+  ],
+  clientMovement: [
+    UserEventTypeTypeEnum.CLIENT_LEFT_FIRM,
+    UserEventTypeTypeEnum.EMPLOYEE_LOST_CLIENT,
+    UserEventTypeTypeEnum.EMPLOYEE_RECEIVED_CLIENT
+  ],
+  propertyOwner: [
+    UserEventTypeTypeEnum.CO_OWNER_INVITE_SEND,
+    UserEventTypeTypeEnum.CO_OWNER_INVITE_ACCEPT,
+    UserEventTypeTypeEnum.CO_OWNER_INVITE_REJECT,
+    UserEventTypeTypeEnum.CO_OWNER_REGISTER,
+    UserEventTypeTypeEnum.CO_OWNER_CHANGES_OFFER,
+    UserEventTypeTypeEnum.CO_OWNER_CHANGES_ACCEPT,
+    UserEventTypeTypeEnum.CO_OWNER_CHANGES_REJECT
+  ]
+};

package/src/lib/models/notification/notification.ts

@@ -0,0 +1,66 @@
+import { ServiceNotification as ServiceNotificationBase } from '../../db/Models/service-notification';
+import { UserEventTypeTypeEnum } from '../../db/Enums/user-event-type-type.enum';
+import { Expose, Transform, Type } from 'class-transformer';
+import { User } from '../user/user';
+import { NOTIFICATION_EVENT_TYPES } from './notification-event-types.const';
+
+export class Notification extends ServiceNotificationBase {
+  @Type(() => User)
+  sender: User;
+
+  // notification redirection link
+  @Expose({toClassOnly: true})
+  @Transform(({obj}) => {
+    switch (true) {
+      case NOTIFICATION_EVENT_TYPES.employeeInvite.includes(obj.eventType):
+        return '/client/users/firms';
+      case NOTIFICATION_EVENT_TYPES.bankConnection.includes(obj.eventType):
+        return '/client/bank-feeds';
+      case NOTIFICATION_EVENT_TYPES.clientInvite.includes(obj.eventType):
+        return '/client/users/invitations';
+      case NOTIFICATION_EVENT_TYPES.propertyOwner.includes(obj.eventType):
+        return '/client/users/co-owners';
+      case NOTIFICATION_EVENT_TYPES.employeeInviteFromClient.includes(obj.eventType):
+        return '/firm/clients/invites';
+      default:
+        return '';
+    }
+  })
+  redirectionLink: string;
+
+  get eventType(): UserEventTypeTypeEnum {
+    return this.userEvent.userEventType.type;
+  }
+
+  /**
+   * Set redirection link based on current event type
+   */
+  private setRedirectionLink(): void {
+    switch (true) {
+      case NOTIFICATION_EVENT_TYPES.employeeInvite.includes(this.eventType):
+        this.redirectionLink = '/client/users/firms';
+        break;
+      case NOTIFICATION_EVENT_TYPES.bankConnection.includes(this.eventType):
+        this.redirectionLink = '/client/bank-feeds';
+        break;
+      case NOTIFICATION_EVENT_TYPES.clientInvite.includes(this.eventType):
+        this.redirectionLink = '/client/users/invitations';
+        break;
+      case NOTIFICATION_EVENT_TYPES.propertyOwner.includes(this.eventType):
+        this.redirectionLink = '/client/users/co-owners';
+        break;
+      case NOTIFICATION_EVENT_TYPES.employeeInviteFromClient.includes(this.eventType):
+        this.redirectionLink = '/firm/clients/invites';
+        break;
+      default:
+        this.redirectionLink = '';
+    }
+  }
+
+  /**
+   * Check if notification is from user or not
+   */
+  isFromUser(): boolean {
+    return !!this.sender;
+  }
+}

package/src/lib/models/phone/phone.ts

@@ -0,0 +1,10 @@
+import { Phone as PhoneBase } from '../../db/Models/phone';
+import { PhoneTypeEnum } from '../../db/Enums/phone-type.enum';
+
+export class Phone extends PhoneBase {
+  type: PhoneTypeEnum = PhoneTypeEnum.MOBILE;
+
+  toString(): string {
+    return `+${this.country.callingCode} ${this.number}`;
+  }
+}

package/src/lib/models/property/calculation-form-item.ts

@@ -0,0 +1,24 @@
+import { ValidatorFn } from '@angular/forms';
+import { Expose, Transform } from 'class-transformer';
+import { CalculationFormTypeEnum } from './calculation-form-type.enum';
+
+/**
+ * Fields to implement custom calculation form
+ */
+export class CalculationFormItem {
+  name: string;
+  value: number | boolean;
+  // label for form control
+  label: string;
+  // type of control (input, select, e.t.c)
+  type: CalculationFormTypeEnum = CalculationFormTypeEnum.SELECT;
+  // array of dependent fields for control
+  dependentFields?: string[];
+  // flag to check if field is disabled
+  isDisabled: boolean;
+
+  @Transform(({obj}) => obj.type === CalculationFormTypeEnum.SELECT)
+  @Expose() isSelect: boolean;
+
+  validators?: ValidatorFn[];
+}

package/src/lib/models/property/calculation-form-type.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Calculation form control types
+ */
+export enum CalculationFormTypeEnum {
+  INPUT = 1,
+  SELECT = 2,
+}

package/src/lib/models/property/capital-costs-itmes.const.ts

@@ -0,0 +1,57 @@
+import { Validators } from '@angular/forms';
+import { plainToClass } from 'class-transformer';
+import { CalculationFormItem } from './calculation-form-item';
+import { CalculationFormTypeEnum } from './calculation-form-type.enum';
+
+export const CAPITAL_COSTS_ITEMS: CalculationFormItem[] = [
+  plainToClass(CalculationFormItem, {
+    name: 'rentingWholeProperty',
+    value: null,
+    label: 'Are you renting out the whole property?',
+    type: CalculationFormTypeEnum.SELECT,
+    dependentFields: ['howBigIsProperty', 'howBigIsLetArea', 'howBigIsCommonAreas'],
+    isDisabled: false,
+    validators: [Validators.required]
+  }),
+  plainToClass(CalculationFormItem, {
+    name: 'rentingWholeYear',
+    value: null,
+    label: 'Are you renting out for the whole year?',
+    type: CalculationFormTypeEnum.SELECT,
+    dependentFields: ['howManyDays'],
+    isDisabled: false,
+    validators: [Validators.required]
+  }),
+  plainToClass(CalculationFormItem, {
+    name: 'howBigIsProperty',
+    value: null,
+    label: 'How big is the property?',
+    type: CalculationFormTypeEnum.INPUT,
+    isDisabled: true,
+    validators: [Validators.required, Validators.min(1)]
+  }),
+  plainToClass(CalculationFormItem, {
+    name: 'howBigIsLetArea',
+    value: null,
+    label: 'How big is the let area?',
+    type: CalculationFormTypeEnum.INPUT,
+    isDisabled: true,
+    validators: [Validators.required, Validators.min(1)]
+  }),
+  plainToClass(CalculationFormItem, {
+    name: 'howBigIsCommonAreas',
+    value: null,
+    label: 'How big are the common areas?',
+    type: CalculationFormTypeEnum.INPUT,
+    isDisabled: true,
+    validators: [Validators.required, Validators.min(1)]
+  }),
+  plainToClass(CalculationFormItem, {
+    name: 'howManyDays',
+    value: null,
+    label: 'How many days of the year is the property available for rent?',
+    type: CalculationFormTypeEnum.INPUT,
+    isDisabled: true,
+    validators: [Validators.required, Validators.min(1)]
+  }),
+];

package/src/lib/models/property/corelogic-suggestion.ts

@@ -0,0 +1,18 @@
+/**
+ * https://api-uat.corelogic.asia/property/au/v2/suggest.json
+ * address suggestion from corelogic service
+ */
+export class CorelogicSuggestion {
+  councilAreaId: number;
+  countryId: number;
+  isActiveProperty: boolean;
+  isBodyCorporate: boolean;
+  isUnit: boolean;
+  localityId: number;
+  postcodeId: number;
+  propertyId: number;
+  stateId: number;
+  streetId: number;
+  suggestion: string;
+  suggestionType: string;
+}

package/src/lib/models/property/ownership-filter-options.enum.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum with properties ownership filter options
+ */
+export enum OwnershipFilterOptionsEnum {
+  ALL_PROPERTIES = 1,
+  OWN_PROPERTIES = 2,
+  SHARED_PROPERTIES = 3
+}

package/src/lib/models/property/property-capital-cost.ts

@@ -0,0 +1,4 @@
+import { PropertyCapitalCost as PropertyCapitalCostBase } from '../../db/Models/property-capital-cost';
+
+export class PropertyCapitalCost extends PropertyCapitalCostBase {
+}

package/src/lib/models/property/property-category-movement.ts

@@ -0,0 +1,18 @@
+import { PropertyCategoryMovement as PropertyCategoryMovementBase } from '../../db/Models/property-category-movement';
+import { Type } from 'class-transformer';
+import { PropertyValuation } from './property-valuation';
+import { PropertyCategory } from './property-category';
+
+export class PropertyCategoryMovement extends PropertyCategoryMovementBase {
+  @Type(() => PropertyValuation)
+  valuation: PropertyValuation;
+
+  @Type(() => PropertyCategory)
+  propertyCategory: PropertyCategory;
+
+  @Type(() => Date)
+  fromDate: Date;
+
+  @Type(() => Date)
+  toDate: Date;
+}

package/src/lib/models/property/property-category.ts

@@ -0,0 +1,9 @@
+import { PropertyCategory as PropertyCategoryBase } from '../../db/Models/property-category';
+
+export class PropertyCategory extends PropertyCategoryBase {
+
+  // @Todo check if category is Owner Occupied. If will be needed to check more categories - move the checking to the backend
+  isOwnerOccupied(): boolean {
+    return this.name === 'Owner Occupied';
+  }
+}

package/src/lib/models/property/property-document.ts

@@ -0,0 +1,21 @@
+import { PropertyDocument as PropertyDocumentBase } from '../../db/Models/property-document';
+import { IAsset } from '../../interfaces/asset.interface';
+import { IDocument } from '../../interfaces/document.interface';
+import { AssetTypeEnum } from '../../interfaces/asset-type.enum';
+import { AssetEntityTypeEnum } from '../../interfaces/asset-entity-type.enum';
+import { Documentable } from '../../interfaces/documentable.interface';
+import { Property } from './property';
+
+export class PropertyDocument extends PropertyDocumentBase implements IAsset, IDocument {
+  type: AssetTypeEnum = AssetTypeEnum.DOCUMENTS;
+  entityType: AssetEntityTypeEnum = AssetEntityTypeEnum.PROPERTIES;
+  property: Property;
+
+  getApiUrlPrefix(): string {
+    return '';
+  }
+
+  getEntity(): Documentable {
+    return this.property;
+  }
+}

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

@@ -0,0 +1,188 @@
+import first from 'lodash/first';
+import { PropertyEquityChartItem } from './property-equity-chart-item';
+import { PropertyCollection } from '../../collections/property.collection';
+import { BankAccountCollection } from '../../collections/bank-account.collection';
+import { LoanCollection } from '../../collections/loan.collection';
+import { FinancialYear } from '../financial-year/financial-year';
+import { PropertyEquityChartTypeEnum } from './property-equity-chart-type.enum';
+import { Property } from './property';
+import { BankAccount } from '../bank/bank-account';
+
+// count of years for future values
+const FORECAST_YEARS: number = 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;
+  // list of properties this collection based on
+  private properties: PropertyCollection;
+  private bankAccounts: BankAccountCollection;
+  private loans: LoanCollection;
+
+  constructor(
+    properties: PropertyCollection,
+    bankAccounts: BankAccountCollection,
+    loans: LoanCollection,
+    private registerDate: Date
+  ) {
+    this.properties = properties;
+    this.bankAccounts = bankAccounts.getLoanAccounts();
+    this.loans = loans;
+    this.currentYear = new FinancialYear(new Date()).year;
+    this.initItems();
+    this.buildHistoryItems();
+    this.buildActualItem();
+    this.buildForecastedItems();
+    this.checkZeroLoanBalance();
+  }
+
+  /**
+   * 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 => {
+        return sum + this.getMarketValueForPropertyByYear(property, item.year);
+      }, 0);
+
+      item.loanBalance = Math.abs(this.properties.items.reduce((sum: number, property: Property): number => {
+        return sum + this.getLoanBalanceForPropertyByYear(property, item.year);
+      }, 0));
+    });
+  }
+
+  /**
+   * 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.properties.marketValue;
+    item.loanBalance = this.properties.items.reduce((sum: number, property: Property): number => {
+      return sum + Math.abs(this.bankAccounts.getPropertyBalanceAmount(property.id));
+    }, 0);
+  }
+
+  /**
+   * 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) => {
+      let forecastedMarketValue: number = (property.growthPercent / 100) * property.marketValue + property.marketValue;
+
+      // calculate future values for each future year for current handling property
+      this.list
+        .filter((item: PropertyEquityChartItem) => item.year > this.currentYear)
+        .forEach((item: PropertyEquityChartItem) => {
+          const propertyBankAccounts: BankAccountCollection = this.bankAccounts.getByPropertyId(property.id);
+          // increase loan balance amount for handling equity position item
+          item.loanBalance += this.getLoanBalanceByYear(property, item.year, propertyBankAccounts, this.loans.getByBankAccountsIds(propertyBankAccounts.getIds()));
+
+          // 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
+   * @param bankAccounts List of bank accounts
+   * @param loans List of loans
+   * @private
+   */
+  private getLoanBalanceByYear(property: Property, year: number, bankAccounts: BankAccountCollection, loans: LoanCollection): number {
+    return bankAccounts.items.reduce((totalSum: number, bankAccount: BankAccount): number => {
+      return totalSum + (bankAccount.getPropertyPercentage(property.id) * (loans.getByBankAccountId(bankAccount.id)?.getLastPaymentByYear(year)?.totalOwed || 0));
+    }, 0);
+  }
+
+  getMarketValueForPropertyByYear(property: Property, year: number): number {
+    if (new FinancialYear(property.purchaseDate).year > year) {
+      return 0;
+    }
+
+    return (property.getForecastByYear(year) || first(property.forecasts)).marketValue;
+  }
+
+  getLoanBalanceForPropertyByYear(property: Property, year: number): number {
+    if (new FinancialYear(property.purchaseDate).year > year) {
+      return 0;
+    }
+
+    return property.getForecastByYear(year)?.loanBalance || this.bankAccounts.getPropertyBalanceAmount(property.id);
+  }
+
+  /**
+   * 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;
+      }
+    });
+  }
+}

package/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/src/lib/models/property/property-equity-chart-type.enum.ts

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