refactor: banking services to Nestjs

2026-02-20 14:50:32 +00:00 · 2025-01-05 16:26:23 +02:00
parent b72f85b394
commit 1869ba216f
150 changed files with 9698 additions and 163 deletions
--- a/packages/server-nest/src/modules/BankingTranasctionsRegonize/commands/RecognizeTranasctions.service.ts
+++ b/packages/server-nest/src/modules/BankingTranasctionsRegonize/commands/RecognizeTranasctions.service.ts
@@ -0,0 +1,129 @@
+import { Knex } from 'knex';
+import { Inject, Injectable } from '@nestjs/common';
+import { castArray, isEmpty } from 'lodash';
+import { PromisePool } from '@supercharge/promise-pool';
+import { bankRulesMatchTransaction } from '../_utils';
+import { RecognizeTransactionsCriteria } from '../_types';
+import { BankRule } from '@/modules/BankRules/models/BankRule';
+import { RecognizedBankTransaction } from '../models/RecognizedBankTransaction';
+import { UncategorizedBankTransaction } from '@/modules/BankingTransactions/models/UncategorizedBankTransaction';
+import { transformToMapBy } from '@/utils/transform-to-map-by';
+
+@Injectable()
+export class RecognizeTranasctionsService {
+  constructor(
+    @Inject(UncategorizedBankTransaction.name)
+    private readonly uncategorizedCashflowTransactionModel: typeof UncategorizedBankTransaction,
+
+    @Inject(RecognizedBankTransaction.name)
+    private readonly recognizedBankTransactionModel: typeof RecognizedBankTransaction,
+
+    @Inject(BankRule.name)
+    private readonly bankRuleModel: typeof BankRule,
+  ) {}
+
+  /**
+   * Marks the uncategorized transaction as recognized from the given bank rule.
+   * @param {BankRule} bankRule -
+   * @param {UncategorizedCashflowTransaction} transaction -
+   * @param {Knex.Transaction} trx -
+   */
+  private async markBankRuleAsRecognized(
+    bankRule: BankRule,
+    transaction: UncategorizedBankTransaction,
+    trx?: Knex.Transaction,
+  ) {
+    const recognizedTransaction = await this.recognizedBankTransactionModel
+      .query(trx)
+      .insert({
+        bankRuleId: bankRule.id,
+        uncategorizedTransactionId: transaction.id,
+        assignedCategory: bankRule.assignCategory,
+        assignedAccountId: bankRule.assignAccountId,
+        assignedPayee: bankRule.assignPayee,
+        assignedMemo: bankRule.assignMemo,
+      });
+    await this.uncategorizedCashflowTransactionModel
+      .query(trx)
+      .findById(transaction.id)
+      .patch({
+        recognizedTransactionId: recognizedTransaction.id,
+      });
+  }
+
+  /**
+   * Regonized the uncategorized transactions.
+   * @param {number|Array<number>} ruleId - The target rule id/ids.
+   * @param {RecognizeTransactionsCriteria}
+   * @param {Knex.Transaction} trx -
+   */
+  public async recognizeTransactions(
+    ruleId?: number | Array<number>,
+    transactionsCriteria?: RecognizeTransactionsCriteria,
+    trx?: Knex.Transaction,
+  ) {
+    const uncategorizedTranasctions =
+      await this.uncategorizedCashflowTransactionModel
+        .query(trx)
+        .onBuild((query) => {
+          query.modify('notRecognized');
+          query.modify('notCategorized');
+
+          // Filter the transactions based on the given criteria.
+          if (transactionsCriteria?.batch) {
+            query.where('batch', transactionsCriteria.batch);
+          }
+          if (transactionsCriteria?.accountId) {
+            query.where('accountId', transactionsCriteria.accountId);
+          }
+        });
+
+    const bankRules = await this.bankRuleModel.query(trx).onBuild((q) => {
+      const rulesIds = !isEmpty(ruleId) ? castArray(ruleId) : [];
+
+      if (rulesIds?.length > 0) {
+        q.whereIn('id', rulesIds);
+      }
+      q.withGraphFetched('conditions');
+    });
+    const bankRulesByAccountId = transformToMapBy(
+      bankRules,
+      'applyIfAccountId',
+    );
+    // Try to recognize the transaction.
+    const regonizeTransaction = async (
+      transaction: UncategorizedBankTransaction,
+    ) => {
+      const allAccountsBankRules = bankRulesByAccountId.get(`null`);
+      const accountBankRules = bankRulesByAccountId.get(
+        `${transaction.accountId}`,
+      );
+      const recognizedBankRule = bankRulesMatchTransaction(
+        transaction,
+        accountBankRules,
+      );
+      if (recognizedBankRule) {
+        await this.markBankRuleAsRecognized(
+          recognizedBankRule,
+          transaction,
+          trx,
+        );
+      }
+    };
+    const result = await PromisePool.withConcurrency(MIGRATION_CONCURRENCY)
+      .for(uncategorizedTranasctions)
+      .process((transaction: UncategorizedBankTransaction, index, pool) => {
+        return regonizeTransaction(transaction);
+      });
+  }
+
+  /**
+   *
+   * @param {number} uncategorizedTransaction
+   */
+  public async regonizeTransaction(
+    uncategorizedTransaction: UncategorizedBankTransaction,
+  ) {}
+}
+
+const MIGRATION_CONCURRENCY = 10;
--- a/packages/server-nest/src/modules/BankingTranasctionsRegonize/commands/RevertRecognizedTransactions.service.ts
+++ b/packages/server-nest/src/modules/BankingTranasctionsRegonize/commands/RevertRecognizedTransactions.service.ts
@@ -0,0 +1,70 @@
+import { castArray } from 'lodash';
+import { Knex } from 'knex';
+import { Inject, Injectable } from '@nestjs/common';
+import { RevertRecognizedTransactionsCriteria } from '../_types';
+import { RecognizedBankTransaction } from '../models/RecognizedBankTransaction';
+import { UncategorizedBankTransaction } from '@/modules/BankingTransactions/models/UncategorizedBankTransaction';
+import { UnitOfWork } from '@/modules/Tenancy/TenancyDB/UnitOfWork.service';
+
+@Injectable()
+export class RevertRecognizedTransactionsService {
+  constructor(
+    private readonly uow: UnitOfWork,
+
+    @Inject(RecognizedBankTransaction.name)
+    private readonly recognizedBankTransactionModel: typeof RecognizedBankTransaction,
+
+    @Inject(UncategorizedBankTransaction.name)
+    private readonly uncategorizedBankTransactionModel: typeof UncategorizedBankTransaction,
+  ) {}
+
+  /**
+   * Revert and unlinks the recognized transactions based on the given bank rule
+   * and transactions criteria..
+   * @param {number|Array<number>} bankRuleId - Bank rule id.
+   * @param {RevertRecognizedTransactionsCriteria} transactionsCriteria -
+   * @param {Knex.Transaction} trx - Knex transaction.
+   * @returns {Promise<void>}
+   */
+  public async revertRecognizedTransactions(
+    ruleId?: number | Array<number>,
+    transactionsCriteria?: RevertRecognizedTransactionsCriteria,
+    trx?: Knex.Transaction,
+  ): Promise<void> {
+    const rulesIds = castArray(ruleId);
+
+    return this.uow.withTransaction(async (trx: Knex.Transaction) => {
+      // Retrieves all the recognized transactions of the banbk rule.
+      const uncategorizedTransactions =
+        await this.uncategorizedBankTransactionModel.query(trx).onBuild((q) => {
+          q.withGraphJoined('recognizedTransaction');
+          q.whereNotNull('recognizedTransaction.id');
+
+          if (rulesIds.length > 0) {
+            q.whereIn('recognizedTransaction.bankRuleId', rulesIds);
+          }
+          if (transactionsCriteria?.accountId) {
+            q.where('accountId', transactionsCriteria.accountId);
+          }
+          if (transactionsCriteria?.batch) {
+            q.where('batch', transactionsCriteria.batch);
+          }
+        });
+      const uncategorizedTransactionIds = uncategorizedTransactions.map(
+        (r) => r.id,
+      );
+      // Unlink the recongized transactions out of uncategorized transactions.
+      await this.uncategorizedBankTransactionModel
+        .query(trx)
+        .whereIn('id', uncategorizedTransactionIds)
+        .patch({
+          recognizedTransactionId: null,
+        });
+      // Delete the recognized bank transactions that assocaited to bank rule.
+      await this.recognizedBankTransactionModel
+        .query(trx)
+        .whereIn('uncategorizedTransactionId', uncategorizedTransactionIds)
+        .delete();
+    }, trx);
+  }
+}