taxtank 0.1.0

package/projects/tt-core/src/lib/models/sole/bas-report.ts

@@ -0,0 +1,49 @@
+import { BasReport as BasReportBase } from '../../db/Models/sole/bas-report';
+import { Type } from 'class-transformer';
+
+export class BasReport extends BasReportBase {
+  @Type(() => Date)
+  dateFrom: Date;
+
+  @Type(() => Date)
+  dateTo: Date;
+
+  get taxWithheldTotal(): number {
+    return this.taxWithheldSalary + this.taxWithheldNoABN;
+  }
+
+  get paygTaxInstalmentOwedToATO(): number {
+    return this.paygTaxInstalment > 0 ? this.paygTaxInstalment : 0;
+  }
+
+  get paygTaxInstalmentOwedByATO(): number {
+    return this.paygTaxInstalment < 0 ? Math.abs(this.paygTaxInstalment) : 0;
+  }
+
+  get fuelTaxCreditOwedToATO(): number {
+    return this.fuelTaxCredit < 0 ? this.fuelTaxCredit : 0;
+  }
+
+  get fuelTaxCreditOwedByATO(): number {
+    return this.fuelTaxCredit > 0 ? Math.abs(this.fuelTaxCredit) : 0;
+  }
+
+  get owesToATO(): number {
+    return this.incomeGST + this.taxWithheldTotal + this.paygTaxInstalmentOwedToATO + this.fuelTaxCreditOwedToATO;
+  }
+
+  get owedByATO(): number {
+    return this.expenseGST + this.paygTaxInstalmentOwedByATO + this.fuelTaxCreditOwedByATO;
+  }
+
+  /**
+   * GST payable to the ATO, or refundable from the ATO in case it's negative
+   */
+  get gst(): number {
+    if (!this.id) {
+      return 0;
+    }
+
+    return this.incomeGST + this.expenseGST + this.taxWithheldTotal + this.paygTaxInstalment - this.fuelTaxCredit;
+  }
+}

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

@@ -0,0 +1,12 @@
+export * from './sole-business';
+export * from './sole-business-activity';
+export * from './sole-business-allocation';
+export * from './sole-business-loss';
+export * from './sole-business-loss-offset-rule';
+export * from './sole-contact';
+export * from './sole-depreciation-method';
+export * from './sole-details';
+export * from './sole-invoice';
+export * from './sole-invoice-item';
+export * from './sole-invoice-template';
+export * from './bas-report';

package/projects/tt-core/src/lib/models/sole/sole-business-activity.ts

@@ -0,0 +1,5 @@
+import { SoleBusinessActivity as SoleBusinessActivityBase } from '../../db/Models/sole/sole-business-activity';
+
+export class SoleBusinessActivity extends SoleBusinessActivityBase {
+
+}

package/projects/tt-core/src/lib/models/sole/sole-business-allocation.ts

@@ -0,0 +1,15 @@
+import { SoleBusinessAllocation as SoleBusinessAllocationBase } from '../../db/Models/sole/sole-business-allocation';
+import { BankAccount } from '../bank/bank-account';
+import { Expose, Transform, Type } from 'class-transformer';
+import { SoleBusiness } from './sole-business';
+
+export class SoleBusinessAllocation extends SoleBusinessAllocationBase {
+  @Type(() => BankAccount)
+  bankAccount: BankAccount;
+
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  @Transform(({ value }) => isNaN(value) ? 100 : value)
+  @Expose() percent: number;
+}

package/projects/tt-core/src/lib/models/sole/sole-business-loss-offset-rule.ts

@@ -0,0 +1,7 @@
+import { SoleBusinessLossOffsetRule as SoleBusinessLossOffsetRuleBase } from '../../db/Models/sole/sole-business-loss-offset-rule';
+import { Type } from 'class-transformer';
+
+export class SoleBusinessLossOffsetRule extends SoleBusinessLossOffsetRuleBase {
+  @Type(() => SoleBusinessLossOffsetRule)
+    parent: SoleBusinessLossOffsetRule;
+}

package/projects/tt-core/src/lib/models/sole/sole-business-loss.ts

@@ -0,0 +1,24 @@
+import { SoleBusinessLoss as SoleBusinessLossBase } from '../../db/Models/sole/sole-business-loss';
+import { SoleBusiness } from './sole-business';
+import { Type } from 'class-transformer';
+import { SoleBusinessLossOffsetRule } from './sole-business-loss-offset-rule';
+import { FinancialYear } from '../financial-year';
+
+/**
+ * If a sole trader business makes a tax loss in a current year, you can generally carry forward that loss and offset profit in future years.
+ * https://taxtank.atlassian.net/wiki/spaces/TAXTANK/pages/4641357930/Rules+when+a+business+makes+a+loss+Tax+Summary#Offsetting-current-year-business-losses
+ */
+export class SoleBusinessLoss extends SoleBusinessLossBase {
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  @Type(() => SoleBusinessLossOffsetRule)
+  offsetRule: SoleBusinessLossOffsetRule;
+
+  openBalance = 0;
+  financialYear: number = new FinancialYear().year;
+
+  get hasOffset(): boolean {
+    return !!this.offsetRule;
+  }
+}

package/projects/tt-core/src/lib/models/sole/sole-business.ts

@@ -0,0 +1,56 @@
+import { SoleBusiness as SoleBusinessBase } from '../../db/Models/sole/sole-business';
+import { User } from '../user';
+import { SoleBusinessAllocation } from './sole-business-allocation';
+import { SoleBusinessLoss } from './sole-business-loss';
+import { SoleInvoice } from './sole-invoice';
+import { SoleInvoiceTemplate } from './sole-invoice-template';
+import { Transform, Type } from 'class-transformer';
+import { VehicleClaim } from '../vehicle';
+import { Depreciation } from '../depreciation';
+import { Transaction } from '../transaction';
+import { SoleBusinessActivity } from '../../db/Models';
+import { IncomeSource } from '../income-source';
+import { AppFile } from '../file';
+
+export class SoleBusiness extends SoleBusinessBase {
+  /**
+   * Maximum number of businesses that a person can have, according to the ATO
+   */
+  static businessesLimit = 6;
+
+  @Type(() => User)
+  user: User;
+
+  @Type(() => SoleBusinessAllocation)
+  allocations: SoleBusinessAllocation[];
+
+  @Type(() => SoleBusinessLoss)
+  losses: SoleBusinessLoss[];
+
+  @Type(() => SoleInvoice)
+  invoices: SoleInvoice[];
+
+  @Type(() => SoleInvoiceTemplate)
+  invoiceTemplates: SoleInvoiceTemplate[];
+
+  @Type(() => VehicleClaim)
+  vehicleClaims: VehicleClaim[];
+
+  @Type(() => Transaction)
+  transactions: Transaction[];
+
+  @Type(() => Depreciation)
+  depreciations: Depreciation[];
+
+  @Type(() => SoleBusinessActivity)
+  activity: SoleBusinessActivity;
+
+  @Type(() => IncomeSource)
+  incomeSource: IncomeSource;
+
+  @Transform(({ value }) => value || false)
+  isPrimaryProduction: boolean;
+
+  @Type(() => AppFile)
+  file: AppFile;
+}

package/projects/tt-core/src/lib/models/sole/sole-contact.ts

@@ -0,0 +1,29 @@
+import { SoleContact as SoleContactBase } from '../../db/Models/sole/sole-contact';
+import { User } from '../user';
+import { Address } from '../address';
+import { Phone } from '../phone/phone';
+import { SoleInvoice } from './sole-invoice';
+import { Type } from 'class-transformer';
+import { AppFile } from '../file';
+
+// @TODO Alex/Vik: Create some base class for User and SoleContact with common methods and properties
+export class SoleContact extends SoleContactBase {
+  @Type(() => User)
+    user: User;
+
+  @Type(() => Phone)
+    phone: Phone;
+
+  @Type(() => Address)
+    address: Address;
+
+  @Type(() => SoleInvoice)
+    invoices: SoleInvoice[];
+
+  @Type(() => AppFile)
+    file: AppFile;
+
+  get fullName(): string {
+    return `${this.firstName} ${this.lastName}`;
+  }
+}

package/projects/tt-core/src/lib/models/sole/sole-depreciation-method.ts

@@ -0,0 +1,8 @@
+import { SoleDepreciationMethod as SoleDepreciationMethodBase } from '../../db/Models/sole/sole-depreciation-method';
+import { SoleDepreciationMethodEnum } from '../../db/Enums';
+
+export class SoleDepreciationMethod extends SoleDepreciationMethodBase {
+  isSBP(): boolean {
+    return this.method === SoleDepreciationMethodEnum.SBP;
+  }
+}

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

@@ -0,0 +1,8 @@
+import { SoleDetails as SoleDetailsBase } from '../../db/Models/sole/sole-details';
+import { User } from '../user';
+import { Type } from 'class-transformer';
+
+export class SoleDetails extends SoleDetailsBase {
+  @Type(() => User)
+  user: User;
+}

package/projects/tt-core/src/lib/models/sole/sole-invoice-item.ts

@@ -0,0 +1,71 @@
+import { SoleInvoiceItem as SoleInvoiceItemBase } from '../../db/Models/sole/sole-invoice-item';
+import { SoleInvoice } from './sole-invoice';
+import { ChartAccounts } from '../chart-accounts';
+import { Type, plainToClass } from 'class-transformer';
+import { Transaction } from '../transaction';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { BusinessChartAccountsEnum, SoleInvoiceTaxTypeEnum } from '../../db/Enums';
+
+export class SoleInvoiceItem extends SoleInvoiceItemBase {
+  static chartAccounts = [
+    BusinessChartAccountsEnum.PSI_ABN_NOT_QUOTED,
+    BusinessChartAccountsEnum.PSI_LABOUR_HIRE_OR_OTHER,
+    BusinessChartAccountsEnum.PSI_VOLUNTARY_AGREEMENT,
+    BusinessChartAccountsEnum.SALES,
+    BusinessChartAccountsEnum.LABOUR,
+    BusinessChartAccountsEnum.UBER_INCOME,
+    BusinessChartAccountsEnum.COMMISSION,
+    BusinessChartAccountsEnum.PARTS_CONSUMABLES,
+    BusinessChartAccountsEnum.OTHER_BUSINESS_INCOME,
+    BusinessChartAccountsEnum.ASSESSIBLE_GOVERNMENT_PAYMENTS,
+    BusinessChartAccountsEnum.GROSS_PAYMENTS_NO_ABN_GIVEN,
+    BusinessChartAccountsEnum.GROSS_PAYMENTS_VOLUNTARY_AGREEMENT,
+    BusinessChartAccountsEnum.GROSS_PAYMENTS_LABOUR_HIRE_OR_OTHER_SPECIFIED_PAYMENTS,
+    BusinessChartAccountsEnum.CONTRACTORS_AND_COMMISSION,
+    BusinessChartAccountsEnum.SUPERANNUATION,
+    BusinessChartAccountsEnum.PSI_OTHER,
+    BusinessChartAccountsEnum.OTHER_ASSESSABLE_PAYMENTS,
+    BusinessChartAccountsEnum.JOBKEEPER,
+    BusinessChartAccountsEnum.GST_REFUND,
+    BusinessChartAccountsEnum.PAYG_INSTALLMENTS,
+    BusinessChartAccountsEnum.INTEREST_EARNED,
+    BusinessChartAccountsEnum.CREDIT_ADJUSTMENT
+  ];
+  @Type(() => SoleInvoice)
+  invoice: SoleInvoice;
+
+  @Type(() => ChartAccounts)
+  chartAccounts: ChartAccounts;
+
+  @Type(() => Transaction)
+  transactions: Transaction[];
+
+  isGST = false;
+
+  get totalPrice(): number {
+    return this.price * this.quantity;
+  }
+
+  getTotalPrice(taxType: SoleInvoiceTaxTypeEnum, includeGST = false): number {
+    const totalPrice = this.totalPrice;
+    if (includeGST) {
+      const coefficient = this.isGST && taxType === SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE ? ChartAccounts.GSTCoefficient : 1;
+      return totalPrice * coefficient;
+    }
+
+    const coefficient = this.isGST && taxType === SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE ? ChartAccounts.GSTCoefficient : 1;
+    return totalPrice / coefficient;
+  }
+
+  toTransaction(): Transaction {
+    return plainToClass(Transaction, {
+      chartAccounts: this.chartAccounts,
+      description: this.description,
+      source: TransactionSourceEnum.BANK_TRANSACTION,
+      isGST: this.isGST,
+      operation: TransactionOperationEnum.ALLOCATE_INVOICE,
+      invoiceItem: this
+    });
+  }
+}

package/projects/tt-core/src/lib/models/sole/sole-invoice-template.ts

@@ -0,0 +1,28 @@
+import { SoleBusiness } from './sole-business';
+import { BankAccount } from '../bank';
+import { SoleInvoiceTemplate as SoleInvoiceTemplateBase } from '../../db/Models/sole/sole-invoice-template';
+import { Type } from 'class-transformer';
+import { SoleInvoiceTemplateTaxTypeEnum } from '../../db/Enums';
+
+export class SoleInvoiceTemplate extends SoleInvoiceTemplateBase {
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  @Type(() => BankAccount)
+  bankAccount: BankAccount;
+
+  /**
+   * Affects to SoleInvoiceItem.isGST flag availability.
+   * When NONE: isGST is unavailable
+   * When EXCLUSIVE: GST amount added additionaly to invoice total price
+   * When INCLUSIVE: GST amount is already included to invoice total price
+   */
+  taxType: SoleInvoiceTemplateTaxTypeEnum = SoleInvoiceTemplateTaxTypeEnum.NO_TAX;
+
+  /**
+   * Get term duration in milliseconds
+   */
+  get termTime(): number {
+    return this.term * 24 * 3600 * 1000;
+  }
+}

package/projects/tt-core/src/lib/models/sole/sole-invoice.ts

@@ -0,0 +1,158 @@
+import { SoleInvoice as SoleInvoiceBase } from '../../db/Models/sole/sole-invoice';
+import { User } from '../user';
+import { SoleBusiness } from './sole-business';
+import { SoleInvoiceItem } from './sole-invoice-item';
+import { SoleContact } from './sole-contact';
+import { Type, plainToClass } from 'class-transformer';
+import { SoleInvoiceStatusesEnum, SoleInvoiceTaxTypeEnum } from '../../db/Enums';
+import { BankAccount, BankTransaction } from '../bank';
+import { SoleInvoiceItemCollection, TransactionCollection } from '../../collections';
+import { Transaction, TransactionAllocation } from '../transaction';
+
+export class SoleInvoice extends SoleInvoiceBase {
+  static numberLength = 4;
+
+  @Type(() => Date)
+  dateFrom: Date;
+
+  @Type(() => Date)
+  dateTo: Date;
+
+  @Type(() => User)
+  user: User;
+
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  @Type(() => SoleInvoiceItem)
+  items: SoleInvoiceItem[];
+
+  @Type(() => SoleContact)
+  payer: SoleContact;
+
+  @Type(() => BankAccount)
+  bankAccount: BankAccount;
+
+  status = SoleInvoiceStatusesEnum.DRAFT;
+  taxType = SoleInvoiceTaxTypeEnum.NO_TAX;
+
+  /**
+   * Get items array as collection
+   */
+  get itemsCollection(): SoleInvoiceItemCollection {
+    return new SoleInvoiceItemCollection(this.items);
+  }
+
+  /**
+   * total without GST
+   */
+  get netPrice(): number {
+    return this.itemsCollection.getTotalPrice(this.taxType);
+  }
+
+  /**
+   * total + GST
+   */
+  get grossPrice(): number {
+    return this.itemsCollection.getTotalPrice(this.taxType, true);
+  }
+
+  get gstAmount(): number {
+    return this.grossPrice - this.netPrice;
+  }
+
+  isDraft(): boolean {
+    return this.status === SoleInvoiceStatusesEnum.DRAFT;
+  }
+
+  isCancelled(): boolean {
+    return this.status === SoleInvoiceStatusesEnum.CANCELED;
+  }
+
+  isOpen(): boolean {
+    return this.status === SoleInvoiceStatusesEnum.OPEN;
+  }
+
+  /**
+   * overdue next day after dateTo
+   */
+  isOverdue(): boolean {
+    return this.isOpen() && this.dateTo < new Date(Date.now() - (60 * 60 * 24 * 1000));
+  }
+
+  getUnpaidAmount(transactions: TransactionCollection): number {
+    return this.grossPrice - transactions.filterBy('invoiceItem.id', this.itemsCollection.getIds()).sumBy('grossAmount');
+  }
+
+  isEditable(): boolean {
+    return this.isDraft() || this.isOpen();
+  }
+
+  /**
+   * GST is not available for invoices without taxes
+   */
+  isNoTax(): boolean {
+    return this.taxType === SoleInvoiceTaxTypeEnum.NO_TAX;
+  }
+
+  /**
+   * GST amount is not included in items prices for invoices with tax exclusive,
+   * we should add GST amount additionaly to subtotal price to get total price
+   */
+  isTaxExclusive(): boolean {
+    return this.taxType === SoleInvoiceTaxTypeEnum.TAX_EXCLUSIVE;
+  }
+
+  /**
+   * GST amount already included in items prices for invoices with tax inclusive,
+   * we should subtract GST amount from total price to get subtotal price
+   */
+  isTaxInclusive(): boolean {
+    return this.taxType === SoleInvoiceTaxTypeEnum.TAX_INCLUSIVE;
+  }
+
+  getNumber(): string {
+    if (!this.number) {
+      return null;
+    }
+
+    return 'N' + String(this.number).padStart(SoleInvoice.numberLength, '0');
+  }
+
+  get name(): string {
+    return `invoice-${this.getNumber()}.pdf`;
+  }
+
+  /**
+   * allocate invoice to bankTransaction = create transactions/allocations for specific amount or full
+   */
+  allocate(bankTransaction: BankTransaction, amount?: number): Transaction[] {
+    // Percent of allocation: When amount is less than invoice unallocated amount then we have to allocate its items proportianally
+    const allocationCoefficient: number = amount ? amount / this.grossPrice : 1;
+
+    return this.items.map((item: SoleInvoiceItem) => {
+      const transaction = plainToClass(Transaction, item.toTransaction());
+      transaction.date = bankTransaction.date;
+      transaction.amount = item.getTotalPrice(this.taxType) * allocationCoefficient;
+      transaction.allocations = [plainToClass(TransactionAllocation, {
+        amount: item.getTotalPrice(this.taxType, true) * allocationCoefficient,
+        bankTransaction: bankTransaction,
+      })];
+
+      return transaction;
+    });
+  }
+
+  createTransactions(date: Date, amount: number): Transaction[] {
+    // Percent of allocation: When amount is less than invoice unallocated amount then we have to allocate its items proportianally
+    const allocationCoefficient: number = amount ? amount / this.grossPrice : 1;
+
+    return this.items.map((item: SoleInvoiceItem) => {
+      const transaction = plainToClass(Transaction, item.toTransaction());
+      transaction.date = date;
+      transaction.amount = item.getTotalPrice(this.taxType) * allocationCoefficient;
+
+      return transaction;
+    });
+  }
+}

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

@@ -0,0 +1,3 @@
+export * from './tax-return';
+export * from './tax-return-category';
+export * from './tax-return-item';

package/projects/tt-core/src/lib/models/tax-return/tax-return-category.ts

@@ -0,0 +1,17 @@
+import { Type } from 'class-transformer';
+import { TaxReturnCategory as TaxReturnCategoryBase } from '../../db/Models';
+import { TaxReturnItem } from './tax-return-item';
+
+export class TaxReturnCategory extends TaxReturnCategoryBase {
+  @Type(() => Date)
+  createdAt?: Date;
+
+  @Type(() => Date)
+  updatedAt?: Date;
+
+  @Type(() => TaxReturnItem)
+  taxReturnItems?: TaxReturnItem[];
+
+  @Type(() => TaxReturnCategory)
+  parent?: TaxReturnCategory;
+}

package/projects/tt-core/src/lib/models/tax-return/tax-return-item.ts

@@ -0,0 +1,39 @@
+import { Type } from 'class-transformer';
+import { TaxReturnItem as TaxReturnItemBase } from '../../db/Models';
+import { TaxReturnCategory } from './tax-return-category';
+import { TaxReturn } from './tax-return';
+import { TaxReturnItemEnum } from '../../db/Enums';
+
+export class TaxReturnItem extends TaxReturnItemBase {
+  // used for business schedule report, the order is important
+  static BUSINESS_SCHEDULE_LIST: number[] = [
+    TaxReturnItemEnum.NO_ABN_GIVEN,
+    TaxReturnItemEnum.VOLUNTARY_AGREEMENT,
+    TaxReturnItemEnum.LABOUR_HIRE_OR_OTHER,
+    TaxReturnItemEnum.OTHER_BUSINESS_INCOME,
+    TaxReturnItemEnum.ASSESSABLE_GOVERNMENT_PAYMENTS,
+    TaxReturnItemEnum.PURCHASES_AND_OTHER_COSTS,
+    TaxReturnItemEnum.COMMISSION_EXPENSES,
+    TaxReturnItemEnum.SUPERANNUATION_EXPENSES,
+    TaxReturnItemEnum.BAD_DEBTS,
+    TaxReturnItemEnum.LEASE_EXPENSES,
+    TaxReturnItemEnum.RENT_EXPENSES,
+    TaxReturnItemEnum.INTEREST_EXPENSES_WITHIN_AUSTRALIA,
+    TaxReturnItemEnum.INTEREST_EXPENSES_OVERSEAS,
+    TaxReturnItemEnum.DEPRECIATION_EXPENSES,
+    TaxReturnItemEnum.MOTOR_VEHICLE_EXPENSES,
+    TaxReturnItemEnum.ALL_OTHER_EXPENSES
+  ];
+
+  @Type(() => Date)
+  createdAt?: Date;
+
+  @Type(() => Date)
+  updatedAt?: Date;
+
+  @Type(() => TaxReturnCategory)
+  taxReturnCategory?: TaxReturnCategory;
+
+  @Type(() => TaxReturn)
+  taxReturns?: TaxReturn[];
+}

package/projects/tt-core/src/lib/models/tax-return/tax-return.ts

@@ -0,0 +1,8 @@
+import { Type } from 'class-transformer';
+import { TaxReturn as TaxReturnBase } from '../../db/Models';
+import { TaxReturnItem } from './tax-return-item';
+
+export class TaxReturn extends TaxReturnBase {
+  @Type(() => TaxReturnItem)
+  taxReturnItems?: TaxReturnItem[];
+}

package/projects/tt-core/src/lib/models/tax-review/tax-review.ts

@@ -0,0 +1,109 @@
+import { TaxReview as TaxReviewBase } from '../../db/Models/firm/accountant/tax-review';
+import { TaxReviewStatusEnum } from '../../db/Enums/tax-review-status.enum';
+import { User } from '../user';
+import { Type } from 'class-transformer';
+import { FirmBranch } from '../firm';
+
+export class TaxReview extends TaxReviewBase {
+  @Type(() => User)
+  client: User;
+
+  @Type(() => User)
+  employee: User;
+
+  status: TaxReviewStatusEnum;
+
+  @Type(() => FirmBranch)
+  firmBranch: FirmBranch;
+
+  /**
+   * if tax review status is 'Cancelled'
+   */
+  isCancelled(): boolean {
+    return this.status === TaxReviewStatusEnum.CANCELLED;
+  }
+
+  /**
+   * if tax review status is 'New'
+   */
+  isNew(): boolean {
+    return this.status === TaxReviewStatusEnum.NEW;
+  }
+
+  /**
+   * if tax review status is 'In progress'
+   */
+  isInProgress(): boolean {
+    return this.status === TaxReviewStatusEnum.IN_PROGRESS;
+  }
+
+  /**
+   * if tax review status is 'Waiting for client'
+   */
+  isWaitingForClient(): boolean {
+    return this.status === TaxReviewStatusEnum.WAITING_FOR_CLIENT;
+  }
+
+  /**
+   * if tax review status is 'Waiting for approval'
+   */
+  isWaitingForApproval(): boolean {
+    return this.status === TaxReviewStatusEnum.WAITING_FOR_APPROVAL;
+  }
+
+  /**
+   * if tax review status is 'Approved'
+   */
+  isApproved(): boolean {
+    return this.status === TaxReviewStatusEnum.APPROVED;
+  }
+
+  /**
+   * if tax review status is 'Completed'
+   */
+  isCompleted(): boolean {
+    return this.status === TaxReviewStatusEnum.COMPLETED;
+  }
+
+  /**
+   * if tax review status is 'Sent'
+   */
+  isSent(): boolean {
+    return this.status === TaxReviewStatusEnum.SENT;
+  }
+
+  /**
+   * if tax review status is 'Amend'
+   */
+  isAmend(): boolean {
+    return this.status === TaxReviewStatusEnum.AMEND;
+  }
+
+  /**
+   * If tax review is inactive
+   */
+  isInactive(): boolean {
+    return this.isCancelled() || this.isCompleted();
+  }
+
+  /**
+   * If tax review is active
+   */
+  isActive(): boolean {
+    return this.isNew() ||
+      this.isInProgress() ||
+      this.isWaitingForClient() ||
+      this.isWaitingForApproval() ||
+      this.isApproved() ||
+      this.isSent() ||
+      this.isAmend();
+  }
+
+  get clientFullName(): string {
+    return this.client.fullName;
+  }
+
+  get employeeFullName(): string {
+    return this.employee.fullName;
+  }
+}

package/projects/tt-core/src/lib/models/tax-summary/report-item-details.ts

@@ -0,0 +1,15 @@
+import { TaxReturnCategorySectionEnum } from '../../db/Enums';
+import { AbstractModel } from '../../db/Models';
+
+/**
+ * Used in tax summary reports to show specific details relating to an amount in the report.
+ * See structure in ReportItem class.
+ * Example an amount of $550 for property income could be comprised of 2 different property amounts of $300 and $250.
+ * This is useful in providing drill-down information for the tax summary report.
+ */
+export class ReportItemDetails extends AbstractModel {
+  amount: number;
+  name: string;
+  type: number;
+  section: TaxReturnCategorySectionEnum;
+}