taxtank 0.1.0

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

@@ -0,0 +1,20 @@
+import { TransactionAllocation as TransactionAllocationBase } from '../../db/Models/transaction/transaction-allocation';
+import { BankTransaction } from '../bank';
+import { Transaction } from './transaction';
+import { Type, plainToClass } from 'class-transformer';
+
+export class TransactionAllocation extends TransactionAllocationBase {
+  @Type(() => BankTransaction)
+  bankTransaction: BankTransaction;
+
+  @Type(() => Transaction)
+  transaction: Transaction;
+
+  /**
+   * Create a new instance of transaction allocation
+   * transaction could be empty since we can POST allocation inside a new transaction
+   */
+  static create(amount: number, bankTransaction: BankTransaction, transaction?: Transaction): TransactionAllocation {
+    return plainToClass(TransactionAllocation, { amount, transaction, bankTransaction });
+  }
+}

package/projects/tt-core/src/lib/models/transaction/transaction-category.enum.ts

@@ -0,0 +1,6 @@
+export enum TransactionCategoryEnum {
+  PROPERTY,
+  WORK,
+  SOLE,
+  PERSONAL
+}

package/projects/tt-core/src/lib/models/transaction/transaction-meta-field.ts

@@ -0,0 +1,13 @@
+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 {
+  @Type(() => ChartAccountsMetaField)
+  metaField: ChartAccountsMetaField;
+  @Type(() => Transaction)
+  transaction: Transaction;
+  @Type(() => ChartAccountsMetaField)
+  chartAccountsMetaField: ChartAccountsMetaField;
+}

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

@@ -0,0 +1,302 @@
+import { Transaction as TransactionBase } from '../../db/Models/transaction/transaction';
+import { TransactionTypeEnum } from '../../db/Enums/transaction-type.enum';
+import {
+  ChartAccountsAdjustmentIncludedListEnum,
+  ChartAccountsKeepSign,
+  ChartAccountsListEnum,
+  ChartAccountsMetaFieldListEnum, ChartAccountsSalaryAdjustmentsListEnum,
+} 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, TransactionAllocationCollection } from '../../collections';
+import { Depreciation } from '../depreciation';
+import { Expense } from '../../interfaces';
+import { SoleBusiness, SoleInvoiceItem } from '../sole';
+import { BudgetRule } from '../budget';
+
+// @TODO Alex: refactor: move here allocations methods, netAmount = amount, grossAmount calculation, remove unused methods, etc.
+export class Transaction extends TransactionBase implements Expense {
+  static className = 'Transaction';
+  /**
+   * @TODO rename to childTransactions
+   */
+  @Type(() => Transaction)
+  transactions: Transaction[] = [];
+
+  @Type(() => Property)
+  property: Property;
+
+  @Type(() => ChartAccounts)
+  chartAccounts: ChartAccounts;
+
+  @Type(() => IncomeSource)
+  incomeSource: IncomeSource;
+
+  @Type(() => TransactionMetaField)
+  metaFields: TransactionMetaField[] = [];
+
+  @Type(() => Transaction)
+  transfer: Transaction;
+
+  @Type(() => Loan)
+  loan: Loan;
+
+  @Type(() => Date)
+  date: Date;
+
+  @Type(() => TransactionAllocation)
+  allocations: TransactionAllocation[] = [];
+
+  @Type(() => SoleInvoiceItem)
+  invoiceItem: SoleInvoiceItem;
+
+  @Type(() => SoleBusiness)
+  business: SoleBusiness;
+
+  @Transform(({ value }) => +value)
+  tax = 0;
+
+  operation: TransactionOperationEnum = TransactionOperationEnum.FIND_AND_MATCH;
+  claimPercent = 100;
+  amount = 0;
+
+  get invoiceId(): number {
+    return this.invoiceItem?.invoice.id;
+  }
+
+  isDebit(): boolean {
+    return this.type === TransactionTypeEnum.DEBIT;
+  }
+
+  isCredit(): boolean {
+    return this.type === TransactionTypeEnum.CREDIT;
+  }
+
+  /**
+   * @TODO move to base collection
+   */
+  isIncome(): boolean {
+    // @TODO not used
+    if (!this.chartAccounts) {
+      return this.isCredit();
+    }
+
+    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.chartAccounts.category);
+  }
+
+  /**
+   * @TODO move to base collection
+   */
+  isExpense(): boolean {
+    // @TODO not used
+    if (!this.chartAccounts) {
+      return this.isDebit();
+    }
+
+    return CHART_ACCOUNTS_CATEGORIES.expense.includes(this.chartAccounts.category);
+  }
+
+  isPersonal(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.chartAccounts.category);
+  }
+
+  isInterest(): boolean {
+    return this.chartAccounts.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+  }
+
+  /**
+   * Check if transaction type is vehicle
+   */
+  isVehicleTransaction(): boolean {
+    return this.chartAccounts.isVehicleExpense();
+  }
+
+  get taxFreeComponent(): number {
+    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.TAX_FREE_COMPONENT);
+  }
+
+  get frankingCredit(): number {
+    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.FRANKING_CREDIT);
+  }
+
+  get eligibleForReduction(): number {
+    return this.getMetaFieldValue(ChartAccountsMetaFieldListEnum.ELIGIBLE_FOR_REDUCTION);
+  }
+
+  get untaxedElement(): number {
+    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(): boolean {
+    return this.operation === TransactionOperationEnum.TRANSFER;
+  }
+
+  isFindAndMatch(): boolean {
+    return this.operation === TransactionOperationEnum.FIND_AND_MATCH;
+  }
+
+  get debit(): number {
+    return this.isDebit() ? Math.abs(this.grossAmountWithoutGst) : 0;
+  }
+
+  get credit(): number {
+    return this.isCredit() ? Math.abs(this.grossAmountWithoutGst) : 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: ChartAccountsMetaFieldListEnum): number {
+    return +this.metaFields.find((transactionMetaField: TransactionMetaField): boolean => transactionMetaField.chartAccountsMetaField.id === field)?.value || 0;
+  }
+
+  isCash(): boolean {
+    return this.source === TransactionSourceEnum.CASH;
+  }
+
+  canFindAndMatch(allocations: TransactionAllocationCollection): boolean {
+    return !this.parentTransaction
+      && !this.isCash()
+      && !(this.isSoleTank() && this.isIncome())
+      && this.isEditable()
+      && !this.isAllocated(allocations);
+  }
+
+  /**
+   * Create Depreciation instance based on Transaction
+   */
+  toDepreciation(): Depreciation {
+    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: TransactionAllocationCollection): boolean {
+    return Math.abs(this.getAllocatedAmount(allocations)) - Math.abs(this.netAmount) >= 0;
+  }
+
+  getAllocatedAmount(allocations: TransactionAllocationCollection): number {
+    return allocations.filterBy('transaction.id', this.id).sumBy('amount');
+  }
+
+  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {
+    return this.netAmount - this.getAllocatedAmount(allocations);
+  }
+
+  /**
+   * Total transaction amount including taxes and other additional amounts
+   */
+  get grossAmount(): number {
+    return this.grossAmountWithoutGst + this.gstAmount;
+  }
+
+  get grossTaxableAmount(): number {
+    const untaxableAdjustment = new Collection(this.transactions)
+      .filter(transaction => transaction.chartAccounts.id === ChartAccountsSalaryAdjustmentsListEnum.PRE_TAX_DEDUCTIONS_OTHER).sumBy('amount');
+
+    return this.grossAmount - untaxableAdjustment;
+  }
+
+  get grossAmountWithoutGst(): number {
+    let grossAmount = this.amount + 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;
+  }
+
+  get grossClaimAmountWithoutGst(): number {
+    return this.grossAmountWithoutGst * this.claimRatio;
+  }
+
+  /**
+   * @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(): number {
+    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(): boolean {
+    return !(this.chartAccounts?.id in ChartAccountsKeepSign);
+  }
+
+  setParent(transaction: Transaction): void {
+    this.description = this.chartAccounts.name;
+    this.date = transaction.date;
+    this.property = transaction.property;
+    this.loan = transaction.loan;
+    this.incomeSource = transaction.incomeSource;
+    this.business = transaction.business;
+    if (this.claimPercent > 0) {
+      this.claimPercent = transaction.claimPercent;
+    }
+  }
+
+  isEditable(): boolean {
+    return !ChartAccounts.systemList.includes(this.chartAccounts.id);
+  }
+
+  get claimableTax(): number {
+    return this.tax * this.claimPercent / 100;
+  }
+
+  get month(): number {
+    return this.date.getMonth();
+  }
+
+  inBudget(rule: BudgetRule): boolean {
+    return rule.chartAccounts.id === this.chartAccounts.id
+      && rule.incomeSource?.id === this.incomeSource?.id
+      && rule.property?.id === this.property?.id
+      && rule.business?.id === this.business?.id;
+  }
+}

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

@@ -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';
+export * from './mfa-details';

package/projects/tt-core/src/lib/models/user/mfa-details/index.ts

@@ -0,0 +1,2 @@
+export * from './mfa-details';
+export * from './mfa-details.interface';

package/projects/tt-core/src/lib/models/user/mfa-details/mfa-details.interface.ts

@@ -0,0 +1,6 @@
+export interface MfaDetailsInterface {
+  googleAuthenticatorSecret: string;
+  googleAuthenticatorEnabled: boolean;
+  email: string;
+  emailAuthEnabled: string;
+}

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

@@ -0,0 +1,15 @@
+import { MfaDetailsInterface } from './mfa-details.interface';
+import { AbstractModel } from '../../../db/Models';
+
+export class MfaDetails extends AbstractModel implements MfaDetailsInterface {
+  googleAuthenticatorSecret: string;
+  googleAuthenticatorEnabled: boolean;
+  email: string;
+  emailAuthEnabled: string;
+  otpAuthUri: string;
+  provider: string;
+
+  isGoogleProvider(): boolean {
+    return this.provider === 'google';
+  }
+}

package/projects/tt-core/src/lib/models/user/my-account-history-initiated-by.enum.ts

@@ -0,0 +1,4 @@
+export enum MyAccountHistoryInitiatedByEnum {
+  OWNER = 0,
+  ACCOUNTANT = 1
+}

package/projects/tt-core/src/lib/models/user/my-account-history-status.enum.ts

@@ -0,0 +1,4 @@
+export enum MyAccountHistoryStatusEnum {
+  SUCCESS = 0,
+  ERROR = 1
+}

package/projects/tt-core/src/lib/models/user/my-account-history-type.enum.ts

@@ -0,0 +1,5 @@
+export enum MyAccountHistoryTypeEnum {
+  REVIEW = 0,
+  UPGRADE_PLAN = 1,
+  UPLOAD_DOCUMENT = 2
+}

package/projects/tt-core/src/lib/models/user/my-account-history.ts

@@ -0,0 +1,12 @@
+import { MyAccountHistoryTypeEnum } from './my-account-history-type.enum';
+import { MyAccountHistoryInitiatedByEnum } from './my-account-history-initiated-by.enum';
+import { MyAccountHistoryStatusEnum } from './my-account-history-status.enum';
+
+export class MyAccountHistory {
+  id: number;
+  name: string;
+  type: MyAccountHistoryTypeEnum;
+  initiatedBy: MyAccountHistoryInitiatedByEnum;
+  date: Date;
+  status: MyAccountHistoryStatusEnum;
+}

package/projects/tt-core/src/lib/models/user/occupation.ts

@@ -0,0 +1,4 @@
+import { Occupation as OccupationBase } from '../../db/Models/client/occupation';
+
+export class Occupation extends OccupationBase {
+}

package/projects/tt-core/src/lib/models/user/user-roles.const.ts

@@ -0,0 +1,21 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+
+/**
+ * role hierarchy
+ */
+export const USER_ROLES: {[key: string]: UserRolesEnum[]} = {
+  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],
+  ROLE_USER_MONEY: [UserRolesEnum.MONEY_TANK]
+};

package/projects/tt-core/src/lib/models/user/user-to-register.ts

@@ -0,0 +1,7 @@
+/**
+ * Class with basic information about registering user
+ */
+export class UserToRegister {
+  firstName: string;
+  email: string;
+}

package/projects/tt-core/src/lib/models/user/user-work-position.const.ts

@@ -0,0 +1,7 @@
+import { UserRolesEnum } from 'taxtank-core/common';
+
+export const USER_WORK_POSITION: {[key: string]: string} = {
+  [UserRolesEnum.EMPLOYEE]: 'Employee',
+  [UserRolesEnum.FIRM_MANAGER]: 'Manager',
+  [UserRolesEnum.FIRM_OWNER]: 'Firm Owner'
+};

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

@@ -0,0 +1,192 @@
+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';
+import { TankTypeEnum } from '../../db/Enums/tank-type.enum';
+
+export class User extends BaseUser {
+  @Type(() => ServiceSubscription)
+  subscriptions: ServiceSubscription[];
+
+  @Type(() => ClientDetails)
+  clientDetails: ClientDetails;
+
+  @Type(() => EmployeeDetails)
+  employeeDetails: EmployeeDetails;
+
+  @Type(() => SoleDetails)
+  soleDetails: SoleDetails;
+
+  @Type(() => Address)
+  address: Address;
+
+  @Type(() => Phone)
+  phone: Phone;
+
+  @Type(() => Date)
+  createdAt: Date;
+
+  // @TODO Alex remove this hack
+  @Type(() => User)
+  clients: User[];
+
+  @Type(() => AppFile)
+  file: AppFile;
+
+  @Type(() => AccountSetupItem)
+  blacklistSetupItems: AccountSetupItem[] = [];
+
+  get fullName(): string {
+    return `${this.firstName} ${this.lastName}`;
+  }
+
+  get photo(): string {
+    return this.file?.publicUrl;
+  }
+
+  get activeSubscription(): ServiceSubscription {
+    return this.subscriptions.find((ss: ServiceSubscription): boolean => ss.isActive);
+  }
+
+  get lastSubscription(): ServiceSubscription {
+    return this.subscriptions[this.subscriptions.length - 1];
+  }
+
+  /**
+   * @TODO refactor
+   *
+   */
+  get position(): string {
+    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 '';
+    }
+  }
+
+  addRoles(roles: UserRolesEnum[] = []): void {
+    this.roles = [...new Set([...this.roles, ...roles])];
+  }
+
+  /**
+   * search roles including hierarchy
+   */
+  hasRoles(roles: UserRolesEnum | UserRolesEnum[]): boolean {
+    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;
+  }
+
+  getTankTypes(): TankTypeEnum[] {
+    const tankTypes = [];
+    if (this.roles.includes(UserRolesEnum.WORK_TANK)) {
+      tankTypes.push(TankTypeEnum.WORK);
+    }
+    if (this.roles.includes(UserRolesEnum.PROPERTY_TANK)) {
+      tankTypes.push(TankTypeEnum.PROPERTY);
+    }
+    if (this.roles.includes(UserRolesEnum.SOLE_TANK)) {
+      tankTypes.push(TankTypeEnum.SOLE);
+    }
+    if (this.roles.includes(UserRolesEnum.HOLDING_TANK)) {
+      tankTypes.push(TankTypeEnum.HOLDING);
+    }
+    tankTypes.push(TankTypeEnum.PERSONAL);
+
+    return tankTypes;
+  }
+
+  isOnboarding(): boolean {
+    return this.status === UserStatusEnum.ON_BOARDING;
+  }
+
+  isInactive(): boolean {
+    return this.status === UserStatusEnum.INACTIVE;
+  }
+
+  hasSubscription(): boolean {
+    return this.roles.includes(UserRolesEnum.SUBSCRIPTION);
+  }
+
+  isLoggedIn(): boolean {
+    return this.id === +localStorage.getItem('userId');
+  }
+
+  isClient(): boolean {
+    return this.roles.includes(UserRolesEnum.CLIENT);
+  }
+
+  isEmployee(): boolean {
+    return this.isAccountant() || this.isAdvisor();
+  }
+
+  isAccountant(): boolean {
+    return this.roles.includes(UserRolesEnum.ACCOUNTANT);
+  }
+
+  isAdvisor(): boolean {
+    return this.roles.includes(UserRolesEnum.ADVISOR);
+  }
+
+  isImpersonator(): boolean {
+    return this.roles.includes(UserRolesEnum.SWITCH_USER);
+  }
+
+  /**
+   * Check if current user is firm owner
+   */
+  isFirmOwner(): boolean {
+    return this.roles.includes(UserRolesEnum.FIRM_OWNER);
+  }
+
+  isTopManager(): boolean {
+    return this.roles.includes(UserRolesEnum.FIRM_TOP_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);
+  }
+
+  isManager(): boolean {
+    return this.roles.includes(UserRolesEnum.FIRM_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_TOP_MANAGER) || this.roles.includes(UserRolesEnum.FIRM_OWNER);
+  }
+
+  isCurrentFinancialYear(): boolean {
+    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(): number {
+    return range(
+      Math.min(FinancialYear.toFinYear(this.createdAt) - 1, 2022),
+      FinancialYear.toFinYear(new Date()) + 1
+    );
+  }
+
+  get firmBranchNames(): string {
+    return this.employeeDetails.firmBranchNames;
+  }
+}
+

package/projects/tt-core/src/lib/models/user-event/user-event-setting-field.enum.ts

@@ -0,0 +1,8 @@
+/**
+ * Enum with user event setting fields
+ */
+export enum UserEventSettingFieldEnum {
+  BY_EMAIL = 'byEmail',
+  BY_NOTIFICATION = 'byNotification',
+  FREQUENCY = 'frequency'
+}

package/projects/tt-core/src/lib/models/user-event/user-event-setting.ts

@@ -0,0 +1,11 @@
+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 {
+  @Type(() => UserEventType)
+  type: UserEventType;
+  // flag indicates that the setting is updating  now saved or not
+  @Exclude({ toPlainOnly: true })
+  isUpdating?: boolean = false;
+}

package/projects/tt-core/src/lib/models/user-event/user-event-type-category.ts

@@ -0,0 +1,4 @@
+import { UserEventTypeCategory as UserEventTypeCategoryBase } from '../../db/Models/user/user-event-type-category';
+
+export class UserEventTypeCategory extends UserEventTypeCategoryBase {
+}