gemcap-be-common 1.2.140 → 1.3.0

package/services/borrowers.service.js

@@ -0,0 +1,268 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BorrowerService = exports.borrowerDataModels = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const BorrowerSettings_model_1 = require("../models/BorrowerSettings.model");
+const Borrower_model_1 = require("../models/Borrower.model");
+const BorrowerData_model_1 = require("../models/BorrowerData.model");
+const BorrowerDataContact_model_1 = require("../models/BorrowerDataContact.model");
+const BorrowerDataGuarantee_model_1 = require("../models/BorrowerDataGuarantee.model");
+const BorrowerDataLocation_model_1 = require("../models/BorrowerDataLocation.model");
+const BorrowerDataBank_model_1 = require("../models/BorrowerDataBank.model");
+const BorrowerDataInsurance_model_1 = require("../models/BorrowerDataInsurance.model");
+const BorrowerDataReceivable_model_1 = require("../models/BorrowerDataReceivable.model");
+const BorrowerDataInventory_model_1 = require("../models/BorrowerDataInventory.model");
+const BorrowerDataTerm_model_1 = require("../models/BorrowerDataTerm.model");
+const BorrowerDataBootCollateral_model_1 = require("../models/BorrowerDataBootCollateral.model");
+exports.borrowerDataModels = {
+    receivables: BorrowerDataReceivable_model_1.BorrowerDataReceivableModel,
+    inventories: BorrowerDataInventory_model_1.BorrowerDataInventoryModel,
+    terms: BorrowerDataTerm_model_1.BorrowerDataTermModel,
+    bootCollaterals: BorrowerDataBootCollateral_model_1.BorrowerDataBootCollateralModel,
+    contacts: BorrowerDataContact_model_1.BorrowerDataContactModel,
+    guarantees: BorrowerDataGuarantee_model_1.BorrowerDataGuaranteeModel,
+    locations: BorrowerDataLocation_model_1.BorrowerDataLocationModel,
+    banks: BorrowerDataBank_model_1.BorrowerDataBankModel,
+    insurance: BorrowerDataInsurance_model_1.BorrowerDataInsuranceModel,
+};
+class BorrowerService {
+    collateralsService;
+    loanStatementStatusService;
+    loanTransactionsService;
+    signsService;
+    constructor(collateralsService, loanStatementStatusService, loanTransactionsService, signsService) {
+        this.collateralsService = collateralsService;
+        this.loanStatementStatusService = loanStatementStatusService;
+        this.loanTransactionsService = loanTransactionsService;
+        this.signsService = signsService;
+    }
+    isBorrowerAllowed(userAccess, requestedBorrowerId) {
+        if (userAccess.allBorrowers) {
+            return true;
+        }
+        return userAccess.borrowersAccess.some((b) => b.borrower === requestedBorrowerId);
+    }
+    checkBorrower(userAccess, requestedBorrowerId) {
+        const allowedBorrower = this.isBorrowerAllowed(userAccess, requestedBorrowerId);
+        if (!allowedBorrower) {
+            throw new Error('Non allowed borrower');
+        }
+        return true;
+    }
+    async getBorrowerById(borrowerId) {
+        return Borrower_model_1.BorrowerModel.findById(borrowerId).lean();
+    }
+    async isNameCodeAllowed(borrower) {
+        const existingUserName = await Borrower_model_1.BorrowerModel.findOne({ name: borrower.name });
+        const existingUserCode = await Borrower_model_1.BorrowerModel.findOne({ code: borrower.code });
+        if (existingUserName && existingUserName.id !== borrower._id) {
+            return { message: 'There already exists a borrower with this name' };
+        }
+        if (existingUserCode && existingUserCode.id !== borrower._id) {
+            return { message: 'There already exists a borrower with this code' };
+        }
+        return null;
+    }
+    async getDefaultSettings(borrowerId) {
+        const options = await BorrowerData_model_1.BorrowerDataOptionModel.find().lean();
+        const dataOptions = options.reduce((acc, option) => {
+            return [
+                ...acc,
+                { dataOption: option._id, dataValue: option.type === 'boolean' ? false : '' },
+            ];
+        }, []);
+        const defaultSettings = {
+            borrower: new mongoose_1.default.Types.ObjectId(borrowerId),
+            queries: {
+                inventory: {},
+                receivable: {},
+                'account payable': {},
+                other: {},
+                cash: {},
+            },
+            dataTypes: {
+                upload: [],
+            },
+            data: {
+                options: dataOptions,
+                receivables: [],
+                inventories: [],
+                contacts: [],
+                guarantees: [],
+                banks: [],
+                insurance: [],
+                locations: [],
+                terms: [],
+                bootCollaterals: [],
+            },
+            dataAvailability: {
+                receivables: false,
+                inventories: false,
+            },
+        };
+        return defaultSettings;
+    }
+    async addOptionNames(unmappedSettings) {
+        const borrowerDataOptions = await BorrowerData_model_1.BorrowerDataOptionModel.find().lean();
+        const borrowerDataOptionsMap = new Map();
+        borrowerDataOptions.forEach((option) => borrowerDataOptionsMap.set(option._id.toString(), option.name));
+        unmappedSettings.data.options = unmappedSettings.data.options.map((item) => {
+            const dataName = borrowerDataOptionsMap.get(item.dataOption.toString());
+            return { ...item, dataName };
+        });
+        return unmappedSettings;
+    }
+    async getBorrowerOption(borrowerId, optionName) {
+        const borrowerSettings = await this.getBorrowerSettings(borrowerId);
+        if (!borrowerSettings) {
+            return null;
+        }
+        const foundOption = borrowerSettings.data.options.find((option) => option.dataName === optionName);
+        if (!foundOption) {
+            return null;
+        }
+        return foundOption;
+    }
+    async getBorrowerSettings(borrowerId) {
+        const borrowerSettings = await BorrowerSettings_model_1.BorrowerSettingsModel
+            .findOne({ borrower: borrowerId })
+            .populate('data.options')
+            .populate('data.receivables')
+            .populate('data.inventories')
+            .populate('data.terms')
+            .populate('data.bootCollaterals')
+            .populate('data.contacts')
+            .populate('data.guarantees')
+            .populate('data.locations')
+            .populate('data.banks')
+            .populate('data.insurance')
+            .lean();
+        const options = await BorrowerData_model_1.BorrowerDataOptionModel.find({}).lean();
+        if (borrowerSettings?.data?.options) {
+            borrowerSettings.data.options = borrowerSettings.data.options.sort((a, b) => {
+                const foundA = options.find((option) => option._id.toString() === a.dataOption.toString());
+                const foundB = options.find((option) => option._id.toString() === b.dataOption.toString());
+                if (!foundA || !foundB) {
+                    return 0;
+                }
+                return foundA.order - foundB.order;
+            });
+        }
+        const unmappedSettings = borrowerSettings ? borrowerSettings : await this.getDefaultSettings(borrowerId);
+        return await this.addOptionNames(unmappedSettings);
+    }
+    async getBorrowerByCode(code) {
+        return Borrower_model_1.BorrowerModel.findOne({ code });
+    }
+    async getExtraInfo(borrowerId) {
+        const extraInfo = await this.loanTransactionsService.getLoanBalanceForBorrowerId(borrowerId);
+        const { lastBBCDate, lastBBCId } = await this.collateralsService.getLatestBBCDate(borrowerId);
+        const lastSignedBBCDate = await this.signsService.getLatestSignedBBCDate(borrowerId);
+        return {
+            extraInfo,
+            lastBBCDate,
+            lastBBCId,
+            lastSignedBBCDate: lastSignedBBCDate?.bbcDate || null,
+            lastSignedBBCId: lastSignedBBCDate?._id.toString() || null,
+        };
+    }
+    async updateBorrowerData(borrowerSettings) {
+        const results = await Promise.all(Object.entries(exports.borrowerDataModels).map(async ([modelName, model]) => {
+            const newIds = await Promise.all(borrowerSettings.data[modelName].map(async (contact) => {
+                if (!contact._id) {
+                    delete contact._id;
+                    const newContact = new model(contact);
+                    const savedContact = await newContact.save();
+                    return savedContact._id;
+                }
+                await model.findByIdAndUpdate(contact._id, contact);
+                return new mongoose_1.default.Types.ObjectId(contact._id);
+            }));
+            return { [modelName]: newIds };
+        }));
+        return results.reduce((acc, modelCollection) => {
+            const collections = Object.entries(modelCollection).reduce((innerAcc, [modelName, ids]) => {
+                return { ...innerAcc, [modelName]: ids };
+            }, {});
+            return { ...acc, ...collections };
+        }, {});
+    }
+    async updateBorrowerSettings(borrowerId, borrowerSettings) {
+        const newOptions = [];
+        await Promise.all(borrowerSettings.data.options.map(async (option) => {
+            if (option._id) {
+                await BorrowerData_model_1.BorrowerDataModel.findByIdAndUpdate(option._id, { dataValue: option.dataValue });
+            }
+            else {
+                const newOption = await BorrowerData_model_1.BorrowerDataModel.create(option);
+                await newOption.save();
+                newOptions.push(newOption._id);
+            }
+        }));
+        const oldSettings = await BorrowerSettings_model_1.BorrowerSettingsModel.findOne({ borrower: borrowerId }).lean();
+        const updatedData = await this.updateBorrowerData(borrowerSettings);
+        await Promise.all(Object.keys(exports.borrowerDataModels).map(async (modelName) => {
+            borrowerSettings.data[modelName] = updatedData[modelName];
+            if (oldSettings) {
+                const oldIds = oldSettings.data[modelName].map((id) => id.toString());
+                const updatedIds = updatedData[modelName].map((id) => id.toString());
+                const idsToRemoved = oldIds.reduce((acc, oldId) => {
+                    if (updatedIds.find((id) => id === oldId)) {
+                        return acc;
+                    }
+                    return [...acc, oldId];
+                }, []);
+                await Promise.all(idsToRemoved.map(async (id) => {
+                    await exports.borrowerDataModels[modelName].findByIdAndDelete(id);
+                }));
+            }
+        }));
+        const foundSettings = await BorrowerSettings_model_1.BorrowerSettingsModel.findOne({ borrower: borrowerId });
+        if (foundSettings) {
+            await BorrowerSettings_model_1.BorrowerSettingsModel.findOneAndUpdate({ borrower: borrowerId }, { borrower: borrowerId, ...borrowerSettings }, { upsert: true });
+        }
+        else {
+            const newSettings = await BorrowerSettings_model_1.BorrowerSettingsModel.create({ borrower: borrowerId, ...borrowerSettings, data: { ...borrowerSettings.data, options: newOptions } });
+            await newSettings.save();
+        }
+    }
+    async getBorrowerCodesMap() {
+        const borrowers = await Borrower_model_1.BorrowerModel.find().lean();
+        const codesMap = new Map();
+        borrowers.forEach((borrower) => {
+            codesMap.set(borrower.code.toLowerCase(), borrower._id.toString());
+        });
+        return codesMap;
+    }
+    async getAllBorrowers() {
+        return Borrower_model_1.BorrowerModel.find().sort({ name: 1 }).lean();
+    }
+    async getActiveBorrowers() {
+        return Borrower_model_1.BorrowerModel.find({ active: true }).sort({ name: 1 }).lean();
+    }
+    async getAllowedBorrowers(user) {
+        return Borrower_model_1.BorrowerModel
+            .find(user.allBorrowers ? {} : { '_id': { $in: user.borrowersAccess.map((b) => b.borrower) } })
+            .collation({ locale: 'en' })
+            .sort({ code: 1 })
+            .lean();
+    }
+    async getBorrowerStatementDetails(borrowers) {
+        const allBorrowersWithExtraInfo = await Promise.all(borrowers.map(async (borrower) => {
+            const borrowerId = borrower._id.toString();
+            const statementStatuses = await this.loanStatementStatusService.getBorrowerStatement(borrowerId);
+            return { [borrowerId]: statementStatuses };
+        }));
+        return allBorrowersWithExtraInfo.reduce((acc, borrower) => {
+            const borrowerRes = Object.entries(borrower).reduce((innerAcc, [borrowerId, values]) => ({
+                ...innerAcc,
+                [borrowerId]: values,
+            }), {});
+            return { ...acc, ...borrowerRes };
+        }, {});
+    }
+}
+exports.BorrowerService = BorrowerService;

package/services/borrowers.service.ts

@@ -0,0 +1,302 @@
+import mongoose from 'mongoose';
+
+import {
+  BorrowerSettingsModel,
+  IBorrowerSettings,
+  IBorrowerSettingsDocPopulated,
+} from '../models/BorrowerSettings.model';
+import { BorrowerModel, IBorrowerDocument } from '../models/Borrower.model';
+import {
+  BorrowerDataModel,
+  BorrowerDataOptionModel,
+  IBorrowerDataDocWithName,
+} from '../models/BorrowerData.model';
+import { BorrowerDataContactModel } from '../models/BorrowerDataContact.model';
+import { BorrowerDataGuaranteeModel } from '../models/BorrowerDataGuarantee.model';
+import { BorrowerDataLocationModel } from '../models/BorrowerDataLocation.model';
+import { BorrowerDataBankModel } from '../models/BorrowerDataBank.model';
+import { BorrowerDataInsuranceModel } from '../models/BorrowerDataInsurance.model';
+import { BorrowerDataReceivableModel } from '../models/BorrowerDataReceivable.model';
+import { BorrowerDataInventoryModel } from '../models/BorrowerDataInventory.model';
+import { BorrowerDataTermModel } from '../models/BorrowerDataTerm.model';
+import { BorrowerDataBootCollateralModel } from '../models/BorrowerDataBootCollateral.model';
+import { IUser } from '../models/User.model';
+import { CollateralsService } from './collaterals.service';
+import { LoanStatementStatusService } from './loan-statement-status.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+import { SignsService } from './signs.service';
+
+export const borrowerDataModels: {
+  [modelName: string]: mongoose.Model<any>
+} = {
+  receivables: BorrowerDataReceivableModel,
+  inventories: BorrowerDataInventoryModel,
+  terms: BorrowerDataTermModel,
+  bootCollaterals: BorrowerDataBootCollateralModel,
+  contacts: BorrowerDataContactModel,
+  guarantees: BorrowerDataGuaranteeModel,
+  locations: BorrowerDataLocationModel,
+  banks: BorrowerDataBankModel,
+  insurance: BorrowerDataInsuranceModel,
+};
+
+export class BorrowerService {
+
+  constructor(
+    private readonly collateralsService: CollateralsService,
+    private readonly loanStatementStatusService: LoanStatementStatusService,
+    private readonly loanTransactionsService: LoanTransactionsService,
+    private readonly signsService: SignsService,
+  ) {
+  }
+
+
+  isBorrowerAllowed(userAccess, requestedBorrowerId: string): boolean {
+    if (userAccess.allBorrowers) {
+      return true;
+    }
+    return userAccess.borrowersAccess.some((b) => b.borrower === requestedBorrowerId);
+  }
+
+  checkBorrower(userAccess, requestedBorrowerId: string): boolean {
+    const allowedBorrower = this.isBorrowerAllowed(userAccess, requestedBorrowerId);
+    if (!allowedBorrower) {
+      throw new Error('Non allowed borrower');
+    }
+    return true;
+  }
+
+  async getBorrowerById(borrowerId: string) {
+    return BorrowerModel.findById(borrowerId).lean();
+  }
+
+  async isNameCodeAllowed(borrower: IBorrowerDocument) {
+    const existingUserName = await BorrowerModel.findOne({ name: borrower.name });
+    const existingUserCode = await BorrowerModel.findOne({ code: borrower.code });
+    if (existingUserName && existingUserName.id !== borrower._id) {
+      return { message: 'There already exists a borrower with this name' };
+    }
+    if (existingUserCode && existingUserCode.id !== borrower._id) {
+      return { message: 'There already exists a borrower with this code' };
+    }
+    return null;
+  }
+
+  private async getDefaultSettings(borrowerId: string) {
+    const options = await BorrowerDataOptionModel.find().lean();
+    const dataOptions = options.reduce((acc, option) => {
+      return [
+        ...acc,
+        { dataOption: option._id, dataValue: option.type === 'boolean' ? false : '' },
+      ];
+    }, []);
+    const defaultSettings: IBorrowerSettings = {
+      borrower: new mongoose.Types.ObjectId(borrowerId),
+      queries: {
+        inventory: {},
+        receivable: {},
+        'account payable': {},
+        other: {},
+        cash: {},
+      },
+      dataTypes: {
+        upload: [],
+      },
+      data: {
+        options: dataOptions,
+        receivables: [],
+        inventories: [],
+        contacts: [],
+        guarantees: [],
+        banks: [],
+        insurance: [],
+        locations: [],
+        terms: [],
+        bootCollaterals: [],
+      },
+      dataAvailability: {
+        receivables: false,
+        inventories: false,
+      },
+    };
+    return defaultSettings;
+  }
+
+  private async addOptionNames(unmappedSettings: IBorrowerSettingsDocPopulated) {
+    const borrowerDataOptions = await BorrowerDataOptionModel.find().lean();
+    const borrowerDataOptionsMap = new Map();
+    borrowerDataOptions.forEach((option) => borrowerDataOptionsMap.set(option._id.toString(), option.name));
+    unmappedSettings.data.options = unmappedSettings.data.options.map((item) => {
+      const dataName: string = borrowerDataOptionsMap.get(item.dataOption.toString());
+      return { ...item, dataName } as unknown as IBorrowerDataDocWithName;
+    });
+    return unmappedSettings;
+  }
+
+  async getBorrowerOption(borrowerId: string, optionName: string): Promise<IBorrowerDataDocWithName> {
+    const borrowerSettings = await this.getBorrowerSettings(borrowerId);
+    if (!borrowerSettings) {
+      return null;
+    }
+    const foundOption = borrowerSettings.data.options.find((option) => option.dataName === optionName);
+    if (!foundOption) {
+      return null;
+    }
+    return foundOption;
+  }
+
+  async getBorrowerSettings(borrowerId: string) {
+    const borrowerSettings = await BorrowerSettingsModel
+      .findOne({ borrower: borrowerId })
+      .populate('data.options')
+      .populate('data.receivables')
+      .populate('data.inventories')
+      .populate('data.terms')
+      .populate('data.bootCollaterals')
+      .populate('data.contacts')
+      .populate('data.guarantees')
+      .populate('data.locations')
+      .populate('data.banks')
+      .populate('data.insurance')
+      .lean() as unknown as IBorrowerSettingsDocPopulated;
+    const options = await BorrowerDataOptionModel.find({}).lean();
+    if (borrowerSettings?.data?.options) {
+      borrowerSettings.data.options = borrowerSettings.data.options.sort((a, b) => {
+        const foundA = options.find((option) => option._id.toString() === a.dataOption.toString());
+        const foundB = options.find((option) => option._id.toString() === b.dataOption.toString());
+        if (!foundA || !foundB) {
+          return 0;
+        }
+        return foundA.order - foundB.order;
+      });
+    }
+    const unmappedSettings = borrowerSettings ? borrowerSettings : await this.getDefaultSettings(borrowerId);
+    return await this.addOptionNames(unmappedSettings as IBorrowerSettingsDocPopulated);
+  }
+
+  async getBorrowerByCode(code: string): Promise<IBorrowerDocument> {
+    return BorrowerModel.findOne({ code });
+  }
+
+  async getExtraInfo(borrowerId: string) {
+    const extraInfo = await this.loanTransactionsService.getLoanBalanceForBorrowerId(borrowerId);
+    const { lastBBCDate, lastBBCId } = await this.collateralsService.getLatestBBCDate(borrowerId);
+    const lastSignedBBCDate = await this.signsService.getLatestSignedBBCDate(borrowerId);
+    return {
+      extraInfo,
+      lastBBCDate,
+      lastBBCId,
+      lastSignedBBCDate: lastSignedBBCDate?.bbcDate || null,
+      lastSignedBBCId: lastSignedBBCDate?._id.toString() || null,
+    };
+  }
+
+  async updateBorrowerData(borrowerSettings: IBorrowerSettingsDocPopulated) {
+    const results = await Promise.all(Object.entries(borrowerDataModels).map(async ([modelName, model]) => {
+      const newIds: mongoose.Types.ObjectId[] = await Promise.all(borrowerSettings.data[modelName].map(async (contact: any) => {
+        if (!contact._id) {
+          delete contact._id;
+          const newContact = new model(contact);
+          const savedContact = await newContact.save();
+          return savedContact._id;
+        }
+        await model.findByIdAndUpdate(contact._id, contact);
+        return new mongoose.Types.ObjectId(contact._id);
+      }));
+      return { [modelName]: newIds };
+    }));
+
+    return results.reduce((acc, modelCollection) => {
+      const collections = Object.entries(modelCollection).reduce((innerAcc, [modelName, ids]) => {
+        return { ...innerAcc, [modelName]: ids };
+      }, {});
+      return { ...acc, ...collections };
+    }, {});
+  }
+
+  async updateBorrowerSettings(borrowerId: string, borrowerSettings: IBorrowerSettingsDocPopulated) {
+    const newOptions = [];
+    await Promise.all(borrowerSettings.data.options.map(async (option) => {
+      if (option._id) {
+        await BorrowerDataModel.findByIdAndUpdate(option._id, { dataValue: option.dataValue });
+      } else {
+        const newOption = await BorrowerDataModel.create(option);
+        await newOption.save();
+        newOptions.push(newOption._id);
+      }
+    }));
+    const oldSettings = await BorrowerSettingsModel.findOne({ borrower: borrowerId }).lean();
+    const updatedData = await this.updateBorrowerData(borrowerSettings);
+    await Promise.all(Object.keys(borrowerDataModels).map(async (modelName) => {
+        borrowerSettings.data[modelName] = updatedData[modelName];
+        if (oldSettings) {
+          const oldIds: string[] = oldSettings.data[modelName].map((id) => id.toString());
+          const updatedIds = updatedData[modelName].map((id) => id.toString());
+          const idsToRemoved = oldIds.reduce((acc, oldId) => {
+            if (updatedIds.find((id) => id === oldId)) {
+              return acc;
+            }
+            return [...acc, oldId];
+          }, []);
+          await Promise.all(idsToRemoved.map(async (id) => {
+            await borrowerDataModels[modelName].findByIdAndDelete(id);
+          }));
+        }
+      }),
+    );
+    const foundSettings = await BorrowerSettingsModel.findOne({ borrower: borrowerId });
+    if (foundSettings) {
+      await BorrowerSettingsModel.findOneAndUpdate(
+        { borrower: borrowerId },
+        { borrower: borrowerId, ...borrowerSettings },
+        { upsert: true },
+      );
+    } else {
+      const newSettings = await BorrowerSettingsModel.create(
+        { borrower: borrowerId, ...borrowerSettings, data: { ...borrowerSettings.data, options: newOptions } },
+      );
+      await newSettings.save();
+    }
+  }
+
+  async getBorrowerCodesMap() {
+    const borrowers = await BorrowerModel.find().lean();
+    const codesMap = new Map<string, string>();
+    borrowers.forEach((borrower) => {
+      codesMap.set(borrower.code.toLowerCase(), borrower._id.toString());
+    });
+    return codesMap;
+  }
+
+  async getAllBorrowers() {
+    return BorrowerModel.find().sort({ name: 1 }).lean();
+  }
+
+  async getActiveBorrowers() {
+    return BorrowerModel.find({ active: true }).sort({ name: 1 }).lean();
+  }
+
+  async getAllowedBorrowers(user: IUser) {
+    return BorrowerModel
+      .find(user.allBorrowers ? {} : { '_id': { $in: user.borrowersAccess.map((b) => b.borrower) } })
+      .collation({ locale: 'en' })
+      .sort({ code: 1 })
+      .lean();
+  }
+
+  async getBorrowerStatementDetails(borrowers: IBorrowerDocument[]) {
+    const allBorrowersWithExtraInfo = await Promise.all(borrowers.map(async (borrower) => {
+      const borrowerId = borrower._id.toString();
+      const statementStatuses = await this.loanStatementStatusService.getBorrowerStatement(borrowerId);
+      return { [borrowerId]: statementStatuses };
+    }));
+    return allBorrowersWithExtraInfo.reduce((acc, borrower) => {
+      const borrowerRes = Object.entries(borrower).reduce((innerAcc, [borrowerId, values]) => ({
+        ...innerAcc,
+        [borrowerId]: values,
+      }), {});
+      return { ...acc, ...borrowerRes };
+    }, {});
+  }
+
+}