taxtank-core 0.0.1 → 0.1.1

package/src/lib/models/bank/bank-transaction-chart-data.ts

@@ -0,0 +1,132 @@
+import { BankTransaction } from './bank-transaction';
+import { IChartData } from '../../interfaces/chart-data.interface';
+import { IChartSerie } from '../../interfaces/chart-serie.interface';
+import { MonthNumberEnum } from '../financial-year/month-number.enum';
+import { MonthNameShortEnum } from '../financial-year/month-name-short.enum';
+import cloneDeep from 'lodash/cloneDeep';
+
+/**
+ * bank transactions collection UI class with frontend specific data
+ */
+export class BankTransactionChartData {
+  private bankTransactions: BankTransaction[];
+
+  constructor(
+    bankTransactions: BankTransaction[]
+  ) {
+    this.bankTransactions = bankTransactions;
+  }
+
+  /**
+   * get value of bar chart data
+   */
+  getCashInOutBarChartData(months?: MonthNumberEnum[]): IChartData[] {
+    const chartData: IChartData[] = this.calculateCashInOutBarChartData();
+
+    if (!months) {
+      return chartData;
+    }
+
+    return this.filterChartDataByMonths(months, chartData);
+  }
+
+  /**
+   * get value of line chart data
+   */
+  getBalanceLineChartData(months?: MonthNumberEnum[]): IChartData[] {
+    const chartData: IChartData[] = this.calculateBalanceLineChartData();
+
+    if (!months) {
+      return chartData;
+    }
+
+    return this.filterChartDataByMonths(months, chartData);
+  }
+
+  /**
+   * set bar chart data
+   */
+  private calculateCashInOutBarChartData(): IChartData[] {
+    const chartData: IChartData[] = [{
+      name: 'Cash In',
+      data: []
+    }, {
+      name: 'Cash Out',
+      data: []
+    }];
+
+    for (const key in MonthNameShortEnum) {
+      if (MonthNameShortEnum.hasOwnProperty(key)) {
+        const bankTransactionsForMonth: BankTransaction[] = this.bankTransactions.filter((bankTransaction: BankTransaction) => {
+          return +bankTransaction.date.getMonth() === +MonthNumberEnum[key];
+        });
+
+        const cashInForMonth: number = bankTransactionsForMonth
+          .filter((bankTransaction: BankTransaction) => bankTransaction.isCredit())
+          .reduce((sum: number, bankTransaction: BankTransaction) => sum += bankTransaction.allocatedAmount, 0);
+
+        const cashOutForMonth: number = bankTransactionsForMonth
+          .filter((bankTransaction: BankTransaction) => bankTransaction.isDebit())
+          .reduce((sum: number, bankTransaction: BankTransaction) => sum += bankTransaction.allocatedAmount, 0);
+
+        chartData[0].data.push({
+          label: MonthNameShortEnum[key],
+          value: cashInForMonth
+        });
+
+        chartData[1].data.push({
+          label: MonthNameShortEnum[key],
+          value: cashOutForMonth
+        });
+      }
+    }
+
+    return chartData;
+  }
+
+
+  /**
+   * set line chart data
+   */
+  private calculateBalanceLineChartData(): IChartData[] {
+    const chartData: IChartData[] = [{
+        name: 'Balance',
+        data: []
+      }];
+
+    for (const key in MonthNameShortEnum) {
+      if (MonthNameShortEnum.hasOwnProperty(key)) {
+        const bankTransactionsForMonth: BankTransaction[] = this.bankTransactions.filter((bankTransaction: BankTransaction) => {
+          return +bankTransaction.date.getMonth() === +MonthNumberEnum[key];
+        });
+
+        const balanceForMonth: number = bankTransactionsForMonth.reduce((sum: number, bankTransaction: BankTransaction) => {
+          if (bankTransaction.isCredit()) {
+            return sum += bankTransaction.allocatedAmount;
+          } else {
+            return sum -= bankTransaction.allocatedAmount;
+          }
+        }, 0);
+
+        chartData[0].data.push({
+          label: MonthNameShortEnum[key],
+          value: balanceForMonth
+        });
+      }
+    }
+
+    return chartData;
+  }
+
+  /**
+   * filter chart data for passed months
+   */
+  private filterChartDataByMonths(months: number[], chartData: IChartData[]): IChartData[] {
+    const monthsNames: string[] = months.map((month: number) => MonthNumberEnum[month]).map((key: string) => MonthNameShortEnum[key]);
+    const filteredChartData: IChartData[] = cloneDeep(chartData);
+    filteredChartData.forEach((chartDataItem: IChartData) => {
+      chartDataItem.data = chartDataItem.data.filter((serie: IChartSerie) => monthsNames.includes(serie.label));
+    });
+    return filteredChartData;
+  }
+}

package/src/lib/models/bank/bank-transaction-summary-fields.enum.ts

@@ -0,0 +1,4 @@
+export enum BankTransactionSummaryFieldsEnum {
+  AMOUNT = 'amount',
+  ALLOCATED_AMOUNT = 'allocatedAmount'
+}

package/src/lib/models/bank/bank-transaction.ts

@@ -0,0 +1,74 @@
+import { BankTransaction as BankTransactionBase } from '../../db/Models/bank-transaction';
+import { BankTransactionTypeEnum } from '../../db/Enums/bank-transaction-type.enum';
+import { TransactionSourceEnum } from '../../db/Enums/transaction-source.enum';
+import { plainToClass, Type } from 'class-transformer';
+import { TransactionOperationEnum } from '../../db/Enums/transaction-operation.enum';
+import { Transaction } from '../transaction/transaction';
+import { TransactionAllocationCollection } from '../../collections/transaction-allocation.collection';
+
+export class BankTransaction extends BankTransactionBase {
+  // allocated money amount for bank transaction
+  allocatedAmount: number = 0;
+  unallocatedAmount: number = 0;
+
+  operation: TransactionOperationEnum;
+
+  @Type(() => Date)
+  date: Date;
+
+  /**
+   * get allocated amount value but with +/- sign
+   */
+  get balanceAmount(): number {
+    return this.isCredit() ? this.allocatedAmount : -this.allocatedAmount;
+  }
+
+  /**
+   * check if bank transaction is debit
+   */
+  isDebit(): boolean {
+    return this.type === BankTransactionTypeEnum.DEBIT;
+  }
+
+  /**
+   * check if bank transaction is credit
+   */
+  isCredit(): boolean {
+    return this.type === BankTransactionTypeEnum.CREDIT;
+  }
+
+  /**
+   * Create Transaction instance based on Bank Transaction
+   */
+  toTransaction(): Transaction {
+    return plainToClass(Transaction, {
+      amount: +this.amount.toFixed(2),
+      description: this.description,
+      date: this.date,
+      source: TransactionSourceEnum.BANK_TRANSACTION,
+      operation: this.operation,
+      type: this.type,
+    });
+  }
+
+  /**
+   * Check if bank transaction is completely allocated
+   */
+  isAllocated(allocations: TransactionAllocationCollection): boolean {
+    return this.amount === this.getAllocatedAmount(allocations);
+  }
+
+  /**
+   * Get bank transaction allocated amount
+   */
+  getAllocatedAmount(allocations: TransactionAllocationCollection): number {
+    return allocations.getByBankTransactionsIds([this.id]).amount;
+  }
+
+  /**
+   * Get bank transaction unallocated amount
+   */
+  getUnallocatedAmount(allocations: TransactionAllocationCollection): number {
+    return this.amount - this.getAllocatedAmount(allocations);
+  }
+}

package/src/lib/models/bank/bank.ts

@@ -0,0 +1,21 @@
+import { Bank as BankBase } from '../../db/Models/bank';
+import { Photoable } from '../../interfaces/photoable';
+import { Inject } from '@angular/core';
+
+export class Bank extends BankBase implements Photoable {
+  constructor(
+    @Inject('environment') private environment: any
+  ) {
+    super();
+  }
+  getInitials(): string {
+    return this.name[0] + this.name[1];
+  }
+
+  getPhoto(): string {
+    if (!this.logo) {
+      return null;
+    }
+    return this.logo.includes('http') ? `${this.logo}` : `${this.environment.api_uri}/${this.logo}`;
+  }
+}

package/src/lib/models/bank/basiq-job.ts

@@ -0,0 +1,4 @@
+import { BasiqJob as BasiqJobBase } from '../../db/Models/basiq-job';
+
+export class BasiqJob extends BasiqJobBase {
+}

package/src/lib/models/bank/basiq-token.ts

@@ -0,0 +1,16 @@
+/**
+ * access token, needed to access basiq connect ui (https://github.com/basiqio/basiq-connect-ui)
+ */
+export class BasiqToken {
+  value: string;
+  expiresAt: Date;
+
+  constructor(value: string, expiresAt: Date) {
+    this.value = value;
+    this.expiresAt = expiresAt;
+  }
+
+  isExpired(): boolean {
+    return this.expiresAt < new Date();
+  }
+}

package/src/lib/models/bank/type-loan.const.ts

@@ -0,0 +1,7 @@
+import { BankAccountTypeEnum } from '../../db/Enums/bank-account-type.enum';
+
+export const TYPE_LOAN: BankAccountTypeEnum[] = [
+  BankAccountTypeEnum.MORTGAGE,
+  BankAccountTypeEnum.CREDIT_CARD,
+  BankAccountTypeEnum.LOAN
+];

package/src/lib/models/borrowing-expense/borrowing-expense-loan.ts

@@ -0,0 +1,4 @@
+import { BorrowingExpenseLoan as BorrowingExpenseLoanBase} from '../../db/Models/borrowing-expense-loan';
+
+export class BorrowingExpenseLoan extends BorrowingExpenseLoanBase {
+}

package/src/lib/models/borrowing-expense/borrowing-expense.ts

@@ -0,0 +1,4 @@
+import { BorrowingExpense as BorrowingExpenseBase } from '../../db/Models/borrowing-expense';
+
+export class BorrowingExpense extends BorrowingExpenseBase {
+}

package/src/lib/models/chart/chart-data.ts

@@ -0,0 +1,13 @@
+import { ChartSerie } from './chart-serie';
+import { Type } from 'class-transformer';
+
+/**
+ * Chart data class
+ * @TODO consider rename to ChartSerie
+ */
+export class ChartData {
+  name: string;
+
+  @Type(() => ChartSerie)
+  data: ChartSerie[];
+}

package/src/lib/models/chart/chart-serie.ts

@@ -0,0 +1,8 @@
+/**
+ * Chart serie class: chart data item
+ * @TODO consider rename to ChartSerieData
+ */
+export class ChartSerie {
+  label: string;
+  value: number;
+}

package/src/lib/models/chart-accounts/chart-accounts-categories.const.ts

@@ -0,0 +1,85 @@
+import { ChartAccountsCategoryEnum } from '../../db/Enums/chart-accounts-category.enum';
+
+export const CHART_ACCOUNTS_CATEGORIES: {[key: string]: ChartAccountsCategoryEnum[]} = {
+  income: [
+    ChartAccountsCategoryEnum.PROPERTY_INCOME,
+    ChartAccountsCategoryEnum.WORK_INCOME,
+    ChartAccountsCategoryEnum.OTHER_INCOME,
+    ChartAccountsCategoryEnum.PERSONAL_INCOME
+  ],
+  expense: [
+    ChartAccountsCategoryEnum.PROPERTY_EXPENSE,
+    ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION,
+    ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS,
+    ChartAccountsCategoryEnum.WORK_DEPRECIATION,
+    ChartAccountsCategoryEnum.WORK_EXPENSE,
+    ChartAccountsCategoryEnum.OTHER_EXPENSE,
+    ChartAccountsCategoryEnum.PERSONAL_EXPENSE
+  ],
+  property: [
+    ChartAccountsCategoryEnum.PROPERTY_EXPENSE,
+    ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION,
+    ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS,
+    ChartAccountsCategoryEnum.PROPERTY_INCOME
+  ],
+  work: [
+    ChartAccountsCategoryEnum.WORK_EXPENSE,
+    ChartAccountsCategoryEnum.WORK_DEPRECIATION,
+    ChartAccountsCategoryEnum.WORK_INCOME,
+    ChartAccountsCategoryEnum.OTHER_EXPENSE,
+    ChartAccountsCategoryEnum.OTHER_INCOME
+  ],
+  personal: [
+    ChartAccountsCategoryEnum.PERSONAL_EXPENSE,
+    ChartAccountsCategoryEnum.PERSONAL_INCOME
+  ],
+  propertyExpense: [
+    ChartAccountsCategoryEnum.PROPERTY_EXPENSE
+  ],
+  propertyIncome: [
+    ChartAccountsCategoryEnum.PROPERTY_INCOME
+  ],
+  workExpense: [
+    ChartAccountsCategoryEnum.WORK_EXPENSE,
+    ChartAccountsCategoryEnum.OTHER_EXPENSE,
+    // @TODO Alex why?
+    ChartAccountsCategoryEnum.PERSONAL_EXPENSE
+  ],
+  workIncome: [
+    ChartAccountsCategoryEnum.WORK_INCOME,
+    ChartAccountsCategoryEnum.OTHER_INCOME,
+    // @TODO Alex why?
+    ChartAccountsCategoryEnum.PERSONAL_INCOME
+  ],
+  workTankHeader: [
+    ChartAccountsCategoryEnum.WORK_INCOME,
+    ChartAccountsCategoryEnum.OTHER_INCOME,
+    ChartAccountsCategoryEnum.WORK_EXPENSE,
+    ChartAccountsCategoryEnum.OTHER_EXPENSE
+  ],
+  workTankHeaderIncome: [
+    ChartAccountsCategoryEnum.WORK_INCOME,
+    ChartAccountsCategoryEnum.OTHER_INCOME
+  ],
+  workTankHeaderExpenses: [
+    ChartAccountsCategoryEnum.WORK_EXPENSE,
+    ChartAccountsCategoryEnum.OTHER_EXPENSE
+  ],
+  depreciation: [
+    ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION,
+    ChartAccountsCategoryEnum.WORK_DEPRECIATION
+  ],
+  all: [
+    ChartAccountsCategoryEnum.PROPERTY_INCOME,
+    ChartAccountsCategoryEnum.WORK_INCOME,
+    ChartAccountsCategoryEnum.OTHER_INCOME,
+    ChartAccountsCategoryEnum.PERSONAL_INCOME,
+    ChartAccountsCategoryEnum.PROPERTY_EXPENSE,
+    ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION,
+    ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS,
+    ChartAccountsCategoryEnum.WORK_DEPRECIATION,
+    ChartAccountsCategoryEnum.WORK_EXPENSE,
+    ChartAccountsCategoryEnum.OTHER_EXPENSE,
+    ChartAccountsCategoryEnum.PERSONAL_EXPENSE
+  ]
+};

package/src/lib/models/chart-accounts/chart-accounts-depreciation.ts

@@ -0,0 +1,14 @@
+import { ChartAccountsDepreciation as ChartAccountsDepreciationBase } from '../../db/Models/chart-accounts-depreciation';
+import { ChartAccounts } from './chart-accounts';
+import { Transform, Type } from 'class-transformer';
+
+export class ChartAccountsDepreciation extends ChartAccountsDepreciationBase {
+  @Type(() => ChartAccounts)
+  chartAccounts: ChartAccounts;
+
+  @Transform(({value}) => +value)
+  limit: number;
+
+  @Transform(({value}) => +value)
+  effectiveLife: number;
+}

package/src/lib/models/chart-accounts/chart-accounts-heading.ts

@@ -0,0 +1,6 @@
+import { ChartAccountsHeading as ChartAccountsHeadingBase } from '../../db/Models/chart-accounts-heading';
+import { ChartAccounts } from './chart-accounts';
+
+export class ChartAccountsHeading extends ChartAccountsHeadingBase {
+  chartAccounts: ChartAccounts[];
+}

package/src/lib/models/chart-accounts/chart-accounts-metadata.ts

@@ -0,0 +1,15 @@
+import { ChartAccountsMetadata as ChartAccountsMetadataBase } from '../../db/Models/chart-accounts-metadata';
+import { ChartAccountsMetadataListEnum } from '../../db/Enums/chart-accounts-metadata-list.enum';
+
+export class ChartAccountsMetadata extends ChartAccountsMetadataBase {
+  /**
+   * Check if metadata id is related to SHARE_PERCENTAGE value
+   */
+  isSharePercentage(): boolean {
+    return this.id === ChartAccountsMetadataListEnum.SHARE_PERCENTAGE;
+  }
+
+  isHours(): boolean {
+    return this.id === ChartAccountsMetadataListEnum.HOURS;
+  }
+}

package/src/lib/models/chart-accounts/chart-accounts-tax-labels.enum.ts

@@ -0,0 +1,5 @@
+export enum ChartAccountsTaxLabelsEnum {
+  TAX_WITHHELD = 'Tax withheld',
+  TAX_PAID = 'Tax Paid',
+  TAX_DEDUCTED = 'Tax Deducted'
+}

package/src/lib/models/chart-accounts/chart-accounts.ts

@@ -0,0 +1,137 @@
+import { ChartAccounts as ChartAccountsBase } from '../../db/Models/chart-accounts';
+import { Type } from 'class-transformer';
+import { ChartAccountsHeading } from './chart-accounts-heading';
+import { ChartAccountsMetadata } from './chart-accounts-metadata';
+import { ChartAccountsListEnum } from '../../db/Enums/chart-accounts-list.enum';
+import { ChartAccountsCategoryEnum } from '../../db/Enums/chart-accounts-category.enum';
+import { ChartAccountsHeadingVehicleListEnum } from '../../db/Enums/chart-accounts-heading-vehicle-list.enum';
+import { CHART_ACCOUNTS_CATEGORIES } from './chart-accounts-categories.const';
+
+export class ChartAccounts extends ChartAccountsBase {
+  @Type(() => ChartAccountsHeading)
+  heading: ChartAccountsHeading;
+
+  @Type(() => ChartAccountsMetadata)
+  metadata: ChartAccountsMetadata[];
+
+  /**
+   * Return name as string
+   */
+  toString(): string {
+    return this.name;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Klms travelled for work' category
+   */
+  isKlmsForWork(): boolean {
+    return this.id === ChartAccountsListEnum.KLMS_TRAVELLED_FOR_WORK;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'NRAS Tax Offset' category
+   */
+  isNRAS(): boolean {
+    return this.id === ChartAccountsListEnum.TAX_OFFSETS_N_R_A_S;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Interest on Loan' category
+   */
+  isInterestOnLoan(): boolean {
+    return this.id === ChartAccountsListEnum.INTEREST_ON_LOAN;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Motor Vehicles' category
+   */
+  isVehicles(): boolean {
+    return this.id === ChartAccountsListEnum.VEHICLES;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Interest Earned' category
+   */
+  isInterestEarned(): boolean {
+    return this.id === ChartAccountsListEnum.INTEREST_EARNED;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Trust Income' category
+   */
+  isTrustIncome(): boolean {
+    return this.id === ChartAccountsListEnum.TRUST_INCOME;
+  }
+
+  /**
+   * Check if chart accounts id is related for 'Motor vehicles (commercial cars)' category
+   */
+  isCommercialVehicles(): boolean {
+    return this.id === ChartAccountsListEnum.COMMERCIAL_VEHICLES;
+  }
+
+  /**
+   * Check if chart accounts is work income
+   */
+  isWorkIncome(): boolean {
+    return this.category === ChartAccountsCategoryEnum.WORK_INCOME;
+  }
+
+  isVehicleExpense(): boolean {
+    return !!ChartAccountsHeadingVehicleListEnum[this.heading?.id];
+  }
+
+  /**
+   * Check if chart accounts is other income
+   */
+  isOtherIncome(): boolean {
+    return this.category === ChartAccountsCategoryEnum.OTHER_INCOME;
+  }
+
+  isIncome(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.income.includes(this.category);
+  }
+
+  isProperty(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.property.includes(this.category);
+  }
+
+  isWorkExpense(): boolean {
+    return [ChartAccountsCategoryEnum.WORK_EXPENSE, ChartAccountsCategoryEnum.OTHER_EXPENSE, ChartAccountsCategoryEnum.WORK_DEPRECIATION]
+      .includes(this.category);
+  }
+
+  /**
+   * Check if chart accounts is property expense
+   */
+  isPropertyExpense(): boolean {
+    return this.category === ChartAccountsCategoryEnum.PROPERTY_EXPENSE;
+  }
+
+  isPersonal(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.personal.includes(this.category);
+  }
+
+  isPersonalExpense(): boolean {
+    return this.category === ChartAccountsCategoryEnum.PERSONAL_EXPENSE;
+  }
+
+  isPropertyDepreciation(): boolean {
+    return [ChartAccountsCategoryEnum.PROPERTY_DEPRECIATION, ChartAccountsCategoryEnum.PROPERTY_CAPITAL_WORKS]
+      .includes(this.category);
+  }
+
+  /**
+   * Check if chart accounts category is depreciation
+   */
+  isDepreciation(): boolean {
+    return CHART_ACCOUNTS_CATEGORIES.depreciation.includes(this.category);
+  }
+
+  /**
+   * Check if transaction chart account is work related car expenses
+   */
+  isVehicleLoanExpense(): boolean {
+    return this.id === ChartAccountsListEnum.VEHICLE_LOAN_INTEREST || this.id === ChartAccountsListEnum.VEHICLE_LOAN_PRINCIPAL;
+  }
+}

package/src/lib/models/chat/chat-view-type.enum.ts

@@ -0,0 +1,4 @@
+export enum ChatViewTypeEnum {
+  MESSAGES,
+  ATTACHMENTS
+}

package/src/lib/models/chat/chat.ts

@@ -0,0 +1,23 @@
+import { Chat as ChatBase } from '../../db/Models/chat';
+import { ChatStatusEnum } from '../../db/Enums/chat-status.enum';
+import { User } from '../user/user';
+import { Type } from 'class-transformer';
+
+export class Chat extends ChatBase {
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => User)
+  client: User;
+
+  // @TODO temporary disabled
+  // @Type(() => User)
+  // typingUsers: User[] = [];
+
+  /**
+   * Check if chat is active
+   */
+  isActive(): boolean {
+    return this.status === ChatStatusEnum.ACTIVE;
+  }
+}

package/src/lib/models/chat/message-document.ts

@@ -0,0 +1,18 @@
+import { MessageDocument as MessageDocumentBase } from '../../db/Models/message-document';
+import { IAsset } from '../../interfaces/asset.interface';
+import { AssetEntityTypeEnum } from '../../interfaces/asset-entity-type.enum';
+import { AssetTypeEnum } from '../../interfaces/asset-type.enum';
+import { User } from '../user/user';
+import { Exclude, Type } from 'class-transformer';
+
+export class MessageDocument extends MessageDocumentBase implements IAsset {
+  entityType: AssetEntityTypeEnum = AssetEntityTypeEnum.MESSAGES;
+  type: AssetTypeEnum = AssetTypeEnum.MESSAGE;
+
+  @Type(() => User)
+  user: User;
+
+  // temp storage for attached file
+  @Exclude({ toPlainOnly: true })
+  file: File;
+}

package/src/lib/models/chat/message.ts

@@ -0,0 +1,40 @@
+import { Message as MessageBase } from '../../db/Models/message';
+import { User } from '../user/user';
+import { MessageDocument } from './message-document';
+import { Expose, Type } from 'class-transformer';
+
+
+export class Message extends MessageBase {
+  @Type(() => Date)
+  createdAt: Date;
+
+  @Type(() => User)
+  employee: User;
+
+  @Type(() => MessageDocument)
+  @Expose() documents: MessageDocument[];
+
+  /**
+   * Check if message created today or not
+   */
+  isToday(): boolean {
+    const now: Date = new Date();
+    return this.createdAt.getFullYear() === now.getFullYear() &&
+      this.createdAt.getMonth() === now.getMonth() &&
+      this.createdAt.getDate() === now.getDate();
+  }
+
+  /**
+   * Check if message sent from firm
+   */
+  isFromEmployee(): boolean {
+    return !!this.employee;
+  }
+
+  /**
+   * Check if message read
+   */
+  isRead(): boolean {
+    return !!this.readAt;
+  }
+}

package/src/lib/models/client/client-details.ts

@@ -0,0 +1,4 @@
+import { ClientDetails as ClientDetailsBase } from '../../db/Models/client-details';
+
+export class ClientDetails extends ClientDetailsBase {
+}