taxtank 0.1.0

package/projects/tt-core/src/lib/models/holding/holding-trade.ts

@@ -0,0 +1,106 @@
+import { Expose, Transform, Type, plainToClass } from 'class-transformer';
+import { User } from '../user';
+import { HoldingType } from './holding-type';
+import { AppFile } from '../file';
+import { ObservableModel } from '../../db/Models';
+import { FinancialYear } from '../financial-year';
+import { HoldingTradeTypeEnum, HoldingTypeCategoryEnum } from '../../db/Enums';
+
+export class HoldingTrade extends ObservableModel {
+  static className = 'HoldingTrade';
+  isTaxFree = false;
+  quantity = 0;
+  ownershipPercent?: number;
+  price = 0;
+  fee: number;
+  type = HoldingTradeTypeEnum.BUY;
+  externalId?: number;
+
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => User)
+  user: User;
+
+  /**
+   * @TODO vik 4521 rename to holding
+   */
+  @Type(() => HoldingType)
+  holdingType: HoldingType;
+
+  @Type(() => AppFile)
+  file: AppFile;
+
+  isPurchase(): boolean {
+    return this.type === HoldingTradeTypeEnum.BUY;
+  }
+
+  get typeLabel(): string {
+    return this.isPurchase() ? 'Buy' : 'Sell';
+  }
+
+  get sign(): string {
+    return this.isPurchase() ? '' : '-';
+  }
+
+  /**
+   * Get total purchasing price
+   */
+  get total(): number {
+    return this.price * this.quantity;
+  }
+
+  /**
+   * @TODO vik remove
+   */
+  get marketValue(): number {
+    return this.quantity * this.holdingType.price;
+  }
+
+  /**
+   * Get percent difference between current and buy price
+   * @TODO vik/alex no need to pass holdingType, should come from backend
+   */
+  get growthCoefficient(): number {
+    return this.holdingType.price / this.price - 1;
+  }
+
+  heldMoreYear(): boolean {
+    const yearTime: number = 1000 * 60 * 60 * 24 * 365;
+
+    return (new FinancialYear().startDate.getTime() - this.date.getTime()) > yearTime;
+  }
+
+  /**
+   * @TODO Artem/Alex looks bad, come up with a better solution
+   * get current category, in holding we are interested in 3 main categories: stock/crypto/other
+   */
+  @Transform(({ obj }) => {
+    const holdingType: HoldingType = plainToClass(HoldingType, obj.holdingType)
+    if (holdingType) {
+      return holdingType.isOther() ? null : holdingType.category
+    }
+    if (obj.category) {
+      return [
+        HoldingTypeCategoryEnum.COLLECTIBLE,
+        HoldingTypeCategoryEnum.UNLISTED_STOCK,
+        HoldingTypeCategoryEnum.UNLISTED_UNIT,
+        HoldingTypeCategoryEnum.OTHER
+      ].includes(obj.category) ? null : obj.category;
+    }
+    return HoldingTypeCategoryEnum.STOCK;
+  }, { toClassOnly: true })
+  @Expose({ toClassOnly: true }) category: HoldingTypeCategoryEnum;
+
+  get categoryLabel(): string {
+    return this.holdingType.categoryLabel;
+  }
+
+  get name(): string {
+    return this.holdingType.name;
+  }
+
+  get ticker(): string {
+    return this.holdingType.ticker;
+  }
+}

package/projects/tt-core/src/lib/models/holding/holding-type-exchange.ts

@@ -0,0 +1,20 @@
+import { Type } from 'class-transformer';
+import { AbstractModel } from '../../db/Models';
+import { HoldingType } from './holding-type';
+
+/**
+ * @TODO rename 4521 to HoldingExchange when backend ready
+ */
+export class HoldingTypeExchange extends AbstractModel {
+  code?: string;
+  name?: string;
+  currency?: string;
+  closeTime?: string;
+  timezone?: string;
+
+  @Type(() => Date)
+  exchangeUpdatedAt?: Date;
+
+  @Type(() => HoldingType)
+  holdingTypes?: HoldingType[];
+}

package/projects/tt-core/src/lib/models/holding/holding-type.ts

@@ -0,0 +1,88 @@
+import { Type } from 'class-transformer';
+import { HoldingTypeCategoryEnum } from '../../db/Enums';
+import { User } from '../user';
+import { AbstractModel } from '../../db/Models';
+import { HoldingTypeExchange } from './holding-type-exchange';
+import { AppFile } from '../file';
+
+/**
+ * @TODO vik 4521 rename to Holding when backend ready
+ */
+export class HoldingType extends AbstractModel {
+  category?: HoldingTypeCategoryEnum;
+  name?: string;
+  ticker?: string;
+  price?: number;
+  openPrice?: number;
+  highPrice?: number;
+  lowPrice?: number;
+  volume?: number;
+  ema50d?: number;
+  ema200d?: number;
+  highPrice250d?: number;
+  lowPrice250d?: number;
+  avgVolume14d?: number;
+  avgVolume50d?: number;
+  avgVolume200d?: number;
+  marketCap?: number;
+  beta?: number;
+  adjustedPrice?: number;
+  isDelisted?: boolean;
+  peRatio?: number;
+  description?: string;
+  dividendPercent?: number;
+  @Type(() => AppFile)
+  file: AppFile;
+  @Type(() => Date)
+  lastUpdateDateOnExchange?: Date;
+  @Type(() => Date)
+  updatedAt?: Date;
+  @Type(() => User)
+  user?: User;
+  @Type(() => HoldingTypeExchange)
+  exchange?: HoldingTypeExchange;
+
+  /**
+   * @TODO Alex move to translation file
+   */
+  get categoryLabel(): string {
+    switch (this.category) {
+      case HoldingTypeCategoryEnum.STOCK:
+        return 'Shares';
+      case HoldingTypeCategoryEnum.CRYPTO:
+        return 'Crypto';
+      case HoldingTypeCategoryEnum.COLLECTIBLE:
+        return 'Collectibles';
+      case HoldingTypeCategoryEnum.UNLISTED_STOCK:
+        return 'Unlisted stock';
+      case HoldingTypeCategoryEnum.UNLISTED_UNIT:
+        return 'Unlisted unit';
+      default:
+        return 'Other';
+    }
+  }
+
+  isOther(): boolean {
+    return [
+      HoldingTypeCategoryEnum.COLLECTIBLE,
+      HoldingTypeCategoryEnum.UNLISTED_STOCK,
+      HoldingTypeCategoryEnum.UNLISTED_UNIT,
+      HoldingTypeCategoryEnum.OTHER
+    ].includes(this.category);
+  }
+
+  isShare(): boolean {
+    return this.category === HoldingTypeCategoryEnum.STOCK;
+  }
+
+  isCrypto(): boolean {
+    return this.category === HoldingTypeCategoryEnum.CRYPTO;
+  }
+
+  /**
+   * crypto include pairs in ticker, should be excluded beforeg display to user
+   */
+  getTicker(): string {
+    return this.isCrypto() ? this.ticker.slice(0, -4) : this.ticker;
+  }
+}

package/projects/tt-core/src/lib/models/holding/holding.ts

@@ -0,0 +1,75 @@
+import { AbstractModel } from '../../db/Models';
+import { HoldingTradeCollection } from '../../collections';
+import { HoldingType } from './holding-type';
+
+export class Holding extends AbstractModel {
+  type: HoldingType;
+  name: string;
+  ticker: string;
+  quantity: number;
+  avgPrice: number;
+  purchaseValue: number;
+  marketValue: number;
+  pnl: number;
+
+  constructor(private trades: HoldingTradeCollection, type: HoldingType) {
+    super();
+    this.type = type;
+    this.name = type.name;
+    this.ticker = type.ticker;
+    this.quantity = trades.getPosition();
+    this.purchaseValue = this.getPurchaseValue();
+    this.marketValue = this.getMarketValue();
+    this.avgPrice = this.getAvgPrice();
+    this.pnl = this.getPnl();
+  }
+
+  getPurchaseValue(): number {
+    let remainingQuantity = this.quantity;
+    let totalCost = 0;
+
+    this.trades.getPurchases().items.forEach(trade => {
+      if (remainingQuantity <= 0) {
+        return;
+      }
+
+      const applicableQuantity = Math.min(trade.quantity, remainingQuantity);
+      totalCost += applicableQuantity * trade.price + trade.fee;
+      remainingQuantity -= applicableQuantity;
+    });
+
+    return totalCost;
+  }
+
+  getMarketValue(): number {
+    return this.quantity * this.type.price;
+  }
+
+  getAvgPrice(): number {
+    return this.purchaseValue / this.quantity;
+  }
+
+  /**
+   * profit and loss
+   */
+  getPnl(): number {
+    return this.marketValue - this.purchaseValue;
+  }
+
+  getSharedMarketValue(): number {
+    let sharedMarketValue = 0;
+    this.trades.items.forEach(holding => {
+      sharedMarketValue += holding.ownershipPercent / 100 * holding.marketValue
+    });
+
+    return sharedMarketValue;
+  }
+
+  getGrowthCoefficient(): number {
+    return this.marketValue / this.purchaseValue - 1;
+  }
+
+  getUnrealisedProfit() {
+    return this.marketValue - this.purchaseValue;
+  }
+}

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

@@ -0,0 +1,8 @@
+export * from './holding-trade';
+export * from './holding-trade-report-item';
+export * from './holding-type';
+export * from './holding-sale';
+export * from './holding-type-exchange';
+export * from './holding-reinvest';
+export * from './holding-trade-import';
+export * from './holding';

package/projects/tt-core/src/lib/models/home-office/home-office-claim.interface.ts

@@ -0,0 +1,22 @@
+import { HomeOfficeClaimMethodEnum } from '../../db/Enums';
+import { User } from '../user';
+import { SoleBusiness } from '../sole';
+
+export interface HomeOfficeClaimInterface {
+  id: number;
+  user: User;
+  method: HomeOfficeClaimMethodEnum;
+  financialYear: number;
+  electricityAndGas?: number;
+  cleaning?: number;
+  internet?: number;
+  telephone?: number;
+  mobile?: number;
+  occupancyPercent?: number;
+  workPercent?: number;
+  homeArea?: number;
+  officeArea?: number;
+  dedicatedOffice?: boolean;
+  workUsage?: number;
+  business?: SoleBusiness;
+}

package/projects/tt-core/src/lib/models/home-office/home-office-claim.ts

@@ -0,0 +1,51 @@
+import { BusinessChartAccountsEnum, ChartAccountsListEnum, HomeOfficeClaimMethodEnum } from '../../db/Enums';
+import { User } from '../user';
+import { SoleBusiness } from '../sole';
+import { ObservableModel } from '../../db/Models';
+import { HomeOfficeClaimInterface } from './home-office-claim.interface';
+import { Type } from 'class-transformer';
+import { Dictionary } from '../dictionary';
+
+export class HomeOfficeClaim extends ObservableModel implements HomeOfficeClaimInterface {
+  static className = 'HomeOfficeClaim';
+  id: number;
+  @Type(() => User)
+  user: User;
+  method: HomeOfficeClaimMethodEnum;
+  financialYear: number;
+  electricityAndGas?: number = 0;
+  cleaning?: number = 0;
+  internet?: number = 0;
+  telephone?: number = 0;
+  mobile?: number = 0;
+  occupancyPercent?: number = 0;
+  homeArea?: number;
+  officeArea?: number;
+  dedicatedOffice?: boolean = true;
+  workUsage?: number;
+  @Type(() => SoleBusiness)
+  business?: SoleBusiness;
+
+  getChartAccountsList(): typeof ChartAccountsListEnum | typeof BusinessChartAccountsEnum {
+    return this.business ? BusinessChartAccountsEnum : ChartAccountsListEnum;
+  }
+
+  getChartAccountsClaims(): Dictionary<number> {
+    const claims = new Dictionary([]);
+    const list = this.getChartAccountsList();
+    claims.add(list.ELECTRICITY_AND_GAS, this.electricityAndGas)
+      .add(list.HOME_OFFICE_CLEANING, this.cleaning)
+      .add(list.INTERNET, this.internet)
+      .add(list.TELEPHONE, this.telephone)
+      .add(list.MOBILE_PHONE, this.mobile);
+
+    if (this.method === HomeOfficeClaimMethodEnum.OCCUPANCY) {
+      claims.add(BusinessChartAccountsEnum.HOME_OFFICE_RENT, this.occupancyPercent);
+      claims.add(BusinessChartAccountsEnum.HOME_OFFICE_LOAN, this.occupancyPercent);
+      claims.add(BusinessChartAccountsEnum.HOME_OFFICE_RATES, this.occupancyPercent);
+      claims.add(BusinessChartAccountsEnum.HOME_OFFICE_OTHER, this.occupancyPercent);
+    }
+
+    return claims;
+  }
+}

package/projects/tt-core/src/lib/models/home-office/home-office-log.interface.ts

@@ -0,0 +1,10 @@
+import { HomeOfficeClaim } from './home-office-claim';
+import { SoleBusiness } from '../sole';
+
+export interface HomeOfficeLogInterface {
+  claim: HomeOfficeClaim;
+  date: Date;
+  hours: number;
+  description: string;
+  business?: SoleBusiness;
+}

package/projects/tt-core/src/lib/models/home-office/home-office-log.ts

@@ -0,0 +1,20 @@
+import { HomeOfficeClaim } from './home-office-claim';
+import { SoleBusiness } from '../sole';
+import { ObservableModel } from '../../db/Models';
+import { HomeOfficeLogInterface } from './home-office-log.interface';
+import { Type } from 'class-transformer';
+
+export class HomeOfficeLog extends ObservableModel implements HomeOfficeLogInterface {
+  static className = 'HomeOfficeLog';
+  @Type(() => HomeOfficeClaim)
+  claim: HomeOfficeClaim;
+  date: Date;
+  hours: number;
+  description: string;
+  @Type(() => SoleBusiness)
+  business?: SoleBusiness;
+
+  get formattedDate(): string {
+    return this.formatDate(this.date);
+  }
+}

package/projects/tt-core/src/lib/models/home-office/index.ts

@@ -0,0 +1,4 @@
+export * from './home-office-claim.interface';
+export * from './home-office-claim';
+export * from './home-office-log.interface';
+export * from './home-office-log';

package/projects/tt-core/src/lib/models/income-position/income-position.ts

@@ -0,0 +1,13 @@
+import { Type } from 'class-transformer';
+
+// Todo extend from the base model when the backend is ready TT-555
+export class IncomePosition {
+  @Type(() => Date)
+    date: Date;
+  income: number;
+  expenses: number;
+  otherIncome: number;
+  otherDeductions: number;
+  incomeForecast: number;
+  incomeSourceForecast: number;
+}

package/projects/tt-core/src/lib/models/income-source/income-source-chart-data.ts

@@ -0,0 +1,57 @@
+import { TransactionCollection } from '../../collections/transaction/transaction.collection';
+import { IChartData } from '../../interfaces/chart-data.interface';
+import { FinancialYear } from '../financial-year/financial-year';
+import { MonthNameShortEnum } from '../financial-year/month-name-short.enum';
+import { MonthNumberEnum } from '../financial-year/month-number.enum';
+
+/**
+ * Income sources chart data
+ */
+export class IncomeSourceChartData {
+  private forecastedIncomeAmount: number;
+  private transactions: TransactionCollection;
+
+  constructor(
+    forecastedIncomeAmount: number,
+    transactions: TransactionCollection,
+  ) {
+    this.forecastedIncomeAmount = forecastedIncomeAmount;
+    this.transactions = transactions;
+  }
+
+  /**
+   * Get prepared data for income sources chart
+   */
+  get(): IChartData[] {
+    const chartData: IChartData[] = [{
+      id: 'actualIncome',
+      name: 'Actual Income',
+      data: [],
+      // display future actual incomes with dash line and past actual incomes with solid line
+      zones: [{
+        // line style after current month
+        value: new FinancialYear().getMonthDate(new Date().getMonth()).getTime(),
+        dashStyle: 'Solid'
+      }, {
+        // default line style
+        dashStyle: 'Dash'
+      }]
+    }, {
+      id: 'forecastedIncome',
+      name: 'Forecasted Income',
+      data: [],
+    }];
+
+    for (const key in MonthNameShortEnum) {
+      if (MonthNameShortEnum.hasOwnProperty(key)) {
+        // transaction collection for provided month
+        const monthTransactionCollection: TransactionCollection = this.transactions.getByMonth(+MonthNumberEnum[key]);
+
+        chartData[0].data.push([new FinancialYear().getMonthDate(+MonthNumberEnum[key]).getTime(), monthTransactionCollection.getGrossClaimAmountWithoutGst()]);
+        chartData[1].data.push([new FinancialYear().getMonthDate(+MonthNumberEnum[key]).getTime(), this.forecastedIncomeAmount / 12]);
+      }
+    }
+
+    return chartData;
+  }
+}

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

@@ -0,0 +1,34 @@
+import { IncomeSourceForecast as IncomeSourceForecastBase } from '../../db/Models/incomeSource/income-source-forecast';
+import { AnnualFrequencyEnum } from '../../db/Enums';
+import { IIncomeSourceForecast } from '../../interfaces';
+import { Type } from 'class-transformer';
+import { IncomeSourceType } from './income-source-type';
+import { IncomeSource } from './income-source';
+
+export class IncomeSourceForecast extends IncomeSourceForecastBase implements IIncomeSourceForecast {
+  @Type(() => IncomeSourceType)
+  incomeSourceType: IncomeSourceType;
+
+  paygIncome = 0;
+  frequency: AnnualFrequencyEnum = AnnualFrequencyEnum.ANNUAL;
+  isTaxFree = false;
+
+  @Type(() => IncomeSource)
+  incomeSource: IncomeSource;
+
+  /**
+   * Sometimes Income source has Salary & Income source forecasts,
+   * and we need these fields to work with Income source forecasts like with Salary Forecasts
+   */
+  get netPay(): number {
+    return this.amount;
+  }
+
+  get grossAmount(): number {
+    return this.amount + this.tax + this.taxInstalments + this.frankingCredits;
+  }
+
+  get monthlyAmount(): number {
+    return this.amount / 12;
+  }
+}

package/projects/tt-core/src/lib/models/income-source/income-source-type.ts

@@ -0,0 +1,24 @@
+import { IncomeSourceType as IncomeSourceTypeBase } from '../../db/Models/incomeSource/income-source-type';
+import { IncomeSourceTypeListWorkEnum, IncomeSourceTypeListOtherEnum, IncomeSourceTypeListSoleEnum, IncomeSourceTypeListHoldingEnum } from '../../db/Enums/income-source';
+
+export class IncomeSourceType extends IncomeSourceTypeBase {
+  isBonuses(): boolean {
+    return this.id === IncomeSourceTypeListWorkEnum.BONUSES;
+  }
+
+  isWork(): boolean {
+    return !!IncomeSourceTypeListWorkEnum[this.id];
+  }
+
+  isOther(): boolean {
+    return !!IncomeSourceTypeListOtherEnum[this.id];
+  }
+
+  isHolding(): boolean {
+    return !!IncomeSourceTypeListHoldingEnum[this.id];
+  }
+
+  isSole(): boolean {
+    return !!IncomeSourceTypeListSoleEnum[this.id];
+  }
+}

package/projects/tt-core/src/lib/models/income-source/income-source.ts

@@ -0,0 +1,64 @@
+import { IncomeSource as IncomeSourceBase } from '../../db/Models/incomeSource/income-source';
+import { IncomeSourceTypeEnum } from '../../db/Enums/income-source';
+import { IIncomeSourceForecast } from '../../interfaces';
+import { Type } from 'class-transformer';
+import { SalaryForecast } from './salary-forecast';
+import { SoleForecast } from './sole-forecast';
+import { IncomeSourceForecast } from './income-source-forecast';
+import { FinancialYear } from '../financial-year';
+
+export class IncomeSource extends IncomeSourceBase {
+  @Type(() => SalaryForecast)
+  salaryForecasts: SalaryForecast[];
+
+  @Type(() => SoleForecast)
+  soleForecasts: SoleForecast[];
+
+  @Type(() => IncomeSourceForecast)
+  incomeSourceForecasts: IncomeSourceForecast[];
+
+  @Type(() => Date)
+  dateFrom: Date;
+
+  @Type(() => Date)
+  dateTo: Date;
+
+  isSoleIncome(): boolean {
+    return this.type === IncomeSourceTypeEnum.SOLE;
+  }
+
+  isWorkIncome(): boolean {
+    return this.type === IncomeSourceTypeEnum.WORK;
+  }
+
+  isOtherIncome(): boolean {
+    return this.type === IncomeSourceTypeEnum.OTHER;
+  }
+
+  isHolding(): boolean {
+    return this.type === IncomeSourceTypeEnum.HOLDING;
+  }
+
+  /**
+   * Get salary and other income forecasts
+   */
+  get forecasts(): IIncomeSourceForecast[] {
+    return [...this.salaryForecasts, ...this.incomeSourceForecasts, ...this.soleForecasts];
+  }
+
+  /**
+   * Get actual (1st from the list) forecast
+   */
+  get actualForecast(): IIncomeSourceForecast {
+    return this.forecasts[0];
+  }
+
+  /**
+   * Check if user was working in month taken by the index
+   * @param monthIndex by which month should be taken
+   */
+  isWorkedInMonth(monthIndex: number): boolean {
+    const monthDate: Date = new FinancialYear().getMonthDate(monthIndex);
+    return (!this.dateFrom || monthDate >= this.dateFrom) && (!this.dateTo || monthDate < this.dateTo);
+  }
+}

package/projects/tt-core/src/lib/models/income-source/index.ts

@@ -0,0 +1,6 @@
+export * from './income-source';
+export * from './income-source-chart-data';
+export * from './income-source-forecast';
+export * from './income-source-type';
+export * from './salary-forecast';
+export * from './sole-forecast';

package/projects/tt-core/src/lib/models/income-source/salary-forecast.ts

@@ -0,0 +1,38 @@
+import { SalaryForecast as SalaryForecastBase } from '../../db/Models/incomeSource/salary-forecast';
+import { IncomeSource } from './income-source';
+import { IIncomeSourceForecast } from '../../interfaces';
+import { Type } from 'class-transformer';
+import { AnnualFrequencyEnum } from '../../db/Enums';
+import { FinancialYear } from '../financial-year';
+
+export class SalaryForecast extends SalaryForecastBase implements IIncomeSourceForecast {
+  @Type(() => Number)
+  tax: number;
+
+  @Type(() => Number)
+  netPay: number;
+
+  get grossAmount(): number {
+    return this.netPay + this.tax;
+  }
+
+  @Type(() => IncomeSource)
+  incomeSource: IncomeSource;
+
+  get taxWithheld(): number {
+    return this.grossAmount - this.netPay;
+  }
+
+  get monthlyAmount(): number {
+    switch (this.frequency) {
+      case AnnualFrequencyEnum.ANNUAL:
+        return this.netPay / FinancialYear.monthsInYear;
+      case AnnualFrequencyEnum.FORTNIGHTLY:
+        return this.netPay * FinancialYear.weeksInYear / FinancialYear.monthsInYear / 2;
+      case AnnualFrequencyEnum.WEEKLY:
+        return this.netPay * FinancialYear.weeksInYear / FinancialYear.monthsInYear;
+      default:
+        return this.netPay;
+    }
+  }
+}

package/projects/tt-core/src/lib/models/income-source/sole-forecast.ts

@@ -0,0 +1,14 @@
+import { IncomeSource } from './income-source';
+import { SoleForecast as SoleForecastBase } from '../../db/Models/sole/sole-forecast';
+import { Type } from 'class-transformer';
+import { IIncomeSourceForecast } from '../../interfaces';
+import { User } from '../user';
+
+export class SoleForecast extends SoleForecastBase  implements IIncomeSourceForecast {
+  @Type(() => IncomeSource)
+  incomeSource: IncomeSource;
+
+  get netPay(): number {
+    return this.amount;
+  }
+}