gemcap-be-common 1.1.91 → 1.1.92

package/db/availability.db.d.ts

@@ -0,0 +1,6 @@
+import { IAvailabilitySignDoc, IAvailabilitySignItem, IAvailabilitySignView } from '../models';
+import { IResult } from '../interfaces';
+export declare const findAvailabilitySignsByBBCDateId: (bbcDateId: string) => Promise<IAvailabilitySignDoc>;
+export declare const getAvailabilitySigns: (bbcDateId: string) => Promise<IAvailabilitySignView[]>;
+export declare const addAvailabilitySign: (bbcDateId: string, sign: IAvailabilitySignItem) => Promise<IResult>;
+export declare const updateAvailabilitySigns: (bbcDateId: string, signs: IAvailabilitySignItem[]) => Promise<void>;

package/db/availability.db.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateAvailabilitySigns = exports.addAvailabilitySign = exports.getAvailabilitySigns = exports.findAvailabilitySignsByBBCDateId = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const models_1 = require("../models");
+const findAvailabilitySignsByBBCDateId = async (bbcDateId) => {
+    return models_1.AvailabilitySign.findOne({ bbcDateId: new mongoose_1.default.Types.ObjectId(bbcDateId) }).lean();
+};
+exports.findAvailabilitySignsByBBCDateId = findAvailabilitySignsByBBCDateId;
+const getAvailabilitySigns = async (bbcDateId) => {
+    return models_1.AvailabilitySign.aggregate([
+        {
+            $match: {
+                'bbcDateId': new mongoose_1.default.Types.ObjectId(bbcDateId)
+            }
+        }, {
+            $unwind: {
+                path: '$signs',
+                preserveNullAndEmptyArrays: true
+            }
+        }, {
+            $lookup: {
+                from: 'users',
+                localField: 'signs.userSignedId',
+                foreignField: '_id',
+                as: 'signs.userSigned'
+            }
+        }, {
+            $lookup: {
+                from: 'users',
+                localField: 'signs.userRevokedId',
+                foreignField: '_id',
+                as: 'signs.userRevoked',
+            },
+        }, {
+            $unwind: {
+                path: '$signs.userSigned',
+                preserveNullAndEmptyArrays: true
+            }
+        }, {
+            $unwind: {
+                path: '$signs.userRevoked',
+                preserveNullAndEmptyArrays: true,
+            },
+        }, {
+            $unset: [
+                'signs.userSignedId',
+                'signs.userRevokedId',
+            ],
+        },
+        {
+            $sort: {
+                'signs.signedAt': 1,
+            },
+        }, {
+            $group: {
+                '_id': '$_id',
+                'bbcDateId': {
+                    $first: '$bbcDateId'
+                },
+                'requiredSigns': {
+                    $first: '$requiredSigns'
+                },
+                'signs': {
+                    $push: '$signs'
+                }
+            }
+        }
+    ]);
+};
+exports.getAvailabilitySigns = getAvailabilitySigns;
+const addAvailabilitySign = async (bbcDateId, sign) => {
+    const availabilitySigns = await models_1.AvailabilitySign.findOne({ bbcDateId: new mongoose_1.default.Types.ObjectId(bbcDateId) }).lean();
+    if (!availabilitySigns) {
+        await models_1.AvailabilitySign.create({ bbcDateId, signs: [sign] });
+        return { message: 'Availability was signed', success: true };
+    }
+    const activeSigns = availabilitySigns.signs.filter((sign) => !sign.revokedAt);
+    const foundUserSign = activeSigns.find((s) => s.userSignedId.toString() === sign.userSignedId.toString());
+    if (foundUserSign) {
+        return { message: `You already signed this availability`, success: false };
+    }
+    if (activeSigns.length >= availabilitySigns.requiredSigns) {
+        return { message: `Availability required only ${availabilitySigns.requiredSigns} signs`, success: false };
+    }
+    const updatedSigns = availabilitySigns.signs.slice();
+    await models_1.AvailabilitySign.findOneAndUpdate({ bbcDateId: new mongoose_1.default.Types.ObjectId(bbcDateId) }, { signs: [...updatedSigns, sign] });
+    return { message: 'Availability was signed', success: true };
+};
+exports.addAvailabilitySign = addAvailabilitySign;
+const updateAvailabilitySigns = async (bbcDateId, signs) => {
+    await models_1.AvailabilitySign.findOneAndUpdate({ bbcDateId: new mongoose_1.default.Types.ObjectId(bbcDateId) }, { signs: signs });
+};
+exports.updateAvailabilitySigns = updateAvailabilitySigns;

package/db/availability.db.ts

@@ -0,0 +1,100 @@
+import mongoose from 'mongoose';
+
+import {
+  AvailabilitySign,
+  IAvailabilitySignDoc,
+  IAvailabilitySignItem,
+  IAvailabilitySignView
+} from '../models';
+import { IResult } from '../interfaces';
+
+export const findAvailabilitySignsByBBCDateId = async (bbcDateId: string): Promise<IAvailabilitySignDoc> => {
+  return AvailabilitySign.findOne({ bbcDateId: new mongoose.Types.ObjectId(bbcDateId) }).lean();
+}
+
+export const getAvailabilitySigns = async (bbcDateId: string) => {
+  return AvailabilitySign.aggregate<IAvailabilitySignView>([
+    {
+      $match: {
+        'bbcDateId': new mongoose.Types.ObjectId(bbcDateId)
+      }
+    }, {
+      $unwind: {
+        path: '$signs',
+        preserveNullAndEmptyArrays: true
+      }
+    }, {
+      $lookup: {
+        from: 'users',
+        localField: 'signs.userSignedId',
+        foreignField: '_id',
+        as: 'signs.userSigned'
+      }
+    }, {
+      $lookup:
+        {
+          from: 'users',
+          localField: 'signs.userRevokedId',
+          foreignField: '_id',
+          as: 'signs.userRevoked',
+        },
+    }, {
+      $unwind: {
+        path: '$signs.userSigned',
+        preserveNullAndEmptyArrays: true
+      }
+    }, {
+      $unwind: {
+        path: '$signs.userRevoked',
+        preserveNullAndEmptyArrays: true,
+      },
+    }, {
+      $unset: [
+        'signs.userSignedId',
+        'signs.userRevokedId',
+      ],
+    },
+    {
+      $sort:
+        {
+          'signs.signedAt': 1,
+        },
+    }, {
+      $group: {
+        '_id': '$_id',
+        'bbcDateId': {
+          $first: '$bbcDateId'
+        },
+        'requiredSigns': {
+          $first: '$requiredSigns'
+        },
+        'signs': {
+          $push: '$signs'
+        }
+      }
+    }
+  ]);
+}
+
+export const addAvailabilitySign = async (bbcDateId: string, sign: IAvailabilitySignItem): Promise<IResult> => {
+  const availabilitySigns: IAvailabilitySignDoc = await AvailabilitySign.findOne({ bbcDateId: new mongoose.Types.ObjectId(bbcDateId) }).lean();
+  if (!availabilitySigns) {
+    await AvailabilitySign.create({ bbcDateId, signs: [sign] });
+    return { message: 'Availability was signed', success: true };
+  }
+  const activeSigns = availabilitySigns.signs.filter((sign) => !sign.revokedAt);
+  const foundUserSign = activeSigns.find((s) => s.userSignedId.toString() === sign.userSignedId.toString());
+  if (foundUserSign) {
+    return { message: `You already signed this availability`, success: false };
+  }
+  if (activeSigns.length >= availabilitySigns.requiredSigns) {
+    return { message: `Availability required only ${availabilitySigns.requiredSigns} signs`, success: false };
+  }
+  const updatedSigns = availabilitySigns.signs.slice();
+  await AvailabilitySign.findOneAndUpdate({ bbcDateId: new mongoose.Types.ObjectId(bbcDateId) }, {signs: [...updatedSigns, sign] });
+  return { message: 'Availability was signed', success: true };
+}
+
+export const updateAvailabilitySigns = async (bbcDateId: string, signs: IAvailabilitySignItem[]): Promise<void> => {
+  await AvailabilitySign.findOneAndUpdate({ bbcDateId: new mongoose.Types.ObjectId(bbcDateId) }, { signs: signs });
+}

package/db/bbcDates.db.d.ts

@@ -0,0 +1,39 @@
+/// <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 { IBBCDateDoc } from '../models';
+import { ECollaterals } from '../enums';
+export declare const getBBCDateDoc: (bbcDateId: string) => Promise<mongoose.FlattenMaps<IBBCDateDoc> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const getBBCDatesByBorrower: (borrowerId: string, sortOrder?: 1 | -1) => Promise<IBBCDateDoc[]>;
+export declare const getLatestSignedBBCDateDoc: (borrowerId: string) => Promise<any>;
+export declare const getOlderBBCDates: (borrowerId: string, bbcDate: Date) => Promise<IBBCDateDoc[]>;
+export declare const getBBCDates: (borrowerId: string, bbcDate: Date) => Promise<IBBCDateDoc[]>;
+export declare const getBBCDatesForPeriod: (borrowerId: string, bbcDateStart: Date, bbcDateEnd: Date) => Promise<IBBCDateDoc[]>;
+export declare const getBBCDatesByType: (borrowerId: string, collateralType: ECollaterals) => mongoose.Aggregate<IBBCDateDoc[]>;
+export declare const createBBCDate: (borrowerId: string, bbcDate: Date) => Promise<mongoose.Document<unknown, {}, IBBCDateDoc> & IBBCDateDoc & {
+    _id: mongoose.Types.ObjectId;
+}>;

package/db/bbcDates.db.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.createBBCDate = exports.getBBCDatesByType = exports.getBBCDatesForPeriod = exports.getBBCDates = exports.getOlderBBCDates = exports.getLatestSignedBBCDateDoc = exports.getBBCDatesByBorrower = exports.getBBCDateDoc = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const models_1 = require("../models");
+const availability_db_1 = require("./availability.db");
+const getBBCDateDoc = async (bbcDateId) => {
+    return models_1.BBCDateModel.findById(bbcDateId).lean();
+};
+exports.getBBCDateDoc = getBBCDateDoc;
+const getBBCDatesByBorrower = async (borrowerId, sortOrder = 1) => {
+    return models_1.BBCDateModel.aggregate([
+        {
+            $match: {
+                borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+            },
+        },
+        {
+            $sort: { bbcDate: sortOrder },
+        },
+    ]);
+};
+exports.getBBCDatesByBorrower = getBBCDatesByBorrower;
+const getLatestSignedBBCDateDoc = async (borrowerId) => {
+    const bbcDates = await models_1.BBCDateModel.aggregate([
+        {
+            $match: {
+                borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+            },
+        },
+        {
+            $sort: { bbcDate: -1 },
+        },
+    ]);
+    if (!bbcDates) {
+        return null;
+    }
+    let foundSignedBBC = null;
+    let i = 0;
+    while (!foundSignedBBC) {
+        if (i === bbcDates.length) {
+            break;
+        }
+        const availabilitySigns = (await (0, availability_db_1.getAvailabilitySigns)(bbcDates[i]._id.toString())).pop();
+        if (availabilitySigns) {
+            const totalSigns = availabilitySigns.signs.filter((sign) => !sign.revokedAt);
+            foundSignedBBC = totalSigns.length === availabilitySigns.requiredSigns ? bbcDates[i] : null;
+        }
+        i = i + 1;
+    }
+    return foundSignedBBC;
+};
+exports.getLatestSignedBBCDateDoc = getLatestSignedBBCDateDoc;
+const getOlderBBCDates = async (borrowerId, bbcDate) => {
+    return models_1.BBCDateModel.aggregate([
+        {
+            $match: {
+                borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+                bbcDate: { $lt: bbcDate },
+            },
+        },
+        {
+            $sort: { bbcDate: 1 },
+        },
+    ]);
+};
+exports.getOlderBBCDates = getOlderBBCDates;
+const getBBCDates = async (borrowerId, bbcDate) => {
+    return models_1.BBCDateModel.aggregate([
+        {
+            $match: {
+                borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId),
+                bbcDate: new Date(bbcDate),
+            },
+        },
+        {
+            $sort: { updatedAt: 1 },
+        },
+    ]);
+};
+exports.getBBCDates = getBBCDates;
+const getBBCDatesForPeriod = async (borrowerId, bbcDateStart, bbcDateEnd) => {
+    return models_1.BBCDateModel.aggregate([
+        {
+            $match: {
+                $and: [
+                    { 'borrowerId': new mongoose_1.default.Types.ObjectId(borrowerId) },
+                    { 'bbcDate': { $gte: bbcDateStart } },
+                    { 'bbcDate': { $lte: bbcDateEnd } },
+                ],
+            },
+        },
+        {
+            $sort: {
+                'bbcDate': 1,
+            },
+        },
+    ]);
+};
+exports.getBBCDatesForPeriod = getBBCDatesForPeriod;
+const getBBCDatesByType = (borrowerId, collateralType) => {
+    return models_1.BBCSheetModel.aggregate([
+        {
+            $match: {
+                'dataType': collateralType,
+            },
+        },
+        {
+            $lookup: {
+                from: 'bbcdates',
+                localField: 'bbcDateId',
+                foreignField: '_id',
+                as: 'bbc',
+            },
+        },
+        {
+            $unwind: {
+                path: '$bbc',
+            },
+        },
+        {
+            $match: {
+                'bbc.borrowerId': new mongoose_1.default.Types.ObjectId(borrowerId),
+            },
+        },
+        {
+            $group: {
+                '_id': '$bbc._id',
+                'borrowerId': {
+                    $first: '$bbc.borrowerId',
+                },
+                'bbcDate': {
+                    $first: '$bbc.bbcDate',
+                },
+                'createdAt': {
+                    $first: '$bbc.createdAt',
+                },
+                'updatedAt': {
+                    $first: '$bbc.updatedAt',
+                },
+                '__v': {
+                    $first: '$bbc.__v',
+                },
+            },
+        },
+        {
+            $sort: {
+                'bbcDate': -1,
+            },
+        },
+    ]);
+};
+exports.getBBCDatesByType = getBBCDatesByType;
+const createBBCDate = async (borrowerId, bbcDate) => {
+    const newBBC = await models_1.BBCDateModel.create({ borrowerId: new mongoose_1.default.Types.ObjectId(borrowerId), bbcDate });
+    return newBBC.save();
+};
+exports.createBBCDate = createBBCDate;

package/db/bbcDates.db.ts

@@ -0,0 +1,157 @@
+import mongoose from 'mongoose';
+
+import { BBCDateModel, BBCSheetModel, IBBCDateDoc } from '../models';
+import { getAvailabilitySigns } from './availability.db';
+import { ECollaterals } from '../enums';
+
+export const getBBCDateDoc = async (bbcDateId: string) => {
+  return BBCDateModel.findById(bbcDateId).lean();
+};
+
+export const getBBCDatesByBorrower = async (borrowerId: string, sortOrder: 1 | -1 = 1) => {
+  return BBCDateModel.aggregate<IBBCDateDoc>([
+    {
+      $match: {
+        borrowerId: new mongoose.Types.ObjectId(borrowerId),
+      },
+    },
+    {
+      $sort: { bbcDate: sortOrder },
+    },
+  ]);
+};
+
+export const getLatestSignedBBCDateDoc = async (borrowerId: string) => {
+  const bbcDates = await BBCDateModel.aggregate<IBBCDateDoc>([
+    {
+      $match: {
+        borrowerId: new mongoose.Types.ObjectId(borrowerId),
+      },
+    },
+    {
+      $sort: { bbcDate: -1 },
+    },
+  ]);
+  if (!bbcDates) {
+    return null;
+  }
+  let foundSignedBBC = null;
+  let i = 0;
+  while (!foundSignedBBC) {
+    if (i === bbcDates.length) {
+      break;
+    }
+    const availabilitySigns = (await getAvailabilitySigns(bbcDates[i]._id.toString())).pop();
+    if (availabilitySigns) {
+      const totalSigns = availabilitySigns.signs.filter((sign) => !sign.revokedAt);
+      foundSignedBBC = totalSigns.length === availabilitySigns.requiredSigns ? bbcDates[i] : null;
+    }
+    i = i + 1;
+  }
+  return foundSignedBBC;
+};
+
+export const getOlderBBCDates = async (borrowerId: string, bbcDate: Date) => {
+  return BBCDateModel.aggregate<IBBCDateDoc>([
+    {
+      $match: {
+        borrowerId: new mongoose.Types.ObjectId(borrowerId),
+        bbcDate: { $lt: bbcDate },
+      },
+    },
+    {
+      $sort: { bbcDate: 1 },
+    },
+  ]);
+};
+
+export const getBBCDates = async (borrowerId: string, bbcDate: Date) => {
+  return BBCDateModel.aggregate<IBBCDateDoc>([
+    {
+      $match: {
+        borrowerId: new mongoose.Types.ObjectId(borrowerId),
+        bbcDate: new Date(bbcDate),
+      },
+    },
+    {
+      $sort: { updatedAt: 1 },
+    },
+  ]);
+};
+
+export const getBBCDatesForPeriod = async (borrowerId: string, bbcDateStart: Date, bbcDateEnd: Date) => {
+  return BBCDateModel.aggregate<IBBCDateDoc>([
+    {
+      $match: {
+        $and: [
+          { 'borrowerId': new mongoose.Types.ObjectId(borrowerId) },
+          { 'bbcDate': { $gte: bbcDateStart } },
+          { 'bbcDate': { $lte: bbcDateEnd } },
+        ],
+      },
+    },
+    {
+      $sort: {
+        'bbcDate': 1,
+      },
+    },
+  ]);
+};
+
+export const getBBCDatesByType = (borrowerId: string, collateralType: ECollaterals) => {
+  return BBCSheetModel.aggregate<IBBCDateDoc>([
+    {
+      $match: {
+        'dataType': collateralType,
+      },
+    },
+    {
+      $lookup: {
+        from: 'bbcdates',
+        localField: 'bbcDateId',
+        foreignField: '_id',
+        as: 'bbc',
+      },
+    },
+    {
+      $unwind: {
+        path: '$bbc',
+      },
+    },
+    {
+      $match: {
+        'bbc.borrowerId': new mongoose.Types.ObjectId(borrowerId),
+      },
+    },
+    {
+      $group: {
+        '_id': '$bbc._id',
+        'borrowerId': {
+          $first: '$bbc.borrowerId',
+        },
+        'bbcDate': {
+          $first: '$bbc.bbcDate',
+        },
+        'createdAt': {
+          $first: '$bbc.createdAt',
+        },
+        'updatedAt': {
+          $first: '$bbc.updatedAt',
+        },
+        '__v': {
+          $first: '$bbc.__v',
+        },
+      },
+    },
+    {
+      $sort: {
+        'bbcDate': -1,
+      },
+    },
+  ]);
+};
+
+export const createBBCDate = async (borrowerId: string, bbcDate: Date) => {
+  const newBBC = await BBCDateModel.create({ borrowerId: new mongoose.Types.ObjectId(borrowerId), bbcDate });
+  return newBBC.save();
+};

package/db/bbcSheets.db.d.ts

@@ -0,0 +1,44 @@
+/// <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 { ECollaterals } from '../enums';
+import { IBBCSheetDoc } from '../models';
+export declare const getBBCSheetsByType: (bbcDateIds: string[], collateralType: ECollaterals) => Promise<IBBCSheetDoc[]>;
+export declare const getBBCSheetsByTypeGroupedByBBC: (bbcDateIds: string[], collateralType: ECollaterals) => Promise<{
+    _id: mongoose.Types.ObjectId;
+    sheets: IBBCSheetDoc[];
+}[]>;
+export declare const getUniqueDates: (borrowerId: string, limit: number, collateral: ECollaterals) => Promise<{
+    bbcDate: Date;
+    ids: mongoose.Types.ObjectId[];
+}[]>;
+export declare const getUniqueDatesForPeriod: (borrowerId: string, collateral: ECollaterals, startDate: Date, endDate: Date) => Promise<{
+    _id: mongoose.Types.ObjectId;
+    bbcDate: Date;
+    ids: mongoose.Types.ObjectId[];
+}[]>;
+export declare const createBBCSheet: (bbcDateId: string, dataType: 'INVENTORY' | 'RECEIVABLE') => Promise<mongoose.Document<unknown, {}, IBBCSheetDoc> & IBBCSheetDoc & {
+    _id: mongoose.Types.ObjectId;
+}>;