gemcap-be-common 1.2.140 → 1.3.0

package/services/user-logs.service.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserLogsService = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const user_logs_db_1 = require("../db/user-logs.db");
+const UserLog_model_1 = require("../models/UserLog.model");
+const DeletedRecords_model_1 = require("../models/DeletedRecords.model");
+const createLogs = true;
+class UserLogsService {
+    banksService;
+    borrowerService;
+    loanChargesService;
+    constructor(banksService, borrowerService, loanChargesService) {
+        this.banksService = banksService;
+        this.borrowerService = borrowerService;
+        this.loanChargesService = loanChargesService;
+    }
+    async createUserLog(params) {
+        if (createLogs) {
+            await (0, user_logs_db_1.createLog)(params);
+        }
+    }
+    async filterByBorrower(logs, borrowerId) {
+        const products = await this.loanChargesService.getBorrowersLoanProducts(borrowerId);
+        const productIds = products.map((product) => product._id.toString());
+        return logs.filter((r) => {
+            if (r.logType === UserLog_model_1.ELogType.LOAN_TRANSACTION && r.record) {
+                return productIds.includes(r.record.productId.toString());
+            }
+            if (r.details && r.details.hasOwnProperty('borrowerId')) {
+                if (r.details.borrowerId && r.details.borrowerId === borrowerId) {
+                    return true;
+                }
+            }
+            return false;
+        });
+    }
+    async replaceBorrowers(logs) {
+        const convertToMap = (arr) => {
+            return arr.reduce((acc, item) => {
+                acc.set(item._id.toString(), item.name);
+                return acc;
+            }, new Map());
+        };
+        const borrowers = await this.borrowerService.getAllBorrowers();
+        const borrowersMap = convertToMap(borrowers);
+        const products = await this.loanChargesService.getAllLoanProducts();
+        const productsMap = convertToMap(products);
+        const banks = await this.banksService.getBanks();
+        const banksMap = convertToMap(banks);
+        const replacedFields = {
+            borrowerId: borrowersMap,
+            productId: productsMap,
+            bankId: banksMap,
+        };
+        return logs.map((r) => {
+            Object.keys(replacedFields).forEach((key) => {
+                if (r.details && r.details.hasOwnProperty(key) && r.details[key]) {
+                    r.details[key] = `${replacedFields[key].get(r.details[key].toString())} (${r.details[key].toString()})`;
+                }
+                if (r.record && r.record.hasOwnProperty(key) && r.record[key]) {
+                    r.record[key] = `${replacedFields[key].get(r.record[key].toString())} (${r.record[key].toString()})`;
+                }
+            });
+        });
+    }
+    async performDynamicLookup(record) {
+        try {
+            const { _id, recordCollection } = record;
+            if (!recordCollection) {
+                return record;
+            }
+            const pipeline = [
+                {
+                    $match: {
+                        _id,
+                    },
+                },
+                {
+                    $lookup: {
+                        from: recordCollection,
+                        localField: 'recordId',
+                        foreignField: '_id',
+                        as: 'record',
+                    },
+                },
+                {
+                    $unwind: {
+                        path: '$record',
+                        preserveNullAndEmptyArrays: true,
+                    },
+                },
+            ];
+            const result = await UserLog_model_1.UserLog.aggregate(pipeline);
+            if (result.length > 0 && result[0]) {
+                const foundRecord = result[0].record;
+                if (!foundRecord) {
+                    const deletedRecord = await DeletedRecords_model_1.DeletedRecord
+                        .findOne({ DBCollection: recordCollection, recordId: record.recordId })
+                        .lean();
+                    if (deletedRecord) {
+                        result[0].record = deletedRecord.record;
+                    }
+                }
+                return result[0];
+            }
+            return record;
+        }
+        catch (error) {
+            console.error('Error performing dynamic lookup:', error);
+            throw error;
+        }
+    }
+    async getLogs(filter) {
+        const logs = await UserLog_model_1.UserLog.aggregate([
+            {
+                $match: {
+                    $and: [
+                        { 'timestamp': { $gte: filter.periodStart } },
+                        { 'timestamp': { $lte: filter.periodEnd } },
+                        filter.userId ? { 'userId': new mongoose_1.default.Types.ObjectId(filter.userId) } : {},
+                    ],
+                },
+            },
+            {
+                $sort: {
+                    'timestamp': 1,
+                },
+            },
+        ]);
+        const logsWithRecord = await Promise.all(logs.map(async (log) => await this.performDynamicLookup(log)));
+        const filteredByBorrowers = !filter.borrowerId
+            ? logsWithRecord.slice()
+            : await this.filterByBorrower(logsWithRecord, filter.borrowerId);
+        await this.replaceBorrowers(filteredByBorrowers);
+        return filteredByBorrowers;
+    }
+    async getDocumentLogs(documentId) {
+        const logs = await UserLog_model_1.UserLog.aggregate([
+            {
+                $match: {
+                    $and: [
+                        { 'recordCollection': 'loan_transactions' },
+                        { 'recordId': new mongoose_1.default.Types.ObjectId(documentId) },
+                    ],
+                },
+            },
+            {
+                $sort: {
+                    'timestamp': 1,
+                },
+            },
+        ]);
+        return await Promise.all(logs.map(async (log) => await this.performDynamicLookup(log)));
+    }
+}
+exports.UserLogsService = UserLogsService;

package/services/user-logs.service.ts

@@ -0,0 +1,177 @@
+import mongoose from 'mongoose';
+
+import { createLog, ICreateLogParams } from '../db/user-logs.db';
+import { ELogType, IUserLog, IUserLogWithLookup, UserLog } from '../models/UserLog.model';
+import { DeletedRecord } from '../models/DeletedRecords.model';
+
+import { BanksService } from './banks.service';
+import { BorrowerService } from './borrowers.service';
+import { LoanChargesService } from './loan-charges.service';
+
+export interface IUserLogFilter {
+  userId: string;
+  borrowerId: string;
+  periodStart: Date;
+  periodEnd: Date;
+}
+
+const createLogs = true;
+
+export class UserLogsService {
+
+  constructor(
+    private readonly banksService: BanksService,
+    private readonly borrowerService: BorrowerService,
+    private readonly loanChargesService: LoanChargesService,
+  ) {
+  }
+
+  async createUserLog(params: ICreateLogParams) {
+    if (createLogs) {
+      await createLog(params);
+    }
+  }
+
+  async filterByBorrower(logs: IUserLogWithLookup[], borrowerId: string): Promise<IUserLogWithLookup[]> {
+    const products = await this.loanChargesService.getBorrowersLoanProducts(borrowerId);
+    const productIds = products.map((product) => <string>product._id.toString());
+    return logs.filter((r) => {
+      if (r.logType === ELogType.LOAN_TRANSACTION && r.record) {
+        return productIds.includes(r.record.productId.toString());
+      }
+      if (r.details && r.details.hasOwnProperty('borrowerId')) {
+        if (r.details.borrowerId && r.details.borrowerId === borrowerId) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+
+  async replaceBorrowers(logs: IUserLogWithLookup[]) {
+    const convertToMap = (arr: any[]): Map<string, string> => {
+      return arr.reduce((acc, item) => {
+        acc.set(item._id.toString(), item.name);
+        return acc;
+      }, new Map<string, string>());
+    };
+    const borrowers = await this.borrowerService.getAllBorrowers();
+    const borrowersMap = convertToMap(borrowers);
+
+    const products = await this.loanChargesService.getAllLoanProducts();
+    const productsMap = convertToMap(products);
+
+    const banks = await this.banksService.getBanks();
+    const banksMap = convertToMap(banks);
+
+    const replacedFields = {
+      borrowerId: borrowersMap,
+      productId: productsMap,
+      bankId: banksMap,
+    };
+
+    return logs.map((r) => {
+      Object.keys(replacedFields).forEach((key) => {
+        if (r.details && r.details.hasOwnProperty(key) && r.details[key]) {
+          r.details[key] = `${replacedFields[key].get(r.details[key].toString())} (${r.details[key].toString()})`;
+        }
+        if (r.record && r.record.hasOwnProperty(key) && r.record[key]) {
+          r.record[key] = `${replacedFields[key].get(r.record[key].toString())} (${r.record[key].toString()})`;
+        }
+      });
+    });
+  }
+
+  async performDynamicLookup(record: IUserLog): Promise<IUserLogWithLookup> {
+    try {
+      const { _id, recordCollection } = record;
+      if (!recordCollection) {
+        return record;
+      }
+
+      const pipeline = [
+        {
+          $match: {
+            _id,
+          },
+        },
+        {
+          $lookup: {
+            from: recordCollection,
+            localField: 'recordId',
+            foreignField: '_id',
+            as: 'record',
+          },
+        },
+        {
+          $unwind: {
+            path: '$record',
+            preserveNullAndEmptyArrays: true,
+          },
+        },
+      ];
+
+      const result = await UserLog.aggregate(pipeline);
+      if (result.length > 0 && result[0]) {
+        const foundRecord = result[0].record;
+        if (!foundRecord) {
+          const deletedRecord = await DeletedRecord
+            .findOne({ DBCollection: recordCollection, recordId: record.recordId })
+            .lean();
+          if (deletedRecord) {
+            result[0].record = deletedRecord.record;
+          }
+        }
+        return result[0];
+      }
+      return record;
+    } catch (error) {
+      console.error('Error performing dynamic lookup:', error);
+      throw error;
+    }
+  }
+
+  async getLogs(filter: IUserLogFilter) {
+    const logs = await UserLog.aggregate<IUserLog>([
+      {
+        $match: {
+          $and: [
+            { 'timestamp': { $gte: filter.periodStart } },
+            { 'timestamp': { $lte: filter.periodEnd } },
+            filter.userId ? { 'userId': new mongoose.Types.ObjectId(filter.userId) } : {},
+          ],
+        },
+      },
+      {
+        $sort: {
+          'timestamp': 1,
+        },
+      },
+    ]);
+    const logsWithRecord = await Promise.all(logs.map(async (log) => await this.performDynamicLookup(log)));
+    const filteredByBorrowers = !filter.borrowerId
+      ? logsWithRecord.slice()
+      : await this.filterByBorrower(logsWithRecord, filter.borrowerId);
+    await this.replaceBorrowers(filteredByBorrowers);
+    return filteredByBorrowers;
+  }
+
+  async getDocumentLogs(documentId: string) {
+    const logs = await UserLog.aggregate<IUserLog>([
+      {
+        $match: {
+          $and: [
+            { 'recordCollection': 'loan_transactions' },
+            { 'recordId': new mongoose.Types.ObjectId(documentId) },
+          ],
+        },
+      },
+      {
+        $sort: {
+          'timestamp': 1,
+        },
+      },
+    ]);
+    return await Promise.all(logs.map(async (log) => await this.performDynamicLookup(log)));
+  }
+}

package/services/users.service.d.ts

@@ -57,10 +57,10 @@ export declare class UsersService {
         };
         firstName: string;
         lastName: string;
-        roles?: IGroupedKeycloakRoles;
-        username: string;
         enabled: boolean;
+        username: string;
         email: string;
+        roles?: IGroupedKeycloakRoles;
         emailVerified: boolean;
         access: {
             manageGroupMembership: boolean;
@@ -143,10 +143,10 @@ export declare class UsersService {
         };
         firstName: string;
         lastName: string;
-        roles?: IGroupedKeycloakRoles;
-        username: string;
         enabled: boolean;
+        username: string;
         email: string;
+        roles?: IGroupedKeycloakRoles;
         emailVerified: boolean;
         access: {
             manageGroupMembership: boolean;

package/services/yield.service.d.ts

@@ -35,6 +35,52 @@ interface IYieldViewData {
     class?: string;
     [data: string]: number | string | ILoanChargeDoc | ILoanProductDoc;
 }
+export declare enum ETotalType {
+    AVERAGE_BALANCE = "AVERAGE_BALANCE",
+    AVERAGE_LIFE_BALANCE = "AVERAGE_LIFE_BALANCE",
+    BROKER = "BROKER",
+    GROSS = "GROSS",
+    NET = "NET",
+    APR_GROSS = "APR_GROSS",
+    APR_LIFE_GROSS = "APR_LIFE_GROSS"
+}
+export declare const YIELD_TOTALS_MAP: {
+    AVERAGE_BALANCE: {
+        order: number;
+        title: string;
+        class: string;
+    };
+    AVERAGE_LIFE_BALANCE: {
+        order: number;
+        title: string;
+        class: string;
+    };
+    GROSS: {
+        order: number;
+        title: string;
+        class: string;
+    };
+    BROKER: {
+        order: number;
+        title: string;
+        class: string;
+    };
+    NET: {
+        order: number;
+        title: string;
+        class: string;
+    };
+    APR_GROSS: {
+        order: number;
+        title: string;
+        class: string;
+    };
+    APR_LIFE_GROSS: {
+        order: number;
+        title: string;
+        class: string;
+    };
+};
 export declare class YieldService {
     private getCalculatedYieldData;
     getCalculatedYieldTotals(productId: string, selectedMonth: ISelectedMonth): Promise<(mongoose.FlattenMaps<import("../models/Yield.model").IYieldData> & Required<{

package/services/yield.service.js

@@ -3,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.YieldService = void 0;
+exports.YieldService = exports.YIELD_TOTALS_MAP = exports.ETotalType = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
 const lodash_1 = __importDefault(require("lodash"));
 const mongoose_1 = __importDefault(require("mongoose"));
 const date_helper_1 = require("../helpers/date.helper");
@@ -12,6 +13,35 @@ const LoanCharges_model_1 = require("../models/LoanCharges.model");
 const LoanProducts_model_1 = require("../models/LoanProducts.model");
 const microservice_tasks_db_1 = require("../db/microservice-tasks.db");
 const microservice_task_enum_1 = require("../enums/microservice-task.enum");
+function getStartOfMonthsBetweenDates(startDate, endDate) {
+    let start = (0, dayjs_1.default)(startDate).utcOffset(0).startOf('month');
+    const end = (0, dayjs_1.default)(endDate).utcOffset(0).startOf('month');
+    const dates = {};
+    while (start.isBefore(end) || start.isSame(end)) {
+        dates[start.format('YYYY-MM')] = { year: start.year(), month: start.month() + 1 };
+        start = start.add(1, 'month');
+    }
+    return dates;
+}
+var ETotalType;
+(function (ETotalType) {
+    ETotalType["AVERAGE_BALANCE"] = "AVERAGE_BALANCE";
+    ETotalType["AVERAGE_LIFE_BALANCE"] = "AVERAGE_LIFE_BALANCE";
+    ETotalType["BROKER"] = "BROKER";
+    ETotalType["GROSS"] = "GROSS";
+    ETotalType["NET"] = "NET";
+    ETotalType["APR_GROSS"] = "APR_GROSS";
+    ETotalType["APR_LIFE_GROSS"] = "APR_LIFE_GROSS";
+})(ETotalType || (exports.ETotalType = ETotalType = {}));
+exports.YIELD_TOTALS_MAP = {
+    [ETotalType.AVERAGE_BALANCE]: { order: -2, title: 'Average Balance in Month $', class: 'whiteOnOrange' },
+    [ETotalType.AVERAGE_LIFE_BALANCE]: { order: -1, title: 'Average loan life balance $', class: 'whiteOnOrange' },
+    [ETotalType.GROSS]: { order: 1, title: 'Gross income $', class: 'whiteOnGray' },
+    [ETotalType.BROKER]: { order: 2, title: 'Broker Fees $', class: 'whiteOnGray' },
+    [ETotalType.NET]: { order: 3, title: 'Net income $', class: 'whiteOnGray' },
+    [ETotalType.APR_GROSS]: { order: 6, title: 'Yield in month', class: 'whiteOnBlack' },
+    [ETotalType.APR_LIFE_GROSS]: { order: 7, title: 'Yield since inception', class: 'whiteOnBlack' },
+};
 class YieldService {
     async getCalculatedYieldData(charge, selectedMonth) {
         const oldData = await Yield_model_1.YieldData.findOne({
@@ -81,7 +111,7 @@ class YieldService {
                 },
             };
         }, {});
-        const allDates = (0, date_helper_1.getStartOfMonthsBetweenDates)(startDate, endDate);
+        const allDates = getStartOfMonthsBetweenDates(startDate, endDate);
         const allResults = [];
         let hasAllData = true;
         await Promise.all(Object.keys(productMap).map(async (productId) => {
@@ -113,13 +143,13 @@ class YieldService {
         }
         await Promise.all(products.map(async (product) => {
             const productTotalList = [
-                Yield_model_1.ETotalType.GROSS,
-                Yield_model_1.ETotalType.BROKER,
-                Yield_model_1.ETotalType.NET,
-                Yield_model_1.ETotalType.AVERAGE_BALANCE,
-                Yield_model_1.ETotalType.AVERAGE_LIFE_BALANCE,
-                Yield_model_1.ETotalType.APR_GROSS,
-                Yield_model_1.ETotalType.APR_LIFE_GROSS,
+                ETotalType.GROSS,
+                ETotalType.BROKER,
+                ETotalType.NET,
+                ETotalType.AVERAGE_BALANCE,
+                ETotalType.AVERAGE_LIFE_BALANCE,
+                ETotalType.APR_GROSS,
+                ETotalType.APR_LIFE_GROSS,
             ];
             const productTotal = productTotalList.reduce((acc, p) => {
                 return {
@@ -127,9 +157,9 @@ class YieldService {
                     [p]: {
                         charge: null,
                         product,
-                        order: Yield_model_1.YIELD_TOTALS_MAP[p].order,
-                        title: `${product.name} (${Yield_model_1.YIELD_TOTALS_MAP[p].title})`,
-                        class: Yield_model_1.YIELD_TOTALS_MAP[p].class,
+                        order: exports.YIELD_TOTALS_MAP[p].order,
+                        title: `${product.name} (${exports.YIELD_TOTALS_MAP[p].title})`,
+                        class: exports.YIELD_TOTALS_MAP[p].class,
                     },
                 };
             }, {});

package/services/yield.service.ts

@@ -1,14 +1,9 @@
+import dayjs from 'dayjs';
 import _ from 'lodash';
 import mongoose from 'mongoose';
 
-import { convertSelectedMonthToDate, getStartOfMonthsBetweenDates, ISelectedMonth } from '../helpers/date.helper';
-import {
-  ETotalType,
-  IYieldParams,
-  YIELD_TOTALS_MAP,
-  YieldData,
-  yieldParamsValidationSchema,
-} from '../models/Yield.model';
+import { convertSelectedMonthToDate, ISelectedMonth } from '../helpers/date.helper';
+import { IYieldParams, YieldData, yieldParamsValidationSchema } from '../models/Yield.model';
 import { ILoanChargeDoc, LoanCharge } from '../models/LoanCharges.model';
 import { ILoanProductDoc, LoanProduct } from '../models/LoanProducts.model';
 import { createMicroserviceTasks } from '../db/microservice-tasks.db';
@@ -24,6 +19,41 @@ interface IYieldViewData {
   [data: string]: number | string | ILoanChargeDoc | ILoanProductDoc;
 }
 
+function getStartOfMonthsBetweenDates(startDate: Date, endDate: Date): {
+  [dateView: string]: { year: number; month: number }
+} {
+  let start = dayjs(startDate).utcOffset(0).startOf('month');
+  const end = dayjs(endDate).utcOffset(0).startOf('month');
+  const dates = {};
+
+  while (start.isBefore(end) || start.isSame(end)) {
+    dates[start.format('YYYY-MM')] = <ISelectedMonth>{ year: start.year(), month: start.month() + 1 };
+    start = start.add(1, 'month');
+  }
+
+  return dates;
+}
+
+export enum ETotalType {
+  AVERAGE_BALANCE = 'AVERAGE_BALANCE',
+  AVERAGE_LIFE_BALANCE = 'AVERAGE_LIFE_BALANCE',
+  BROKER = 'BROKER',
+  GROSS = 'GROSS',
+  NET = 'NET',
+  APR_GROSS = 'APR_GROSS',
+  APR_LIFE_GROSS = 'APR_LIFE_GROSS',
+}
+
+export const YIELD_TOTALS_MAP = {
+  [ETotalType.AVERAGE_BALANCE]: { order: -2, title: 'Average Balance in Month $', class: 'whiteOnOrange' },
+  [ETotalType.AVERAGE_LIFE_BALANCE]: { order: -1, title: 'Average loan life balance $', class: 'whiteOnOrange' },
+  [ETotalType.GROSS]: { order: 1, title: 'Gross income $', class: 'whiteOnGray' },
+  [ETotalType.BROKER]: { order: 2, title: 'Broker Fees $', class: 'whiteOnGray' },
+  [ETotalType.NET]: { order: 3, title: 'Net income $', class: 'whiteOnGray' },
+  [ETotalType.APR_GROSS]: { order: 6, title: 'Yield in month', class: 'whiteOnBlack' },
+  [ETotalType.APR_LIFE_GROSS]: { order: 7, title: 'Yield since inception', class: 'whiteOnBlack' },
+};
+
 export class YieldService {
 
   private async getCalculatedYieldData(charge: ILoanChargeDoc, selectedMonth: ISelectedMonth) {

package/tsconfig.json

@@ -1,12 +1,12 @@
 {
   "compilerOptions": {
-    "incremental": true,
     "target": "ES2022",
     "module": "CommonJS",
-    "declaration": true,
     "esModuleInterop": true,
-    "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "experimentalDecorators": true
-  },
+    "skipLibCheck": true,
+    "experimentalDecorators": true,
+    "declaration": true,
+    "incremental": true
+  }
 }