taxtank 0.1.0

package/projects/tt-core/src/lib/collections/bank-transaction.collection.ts

@@ -0,0 +1,173 @@
+import { TransactionOperationEnum } from '../db/Enums/transaction-operation.enum';
+import { BankAccount, BankTransaction, IncomeSource, MonthNumberEnum } from '../models';
+import { Collection } from './collection';
+import { CollectionDictionary } from './collection-dictionary';
+import { TransactionAllocationCollection } from './transaction';
+import { BankAccountCollection } from './bank-account.collection';
+
+/**
+ * Maximal delay between transfer transactions
+ */
+const TRANSACTION_TRANSFER_DELAY: number = 96 * 3600 * 1000;
+
+/**
+ * Collection of bank transactions.
+ * IMPORTANT: Create this collection based on bank transactions from TransactionAllocationService
+ * @TODO find way to accept interface with allocation instead of bankTransaction to prevent wrong usage
+ * because all amounts calculates with allocated amounts but not from bank transactions amounts.
+ */
+export class BankTransactionCollection extends Collection<BankTransaction> {
+  getAmount(): number {
+    return this.sumBy('amount');
+  }
+
+  /**
+   * Difference between total bank transactions amount and sum of allocations for passed bank transactions
+   */
+  getUnallocatedAmount(allocations: TransactionAllocationCollection) {
+    return this.getAmount() - allocations.getByBankTransactionsIds(this.getIds()).amount;
+  }
+
+  getAllocatedAmount(allocations: TransactionAllocationCollection): number {
+    return allocations.getByBankTransactionsIds(this.getIds()).amount;
+  }
+
+  /**
+   * get date of the last transaction
+   */
+  getLastTransactionDate(): Date {
+    if (!this.length) {
+      return null;
+    }
+
+    return new Date(Math.max(...this.items.map(transaction => transaction.date.getTime())));
+  }
+
+  /**
+   * get list of credit transactions
+   */
+  get creditTransactions(): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.isCredit())
+    );
+  }
+
+  /**
+   * get list of debit transactions
+   */
+  get debitTransactions(): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.isDebit())
+    );
+  }
+
+  /**
+   * get difference between debit and credit transactions amounts
+   */
+  get balanceAmount(): number {
+    return this.items.reduce((sum: number, bankTransaction: BankTransaction) => sum + bankTransaction.balanceAmount, 0);
+  }
+
+  /**
+   * get list of transactions for passed month
+   * @param monthIndex Month number from 0 to 11
+   */
+  getTransactionsByMonth(monthIndex: MonthNumberEnum): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => bankTransaction.date.getMonth() === monthIndex)
+    );
+  }
+
+  /**
+   * get list of transactions by provided bank accounts
+   * @param bankAccounts by which transactions should be returned
+   */
+  getByBankAccounts(bankAccounts: BankAccountCollection): BankTransactionCollection {
+    const bankAccountIds: number[] = bankAccounts.map((bankAccount: BankAccount) => bankAccount.id);
+
+    return new BankTransactionCollection(this.items.filter(
+      (bankTransaction: BankTransaction) => bankAccountIds.includes(bankTransaction.bankAccount.id)
+    ));
+  }
+
+  /**
+   * get list of transactions by provided ids of bank accounts
+   * @param ids of bank accounts
+   */
+  getByBankAccountsIds(ids: number[]): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction) => ids.includes(bankTransaction.bankAccount.id))
+    );
+  }
+
+  /**
+   * Find Bank Transaction available for transfer
+   */
+  findTransfer(bankTransaction: BankTransaction): BankTransaction {
+    return this.items.find((item: BankTransaction): boolean => item.amount + bankTransaction.amount === 0 &&
+        Math.abs(bankTransaction.date.getTime() - item.date.getTime()) < TRANSACTION_TRANSFER_DELAY);
+  }
+
+  /**
+   * Group bank transactions by transaction id.
+   * Each group is bank transaction collection and contains bank transactions related to transactions via allocations
+   */
+  groupByTransaction(allocations: TransactionAllocationCollection): CollectionDictionary<BankTransactionCollection> {
+    // Group allocations by transaction id
+    const allocationsByTransactions = allocations.groupBy('transaction.id');
+    // Init an empty dictionary we will fill below
+    const bankTransactionsByTransactions = new BankTransactionCollection([]).groupBy();
+
+    // Fill dictionary with the same keys as at allocationsByTransactions
+    allocationsByTransactions.keys.forEach((key: string): void => {
+      bankTransactionsByTransactions.add(key, this.getByAllocations(allocationsByTransactions.get(key)));
+    });
+
+    return bankTransactionsByTransactions;
+  }
+
+  /**
+   * Get collection of bank transactions related with passed allocations
+   */
+  getByAllocations(allocations: TransactionAllocationCollection): BankTransactionCollection {
+    return new BankTransactionCollection(
+      this.items.filter((bankTransaction: BankTransaction): boolean => allocations.hasBankTransaction(bankTransaction))
+    );
+  }
+
+  /**
+   * Set allocate operation for bank transactions with amounts equal to salary
+   */
+  preselectAllocateOperationForSalary(salaryIncomeSources: IncomeSource[]): void {
+    // incomeSource.salaryForecasts[0] because each income source has only one forecast for current fin year
+    const salaryAmounts: number[] = salaryIncomeSources.map((incomeSource: IncomeSource): number => incomeSource.salaryForecasts[0]?.netPay || 0);
+
+    this.items.forEach((bankTransaction: BankTransaction): void => {
+      if (salaryAmounts.includes(bankTransaction.amount)) {
+        bankTransaction.operation = TransactionOperationEnum.ALLOCATE;
+      }
+    });
+  }
+
+  getAllocated(allocations: TransactionAllocationCollection): this {
+    return this.filter((bankTransaction: BankTransaction): boolean => bankTransaction.isAllocated(allocations));
+  }
+
+  getUnallocated(allocations: TransactionAllocationCollection): this {
+    return this.filter((bankTransaction: BankTransaction): boolean => !bankTransaction.isAllocated(allocations));
+  }
+
+  /**
+   * Allocated sum of credit transactions
+   */
+  getCreditAmount(allocations: TransactionAllocationCollection): number {
+    return this.creditTransactions.getAllocatedAmount(allocations);
+  }
+
+  /**
+   * Allocated sum of debit transactions
+   */
+  getDebitAmount(allocations: TransactionAllocationCollection): number {
+    return this.debitTransactions.getAllocatedAmount(allocations);
+  }
+}

package/projects/tt-core/src/lib/collections/budget/budget-rule.collection.ts

@@ -0,0 +1,39 @@
+import { BudgetRule, Property } from '../../models';
+import { Collection } from '../collection';
+import { CalendarEventProvider } from '../../interfaces';
+import { MoneyCalendarEventCollection } from '../money';
+
+export class BudgetRuleCollection extends Collection<BudgetRule> implements CalendarEventProvider {
+  get expenses(): BudgetRuleCollection {
+    return this.filter(rule => rule.chartAccounts.isExpense());
+  }
+
+  get incomes(): BudgetRuleCollection {
+    return this.filter(rule => rule.chartAccounts.isIncome());
+  }
+
+  filterByProperties(properties: Property[]): BudgetRuleCollection {
+    const propertyIds = properties.map(property => property.id)
+
+    return this.filter(rule => propertyIds.includes(rule.property?.id));
+  }
+
+  getCalendarEvents(inCalendar = true): MoneyCalendarEventCollection {
+    return new MoneyCalendarEventCollection(
+      this.map(rule => rule.getCalendarEvents(inCalendar).items).flat()
+    );
+  }
+
+  getByMonth(index: number): BudgetRuleCollection {
+    return new BudgetRuleCollection(this.items.filter(rule => rule.inMonth(index)));
+  }
+
+  getByDate(dateFrom: Date, dateTo: Date): BudgetRuleCollection {
+    return this.filter(rule => !!rule.getCalendarEvents().filterByDate(dateFrom, dateTo).length);
+  }
+
+  getByChartAccountsName(name: string): BudgetRuleCollection {
+    const searchQuery: string = name.toLowerCase().trim();
+    return this.filter(rule => rule.chartAccounts.name.toLowerCase().includes(searchQuery));
+  }
+}

package/projects/tt-core/src/lib/collections/budget/budget.collection.ts

@@ -0,0 +1,4 @@
+import { Budget } from '../../models';
+import { Collection } from '../collection';
+
+export class BudgetCollection extends Collection<Budget> {}

package/projects/tt-core/src/lib/collections/budget/index.ts

@@ -0,0 +1,2 @@
+export * from './budget.collection';
+export * from './budget-rule.collection';

package/projects/tt-core/src/lib/collections/chart-accounts/chart-accounts-value.collection.ts

@@ -0,0 +1,25 @@
+import { Collection } from '../collection';
+import { ChartAccountsValue, FinancialYear } from '../../models';
+import { BusinessChartAccountsEnum, ChartAccountsListEnum } from '../../db/Enums';
+
+export class ChartAccountsValueCollection extends Collection<ChartAccountsValue>{
+  /**
+   * $ amount u can claim per 1km
+   */
+  getKmsRate(isSole: boolean): number {
+    const chartAccountsId = isSole ? BusinessChartAccountsEnum.KMS_TRAVELLED : ChartAccountsListEnum.KMS_TRAVELLED;
+    return this.find(
+      (ca) => ca.chartAccounts.id === chartAccountsId && new FinancialYear().year === ca.financialYear
+    ).value;
+  }
+
+  /**
+   * $ amount u can claim per 1hour
+   */
+  getHoursRate(isSole: boolean): number {
+    const chartAccountsId = isSole ? BusinessChartAccountsEnum.HOME_OFFICE_HOURS : ChartAccountsListEnum.HOME_OFFICE_HOURS;
+    return this.find(
+      (ca) => ca.chartAccounts.id === chartAccountsId && new FinancialYear().year === ca.financialYear
+    ).value;
+  }
+}

package/projects/tt-core/src/lib/collections/chart-accounts/index.ts

@@ -0,0 +1 @@
+export * from './chart-accounts-value.collection';

package/projects/tt-core/src/lib/collections/chart-accounts.collection.ts

@@ -0,0 +1,30 @@
+import { Collection } from './collection';
+import { ChartAccounts, FinancialYear } from '../models';
+import { ChartAccountsListEnum } from '../db/Enums';
+
+export class ChartAccountsCollection extends Collection<ChartAccounts> {
+  constructor(items: ChartAccounts[] = []) {
+    super(items);
+
+    // Sort personal chart accounts by name (TT-1950)
+    // @TODO Alex: implement general initial sorting solution in parent class
+    this.items.sort((a: ChartAccounts, b: ChartAccounts) => {
+      if (a.isPersonal() && b.isPersonal()) {
+        return a.name.toLowerCase() > b.name.toLowerCase() ? 1 : -1;
+      }
+
+      return 0;
+    });
+  }
+
+  getManual(): this {
+    return this.filter(chartAccounts => !!chartAccounts.user);
+  }
+
+  /**
+   * Get 'Kms travelled for work' related chart account value
+   */
+  getVehicleKmsRate(year: number = new FinancialYear().year): number {
+    return this.findBy('id', ChartAccountsListEnum.KMS_TRAVELLED).getValueByYear(year).value
+  }
+}

package/projects/tt-core/src/lib/collections/chat/chat.collection.ts

@@ -0,0 +1,9 @@
+import { Collection } from '../collection';
+import { Chat } from '../../models';
+import { ChatStatusEnum } from '../../db/Enums/chat-status.enum';
+
+export class ChatCollection extends Collection<Chat> {
+  getActive(): this {
+    return this.filterBy('status', ChatStatusEnum.ACTIVE);
+  }
+}

package/projects/tt-core/src/lib/collections/chat/index.ts

@@ -0,0 +1,3 @@
+export * from './chat.collection';
+export * from './message-document.collection';
+export * from './message.collection';

package/projects/tt-core/src/lib/collections/chat/message-document.collection.ts

@@ -0,0 +1,16 @@
+import { Collection } from '../collection';
+import { MessageDocument } from '../../models';
+
+/**
+ * Collection of MessageDocument instances
+ */
+export class MessageDocumentCollection extends Collection<MessageDocument> {
+  /**
+   * get list of documents which are not attached to any message
+   */
+  getUnattached(): MessageDocumentCollection {
+    return new MessageDocumentCollection(
+      this.items.filter((doc: MessageDocument): boolean => !doc.message)
+    );
+  }
+}

package/projects/tt-core/src/lib/collections/chat/message.collection.ts

@@ -0,0 +1,39 @@
+import { Collection } from '../collection';
+import { Message, User } from '../../models';
+import uniqBy from 'lodash/uniqBy';
+
+
+export class MessageCollection extends Collection<Message> {
+  getFirstUnreadMessage(user: User): Message {
+    return this.items.find((message: Message): boolean => !message.isRead() && message.isFromEmployee() !== user.isEmployee()
+    );
+  }
+
+  /**
+   * Get List of unread chats
+   */
+  getUnread(): Message[] {
+    return this.items.filter((message: Message): boolean => !message.readAt);
+  }
+
+  getFromActiveChats(): this {
+    return this.filter((message: Message) => message.chat.isActive());
+  }
+
+  /**
+   * Get amount of chats that contains unread messages
+   */
+  getUnreadChatsAmount(isFromEmployee = false): number {
+    // filtered messages for client/employee
+    const filteredMessages: this = this.filter((message: Message) => isFromEmployee ? message.isFromEmployee() : !message.isFromEmployee());
+
+    return uniqBy(filteredMessages.getFromActiveChats().getUnread(), 'chat.id').length;
+  }
+
+  /**
+   * Check if chat has unread chats
+   */
+  hasUnread(): boolean {
+    return !!this.getUnread().length;
+  }
+}

package/projects/tt-core/src/lib/collections/client-invite.collection.ts

@@ -0,0 +1,8 @@
+import { Collection } from './collection';
+import { ClientInvite } from '../models/client/client-invite';
+
+export class ClientInviteCollection extends Collection<ClientInvite> {
+  getPending(): this {
+    return this.filter((invite: ClientInvite) => invite.isPending());
+  }
+}

package/projects/tt-core/src/lib/collections/client-movement.collection.ts

@@ -0,0 +1,63 @@
+import { Collection } from './collection';
+import { ClientMovement, SERVICE_PRODUCT_ROLES } from '../models';
+import { EmployeeCollection } from './firm';
+import { ClientCollection } from './client.collection';
+import { FirmTypeEnum } from '../db/Enums';
+import { CollectionDictionary } from './collection-dictionary';
+import { UserRolesEnum } from 'taxtank-core/common';
+import { ServiceSubscriptionCollection } from './subscription';
+
+/**
+ * Collection of tax review
+ */
+export class ClientMovementCollection extends Collection<ClientMovement> {
+  get active(): ClientMovementCollection {
+    return new ClientMovementCollection(this.items.filter((clientMovement: ClientMovement) => !clientMovement.dateTo));
+  }
+
+  get employees(): EmployeeCollection {
+    return new EmployeeCollection(this.items.map((clientMovement: ClientMovement) => clientMovement.employee));
+  }
+
+  get clients(): ClientCollection {
+    return new ClientCollection(this.items.map((clientMovement: ClientMovement) => clientMovement.client));
+  }
+
+  get accountant(): ClientMovement {
+    return this.items.filter((clientMovement: ClientMovement) => clientMovement.firm.type === FirmTypeEnum.ACCOUNTANT)[0] ?? null;
+  }
+
+  get advisors(): ClientMovementCollection {
+    return new ClientMovementCollection(
+      this.items.filter((clientMovement: ClientMovement) => clientMovement.firm.type === FirmTypeEnum.ADVISOR)
+    );
+  }
+
+  getByEmployeeId(id: number): ClientMovementCollection {
+    return new ClientMovementCollection(this.items.filter((clientMovement: ClientMovement) => clientMovement.employee.id === id));
+  }
+
+  getByFirmType(firmType: FirmTypeEnum): ClientMovementCollection {
+    return new ClientMovementCollection(
+      this.items.filter((clientMovement: ClientMovement) => clientMovement.firm.type === firmType)
+    );
+  }
+
+  /**
+   * group clients (client movements) by tanks
+   */
+  groupByRoles(): CollectionDictionary<ClientMovementCollection> {
+    const dictionary = new CollectionDictionary(new ClientMovementCollection());
+
+    SERVICE_PRODUCT_ROLES.forEach((role: UserRolesEnum) => {
+      const movements = this.filter(movement => {
+        const subscriptions = new ServiceSubscriptionCollection(movement.client.subscriptions).filterByRole(role);
+
+        return (subscriptions.getPaid().last ?? subscriptions.getTrials().first)?.isActive;
+      });
+      dictionary.add(role, movements);
+    });
+
+    return dictionary;
+  }
+}

package/projects/tt-core/src/lib/collections/client-portfolio-report.collection.ts

@@ -0,0 +1,47 @@
+/**
+ * Collection of employee clients tax summary information
+ */
+import { Collection } from './collection';
+import { ClientPortfolioReport } from '../models/client/client-portfolio-report';
+
+export class ClientPortfolioReportCollection extends Collection<ClientPortfolioReport> {
+  get marketValue(): number {
+    return this.sumBy('marketValue');
+  }
+
+  get loanBalance(): number {
+    return this.sumBy('loanBalance');
+  }
+
+  get equityPosition(): number {
+    return this.sumBy('equityPosition');
+  }
+
+  /**
+   * Get average market value if there are more than 1 item in the collection
+   */
+  get averageMarketValue(): number {
+    return this.items.length > 1 ? this.marketValue / this.items.length : null;
+  }
+
+  /**
+   * Get average loan balance if there are more than 1 item in the collection
+   */
+  get averageLoanBalance(): number {
+    return this.items.length > 1 ? this.loanBalance / this.items.length : null;
+  }
+
+  /**
+   * Get average equity position if there are more than 1 item in the collection
+   */
+  get averageEquityPosition(): number {
+    return this.items.length > 1 ? this.equityPosition / this.items.length : null;
+  }
+
+  /**
+   * Return report by provided category name
+   */
+  getByCategoryName(name: string): ClientPortfolioReport {
+    return this.items.find((item: ClientPortfolioReport): boolean => item.category === name);
+  }
+}

package/projects/tt-core/src/lib/collections/client.collection.ts

@@ -0,0 +1,5 @@
+import { Collection } from './collection';
+import { User } from '../models';
+
+export class ClientCollection extends Collection<User> {
+}

package/projects/tt-core/src/lib/collections/collection-dictionary.ts

@@ -0,0 +1,155 @@
+import get from 'lodash/get';
+import flatten from 'lodash/flatten';
+import hasIn from 'lodash/hasIn';
+import { Collection as BaseCollection } from './collection';
+import { AbstractModel } from '../db/Models';
+import intersection from 'lodash/intersection';
+import uniqBy from 'lodash/uniqBy';
+
+/**
+ * @TODO refactor with Map
+ * List of collections grouped by passed property
+ */
+export class CollectionDictionary<Collection extends BaseCollection<object>> {
+  /**
+   * List of grouped collections
+   */
+  items: { [key: string]: Collection } = {};
+
+  /**
+   * Constructor function of passed collection for creating new instances
+   */
+  private collectionConstructor: new (items: object[]) => Collection;
+
+  constructor(collection: Collection, path = 'id') {
+    this.collectionConstructor = collection.constructor as new (items: object[]) => Collection;
+    // group if provided path was found in the 1st collection's item
+    if (collection.length && hasIn(collection.items[0], path.split('.')[0])) {
+      this.groupItems(collection, path);
+    }
+  }
+
+  /**
+   * List of collections keys
+   */
+  get keys(): string[] {
+    return Object.keys(this.items);
+  }
+
+  get values(): Collection[] {
+    return Object.values(this.items);
+  }
+
+  /**
+   * push new elements in existing item
+   */
+  addTo(key: string | number, ...models: AbstractModel[]): void {
+    if (!this.items[key]) {
+      this.add(key);
+    }
+
+    this.items[key].push(...models);
+  }
+
+  /**
+   * Add new item by key
+   */
+  add(key: string | number, value: Collection = this.createCollection([])) {
+    this.items[key] = value;
+  }
+
+  /**
+   * Get collection by key or return empty collection if key does not exist
+   */
+  get(key: string | number): Collection {
+    return this.items[key] ? this.items[key] : this.createCollection([]);
+  }
+
+  /**
+   * @TODO bad name, it just gets items by keys, same as get method by multiple keys
+   * Join several collections by ids, return collection of uniq models (skip duplicates)
+   */
+  merge(keys: number[] | string[]): Collection {
+    if (!this.length) {
+      return this.createCollection([]);
+    }
+
+    return this.createCollection(
+      uniqBy(flatten(keys.map((key: number | string): object[] => this.get(key.toString()).items)), 'id')
+    );
+  }
+
+  /**
+   * Create instance of collection
+   */
+  createCollection(items: object[] = []): Collection {
+    return new this.collectionConstructor(items);
+  }
+
+  get length(): number {
+    return this.keys.length;
+  }
+
+  /**
+   * @Todo find a better solution to get list of the sorted keys
+   * Get array of the "keys" by provided order
+   */
+  getSortedKeys(isDesc = false): string[] {
+    return this.keys.sort((a: any, b: any): number => {
+      if (a > b) {
+        return !isDesc ? 1 : -1;
+      }
+      if (a < b) {
+        return !isDesc ? -1 : 1;
+      }
+      return 0;
+    });
+  }
+
+  keysIntersection(keys: string[] | number[]): string[] {
+    return intersection(keys.map((key: string | number) => key.toString()), this.keys);
+  }
+
+  /**
+   * Group collection items by passed path into items object
+   */
+  private groupItems(collection: Collection, path: string): void {
+    // Create empty initial object for groups
+    const obj: { [key: string]: Array<object> } = {};
+
+    // Group collection items
+    collection.items.forEach((item: object): void => {
+      const keys: string[] = Array.isArray(get(item, path)) ? get(item, path) : [get(item, path)];
+
+      keys.forEach(key => {
+        // if object does not have property for grouping it will be grouped as 'other'
+        if (key === undefined) {
+          key = 'other';
+        }
+
+        if (!obj[key]) {
+          obj[key] = [];
+        }
+
+        obj[key].push(item);
+      });
+    });
+
+    // Create collections from groups
+    Object.keys(obj).forEach((key: string): void => {
+      this.items[key] = this.createCollection(obj[key]);
+    });
+  }
+
+  filter(callback: (collection: Collection) => boolean): CollectionDictionary<Collection> {
+    const collectionDictionary = new CollectionDictionary(this.createCollection());
+
+    for (const key in this.items) {
+      if (callback(this.get(key))) {
+        collectionDictionary.add(key, this.get(key));
+      }
+    }
+
+    return collectionDictionary;
+  }
+}