gemcap-be-common 1.2.140 → 1.3.0

package/services/signs.service.ts

@@ -0,0 +1,260 @@
+import mongoose, { Document } from 'mongoose';
+import _ from 'lodash';
+
+import { IResult } from '../interfaces/result.interface';
+import {
+  addAvailabilitySign,
+  findAvailabilitySignsByBBCDateId,
+  getAvailabilitySigns,
+  updateAvailabilitySigns,
+} from '../db/availability.db';
+import { IUserDocument } from '../models/User.model';
+import {
+  AvailabilitySignsModel,
+  IAvailabilitySignItem,
+  IAvailabilitySignView,
+  REQUIRED_SIGNS,
+} from '../models/AvailabilitySigns.model';
+import { BBCDateModel, IBBCDateDoc } from '../models/BBCDate.model';
+import { MODEL_NAMES } from '../models/_models';
+import { getOlderBBCDates } from '../db/bbcDates.db';
+import { ELogActionType, ELogType } from '../models/UserLog.model';
+import { createLog, ICreateLogParams } from '../db/user-logs.db';
+import { IBorrowerDocument } from '../models/Borrower.model';
+import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
+import { IPaginatorOptions } from '../interfaces/collaterals.interface';
+import { ITEMS_PAGINATION } from '../db/collaterals.db';
+import { UsersService } from './users.service';
+
+import { AvailabilitySignedData } from '../models/AvilabilitySignedData.model';
+import { LoanTransactionsService } from './loan-transactions.service';
+import { LockService } from './lock.service';
+import { LoanStatementService } from './loan-statement.service';
+
+export interface IBBCDateWithBorrower extends Document {
+  borrowerId: IBorrowerDocument;
+  bbcDate: Date;
+}
+
+export enum ESignStatus {
+  STARTED = 'STARTED',
+  APPROVED = 'APPROVED',
+  PENDING = 'PENDING',
+}
+
+export class SignsService {
+
+  constructor(
+    private readonly lockService: LockService,
+    private readonly loanTransactionsService: LoanTransactionsService,
+    private readonly loanStatementService: LoanStatementService,
+    private readonly usersService: UsersService,
+  ) {
+  }
+
+  keyCloakUsers: IKeycloakUser[] = null;
+
+  async fulfillUserList() {
+    const { access_token } = await this.usersService.getKeyCloakAdminBearer();
+    this.keyCloakUsers = await this.usersService.getUserList(access_token);
+  }
+
+  clearUserList() {
+    this.keyCloakUsers = null;
+  }
+
+  async getAvailabilitySigns(bbcDateId: string): Promise<IAvailabilitySignView> {
+    const availabilitiesSigns = await getAvailabilitySigns([bbcDateId]);
+    if (!availabilitiesSigns.length) {
+      return <IAvailabilitySignView>{
+        _id: null,
+        bbcDateId: new mongoose.Types.ObjectId(bbcDateId),
+        requiredSigns: REQUIRED_SIGNS,
+        signs: [],
+      };
+    }
+    const availabilitySigns = availabilitiesSigns[0];
+    let keyCloakUsers = this.keyCloakUsers;
+    if (!keyCloakUsers) {
+      const { access_token } = await this.usersService.getKeyCloakAdminBearer();
+      keyCloakUsers = await this.usersService.getUserList(access_token);
+    }
+    availabilitySigns.signs = availabilitySigns.signs.reduce((acc, userSign) => {
+      if (!userSign.userSigned) {
+        return acc;
+      }
+      const foundUserSigned = keyCloakUsers.find((user) => user.id === userSign.userSigned.keycloakUserId);
+      if (foundUserSigned) {
+        userSign.userSigned.firstName = foundUserSigned.firstName;
+        userSign.userSigned.lastName = foundUserSigned.lastName;
+      }
+      userSign.userSigned = (_.pick(userSign.userSigned, ['_id', 'firstName', 'lastName'])) as IUserDocument;
+      if (userSign.userRevoked) {
+        const foundUserRevoked = keyCloakUsers.find((user) => user.id === userSign.userRevoked.keycloakUserId);
+        if (foundUserRevoked) {
+          userSign.userRevoked.firstName = foundUserRevoked.firstName;
+          userSign.userRevoked.lastName = foundUserRevoked.lastName;
+        }
+        userSign.userRevoked = (_.pick(userSign.userRevoked, ['_id', 'firstName', 'lastName'])) as IUserDocument;
+      }
+      return [...acc, _.pick(userSign, ['userSigned', 'signedAt', 'userRevoked', 'revokedAt'])];
+    }, []);
+    return availabilitySigns;
+  }
+
+  async revokeAvailability(bbcDateId: string, userId: string, userIdRevoked: string): Promise<void> {
+    const availability = await findAvailabilitySignsByBBCDateId(bbcDateId);
+    const updatedSigns = availability.signs.map((sign) => {
+      if (sign.userSignedId.toString() === userId && !sign.revokedAt) {
+        sign.userRevokedId = new mongoose.Types.ObjectId(userIdRevoked);
+        sign.revokedAt = new Date();
+        sign.userRevokedId = new mongoose.Types.ObjectId(userIdRevoked);
+      }
+      return sign;
+    });
+    await updateAvailabilitySigns(bbcDateId, updatedSigns);
+  }
+
+  async signAvailability(bbcDateId: string, user: IUserDocument): Promise<IResult> {
+    const newSign = <IAvailabilitySignItem>{ userSignedId: user._id, signedAt: new Date() };
+    return await addAvailabilitySign(bbcDateId, newSign);
+  }
+
+  async isBBCLocked(bbcDateId: string): Promise<boolean> {
+    const bbcDoc = await BBCDateModel.findById(bbcDateId).lean();
+    if (!bbcDoc) {
+      return false;
+    }
+    return await this.lockService.isDateLocked(bbcDoc.bbcDate, bbcDoc.borrowerId.toString());
+  }
+
+  async getLatestSignedBBCDate(borrowerId: string, date?: Date): Promise<IBBCDateDoc> {
+    const bbcDocs = await getOlderBBCDates(borrowerId, date || new Date());
+    const activeSignsAfter = await AvailabilitySignsModel.aggregate([
+      {
+        $match: {
+          'bbcDateId': { $in: bbcDocs.map((bbc) => bbc._id) },
+        },
+      }, {
+        $unwind: {
+          path: '$signs',
+          preserveNullAndEmptyArrays: true,
+        },
+      }, {
+        $match: {
+          'signs.revokedAt': { $exists: false },
+        },
+      }, {
+        $group: {
+          '_id': '$_id',
+          'requiredSigns': { $first: '$requiredSigns' },
+          'bbcDateId': { $first: '$bbcDateId' },
+          'signs': { $push: '$signs' },
+        },
+      }, {
+        $match: {
+          $expr: {
+            $gte: [
+              { '$size': '$signs' }, '$requiredSigns',
+            ],
+          },
+        },
+      }, {
+        $lookup: {
+          from: MODEL_NAMES.BBCDates,
+          localField: 'bbcDateId',
+          foreignField: '_id',
+          as: 'bbc',
+        },
+      }, {
+        $unwind: {
+          path: '$bbc',
+          preserveNullAndEmptyArrays: true,
+        },
+      }, {
+        $sort: {
+          'bbc.bbcDate': -1,
+        },
+      },
+    ]);
+    if (!activeSignsAfter.length) {
+      return null;
+    }
+    return activeSignsAfter[0].bbc;
+  }
+
+  async getSavedData(bbcDateId: string) {
+    const availabilitySignedData = await AvailabilitySignedData.findOne({ bbcDateId }).lean();
+    if (!availabilitySignedData) {
+      return {};
+    }
+    return availabilitySignedData.data;
+  }
+
+  async keepBalance(bbcDateId: string) {
+    const loanBalances = await this.loanTransactionsService.getLoanBalanceForBBCDateId(bbcDateId);
+    const accruedStatement = await this.loanStatementService.calculateAccruedStatementForBBC(bbcDateId);
+    console.log({ bbcDateId });
+    await AvailabilitySignedData.findOneAndUpdate({ bbcDateId }, { data: { loanBalances, accruedStatement } }, { upsert: true });
+  }
+
+  async clearAvailabilityStoredData(bbcDateId: string) {
+    await AvailabilitySignedData.findOneAndDelete({ bbcDateId });
+  }
+
+  async logSignStatus(bbcDateId: string, userId: string, isSigned: boolean) {
+    const bbcDate = await BBCDateModel.findById(bbcDateId)
+      .populate('borrowerId')
+      .lean() as unknown as IBBCDateWithBorrower;
+    if (!bbcDate) {
+      return;
+    }
+    const newLog: ICreateLogParams = {
+      userId,
+      action: isSigned ? ELogActionType.CREATE : ELogActionType.DELETE,
+      details: { date: bbcDate.bbcDate, borrower: bbcDate.borrowerId.name }, // , borrower: bbcDate.borrower.name
+      logType: isSigned ? ELogType.SIGN_BBC : ELogType.REVOKE_BBC,
+    };
+    await createLog(newLog);
+  }
+
+  async BBCDatesShort(borrowerId: string, paginatorOptions: IPaginatorOptions) {
+    const BBCDates = await BBCDateModel.aggregate<{ _id: mongoose.Types.ObjectId, bbcDate: Date, signStatus: string }>([
+      {
+        '$match': {
+          'borrowerId': new mongoose.Types.ObjectId(borrowerId),
+        },
+      }, {
+        '$sort': {
+          'bbcDate': -1,
+        },
+      }, {
+        '$project': {
+          '_id': 1,
+          'bbcDate': 1,
+          'signStatus': 1,
+        },
+      },
+      ...ITEMS_PAGINATION(paginatorOptions),
+    ]);
+
+    const availabilitiesSigns = await getAvailabilitySigns(BBCDates.map((bbcDate) => bbcDate._id.toString()));
+    await Promise.all(BBCDates.slice().map(async (bbcDate) => {
+      const foundAvailabilitySigns = availabilitiesSigns.find((aSigns) => aSigns.bbcDateId.toString() ===bbcDate._id.toString());
+      if (!foundAvailabilitySigns) {
+        bbcDate.signStatus = ESignStatus.STARTED;
+      }
+      if (foundAvailabilitySigns) {
+        const activeSigns = foundAvailabilitySigns.signs.filter((sign) => !sign.userRevoked).length;
+        if (activeSigns === 0) {
+          bbcDate.signStatus = ESignStatus.STARTED;
+        } else if (activeSigns === foundAvailabilitySigns.requiredSigns) {
+          bbcDate.signStatus = ESignStatus.APPROVED;
+        } else if (activeSigns < foundAvailabilitySigns.requiredSigns) {
+          bbcDate.signStatus = ESignStatus.PENDING;
+        }
+      }
+    }));
+    return BBCDates;
+  }
+}

package/services/term-loan.service.d.ts

@@ -0,0 +1,30 @@
+import { ITermLoanSettingsOnly } from '../models/TermLoanSettings.model';
+import { ETermLoanStatus, ITermLoanView } from '../models/TermLoan.model';
+import { ITermLoanCalculated, ITermLoanCalculatedDoc } from '../models/TermLoanCalculated.model';
+import { FinancialIndexesService } from './financial-indexes.service';
+import { LoanChargesService } from './loan-charges.service';
+import { LoanStatementStatusService } from './loan-statement-status.service';
+import { LoanTransactionsService } from './loan-transactions.service';
+import { UploadsService } from './uploads.service';
+export declare class TermLoanService {
+    private readonly financialIndexesService;
+    private readonly loanChargesService;
+    private readonly getLoanStatementStatusService;
+    private readonly getLoanTransactionsService;
+    private readonly getUploadsService;
+    constructor(financialIndexesService: FinancialIndexesService, loanChargesService: LoanChargesService, getLoanStatementStatusService: () => LoanStatementStatusService, getLoanTransactionsService: () => LoanTransactionsService, getUploadsService: () => UploadsService);
+    private createTermLoan;
+    private createTermLoanSettings;
+    private getCreateTermLoan;
+    getTermLoan(productId: string, actual: boolean): Promise<ITermLoanView & {
+        calculated: ITermLoanCalculatedDoc[];
+    }>;
+    saveTermLoanSettings(productId: string, actual: boolean, settings: ITermLoanSettingsOnly): Promise<any>;
+    calculateAllTermLoans(): Promise<void>;
+    setTermLoanExpected(productId: string, recalculate?: boolean): Promise<void>;
+    updateTermLoanStatus(termLoanId: string, calculationStatus: ETermLoanStatus, lastCalculated?: Date): Promise<void>;
+    calculateTermLoan(productId: string, actual: boolean): Promise<any>;
+    saveCalculatedTermLoan(calculatedTermLoans: ITermLoanCalculated[], productId: string): Promise<void>;
+    getTermLoanExcel(productId: string, actual: boolean, short: boolean): Promise<any>;
+    isBorrowerTermLoanActual(borrowerId: string): Promise<boolean>;
+}