taxtank 0.1.0

package/projects/tt-core/src/lib/models/chart-accounts/chart-accounts.ts

@@ -0,0 +1,377 @@
+import { ChartAccounts as ChartAccountsBase } from '../../db/Models/chart-accounts/chart-accounts';
+import { Expose, Transform, Type } from 'class-transformer';
+import { ChartAccountsHeading } from './chart-accounts-heading';
+import { ChartAccountsMetaField } from './chart-accounts-meta-field';
+import {
+  BusinessChartAccountsEnum,
+  ChartAccountsAdjustmentIncludedListEnum,
+  ChartAccountsCategoryEnum,
+  ChartAccountsHeadingListEnum,
+  ChartAccountsHeadingTaxDeductibleEnum,
+  ChartAccountsHeadingTaxableEnum,
+  ChartAccountsHeadingVehicleListEnum, ChartAccountsListEnum,
+} from '../../db/Enums';
+import { CHART_ACCOUNTS_CATEGORIES } from './chart-accounts-categories.const';
+import { FinancialYear } from '../financial-year';
+import { ChartAccountsValue } from './chart-accounts-value';
+import { ChartAccountsTaxLabelsEnum } from './chart-accounts-tax-labels.enum';
+import { enumToList } from '../../functions/enum-to-list';
+import { CHART_ACCOUNTS_VALUES } from '../../db-static/chart-accounts/chart-accounts-values';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+
+export class ChartAccounts extends ChartAccountsBase {
+  /**
+   * Australian GST percent value (VAT)
+   */
+  static GSTRatio = 0.1;
+  static GSTCoefficient = 1.1;
+  static GSTPercent = 10;
+  static systemList = [
+    ChartAccountsListEnum.HOME_OFFICE_HOURS,
+    ChartAccountsListEnum.KMS_TRAVELLED,
+    BusinessChartAccountsEnum.HOME_OFFICE_HOURS,
+    BusinessChartAccountsEnum.KMS_TRAVELLED,
+  ];
+  static homeOfficeList = [
+    ChartAccountsListEnum.MOBILE_PHONE,
+    ChartAccountsListEnum.INTERNET,
+    ChartAccountsListEnum.ELECTRICITY_AND_GAS,
+    ChartAccountsListEnum.TELEPHONE,
+    ChartAccountsListEnum.HOME_OFFICE_CLEANING,
+    BusinessChartAccountsEnum.ELECTRICITY_AND_GAS,
+    BusinessChartAccountsEnum.HOME_OFFICE_CLEANING,
+    BusinessChartAccountsEnum.INTERNET,
+    BusinessChartAccountsEnum.TELEPHONE,
+    BusinessChartAccountsEnum.MOBILE_PHONE,
+    BusinessChartAccountsEnum.HOME_OFFICE_RENT,
+    BusinessChartAccountsEnum.HOME_OFFICE_LOAN,
+    BusinessChartAccountsEnum.HOME_OFFICE_RATES,
+    BusinessChartAccountsEnum.HOME_OFFICE_OTHER,
+  ]
+
+  @Type(() => ChartAccountsHeading)
+  heading: ChartAccountsHeading;
+
+  @Type(() => ChartAccountsMetaField)
+  metaFields: ChartAccountsMetaField[];
+
+  @Type(() => ChartAccountsValue)
+  @Transform(({ obj }) => CHART_ACCOUNTS_VALUES.get(obj.id).toArray(), { toClassOnly: true })
+  @Expose() values: ChartAccountsValue[];
+
+  /**
+   * Return name as string
+   */
+  toString(): string {
+    return this.name;
+  }
+
+  /**
+   * construction cost, 1 building=1 buildingAtCost depreciation
+   */
+  isBuildingAtCost(): boolean {
+    return this.id === ChartAccountsListEnum.BUILDING_AT_COST;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Kms travelled for work' category
+   */
+  isKmsForWork(): boolean {
+    return this.id === ChartAccountsListEnum.KMS_TRAVELLED;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Kms travelled for sole' category
+   */
+  isKmsForSole(): boolean {
+    return this.id === BusinessChartAccountsEnum.KMS_TRAVELLED;
+  }
+
+  isKms(): boolean {
+    return [ChartAccountsListEnum.KMS_TRAVELLED, BusinessChartAccountsEnum.KMS_TRAVELLED].includes(this.id);
+  }
+
+  /**
+   * special type used for just pre-paying tax to the ATO, uses on tax summary
+   */
+  isNRAS(): boolean {
+    return this.id === ChartAccountsListEnum.TAX_OFFSETS_N_R_A_S;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Interest on Loan' category
+   */
+  isInterestOnLoan(): boolean {
+    return this.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Motor Vehicles' category
+   */
+  isVehicles(): boolean {
+    return [ChartAccountsListEnum.VEHICLES, BusinessChartAccountsEnum.VEHICLES].includes(this.id);
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Interest Earned' category
+   */
+  isInterestEarned(): boolean {
+    return this.id === ChartAccountsListEnum.INTEREST_EARNED;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Trust Income' category
+   */
+  isTrustIncome(): boolean {
+    return this.id === ChartAccountsListEnum.TRUST_INCOME;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Motor vehicles (commercial cars)' category
+   */
+  isCommercialVehicles(): boolean {
+    return this.id === ChartAccountsListEnum.COMMERCIAL_VEHICLES;
+  }
+
+  /**
+   * Check if chart accounts is work income
+   */
+  isWorkIncome(): boolean {
+    return this.category === ChartAccountsCategoryEnum.WORK_INCOME;
+  }
+
+  isVehicleExpense(): boolean {
+    return !!ChartAccountsHeadingVehicleListEnum[this.heading?.id];
+  }
+
+  /**
+   * Check if chart accounts is other income
+   */
+  isOtherIncome(): boolean {
+    return this.category === ChartAccountsCategoryEnum.OTHER_INCOME;
+  }
+
+  isIncome(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.category);
+  }
+
+  isExpense(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.category);
+  }
+
+  isProperty(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.property.includes(this.category);
+  }
+
+  isWork(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.work.includes(this.category);
+  }
+
+  isSole(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.soleIncome.includes(this.category);
+  }
+
+
+  isWorkExpense(): boolean {
+    return [ChartAccountsCategoryEnum.WORK_EXPENSE, ChartAccountsCategoryEnum.OTHER_EXPENSE, ChartAccountsCategoryEnum.WORK_DEPRECIATION]
+      .includes(this.category);
+  }
+
+  isSoleExpense(): boolean {
+    return [ChartAccountsCategoryEnum.SOLE_EXPENSE, ChartAccountsCategoryEnum.SOLE_DEPRECIATION].includes(this.category);
+  }
+
+  isHoldingExpense(): boolean {
+    return [ChartAccountsCategoryEnum.HOLDING_EXPENSE].includes(this.category);
+  }
+
+  /**
+   * Check if chart accounts is property expense
+   */
+  isPropertyExpense(): boolean {
+    return this.isProperty() && this.isExpense();
+  }
+
+  /**
+   * Check if chart accounts is property income
+   */
+  isPropertyIncome(): boolean {
+    return this.category === ChartAccountsCategoryEnum.PROPERTY_INCOME;
+  }
+
+  isPersonal(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.category);
+  }
+
+  isPersonalExpense(): boolean {
+    return this.category === ChartAccountsCategoryEnum.PERSONAL_EXPENSE;
+  }
+
+  /**
+   * Check if chart accounts category is depreciation
+   */
+  isDepreciation(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.depreciation.includes(this.category);
+  }
+
+  /**
+   * Check if transaction chart account is work related car expenses
+   */
+  isVehicleLoanExpense(): boolean {
+    return this.isVehicleLoanInterest() || this.isVehicleLoanPrinciple();
+  }
+
+  isVehicleLoanPrinciple(): boolean {
+    return [ChartAccountsListEnum.VEHICLE_LOAN_PRINCIPAL, BusinessChartAccountsEnum.VEHICLE_LOAN_PRINCIPAL].includes(this.id);
+  }
+
+  isVehicleLoanInterest(): boolean {
+    return [ChartAccountsListEnum.VEHICLE_LOAN_INTEREST, BusinessChartAccountsEnum.VEHICLE_LOAN_INTEREST].includes(this.id);
+  }
+
+  /**
+   * Get chart accounts value for current financial year
+   */
+  getCurrentYearValue(): ChartAccountsValue {
+    return this.getValueByYear(new FinancialYear().year);
+  }
+
+  /**
+   * Get chart accounts value by financial year
+   */
+  getValueByYear(year: number): ChartAccountsValue {
+    return this.values.find((value: ChartAccountsValue): boolean => value.financialYear === year);
+  }
+
+  /**
+   * no way to check how much used for work/sole, so we let user adjust it
+   * except vehicle expense, which is equal to vehicleClaim.workUsage
+   * except when taxablePercent=0, but not ENTERTAINMENT
+   */
+  isClaimPercentEditable(): boolean {
+    return ((this.isWorkExpense() || this.isSoleExpense() || this.isHoldingExpense()) && !this.isVehicleExpense() && this.taxablePercent > 0)
+      || this.id === BusinessChartAccountsEnum.ENTERTAINMENT;
+  }
+
+  /**
+   * get label for transaction tax field depended on selected chart account.
+   * tax type depends on chart account heading or category.
+   */
+  getTaxLabel(): ChartAccountsTaxLabelsEnum {
+    // get simple array of ids from enum with taxable chart accounts headings
+    const taxableCAHeadingsIds: number[] = enumToList(ChartAccountsHeadingTaxableEnum)
+      .map((item: { label: string, value: number }) => item.value);
+    // get simple array of ids from enum with tax-deductible chart accounts headings
+    const deductibleCAHeadingsIds: number[] = enumToList(ChartAccountsHeadingTaxDeductibleEnum)
+      .map((item: { label: string, value: number }) => item.value);
+
+    // check if one of ids arrays includes current chart accounts heading id and set tax label
+    // otherwise label is empty for this class
+    switch (true) {
+      case taxableCAHeadingsIds.includes(this.heading?.id):
+        return ChartAccountsTaxLabelsEnum.TAX_PAID;
+      case deductibleCAHeadingsIds.includes(this.heading?.id):
+        return ChartAccountsTaxLabelsEnum.TAX_DEDUCTED;
+      case CHART_ACCOUNTS_CATEGORIES.workIncome.includes(this.category):
+      case this.category === ChartAccountsCategoryEnum.HOLDING_INCOME:
+        return ChartAccountsTaxLabelsEnum.TAX_WITHHELD;
+      default:
+        return null;
+    }
+  }
+
+  isETP(): boolean {
+    return this.heading.id === ChartAccountsHeadingListEnum.ETP
+  }
+
+  isSalary(): boolean {
+    return this.id === ChartAccountsListEnum.SALARY_OR_WAGES;
+  }
+
+  /**
+   * chart accounts included in salary, like tips or allowance
+   */
+  isAdjustmentIncluded(): boolean {
+    return this.id in ChartAccountsAdjustmentIncludedListEnum;
+  }
+
+  isPropertyCapitalWorks(): boolean {
+    return this.category === ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS
+  }
+
+  hasTaxField(): boolean {
+    return !this.isNRAS() && this.isWorkIncome();
+  }
+
+  isTaxable(): boolean {
+    return this.taxablePercent > 0;
+  }
+
+  isTransfer(): boolean {
+    return this.id === ChartAccountsListEnum.TRANSFER;
+  }
+
+  isDividends(): boolean {
+    return this.id === ChartAccountsListEnum.DIVIDENDS;
+  }
+
+  isHomeOfficeExpense(): boolean {
+    return ChartAccounts.homeOfficeList.includes(this.id);
+  }
+
+  isHomeOfficeWorkHours(): boolean {
+    return this.id === ChartAccountsListEnum.HOME_OFFICE_HOURS;
+  }
+
+  /**
+   * income requiring extra data like adjustments/payer/etc
+   */
+  isIncomeWithMeta(): boolean {
+    if (!this.isIncome() || this.isSole()) {
+      return false;
+    }
+
+    return this.isWork() || this.isTaxable();
+  }
+
+  get tankType(): TankTypeEnum {
+    switch (true) {
+      case this.isPropertyTank():
+        return TankTypeEnum.PROPERTY;
+      case this.isWorkTank():
+        return TankTypeEnum.WORK;
+      case this.isSoleTank():
+        return TankTypeEnum.SOLE;
+      case this.isHoldingTank():
+        return TankTypeEnum.HOLDING;
+      case this.isOtherTank():
+        return TankTypeEnum.OTHER;
+      default:
+        return TankTypeEnum.PERSONAL;
+    }
+  }
+
+  isPropertyTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.property.includes(this.category)
+  }
+
+  isWorkTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.work.includes(this.category);
+  }
+
+  isSoleTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.sole.includes(this.category);
+  }
+
+  isHoldingTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.holding.includes(this.category);
+  }
+
+  isOtherTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.other.includes(this.category);
+  }
+
+  isPersonalTank(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.category);
+  }
+}

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

@@ -0,0 +1,8 @@
+export * from './chart-accounts-categories.const';
+export * from './chart-accounts-category.e-collection';
+export * from './chart-accounts-depreciation';
+export * from './chart-accounts-heading';
+export * from './chart-accounts-meta-field';
+export * from './chart-accounts-tax-labels.enum';
+export * from './chart-accounts-value';
+export * from './chart-accounts';

package/projects/tt-core/src/lib/models/chat/chat-view-type.enum.ts

@@ -0,0 +1,4 @@
+export enum ChatViewTypeEnum {
+  MESSAGES,
+  ATTACHMENTS
+}

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

@@ -0,0 +1,30 @@
+import { Chat as ChatBase } from '../../db/Models/firm/chat';
+import { ChatStatusEnum } from '../../db/Enums/chat-status.enum';
+import { User } from '../user';
+import { Type } from 'class-transformer';
+import { FirmBranch } from '../firm';
+
+export class Chat extends ChatBase {
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => User)
+  client: User;
+
+  @Type(() => Date)
+  updatedAt: Date;
+
+  @Type(() => FirmBranch)
+  firmBranch: FirmBranch;
+
+  // @TODO temporary disabled
+  // @Type(() => User)
+  // typingUsers: User[] = [];
+
+  /**
+   * Check if chat is active
+   */
+  isActive(): boolean {
+    return this.status === ChatStatusEnum.ACTIVE;
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './chat-view-type.enum';
+export * from './chat';
+export * from './message-document';
+export * from './message';

package/projects/tt-core/src/lib/models/chat/message-document.ts

@@ -0,0 +1,18 @@
+import { MessageDocument as MessageDocumentBase } from '../../db/Models/firm/message-document';
+import { IAsset } from '../../interfaces';
+import { AssetEntityTypeEnum } from '../../interfaces';
+import { AssetTypeEnum } from '../../interfaces';
+import { User } from '../user';
+import { Type } from 'class-transformer';
+import { AppFile } from '../file';
+
+export class MessageDocument extends MessageDocumentBase implements IAsset {
+  entityType: AssetEntityTypeEnum = AssetEntityTypeEnum.MESSAGES;
+  type: AssetTypeEnum = AssetTypeEnum.MESSAGE;
+
+  @Type(() => User)
+  user: User;
+
+  @Type(() => AppFile)
+  file: AppFile;
+}

package/projects/tt-core/src/lib/models/chat/message.ts

@@ -0,0 +1,44 @@
+import { Message as MessageBase } from '../../db/Models/firm/message';
+import { User } from '../user/user';
+import { MessageDocument } from './message-document';
+import { Expose, Type } from 'class-transformer';
+import { Chat } from './chat';
+
+
+export class Message extends MessageBase {
+  @Type(() => Date)
+  createdAt: Date;
+
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => Chat)
+  chat: Chat;
+
+  @Type(() => MessageDocument)
+  @Expose() documents: MessageDocument[];
+
+  /**
+   * Check if message created today or not
+   */
+  isToday(): boolean {
+    const now: Date = new Date();
+    return this.createdAt.getFullYear() === now.getFullYear() &&
+      this.createdAt.getMonth() === now.getMonth() &&
+      this.createdAt.getDate() === now.getDate();
+  }
+
+  /**
+   * Check if message sent from firm
+   */
+  isFromEmployee(): boolean {
+    return !!this.employee;
+  }
+
+  /**
+   * Check if message read
+   */
+  isRead(): boolean {
+    return !!this.readAt;
+  }
+}

package/projects/tt-core/src/lib/models/client/annual-client-details.ts

@@ -0,0 +1,21 @@
+import { AbstractModel } from '../../db/Models';
+import { ClientDetails } from './client-details';
+import { FinancialYear } from '../financial-year';
+import { Type } from 'class-transformer';
+
+export class AnnualClientDetails extends AbstractModel {
+  privateHealthCare: boolean;
+  spouse: boolean;
+  spouseAnnualIncome = 0;
+  dependants?: number;
+  studentLoanAmount?: number;
+  financialYear: number = new FinancialYear().year;
+  reportableFringeBenefits?: number;
+  exemptForeignEmploymentIncome?: number;
+  @Type(() => ClientDetails)
+  clientDetails: ClientDetails;
+
+  get spouseMonthlyIncome(): number {
+    return this.spouseAnnualIncome / 12;
+  }
+}

package/projects/tt-core/src/lib/models/client/capital-loss.interface.ts

@@ -0,0 +1,6 @@
+export interface CapitalLossInterface {
+  clientDetails: object;
+  financialYear: number;
+  balance: number;
+  isManual: boolean;
+}

package/projects/tt-core/src/lib/models/client/capital-loss.ts

@@ -0,0 +1,15 @@
+import { CapitalLossInterface } from './capital-loss.interface';
+import { Type } from 'class-transformer';
+import { ClientDetails } from './client-details';
+import { AbstractModel } from '../../db/Models';
+import { FinancialYear } from '../financial-year';
+import { User } from '../user';
+
+export class CapitalLoss extends AbstractModel implements CapitalLossInterface {
+  @Type(() => ClientDetails)
+  clientDetails: ClientDetails;
+
+  financialYear = new FinancialYear().year;
+  balance: number;
+  isManual: boolean;
+}

package/projects/tt-core/src/lib/models/client/client-details.ts

@@ -0,0 +1,35 @@
+import { ClientDetails as ClientDetailsBase } from '../../db/Models/client/client-details';
+import { Type } from 'class-transformer';
+
+export class ClientDetails extends ClientDetailsBase {
+  /**
+   * reminder to sign basiq consent after x days before the expiration
+   */
+  static consentExpiryReminderDays = 30;
+
+  get taxFileNumberMasked(): string {
+    const maskedLength = this.taxFileNumber.length - 4;
+    const maskedPart = '*'.repeat(maskedLength);
+    const lastFour = this.taxFileNumber.slice(-4);
+
+    return maskedPart + lastFour;
+  }
+
+  @Type(() => Date)
+  basiqConsentExpiryDate: Date;
+
+  isBasiqConsentExpiring(): boolean {
+    if (!this.basiqConsentExpiryDate || this.isBasiqConsentExpired()) {
+      return false;
+    }
+
+    const reminderDate = new Date(this.basiqConsentExpiryDate);
+    reminderDate.setDate(this.basiqConsentExpiryDate.getDate() - ClientDetails.consentExpiryReminderDays);
+
+    return new Date() >= reminderDate;
+  }
+
+  isBasiqConsentExpired(): boolean {
+    return this.basiqConsentExpiryDate && new Date() >= this.basiqConsentExpiryDate;
+  }
+}

package/projects/tt-core/src/lib/models/client/client-invite.ts

@@ -0,0 +1,76 @@
+import { ClientInvite as ClientInviteBase } from '../../db/Models/firm/client-invite';
+import { ClientInviteStatusEnum, ClientInviteTypeEnum } from '../../db/Enums';
+import { RegistrationInvite } from '../registration-invite/registration-invite';
+import { User } from '../user';
+import { Type } from 'class-transformer';
+import { Firm, FirmBranch } from '../firm';
+
+export class ClientInvite extends ClientInviteBase {
+  @Type(() => Date)
+  sentOn: Date;
+
+  @Type(() => Date)
+  updatedAt: Date;
+
+  @Type(() => User)
+  client: User;
+
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => RegistrationInvite)
+  registrationInvite: RegistrationInvite;
+
+  @Type(() => Firm)
+  firm: Firm;
+
+  @Type(() => FirmBranch)
+  firmBranch: FirmBranch;
+
+  /**
+   * 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 fullName(): string {
+    return this.client ? this.client.fullName : this.registrationInvite?.fullName;
+  }
+
+  get email(): string {
+    return this.client ? this.client.email : this.registrationInvite?.email;
+  }
+}

package/projects/tt-core/src/lib/models/client/client-movement.ts

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