taxtank-core 0.32.88 → 0.33.1

package/esm2022/src/lib/models/transaction/transaction-meta-field.mjs

@@ -0,0 +1,17 @@
+import { __decorate } from "tslib";
+import { TransactionMetaField as TransactionMetaFieldBase } from '../../db/Models/transaction/transaction-meta-field';
+import { Type } from 'class-transformer';
+import { ChartAccountsMetaField } from '../chart-accounts';
+import { Transaction } from '../../db/Models';
+export class TransactionMetaField extends TransactionMetaFieldBase {
+}
+__decorate([
+    Type(() => ChartAccountsMetaField)
+], TransactionMetaField.prototype, "metaField", void 0);
+__decorate([
+    Type(() => Transaction)
+], TransactionMetaField.prototype, "transaction", void 0);
+__decorate([
+    Type(() => ChartAccountsMetaField)
+], TransactionMetaField.prototype, "chartAccountsMetaField", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24tbWV0YS1maWVsZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdHJhbnNhY3Rpb24vdHJhbnNhY3Rpb24tbWV0YS1maWVsZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLG9CQUFvQixJQUFJLHdCQUF3QixFQUFFLE1BQU0sb0RBQW9ELENBQUM7QUFDdEgsT0FBTyxFQUFFLElBQUksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3pDLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzNELE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUU1QyxNQUFNLE9BQU8sb0JBQXFCLFNBQVEsd0JBQXdCO0NBT2pFO0FBTEM7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsc0JBQXNCLENBQUM7dURBQ0Q7QUFFbEM7SUFEQyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUMsV0FBVyxDQUFDO3lEQUNDO0FBRXpCO0lBREMsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDLHNCQUFzQixDQUFDO29FQUNZIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVHJhbnNhY3Rpb25NZXRhRmllbGQgYXMgVHJhbnNhY3Rpb25NZXRhRmllbGRCYXNlIH0gZnJvbSAnLi4vLi4vZGIvTW9kZWxzL3RyYW5zYWN0aW9uL3RyYW5zYWN0aW9uLW1ldGEtZmllbGQnO1xuaW1wb3J0IHsgVHlwZSB9IGZyb20gJ2NsYXNzLXRyYW5zZm9ybWVyJztcbmltcG9ydCB7IENoYXJ0QWNjb3VudHNNZXRhRmllbGQgfSBmcm9tICcuLi9jaGFydC1hY2NvdW50cyc7XG5pbXBvcnQge1RyYW5zYWN0aW9ufSBmcm9tICcuLi8uLi9kYi9Nb2RlbHMnO1xuXG5leHBvcnQgY2xhc3MgVHJhbnNhY3Rpb25NZXRhRmllbGQgZXh0ZW5kcyBUcmFuc2FjdGlvbk1ldGFGaWVsZEJhc2Uge1xuICBAVHlwZSgoKSA9PiBDaGFydEFjY291bnRzTWV0YUZpZWxkKVxuICBtZXRhRmllbGQ6IENoYXJ0QWNjb3VudHNNZXRhRmllbGQ7XG4gIEBUeXBlKCgpID0+IFRyYW5zYWN0aW9uKVxuICB0cmFuc2FjdGlvbjogVHJhbnNhY3Rpb247XG4gIEBUeXBlKCgpID0+IENoYXJ0QWNjb3VudHNNZXRhRmllbGQpXG4gIGNoYXJ0QWNjb3VudHNNZXRhRmllbGQ6IENoYXJ0QWNjb3VudHNNZXRhRmllbGQ7XG59XG4iXX0=

package/esm2022/src/lib/models/transaction/transaction.mjs

@@ -0,0 +1,249 @@
+import { __decorate } from "tslib";
+import { Transaction as TransactionBase } from '../../db/Models/transaction/transaction';
+import { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';
+import { ChartAccountsKeepSign, ChartAccountsListEnum, ChartAccountsMetaFieldListEnum, ChartAccountsUnallocatableListEnum, } from '../../db/Enums';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+import { DepreciationTypeEnum } from '../../db/Enums/depreciation-type.enum';
+import { DepreciationCalculationEnum } from '../../db/Enums/depreciation-calculation.enum';
+import { Transform, Type, plainToClass } from 'class-transformer';
+import { Property } from '../property';
+import { CHART_ACCOUNTS_CATEGORIES, ChartAccounts } from '../chart-accounts';
+import { IncomeSource } from '../income-source';
+import { TransactionMetaField } from './transaction-meta-field';
+import { Loan } from '../loan';
+import { TransactionAllocation } from './transaction-allocation';
+import { Collection } from '../../collections';
+import { Depreciation } from '../depreciation';
+import { SoleInvoiceItem } from '../sole';
+// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.
+export class Transaction extends TransactionBase {
+    constructor() {
+        super(...arguments);
+        /**
+         * @TODO rename to childTransactions
+         */
+        this.transactions = [];
+        this.metaFields = [];
+        this.allocations = [];
+        this.tax = 0;
+        this.operation = TransactionOperationEnum.FIND_AND_MATCH;
+        this.claimPercent = 100;
+        this.amount = 0;
+    }
+    static { this.className = 'Transaction'; }
+    get invoiceId() {
+        return this.invoiceItem?.invoice.id;
+    }
+    isDebit() {
+        return this.type === TransactionTypeEnum.DEBIT;
+    }
+    isCredit() {
+        return this.type === TransactionTypeEnum.CREDIT;
+    }
+    /**
+     * @TODO move to base collection
+     */
+    isIncome() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isCredit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
+    }
+    /**
+     * @TODO move to base collection
+     */
+    isExpense() {
+        // @TODO not used
+        if (!this.chartAccounts) {
+            return this.isDebit();
+        }
+        return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
+    }
+    isPersonal() {
+        return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
+    }
+    isInterest() {
+        return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+    }
+    get chartAccountsCategories() {
+        switch (true) {
+            case this.isPersonal():
+                return CHART_ACCOUNTS_CATEGORIES.personal;
+            case this.isPropertyTank():
+                return CHART_ACCOUNTS_CATEGORIES.property;
+            case this.isSoleTank():
+                return CHART_ACCOUNTS_CATEGORIES.sole;
+            default:
+                return CHART_ACCOUNTS_CATEGORIES.work;
+        }
+    }
+    /**
+     * Get transaction date
+     */
+    getDate() {
+        return this.date;
+    }
+    /**
+     * Check if transaction type is vehicle
+     */
+    isVehicleTransaction() {
+        return this.chartAccounts.isVehicleExpense();
+    }
+    get taxFreeComponent() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.TAX_FREE_COMPONENT);
+    }
+    get frankingCredit() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.FRANKING_CREDIT);
+    }
+    get eligibleForReduction() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.ELIGIBLE_FOR_REDUCTION);
+    }
+    get untaxedElement() {
+        return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.UNTAXED_ELEMENT);
+    }
+    /**
+     * Check if transaction reconcile operation if TRANSFER
+     * @TODO bad usage of get (and all is* methods), getter should sound like a noun
+     */
+    get isTransfer() {
+        return this.operation === TransactionOperationEnum.TRANSFER;
+    }
+    isFindAndMatch() {
+        return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
+    }
+    get debit() {
+        return this.isDebit() ? Math.abs(this.amount) : 0;
+    }
+    get credit() {
+        return this.isCredit() ? Math.abs(this.amount) : 0;
+    }
+    /**
+     * Get value of transaction meta field
+     * @param field for which value should be returned
+     * @Todo modify 'metaFields' property from array to Collection
+     */
+    getMetaFieldValue(field) {
+        return +this.metaFields.find((transactionMetaField) => transactionMetaField.chartAccountsMetaField.id === field)?.value || 0;
+    }
+    isCash() {
+        return this.source === TransactionSourceEnum.CASH;
+    }
+    canFindAndMatch(allocations) {
+        return !this.parentTransaction
+            && !this.isCash()
+            && !(this.isSoleTank() && this.isIncome())
+            && !Object.values(ChartAccountsUnallocatableListEnum).includes(this.chartAccounts.id)
+            && !this.isAllocated(allocations);
+    }
+    /**
+     * Create Depreciation instance based on Transaction
+     */
+    toDepreciation() {
+        return plainToClass(Depreciation, {
+            date: this.date,
+            amount: Math.abs(this.amount),
+            chartAccounts: this.chartAccounts,
+            description: this.description,
+            type: this.chartAccounts.isPropertyCapitalWorks() ? DepreciationTypeEnum.CAPITAL_WORKS : DepreciationTypeEnum.PLANT_EQUIPMENT,
+            claimPercent: this.claimPercent,
+            property: this.property,
+            calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST,
+            transactions: [this],
+            business: this.business,
+        });
+    }
+    /**
+     * Check if transaction is completely allocated
+     */
+    isAllocated(allocations) {
+        return Math.abs(this.getAllocatedAmount(allocations)) - Math.abs(this.netAmount) >= 0;
+    }
+    getAllocatedAmount(allocations) {
+        return allocations.filterBy('transaction.id', this.id).sumBy('amount');
+    }
+    getUnallocatedAmount(allocations) {
+        return this.netAmount - this.getAllocatedAmount(allocations);
+    }
+    /**
+     * Total transaction amount including taxes and other additional amounts
+     */
+    get grossAmount() {
+        let grossAmount = super.grossAmount + this.tax;
+        if (this.isExpense()) {
+            return grossAmount;
+        }
+        // included transactions affect parent transaction amount and as a result grossAmount, skip to avoid double sum
+        const adjustments = new Collection(this.transactions)
+            .filter(transaction => !transaction.chartAccounts?.isAdjustmentIncluded());
+        const income = adjustments.filter(transaction => transaction.isIncome()).sumBy('amount');
+        const expense = adjustments.filter(transaction => transaction.isExpense()).sumBy('amount', true);
+        // all adjustments except property income increase grossIncome
+        grossAmount += expense + (this.isPropertyTank() ? -income : income);
+        if (this.isWorkTank() || this.isHoldingTank()) {
+            grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;
+        }
+        return grossAmount;
+    }
+    /**
+     * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it
+     * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments
+     * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$
+     */
+    get netAmount() {
+        return new Collection(this.transactions)
+            .filter((t) => t.chartAccounts?.isAdjustmentIncluded())
+            .sumBy('amount') + this.amountWithGst;
+    }
+    /**
+     * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore
+     * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)
+     */
+    ignoreSign() {
+        return !(this.chartAccounts?.id in ChartAccountsKeepSign);
+    }
+    setParent(transaction) {
+        this.description = this.chartAccounts.name;
+        this.date = transaction.date;
+        this.claimPercent = transaction.claimPercent;
+        this.property = transaction.property;
+        this.loan = transaction.loan;
+        this.incomeSource = transaction.incomeSource;
+        this.business = transaction.business;
+    }
+}
+__decorate([
+    Type(() => Transaction)
+], Transaction.prototype, "transactions", void 0);
+__decorate([
+    Type(() => Property)
+], Transaction.prototype, "property", void 0);
+__decorate([
+    Type(() => ChartAccounts)
+], Transaction.prototype, "chartAccounts", void 0);
+__decorate([
+    Type(() => IncomeSource)
+], Transaction.prototype, "incomeSource", void 0);
+__decorate([
+    Type(() => TransactionMetaField)
+], Transaction.prototype, "metaFields", void 0);
+__decorate([
+    Type(() => Transaction)
+], Transaction.prototype, "transfer", void 0);
+__decorate([
+    Type(() => Loan)
+], Transaction.prototype, "loan", void 0);
+__decorate([
+    Type(() => Date)
+], Transaction.prototype, "date", void 0);
+__decorate([
+    Type(() => TransactionAllocation)
+], Transaction.prototype, "allocations", void 0);
+__decorate([
+    Type(() => SoleInvoiceItem)
+], Transaction.prototype, "invoiceItem", void 0);
+__decorate([
+    Transform(({ value }) => +value)
+], Transaction.prototype, "tax", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/models/transaction/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction as TransactionBase } from '../../db/Models/transaction/transaction';\nimport { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';\nimport {\n  ChartAccountsCategoryEnum, ChartAccountsKeepSign,\n  ChartAccountsListEnum,\n  ChartAccountsMetaFieldListEnum, ChartAccountsUnallocatableListEnum,\n} from '../../db/Enums';\nimport { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';\nimport { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';\nimport { DepreciationTypeEnum } from '../../db/Enums/depreciation-type.enum';\nimport { DepreciationCalculationEnum } from '../../db/Enums/depreciation-calculation.enum';\nimport { Transform, Type, plainToClass } from 'class-transformer';\nimport { Property } from '../property';\nimport { CHART_ACCOUNTS_CATEGORIES, ChartAccounts } from '../chart-accounts';\nimport { IncomeSource } from '../income-source';\nimport { TransactionMetaField } from './transaction-meta-field';\nimport { Loan } from '../loan';\nimport { TransactionAllocation } from './transaction-allocation';\nimport { Collection, TransactionAllocationCollection } from '../../collections';\nimport { Depreciation } from '../depreciation';\nimport { Expense } from '../../interfaces';\nimport { SoleInvoiceItem } from '../sole';\n\n// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.\nexport class Transaction extends TransactionBase implements Expense {\n  static className = 'Transaction';\n  /**\n   * @TODO rename to childTransactions\n   */\n  @Type(() => Transaction)\n  transactions: Transaction[] = [];\n\n  @Type(() => Property)\n  property: Property;\n\n  @Type(() => ChartAccounts)\n  chartAccounts: ChartAccounts;\n\n  @Type(() => IncomeSource)\n  incomeSource: IncomeSource;\n\n  @Type(() => TransactionMetaField)\n  metaFields: TransactionMetaField[] = [];\n\n  @Type(() => Transaction)\n  transfer: Transaction;\n\n  @Type(() => Loan)\n  loan: Loan;\n\n  @Type(() => Date)\n  date: Date;\n\n  @Type(() => TransactionAllocation)\n  allocations: TransactionAllocation[] = [];\n\n  @Type(() => SoleInvoiceItem)\n  invoiceItem: SoleInvoiceItem;\n\n  @Transform(({ value }) => +value)\n  tax = 0;\n\n  operation: TransactionOperationEnum = TransactionOperationEnum.FIND_AND_MATCH;\n  claimPercent = 100;\n  amount = 0;\n\n  get invoiceId(): number {\n    return this.invoiceItem?.invoice.id;\n  }\n\n  isDebit(): boolean {\n    return this.type === TransactionTypeEnum.DEBIT;\n  }\n\n  isCredit(): boolean {\n    return this.type === TransactionTypeEnum.CREDIT;\n  }\n\n  /**\n   * @TODO move to base collection\n   */\n  isIncome(): boolean {\n    // @TODO not used\n    if (!this.chartAccounts) {\n      return this.isCredit();\n    }\n\n    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);\n  }\n\n  /**\n   * @TODO move to base collection\n   */\n  isExpense(): boolean {\n    // @TODO not used\n    if (!this.chartAccounts) {\n      return this.isDebit();\n    }\n\n    return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);\n  }\n\n  isPersonal(): boolean {\n    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);\n  }\n\n  isInterest(): boolean {\n    return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;\n  }\n\n  get chartAccountsCategories(): ChartAccountsCategoryEnum[] {\n    switch (true) {\n      case this.isPersonal():\n        return CHART_ACCOUNTS_CATEGORIES.personal;\n\n      case this.isPropertyTank():\n        return CHART_ACCOUNTS_CATEGORIES.property;\n\n      case this.isSoleTank():\n        return CHART_ACCOUNTS_CATEGORIES.sole;\n\n      default:\n        return CHART_ACCOUNTS_CATEGORIES.work;\n    }\n  }\n\n  /**\n   * Get transaction date\n   */\n  getDate(): Date {\n    return this.date;\n  }\n\n  /**\n   * Check if transaction type is vehicle\n   */\n  isVehicleTransaction(): boolean {\n    return this.chartAccounts.isVehicleExpense();\n  }\n\n  get taxFreeComponent(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.TAX_FREE_COMPONENT);\n  }\n\n  get frankingCredit(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.FRANKING_CREDIT);\n  }\n\n  get eligibleForReduction(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.ELIGIBLE_FOR_REDUCTION);\n  }\n\n  get untaxedElement(): number {\n    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.UNTAXED_ELEMENT);\n  }\n\n  /**\n   * Check if transaction reconcile operation if TRANSFER\n   * @TODO bad usage of get (and all is* methods), getter should sound like a noun\n   */\n  get isTransfer(): boolean {\n    return this.operation === TransactionOperationEnum.TRANSFER;\n  }\n\n  isFindAndMatch(): boolean {\n    return this.operation === TransactionOperationEnum.FIND_AND_MATCH;\n  }\n\n  get debit(): number {\n    return this.isDebit() ? Math.abs(this.amount) : 0;\n  }\n\n  get credit(): number {\n    return this.isCredit() ? Math.abs(this.amount) : 0;\n  }\n\n  /**\n   * Get value of transaction meta field\n   * @param field for which value should be returned\n   * @Todo modify 'metaFields' property from array to Collection\n   */\n  getMetaFieldValue(field: ChartAccountsMetaFieldListEnum): number {\n    return +this.metaFields.find((transactionMetaField: TransactionMetaField): boolean => transactionMetaField.chartAccountsMetaField.id === field)?.value || 0;\n  }\n\n  isCash(): boolean {\n    return this.source === TransactionSourceEnum.CASH;\n  }\n\n  canFindAndMatch(allocations: TransactionAllocationCollection): boolean {\n    return !this.parentTransaction\n      && !this.isCash()\n      && !(this.isSoleTank() && this.isIncome())\n      && !Object.values(ChartAccountsUnallocatableListEnum).includes(this.chartAccounts.id)\n      && !this.isAllocated(allocations);\n  }\n\n  /**\n   * Create Depreciation instance based on Transaction\n   */\n  toDepreciation(): Depreciation {\n    return plainToClass(Depreciation, {\n      date: this.date,\n      amount: Math.abs(this.amount),\n      chartAccounts: this.chartAccounts,\n      description: this.description,\n      type: this.chartAccounts.isPropertyCapitalWorks() ? DepreciationTypeEnum.CAPITAL_WORKS : DepreciationTypeEnum.PLANT_EQUIPMENT,\n      claimPercent: this.claimPercent,\n      property: this.property,\n      calculation: this.property ? this.property.depreciationCalculation : DepreciationCalculationEnum.PRIME_COST,\n      transactions: [this],\n      business: this.business,\n    });\n  }\n\n  /**\n   * Check if transaction is completely allocated\n   */\n  isAllocated(allocations: TransactionAllocationCollection): boolean {\n    return Math.abs(this.getAllocatedAmount(allocations)) - Math.abs(this.netAmount) >= 0;\n  }\n\n  getAllocatedAmount(allocations: TransactionAllocationCollection): number {\n    return allocations.filterBy('transaction.id', this.id).sumBy('amount');\n  }\n\n  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {\n    return this.netAmount - this.getAllocatedAmount(allocations);\n  }\n\n  /**\n   * Total transaction amount including taxes and other additional amounts\n   */\n  get grossAmount(): number {\n    let grossAmount = super.grossAmount + this.tax;\n    if (this.isExpense()) {\n      return grossAmount;\n    }\n\n    // included transactions affect parent transaction amount and as a result grossAmount, skip to avoid double sum\n    const adjustments = new Collection(this.transactions)\n      .filter(transaction => !transaction.chartAccounts?.isAdjustmentIncluded());\n    const income = adjustments.filter(transaction => transaction.isIncome()).sumBy('amount');\n    const expense = adjustments.filter(transaction => transaction.isExpense()).sumBy('amount', true);\n    // all adjustments except property income increase grossIncome\n    grossAmount += expense + (this.isPropertyTank() ? -income : income);\n\n    if (this.isWorkTank() || this.isHoldingTank()) {\n      grossAmount += this.frankingCredit - this.taxFreeComponent - this.eligibleForReduction;\n    }\n\n    return grossAmount;\n  }\n\n  /**\n   * @TODO vik confusing logic demanded by Nicole, we need a better ux to fix it\n   * netAmount matches received payment (bankTransaction amount), includes gst and salary included adjustments\n   * ie user received 1000$ salary including 100$ tips. NetAmount=1000$, amount=900$, tips=100$\n   */\n  get netAmount(): number {\n    return new Collection(this.transactions)\n      .filter((t) => t.chartAccounts?.isAdjustmentIncluded())\n      .sumBy('amount') + this.amountWithGst;\n  }\n\n  /**\n   * most of the transactions could have only positive or negative amount depends on chartAccounts, so we ignore\n   * user's choice and transform amount, but there are exceptions like advance (negative or positive amount)\n   */\n  ignoreSign(): boolean {\n    return !(this.chartAccounts?.id in ChartAccountsKeepSign);\n  }\n\n  setParent(transaction: Transaction): void {\n    this.description = this.chartAccounts.name;\n    this.date = transaction.date;\n    this.claimPercent = transaction.claimPercent;\n    this.property = transaction.property;\n    this.loan = transaction.loan;\n    this.incomeSource = transaction.incomeSource;\n    this.business = transaction.business;\n  }\n}\n"]}

package/esm2022/src/lib/models/user/index.mjs

@@ -0,0 +1,10 @@
+export * from './my-account-history-initiated-by.enum';
+export * from './my-account-history-status.enum';
+export * from './my-account-history-type.enum';
+export * from './my-account-history';
+export * from './occupation';
+export * from './user-roles.const';
+export * from './user-to-register';
+export * from './user-work-position.const';
+export * from './user';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3VzZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3Q0FBd0MsQ0FBQztBQUN2RCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LWluaXRpYXRlZC1ieS5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LXN0YXR1cy5lbnVtJztcbmV4cG9ydCAqIGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LXR5cGUuZW51bSc7XG5leHBvcnQgKiBmcm9tICcuL215LWFjY291bnQtaGlzdG9yeSc7XG5leHBvcnQgKiBmcm9tICcuL29jY3VwYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyLXJvbGVzLmNvbnN0JztcbmV4cG9ydCAqIGZyb20gJy4vdXNlci10by1yZWdpc3Rlcic7XG5leHBvcnQgKiBmcm9tICcuL3VzZXItd29yay1wb3NpdGlvbi5jb25zdCc7XG5leHBvcnQgKiBmcm9tICcuL3VzZXInO1xuIl19

package/esm2022/src/lib/models/user/my-account-history-initiated-by.enum.mjs

@@ -0,0 +1,6 @@
+export var MyAccountHistoryInitiatedByEnum;
+(function (MyAccountHistoryInitiatedByEnum) {
+    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["OWNER"] = 0] = "OWNER";
+    MyAccountHistoryInitiatedByEnum[MyAccountHistoryInitiatedByEnum["ACCOUNTANT"] = 1] = "ACCOUNTANT";
+})(MyAccountHistoryInitiatedByEnum || (MyAccountHistoryInitiatedByEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LWluaXRpYXRlZC1ieS5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL215LWFjY291bnQtaGlzdG9yeS1pbml0aWF0ZWQtYnkuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSwrQkFHWDtBQUhELFdBQVksK0JBQStCO0lBQ3pDLHVGQUFTLENBQUE7SUFDVCxpR0FBYyxDQUFBO0FBQ2hCLENBQUMsRUFIVywrQkFBK0IsS0FBL0IsK0JBQStCLFFBRzFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTXlBY2NvdW50SGlzdG9yeUluaXRpYXRlZEJ5RW51bSB7XG4gIE9XTkVSID0gMCxcbiAgQUNDT1VOVEFOVCA9IDFcbn1cbiJdfQ==

package/esm2022/src/lib/models/user/my-account-history-status.enum.mjs

@@ -0,0 +1,6 @@
+export var MyAccountHistoryStatusEnum;
+(function (MyAccountHistoryStatusEnum) {
+    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["SUCCESS"] = 0] = "SUCCESS";
+    MyAccountHistoryStatusEnum[MyAccountHistoryStatusEnum["ERROR"] = 1] = "ERROR";
+})(MyAccountHistoryStatusEnum || (MyAccountHistoryStatusEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LXN0YXR1cy5lbnVtLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL215LWFjY291bnQtaGlzdG9yeS1zdGF0dXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSwwQkFHWDtBQUhELFdBQVksMEJBQTBCO0lBQ3BDLGlGQUFXLENBQUE7SUFDWCw2RUFBUyxDQUFBO0FBQ1gsQ0FBQyxFQUhXLDBCQUEwQixLQUExQiwwQkFBMEIsUUFHckMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBNeUFjY291bnRIaXN0b3J5U3RhdHVzRW51bSB7XG4gIFNVQ0NFU1MgPSAwLFxuICBFUlJPUiA9IDFcbn1cbiJdfQ==

package/esm2022/src/lib/models/user/my-account-history-type.enum.mjs

@@ -0,0 +1,7 @@
+export var MyAccountHistoryTypeEnum;
+(function (MyAccountHistoryTypeEnum) {
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["REVIEW"] = 0] = "REVIEW";
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPGRADE_PLAN"] = 1] = "UPGRADE_PLAN";
+    MyAccountHistoryTypeEnum[MyAccountHistoryTypeEnum["UPLOAD_DOCUMENT"] = 2] = "UPLOAD_DOCUMENT";
+})(MyAccountHistoryTypeEnum || (MyAccountHistoryTypeEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LXR5cGUuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci9teS1hY2NvdW50LWhpc3RvcnktdHlwZS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLHdCQUlYO0FBSkQsV0FBWSx3QkFBd0I7SUFDbEMsMkVBQVUsQ0FBQTtJQUNWLHVGQUFnQixDQUFBO0lBQ2hCLDZGQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFKVyx3QkFBd0IsS0FBeEIsd0JBQXdCLFFBSW5DIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGVudW0gTXlBY2NvdW50SGlzdG9yeVR5cGVFbnVtIHtcbiAgUkVWSUVXID0gMCxcbiAgVVBHUkFERV9QTEFOID0gMSxcbiAgVVBMT0FEX0RPQ1VNRU5UID0gMlxufVxuIl19

package/esm2022/src/lib/models/user/my-account-history.mjs

@@ -0,0 +1,3 @@
+export class MyAccountHistory {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYWNjb3VudC1oaXN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL215LWFjY291bnQtaGlzdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQSxNQUFNLE9BQU8sZ0JBQWdCO0NBTzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTXlBY2NvdW50SGlzdG9yeVR5cGVFbnVtIH0gZnJvbSAnLi9teS1hY2NvdW50LWhpc3RvcnktdHlwZS5lbnVtJztcbmltcG9ydCB7IE15QWNjb3VudEhpc3RvcnlJbml0aWF0ZWRCeUVudW0gfSBmcm9tICcuL215LWFjY291bnQtaGlzdG9yeS1pbml0aWF0ZWQtYnkuZW51bSc7XG5pbXBvcnQgeyBNeUFjY291bnRIaXN0b3J5U3RhdHVzRW51bSB9IGZyb20gJy4vbXktYWNjb3VudC1oaXN0b3J5LXN0YXR1cy5lbnVtJztcblxuZXhwb3J0IGNsYXNzIE15QWNjb3VudEhpc3Rvcnkge1xuICBpZDogbnVtYmVyO1xuICBuYW1lOiBzdHJpbmc7XG4gIHR5cGU6IE15QWNjb3VudEhpc3RvcnlUeXBlRW51bTtcbiAgaW5pdGlhdGVkQnk6IE15QWNjb3VudEhpc3RvcnlJbml0aWF0ZWRCeUVudW07XG4gIGRhdGU6IERhdGU7XG4gIHN0YXR1czogTXlBY2NvdW50SGlzdG9yeVN0YXR1c0VudW07XG59XG4iXX0=

package/esm2022/src/lib/models/user/occupation.mjs

@@ -0,0 +1,4 @@
+import { Occupation as OccupationBase } from '../../db/Models/client/occupation';
+export class Occupation extends OccupationBase {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2NjdXBhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci9vY2N1cGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLElBQUksY0FBYyxFQUFFLE1BQU0sbUNBQW1DLENBQUM7QUFFakYsTUFBTSxPQUFPLFVBQVcsU0FBUSxjQUFjO0NBQzdDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2NjdXBhdGlvbiBhcyBPY2N1cGF0aW9uQmFzZSB9IGZyb20gJy4uLy4uL2RiL01vZGVscy9jbGllbnQvb2NjdXBhdGlvbic7XG5cbmV4cG9ydCBjbGFzcyBPY2N1cGF0aW9uIGV4dGVuZHMgT2NjdXBhdGlvbkJhc2Uge1xufVxuIl19

package/esm2022/src/lib/models/user/user-roles.const.mjs

@@ -0,0 +1,20 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+/**
+ * role hierarchy
+ */
+export const USER_ROLES = {
+    ROLE_FIRM_OWNER: [UserRolesEnum.FIRM_OWNER, UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_FIRM_MANAGER: [UserRolesEnum.FIRM_MANAGER, UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_EMPLOYEE: [UserRolesEnum.ACCOUNTANT, UserRolesEnum.ADVISOR],
+    ROLE_ACCOUNTANT: [UserRolesEnum.ACCOUNTANT],
+    ROLE_ADVISOR: [UserRolesEnum.ADVISOR],
+    // @TODO makes no sense, these roles can't be hierarchical
+    ROLE_CLIENT: [UserRolesEnum.CLIENT],
+    ROLE_USER_SUBSCRIPTION: [UserRolesEnum.SUBSCRIPTION],
+    ROLE_USER_WORK: [UserRolesEnum.WORK_TANK],
+    ROLE_USER_PROPERTY: [UserRolesEnum.PROPERTY_TANK],
+    ROLE_USER_SOLE: [UserRolesEnum.SOLE_TANK],
+    ROLE_USER_HOLDING: [UserRolesEnum.HOLDING_TANK],
+    ROLE_PREVIOUS_ADMIN: [UserRolesEnum.SWITCH_USER],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1yb2xlcy5jb25zdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci91c2VyLXJvbGVzLmNvbnN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVwRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBcUM7SUFDMUQsZUFBZSxFQUFFLENBQUMsYUFBYSxDQUFDLFVBQVUsRUFBRSxhQUFhLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQyxVQUFVLEVBQUUsYUFBYSxDQUFDLE9BQU8sQ0FBQztJQUN4SCxpQkFBaUIsRUFBRSxDQUFDLGFBQWEsQ0FBQyxZQUFZLEVBQUUsYUFBYSxDQUFDLFVBQVUsRUFBRSxhQUFhLENBQUMsT0FBTyxDQUFDO0lBQ2hHLGFBQWEsRUFBRSxDQUFDLGFBQWEsQ0FBQyxVQUFVLEVBQUUsYUFBYSxDQUFDLE9BQU8sQ0FBQztJQUNoRSxlQUFlLEVBQUUsQ0FBQyxhQUFhLENBQUMsVUFBVSxDQUFDO0lBQzNDLFlBQVksRUFBRSxDQUFDLGFBQWEsQ0FBQyxPQUFPLENBQUM7SUFDckMsMERBQTBEO0lBQzFELFdBQVcsRUFBRSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUM7SUFDbkMsc0JBQXNCLEVBQUUsQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDO0lBQ3BELGNBQWMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUM7SUFDekMsa0JBQWtCLEVBQUUsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDO0lBQ2pELGNBQWMsRUFBRSxDQUFDLGFBQWEsQ0FBQyxTQUFTLENBQUM7SUFDekMsaUJBQWlCLEVBQUUsQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDO0lBQy9DLG1CQUFtQixFQUFFLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQztDQUNqRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVXNlclJvbGVzRW51bSB9IGZyb20gJ3RheHRhbmstY29yZS9jb21tb24nO1xuXG4vKipcbiAqIHJvbGUgaGllcmFyY2h5XG4gKi9cbmV4cG9ydCBjb25zdCBVU0VSX1JPTEVTOiB7W2tleTogc3RyaW5nXTogVXNlclJvbGVzRW51bVtdfSA9IHtcbiAgUk9MRV9GSVJNX09XTkVSOiBbVXNlclJvbGVzRW51bS5GSVJNX09XTkVSLCBVc2VyUm9sZXNFbnVtLkZJUk1fTUFOQUdFUiwgVXNlclJvbGVzRW51bS5BQ0NPVU5UQU5ULCBVc2VyUm9sZXNFbnVtLkFEVklTT1JdLFxuICBST0xFX0ZJUk1fTUFOQUdFUjogW1VzZXJSb2xlc0VudW0uRklSTV9NQU5BR0VSLCBVc2VyUm9sZXNFbnVtLkFDQ09VTlRBTlQsIFVzZXJSb2xlc0VudW0uQURWSVNPUl0sXG4gIFJPTEVfRU1QTE9ZRUU6IFtVc2VyUm9sZXNFbnVtLkFDQ09VTlRBTlQsIFVzZXJSb2xlc0VudW0uQURWSVNPUl0sXG4gIFJPTEVfQUNDT1VOVEFOVDogW1VzZXJSb2xlc0VudW0uQUNDT1VOVEFOVF0sXG4gIFJPTEVfQURWSVNPUjogW1VzZXJSb2xlc0VudW0uQURWSVNPUl0sXG4gIC8vIEBUT0RPIG1ha2VzIG5vIHNlbnNlLCB0aGVzZSByb2xlcyBjYW4ndCBiZSBoaWVyYXJjaGljYWxcbiAgUk9MRV9DTElFTlQ6IFtVc2VyUm9sZXNFbnVtLkNMSUVOVF0sXG4gIFJPTEVfVVNFUl9TVUJTQ1JJUFRJT046IFtVc2VyUm9sZXNFbnVtLlNVQlNDUklQVElPTl0sXG4gIFJPTEVfVVNFUl9XT1JLOiBbVXNlclJvbGVzRW51bS5XT1JLX1RBTktdLFxuICBST0xFX1VTRVJfUFJPUEVSVFk6IFtVc2VyUm9sZXNFbnVtLlBST1BFUlRZX1RBTktdLFxuICBST0xFX1VTRVJfU09MRTogW1VzZXJSb2xlc0VudW0uU09MRV9UQU5LXSxcbiAgUk9MRV9VU0VSX0hPTERJTkc6IFtVc2VyUm9sZXNFbnVtLkhPTERJTkdfVEFOS10sXG4gIFJPTEVfUFJFVklPVVNfQURNSU46IFtVc2VyUm9sZXNFbnVtLlNXSVRDSF9VU0VSXSxcbn07XG4iXX0=

package/esm2022/src/lib/models/user/user-to-register.mjs

@@ -0,0 +1,6 @@
+/**
+ * Class with basic information about registering user
+ */
+export class UserToRegister {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci10by1yZWdpc3Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3R0LWNvcmUvc3JjL2xpYi9tb2RlbHMvdXNlci91c2VyLXRvLXJlZ2lzdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxPQUFPLGNBQWM7Q0FHMUIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIENsYXNzIHdpdGggYmFzaWMgaW5mb3JtYXRpb24gYWJvdXQgcmVnaXN0ZXJpbmcgdXNlclxuICovXG5leHBvcnQgY2xhc3MgVXNlclRvUmVnaXN0ZXIge1xuICBmaXJzdE5hbWU6IHN0cmluZztcbiAgZW1haWw6IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/src/lib/models/user/user-work-position.const.mjs

@@ -0,0 +1,7 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+export const USER_WORK_POSITION = {
+    [UserRolesEnum.EMPLOYEE]: 'Employee',
+    [UserRolesEnum.FIRM_MANAGER]: 'Manager',
+    [UserRolesEnum.FIRM_OWNER]: 'Firm Owner'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci13b3JrLXBvc2l0aW9uLmNvbnN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyL3VzZXItd29yay1wb3NpdGlvbi5jb25zdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFFcEQsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQTRCO0lBQ3pELENBQUMsYUFBYSxDQUFDLFFBQVEsQ0FBQyxFQUFFLFVBQVU7SUFDcEMsQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDLEVBQUUsU0FBUztJQUN2QyxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsRUFBRSxZQUFZO0NBQ3pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVc2VyUm9sZXNFbnVtIH0gZnJvbSAndGF4dGFuay1jb3JlL2NvbW1vbic7XHJcblxyXG5leHBvcnQgY29uc3QgVVNFUl9XT1JLX1BPU0lUSU9OOiB7W2tleTogc3RyaW5nXTogc3RyaW5nfSA9IHtcclxuICBbVXNlclJvbGVzRW51bS5FTVBMT1lFRV06ICdFbXBsb3llZScsXHJcbiAgW1VzZXJSb2xlc0VudW0uRklSTV9NQU5BR0VSXTogJ01hbmFnZXInLFxyXG4gIFtVc2VyUm9sZXNFbnVtLkZJUk1fT1dORVJdOiAnRmlybSBPd25lcidcclxufTtcclxuIl19

package/esm2022/src/lib/models/user/user.mjs

@@ -0,0 +1,171 @@
+import { __decorate } from "tslib";
+import { User as BaseUser } from '../../db/Models/user/user';
+import { UserStatusEnum } from '../../db/Enums/user-status.enum';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { Address } from '../address';
+import { USER_WORK_POSITION } from './user-work-position.const';
+import { ClientDetails } from '../client';
+import { EmployeeDetails } from '../employee/employee-details';
+import { Type } from 'class-transformer';
+import { Phone } from '../phone/phone';
+import { ServiceSubscription } from '../service-subscription';
+import { SoleDetails } from '../sole';
+import intersection from 'lodash/intersection';
+import flatten from 'lodash/flatten';
+import { USER_ROLES } from './user-roles.const';
+import { FinancialYear } from '../financial-year';
+import { AppFile } from '../file';
+import range from 'lodash/range';
+import { AccountSetupItem } from '../account-setup/account-setup-item';
+export class User extends BaseUser {
+    constructor() {
+        super(...arguments);
+        this.blacklistSetupItems = [];
+    }
+    get fullName() {
+        return `${this.firstName} ${this.lastName}`;
+    }
+    get photo() {
+        return this.file?.publicUrl;
+    }
+    get activeSubscription() {
+        return this.subscriptions.find((ss) => ss.isActive);
+    }
+    get lastSubscription() {
+        return this.subscriptions[this.subscriptions.length - 1];
+    }
+    /**
+     * @TODO refactor
+     *
+     */
+    get position() {
+        switch (true) {
+            case this.isFirmOwner():
+                return USER_WORK_POSITION[UserRolesEnum.FIRM_OWNER];
+            case this.isManager():
+                return USER_WORK_POSITION[UserRolesEnum.FIRM_MANAGER];
+            case this.isEmployee():
+                return USER_WORK_POSITION[UserRolesEnum.EMPLOYEE];
+            default:
+                return '';
+        }
+    }
+    /**
+     * search roles including hierarchy
+     */
+    hasRoles(roles) {
+        roles = roles instanceof Array ? roles : [roles];
+        if (!roles.length) {
+            return true;
+        }
+        roles = flatten(roles.map((role) => USER_ROLES[role]));
+        return !!intersection(this.roles, roles).length;
+    }
+    isOnboarding() {
+        return this.status === UserStatusEnum.ON_BOARDING;
+    }
+    isInactive() {
+        return this.status === UserStatusEnum.INACTIVE;
+    }
+    hasSubscription() {
+        return this.roles.includes(UserRolesEnum.SUBSCRIPTION);
+    }
+    isLoggedIn() {
+        return this.id === +localStorage.getItem('userId');
+    }
+    isClient() {
+        return this.roles.includes(UserRolesEnum.CLIENT);
+    }
+    isEmployee() {
+        return this.isAccountant() || this.isAdvisor();
+    }
+    isAccountant() {
+        return this.roles.includes(UserRolesEnum.ACCOUNTANT);
+    }
+    isAdvisor() {
+        return this.roles.includes(UserRolesEnum.ADVISOR);
+    }
+    isImpersonator() {
+        return this.roles.includes(UserRolesEnum.SWITCH_USER);
+    }
+    /**
+     * Check if current user is firm owner
+     */
+    isFirmOwner() {
+        return this.roles.includes(UserRolesEnum.FIRM_OWNER);
+    }
+    /**
+     * Check if current user is firm manager
+     */
+    isManager() {
+        return this.roles.includes(UserRolesEnum.FIRM_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);
+    }
+    /**
+     * check if user has property tank access
+     */
+    hasPropertyTank() {
+        return this.roles ?
+            this.roles.includes(UserRolesEnum.PROPERTY_TANK) :
+            !!this.getSubscriptionRole(UserRolesEnum.PROPERTY_TANK);
+    }
+    /**
+     * check if user has property tank access
+     */
+    hasWorkTank() {
+        return this.roles ?
+            this.roles.includes(UserRolesEnum.WORK_TANK) :
+            !!this.getSubscriptionRole(UserRolesEnum.WORK_TANK);
+    }
+    /**
+     * Get user subscription role by provided role type
+     * @param roleType by which role should be returned
+     */
+    getSubscriptionRole(roleType) {
+        /**
+         * Add @TODO for Alex to check if we should use getLastSubscription here
+         */
+        return this.activeSubscription?.items
+            .find((subscriptionItem) => subscriptionItem.price.product.role.includes(roleType));
+    }
+    isCurrentFinancialYear() {
+        return new FinancialYear(new Date()).year === this.financialYear;
+    }
+    /**
+     * financial years available in the app for user
+     * starts from 2022 for new users and registeredYear - 1 for old users
+     */
+    get financialYears() {
+        return range(Math.min(FinancialYear.toFinYear(this.createdAt) - 1, 2022), FinancialYear.toFinYear(new Date()) + 1);
+    }
+}
+__decorate([
+    Type(() => ServiceSubscription)
+], User.prototype, "subscriptions", void 0);
+__decorate([
+    Type(() => ClientDetails)
+], User.prototype, "clientDetails", void 0);
+__decorate([
+    Type(() => EmployeeDetails)
+], User.prototype, "employeeDetails", void 0);
+__decorate([
+    Type(() => SoleDetails)
+], User.prototype, "soleDetails", void 0);
+__decorate([
+    Type(() => Address)
+], User.prototype, "address", void 0);
+__decorate([
+    Type(() => Phone)
+], User.prototype, "phone", void 0);
+__decorate([
+    Type(() => Date)
+], User.prototype, "createdAt", void 0);
+__decorate([
+    Type(() => User)
+], User.prototype, "clients", void 0);
+__decorate([
+    Type(() => AppFile)
+], User.prototype, "file", void 0);
+__decorate([
+    Type(() => AccountSetupItem)
+], User.prototype, "blacklistSetupItems", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user.js","sourceRoot":"","sources":["../../../../../../../projects/tt-core/src/lib/models/user/user.ts"],"names":[],"mappings":"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","sourcesContent":["import { User as BaseUser } from '../../db/Models/user/user';\nimport { UserStatusEnum } from '../../db/Enums/user-status.enum';\nimport { UserRolesEnum } from 'taxtank-core/common';\nimport { Address } from '../address';\nimport { USER_WORK_POSITION } from './user-work-position.const';\nimport { ClientDetails } from '../client';\nimport { EmployeeDetails } from '../employee/employee-details';\nimport { Type } from 'class-transformer';\nimport { Phone } from '../phone/phone';\nimport { ServiceSubscription } from '../service-subscription';\nimport { ServiceSubscriptionItem } from '../service-subscription';\nimport { SoleDetails } from '../sole';\nimport intersection from 'lodash/intersection';\nimport flatten from 'lodash/flatten';\nimport { USER_ROLES } from './user-roles.const';\nimport { FinancialYear } from '../financial-year';\nimport { AppFile } from '../file';\nimport range from 'lodash/range';\nimport { AccountSetupItem } from '../account-setup/account-setup-item';\n\nexport class User extends BaseUser {\n  @Type(() => ServiceSubscription)\n  subscriptions: ServiceSubscription[];\n\n  @Type(() => ClientDetails)\n  clientDetails: ClientDetails;\n\n  @Type(() => EmployeeDetails)\n  employeeDetails: EmployeeDetails;\n\n  @Type(() => SoleDetails)\n  soleDetails: SoleDetails;\n\n  @Type(() => Address)\n  address: Address;\n\n  @Type(() => Phone)\n  phone: Phone;\n\n  @Type(() => Date)\n  createdAt: Date;\n\n  // @TODO Alex remove this hack\n  @Type(() => User)\n  clients: User[];\n\n  @Type(() => AppFile)\n  file: AppFile;\n\n  @Type(() => AccountSetupItem)\n  blacklistSetupItems: AccountSetupItem[] = [];\n\n  get fullName(): string {\n    return `${this.firstName} ${this.lastName}`;\n  }\n\n  get photo(): string {\n    return this.file?.publicUrl;\n  }\n\n  get activeSubscription(): ServiceSubscription {\n    return this.subscriptions.find((ss: ServiceSubscription): boolean => ss.isActive);\n  }\n\n  get lastSubscription(): ServiceSubscription {\n    return this.subscriptions[this.subscriptions.length - 1];\n  }\n\n  /**\n   * @TODO refactor\n   *\n   */\n  get position(): string {\n    switch (true) {\n      case this.isFirmOwner():\n        return USER_WORK_POSITION[UserRolesEnum.FIRM_OWNER];\n      case this.isManager():\n        return USER_WORK_POSITION[UserRolesEnum.FIRM_MANAGER];\n      case this.isEmployee():\n        return USER_WORK_POSITION[UserRolesEnum.EMPLOYEE];\n      default:\n        return '';\n    }\n  }\n\n  /**\n   * search roles including hierarchy\n   */\n  hasRoles(roles: UserRolesEnum | UserRolesEnum[]): boolean {\n    roles = roles instanceof Array ? roles : [roles];\n    if (!roles.length) {\n      return true;\n    }\n\n    roles = flatten(roles.map((role) => USER_ROLES[role]));\n    return !!intersection(this.roles, roles).length;\n  }\n\n  isOnboarding(): boolean {\n    return this.status === UserStatusEnum.ON_BOARDING;\n  }\n\n  isInactive(): boolean {\n    return this.status === UserStatusEnum.INACTIVE;\n  }\n\n  hasSubscription(): boolean {\n    return this.roles.includes(UserRolesEnum.SUBSCRIPTION);\n  }\n\n  isLoggedIn(): boolean {\n    return this.id === +localStorage.getItem('userId');\n  }\n\n  isClient(): boolean {\n    return this.roles.includes(UserRolesEnum.CLIENT);\n  }\n\n  isEmployee(): boolean {\n    return this.isAccountant() || this.isAdvisor();\n  }\n\n  isAccountant(): boolean {\n    return this.roles.includes(UserRolesEnum.ACCOUNTANT);\n  }\n\n  isAdvisor(): boolean {\n    return this.roles.includes(UserRolesEnum.ADVISOR);\n  }\n\n  isImpersonator(): boolean {\n    return this.roles.includes(UserRolesEnum.SWITCH_USER);\n  }\n\n  /**\n   * Check if current user is firm owner\n   */\n  isFirmOwner(): boolean {\n    return this.roles.includes(UserRolesEnum.FIRM_OWNER);\n  }\n\n  /**\n   * Check if current user is firm manager\n   */\n  isManager(): boolean {\n    return this.roles.includes(UserRolesEnum.FIRM_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);\n  }\n\n  /**\n   * check if user has property tank access\n   */\n  hasPropertyTank(): boolean {\n    return this.roles ?\n      this.roles.includes(UserRolesEnum.PROPERTY_TANK) :\n      !!this.getSubscriptionRole(UserRolesEnum.PROPERTY_TANK);\n  }\n\n  /**\n   * check if user has property tank access\n   */\n  hasWorkTank(): boolean {\n    return this.roles ?\n      this.roles.includes(UserRolesEnum.WORK_TANK) :\n      !!this.getSubscriptionRole(UserRolesEnum.WORK_TANK);\n  }\n\n  /**\n   * Get user subscription role by provided role type\n   * @param roleType by which role should be returned\n   */\n  getSubscriptionRole(roleType: UserRolesEnum): ServiceSubscriptionItem {\n    /**\n     * Add @TODO for Alex to check if we should use getLastSubscription here\n     */\n    return this.activeSubscription?.items\n      .find((subscriptionItem: ServiceSubscriptionItem) => subscriptionItem.price.product.role.includes(roleType));\n  }\n\n  isCurrentFinancialYear(): boolean {\n    return new FinancialYear(new Date()).year === this.financialYear;\n  }\n\n  /**\n   * financial years available in the app for user\n   * starts from 2022 for new users and registeredYear - 1 for old users\n   */\n  get financialYears(): number {\n    return range(\n      Math.min(FinancialYear.toFinYear(this.createdAt) - 1, 2022),\n      FinancialYear.toFinYear(new Date()) + 1\n    );\n  }\n}\n\n"]}

package/esm2022/src/lib/models/user-event/user-event-setting-field.enum.mjs

@@ -0,0 +1,10 @@
+/**
+ * Enum with user event setting fields
+ */
+export var UserEventSettingFieldEnum;
+(function (UserEventSettingFieldEnum) {
+    UserEventSettingFieldEnum["BY_EMAIL"] = "byEmail";
+    UserEventSettingFieldEnum["BY_NOTIFICATION"] = "byNotification";
+    UserEventSettingFieldEnum["FREQUENCY"] = "frequency";
+})(UserEventSettingFieldEnum || (UserEventSettingFieldEnum = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1ldmVudC1zZXR0aW5nLWZpZWxkLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy90dC1jb3JlL3NyYy9saWIvbW9kZWxzL3VzZXItZXZlbnQvdXNlci1ldmVudC1zZXR0aW5nLWZpZWxkLmVudW0udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSx5QkFJWDtBQUpELFdBQVkseUJBQXlCO0lBQ25DLGlEQUFvQixDQUFBO0lBQ3BCLCtEQUFrQyxDQUFBO0lBQ2xDLG9EQUF1QixDQUFBO0FBQ3pCLENBQUMsRUFKVyx5QkFBeUIsS0FBekIseUJBQXlCLFFBSXBDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFbnVtIHdpdGggdXNlciBldmVudCBzZXR0aW5nIGZpZWxkc1xuICovXG5leHBvcnQgZW51bSBVc2VyRXZlbnRTZXR0aW5nRmllbGRFbnVtIHtcbiAgQllfRU1BSUwgPSAnYnlFbWFpbCcsXG4gIEJZX05PVElGSUNBVElPTiA9ICdieU5vdGlmaWNhdGlvbicsXG4gIEZSRVFVRU5DWSA9ICdmcmVxdWVuY3knXG59XG4iXX0=

package/esm2022/src/lib/models/user-event/user-event-setting.mjs

@@ -0,0 +1,18 @@
+import { __decorate } from "tslib";
+import { UserEventSetting as UserEventSettingBase } from '../../db/Models/user/user-event-setting';
+import { Exclude, Type } from 'class-transformer';
+import { UserEventType } from './user-event-type';
+export class UserEventSetting extends UserEventSettingBase {
+    constructor() {
+        super(...arguments);
+        // flag indicates that the setting is updating  now saved or not
+        this.isUpdating = false;
+    }
+}
+__decorate([
+    Type(() => UserEventType)
+], UserEventSetting.prototype, "type", void 0);
+__decorate([
+    Exclude({ toPlainOnly: true })
+], UserEventSetting.prototype, "isUpdating", void 0);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1ldmVudC1zZXR0aW5nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdHQtY29yZS9zcmMvbGliL21vZGVscy91c2VyLWV2ZW50L3VzZXItZXZlbnQtc2V0dGluZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsT0FBTyxFQUFFLGdCQUFnQixJQUFJLG9CQUFvQixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFDbkcsT0FBTyxFQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEQsTUFBTSxPQUFPLGdCQUFpQixTQUFRLG9CQUFvQjtJQUExRDs7UUFHRSxnRUFBZ0U7UUFFaEUsZUFBVSxHQUFhLEtBQUssQ0FBQztJQUMvQixDQUFDO0NBQUE7QUFKQztJQURDLElBQUksQ0FBQyxHQUFHLEVBQUUsQ0FBQyxhQUFhLENBQUM7OENBQ047QUFHcEI7SUFEQyxPQUFPLENBQUMsRUFBRSxXQUFXLEVBQUUsSUFBSSxFQUFFLENBQUM7b0RBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVc2VyRXZlbnRTZXR0aW5nIGFzIFVzZXJFdmVudFNldHRpbmdCYXNlIH0gZnJvbSAnLi4vLi4vZGIvTW9kZWxzL3VzZXIvdXNlci1ldmVudC1zZXR0aW5nJztcbmltcG9ydCB7IEV4Y2x1ZGUsIFR5cGUgfSBmcm9tICdjbGFzcy10cmFuc2Zvcm1lcic7XG5pbXBvcnQgeyBVc2VyRXZlbnRUeXBlIH0gZnJvbSAnLi91c2VyLWV2ZW50LXR5cGUnO1xuXG5leHBvcnQgY2xhc3MgVXNlckV2ZW50U2V0dGluZyBleHRlbmRzIFVzZXJFdmVudFNldHRpbmdCYXNlIHtcbiAgQFR5cGUoKCkgPT4gVXNlckV2ZW50VHlwZSlcbiAgdHlwZTogVXNlckV2ZW50VHlwZTtcbiAgLy8gZmxhZyBpbmRpY2F0ZXMgdGhhdCB0aGUgc2V0dGluZyBpcyB1cGRhdGluZyAgbm93IHNhdmVkIG9yIG5vdFxuICBARXhjbHVkZSh7IHRvUGxhaW5Pbmx5OiB0cnVlIH0pXG4gIGlzVXBkYXRpbmc/OiBib29sZWFuID0gZmFsc2U7XG59XG4iXX0=