gemcap-be-common 1.2.140 → 1.3.0

package/services/reserve.service.d.ts

@@ -0,0 +1,37 @@
+/// <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 { IReserve, IReserveItem } from '../models/Reserve.model';
+import { SignsService } from './signs.service';
+export declare class ReserveService {
+    private readonly signsService;
+    constructor(signsService: SignsService);
+    getReserve(bbcDateId: string): Promise<IReserve>;
+    saveAndReturnReserve(bbcDateId: string, reserveUpdate: Partial<IReserve>): Promise<mongoose.FlattenMaps<import("../models/Reserve.model").IReserveDoc> & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    getLastCopyReserve(bbcDateId: string): Promise<IReserveItem[]>;
+    private calculateSummary;
+}

package/services/reserve.service.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReserveService = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const bbcDates_db_1 = require("../db/bbcDates.db");
+const reserve_types_enum_1 = require("../enums/reserve-types.enum");
+const reserve_db_1 = require("../db/reserve.db");
+class ReserveService {
+    signsService;
+    constructor(signsService) {
+        this.signsService = signsService;
+    }
+    async getReserve(bbcDateId) {
+        const bbcDateIdID = new mongoose_1.default.Types.ObjectId(bbcDateId);
+        const reserves = await (0, reserve_db_1.getReserveDocs)([bbcDateIdID]);
+        if (!!reserves.length) {
+            return reserves.pop();
+        }
+        const lastItems = await this.getLastCopyReserve(bbcDateId);
+        const isBBCLockedResult = await this.signsService.isBBCLocked(bbcDateId);
+        if (isBBCLockedResult) {
+            const summary = this.calculateSummary(lastItems);
+            return await (0, reserve_db_1.copyReserveWithoutSaving)(bbcDateIdID, lastItems, summary);
+        }
+        return this.saveAndReturnReserve(bbcDateId, { items: lastItems, notes: '' });
+    }
+    async saveAndReturnReserve(bbcDateId, reserveUpdate) {
+        const isBBCLockedResult = await this.signsService.isBBCLocked(bbcDateId);
+        if (isBBCLockedResult) {
+            return null;
+        }
+        const summary = this.calculateSummary(reserveUpdate.items);
+        return await (0, reserve_db_1.saveReserveDoc)(new mongoose_1.default.Types.ObjectId(bbcDateId), { ...reserveUpdate, summary });
+    }
+    ;
+    async getLastCopyReserve(bbcDateId) {
+        const { borrowerId } = await (0, bbcDates_db_1.getBBCDateDoc)(bbcDateId.toString());
+        const equipment = await (0, reserve_db_1.getLastReserveDocs)(bbcDateId, borrowerId.toString());
+        if (!!equipment.length) {
+            return equipment.pop().items;
+        }
+        return [];
+    }
+    calculateSummary(reserveItems) {
+        const summary = [];
+        const summaryOrder = [
+            reserve_types_enum_1.EReserveTypes.RENT,
+            reserve_types_enum_1.EReserveTypes.PAYROLL,
+            reserve_types_enum_1.EReserveTypes.INSURANCE,
+            reserve_types_enum_1.EReserveTypes.TAX,
+            reserve_types_enum_1.EReserveTypes.INVENTORY,
+            reserve_types_enum_1.EReserveTypes.RECEIVABLES,
+            reserve_types_enum_1.EReserveTypes.EQUIPMENT,
+            reserve_types_enum_1.EReserveTypes.OTHER,
+        ];
+        const result = Object.keys(reserve_types_enum_1.EReserveTypes).map((equipmentType) => {
+            const typeSummary = { rowDef: equipmentType, amount: 0 };
+            reserveItems.forEach((item) => {
+                if (item.type === equipmentType) {
+                    typeSummary.amount = new decimal_js_1.default(typeSummary.amount).add(item.amount).toNumber();
+                }
+                return typeSummary;
+            });
+            return typeSummary;
+        });
+        summaryOrder.forEach((summaryType) => {
+            summary.push(...result.filter((r) => r.rowDef === summaryType));
+        });
+        return summary.reduce((acc, s) => ({ ...acc, [s.rowDef]: s }), {});
+    }
+}
+exports.ReserveService = ReserveService;

package/services/reserve.service.ts

@@ -0,0 +1,79 @@
+import mongoose from 'mongoose';
+import Decimal from 'decimal.js';
+
+import { getBBCDateDoc } from '../db/bbcDates.db';
+import { EReserveTypes } from '../enums/reserve-types.enum';
+
+import { IReserve, IReserveItem, IReserveSummary } from '../models/Reserve.model';
+import { copyReserveWithoutSaving, getLastReserveDocs, getReserveDocs, saveReserveDoc } from '../db/reserve.db';
+import { SignsService } from './signs.service';
+
+export class ReserveService {
+
+  constructor(
+    private readonly signsService: SignsService,
+  ) {
+  }
+
+  async getReserve(bbcDateId: string): Promise<IReserve> {
+    const bbcDateIdID = new mongoose.Types.ObjectId(bbcDateId);
+    const reserves = await getReserveDocs([bbcDateIdID]);
+    if (!!reserves.length) {
+      return reserves.pop();
+    }
+    const lastItems = await this.getLastCopyReserve(bbcDateId);
+    const isBBCLockedResult = await this.signsService.isBBCLocked(bbcDateId);
+    if (isBBCLockedResult) {
+      const summary = this.calculateSummary(lastItems);
+      return await copyReserveWithoutSaving(bbcDateIdID, lastItems, summary);
+    }
+    return this.saveAndReturnReserve(bbcDateId, { items: lastItems, notes: '' });
+  }
+
+  async saveAndReturnReserve(bbcDateId: string, reserveUpdate: Partial<IReserve>) {
+    const isBBCLockedResult = await this.signsService.isBBCLocked(bbcDateId);
+    if (isBBCLockedResult) {
+      return null;
+    }
+    const summary = this.calculateSummary(reserveUpdate.items);
+    return await saveReserveDoc(new mongoose.Types.ObjectId(bbcDateId), { ...reserveUpdate, summary });
+  };
+
+  async getLastCopyReserve(bbcDateId: string) {
+    const { borrowerId } = await getBBCDateDoc(bbcDateId.toString());
+    const equipment = await getLastReserveDocs(bbcDateId, borrowerId.toString());
+    if (!!equipment.length) {
+      return equipment.pop().items;
+    }
+    return [];
+  }
+
+  private calculateSummary(reserveItems: IReserveItem[]): IReserveSummary {
+    const summary: { rowDef: string, amount: number }[] = [];
+    const summaryOrder = [
+      EReserveTypes.RENT,
+      EReserveTypes.PAYROLL,
+      EReserveTypes.INSURANCE,
+      EReserveTypes.TAX,
+      EReserveTypes.INVENTORY,
+      EReserveTypes.RECEIVABLES,
+      EReserveTypes.EQUIPMENT,
+      EReserveTypes.OTHER,
+    ];
+    const result = Object.keys(EReserveTypes).map((equipmentType) => {
+      const typeSummary = { rowDef: equipmentType, amount: 0 };
+      reserveItems.forEach((item) => {
+        if (item.type === equipmentType) {
+          typeSummary.amount = new Decimal(typeSummary.amount).add(item.amount).toNumber();
+        }
+        return typeSummary;
+      });
+      return typeSummary;
+    });
+    summaryOrder.forEach((summaryType) => {
+      summary.push(...result.filter((r) => r.rowDef === summaryType));
+    });
+    return summary.reduce((acc, s) => ({ ...acc, [s.rowDef]: s }), {});
+  }
+
+}

package/services/sentry.service.d.ts

@@ -0,0 +1,11 @@
+import express from 'express';
+interface ISentryServiceConfig {
+    dsn: string;
+    isProduction: boolean;
+}
+export declare class SentryService {
+    private readonly config;
+    constructor(config: ISentryServiceConfig);
+    catchErrorBySentry(res: express.Response, err?: Error, status?: number, data?: object): express.Response<any, Record<string, any>>;
+}
+export {};

package/services/sentry.service.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SentryService = void 0;
+const Sentry = __importStar(require("@sentry/node"));
+class SentryService {
+    config;
+    constructor(config) {
+        this.config = config;
+        if (this.config.isProduction) {
+            Sentry.init({
+                dsn: this.config.dsn,
+                tracesSampleRate: 1.0,
+            });
+        }
+    }
+    catchErrorBySentry(res, err, status = 500, data) {
+        console.error(err);
+        if (this.config.isProduction) {
+            Sentry.captureException(err);
+            if (res) {
+                return res.status(status).json({ message: err?.message ?? 'Something went wrong', ...data });
+            }
+        }
+    }
+}
+exports.SentryService = SentryService;

package/services/sentry.service.ts

@@ -0,0 +1,33 @@
+import express from 'express';
+import * as Sentry from '@sentry/node';
+
+interface ISentryServiceConfig {
+  dsn: string;
+  isProduction: boolean;
+}
+
+export class SentryService {
+  private readonly config: ISentryServiceConfig;
+
+  constructor(
+    config: ISentryServiceConfig,
+  ) {
+    this.config = config;
+    if (this.config.isProduction) {
+      Sentry.init({
+        dsn: this.config.dsn,
+        tracesSampleRate: 1.0,
+      });
+    }
+  }
+
+  catchErrorBySentry(res: express.Response, err?: Error, status = 500, data?: object) {
+    console.error(err);
+    if (this.config.isProduction) {
+      Sentry.captureException(err);
+      if (res) {
+        return res.status(status).json({ message: err?.message ?? 'Something went wrong', ...data });
+      }
+    }
+  }
+}

package/services/signs.service.d.ts

@@ -0,0 +1,69 @@
+/// <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, { Document } from 'mongoose';
+import { IResult } from '../interfaces/result.interface';
+import { IUserDocument } from '../models/User.model';
+import { IAvailabilitySignView } from '../models/AvailabilitySigns.model';
+import { IBBCDateDoc } from '../models/BBCDate.model';
+import { IBorrowerDocument } from '../models/Borrower.model';
+import { IKeycloakUser } from '../interfaces/keycloak-user.interface';
+import { IPaginatorOptions } from '../interfaces/collaterals.interface';
+import { UsersService } from './users.service';
+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 declare enum ESignStatus {
+    STARTED = "STARTED",
+    APPROVED = "APPROVED",
+    PENDING = "PENDING"
+}
+export declare class SignsService {
+    private readonly lockService;
+    private readonly loanTransactionsService;
+    private readonly loanStatementService;
+    private readonly usersService;
+    constructor(lockService: LockService, loanTransactionsService: LoanTransactionsService, loanStatementService: LoanStatementService, usersService: UsersService);
+    keyCloakUsers: IKeycloakUser[];
+    fulfillUserList(): Promise<void>;
+    clearUserList(): void;
+    getAvailabilitySigns(bbcDateId: string): Promise<IAvailabilitySignView>;
+    revokeAvailability(bbcDateId: string, userId: string, userIdRevoked: string): Promise<void>;
+    signAvailability(bbcDateId: string, user: IUserDocument): Promise<IResult>;
+    isBBCLocked(bbcDateId: string): Promise<boolean>;
+    getLatestSignedBBCDate(borrowerId: string, date?: Date): Promise<IBBCDateDoc>;
+    getSavedData(bbcDateId: string): Promise<any>;
+    keepBalance(bbcDateId: string): Promise<void>;
+    clearAvailabilityStoredData(bbcDateId: string): Promise<void>;
+    logSignStatus(bbcDateId: string, userId: string, isSigned: boolean): Promise<void>;
+    BBCDatesShort(borrowerId: string, paginatorOptions: IPaginatorOptions): Promise<{
+        _id: mongoose.Types.ObjectId;
+        bbcDate: Date;
+        signStatus: string;
+    }[]>;
+}

package/services/signs.service.js

@@ -0,0 +1,230 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignsService = exports.ESignStatus = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const lodash_1 = __importDefault(require("lodash"));
+const availability_db_1 = require("../db/availability.db");
+const AvailabilitySigns_model_1 = require("../models/AvailabilitySigns.model");
+const BBCDate_model_1 = require("../models/BBCDate.model");
+const _models_1 = require("../models/_models");
+const bbcDates_db_1 = require("../db/bbcDates.db");
+const UserLog_model_1 = require("../models/UserLog.model");
+const user_logs_db_1 = require("../db/user-logs.db");
+const collaterals_db_1 = require("../db/collaterals.db");
+const AvilabilitySignedData_model_1 = require("../models/AvilabilitySignedData.model");
+var ESignStatus;
+(function (ESignStatus) {
+    ESignStatus["STARTED"] = "STARTED";
+    ESignStatus["APPROVED"] = "APPROVED";
+    ESignStatus["PENDING"] = "PENDING";
+})(ESignStatus || (exports.ESignStatus = ESignStatus = {}));
+class SignsService {
+    lockService;
+    loanTransactionsService;
+    loanStatementService;
+    usersService;
+    constructor(lockService, loanTransactionsService, loanStatementService, usersService) {
+        this.lockService = lockService;
+        this.loanTransactionsService = loanTransactionsService;
+        this.loanStatementService = loanStatementService;
+        this.usersService = usersService;
+    }
+    keyCloakUsers = 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) {
+        const availabilitiesSigns = await (0, availability_db_1.getAvailabilitySigns)([bbcDateId]);
+        if (!availabilitiesSigns.length) {
+            return {
+                _id: null,
+                bbcDateId: new mongoose_1.default.Types.ObjectId(bbcDateId),
+                requiredSigns: AvailabilitySigns_model_1.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 = (lodash_1.default.pick(userSign.userSigned, ['_id', 'firstName', 'lastName']));
+            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 = (lodash_1.default.pick(userSign.userRevoked, ['_id', 'firstName', 'lastName']));
+            }
+            return [...acc, lodash_1.default.pick(userSign, ['userSigned', 'signedAt', 'userRevoked', 'revokedAt'])];
+        }, []);
+        return availabilitySigns;
+    }
+    async revokeAvailability(bbcDateId, userId, userIdRevoked) {
+        const availability = await (0, availability_db_1.findAvailabilitySignsByBBCDateId)(bbcDateId);
+        const updatedSigns = availability.signs.map((sign) => {
+            if (sign.userSignedId.toString() === userId && !sign.revokedAt) {
+                sign.userRevokedId = new mongoose_1.default.Types.ObjectId(userIdRevoked);
+                sign.revokedAt = new Date();
+                sign.userRevokedId = new mongoose_1.default.Types.ObjectId(userIdRevoked);
+            }
+            return sign;
+        });
+        await (0, availability_db_1.updateAvailabilitySigns)(bbcDateId, updatedSigns);
+    }
+    async signAvailability(bbcDateId, user) {
+        const newSign = { userSignedId: user._id, signedAt: new Date() };
+        return await (0, availability_db_1.addAvailabilitySign)(bbcDateId, newSign);
+    }
+    async isBBCLocked(bbcDateId) {
+        const bbcDoc = await BBCDate_model_1.BBCDateModel.findById(bbcDateId).lean();
+        if (!bbcDoc) {
+            return false;
+        }
+        return await this.lockService.isDateLocked(bbcDoc.bbcDate, bbcDoc.borrowerId.toString());
+    }
+    async getLatestSignedBBCDate(borrowerId, date) {
+        const bbcDocs = await (0, bbcDates_db_1.getOlderBBCDates)(borrowerId, date || new Date());
+        const activeSignsAfter = await AvailabilitySigns_model_1.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: _models_1.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) {
+        const availabilitySignedData = await AvilabilitySignedData_model_1.AvailabilitySignedData.findOne({ bbcDateId }).lean();
+        if (!availabilitySignedData) {
+            return {};
+        }
+        return availabilitySignedData.data;
+    }
+    async keepBalance(bbcDateId) {
+        const loanBalances = await this.loanTransactionsService.getLoanBalanceForBBCDateId(bbcDateId);
+        const accruedStatement = await this.loanStatementService.calculateAccruedStatementForBBC(bbcDateId);
+        console.log({ bbcDateId });
+        await AvilabilitySignedData_model_1.AvailabilitySignedData.findOneAndUpdate({ bbcDateId }, { data: { loanBalances, accruedStatement } }, { upsert: true });
+    }
+    async clearAvailabilityStoredData(bbcDateId) {
+        await AvilabilitySignedData_model_1.AvailabilitySignedData.findOneAndDelete({ bbcDateId });
+    }
+    async logSignStatus(bbcDateId, userId, isSigned) {
+        const bbcDate = await BBCDate_model_1.BBCDateModel.findById(bbcDateId)
+            .populate('borrowerId')
+            .lean();
+        if (!bbcDate) {
+            return;
+        }
+        const newLog = {
+            userId,
+            action: isSigned ? UserLog_model_1.ELogActionType.CREATE : UserLog_model_1.ELogActionType.DELETE,
+            details: { date: bbcDate.bbcDate, borrower: bbcDate.borrowerId.name }, // , borrower: bbcDate.borrower.name
+            logType: isSigned ? UserLog_model_1.ELogType.SIGN_BBC : UserLog_model_1.ELogType.REVOKE_BBC,
+        };
+        await (0, user_logs_db_1.createLog)(newLog);
+    }
+    async BBCDatesShort(borrowerId, paginatorOptions) {
+        const BBCDates = await BBCDate_model_1.BBCDateModel.aggregate([
+            {
+                '$match': {
+                    'borrowerId': new mongoose_1.default.Types.ObjectId(borrowerId),
+                },
+            }, {
+                '$sort': {
+                    'bbcDate': -1,
+                },
+            }, {
+                '$project': {
+                    '_id': 1,
+                    'bbcDate': 1,
+                    'signStatus': 1,
+                },
+            },
+            ...(0, collaterals_db_1.ITEMS_PAGINATION)(paginatorOptions),
+        ]);
+        const availabilitiesSigns = await (0, availability_db_1.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;
+    }
+}
+exports.SignsService = SignsService;