gemcap-be-common 1.2.140 → 1.3.0

package/services/collaterals.service.ts

@@ -0,0 +1,319 @@
+import mongoose from 'mongoose';
+import _ from 'lodash';
+
+import { ECollaterals } from '../enums/collaterals.enum';
+import { IPaginatorOptions, IUploadedItems } from '../interfaces/collaterals.interface';
+import { BBCDateModel, IBBCDateDoc, ICreateBBCDate } from '../models/BBCDate.model';
+import { BBCSheetModel, IBBCSheetDoc, IBBCSheetWithBBCDate } from '../models/BBCSheet.model';
+import { IInventoryItem } from '../models/InventoryItem.model';
+import { IReceivableItem } from '../models/ReceivableItem.model';
+import {
+  IAccountPayableItem,
+} from '../models/AccountPayableItem.model';
+import { createBBCDate, getBBCDates, getBBCDatesByType } from '../db/bbcDates.db';
+import { createBBCSheet, getBBCSheetsByType } from '../db/bbcSheets.db';
+import {
+  collateralMap,
+  COLLATERALS_LOOKUP,
+  createQuery,
+  getCollateralListBySheetId,
+  ITEMS_PAGINATION,
+} from '../db/collaterals.db';
+import { getDigitsFrequencies } from '../helpers/numbers.helper';
+import { getEnumKeyByEnumValue } from '../helpers/enums.helper';
+
+import { GroupsService } from './groups.service';
+import { UploadsService } from './uploads.service';
+
+export class CollateralsService {
+
+  constructor(
+    private readonly _groupsService: GroupsService,
+    private readonly _uploadsService: UploadsService,
+  ) {
+  }
+
+  async findCollateralsByType(bbcDateId: string, collateralType: ECollaterals) {
+    const sheets = await this.findCollateralSheets(bbcDateId, collateralType);
+    return (await Promise.all(sheets.map(async (sheet) => {
+      return await this.getCollateralsBySheet(sheet);
+    })))
+      .reduce((acc, group) => [...acc, ...group], []);
+  }
+
+  async findCollaterals(collateralsId: string, group: boolean, paginatorOptions?: IPaginatorOptions) {
+    const sheet = await this.findCollateralSheetsById(collateralsId);
+    if (group) {
+      return await this.getCollateralsBySheet(sheet, paginatorOptions);
+    }
+    return await getCollateralListBySheetId(sheet, paginatorOptions);
+  }
+
+  async countCollateralItems(bbcSheetId: string) {
+    const sheet = await this.findCollateralSheetsById(bbcSheetId);
+    return await this.getCollateralItemTotal(sheet);
+  }
+
+  async findCollateralSheets(bbcDateId: string, collateralType: ECollaterals) {
+    return BBCSheetModel.find({ bbcDateId, dataType: collateralType });
+  }
+
+  async findCollateralSheetsById(collateralsId: string): Promise<IBBCSheetDoc> {
+    return BBCSheetModel.findById(collateralsId);
+  }
+
+  async findCollateralSheetByIdWithBBCDate(collateralsId: string) {
+    const bbcSheet: IBBCSheetWithBBCDate[] = await BBCSheetModel.aggregate([
+      {
+        $match: {
+          '_id': new mongoose.Types.ObjectId(collateralsId),
+        },
+      }, {
+        $lookup: {
+          'from': 'bbcdates',
+          'localField': 'bbcDateId',
+          'foreignField': '_id',
+          'as': 'bbcDate',
+        },
+      }, {
+        $unwind: {
+          'path': '$bbcDate',
+        },
+      },
+    ]);
+    return bbcSheet.length ? bbcSheet[0] : null;
+  }
+
+  async findAllCollaterals(borrowerId: string, collateralTypes: ECollaterals[]) {
+    return getBBCDatesByType(borrowerId, collateralTypes);
+  }
+
+  async saveCollateralItems<T extends IInventoryItem | IReceivableItem | IAccountPayableItem>(uploadedItems: IUploadedItems<T>, collateralType: ECollaterals, shift = 0) {
+    const bbcDates = await getBBCDates(uploadedItems.borrowerId, uploadedItems.bbcDate);
+    const bbcSheets = await getBBCSheetsByType(bbcDates.map((bbcDate) => String(bbcDate._id)), collateralType);
+    const lastBBCDate = bbcDates.pop();
+    const lastBBCSheet = bbcSheets.find((bbcSheet) => (bbcSheet.fileName === uploadedItems.fileName) && (bbcSheet.sheetName === uploadedItems.sheetName));
+
+    let savedBBCDate;
+    if (!lastBBCDate) {
+      const newBBCDate = new BBCDateModel({
+        borrowerId: uploadedItems.borrowerId,
+        bbcDate: uploadedItems.bbcDate,
+      });
+      savedBBCDate = await newBBCDate.save();
+    } else {
+      savedBBCDate = lastBBCDate;
+    }
+
+    let savedBBCSheet;
+    if (!lastBBCSheet) {
+      const newBBCSheet = new BBCSheetModel({
+        bbcDateId: savedBBCDate._id,
+        dataType: collateralType,
+        fileName: uploadedItems.fileName,
+        sheetName: uploadedItems.sheetName,
+      });
+      savedBBCSheet = await newBBCSheet.save();
+    } else {
+      savedBBCSheet = bbcSheets.pop();
+    }
+
+    const orderedItems = uploadedItems.items.map((item, index) => ({
+      ...item,
+      order: index + shift,
+    }));
+    await Promise.all(orderedItems.map(async (item) => {
+      const newCollateralItem = new collateralMap[collateralType]({
+        bbcSheetId: savedBBCSheet._id,
+        order: item.order,
+        ...item,
+      });
+      await newCollateralItem.save();
+    }));
+    return savedBBCDate._id;
+  }
+
+  async getCollateralsBySheet(sheet: IBBCSheetDoc, paginatorOptions?: IPaginatorOptions) {
+
+    const groupFields = {
+      bbcDate: 'bbc.bbcDate',
+      borrowerId: 'bbc.borrowerId',
+      fileName: 'bbcSheet.fileName',
+      sheetName: 'bbcSheet.sheetName',
+    };
+
+    const { groupQueries, itemQueries, enumKey } = createQuery(groupFields, sheet.dataType);
+    const groupingQuery = { _id: '$bbcSheetId', ...groupQueries, items: { $push: itemQueries } };
+
+    const collateralSheets = await collateralMap[enumKey].aggregate([
+      {
+        $match: {
+          'bbcSheetId': new mongoose.Types.ObjectId(sheet.id),
+        },
+      },
+      ...COLLATERALS_LOOKUP,
+      {
+        $sort: {
+          order: 1,
+        },
+      },
+      ...ITEMS_PAGINATION(paginatorOptions),
+      {
+        $group: groupingQuery,
+      },
+    ]);
+    if (collateralSheets.length === 0) {
+      const bbcDates = await BBCDateModel.aggregate<IBBCDateDoc>([
+        {
+          $match: {
+            '_id': sheet.bbcDateId,
+          },
+        },
+      ]);
+      if (bbcDates.length === 0) {
+        return [];
+      }
+      return [{
+        _id: sheet._id,
+        bbcDate: bbcDates[0].bbcDate,
+        borrowerId: bbcDates[0].borrowerId,
+        fileName: sheet.fileName,
+        sheetName: sheet.sheetName,
+        items: [],
+      }];
+    }
+    return collateralSheets;
+  }
+
+  async getCollateralItemTotal(sheet: IBBCSheetDoc) {
+    const enumKey = getEnumKeyByEnumValue(ECollaterals, sheet.dataType);
+    return collateralMap[enumKey].countDocuments(
+      {
+        'bbcSheetId': new mongoose.Types.ObjectId(sheet.id),
+      },
+    );
+  }
+
+  getCollateralsBenford(collaterals: any[]) {
+    if (collaterals.length === 0) {
+      return [];
+    }
+    const eachInventoryBenfordResult = [];
+
+    collaterals[0]?.digitArrays.forEach((lastDigitsArray) => {
+      const digitsArrayWithoutZeros = lastDigitsArray.filter((digit) => digit !== '0');
+      const results = [];
+      const firstDigitFrequencies = getDigitsFrequencies(lastDigitsArray);
+
+      for (let n = 1; n <= 9; n++) {
+        const dataFrequency = firstDigitFrequencies[n];
+        const dataFrequencyPercent = (dataFrequency / digitsArrayWithoutZeros.length) * 100;
+        const dataFrequencyTotal = isNaN(dataFrequencyPercent) ? 0 : Math.round(dataFrequencyPercent * 100) / 100;
+        results.push(dataFrequencyTotal);
+      }
+      eachInventoryBenfordResult.push(results);
+    });
+    return {
+      _id: collaterals[0]._id,
+      bbcDates: collaterals[0].bbcDates,
+      confirmed: eachInventoryBenfordResult,
+    };
+  }
+
+  async countCollateralDocsByBBC(bbcIds: string[], collateralType: ECollaterals) {
+    const bbcSheets = await getBBCSheetsByType(bbcIds, collateralType);
+    const collateralModel = collateralMap[collateralType];
+    if (!collateralModel) {
+      console.error(`Could not find a model for ${collateralType}`);
+      return 0;
+    }
+    return collateralModel.countDocuments(
+      {
+        'bbcSheetId': { $in: bbcSheets.map((bbcSheet) => bbcSheet._id) },
+      },
+    );
+
+  }
+
+  excludeNoDataColumns(data: any[], columns: string[]) {
+    return data.map((dataRow) => _.pick(dataRow, columns));
+  }
+
+  async addCustomerGroups(data: any[], borrowerId: string) {
+    const groupName = 'customers';
+    const groups = await this._groupsService.getBorrowerGroups(borrowerId, groupName);
+    return data.map((dataRow) => {
+      const foundGroup = groups[groupName].find((group) => group.items.includes(dataRow.customerTitle));
+      return {
+        ...dataRow,
+        customerGroup: foundGroup ? foundGroup.groupName : dataRow.customerTitle,
+      };
+    });
+  }
+
+  async getLatestBBC(borrowerId: string, bbcDate = new Date()) {
+    const bbcDateDocs = await BBCDateModel.aggregate<IBBCDateDoc>([
+      {
+        $match: {
+          'borrowerId': new mongoose.Types.ObjectId(borrowerId),
+          'bbcDate': { $lte: bbcDate },
+        },
+      }, {
+        $sort: {
+          'bbcDate': -1,
+        },
+      }, {
+        $limit: 1,
+      },
+    ]);
+    if (bbcDateDocs.length === 0) {
+      return null;
+    }
+    return bbcDateDocs[0];
+  }
+
+  async gebNextBBC(borrowerId: string, bbcDate = new Date()) {
+    return BBCDateModel.aggregate<IBBCDateDoc>([
+      {
+        $match: {
+          'borrowerId': new mongoose.Types.ObjectId(borrowerId),
+          'bbcDate': { $gte: bbcDate },
+        },
+      }, {
+        $sort: {
+          'bbcDate': -1,
+        },
+      },
+    ]);
+  }
+
+  async getLatestBBCDate(borrowerId: string) {
+    const latestBBC = await this.getLatestBBC(borrowerId);
+    if (!latestBBC) {
+      return { lastBBCDate: null, lastBBCId: null };
+    }
+    return { lastBBCDate: latestBBC.bbcDate, lastBBCId: latestBBC._id.toString() };
+  }
+
+  async createBBCDate(bbcDate: ICreateBBCDate) {
+    if (bbcDate.inventory || bbcDate.receivables) {
+      const existingBbcDates = await getBBCDates(bbcDate.borrowerId, bbcDate.date);
+      let existingBbcDate = existingBbcDates.length > 0 ? existingBbcDates[0] : null;
+      if (!existingBbcDate) {
+        existingBbcDate = await createBBCDate(bbcDate.borrowerId, bbcDate.date);
+      }
+      if (bbcDate.inventory) {
+        await createBBCSheet(existingBbcDate._id.toString(), 'INVENTORY');
+      }
+      if (bbcDate.receivables) {
+        await createBBCSheet(existingBbcDate._id.toString(), 'RECEIVABLE');
+      }
+    }
+  }
+
+  async deleteCollateralById(collateralId: string) {
+    const results = await BBCSheetModel.findByIdAndDelete(collateralId);
+    setTimeout(async () => await this._uploadsService.removeEmptyBBC(true), 500);
+    return results;
+  }
+}

package/services/companies.service.d.ts

@@ -0,0 +1,5 @@
+import { ICompany } from '../models/Company.model';
+export declare class CompaniesService {
+    getCompanies(): Promise<ICompany[]>;
+    createCompanies(): Promise<void>;
+}

package/services/companies.service.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompaniesService = void 0;
+const Company_model_1 = require("../models/Company.model");
+const main_helper_1 = require("../helpers/main.helper");
+class CompaniesService {
+    async getCompanies() {
+        const companies = await Company_model_1.Company.find().sort({ name: 1 });
+        return companies.map((i) => (0, main_helper_1.removeFields)(i, main_helper_1.fieldsToUnset));
+    }
+    async createCompanies() {
+        const companies = [
+            { name: 'AssetCo' },
+            { name: 'OpCo' },
+        ];
+        await Promise.all(companies.map(async (company) => {
+            await Company_model_1.Company.findOneAndUpdate({ name: company.name }, { $setOnInsert: { name: company.name } }, { upsert: true, new: true });
+        }));
+    }
+}
+exports.CompaniesService = CompaniesService;

package/services/companies.service.ts

@@ -0,0 +1,23 @@
+import { Company, ICompany } from '../models/Company.model';
+import { fieldsToUnset, removeFields } from '../helpers/main.helper';
+
+export class CompaniesService {
+  async getCompanies() {
+    const companies = await Company.find().sort({ name: 1 });
+    return companies.map((i) => removeFields<ICompany>(i, fieldsToUnset));
+  }
+
+  async createCompanies() {
+    const companies: ICompany[] = [
+      { name: 'AssetCo' },
+      { name: 'OpCo' },
+    ];
+    await Promise.all(companies.map(async (company) => {
+      await Company.findOneAndUpdate(
+        { name: company.name },
+        { $setOnInsert: { name: company.name } },
+        { upsert: true, new: true },
+      );
+    }));
+  }
+}

package/services/compliance-borrowers.service.d.ts

@@ -0,0 +1,152 @@
+/// <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 { IEmailRecipient } from '../models/ComplianceItem.model';
+import { IGroupedEmailsUpdate } from '../interfaces/email-addresses.interface';
+import { IComplianceBorrowerDocument, IComplianceBorrowerDocumentFull } from '../models/BorrowerCompliance.model';
+import { IUser } from '../models/User.model';
+import { FileManagerService } from './file-manager.service';
+import { UploadsService } from './uploads.service';
+export declare class ComplianceBorrowersService {
+    private readonly _fileManagerService;
+    private readonly _uploadsService;
+    constructor(_fileManagerService: FileManagerService, _uploadsService: UploadsService);
+    isComplianceBorrowerAllowed(userAccess: any, requestedBorrowerId: any): boolean;
+    calculateInstanceStatuses(instance: any, item: any): {
+        progress: {
+            text: string;
+            status: string;
+        };
+        score: {
+            value: number;
+            tooltip: string;
+        };
+    };
+    getFullComplianceBorrowerById(complianceBorrowerId: any): Promise<any>;
+    getAllBorrowersShortened(userAccess: any): Promise<(Pick<IComplianceBorrowerDocument, "items" | "borrower" | "fundingStatus"> | {
+        items: {
+            instances: any[];
+            item: import("../models/ComplianceItem.model").IComplianceItemDocument;
+            startDate: Date;
+            frequency: string;
+            emailAddresses: import("../models/ComplianceItem.model").IEmailRecipientDocument[];
+            _id?: any;
+            __v?: any;
+            $locals: Record<string, unknown>;
+            $op: "save" | "validate" | "remove";
+            $where: Record<string, unknown>;
+            baseModelName?: string;
+            collection: mongoose.Collection<mongoose.mongo.BSON.Document>;
+            db: mongoose.Connection;
+            errors?: mongoose.Error.ValidationError;
+            id?: any;
+            isNew: boolean;
+            schema: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, {
+                [x: string]: unknown;
+            }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+                [x: string]: unknown;
+            }>> & mongoose.FlatRecord<{
+                [x: string]: unknown;
+            }> & Required<{
+                _id: unknown;
+            }>>;
+        }[];
+        borrower: any;
+        fundingStatus?: string;
+    })[]>;
+    generateInstances(complianceBorrowerId: any): Promise<any>;
+    calculateAndUpdateFundingStatus(complianceBorrowerId: string): Promise<void>;
+    calculateFundingStatus(complianceBorrower: IComplianceBorrowerDocumentFull): string;
+    updateComplianceBorrower(complianceBorrower: IComplianceBorrowerDocumentFull): Promise<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    updateFundingStatus(complianceBorrowerId: string, fundingStatus: string): Promise<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    updateLastEmailSent(complianceBorrowerId: string, lastEmailSentAt: Date): Promise<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    getAllBorrowersIds(onlyActive?: boolean): Promise<any[]>;
+    getBorrowerListByItemId(complianceItemId: string): Promise<Omit<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }, never>[]>;
+    deleteInstanceById(complianceBorrowerId: string, complianceInstanceId: string): Promise<void>;
+    getBorrowerByInstanceId(complianceInstanceId: string): Promise<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    markInstanceFilesAsOld(complianceInstanceId: string): Promise<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    getBorrowerWithPlaidToken(): Promise<(mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    })[]>;
+    getBorrowerEmails(userAccess: any): Promise<{
+        borrower: {
+            _id: any;
+            name: any;
+            borrowerId: any;
+        };
+        email: string;
+        mainEmails: IEmailRecipient[];
+        financialEmails: IEmailRecipient[];
+        isEmailingActive: boolean;
+        isDailyTransactionsEmailingActive: boolean;
+        uniqEmails: any[];
+        groupedEmails: {};
+        items: {
+            value: any;
+            title: string;
+        }[];
+    }[]>;
+    getOneBorrowerEmails(userAccess: any, borrowerId: any): Promise<{
+        borrower: {
+            _id: any;
+            name: any;
+            borrowerId: any;
+        };
+        email: string;
+        mainEmails: IEmailRecipient[];
+        financialEmails: IEmailRecipient[];
+        isEmailingActive: boolean;
+        isDailyTransactionsEmailingActive: boolean;
+        uniqEmails: any[];
+        groupedEmails: {};
+        items: {
+            value: any;
+            title: string;
+        }[];
+    }>;
+    getBorrowerEmailsGrouped(borrowerId: string): Promise<{
+        mainEmails: IEmailRecipient[];
+        financialEmails: IEmailRecipient[];
+    }>;
+    updateBorrowerEmailAddresses(emailUpdate: IGroupedEmailsUpdate): Promise<mongoose.Document<unknown, {}, IComplianceBorrowerDocument> & IComplianceBorrowerDocument & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    toggleComplianceBorrowerVisibility(borrowerId: string, isVisible: boolean): Promise<void>;
+    createComplianceBorrower(borrowerId: string, isVisible?: boolean): Promise<void>;
+    removeIncorrectBorrowers(): Promise<void>;
+    getBorrowerListReport(user: IUser): Promise<any>;
+}