taxtank-core 0.29.37 → 0.30.1

package/esm2020/lib/models/bank/bank-account.mjs

@@ -0,0 +1,170 @@
+import { __decorate } from "tslib";
+import { BankAccount as BankAccountBase } from '../../db/Models/bank/bank-account';
+import { BankAccountTypeEnum } from '../../db/Enums/bank-account-type.enum';
+import { BankAccountStatusEnum } from '../../db/Enums/bank-account-status.enum';
+import { Loan } from '../loan/loan';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { BankAccountBalance } from '../../db/Models/bank/bank-account-balance';
+import { FinancialYear } from '../financial-year/financial-year';
+import { BankAccountProperty } from './bank-account-property';
+import { BankConnection } from './bank-connection';
+import { Transform, Type } from 'class-transformer';
+import { SoleBusinessAllocation } from '../sole';
+export class BankAccount extends BankAccountBase {
+    get bank() {
+        return this.bankConnection.bank;
+    }
+    get bsb() {
+        return this.accountNumber.slice(0, 6);
+    }
+    get number() {
+        return this.accountNumber.trim().slice(6);
+    }
+    /**
+     * Get last digits of account number
+     */
+    get partialAccountNumber() {
+        return `xxxx${this.accountNumber.slice(-4)}`;
+    }
+    /**
+     * Get current opening balance amount
+     */
+    getOpeningBalance() {
+        return this.getCurrentYearBalance()?.openingBalance || 0;
+    }
+    /**
+     * Get bank account balance for current financial year
+     */
+    getCurrentYearBalance() {
+        const currentFinYear = new FinancialYear().year;
+        return this.balances.find((balance) => balance.financialYear === currentFinYear);
+    }
+    /**
+     * check if bank account type is one of savings accounts
+     */
+    isSavingsAccount() {
+        return this.type === BankAccountTypeEnum.INVESTMENT ||
+            this.type === BankAccountTypeEnum.TERM_DEPOSIT ||
+            this.type === BankAccountTypeEnum.SAVINGS;
+    }
+    /**
+     * check if bank account type is Loan
+     */
+    isLoan() {
+        return this.type === BankAccountTypeEnum.LOAN;
+    }
+    /**
+     * check if bank account type is Credit card
+     */
+    isCreditCard() {
+        return this.type === BankAccountTypeEnum.CREDIT_CARD;
+    }
+    /**
+     * check if bank account related to work tank
+     */
+    isWorkTank() {
+        return !this.isPropertyTank() && !this.isSoleTank();
+    }
+    /**
+     * check if bank account related to work tank
+     */
+    isPropertyTank() {
+        return !!this.bankAccountProperties.length;
+    }
+    /**
+     * check if bank account related to sole tank
+     */
+    isSoleTank() {
+        return !!this.businessAllocations.length;
+    }
+    get tankType() {
+        switch (true) {
+            case this.isPropertyTank():
+                return TankTypeEnum.PROPERTY;
+            case this.isSoleTank():
+                return TankTypeEnum.SOLE;
+            default:
+                return TankTypeEnum.WORK;
+        }
+    }
+    /**
+     * Get Bank account property by id
+     * @param id Id of property
+     */
+    getPropertyById(id) {
+        return this.bankAccountProperties.find((bankAccountProperty) => bankAccountProperty.property.id === id);
+    }
+    /**
+     * check if bank account is related with passed property by id
+     * @param propertyId Property id for checking
+     */
+    hasProperty(propertyId) {
+        return !!this.getPropertyById(propertyId);
+    }
+    /**
+     * Get decimal percentage for property
+     * @param propertyId Id of property
+     */
+    getPropertyPercentage(propertyId) {
+        if (!this.hasProperty(propertyId)) {
+            return 0;
+        }
+        return this.getPropertyById(propertyId).percent / 100;
+    }
+    /**
+     * Get balance amount for property by id
+     * @param propertyId Id of property
+     */
+    getPropertyBalanceAmount(propertyId) {
+        return this.currentBalance * this.getPropertyPercentage(propertyId);
+    }
+    /**
+     * Check if bank account is active (has 'active' status or hasn't been paid out/refinanced)
+     */
+    isActive() {
+        return this.status === BankAccountStatusEnum.ACTIVE;
+    }
+    /**
+     * first import (transactions) of basiq accounts
+     */
+    isFirstImport() {
+        return !this.lastTransactionDate && !this.isManual;
+    }
+    /**
+     * Check if passed user id is owner of bank account
+     */
+    isOwner(userId) {
+        return this.bankConnection.user.id === userId;
+    }
+    /**
+     * Loan is paid if it has no unallocated transactions and the bank balance is $0.
+     */
+    isLoanPaid(taxTankBalance) {
+        const shouldPayoutLoanAccount = this.isActive() && this.isLoan() && taxTankBalance === 0;
+        // we don't check current balance for basiq accounts, because basiq doesn't provide us last transactions (can't do for closed accounts),
+        // that's why balance won't be 0 (updated by basiq)
+        if (shouldPayoutLoanAccount && this.isManual) {
+            return this.currentBalance === 0;
+        }
+        return shouldPayoutLoanAccount;
+    }
+}
+__decorate([
+    Type(() => BankAccountProperty)
+], BankAccount.prototype, "bankAccountProperties", void 0);
+__decorate([
+    Type(() => SoleBusinessAllocation)
+], BankAccount.prototype, "businessAllocations", void 0);
+__decorate([
+    Type(() => BankAccountBalance)
+], BankAccount.prototype, "balances", void 0);
+__decorate([
+    Type(() => Loan)
+], BankAccount.prototype, "loan", void 0);
+__decorate([
+    Type(() => BankConnection)
+], BankAccount.prototype, "bankConnection", void 0);
+__decorate([
+    Transform(({ value }) => value === 4 ? BankAccountTypeEnum.LOAN : value)
+], BankAccount.prototype, "type", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bank-account.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/models/bank/bank-account.ts"],"names":[],"mappings":"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","sourcesContent":["import { BankAccount as BankAccountBase } from '../../db/Models/bank/bank-account';\nimport { BankAccountTypeEnum } from '../../db/Enums/bank-account-type.enum';\nimport { BankAccountStatusEnum } from '../../db/Enums/bank-account-status.enum';\nimport { Loan } from '../loan/loan';\nimport { TankTypeEnum } from '../../db/Enums/tank-type.enum';\nimport { BankAccountBalance } from '../../db/Models/bank/bank-account-balance';\nimport { FinancialYear } from '../financial-year/financial-year';\nimport { BankAccountProperty } from './bank-account-property';\nimport { BankConnection } from './bank-connection';\nimport { Transform, Type } from 'class-transformer';\nimport { SoleBusinessAllocation } from '../sole';\nimport { Bank } from './bank';\n\nexport class BankAccount extends BankAccountBase {\n  // list of properties related with this bank account\n  @Type(() => BankAccountProperty)\n  bankAccountProperties: BankAccountProperty[];\n\n  @Type(() => SoleBusinessAllocation)\n  businessAllocations: SoleBusinessAllocation[]\n\n  @Type(() => BankAccountBalance)\n  balances: BankAccountBalance[];\n\n  // bank account's loan\n  @Type(() => Loan)\n  loan: Loan;\n\n  @Type(() => BankConnection)\n  bankConnection: BankConnection;\n\n  // @TODO Alex: temp hack: remove when TT-2107 ready. Backend shoud return Mortgage type as Loan type\n  @Transform(({value}) => value === 4 ? BankAccountTypeEnum.LOAN : value)\n  type: BankAccountTypeEnum;\n\n  get bank(): Bank {\n    return this.bankConnection.bank;\n  }\n\n  get bsb(): string {\n    return this.accountNumber.slice(0, 6);\n  }\n\n  get number(): string {\n    return this.accountNumber.trim().slice(6);\n  }\n\n  /**\n   * Get last digits of account number\n   */\n  get partialAccountNumber(): string {\n    return `xxxx${this.accountNumber.slice(-4)}`;\n  }\n\n  /**\n   * Get current opening balance amount\n   */\n  getOpeningBalance(): number {\n    return this.getCurrentYearBalance()?.openingBalance || 0;\n  }\n\n  /**\n   * Get bank account balance for current financial year\n   */\n  getCurrentYearBalance(): BankAccountBalance {\n    const currentFinYear: number = new FinancialYear().year;\n    return this.balances.find((balance: BankAccountBalance): boolean => balance.financialYear === currentFinYear);\n  }\n\n  /**\n   * check if bank account type is one of savings accounts\n   */\n  isSavingsAccount(): boolean {\n    return this.type === BankAccountTypeEnum.INVESTMENT ||\n      this.type === BankAccountTypeEnum.TERM_DEPOSIT ||\n      this.type === BankAccountTypeEnum.SAVINGS;\n  }\n\n  /**\n   * check if bank account type is Loan\n   */\n  isLoan(): boolean {\n    return this.type === BankAccountTypeEnum.LOAN;\n  }\n\n  /**\n   * check if bank account type is Credit card\n   */\n  isCreditCard(): boolean {\n    return this.type === BankAccountTypeEnum.CREDIT_CARD;\n  }\n\n  /**\n   * check if bank account related to work tank\n   */\n  isWorkTank(): boolean {\n    return !this.isPropertyTank() && !this.isSoleTank();\n  }\n\n  /**\n   * check if bank account related to work tank\n   */\n  isPropertyTank(): boolean {\n    return !!this.bankAccountProperties.length;\n  }\n\n  /**\n   * check if bank account related to sole tank\n   */\n  isSoleTank(): boolean {\n    return !!this.businessAllocations.length;\n  }\n\n  get tankType(): TankTypeEnum {\n    switch (true) {\n      case this.isPropertyTank():\n        return TankTypeEnum.PROPERTY;\n      case this.isSoleTank():\n        return TankTypeEnum.SOLE;\n      default:\n        return TankTypeEnum.WORK;\n    }\n  }\n\n  /**\n   * Get Bank account property by id\n   * @param id Id of property\n   */\n  getPropertyById(id: number): BankAccountProperty {\n    return this.bankAccountProperties.find((bankAccountProperty: BankAccountProperty): boolean => bankAccountProperty.property.id === id);\n  }\n\n  /**\n   * check if bank account is related with passed property by id\n   * @param propertyId Property id for checking\n   */\n  hasProperty(propertyId: number): boolean {\n    return !!this.getPropertyById(propertyId);\n  }\n\n  /**\n   * Get decimal percentage for property\n   * @param propertyId Id of property\n   */\n  getPropertyPercentage(propertyId: number): number {\n    if (!this.hasProperty(propertyId)) {\n      return 0;\n    }\n\n    return this.getPropertyById(propertyId).percent / 100;\n  }\n\n  /**\n   * Get balance amount for property by id\n   * @param propertyId Id of property\n   */\n  getPropertyBalanceAmount(propertyId: number): number {\n    return this.currentBalance * this.getPropertyPercentage(propertyId);\n  }\n\n  /**\n   * Check if bank account is active (has 'active' status or hasn't been paid out/refinanced)\n   */\n  isActive(): boolean {\n    return this.status === BankAccountStatusEnum.ACTIVE;\n  }\n\n  /**\n   * first import (transactions) of basiq accounts\n   */\n  isFirstImport(): boolean {\n    return !this.lastTransactionDate && !this.isManual;\n  }\n\n  /**\n   * Check if passed user id is owner of bank account\n   */\n  isOwner(userId: number): boolean {\n    return this.bankConnection.user.id === userId;\n  }\n\n  /**\n   * Loan is paid if it has no unallocated transactions and the bank balance is $0.\n   */\n  isLoanPaid(taxTankBalance: number): boolean {\n    const shouldPayoutLoanAccount: boolean = this.isActive() && this.isLoan() && taxTankBalance === 0;\n\n    // we don't check current balance for basiq accounts, because basiq doesn't provide us last transactions (can't do for closed accounts),\n    // that's why balance won't be 0 (updated by basiq)\n    if (shouldPayoutLoanAccount && this.isManual) {\n      return this.currentBalance === 0;\n    }\n\n    return shouldPayoutLoanAccount;\n  }\n}\n"]}

package/esm2020/lib/models/chart-accounts/chart-accounts.mjs

@@ -0,0 +1,213 @@
+import { __decorate } from "tslib";
+import { ChartAccounts as ChartAccountsBase } from '../../db/Models/chart-accounts/chart-accounts';
+import { Type } from 'class-transformer';
+import { ChartAccountsHeading } from './chart-accounts-heading';
+import { ChartAccountsMetadata } from './chart-accounts-metadata';
+import { ChartAccountsListEnum, ChartAccountsCategoryEnum, ChartAccountsHeadingVehicleListEnum, ChartAccountsHeadingTaxableEnum, ChartAccountsHeadingTaxDeductibleEnum, ChartAccountsSalaryIncludedListEnum, ChartAccountsHeadingListEnum } from '../../db/Enums';
+import { CHART_ACCOUNTS_CATEGORIES } from './chart-accounts-categories.const';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+import { FinancialYear } from '../financial-year';
+import { ChartAccountsTaxLabelsEnum } from './chart-accounts-tax-labels.enum';
+import { enumToList } from '../../functions/enum-to-list';
+export class ChartAccounts extends ChartAccountsBase {
+    /**
+     * Return name as string
+     */
+    toString() {
+        return this.name;
+    }
+    /**
+     * Check if chart accounts id is related for 'Kms travelled for work' category
+     */
+    isKmsForWork() {
+        return this.id === ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK;
+    }
+    /**
+     * Check if chart accounts id is related for 'Kms travelled for sole' category
+     */
+    isKmsForSole() {
+        return this.id === ChartAccountsListEnum.KLMS_TRAVELLED;
+    }
+    /**
+     * Check if accounts id is related for KMs category related to passed tank type
+     */
+    isKMsByTankType(tankType) {
+        switch (tankType) {
+            case TankTypeEnum.WORK:
+                return this.isKmsForWork();
+            case TankTypeEnum.SOLE:
+                return this.isKmsForSole();
+            default:
+                return false;
+        }
+    }
+    /**
+     * special type used for just pre-paying tax to the ATO, uses on tax summary
+     */
+    isNRAS() {
+        return this.id === ChartAccountsListEnum.TAX_OFFSETS_N_R_A_S;
+    }
+    /**
+     * Check if chart accounts id is related for 'Interest on Loan' category
+     */
+    isInterestOnLoan() {
+        return this.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+    }
+    /**
+     * Check if chart accounts id is related for 'Motor Vehicles' category
+     */
+    isVehicles() {
+        return this.id === ChartAccountsListEnum.VEHICLES;
+    }
+    /**
+     * Check if chart accounts id is related for 'Interest Earned' category
+     */
+    isInterestEarned() {
+        return this.id === ChartAccountsListEnum.INTEREST_EARNED;
+    }
+    /**
+     * Check if chart accounts id is related for 'Trust Income' category
+     */
+    isTrustIncome() {
+        return this.id === ChartAccountsListEnum.TRUST_INCOME;
+    }
+    /**
+     * Check if chart accounts id is related for 'Motor vehicles (commercial cars)' category
+     */
+    isCommercialVehicles() {
+        return this.id === ChartAccountsListEnum.COMMERCIAL_VEHICLES;
+    }
+    /**
+     * Check if chart accounts is work income
+     */
+    isWorkIncome() {
+        return this.category === ChartAccountsCategoryEnum.WORK_INCOME;
+    }
+    isVehicleExpense() {
+        return !!ChartAccountsHeadingVehicleListEnum[this.heading?.id];
+    }
+    /**
+     * Check if chart accounts is other income
+     */
+    isOtherIncome() {
+        return this.category === ChartAccountsCategoryEnum.OTHER_INCOME;
+    }
+    isIncome() {
+        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.category);
+    }
+    isExpense() {
+        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.category);
+    }
+    isProperty() {
+        return CHART_ACCOUNTS_CATEGORIES.property.includes(this.category);
+    }
+    isWorkExpense() {
+        return [ChartAccountsCategoryEnum.WORK_EXPENSE, ChartAccountsCategoryEnum.OTHER_EXPENSE, ChartAccountsCategoryEnum.WORK_DEPRECIATION]
+            .includes(this.category);
+    }
+    isSoleExpense() {
+        return [ChartAccountsCategoryEnum.SOLE_EXPENSE, ChartAccountsCategoryEnum.SOLE_DEPRECIATION]
+            .includes(this.category);
+    }
+    /**
+     * Check if chart accounts is property expense
+     */
+    isPropertyExpense() {
+        return this.isProperty() && this.isExpense();
+    }
+    /**
+     * Check if chart accounts is property income
+     */
+    isPropertyIncome() {
+        return this.category === ChartAccountsCategoryEnum.PROPERTY_INCOME;
+    }
+    isPersonal() {
+        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.category);
+    }
+    isPersonalExpense() {
+        return this.category === ChartAccountsCategoryEnum.PERSONAL_EXPENSE;
+    }
+    /**
+     * Check if chart accounts category is depreciation
+     */
+    isDepreciation() {
+        return CHART_ACCOUNTS_CATEGORIES.depreciation.includes(this.category);
+    }
+    /**
+     * Check if transaction chart account is work related car expenses
+     */
+    isVehicleLoanExpense() {
+        return this.id === ChartAccountsListEnum.VEHICLE_LOAN_INTEREST || this.id === ChartAccountsListEnum.VEHICLE_LOAN_PRINCIPAL;
+    }
+    /**
+     * Get chart accounts value for current financial year
+     */
+    getCurrentYearValue() {
+        return this.getValueByYear(new FinancialYear().year);
+    }
+    /**
+     * Get chart accounts value by financial year
+     */
+    getValueByYear(year) {
+        return this.values.find((value) => 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 and personal, which is equal to 0
+     */
+    isClaimPercentEditable() {
+        return (this.isWorkExpense() || this.isSoleExpense()) && (!this.isVehicleExpense() && !this.isPersonalExpense());
+    }
+    /**
+     * get label for transaction tax field depended on selected chart account.
+     * tax type depends on chart account heading or category.
+     */
+    getTaxLabel() {
+        // get simple array of ids from enum with taxable chart accounts headings
+        const taxableCAHeadingsIds = enumToList(ChartAccountsHeadingTaxableEnum)
+            .map((item) => item.value);
+        // get simple array of ids from enum with tax-deductible chart accounts headings
+        const deductibleCAHeadingsIds = enumToList(ChartAccountsHeadingTaxDeductibleEnum)
+            .map((item) => 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):
+                return ChartAccountsTaxLabelsEnum.TAX_WITHHELD;
+            default:
+                return null;
+        }
+    }
+    isETP() {
+        return this.heading.id === ChartAccountsHeadingListEnum.ETP;
+    }
+    isSalary() {
+        return this.id === ChartAccountsListEnum.SALARY_OR_WAGES;
+    }
+    /**
+     * chart accounts included in salary, like tips or allowance
+     */
+    isSalaryIncluded() {
+        return this.id in ChartAccountsSalaryIncludedListEnum;
+    }
+    isPropertyCapitalWorks() {
+        return this.category === ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS;
+    }
+}
+/**
+ * Australian GST percent value (VAT)
+ */
+ChartAccounts.GSTRatio = 0.1;
+ChartAccounts.GSTCoefficient = 1.1;
+ChartAccounts.GSTPercent = 10;
+__decorate([
+    Type(() => ChartAccountsHeading)
+], ChartAccounts.prototype, "heading", void 0);
+__decorate([
+    Type(() => ChartAccountsMetadata)
+], ChartAccounts.prototype, "metadata", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chart-accounts.js","sourceRoot":"","sources":["../../../../../../projects/tt-core/src/lib/models/chart-accounts/chart-accounts.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChartAccounts as ChartAccountsBase } from '../../db/Models/chart-accounts/chart-accounts';\r\nimport { Type } from 'class-transformer';\r\nimport { ChartAccountsHeading } from './chart-accounts-heading';\r\nimport { ChartAccountsMetadata } from './chart-accounts-metadata';\r\nimport {\r\n  ChartAccountsListEnum, ChartAccountsCategoryEnum, ChartAccountsHeadingVehicleListEnum,\r\n  ChartAccountsHeadingTaxableEnum, ChartAccountsHeadingTaxDeductibleEnum, ChartAccountsSalaryIncludedListEnum,\r\n  ChartAccountsHeadingListEnum\r\n} from '../../db/Enums';\r\nimport { CHART_ACCOUNTS_CATEGORIES } from './chart-accounts-categories.const';\r\nimport { TankTypeEnum } from '../../db/Enums/tank-type.enum';\r\nimport { FinancialYear } from '../financial-year';\r\nimport { ChartAccountsValue } from './chart-accounts-value';\r\nimport {ChartAccountsTaxLabelsEnum} from './chart-accounts-tax-labels.enum';\r\nimport {enumToList} from '../../functions/enum-to-list';\r\n\r\nexport class ChartAccounts extends ChartAccountsBase {\r\n  /**\r\n   * Australian GST percent value (VAT)\r\n   */\r\n  static GSTRatio = 0.1;\r\n  static GSTCoefficient = 1.1;\r\n  static GSTPercent = 10;\r\n\r\n  @Type(() => ChartAccountsHeading)\r\n  heading: ChartAccountsHeading;\r\n\r\n  @Type(() => ChartAccountsMetadata)\r\n  metadata: ChartAccountsMetadata[];\r\n\r\n  /**\r\n   * Return name as string\r\n   */\r\n  toString(): string {\r\n    return this.name;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Kms travelled for work' category\r\n   */\r\n  isKmsForWork(): boolean {\r\n    return this.id === ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Kms travelled for sole' category\r\n   */\r\n  isKmsForSole(): boolean {\r\n    return this.id === ChartAccountsListEnum.KLMS_TRAVELLED;\r\n  }\r\n\r\n  /**\r\n   * Check if accounts id is related for KMs category related to passed tank type\r\n   */\r\n  isKMsByTankType(tankType: TankTypeEnum): boolean {\r\n    switch (tankType) {\r\n      case TankTypeEnum.WORK:\r\n        return this.isKmsForWork();\r\n      case TankTypeEnum.SOLE:\r\n        return this.isKmsForSole();\r\n      default:\r\n        return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * special type used for just pre-paying tax to the ATO, uses on tax summary\r\n   */\r\n  isNRAS(): boolean {\r\n    return this.id === ChartAccountsListEnum.TAX_OFFSETS_N_R_A_S;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Interest on Loan' category\r\n   */\r\n  isInterestOnLoan(): boolean {\r\n    return this.id === ChartAccountsListEnum.INTEREST_ON_LOAN;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Motor Vehicles' category\r\n   */\r\n  isVehicles(): boolean {\r\n    return this.id === ChartAccountsListEnum.VEHICLES;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Interest Earned' category\r\n   */\r\n  isInterestEarned(): boolean {\r\n    return this.id === ChartAccountsListEnum.INTEREST_EARNED;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Trust Income' category\r\n   */\r\n  isTrustIncome(): boolean {\r\n    return this.id === ChartAccountsListEnum.TRUST_INCOME;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts id is related for 'Motor vehicles (commercial cars)' category\r\n   */\r\n  isCommercialVehicles(): boolean {\r\n    return this.id === ChartAccountsListEnum.COMMERCIAL_VEHICLES;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts is work income\r\n   */\r\n  isWorkIncome(): boolean {\r\n    return this.category === ChartAccountsCategoryEnum.WORK_INCOME;\r\n  }\r\n\r\n  isVehicleExpense(): boolean {\r\n    return !!ChartAccountsHeadingVehicleListEnum[this.heading?.id];\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts is other income\r\n   */\r\n  isOtherIncome(): boolean {\r\n    return this.category === ChartAccountsCategoryEnum.OTHER_INCOME;\r\n  }\r\n\r\n  isIncome(): boolean {\r\n    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.category);\r\n  }\r\n\r\n  isExpense(): boolean {\r\n    return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.category);\r\n  }\r\n\r\n  isProperty(): boolean {\r\n    return CHART_ACCOUNTS_CATEGORIES.property.includes(this.category);\r\n  }\r\n\r\n  isWorkExpense(): boolean {\r\n    return [ChartAccountsCategoryEnum.WORK_EXPENSE, ChartAccountsCategoryEnum.OTHER_EXPENSE, ChartAccountsCategoryEnum.WORK_DEPRECIATION]\r\n      .includes(this.category);\r\n  }\r\n\r\n  isSoleExpense(): boolean {\r\n    return [ChartAccountsCategoryEnum.SOLE_EXPENSE, ChartAccountsCategoryEnum.SOLE_DEPRECIATION]\r\n      .includes(this.category);\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts is property expense\r\n   */\r\n  isPropertyExpense(): boolean {\r\n    return this.isProperty() && this.isExpense();\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts is property income\r\n   */\r\n  isPropertyIncome(): boolean {\r\n    return this.category === ChartAccountsCategoryEnum.PROPERTY_INCOME;\r\n  }\r\n\r\n  isPersonal(): boolean {\r\n    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.category);\r\n  }\r\n\r\n  isPersonalExpense(): boolean {\r\n    return this.category === ChartAccountsCategoryEnum.PERSONAL_EXPENSE;\r\n  }\r\n\r\n  /**\r\n   * Check if chart accounts category is depreciation\r\n   */\r\n  isDepreciation(): boolean {\r\n    return CHART_ACCOUNTS_CATEGORIES.depreciation.includes(this.category);\r\n  }\r\n\r\n  /**\r\n   * Check if transaction chart account is work related car expenses\r\n   */\r\n  isVehicleLoanExpense(): boolean {\r\n    return this.id === ChartAccountsListEnum.VEHICLE_LOAN_INTEREST || this.id === ChartAccountsListEnum.VEHICLE_LOAN_PRINCIPAL;\r\n  }\r\n\r\n  /**\r\n   * Get chart accounts value for current financial year\r\n   */\r\n  getCurrentYearValue(): ChartAccountsValue {\r\n    return this.getValueByYear(new FinancialYear().year);\r\n  }\r\n\r\n  /**\r\n   * Get chart accounts value by financial year\r\n   */\r\n  getValueByYear(year: number): ChartAccountsValue {\r\n    return this.values.find((value: ChartAccountsValue): boolean => value.financialYear === year);\r\n  }\r\n\r\n  /**\r\n   * no way to check how much used for work/sole, so we let user adjust it\r\n   * except vehicle expense, which is equal to vehicleClaim.workUsage and personal, which is equal to 0\r\n   */\r\n  isClaimPercentEditable(): boolean {\r\n    return (this.isWorkExpense() || this.isSoleExpense()) && (!this.isVehicleExpense() && !this.isPersonalExpense());\r\n  }\r\n\r\n  /**\r\n   * get label for transaction tax field depended on selected chart account.\r\n   * tax type depends on chart account heading or category.\r\n   */\r\n  getTaxLabel(): ChartAccountsTaxLabelsEnum {\r\n    // get simple array of ids from enum with taxable chart accounts headings\r\n    const taxableCAHeadingsIds: number[] = enumToList(ChartAccountsHeadingTaxableEnum)\r\n      .map((item: { label: string, value: number }) => item.value);\r\n    // get simple array of ids from enum with tax-deductible chart accounts headings\r\n    const deductibleCAHeadingsIds: number[] = enumToList(ChartAccountsHeadingTaxDeductibleEnum)\r\n      .map((item: { label: string, value: number }) => item.value);\r\n\r\n    // check if one of ids arrays includes current chart accounts heading id and set tax label\r\n    // otherwise label is empty for this class\r\n    switch (true) {\r\n      case taxableCAHeadingsIds.includes(this.heading?.id):\r\n        return ChartAccountsTaxLabelsEnum.TAX_PAID;\r\n      case deductibleCAHeadingsIds.includes(this.heading?.id):\r\n        return ChartAccountsTaxLabelsEnum.TAX_DEDUCTED;\r\n      case CHART_ACCOUNTS_CATEGORIES.workIncome.includes(this.category):\r\n        return ChartAccountsTaxLabelsEnum.TAX_WITHHELD;\r\n      default:\r\n        return null;\r\n    }\r\n  }\r\n\r\n  isETP(): boolean {\r\n    return this.heading.id === ChartAccountsHeadingListEnum.ETP\r\n  }\r\n\r\n  isSalary(): boolean {\r\n    return this.id === ChartAccountsListEnum.SALARY_OR_WAGES;\r\n  }\r\n\r\n  /**\r\n   * chart accounts included in salary, like tips or allowance\r\n   */\r\n  isSalaryIncluded(): boolean {\r\n    return this.id in ChartAccountsSalaryIncludedListEnum;\r\n  }\r\n\r\n  isPropertyCapitalWorks(): boolean {\r\n    return this.category === ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS\r\n  }\r\n}\r\n"]}

package/esm2020/lib/models/client/client-invite.mjs

@@ -0,0 +1,65 @@
+import { __decorate } from "tslib";
+import { ClientInvite as ClientInviteBase } from '../../db/Models/firm/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 {
+    /**
+     * Check if client invite status is pending
+     */
+    isPending() {
+        return this.status === ClientInviteStatusEnum.PENDING;
+    }
+    /**
+     * Check if client invite status is accepted
+     */
+    isAccepted() {
+        return !this.isPending() && !this.isRejected();
+    }
+    /**
+     * Check if client invite status is rejected
+     */
+    isRejected() {
+        return this.status === ClientInviteStatusEnum.REJECTED;
+    }
+    /**
+     * Check if client invite initiated by firm
+     */
+    isFromEmployee() {
+        return this.type === ClientInviteTypeEnum.FROM_EMPLOYEE;
+    }
+    /**
+     * Check if client invite initiated by client
+     */
+    isFromClient() {
+        return this.type === ClientInviteTypeEnum.FROM_CLIENT;
+    }
+    get firstName() {
+        return this.client ? this.client.firstName : this.registrationInvite?.firstName;
+    }
+    get email() {
+        return this.client ? this.client.email : this.registrationInvite?.email;
+    }
+}
+__decorate([
+    Type(() => Date)
+], ClientInvite.prototype, "sentOn", void 0);
+__decorate([
+    Type(() => Date)
+], ClientInvite.prototype, "updatedAt", void 0);
+__decorate([
+    Type(() => Firm)
+], ClientInvite.prototype, "firm", void 0);
+__decorate([
+    Type(() => User)
+], ClientInvite.prototype, "client", void 0);
+__decorate([
+    Type(() => User)
+], ClientInvite.prototype, "employee", void 0);
+__decorate([
+    Type(() => RegistrationInvite)
+], ClientInvite.prototype, "registrationInvite", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LWludml0ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvY2xpZW50L2NsaWVudC1pbnZpdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sRUFBRSxZQUFZLElBQUksZ0JBQWdCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUN0RixPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQztBQUNsRixPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUM5RSxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUNoRixPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFDcEMsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRXpDLE1BQU0sT0FBTyxZQUFhLFNBQVEsZ0JBQWdCO0lBbUJoRDs7T0FFRztJQUNILFNBQVM7UUFDUCxPQUFPLElBQUksQ0FBQyxNQUFNLEtBQUssc0JBQXNCLENBQUMsT0FBTyxDQUFDO0lBQ3hELENBQUM7SUFFRDs7T0FFRztJQUNILFVBQVU7UUFDUixPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO0lBQ2pELENBQUM7SUFFRDs7T0FFRztJQUNILFVBQVU7UUFDUixPQUFPLElBQUksQ0FBQyxNQUFNLEtBQUssc0JBQXNCLENBQUMsUUFBUSxDQUFDO0lBQ3pELENBQUM7SUFFRDs7T0FFRztJQUNILGNBQWM7UUFDWixPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssb0JBQW9CLENBQUMsYUFBYSxDQUFDO0lBQzFELENBQUM7SUFFRDs7T0FFRztJQUNILFlBQVk7UUFDVixPQUFPLElBQUksQ0FBQyxJQUFJLEtBQUssb0JBQW9CLENBQUMsV0FBVyxDQUFDO0lBQ3hELENBQUM7SUFFRCxJQUFJLFNBQVM7UUFDWCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsU0FBUyxDQUFDO0lBQ2xGLENBQUM7SUFFRCxJQUFJLEtBQUs7UUFDUCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsa0JBQWtCLEVBQUUsS0FBSyxDQUFDO0lBQzFFLENBQUM7Q0FDRjtBQTNEQztJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUM7NENBQ0o7QUFHYjtJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUM7K0NBQ0Q7QUFHaEI7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDOzBDQUNOO0FBR1g7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDOzRDQUNKO0FBR2I7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDOzhDQUNGO0FBR2Y7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsa0JBQWtCLENBQUM7d0RBQ1EiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDbGllbnRJbnZpdGUgYXMgQ2xpZW50SW52aXRlQmFzZSB9IGZyb20gJy4uLy4uL2RiL01vZGVscy9maXJtL2NsaWVudC1pbnZpdGUnO1xyXG5pbXBvcnQgeyBDbGllbnRJbnZpdGVTdGF0dXNFbnVtIH0gZnJvbSAnLi4vLi4vZGIvRW51bXMvY2xpZW50LWludml0ZS1zdGF0dXMuZW51bSc7XHJcbmltcG9ydCB7IENsaWVudEludml0ZVR5cGVFbnVtIH0gZnJvbSAnLi4vLi4vZGIvRW51bXMvY2xpZW50LWludml0ZS10eXBlLmVudW0nO1xyXG5pbXBvcnQgeyBSZWdpc3RyYXRpb25JbnZpdGUgfSBmcm9tICcuLi9yZWdpc3RyYXRpb24taW52aXRlL3JlZ2lzdHJhdGlvbi1pbnZpdGUnO1xyXG5pbXBvcnQgeyBGaXJtIH0gZnJvbSAnLi4vZmlybS9maXJtJztcclxuaW1wb3J0IHsgVXNlciB9IGZyb20gJy4uL3VzZXIvdXNlcic7XHJcbmltcG9ydCB7IFR5cGUgfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XHJcblxyXG5leHBvcnQgY2xhc3MgQ2xpZW50SW52aXRlIGV4dGVuZHMgQ2xpZW50SW52aXRlQmFzZSB7XHJcbiAgQFR5cGUoKCkgPT4gRGF0ZSlcclxuICBzZW50T246IERhdGU7XHJcblxyXG4gIEBUeXBlKCgpID0+IERhdGUpXHJcbiAgdXBkYXRlZEF0OiBEYXRlO1xyXG5cclxuICBAVHlwZSgoKSA9PiBGaXJtKVxyXG4gIGZpcm06IEZpcm07XHJcblxyXG4gIEBUeXBlKCgpID0+IFVzZXIpXHJcbiAgY2xpZW50OiBVc2VyO1xyXG5cclxuICBAVHlwZSgoKSA9PiBVc2VyKVxyXG4gIGVtcGxveWVlOiBVc2VyO1xyXG5cclxuICBAVHlwZSgoKSA9PiBSZWdpc3RyYXRpb25JbnZpdGUpXHJcbiAgcmVnaXN0cmF0aW9uSW52aXRlOiBSZWdpc3RyYXRpb25JbnZpdGU7XHJcblxyXG4gIC8qKlxyXG4gICAqIENoZWNrIGlmIGNsaWVudCBpbnZpdGUgc3RhdHVzIGlzIHBlbmRpbmdcclxuICAgKi9cclxuICBpc1BlbmRpbmcoKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdGhpcy5zdGF0dXMgPT09IENsaWVudEludml0ZVN0YXR1c0VudW0uUEVORElORztcclxuICB9XHJcblxyXG4gIC8qKlxyXG4gICAqIENoZWNrIGlmIGNsaWVudCBpbnZpdGUgc3RhdHVzIGlzIGFjY2VwdGVkXHJcbiAgICovXHJcbiAgaXNBY2NlcHRlZCgpOiBib29sZWFuIHtcclxuICAgIHJldHVybiAhdGhpcy5pc1BlbmRpbmcoKSAmJiAhdGhpcy5pc1JlamVjdGVkKCk7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBDaGVjayBpZiBjbGllbnQgaW52aXRlIHN0YXR1cyBpcyByZWplY3RlZFxyXG4gICAqL1xyXG4gIGlzUmVqZWN0ZWQoKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdGhpcy5zdGF0dXMgPT09IENsaWVudEludml0ZVN0YXR1c0VudW0uUkVKRUNURUQ7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBDaGVjayBpZiBjbGllbnQgaW52aXRlIGluaXRpYXRlZCBieSBmaXJtXHJcbiAgICovXHJcbiAgaXNGcm9tRW1wbG95ZWUoKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdGhpcy50eXBlID09PSBDbGllbnRJbnZpdGVUeXBlRW51bS5GUk9NX0VNUExPWUVFO1xyXG4gIH1cclxuXHJcbiAgLyoqXHJcbiAgICogQ2hlY2sgaWYgY2xpZW50IGludml0ZSBpbml0aWF0ZWQgYnkgY2xpZW50XHJcbiAgICovXHJcbiAgaXNGcm9tQ2xpZW50KCk6IGJvb2xlYW4ge1xyXG4gICAgcmV0dXJuIHRoaXMudHlwZSA9PT0gQ2xpZW50SW52aXRlVHlwZUVudW0uRlJPTV9DTElFTlQ7XHJcbiAgfVxyXG5cclxuICBnZXQgZmlyc3ROYW1lKCk6IHN0cmluZyB7XHJcbiAgICByZXR1cm4gdGhpcy5jbGllbnQgPyB0aGlzLmNsaWVudC5maXJzdE5hbWUgOiB0aGlzLnJlZ2lzdHJhdGlvbkludml0ZT8uZmlyc3ROYW1lO1xyXG4gIH1cclxuXHJcbiAgZ2V0IGVtYWlsKCk6IHN0cmluZyB7XHJcbiAgICByZXR1cm4gdGhpcy5jbGllbnQgPyB0aGlzLmNsaWVudC5lbWFpbCA6IHRoaXMucmVnaXN0cmF0aW9uSW52aXRlPy5lbWFpbDtcclxuICB9XHJcbn1cclxuIl19