taxtank 0.1.0

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

@@ -0,0 +1,17 @@
+import { File } from '../../db/Models';
+
+/**
+ * The model renamed for more comfortable work because File already exist in JS
+ * @TODO Alex: consider a better name like document
+ */
+export class AppFile extends File {
+  static imageMimeTypes: string[] = ['image/jpg', 'image/jpeg', 'image/png', 'image/tiff', 'image/bmp'];
+
+  isImage(): boolean {
+    return AppFile.imageMimeTypes.includes(this.mimeType);
+  }
+
+  get month(): string {
+    return this.formatDate(this.createdAt, 'MMM yyyy');
+  }
+}

package/projects/tt-core/src/lib/models/file/icons-file.enum.ts

@@ -0,0 +1,5 @@
+export enum IconsFileEnum {
+  JPG = 'icon-image-jpg',
+  PDF = 'icon-doc-pdf',
+  DOC = 'icon-doc'
+}

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

@@ -0,0 +1 @@
+export * from './file';

package/projects/tt-core/src/lib/models/financial-goal/financial-goal-status.enum.ts

@@ -0,0 +1,5 @@
+export enum FinancialGoalStatusEnum {
+  ACTIVE = 1,
+  PAUSE = 2,
+  COMPLETE = 3,
+}

package/projects/tt-core/src/lib/models/financial-goal/financial-goal-type.enum.ts

@@ -0,0 +1,6 @@
+export enum FinancialGoalTypeEnum {
+  DEBIT = 1,
+  CREDIT = 2,
+  PROPERTY_EQUITY = 3,
+  PROPERTY_LVR = 4,
+}

package/projects/tt-core/src/lib/models/financial-goal/financial-goal.interface.ts

@@ -0,0 +1,25 @@
+import { BankAccount } from '../bank';
+import { AppFile } from '../file';
+import { Property } from '../property';
+import { FinancialGoalStatusEnum } from './financial-goal-status.enum';
+import { FinancialGoalTypeEnum } from './financial-goal-type.enum';
+import { DailyFrequencyEnum } from '../../db/Enums';
+
+export interface FinancialGoalInterface {
+  name: string;
+  description: string;
+  type: FinancialGoalTypeEnum;
+  status: FinancialGoalStatusEnum;
+  initialValue: number;
+  currentValue: number;
+  finalValue: number;
+  targetValue: number;
+  startDate: Date;
+  endDate: Date;
+  bankAccount : BankAccount;
+  paymentFrequency: DailyFrequencyEnum;
+  paymentAmount: number;
+  inCalendar: boolean;
+  properties?: Property[];
+  file: AppFile;
+}

package/projects/tt-core/src/lib/models/financial-goal/financial-goal.ts

@@ -0,0 +1,195 @@
+import { FinancialGoalInterface } from './financial-goal.interface';
+import { BankAccount } from '../bank';
+import { AppFile } from '../file';
+import { Type, plainToClass } from 'class-transformer';
+import { ObservableModel } from '../../db/Models';
+import { FinancialGoalTypeEnum } from './financial-goal-type.enum';
+import { FinancialGoalStatusEnum } from './financial-goal-status.enum';
+import { DailyFrequencyEnum } from '../../db/Enums';
+import { Property } from '../property';
+import moment from 'moment';
+import { Badge } from '../badge/badge';
+import { BadgeColorEnum } from '../badge/badge-color.enum';
+import round from 'lodash/round';
+import { MoneyCalendarEvent } from '../fullcalendar';
+import { recurringDates } from '../../functions/date';
+import { CalendarEventProvider } from '../../interfaces';
+import { CurrencyPipe } from '@angular/common';
+import { MoneyCalendarEventCollection } from '../../collections';
+
+export class FinancialGoal extends ObservableModel implements FinancialGoalInterface, CalendarEventProvider {
+  static className = 'FinancialGoal';
+  name: string;
+  description: string;
+  type: FinancialGoalTypeEnum;
+  status: FinancialGoalStatusEnum;
+  initialValue: number;
+  currentValue: number;
+  finalValue: number;
+  targetValue: number;
+  @Type(() => Date)
+  startDate = moment().startOf('day').toDate();
+  @Type(() => Date)
+  endDate: Date;
+  @Type(() => BankAccount)
+  bankAccount: BankAccount;
+  paymentFrequency: DailyFrequencyEnum;
+  paymentAmount: number;
+  inCalendar = false;
+  @Type(() => Property)
+  properties: Property[] = [];
+  @Type(() => AppFile)
+  file: AppFile;
+
+  isCompleted(): boolean {
+    return this.status === FinancialGoalStatusEnum.COMPLETE;
+  }
+
+  isAchieved(): boolean {
+    return this.progress >= this.target;
+  }
+
+  isPropertyType(): boolean {
+    return [FinancialGoalTypeEnum.PROPERTY_EQUITY, FinancialGoalTypeEnum.PROPERTY_LVR].includes(this.type);
+  }
+
+  isLvr(): boolean {
+    return this.type === FinancialGoalTypeEnum.PROPERTY_LVR;
+  }
+
+  /**
+   * today's forecasted progress
+   */
+  get forecast(): number {
+    return this.paymentAmount * this.calculatePaymentsByDate(new Date());
+  }
+
+  get variancePercent(): number {
+    return round(this.progress / this.forecast, 2);
+  }
+
+  get variance(): number {
+    return round(this.progress - this.forecast);
+  }
+
+  /**
+   *  How much user saved so far.
+   */
+  get progress(): number {
+    let progress = this.currentValue - this.initialValue;
+    if (this.isLvr()) {
+      progress = this.initialValue - this.currentValue;
+    }
+
+    return round(progress, 2);
+  }
+
+  /**
+   * How much is left to reach the goal from the current balance.
+   */
+  get remaining(): number {
+    if (this.isCompleted() || this.isAchieved()) {
+      return 0;
+    }
+
+    return round(this.target - this.progress, 2);
+  }
+
+  /**
+   * How much needs to deposit to achieve the goal from the start
+   */
+  get target(): number {
+    let target = this.targetValue - this.initialValue;
+    if (this.isLvr()) {
+      target = this.initialValue - this.targetValue;
+    }
+
+    return round(target, 2);
+  }
+
+  /**
+   *  How much of the goal is reached in percents.
+   */
+  get progressPercent(): number {
+    return round(this.progress / this.target, 2);
+  }
+
+  getBadge(): Badge {
+    const variance = new CurrencyPipe('en-AU').transform(this.variance, 'USD', 'symbol', '1.0-2');
+
+    if (this.isPropertyType() && this.status === FinancialGoalStatusEnum.ACTIVE && this.progress > 0 && !this.isAchieved()) {
+      return new Badge('Active', BadgeColorEnum.GREEN);
+    }
+
+    switch (true) {
+      case this.status === FinancialGoalStatusEnum.PAUSE:
+        return new Badge('Paused', BadgeColorEnum.GOLD);
+      case this.status === FinancialGoalStatusEnum.COMPLETE:
+        return new Badge('Completed', BadgeColorEnum.GREEN);
+      case this.isAchieved():
+        return new Badge('Achieved', BadgeColorEnum.GREEN);
+      case this.forecast === 0:
+        return this.progress ? new Badge(`Ahead ${this.variancePercent}`, BadgeColorEnum.GREEN) : new Badge(`On track`, BadgeColorEnum.PRIMARY);
+      case this.variancePercent >= 1.05:
+        return new Badge(`Ahead by ${variance}`, BadgeColorEnum.GREEN);
+      case this.variancePercent >= 0.95 && this.variancePercent <= 1.05:
+        return new Badge('On track', BadgeColorEnum.PRIMARY);
+      case this.variancePercent >= 0.8 && this.variancePercent <= 0.95:
+        return new Badge(`Behind by ${variance}`, BadgeColorEnum.GOLD);
+      default:
+        return new Badge(`Behind by ${this.variancePercent}%`, BadgeColorEnum.ERROR);
+    }
+  }
+
+  /**
+   *  Calculates the number of scheduled payments between start and end dates for the selected payment frequency.
+   */
+  calculatePaymentsByDate(date: Date) {
+    const start = moment(this.startDate);
+    const end = moment(date);
+    let payments = 0;
+
+    switch (this.paymentFrequency) {
+      case DailyFrequencyEnum.WEEKLY:
+        payments = end.diff(start, 'weeks');
+        break;
+
+      case DailyFrequencyEnum.FORTNIGHTLY:
+        payments = Math.round(end.diff(start, 'weeks') / 2);
+        break;
+
+      case DailyFrequencyEnum.MONTHLY:
+        payments = end.diff(start, 'months');
+        break;
+    }
+
+    return payments;
+  }
+
+  get propertyIds(): number[] {
+    return this.properties.map(property => property.id);
+  }
+
+  /**
+   * creates recurring calendar events based on paymentFrequency
+   */
+  getCalendarEvents(inCalendar = false): MoneyCalendarEventCollection {
+    if (inCalendar && (!this.inCalendar || this.isPropertyType())) {
+      return new MoneyCalendarEventCollection([]);
+    }
+
+    const paymentDates = recurringDates(this.paymentFrequency, this.startDate, this.endDate);
+
+    return new MoneyCalendarEventCollection(paymentDates.map(date => plainToClass(
+      MoneyCalendarEvent,
+      {
+        title: this.name,
+        date: date,
+        extendedProps: {
+          id: this.id,
+          class: FinancialGoal.className,
+          amount: this.paymentAmount
+        }
+      })));
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './financial-goal.interface';
+export * from './financial-goal-type.enum';
+export * from './financial-goal-status.enum';
+export * from './financial-goal';

package/projects/tt-core/src/lib/models/financial-year/financial-year.ts

@@ -0,0 +1,72 @@
+export class FinancialYear {
+  static weeksInYear = 52;
+  static monthsInYear = 12;
+  static startMonthIndex = 6;
+  static endMonthIndex = 5;
+  static get year(): number {
+    return +localStorage.getItem('financialYear');
+  }
+  year: number;
+  startDate: Date;
+  endDate: Date;
+
+  // @TODO UTC?
+  private yearStartDate = '-07-01T00:00:00';
+  private yearEndDate = '-06-30T23:59:59';
+
+  constructor(date?: Date|number) {
+    if (date) {
+      this.year = date instanceof Date ? FinancialYear.toFinYear(date) : date;
+    } else {
+      this.year = FinancialYear.year || FinancialYear.toFinYear(new Date());
+    }
+
+    this.setStartDate(this.year);
+    this.setEndDate(this.year);
+  }
+
+  static isCurrent(year: number = FinancialYear.year): boolean {
+    return FinancialYear.toFinYear(new Date()) === year;
+  }
+
+  includes(date: Date): boolean {
+    return this.year === new FinancialYear(date).year;
+  }
+
+  static toFinYear(date: Date): number {
+    return date.getFullYear() + (date.getMonth() >= this.startMonthIndex ? 1 : 0);
+  }
+
+  /**
+   * Get date by desired month
+   */
+  getMonthDate(monthIndex: number): Date {
+    if (monthIndex >= FinancialYear.startMonthIndex) {
+      return new Date(`${this.year - 1}-${monthIndex + 1}-01`);
+    }
+    return new Date(`${this.year}-${monthIndex + 1}-01`);
+  }
+
+  private setStartDate(year: number): void {
+    this.startDate = new Date(`${year - 1}${this.yearStartDate}`);
+  }
+
+  private setEndDate(year: number): void {
+    this.endDate = new Date(`${year}${this.yearEndDate}`);
+  }
+
+  getPastMonths(): number[] {
+    const months: number[] = [];
+    const now: Date = new Date();
+    const endDate: Date = this.endDate < now ? this.endDate : now;
+    for (const d: Date = this.startDate; d <= endDate; d.setMonth(d.getMonth() + 1)) {
+      months.push(d.getMonth());
+    }
+
+    return months;
+  }
+
+  getYearByMonth(index: number): number {
+    return index > 5 ? this.year - 1 : this.year;
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './financial-year';
+export * from './month-name-short.enum';
+export * from './month-number.enum';
+export * from './months.const';

package/projects/tt-core/src/lib/models/financial-year/month-name-short.enum.ts

@@ -0,0 +1,19 @@
+/**
+ * @TODO move to pipe/translation
+ * enum with months short names.
+ * Order of items match with financial year months order
+ */
+export enum MonthNameShortEnum {
+  JULY = 'Jul',
+  AUGUST = 'Aug',
+  SEPTEMBER = 'Sep',
+  OCTOBER = 'Oct',
+  NOVEMBER = 'Nov',
+  DECEMBER = 'Dec',
+  JANUARY = 'Jan',
+  FEBRUARY = 'Feb',
+  MARCH = 'Mar',
+  APRIL = 'Apr',
+  MAY = 'May',
+  JUNE = 'Jun'
+}

package/projects/tt-core/src/lib/models/financial-year/month-number.enum.ts

@@ -0,0 +1,19 @@
+/**
+ * enum with months indexes.
+ * item value match with js Date month index from 0 to 11
+ * Order of items match with financial year months order
+ */
+export enum MonthNumberEnum {
+  JULY = 6,
+  AUGUST = 7,
+  SEPTEMBER = 8,
+  OCTOBER = 9,
+  NOVEMBER = 10,
+  DECEMBER = 11,
+  JANUARY = 0,
+  FEBRUARY = 1,
+  MARCH = 2,
+  APRIL = 3,
+  MAY = 4,
+  JUNE = 5
+}

package/projects/tt-core/src/lib/models/financial-year/months.const.ts

@@ -0,0 +1 @@
+export const MONTHS: string[] = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];

package/projects/tt-core/src/lib/models/firm/firm-branch.interface.ts

@@ -0,0 +1,7 @@
+export interface FirmBranchInterface {
+  name: string;
+  isMain: boolean;
+  firm: object;
+  address: object;
+  phone?: object;
+}

package/projects/tt-core/src/lib/models/firm/firm-branch.ts

@@ -0,0 +1,17 @@
+import { Firm } from './firm';
+import { Address } from '../address';
+import { AbstractModel } from '../../db/Models';
+import { Type } from 'class-transformer';
+import { FirmBranchInterface } from './firm-branch.interface';
+import { Phone } from '../phone/phone';
+
+export class FirmBranch extends AbstractModel implements FirmBranchInterface {
+  name: string;
+  isMain = false;
+  @Type(() => Firm)
+  firm: Firm;
+  @Type(() => Address)
+  address: Address;
+  @Type(() => Phone)
+  phone?: Phone;
+}

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

@@ -0,0 +1,25 @@
+import { Firm as FirmBase } from '../../db/Models/firm/firm';
+import { Phone } from '../phone/phone';
+import { Address } from '../address';
+import { User } from '../user';
+import { Type } from 'class-transformer';
+import { AppFile } from '../file';
+import { FirmTypeEnum } from '../../db/Enums';
+
+export class Firm extends FirmBase {
+  @Type(() => User)
+  owner: User;
+
+  @Type(() => Address)
+  address: Address;
+
+  @Type(() => Phone)
+  phone: Phone;
+
+  @Type(() => AppFile)
+  file: AppFile;
+
+  isAccountant(): boolean {
+    return this.type === FirmTypeEnum.ACCOUNTANT;
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './firm';
+export * from './firm-branch';

package/projects/tt-core/src/lib/models/fullcalendar/calendar-event.ts

@@ -0,0 +1,26 @@
+import { EventInput } from '@fullcalendar/core';
+import moment from 'moment';
+/**
+ * Typed wrapper for FullCalendar EventInput.
+ * FullCalendar extendedProps is Record<string, any> so we need to add structure :
+ * https://primefaces.github.io/primefaces/jsdocs/classes/node_modules__fullcalendar_common_main.EventApi.html#extendedProps
+ */
+export class CalendarEvent implements EventInput {
+  // id, class are necessary for editing/deleting, to find the right event
+  extendedProps: {
+    id: number;
+    class: string;
+    [key: string]: any;
+  };
+  title: string;
+  date: Date;
+  private today = moment().startOf('day');
+
+  get isOverdue(): boolean {
+    return moment(this.date).isBefore(this.today, 'day');
+  }
+
+  get isUpcoming(): boolean {
+    return moment(this.date).isAfter(this.today, 'day');
+  }
+}

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

@@ -0,0 +1,2 @@
+export * from './calendar-event';
+export * from './money-calendar-event';

package/projects/tt-core/src/lib/models/fullcalendar/money-calendar-event.ts

@@ -0,0 +1,35 @@
+import { CalendarEvent } from './calendar-event';
+import { ChartAccounts } from '../chart-accounts';
+import { FinancialYear } from '../financial-year';
+
+/**
+ * extended class for filtering and data visualisation
+ */
+export class MoneyCalendarEvent extends CalendarEvent {
+  extendedProps: {
+    id: number;
+    class: 'FinancialGoal' | 'BudgetRule';
+    amount: number;
+    chartAccounts: ChartAccounts;
+
+    isIncome?: boolean;
+    isExpense?: boolean;
+    isProperty?: boolean;
+    isWork?: boolean;
+    isPersonal?: boolean;
+    isSole?: boolean;
+    isHolding?: boolean;
+    isOther?: boolean;
+
+    propertyId?: number;
+    businessId?: number;
+  };
+
+  inMonth(month: number): boolean {
+    const year = new FinancialYear().getYearByMonth(month);
+    const dateStart = new Date(year, month, 1);
+    const dateEnd = new Date(year, month + 1, 0);
+
+    return dateStart <= this.date && dateEnd >= this.date;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Transaction } from '../transaction';
+import { HoldingTrade } from './holding-trade';
+import { AbstractModel } from '../../db/Models';
+import { Type } from 'class-transformer';
+import { HoldingType } from './holding-type';
+
+/**
+ * Helper class for holding reinvest functionality.
+ * Reinvest - get dividends and directly buy holdings
+ */
+export class HoldingReinvest extends AbstractModel {
+  @Type(() => Transaction)
+  transaction: Transaction;
+
+  @Type(() => HoldingTrade)
+  trade: HoldingTrade;
+
+  @Type(() => HoldingType)
+  holdingType: HoldingType;
+}

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

@@ -0,0 +1,52 @@
+import { Transform, Type } from 'class-transformer';
+import { HoldingTrade } from './holding-trade';
+import { AssetSale } from '../asset-sale';
+import { HoldingType } from './holding-type';
+
+/**
+ * @TODO vik rename to HoldingTradeParcel when backend ready
+ */
+export class HoldingSale extends AssetSale {
+  quantity: number;
+  price: number;
+  costBase: number;
+  marketValue: number;
+  isHalfExemption: boolean;
+  ownershipPercent: number;
+  isTaxFree: boolean;
+  @Type(() => Date)
+  buyDate: Date;
+
+  @Type(() => HoldingType)
+  @Transform(({ value }) => ({ id: value.id }), { toPlainOnly: true })
+  holdingType: HoldingType;
+
+  get concession(): string {
+    return this.isHalfExemption ? '50% (1 year rule)' : 'None';
+  }
+
+  getCostBase(holding: HoldingTrade): number {
+    return this.getPurchasePrice(holding) + holding.fee;
+  }
+
+  /**
+   * Purchase price of sold items
+   */
+  getPurchasePrice(holding: HoldingTrade): number {
+    return holding.price * this.quantity;
+  }
+
+  /**
+   * total price of sale
+   */
+  get netCost(): number {
+    return this.marketValue;
+  }
+
+  /**
+   * total price of sale without fee
+   */
+  get cost(): number {
+    return this.price * this.quantity;
+  }
+}

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

@@ -0,0 +1,13 @@
+import { HoldingTrade, ObservableModel } from '../../db/Models';
+import { Type } from 'class-transformer';
+
+export class HoldingTradeImport extends ObservableModel {
+  static className = 'HoldingTradeImport';
+  originalName: string;
+  @Type(() => Date)
+  createdAt: Date;
+  @Type(() => Date)
+  updatedAt: Date;
+  @Type(() => HoldingTrade)
+  holdings?: HoldingTrade[];
+}

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

@@ -0,0 +1,28 @@
+import { HoldingTrade } from './holding-trade';
+import { Dictionary } from '../dictionary';
+import { HoldingType } from './holding-type';
+import { HoldingTradeTypeEnum } from '../../db/Enums';
+
+export class HoldingTradeReportItem {
+  date: Date;
+  name: string;
+  ticker: string;
+  quantity: number;
+  fee: number;
+  price: number;
+  total: number;
+  trade: HoldingTrade;
+  type: string;
+
+  constructor(trade: HoldingTrade, holdingTypesById: Dictionary<HoldingType>) {
+    this.trade = trade;
+    this.date = trade.date;
+    this.type = HoldingTradeTypeEnum[trade.type].toLowerCase();
+    this.name = holdingTypesById.get(trade.holdingType.id).name;
+    this.ticker = holdingTypesById.get(trade.holdingType.id).ticker;
+    this.quantity = trade.quantity;
+    this.fee = trade.fee;
+    this.price = trade.price;
+    this.total = parseFloat(`${trade.sign}${trade.total}`);
+  }
+}