taxtank-core 0.0.1 → 0.1.1

package/src/lib/models/client/client-invite.ts

@@ -0,0 +1,70 @@
+import { ClientInvite as ClientInviteBase } from '../../db/Models/client-invite';
+import { ClientInviteStatusEnum } from '../../db/Enums/client-invite-status.enum';
+import { ClientInviteTypeEnum } from '../../db/Enums/client-invite-type.enum';
+import { RegistrationInvite } from '../registration-invite/registration-invite';
+import { Firm } from '../firm/firm';
+import { User } from '../user/user';
+import { Type } from 'class-transformer';
+
+export class ClientInvite extends ClientInviteBase {
+  @Type(() => Date)
+  sentOn: Date;
+
+  @Type(() => Date)
+  updatedAt: Date;
+
+  @Type(() => Firm)
+  firm: Firm;
+
+  @Type(() => User)
+  client: User;
+
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => RegistrationInvite)
+  registrationInvite: RegistrationInvite;
+
+  /**
+   * Check if client invite status is pending
+   */
+  isPending(): boolean {
+    return this.status === ClientInviteStatusEnum.PENDING;
+  }
+
+  /**
+   * Check if client invite status is accepted
+   */
+  isAccepted(): boolean {
+    return !this.isPending() && !this.isRejected();
+  }
+
+  /**
+   * Check if client invite status is rejected
+   */
+  isRejected(): boolean {
+    return this.status === ClientInviteStatusEnum.REJECTED;
+  }
+
+  /**
+   * Check if client invite initiated by firm
+   */
+  isFromEmployee(): boolean {
+    return this.type === ClientInviteTypeEnum.FROM_EMPLOYEE;
+  }
+
+  /**
+   * Check if client invite initiated by client
+   */
+  isFromClient(): boolean {
+    return this.type === ClientInviteTypeEnum.FROM_CLIENT;
+  }
+
+  get firstName(): string {
+    return this.client ? this.client.firstName : this.registrationInvite?.firstName;
+  }
+
+  get email(): string {
+    return this.client ? this.client.email : this.registrationInvite?.email;
+  }
+}

package/src/lib/models/client/client-movement.ts

@@ -0,0 +1,25 @@
+import { ClientMovement as ClientMovementBase } from '../../db/Models/client-movement';
+import { ServiceSubscription } from '../service-subscription/service-subscription';
+import { Firm } from '../firm/firm';
+import { User } from '../user/user';
+import { Type } from 'class-transformer';
+
+export class ClientMovement extends ClientMovementBase {
+  @Type(() => Firm)
+  firm: Firm;
+
+  @Type(() => User)
+  client: User;
+
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => ServiceSubscription)
+  subscription: ServiceSubscription;
+
+  @Type(() => Date)
+  dateFrom: Date;
+
+  @Type(() => Date)
+  dateTo: Date;
+}

package/src/lib/models/client/client-portfolio-chart-data.ts

@@ -0,0 +1,65 @@
+import { plainToClass } from 'class-transformer';
+import { ClientPortfolioReportCollection } from '../../collections/client-portfolio-report.collection';
+import { ClientPortfolioReport } from './client-portfolio-report';
+import { ChartData } from '../chart/chart-data';
+
+/**
+ * Client portfolio charts data based on ClientPortfolioReportCollection
+ */
+export class ClientPortfolioChartData {
+  private clientsPortfolioReportCollection: ClientPortfolioReportCollection;
+
+  constructor(
+    clientsPortfolioReportCollection: ClientPortfolioReportCollection
+  ) {
+    this.clientsPortfolioReportCollection = clientsPortfolioReportCollection;
+  }
+
+  getPieChartData(): ChartData[] {
+    return this.clientsPortfolioReportCollection.items.map((clientPortfolioReport: ClientPortfolioReport) => {
+      return plainToClass(ChartData, {
+        name: clientPortfolioReport.category,
+        data: clientPortfolioReport.count
+      });
+    });
+  }
+
+  getBarChartData(): ChartData[] {
+    return [
+      plainToClass(ChartData, {
+        name: 'Total',
+        data: [
+          {
+            label: 'Market value',
+            value: this.clientsPortfolioReportCollection.marketValue
+          },
+          {
+            label: 'Loan balance',
+            value: this.clientsPortfolioReportCollection.loanBalance
+          },
+          {
+            label: 'Equity position',
+            value: this.clientsPortfolioReportCollection.equityPosition
+          }
+        ]
+      }),
+      plainToClass(ChartData, {
+        name: 'Average',
+        data: [
+          {
+            label: 'Market value',
+            value: this.clientsPortfolioReportCollection.averageMarketValue
+          },
+          {
+            label: 'Loan balance',
+            value: this.clientsPortfolioReportCollection.averageLoanBalance
+          },
+          {
+            label: 'Equity position',
+            value: this.clientsPortfolioReportCollection.averageEquityPosition
+          }
+        ]
+      })
+    ];
+  }
+}

package/src/lib/models/client/client-portfolio-report.ts

@@ -0,0 +1,10 @@
+/**
+ * Class describes client's portfolio report information
+ */
+export class ClientPortfolioReport {
+  category: string;
+  count: number;
+  marketValue: number;
+  loanBalance: number;
+  equityPosition: number;
+}

package/src/lib/models/depreciation/depreciation-capital-project.ts

@@ -0,0 +1,10 @@
+import { DepreciationCapitalProject as DepreciationCapitalProjectBase } from '../../db/Models/depreciation-capital-project';
+import { Type } from 'class-transformer';
+
+export class DepreciationCapitalProject extends DepreciationCapitalProjectBase {
+  // @TODO remove after new rest api ready
+  propertyId: number;
+
+  @Type(() => Date)
+  effectiveDate: Date;
+}

package/src/lib/models/depreciation/depreciation-forecast.ts

@@ -0,0 +1,31 @@
+import { DepreciationForecast as DepreciationForecastBase } from '../../db/Models/depreciation-forecast';
+import * as moment from 'moment';
+import { DateRange } from 'moment-range';
+
+export class DepreciationForecast extends DepreciationForecastBase {
+  isLVP: boolean;
+
+  get dailyClaimAmount(): number {
+    return this.claimAmount / this.daysApplied;
+  }
+
+  get daysApplied(): number {
+    return moment(this.toDate).diff(moment(this.fromDate), 'days');
+  }
+
+  getDaysByMonth(month: number): number {
+    // @TODO find a better place
+    const year: number = this.financialYear - (month > 5 ? 1 : 0);
+
+    // forecast date intersect by month
+    const range: DateRange = new DateRange(this.fromDate, this.toDate).intersect(
+      new DateRange(new Date(year, month, 1), new Date(year, month + 1, 0))
+    );
+
+    return range ? range.duration('days') + 1 : 0;
+  }
+
+  getClaimAmountByMonth(month: number): number {
+    return this.getDaysByMonth(month) * this.dailyClaimAmount;
+  }
+}

package/src/lib/models/depreciation/depreciation-group-item.ts

@@ -0,0 +1,20 @@
+import { DepreciationGroup } from './depreciation-group';
+import { Depreciation } from './depreciation';
+
+/**
+ * Depreciation Tree node with depreciation details
+ */
+export class DepreciationGroupItem extends DepreciationGroup {
+  depreciation: Depreciation;
+
+  constructor(
+    depreciation: Depreciation
+  ) {
+    super(depreciation.chartAccounts.name, depreciation.description, 'property');
+    this.depreciation = depreciation;
+  }
+
+  getClaimAmount(): number {
+    return this.depreciation.claimAmount;
+  }
+}

package/src/lib/models/depreciation/depreciation-group.enum.ts

@@ -0,0 +1,7 @@
+export enum DepreciationGroupEnum {
+  BUILDING_IMPROVEMENTS,
+  PLANT_EQUIPMENT,
+  LOW_VALUE_POOL,
+  WRITTEN_OFF_ITEMS,
+  BORROWING_EXPENSES
+}

package/src/lib/models/depreciation/depreciation-group.ts

@@ -0,0 +1,25 @@
+/**
+ * Depreciation Nested Tree node with depreciations group
+ */
+export class DepreciationGroup {
+  label: string;
+  description: string;
+  icon: string;
+  children: DepreciationGroup[];
+
+  constructor(
+    label: string,
+    description?: string,
+    icon?: string,
+    children?: DepreciationGroup[]
+  ) {
+    this.label = label;
+    this.description = description;
+    this.icon = icon;
+    this.children = children;
+  }
+
+  getClaimAmount(): number {
+    return this.children.reduce((sum: number, child: DepreciationGroup): number => sum + child.getClaimAmount(), 0);
+  }
+}

package/src/lib/models/depreciation/depreciation-groups.const.ts

@@ -0,0 +1,35 @@
+import { DepreciationGroupEnum } from './depreciation-group.enum';
+
+interface DepreciationGroup {
+  label: string;
+  description: string;
+  icon: string;
+}
+
+export const DEPRECIATION_GROUPS: { [key: number]: DepreciationGroup } = {
+  [DepreciationGroupEnum.BORROWING_EXPENSES]: {
+    label: 'Borrowing Expenses',
+    description: 'Borrowing expenses on loans are deductible over 1826 days (5 years) starting from the date of a loan',
+    icon: 'loan'
+  },
+  [DepreciationGroupEnum.BUILDING_IMPROVEMENTS]: {
+    label: 'Building & Improvements',
+    description: 'Construction costs, renovations and capital improvements which depreciate at 2.5%',
+    icon: 'building-improvements'
+  },
+  [DepreciationGroupEnum.PLANT_EQUIPMENT]: {
+    label: 'Plant & Equipment',
+    description: 'Assets which decline in value over their useful life (as prescribed by the ATO)',
+    icon: 'plant-equipment'
+  },
+  [DepreciationGroupEnum.LOW_VALUE_POOL]: {
+    label: 'Low Value Pool',
+    description: 'Items under $1,000 are added to the pool to maximise depreciation',
+    icon: 'lvp'
+  },
+  [DepreciationGroupEnum.WRITTEN_OFF_ITEMS]: {
+    label: 'Written Off Items',
+    description: 'Items below $300, replaced or obsolete are fully deductible',
+    icon: 'cart'
+  }
+};

package/src/lib/models/depreciation/depreciation-receipt.ts

@@ -0,0 +1,9 @@
+import { DepreciationReceipt as DepreciationReceiptBase } from '../../db/Models/depreciation-receipt';
+import { IAsset } from '../../interfaces/asset.interface';
+import { AssetTypeEnum } from '../../interfaces/asset-type.enum';
+import { AssetEntityTypeEnum } from '../../interfaces/asset-entity-type.enum';
+
+export class DepreciationReceipt extends DepreciationReceiptBase implements IAsset {
+  type: AssetTypeEnum = AssetTypeEnum.RECEIPTS;
+  entityType: AssetEntityTypeEnum = AssetEntityTypeEnum.DEPRECIATIONS;
+}

package/src/lib/models/depreciation/depreciation.ts

@@ -0,0 +1,174 @@
+import { Depreciation as DepreciationBase } from '../../db/Models/depreciation';
+import { DepreciationTypeEnum } from '../../db/Enums/depreciation-type.enum';
+import { DepreciationCalculationEnum } from '../../db/Enums/depreciation-calculation.enum';
+import { ChartAccountsHeadingVehicleListEnum } from '../../db/Enums/chart-accounts-heading-vehicle-list.enum';
+import { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';
+import { DepreciationCapitalProject } from './depreciation-capital-project';
+import { DepreciationForecast } from './depreciation-forecast';
+import { FinancialYear } from '../financial-year/financial-year';
+import { ChartAccounts } from '../chart-accounts/chart-accounts';
+import { BankTransaction } from '../bank/bank-transaction';
+import { ITank } from '../../interfaces/tank.interface';
+import { IReceipt } from '../../interfaces/receipt.interface';
+import { IAsset } from '../../interfaces/asset.interface';
+import { Transform, Type } from 'class-transformer';
+
+export class Depreciation extends DepreciationBase implements ITank, IReceipt {
+  static WRITTEN_OFF_THRESHOLD = 300;
+  static LOW_VALUE_POOL_THRESHOLD = 1000;
+
+  @Type(() => Date)
+  purchaseDate: Date;
+
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => Date)
+  writeOffManualDate: Date;
+
+  @Type(() => Date)
+  writeOffDate: Date;
+
+  @Type(() => DepreciationCapitalProject)
+  depreciationCapitalProject: DepreciationCapitalProject;
+
+  @Type(() => DepreciationForecast)
+  @Transform(({value, obj}) => {
+    // value = array of DepreciationForecast
+    // obj = plain (whole Depreciation object)
+    // Set isLVP flag for each DepreciationForecast
+    value.forEach((forecast: DepreciationForecast): void => {
+      forecast.isLVP =
+        forecast.closeBalance < 1000 &&
+        obj.calculation === DepreciationCalculationEnum.DIMINISHING &&
+        obj.type === DepreciationTypeEnum.PLANT_EQUIPMENT &&
+        !(obj.amount > Depreciation.WRITTEN_OFF_THRESHOLD && obj.amount < Depreciation.LOW_VALUE_POOL_THRESHOLD) &&
+        !(obj.writeOffDate && new FinancialYear(new Date(obj.writeOffDate)).year === obj.financialYear);
+    });
+    return value;
+  })
+  forecasts: DepreciationForecast[] = [];
+
+  @Type(() => ChartAccounts)
+  chartAccounts: ChartAccounts;
+
+  @Type(() => BankTransaction)
+  bankTransaction: BankTransaction;
+
+  type: DepreciationTypeEnum = DepreciationTypeEnum.PLANT_EQUIPMENT;
+
+  receipt: IAsset;
+
+  isCapital(): boolean {
+    return this.type === DepreciationTypeEnum.CAPITAL_WORKS;
+  }
+
+  isBorrowingExpense(): boolean {
+    return this.type === DepreciationTypeEnum.BORROWING_EXPENSES;
+  }
+
+  isAsset(): boolean {
+    return this.type === DepreciationTypeEnum.PLANT_EQUIPMENT;
+  }
+
+  /**
+   * check if depreciation should be displayed in written off category
+   * details in project documentation
+   * @TODO new FinancialYear(this.writeOffDate) === new FinancialYear()
+   */
+  isWrittenOff(): boolean {
+    return this.isAsset && this.writeOffDate && new FinancialYear(this.writeOffDate).year === this.financialYear;
+  }
+
+  /**
+   * Check if depreciation is Plant & Equipment
+   */
+  isPlantEquipment(): boolean {
+    return this.isAsset() && !this.isWrittenOff() && !this.isLowValuePool();
+  }
+
+  /**
+   * check if depreciation should be displayed in low value pool
+   * details in project documentation
+   * @TODO new FinancialYear(this.writeOffDate) === new FinancialYear()
+   */
+  isLowValuePool(): boolean {
+    return this.isAsset && !this.isWrittenOff() &&
+      this.calculation === DepreciationCalculationEnum.DIMINISHING &&
+      this.amount > Depreciation.WRITTEN_OFF_THRESHOLD &&
+      this.amount <= Depreciation.LOW_VALUE_POOL_THRESHOLD;
+  }
+
+  isPropertyTank(): boolean {
+    return !!this.property;
+  }
+
+  isWorkTank(): boolean {
+    return !this.property;
+  }
+
+  isPrimeCost(): boolean {
+    return this.calculation === DepreciationCalculationEnum.PRIME_COST;
+  }
+
+  isDiminishing(): boolean {
+    return this.calculation === DepreciationCalculationEnum.DIMINISHING;
+  }
+
+  /**
+   * Check if depreciation chart accounts heading related to vehicles category
+   */
+  isVehicleDepreciation(): boolean {
+    return this.chartAccounts.heading?.id === ChartAccountsHeadingVehicleListEnum.DEPRECIATION_VEHICLES;
+  }
+
+  /**
+   * Get depreciation purchase date
+   */
+  getDate(): Date {
+    return this.date;
+  }
+
+  /**
+   * @TODO wrong year, use current financial year, check everywhere
+   */
+  get currentYearForecast(): DepreciationForecast {
+    return this.forecasts.find((forecast: DepreciationForecast): boolean => {
+      return forecast.financialYear === new FinancialYear().year;
+    });
+  }
+
+  getForecastByYear(year: number): DepreciationForecast {
+    return this.forecasts.find((forecast: DepreciationForecast): boolean => {
+      return forecast.financialYear === year;
+    });
+  }
+
+  /**
+   * get depreciation's closing balance for current financial year
+   * open balance here because closing balance in POST actually saves to previous financial year forecast
+   */
+  getCloseBalance(): number {
+    return this.currentYearForecast?.openBalance || 0;
+  }
+
+  get claimAmount(): number {
+    return this.currentYearForecast?.claimAmount || 0;
+  }
+
+  getClaimAmountByYear(year: number): number {
+    return this.getForecastByYear(year)?.claimAmount || 0;
+  }
+
+  get assetValue(): number {
+    return this.currentYearForecast?.closeBalance || 0;
+  }
+
+  getClaimPercent(): number {
+    return this.currentYearForecast?.claimPercent;
+  }
+
+  isBuildingAtCost() {
+    return this.chartAccounts.id === ChartAccountsListEnum.BUILDING_AT_COST;
+  }
+}

package/src/lib/models/document/document-api-url-prefix.enum.ts

@@ -0,0 +1,7 @@
+/**
+ * Enum with document types which used to API url prefix
+ */
+export enum DocumentApiUrlPrefixEnum {
+  FOLDERS = 'folders',
+  PROPERTIES = 'properties'
+}

package/src/lib/models/document/document-file-types.const.ts

@@ -0,0 +1,22 @@
+export const DOCUMENT_FILE_TYPES: {[key: string]: string[]} = {
+  image: [
+    'image/png',
+    'image/jpg',
+    'image/jpeg',
+    'image/tiff',
+    'image/bmp'
+  ],
+  all: [
+    'image/png',
+    'image/jpg',
+    'image/jpeg',
+    'image/tiff',
+    'image/bmp',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/pdf',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'text/csv'
+  ]
+};

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

@@ -0,0 +1,11 @@
+import { DocumentFolder as DocumentFolderBase } from '../../db/Models/document-folder';
+import { Documentable } from '../../interfaces/documentable.interface';
+import { Document } from './document';
+import { Type } from 'class-transformer';
+
+export class DocumentFolder extends DocumentFolderBase implements Documentable {
+  documentFile: File;
+
+  @Type(() => Document)
+  documents: Document[];
+}

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

@@ -0,0 +1,29 @@
+import { Document as DocumentBase } from '../../db/Models/document';
+import { IAsset } from '../../interfaces/asset.interface';
+import { AssetTypeEnum } from '../../interfaces/asset-type.enum';
+import { AssetEntityTypeEnum } from '../../interfaces/asset-entity-type.enum';
+import { DocumentFolder } from './document-folder';
+import { DocumentApiUrlPrefixEnum } from './document-api-url-prefix.enum';
+import { IDocument } from '../../interfaces/document.interface';
+import { Documentable } from '../../interfaces/documentable.interface';
+
+export class Document extends DocumentBase implements IAsset, IDocument {
+  file: File;
+  type: AssetTypeEnum = AssetTypeEnum.DOCUMENTS;
+  entityType: AssetEntityTypeEnum = AssetEntityTypeEnum.FOLDERS;
+  folder: DocumentFolder;
+
+  /**
+   * Get folder as document parent entity
+   */
+  getEntity(): Documentable {
+    return this.folder;
+  }
+
+  /**
+   * Get API url prefix
+   */
+  getApiUrlPrefix(): string {
+    return DocumentApiUrlPrefixEnum.FOLDERS;
+  }
+}

package/src/lib/models/employee/employee-details.ts

@@ -0,0 +1,8 @@
+import { EmployeeDetails as EmployeeDetailsBase } from '../../db/Models/employee-details';
+import { Firm } from '../firm/firm';
+import { Type } from 'class-transformer';
+
+export class EmployeeDetails extends EmployeeDetailsBase {
+  @Type(() => Firm)
+  firm: Firm;
+}

package/src/lib/models/employee/employee-invite.ts

@@ -0,0 +1,12 @@
+import { EmployeeInvite as EmployeeInviteBase } from '../../db/Models/employee-invite';
+import { Type } from 'class-transformer';
+import { RegistrationInvite } from '../registration-invite/registration-invite';
+import { User } from '../user/user';
+
+export class EmployeeInvite extends EmployeeInviteBase {
+  @Type(() => RegistrationInvite)
+  registrationInvite: RegistrationInvite;
+
+  @Type(() => User)
+  employee: User;
+}

package/src/lib/models/endpoint/endpoint.ts

@@ -0,0 +1,35 @@
+/**
+ * Available request methods
+ */
+declare type RequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+/**
+ * Backend endpoint class
+ */
+export class Endpoint {
+  method: RequestMethod;
+  pattern: string;
+
+  constructor(
+    method: RequestMethod,
+    pattern: string,
+  ) {
+    this.method = method;
+    this.pattern = pattern;
+  }
+
+  /**
+   * check url with regexp
+   * @param url
+   */
+  test(url: string): boolean {
+    return this.regexp.test(url);
+  }
+
+  /**
+   * Get regexp for endpoint
+   */
+  get regexp(): RegExp {
+    return new RegExp(`^${this.method} \.\*${this.pattern}$`);
+  }
+}