taxtank-core 0.0.1 → 0.1.1

package/src/lib/collections/tax-return-category-item.collection.ts

@@ -0,0 +1,148 @@
+import { AbstractCollection } from './abstract.collection';
+import { TaxReturnCategoryItem } from '../models/tax-summary/tax-return-category-item';
+import { TaxReturnCategoryListEnum } from '../db/Enums/tax-return-category-list.enum';
+import { TaxReturnCategorySectionEnum } from '../db/Enums/tax-return-category-section.enum';
+import { TaxReturnCategoryItemDetails } from '../models/tax-summary/tax-return-category-item-details';
+
+/**
+ * collection for tax return category items
+ */
+export class TaxReturnCategoryItemCollection extends AbstractCollection<TaxReturnCategoryItem> {
+  /**
+   * Work income
+   */
+  get salary(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.SALARY)?.amount || 0;
+  }
+
+  /**
+   * Work expenses
+   */
+  get workExpenses(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.WORK_EXPENSES)?.amount || 0;
+  }
+
+  /**
+   * Property income
+   */
+  get rentalIncome(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.GROSS_RENT)?.amount || 0;
+  }
+
+  /**
+   * Property rental deductions
+   */
+  get rentalDeductions(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.OTHER_RENTAL_DEDUCTIONS)?.amount || 0;
+  }
+
+  /**
+   * Property expenses
+   */
+  get propertyExpenses(): number {
+    return this.rentalDeductions + this.borrowingExpenses;
+  }
+
+  /**
+   * Property interest
+   */
+  get interestDeductions(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.INTEREST_DEDUCTIONS)?.amount || 0;
+  }
+
+  /**
+   * Property capital works depreciations
+   */
+  get capitalWorks(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.CAPITAL_WORKS)?.amount || 0;
+  }
+
+  /**
+   * Property plant & equipment depreciations
+   */
+  get plantEquipment(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.DEPRECIATION)?.amount || 0;
+  }
+
+  /**
+   * Total property depreciaions
+   */
+  get propertyDepreciations(): number {
+    return this.capitalWorks + this.plantEquipment;
+  }
+
+  get partnershipsAndTrusts(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.PARTNERSHIPS_TRUSTS)?.amount || 0;
+  }
+
+  get pciAndSbeIncome(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.PCI_SBE_INCOME)?.amount || 0;
+  }
+
+  get capitalGains(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.CAPITAL_GAINS)?.amount || 0;
+  }
+
+  get foreignSourceIncome(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.FOREIGN_SOURCE_INCOME)?.amount || 0;
+  }
+
+  /**
+   * Other income
+   */
+  get otherIncome(): number {
+    return (this.getByCategory(TaxReturnCategoryListEnum.OTHER_INCOME)?.amount || 0) +
+      this.partnershipsAndTrusts +
+      this.pciAndSbeIncome +
+      this.capitalGains +
+      this.foreignSourceIncome;
+  }
+
+  /**
+   * Other expenses
+   */
+  get otherDeductions(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.OTHER_DEDUCTIONS)?.amount || 0;
+  }
+
+  get taxInstalments(): number {
+    return this.getTaxCreditsCollection().getByCategory(TaxReturnCategoryListEnum.TAX_INSTALMENTS)?.amount || 0;
+  }
+
+  get frankingCredits(): number {
+    return this.getTaxCreditsCollection().getByCategory(TaxReturnCategoryListEnum.FRANKING_CREDITS)?.amount || 0;
+  }
+
+  get taxOffsets(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.TAX_OFFSETS)?.amount || 0;
+  }
+
+  get borrowingExpenses(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.BORROWING_EXPENSES)?.amount || 0;
+  }
+
+  get grossTaxPayable(): number {
+    return this.getByCategory(TaxReturnCategoryListEnum.GROSS_TAX_PAYABLE)?.amount || 0;
+  }
+
+  /**
+   * taxWithheld by section (work or other)
+   */
+  getTaxWithheld(section: TaxReturnCategorySectionEnum = TaxReturnCategorySectionEnum.WORK_TANK): number {
+    return this.getTaxCreditsCollection().getByCategory(TaxReturnCategoryListEnum.TAX_WITHHELD)?.details
+      .filter((details: TaxReturnCategoryItemDetails) => details.section === section)
+      .reduce((sum: number, details: TaxReturnCategoryItemDetails): number => sum + details.amount, 0) || 0;
+  }
+
+  getTaxCreditsCollection(): TaxReturnCategoryItemCollection {
+    return new TaxReturnCategoryItemCollection(this.getByCategory(TaxReturnCategoryListEnum.TAX_CREDITS)?.items || []);
+  }
+
+  getTotalAmountByIncomeSourceName(name: string): number {
+    return this.items.reduce(((sum: number, item: TaxReturnCategoryItem): number => sum + item.getAmountByIncomeSourceName(name)), 0);
+  }
+
+  private getByCategory(category: TaxReturnCategoryListEnum): TaxReturnCategoryItem {
+    return this.items.find((item: TaxReturnCategoryItem): boolean => item.taxReturnCategory.id === category);
+  }
+}

package/src/lib/collections/tax-review.collection.ts

@@ -0,0 +1,64 @@
+import { AbstractCollection } from './abstract.collection';
+import { TaxReview } from '../models/tax-review/tax-review';
+import { TaxReviewStatusEnum } from '../db/Enums/tax-review-status.enum';
+import { User } from '../models/user/user';
+import uniqBy from 'lodash/uniqBy'
+
+/**
+ * Collection of tax review
+ */
+export class TaxReviewCollection extends AbstractCollection<TaxReview> {
+  /**
+   * Get tax reviews items with SENT & COMPLETED statuses
+   */
+  getCompleted(): TaxReview[] {
+    return this.items
+      .filter((taxReview: TaxReview) => taxReview.isSent() || taxReview.isCompleted());
+  }
+
+  /**
+   * Get tax reviews items with WAITING_FOR_APPROVAL status
+   */
+  getReadyForReview(): TaxReview[] {
+    return this.items.filter((taxReview: TaxReview) => taxReview.isNew());
+  }
+
+  /**
+   * Get tax reviews items in work (In progress, Waiting for client, Waiting for Approval, Is approved)
+   */
+  getInWork(): TaxReview[] {
+    return this.items
+      .filter((taxReview: TaxReview) => {
+        return taxReview.isInProgress() ||
+          taxReview.isWaitingForClient() ||
+          taxReview.isWaitingForApproval() ||
+          taxReview.isApproved();
+      });
+  }
+
+  /**
+   * Get percentage of completed reviews of the total review amount
+   */
+  getCompletedPercentage(): number {
+    return 100 * this.getCompleted().length / this.items.length || 0;
+  }
+
+  /**
+   * get list of items filtered by status
+   * @param status
+   */
+  getByStatus(status: TaxReviewStatusEnum): TaxReview[] {
+    return this.items.filter((item: TaxReview): boolean => item.status === status);
+  }
+
+  /**
+   * get list of items by firm id
+   */
+  getByEmployeeId(employeeId: number): TaxReview[] {
+    return this.items.filter((item: TaxReview): boolean => item.employee.id === employeeId);
+  }
+
+  getEmployees(): User[] {
+    return uniqBy(this.items.map((review: TaxReview): User => review.employee), 'id');
+  }
+}

package/src/lib/collections/transaction-allocation.collection.ts

@@ -0,0 +1,54 @@
+import { AbstractCollection } from './abstract.collection';
+import { TransactionAllocation } from '../models/transaction/transaction-allocation';
+import { BankTransactionCollection } from './bank-transaction.collection';
+import { CollectionDictionary } from './collection-dictionary';
+import { Transaction } from '../models/transaction/transaction';
+import { BankTransaction } from '../models/bank/bank-transaction';
+
+
+export class TransactionAllocationCollection extends AbstractCollection<TransactionAllocation> {
+  get amount(): number {
+    return this.sumBy('amount');
+  }
+
+  getByTransactionsIds(ids: number[]): TransactionAllocationCollection {
+    return new TransactionAllocationCollection(
+      this.items.filter((allocation: TransactionAllocation): boolean => ids.includes(allocation.transaction.id))
+    );
+  }
+
+  getByBankTransactionsIds(ids: number[]): TransactionAllocationCollection {
+    return new TransactionAllocationCollection(
+      this.items.filter((allocation: TransactionAllocation): boolean => ids.includes(allocation.bankTransaction.id))
+    );
+  }
+
+  /**
+   * Group allocations by bank account via bank transactions collection
+   */
+  groupByBankAccount(bankTransactions: BankTransactionCollection): CollectionDictionary<TransactionAllocationCollection> {
+    // Group bank transactions by bank account id
+    const bankTransactionsByBankAccount: CollectionDictionary<BankTransactionCollection> = new CollectionDictionary(bankTransactions, 'bankAccount');
+    // Create empty dictionary of transaction allocations
+    const allocationsByBankAccount: CollectionDictionary<TransactionAllocationCollection> = new CollectionDictionary(new TransactionAllocationCollection([]));
+    // Fill allocations dictionary with bank transactions dictionary keys and allocations related with each bank transaction collection
+    bankTransactionsByBankAccount.keys.forEach((key: string): void => {
+      allocationsByBankAccount.add(key, this.getByBankTransactionsIds(bankTransactionsByBankAccount.get(key).getIds()));
+    });
+    return allocationsByBankAccount;
+  }
+
+  /**
+   * check if collection includes allocation of passed transaction
+   */
+  hasTransaction(transaction: Transaction): boolean {
+    return !!this.items.find((allocation: TransactionAllocation): boolean => allocation.transaction.id === transaction.id);
+  }
+
+  /**
+   * Check if bank transaction is related with current allocations
+   */
+  hasBankTransaction(bankTransaction: BankTransaction): boolean {
+    return !!this.items.find((allocation: TransactionAllocation): boolean => allocation.bankTransaction.id === bankTransaction.id);
+  }
+}

package/src/lib/collections/transaction.collection.ts

@@ -0,0 +1,170 @@
+import { AbstractCollection } from './abstract.collection';
+import { Transaction } from '../models/transaction/transaction';
+import { TransactionAllocationCollection } from './transaction-allocation.collection';
+import { TankTypeEnum } from '../db/Enums/tank-type.enum';
+import { ChartAccountsCategoryEnum } from '../db/Enums/chart-accounts-category.enum';
+
+/**
+ * Collection of transactions
+ */
+export class TransactionCollection extends AbstractCollection<Transaction> {
+  /**
+   * Get total amount of all transactions in the collection
+   */
+  get amount(): number {
+    return +this.items.reduce((sum: number, transaction: Transaction) => sum + transaction.getNetAmount(), 0).toFixed(2);
+  }
+
+  /**
+   * Difference between allocated amount and total amount
+   */
+  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {
+    return +(this.amount - allocations.getByTransactionsIds(this.getIds()).amount).toFixed(2);
+  }
+
+  /**
+   * Get cash position
+   * Cash Position = Income - Expenses
+   * Cash position is equal to Total Amount because income is positive and expense is negative,
+   */
+  get cashPosition(): number {
+    return this.claimAmount;
+  }
+
+  /**
+   * Get new collection of transactions filtered by tank type
+   * @param tankType
+   */
+  getByTankType(tankType: TankTypeEnum): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.tankType === tankType)
+    );
+  }
+
+  /**
+   * get date of the last transaction
+   */
+  getLastTransactionDate(): Date {
+    return new Date(Math.max.apply(Math, this.items.map((transaction: Transaction) => transaction.date)));
+  }
+
+  /**
+   * Get summary of claim amounts
+   */
+  get claimAmount(): number {
+    return this.items.reduce((sum: number, transaction: Transaction) => sum + transaction.claimAmount, 0);
+  }
+
+  getByCategories(categories: ChartAccountsCategoryEnum[]): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => categories.includes(transaction.chartAccounts.category))
+    );
+  }
+
+  /**
+   * Get transactions by month
+   * @param monthIndex by which desired month should be taken
+   */
+  getByMonth(monthIndex: number): TransactionCollection {
+    return new TransactionCollection(this.items.filter((transaction: Transaction): boolean =>
+      transaction.date.getMonth() === monthIndex
+    ));
+  }
+
+  /**
+   * get list of transactions filtered by chart accounts id
+   * @param chartAccountsId chart accounts id for filtering
+   */
+  getByChartAccountsId(chartAccountsId: number): Transaction[] {
+    return this.items.filter((transaction: Transaction): boolean => transaction.chartAccounts.id === chartAccountsId);
+  }
+
+  getIncomeTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isIncome())
+    );
+  }
+
+  get claimIncome(): number {
+    return this.getIncomeTransactions().claimAmount;
+  }
+
+  getExpenseTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isExpense() && !transaction.isInterest())
+    );
+  }
+
+  get claimExpense(): number {
+    return this.getExpenseTransactions().claimAmount;
+  }
+
+  getInterestTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isInterest())
+    );
+  }
+
+  get claimInterest(): number {
+    return this.getInterestTransactions().claimAmount;
+  }
+
+  /**
+   * Get collection of transactions and properties filtered by properties ids
+   * @param ids Ids of properties for filter
+   */
+  getByPropertiesIds(ids: number[]): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => {
+        return ids.includes(transaction.property?.id);
+      })
+    );
+  }
+
+  /**
+   * Get new collection filtered by income source id
+   * @param id id of income source for filter
+   */
+  getByIncomeSourceId(id: number): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.incomeSource?.id === id)
+    );
+  }
+
+  /**
+   * Get new collection filtered by chart accounts category
+   * @param category Chart accounts category value
+   */
+  getByChartAccountsCategory(category: ChartAccountsCategoryEnum): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.chartAccounts.category === category)
+    );
+  }
+
+  /**
+   * Get new collection of property transactions
+   */
+  getPropertyTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isPropertyTank())
+    );
+  }
+
+  getDebitTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isDebit())
+    );
+  }
+
+  getCreditTransactions(): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => transaction.isCredit())
+    );
+  }
+
+  getByAllocations(allocations: TransactionAllocationCollection): TransactionCollection {
+    return new TransactionCollection(
+      this.items.filter((transaction: Transaction): boolean => allocations.hasTransaction(transaction))
+    );
+  }
+}

package/src/lib/collections/user-event-setting.collection.ts

@@ -0,0 +1,70 @@
+import { AbstractCollection } from './abstract.collection';
+import { UserEventSetting } from '../models/user-event/user-event-setting';
+import { UserEventType } from '../models/user-event/user-event-type';
+import { UserEventTypeFrequencyEnum } from '../db/Enums/user-event-type-frequency.enum';
+import { CollectionDictionary } from './collection-dictionary';
+import { plainToClass } from 'class-transformer';
+
+/**
+ * Collection of user event settings
+ */
+export class UserEventSettingCollection extends AbstractCollection<UserEventSetting> {
+  constructor(items: UserEventSetting[], userEventTypes: UserEventType[]) {
+    super(items);
+    this.setItems(userEventTypes);
+  }
+
+  /**
+   * Flag that indicates if all settings are selected for provided field
+   */
+  isAllSelected(field: string): boolean {
+    return !this.items.find((item: UserEventSetting) => !item[field]);
+  }
+
+  /**
+   * Flag that indicates if all settings are deselected for provided field
+   */
+  isAllDeselected(field: string): boolean {
+    return !this.items.find((item: UserEventSetting) => item[field]);
+  }
+
+  /**
+   * Check is any setting is updating by 'isUpdating' flag
+   */
+  isAnyUpdating(): boolean {
+    return this.items.some((item: UserEventSetting) => item.isUpdating);
+  }
+
+  /**
+   * Get frequency type based on each collection item 'frequency' field value
+   */
+  get commonFrequencyType(): UserEventTypeFrequencyEnum | false {
+    const frequencyDictionary: CollectionDictionary<UserEventSettingCollection> = new CollectionDictionary(this, '', 'frequency');
+    return +Object.keys(frequencyDictionary).find((key: string): boolean => frequencyDictionary[key].length === this.length) || false;
+  }
+
+  /**
+   * Rewrite collection items with provided user event types
+   */
+  private setItems(userEventTypes: UserEventType[]): void {
+    if (!userEventTypes) {
+      return;
+    }
+
+    this.items = userEventTypes.map((userEventType: UserEventType): UserEventSetting => {
+      // find existing setting by user event type id
+      const existingSetting: UserEventSetting = this.items.find((setting: UserEventSetting) => setting.userEventType.id === userEventType.id);
+      // if setting exist - return new UserEventSetting instance based on existing setting and default user event type
+      if (existingSetting) {
+        return plainToClass(UserEventSetting, Object.assign(existingSetting, {userEventType}));
+      }
+      // ...or return new UserEventSetting instance based on default user event type
+      return plainToClass(UserEventSetting, {
+        byEmail: userEventType.byEmail,
+        byNotification: userEventType.byNotification,
+        frequency: userEventType.frequency,
+        userEventType
+      });
+    });
+  }
+}

package/src/lib/db/Enums/address-type.enum.ts

@@ -0,0 +1,4 @@
+export enum AddressTypeEnum {
+	STREET = 1,
+	POSTAL = 2,
+}

package/src/lib/db/Enums/bank-account-status.enum.ts

@@ -0,0 +1,4 @@
+export enum BankAccountStatusEnum {
+	INACTIVE = 0,
+	ACTIVE = 1,
+}

package/src/lib/db/Enums/bank-account-type.enum.ts

@@ -0,0 +1,10 @@
+export enum BankAccountTypeEnum {
+  TRANSACTION = 1,
+  SAVINGS = 2,
+  CREDIT_CARD = 3,
+  MORTGAGE = 4,
+  LOAN = 5,
+  INVESTMENT = 6,
+  TERM_DEPOSIT = 7,
+  OFFSET = 10,
+}

package/src/lib/db/Enums/bank-connection-status.enum.ts

@@ -0,0 +1,5 @@
+export enum BankConnectionStatusEnum {
+	PENDING = 1,
+	ACTIVE = 2,
+	INVALID = 3,
+}

package/src/lib/db/Enums/bank-transaction-type.enum.ts

@@ -0,0 +1,4 @@
+export enum BankTransactionTypeEnum {
+	DEBIT = 1,
+	CREDIT = 2,
+}

package/src/lib/db/Enums/chart-accounts-category.enum.ts

@@ -0,0 +1,13 @@
+export enum ChartAccountsCategoryEnum {
+	PROPERTY_INCOME = 1,
+	PROPERTY_EXPENSE = 2,
+	PROPERTY_DEPRECIATION = 3,
+	PROPERTY_CAPITAL_WORKS = 4,
+	WORK_DEPRECIATION = 5,
+	WORK_INCOME = 6,
+	WORK_EXPENSE = 7,
+	OTHER_INCOME = 8,
+	OTHER_EXPENSE = 9,
+	PERSONAL_INCOME = 10,
+	PERSONAL_EXPENSE = 11,
+}

package/src/lib/db/Enums/chart-accounts-etp.enum.ts

@@ -0,0 +1,7 @@
+export enum ChartAccountsEtpEnum {
+	ETP_R = 549,
+	ETP_S = 550,
+	ETP_O = 551,
+	ETP_D = 552,
+	ETP_B = 553,
+}

package/src/lib/db/Enums/chart-accounts-heading-tax-deductible.enum.ts

@@ -0,0 +1,6 @@
+export enum ChartAccountsHeadingTaxDeductibleEnum {
+	ALLOWANCES_AND_PAYMENTS = 4,
+	PENSIONS_AND_ALLOWANCES = 5,
+	ANNUITIES_AND_SUPERANNUATION_INCOME_STREAMS = 40,
+	SUPERANNUATION_LUMP_SUM = 41,
+}

package/src/lib/db/Enums/chart-accounts-heading-taxable.enum.ts

@@ -0,0 +1,6 @@
+export enum ChartAccountsHeadingTaxableEnum {
+	GROSS_INTEREST = 7,
+	DIVIDENDS = 38,
+	EMPLOYEE_SHARE_SCHEMES = 42,
+	PARTNERSHIPS_AND_TRUSTS_INCOME = 43,
+}

package/src/lib/db/Enums/chart-accounts-heading-vehicle-list.enum.ts

@@ -0,0 +1,4 @@
+export enum ChartAccountsHeadingVehicleListEnum {
+	WORK_RELATED_CAR_EXPENSES = 8,
+	DEPRECIATION_VEHICLES = 9,
+}

package/src/lib/db/Enums/chart-accounts-list.enum.ts

@@ -0,0 +1,19 @@
+export enum ChartAccountsListEnum {
+	INTEREST_ON_LOAN = 302,
+	BORROWING_EXPENSES = 315,
+	DIVIDENDS = 542,
+	TRANSFER = 615,
+	BUILDING_AT_COST = 304,
+	MANAGEMENT_FEES_PLATFORM_FEES = 656,
+	KLMS_TRAVELLED_FOR_WORK = 24,
+	DIRECTOR_FEES = 6,
+	SALARY_OR_WAGES = 2,
+	VEHICLES = 25,
+	COMMERCIAL_VEHICLES = 26,
+	TAX_INSTALMENTS = 662,
+	INTEREST_EARNED = 22,
+	TRUST_INCOME = 567,
+	TAX_OFFSETS_N_R_A_S = 571,
+  VEHICLE_LOAN_INTEREST = 37,
+  VEHICLE_LOAN_PRINCIPAL = 38,
+}

package/src/lib/db/Enums/chart-accounts-metadata-list.enum.ts

@@ -0,0 +1,14 @@
+export enum ChartAccountsMetadataListEnum {
+	TAX_INSTALMENTS = 4,
+	FRANKING_CREDIT = 5,
+	SHARE_PERCENTAGE = 7,
+	TAX_OFFSETS = 8,
+  HOURS = 11,
+	TAX_PAID = 13,
+	REDUNDANCY = 17,
+	NON_REDUNDANCY = 18,
+	YEARS_OF_SERVICE = 19,
+	UNTAXED_ELEMENT = 24,
+	FRANKED = 26,
+	TAX_OFFSETS_N_R_A_S = 29,
+}

package/src/lib/db/Enums/chart-accounts-metadata-type.enum.ts

@@ -0,0 +1,4 @@
+export enum ChartAccountsMetadataTypeEnum {
+	NUMBER = 3,
+	BOOLEAN = 4,
+}

package/src/lib/db/Enums/chart-accounts-type.enum.ts

@@ -0,0 +1,4 @@
+export enum ChartAccountsTypeEnum {
+	INCOME = 1,
+	EXPENSE = 2,
+}

package/src/lib/db/Enums/chat-status.enum.ts

@@ -0,0 +1,4 @@
+export enum ChatStatusEnum {
+	ACTIVE = 1,
+	INACTIVE = 2,
+}

package/src/lib/db/Enums/client-details-medicare-exemption.enum.ts

@@ -0,0 +1,5 @@
+export enum ClientDetailsMedicareExemptionEnum {
+	NO = 0,
+	HALF = 1,
+	FULL = 2,
+}

package/src/lib/db/Enums/client-details-work-depreciation-calculation.enum.ts

@@ -0,0 +1,4 @@
+export enum ClientDetailsWorkDepreciationCalculationEnum {
+	PRIME_COST = 1,
+	DIMINISHING = 2,
+}

package/src/lib/db/Enums/client-details-working-holiday-maker.enum.ts

@@ -0,0 +1,5 @@
+export enum ClientDetailsWorkingHolidayMakerEnum {
+	NO = 0,
+	VISA417 = 1,
+	VISA462 = 2,
+}

package/src/lib/db/Enums/client-invite-status.enum.ts

@@ -0,0 +1,4 @@
+export enum ClientInviteStatusEnum {
+	PENDING = 1,
+	REJECTED = 2,
+}

package/src/lib/db/Enums/client-invite-type.enum.ts

@@ -0,0 +1,4 @@
+export enum ClientInviteTypeEnum {
+  FROM_CLIENT = 1,
+  FROM_EMPLOYEE = 2,
+}

package/src/lib/db/Enums/depreciation-calculation-percent.enum.ts

@@ -0,0 +1,7 @@
+export enum DepreciationCalculationPercentEnum {
+	PRIME_COST = 100,
+	DIMINISHING = 200,
+	CAPITAL = 2.5,
+	LVP = 37.5,
+	LVP_FIRST = 18.75,
+}