gemcap-be-common 1.2.136 → 1.2.138

package/services/users.service.d.ts

@@ -24,9 +24,9 @@
 /// <reference types="mongoose/types/inferschematype" />
 import express from 'express';
 import mongoose from 'mongoose';
+import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 import { IUser, IUserDocument } from '../models/User.model';
 import { IGroupedKeycloakRoles, IKeycloakRole } from '../interfaces/keycloak-role.interface';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 interface IKeycloakConfig {
     keycloakHost: string;
     realm: string;
@@ -55,12 +55,12 @@ export declare class UsersService {
             hasAccess: boolean;
             canSignDocument: boolean;
         };
-        email: string;
         firstName: string;
         lastName: string;
         roles?: IGroupedKeycloakRoles;
         username: string;
         enabled: boolean;
+        email: string;
         emailVerified: boolean;
         access: {
             manageGroupMembership: boolean;
@@ -141,12 +141,12 @@ export declare class UsersService {
             hasAccess: boolean;
             canSignDocument: boolean;
         };
-        email: string;
         firstName: string;
         lastName: string;
         roles?: IGroupedKeycloakRoles;
         username: string;
         enabled: boolean;
+        email: string;
         emailVerified: boolean;
         access: {
             manageGroupMembership: boolean;

package/services/users.service.js

@@ -10,11 +10,11 @@ const axios_1 = __importDefault(require("axios"));
 const dayjs_1 = __importDefault(require("dayjs"));
 const mongoose_1 = __importDefault(require("mongoose"));
 const qs_1 = __importDefault(require("qs"));
+const user_logs_db_1 = require("../db/user-logs.db");
 const User_model_1 = require("../models/User.model");
 const BorrowerCompliance_model_1 = require("../models/BorrowerCompliance.model");
 const UserMobileAccess_model_1 = require("../models/UserMobileAccess.model");
 const UserLog_model_1 = require("../models/UserLog.model");
-const user_logs_db_1 = require("../db/user-logs.db");
 class UsersService {
     config;
     constructor(config) {
@@ -343,13 +343,13 @@ class UsersService {
                     return;
                 }
                 await Promise.all(Array.from(dateSet).map(async (date) => {
-                    const existingLog = await this.getUserLogByDate(user._id, new Date(date));
+                    const existingLog = await this.getUserLogByDate(String(user._id), new Date(date));
                     if (!existingLog) {
                         const newLog = {
                             action: UserLog_model_1.ELogActionType.CREATE,
                             timestamp: new Date(date),
                             logType: UserLog_model_1.ELogType.LOGIN,
-                            userId: user._id,
+                            userId: String(user._id),
                             details: {},
                         };
                         await (0, user_logs_db_1.createLog)(newLog);

package/services/users.service.ts

@@ -6,13 +6,13 @@ import dayjs from 'dayjs';
 import mongoose from 'mongoose';
 import qs from 'qs';
 
+import { createLog, ICreateLogParams } from '../db/user-logs.db';
+import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
 import { IUser, IUserDocument, UserModel } from '../models/User.model';
 import { BorrowerCompliance } from '../models/BorrowerCompliance.model';
 import { UserMobileAccess } from '../models/UserMobileAccess.model';
 import { ELogActionType, ELogType, UserLog } from '../models/UserLog.model';
 import { IGroupedKeycloakRoles, IKeycloakRole } from '../interfaces/keycloak-role.interface';
-import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
-import { createLog, ICreateLogParams } from '../db/user-logs.db';
 
 interface IKeycloakConfig {
   keycloakHost: string;
@@ -384,13 +384,13 @@ export class UsersService {
           return;
         }
         await Promise.all(Array.from(dateSet).map(async (date) => {
-          const existingLog = await this.getUserLogByDate(user._id, new Date(date));
+          const existingLog = await this.getUserLogByDate(String(user._id), new Date(date));
           if (!existingLog) {
             const newLog: ICreateLogParams = {
               action: ELogActionType.CREATE,
               timestamp: new Date(date),
               logType: ELogType.LOGIN,
-              userId: user._id,
+              userId: String(user._id),
               details: {},
             };
             await createLog(newLog);

package/services/yield.service.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import mongoose from 'mongoose';
+import { ISelectedMonth } from '../helpers/date.helper';
+import { IYieldParams } from '../models/Yield.model';
+import { ILoanChargeDoc } from '../models/LoanCharges.model';
+import { ILoanProductDoc } from '../models/LoanProducts.model';
+interface IYieldViewData {
+    order: number;
+    charge: ILoanChargeDoc;
+    product: ILoanProductDoc;
+    title: string;
+    class?: string;
+    [data: string]: number | string | ILoanChargeDoc | ILoanProductDoc;
+}
+export declare class YieldService {
+    private getCalculatedYieldData;
+    getCalculatedYieldTotals(productId: string, selectedMonth: ISelectedMonth): Promise<(mongoose.FlattenMaps<import("../models/Yield.model").IYieldData> & Required<{
+        _id: mongoose.Types.ObjectId;
+    }>)[]>;
+    getCalculatedYieldTotalsForPeriod(productId: string, periodStart: ISelectedMonth, periodEnd: ISelectedMonth): Promise<(mongoose.FlattenMaps<import("../models/Yield.model").IYieldData> & Required<{
+        _id: mongoose.Types.ObjectId;
+    }>)[]>;
+    getYieldData(params: IYieldParams): Promise<{
+        data: IYieldViewData[];
+        dateColumns: string[];
+    }>;
+    createYieldTask(params: IYieldParams): Promise<void>;
+    private getEmptyResult;
+}
+export {};

package/services/yield.service.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YieldService = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const mongoose_1 = __importDefault(require("mongoose"));
+const date_helper_1 = require("../helpers/date.helper");
+const Yield_model_1 = require("../models/Yield.model");
+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");
+class YieldService {
+    async getCalculatedYieldData(charge, selectedMonth) {
+        const oldData = await Yield_model_1.YieldData.findOne({
+            chargeId: charge._id,
+            productId: charge.productId,
+            year: selectedMonth.year,
+            month: selectedMonth.month,
+        }).lean();
+        if (oldData) {
+            return oldData.valuePercent;
+        }
+        return null;
+    }
+    async getCalculatedYieldTotals(productId, selectedMonth) {
+        return Yield_model_1.YieldData.find({
+            chargeId: null,
+            productId: productId,
+            year: selectedMonth.year,
+            month: selectedMonth.month,
+        }).lean();
+    }
+    async getCalculatedYieldTotalsForPeriod(productId, periodStart, periodEnd) {
+        return Yield_model_1.YieldData.find({
+            productId: new mongoose_1.default.Types.ObjectId(productId),
+            $or: [
+                {
+                    year: periodStart.year,
+                    month: { $gte: periodStart.month },
+                },
+                {
+                    year: periodEnd.year,
+                    month: { $lte: periodEnd.month },
+                },
+                {
+                    year: { $gt: periodStart.year, $lt: periodEnd.year },
+                },
+            ],
+        }).sort({
+            year: 1,
+            month: 1,
+        }).lean();
+    }
+    async getYieldData(params) {
+        const validationRes = Yield_model_1.yieldParamsValidationSchema.validate(params);
+        if (validationRes.error) {
+            console.error(validationRes.error);
+            return null;
+        }
+        if (params.ignoreOldData) {
+            return await this.getEmptyResult(params);
+        }
+        const startDate = (0, date_helper_1.convertSelectedMonthToDate)(params.periodStart);
+        const endDate = (0, date_helper_1.convertSelectedMonthToDate)(params.periodEnd);
+        const charges = await LoanCharges_model_1.LoanCharge.find({ includeInYield: true }).lean();
+        const productIDs = charges.reduce((acc, charge) => [...acc, charge.productId.toString()], []);
+        const products = await LoanProducts_model_1.LoanProduct
+            .find({ _id: { $in: Object.values(productIDs).map((id) => new mongoose_1.default.Types.ObjectId(id)) } })
+            .populate('borrowerId')
+            .lean();
+        const productMap = products
+            .reduce((acc, product) => {
+            return {
+                ...acc,
+                [product._id.toString()]: {
+                    product,
+                    charges: charges.filter((charge) => charge.productId.toString() == product._id.toString()),
+                },
+            };
+        }, {});
+        const allDates = (0, date_helper_1.getStartOfMonthsBetweenDates)(startDate, endDate);
+        const allResults = [];
+        let hasAllData = true;
+        await Promise.all(Object.keys(productMap).map(async (productId) => {
+            await Promise.all(productMap[productId].charges.map(async (charge) => {
+                const monthlyData = {
+                    charge,
+                    product: productMap[charge.productId.toString()].product,
+                    order: 0,
+                    title: productMap[charge.productId.toString()].product.name,
+                };
+                await Promise.all(Object.entries(allDates).map(async ([dateView, date]) => {
+                    if (!hasAllData) {
+                        return;
+                    }
+                    const yieldDataValuePercent = await this.getCalculatedYieldData(charge, date);
+                    if (!yieldDataValuePercent) {
+                        console.error(`Yield data not found for product ${productMap[productId].product.name} for charge ${charge.name} and date ${dateView}`);
+                        hasAllData = false;
+                    }
+                    else {
+                        monthlyData[`valuePercent-${dateView}`] = yieldDataValuePercent;
+                    }
+                }));
+                allResults.push({ ...monthlyData });
+            }));
+        }));
+        if (!hasAllData) {
+            // return await this.getEmptyResult(params); // TODO return it
+        }
+        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,
+            ];
+            const productTotal = productTotalList.reduce((acc, p) => {
+                return {
+                    ...acc,
+                    [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,
+                    },
+                };
+            }, {});
+            await Promise.all(Object.entries(allDates).map(async ([dateView, dateValue]) => {
+                const productTotals = await this.getCalculatedYieldTotals(product._id.toString(), dateValue);
+                Object.keys(productTotal).forEach((totalType) => {
+                    const foundType = productTotals.find((total) => total.totalType === totalType);
+                    if (foundType) {
+                        productTotal[totalType][`value-${dateView}`] = foundType.value;
+                        productTotal[totalType][`valuePercent-${dateView}`] = foundType.valuePercent;
+                    }
+                });
+            }));
+            Object.values(productTotal).forEach((values) => {
+                allResults.push(values);
+            });
+        }));
+        const sortedData = lodash_1.default.orderBy(allResults, ['product.borrowerId.name', 'product.order', 'order', 'charge.name'], ['asc', 'asc', 'asc', 'asc']);
+        return { data: sortedData, dateColumns: Object.keys(allDates) };
+    }
+    async createYieldTask(params) {
+        await (0, microservice_tasks_db_1.createMicroserviceTasks)(microservice_task_enum_1.EMicroserviceTask.YIELD, params);
+    }
+    async getEmptyResult(params) {
+        await this.createYieldTask(params);
+        return { data: [], dateColumns: [] };
+    }
+}
+exports.YieldService = YieldService;

package/services/yield.service.ts

@@ -0,0 +1,198 @@
+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 { ILoanChargeDoc, LoanCharge } from '../models/LoanCharges.model';
+import { ILoanProductDoc, LoanProduct } from '../models/LoanProducts.model';
+import { createMicroserviceTasks } from '../db/microservice-tasks.db';
+import { EMicroserviceTask } from '../enums/microservice-task.enum';
+
+interface IYieldViewData {
+  order: number;
+  charge: ILoanChargeDoc;
+  product: ILoanProductDoc;
+  title: string;
+  class?: string;
+
+  [data: string]: number | string | ILoanChargeDoc | ILoanProductDoc;
+}
+
+export class YieldService {
+
+  private async getCalculatedYieldData(charge: ILoanChargeDoc, selectedMonth: ISelectedMonth) {
+    const oldData = await YieldData.findOne({
+      chargeId: charge._id,
+      productId: charge.productId,
+      year: selectedMonth.year,
+      month: selectedMonth.month,
+    }).lean();
+    if (oldData) {
+      return oldData.valuePercent;
+    }
+    return null;
+  }
+
+  async getCalculatedYieldTotals(productId: string, selectedMonth: ISelectedMonth) {
+    return YieldData.find({
+      chargeId: null,
+      productId: productId,
+      year: selectedMonth.year,
+      month: selectedMonth.month,
+    }).lean();
+  }
+
+  async getCalculatedYieldTotalsForPeriod(productId: string, periodStart: ISelectedMonth, periodEnd: ISelectedMonth) {
+    return YieldData.find({
+      productId: new mongoose.Types.ObjectId(productId),
+      $or: [
+        {
+          year: periodStart.year,
+          month: { $gte: periodStart.month },
+        },
+        {
+          year: periodEnd.year,
+          month: { $lte: periodEnd.month },
+        },
+        {
+          year: { $gt: periodStart.year, $lt: periodEnd.year },
+        },
+      ],
+    }).sort({
+      year: 1,
+      month: 1,
+    }).lean();
+  }
+
+  async getYieldData(params: IYieldParams): Promise<{ data: IYieldViewData[], dateColumns: string[] }> {
+    const validationRes = yieldParamsValidationSchema.validate(params);
+    if (validationRes.error) {
+      console.error(validationRes.error);
+      return null;
+    }
+
+    if (params.ignoreOldData) {
+      return await this.getEmptyResult(params);
+    }
+
+    const startDate = convertSelectedMonthToDate(params.periodStart);
+    const endDate = convertSelectedMonthToDate(params.periodEnd);
+    const charges = await LoanCharge.find({ includeInYield: true }).lean();
+
+    const productIDs = charges.reduce((acc, charge) => [...acc, charge.productId.toString()], <string[]>[]);
+
+    const products = await LoanProduct
+      .find({ _id: { $in: Object.values(productIDs).map((id) => new mongoose.Types.ObjectId(id)) } })
+      .populate('borrowerId')
+      .lean();
+
+    const productMap = products
+      .reduce((acc, product) => {
+        return {
+          ...acc,
+          [product._id.toString()]: {
+            product,
+            charges: charges.filter((charge) => charge.productId.toString() == product._id.toString()),
+          },
+        };
+      }, <{ [productId: string]: { product: ILoanProductDoc, charges: ILoanChargeDoc[] } }>{});
+
+    const allDates = getStartOfMonthsBetweenDates(startDate, endDate);
+
+    const allResults: IYieldViewData[] = [];
+
+    let hasAllData = true;
+
+    await Promise.all(Object.keys(productMap).map(async (productId) => {
+
+      await Promise.all(productMap[productId].charges.map(async (charge) => {
+
+        const monthlyData = {
+          charge,
+          product: productMap[charge.productId.toString()].product,
+          order: 0,
+          title: productMap[charge.productId.toString()].product.name,
+        };
+
+        await Promise.all(Object.entries(allDates).map(async ([dateView, date]) => {
+          if (!hasAllData) {
+            return;
+          }
+          const yieldDataValuePercent = await this.getCalculatedYieldData(charge, date);
+          if (!yieldDataValuePercent) {
+            console.error(`Yield data not found for product ${productMap[productId].product.name} for charge ${charge.name} and date ${dateView}`);
+            hasAllData = false;
+          } else {
+            monthlyData[`valuePercent-${dateView}`] = yieldDataValuePercent;
+          }
+        }));
+
+        allResults.push({ ...monthlyData });
+
+      }));
+
+    }));
+
+    if (!hasAllData) {
+      // return await this.getEmptyResult(params); // TODO return it
+    }
+
+    await Promise.all(products.map(async (product) => {
+
+      const productTotalList = [
+        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 {
+          ...acc,
+          [p]: {
+            charge: null,
+            product,
+            order: YIELD_TOTALS_MAP[p].order,
+            title: `${product.name} (${YIELD_TOTALS_MAP[p].title})`,
+            class: YIELD_TOTALS_MAP[p].class,
+          },
+        };
+      }, {});
+
+      await Promise.all(Object.entries(allDates).map(async ([dateView, dateValue]) => {
+        const productTotals = await this.getCalculatedYieldTotals(product._id.toString(), dateValue);
+        Object.keys(productTotal).forEach((totalType) => {
+          const foundType = productTotals.find((total) => total.totalType === totalType);
+          if (foundType) {
+            productTotal[totalType][`value-${dateView}`] = foundType.value;
+            productTotal[totalType][`valuePercent-${dateView}`] = foundType.valuePercent;
+          }
+        });
+      }));
+      Object.values(productTotal).forEach((values: IYieldViewData) => {
+        allResults.push(values);
+      });
+    }));
+
+    const sortedData = _.orderBy(allResults, ['product.borrowerId.name', 'product.order', 'order', 'charge.name'], ['asc', 'asc', 'asc', 'asc']);
+    return { data: sortedData, dateColumns: Object.keys(allDates) };
+  }
+
+  async createYieldTask(params: IYieldParams) {
+    await createMicroserviceTasks(EMicroserviceTask.YIELD, params);
+  }
+
+  private async getEmptyResult(params: IYieldParams) {
+    await this.createYieldTask(params);
+    return { data: [], dateColumns: [] };
+  }
+}