gemcap-be-common 1.2.140 → 1.3.0

package/services/calendar.service.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CalendarService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const CalandarDay_model_1 = __importDefault(require("../models/CalandarDay.model"));
+class CalendarService {
+    async fulfillCalendar() {
+        const getDays = () => {
+            const days = [];
+            const start = (0, dayjs_1.default)('2025-01-01');
+            const end = (0, dayjs_1.default)('2026-01-01'); // TODO add custom date
+            for (let day = (0, dayjs_1.default)(start); day.isBefore(end); day = day.add(1, 'day')) {
+                days.push(day.format('YYYY-MM-DD'));
+            }
+            return days;
+        };
+        const options = (date) => ({
+            method: 'GET',
+            url: 'https://working-days.p.rapidapi.com/1.3/get_info_day',
+            params: {
+                country_code: 'US',
+                date,
+            },
+            headers: {
+                'X-RapidAPI-Key': '07a550d083msh90e492b0eeb739cp180bb6jsn4005ea3ba2a7',
+                'X-RapidAPI-Host': 'working-days.p.rapidapi.com',
+            },
+        });
+        try {
+            const dates = getDays();
+            const datesToCreate = [];
+            await Promise.all(dates.map(async (date) => {
+                const foundDate = await CalandarDay_model_1.default.findOne({ date });
+                if (!foundDate) {
+                    datesToCreate.push(date);
+                }
+            }));
+            await Promise.all(datesToCreate.map(async (date, i) => {
+                setTimeout(async () => {
+                    const response = await axios_1.default.request(options(date));
+                    await this.createDate(date, response.data);
+                    console.log('created', date);
+                    if (datesToCreate.length === i + 1) {
+                        console.log('done!');
+                    }
+                }, i * 500);
+            }));
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    async createDate(date, dateProp) {
+        const newDate = {
+            date: date,
+            customDate: dateProp.custom_date === 1,
+            customDateDescription: dateProp.custom_date_description,
+            publicHoliday: dateProp.public_holiday === '1',
+            publicHolidayDescription: dateProp.public_holiday_description,
+            weekendDay: dateProp.weekend_day === 1,
+            workingDay: dateProp.working_day === 1,
+        };
+        await CalandarDay_model_1.default.create(newDate);
+    }
+    async isWorkingDay(date) {
+        const calendarDay = await CalandarDay_model_1.default.findOne({ date });
+        return calendarDay.workingDay;
+    }
+    async isLastWorkingDay(date) {
+        const calendarDay = await CalandarDay_model_1.default.findOne({ date });
+        const isNextDayWorking = await this.isWorkingDay((0, dayjs_1.default)(calendarDay.date).add(1, 'day').format('YYYY-MM-DD'));
+        return !isNextDayWorking;
+    }
+    async getNextWorkingDay(date) {
+        let nextDay = (0, dayjs_1.default)(new Date(date));
+        let isWorking = false;
+        do {
+            nextDay = nextDay.add(1, 'day');
+            const calendarDay = await CalandarDay_model_1.default.findOne({ date: nextDay.format('YYYY-MM-DD') }).lean();
+            if (!calendarDay) {
+                console.error(`no data in calendar for ${nextDay.format('YYYY-MM-DD')}`);
+            }
+            isWorking = calendarDay ? calendarDay.workingDay : true;
+        } while (isWorking === false);
+        return nextDay.format('YYYY-MM-DD');
+    }
+    async getLastWorkingDay(date) {
+        let previous = (0, dayjs_1.default)(new Date(date));
+        let isWorking = false;
+        do {
+            previous = previous.subtract(1, 'day');
+            const calendarDay = await CalandarDay_model_1.default.findOne({ date: previous.format('YYYY-MM-DD') }).lean();
+            if (!calendarDay) {
+                console.error(`no data in calendar for ${previous.format('YYYY-MM-DD')}`);
+            }
+            isWorking = calendarDay ? calendarDay.workingDay : true;
+        } while (isWorking === false);
+        return previous.format('YYYY-MM-DD');
+    }
+    async getFullCalendarList() {
+        return CalandarDay_model_1.default.find().sort({ date: 1 }).lean();
+    }
+}
+exports.CalendarService = CalendarService;

package/services/calendar.service.ts

@@ -0,0 +1,128 @@
+import axios from 'axios';
+import dayjs from 'dayjs';
+
+import CalendarDay, { ICalendarDay } from '../models/CalandarDay.model';
+
+interface IWorkingDaysApi {
+  working_day: number;
+  work_hours: number;
+  wages: number;
+  morning_start: string;
+  morning_end: string;
+  afternoon_start: string;
+  afternoon_end: string;
+  public_holiday: string;
+  public_holiday_description: string;
+  weekend_day: number;
+  custom_date: number;
+  custom_date_description: string;
+  custom_date_color: string;
+  type: number;
+}
+
+export class CalendarService {
+  async fulfillCalendar() {
+
+    const getDays = () => {
+      const days: string[] = [];
+      const start = dayjs('2025-01-01');
+      const end = dayjs('2026-01-01'); // TODO add custom date
+      for (let day = dayjs(start); day.isBefore(end); day = day.add(1, 'day')) {
+        days.push(day.format('YYYY-MM-DD'));
+      }
+      return days;
+    };
+
+    const options = (date: string) => ({
+      method: 'GET',
+      url: 'https://working-days.p.rapidapi.com/1.3/get_info_day',
+      params: {
+        country_code: 'US',
+        date,
+      },
+      headers: {
+        'X-RapidAPI-Key': '07a550d083msh90e492b0eeb739cp180bb6jsn4005ea3ba2a7',
+        'X-RapidAPI-Host': 'working-days.p.rapidapi.com',
+      },
+    });
+
+    try {
+      const dates = getDays();
+      const datesToCreate: string[] = [];
+      await Promise.all(dates.map(async (date) => {
+        const foundDate = await CalendarDay.findOne({ date });
+        if (!foundDate) {
+          datesToCreate.push(date);
+        }
+      }));
+      await Promise.all(datesToCreate.map(async (date, i) => {
+        setTimeout(async () => {
+          const response = await axios.request(options(date));
+          await this.createDate(date, response.data);
+          console.log('created', date);
+          if (datesToCreate.length === i + 1) {
+            console.log('done!');
+          }
+        }, i * 500);
+      }));
+    } catch (error) {
+      console.error(error);
+    }
+  }
+
+  async createDate(date: string, dateProp: IWorkingDaysApi) {
+    const newDate: ICalendarDay = {
+      date: date,
+      customDate: dateProp.custom_date === 1,
+      customDateDescription: dateProp.custom_date_description,
+      publicHoliday: dateProp.public_holiday === '1',
+      publicHolidayDescription: dateProp.public_holiday_description,
+      weekendDay: dateProp.weekend_day === 1,
+      workingDay: dateProp.working_day === 1,
+    };
+    await CalendarDay.create(newDate);
+  }
+
+  async isWorkingDay(date: string): Promise<boolean> {
+    const calendarDay = await CalendarDay.findOne({ date });
+    return calendarDay.workingDay;
+  }
+
+  async isLastWorkingDay(date: string): Promise<boolean> {
+    const calendarDay = await CalendarDay.findOne({ date });
+    const isNextDayWorking = await this.isWorkingDay(dayjs(calendarDay.date).add(1, 'day').format('YYYY-MM-DD'));
+    return !isNextDayWorking;
+  }
+
+  async getNextWorkingDay(date: string) {
+    let nextDay = dayjs(new Date(date));
+    let isWorking = false;
+    do {
+      nextDay = nextDay.add(1, 'day');
+      const calendarDay = await CalendarDay.findOne({ date: nextDay.format('YYYY-MM-DD') }).lean();
+      if (!calendarDay) {
+        console.error(`no data in calendar for ${nextDay.format('YYYY-MM-DD')}`);
+      }
+      isWorking = calendarDay ? calendarDay.workingDay : true;
+    } while (isWorking === false);
+    return nextDay.format('YYYY-MM-DD');
+  }
+
+  async getLastWorkingDay(date: string) {
+    let previous = dayjs(new Date(date));
+    let isWorking = false;
+    do {
+      previous = previous.subtract(1, 'day');
+      const calendarDay = await CalendarDay.findOne({ date: previous.format('YYYY-MM-DD') }).lean();
+      if (!calendarDay) {
+        console.error(`no data in calendar for ${previous.format('YYYY-MM-DD')}`);
+      }
+      isWorking = calendarDay ? calendarDay.workingDay : true;
+    } while (isWorking === false);
+    return previous.format('YYYY-MM-DD');
+  }
+
+  async getFullCalendarList() {
+    return CalendarDay.find().sort({ date: 1 }).lean();
+  }
+}

package/services/cash-allocation.service.d.ts

@@ -0,0 +1,40 @@
+/// <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" />
+/// <reference types="mongoose/types/inferschematype" />
+import { IUploadedBankTransaction } from '../models/UploadedBankTransaction.model';
+import { ICashAllocationReference, ICashAllocationReferenceStringified } from '../models/CashAllocationReference.model';
+import { ICashAllocationProduct, ICashAllocationProductStringified } from '../models/CashAllocationProduct.model';
+export declare class CashAllocationService {
+    createCashAllocation(transactions: IUploadedBankTransaction[]): Promise<void>;
+    getNextOrder(): Promise<number>;
+    getCashAllocationsByReferences(references: string[]): Promise<(import("mongoose").FlattenMaps<ICashAllocationReference> & Required<{
+        _id: import("mongoose").Types.ObjectId;
+    }>)[]>;
+    getAllCashAllocations(): Promise<{
+        references: ICashAllocationReference[];
+        products: ICashAllocationProduct[];
+    }>;
+    updateAllCashAllocation(products: ICashAllocationProductStringified[], references: ICashAllocationReferenceStringified[]): Promise<void>;
+}

package/services/cash-allocation.service.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CashAllocationService = void 0;
+const main_helper_1 = require("../helpers/main.helper");
+const CashAllocationReference_model_1 = require("../models/CashAllocationReference.model");
+const CashAllocationProduct_model_1 = require("../models/CashAllocationProduct.model");
+class CashAllocationService {
+    async createCashAllocation(transactions) {
+        const newReferencesSet = new Set(transactions.map((transaction) => transaction.reference.toLowerCase()));
+        const newReferences = Array.from(newReferencesSet);
+        const foundCashAllocation = await this.getCashAllocationsByReferences(newReferences);
+        const excludedReferences = foundCashAllocation.map((allocation) => allocation.reference.toLowerCase());
+        const createdReferences = newReferences.filter((r) => !excludedReferences.includes(r));
+        const createdTransactions = createdReferences.reduce((acc, cur) => {
+            const newTransactions = transactions.find((tr) => tr.reference.toLowerCase() === cur);
+            return [...acc, newTransactions];
+        }, []);
+        const order = await this.getNextOrder();
+        await Promise.all(createdTransactions.map(async (transactions) => {
+            if (excludedReferences.includes(transactions.reference.toLowerCase())) {
+                return;
+            }
+            if (!newReferencesSet.has(transactions.reference.toLowerCase())) {
+                return;
+            }
+            const cashAllocation = {
+                order,
+                reference: transactions.reference.trim(),
+                cashAllocationProductId: null,
+            };
+            const newCashAllocationReference = new CashAllocationReference_model_1.CashAllocationReference(cashAllocation);
+            await newCashAllocationReference.save();
+            newReferencesSet.delete(transactions.reference.toLowerCase());
+        }));
+    }
+    async getNextOrder() {
+        const lastOrder = await CashAllocationReference_model_1.CashAllocationReference.findOne().sort({ order: -1 }).select('order').lean();
+        return lastOrder ? lastOrder.order + 1 : 0;
+    }
+    async getCashAllocationsByReferences(references) {
+        return CashAllocationReference_model_1.CashAllocationReference
+            .find({ reference: { $in: references.map(ref => new RegExp(`^${ref}$`, 'i')) } })
+            .lean();
+    }
+    async getAllCashAllocations() {
+        const cashAllocationReferences = await CashAllocationReference_model_1.CashAllocationReference
+            .find()
+            .sort({ order: 1 });
+        const cashAllocationsProducts = await CashAllocationProduct_model_1.CashAllocationProduct
+            .find()
+            .sort({ order: 1 });
+        return {
+            references: cashAllocationReferences.map((i) => (0, main_helper_1.removeFields)(i, main_helper_1.fieldsToUnset)),
+            products: cashAllocationsProducts.map((i) => (0, main_helper_1.removeFields)(i, main_helper_1.fieldsToUnset)),
+        };
+    }
+    async updateAllCashAllocation(products, references) {
+        const existingCashAllocations = await this.getAllCashAllocations();
+        const existingCashAllocationProductIds = existingCashAllocations.products.map((i) => i._id.toString());
+        const cashAllocationProductsToDelete = existingCashAllocationProductIds.filter((id) => !products.some((i) => i._id === id));
+        await CashAllocationProduct_model_1.CashAllocationProduct.deleteMany({ _id: { $in: cashAllocationProductsToDelete } });
+        const newProductsMap = new Map();
+        await Promise.all(products.map(async (product, order) => {
+            const { _id, ...update } = product;
+            if (_id.includes('new_')) {
+                const newCashAllocationProduct = new CashAllocationProduct_model_1.CashAllocationProduct({ ...update, order });
+                const createdCashAllocationProduct = await newCashAllocationProduct.save();
+                newProductsMap.set(_id, createdCashAllocationProduct._id.toString());
+            }
+            else {
+                await CashAllocationProduct_model_1.CashAllocationProduct.findByIdAndUpdate(_id, { ...update, order });
+            }
+        }));
+        const existingCashAllocationReferenceIds = existingCashAllocations.references.map((i) => i._id.toString());
+        const cashAllocationReferencesToDelete = existingCashAllocationReferenceIds.filter((id) => !references.some((i) => i._id === id));
+        await CashAllocationReference_model_1.CashAllocationReference.deleteMany({ _id: { $in: cashAllocationReferencesToDelete } });
+        await Promise.all(references.map(async (reference, order) => {
+            if (reference.cashAllocationProductId.includes('new_')) {
+                reference.cashAllocationProductId = newProductsMap.get(reference.cashAllocationProductId);
+            }
+            const { _id, ...update } = reference;
+            if (_id.includes('new_')) {
+                const newCashAllocationReference = new CashAllocationReference_model_1.CashAllocationReference({ ...update, order });
+                await newCashAllocationReference.save();
+            }
+            else {
+                await CashAllocationReference_model_1.CashAllocationReference.findByIdAndUpdate(_id, { ...update, order });
+            }
+        }));
+    }
+}
+exports.CashAllocationService = CashAllocationService;

package/services/cash-allocation.service.ts

@@ -0,0 +1,105 @@
+import { IUploadedBankTransaction } from '../models/UploadedBankTransaction.model';
+import { fieldsToUnset, removeFields } from '../helpers/main.helper';
+import {
+  CashAllocationReference,
+  ICashAllocationReference,
+  ICashAllocationReferenceStringified,
+} from '../models/CashAllocationReference.model';
+import {
+  CashAllocationProduct,
+  ICashAllocationProduct,
+  ICashAllocationProductStringified,
+} from '../models/CashAllocationProduct.model';
+
+export class CashAllocationService {
+  async createCashAllocation(transactions: IUploadedBankTransaction[]) {
+    const newReferencesSet = new Set(transactions.map((transaction: IUploadedBankTransaction) => transaction.reference.toLowerCase()));
+    const newReferences = Array.from(newReferencesSet);
+    const foundCashAllocation = await this.getCashAllocationsByReferences(newReferences);
+    const excludedReferences = foundCashAllocation.map((allocation) => allocation.reference.toLowerCase());
+    const createdReferences = newReferences.filter((r) => !excludedReferences.includes(r));
+    const createdTransactions = createdReferences.reduce((acc, cur) => {
+      const newTransactions = transactions.find((tr) => tr.reference.toLowerCase() === cur);
+      return [...acc, newTransactions];
+    }, <IUploadedBankTransaction[]>[]);
+    const order = await this.getNextOrder();
+    await Promise.all(createdTransactions.map(async (transactions) => {
+      if (excludedReferences.includes(transactions.reference.toLowerCase())) {
+        return;
+      }
+      if (!newReferencesSet.has(transactions.reference.toLowerCase())) {
+        return;
+      }
+      const cashAllocation: ICashAllocationReference = {
+        order,
+        reference: transactions.reference.trim(),
+        cashAllocationProductId: null,
+      };
+      const newCashAllocationReference = new CashAllocationReference(cashAllocation);
+      await newCashAllocationReference.save();
+      newReferencesSet.delete(transactions.reference.toLowerCase());
+    }));
+  }
+
+  async getNextOrder() {
+    const lastOrder = await CashAllocationReference.findOne().sort({ order: -1 }).select('order').lean();
+    return lastOrder ? lastOrder.order + 1 : 0;
+  }
+
+  async getCashAllocationsByReferences(references: string[]) {
+    return CashAllocationReference
+      .find({ reference: { $in: references.map(ref => new RegExp(`^${ref}$`, 'i')) } })
+      .lean();
+  }
+
+  async getAllCashAllocations() {
+    const cashAllocationReferences = await CashAllocationReference
+      .find()
+      .sort({ order: 1 });
+    const cashAllocationsProducts = await CashAllocationProduct
+      .find()
+      .sort({ order: 1 });
+    return {
+      references: cashAllocationReferences.map((i) => removeFields<ICashAllocationReference>(i, fieldsToUnset)),
+      products: cashAllocationsProducts.map((i) => removeFields<ICashAllocationProduct>(i, fieldsToUnset)),
+    };
+  }
+
+  async updateAllCashAllocation(products: ICashAllocationProductStringified[], references: ICashAllocationReferenceStringified[]) {
+    const existingCashAllocations = await this.getAllCashAllocations();
+
+    const existingCashAllocationProductIds = existingCashAllocations.products.map((i) => i._id.toString());
+    const cashAllocationProductsToDelete = existingCashAllocationProductIds.filter((id) => !products.some((i) => i._id === id));
+    await CashAllocationProduct.deleteMany({ _id: { $in: cashAllocationProductsToDelete } });
+
+    const newProductsMap = new Map();
+
+    await Promise.all(products.map(async (product, order) => {
+      const { _id, ...update } = product;
+      if (_id.includes('new_')) {
+        const newCashAllocationProduct = new CashAllocationProduct({ ...update, order });
+        const createdCashAllocationProduct = await newCashAllocationProduct.save();
+        newProductsMap.set(_id, createdCashAllocationProduct._id.toString());
+      } else {
+        await CashAllocationProduct.findByIdAndUpdate(_id, { ...update, order });
+      }
+    }));
+
+    const existingCashAllocationReferenceIds = existingCashAllocations.references.map((i) => i._id.toString());
+    const cashAllocationReferencesToDelete = existingCashAllocationReferenceIds.filter((id) => !references.some((i) => i._id === id));
+    await CashAllocationReference.deleteMany({ _id: { $in: cashAllocationReferencesToDelete } });
+
+    await Promise.all(references.map(async (reference, order) => {
+      if (reference.cashAllocationProductId.includes('new_')) {
+        reference.cashAllocationProductId = newProductsMap.get(reference.cashAllocationProductId);
+      }
+      const { _id, ...update } = reference;
+      if (_id.includes('new_')) {
+        const newCashAllocationReference = new CashAllocationReference({ ...update, order });
+        await newCashAllocationReference.save();
+      } else {
+        await CashAllocationReference.findByIdAndUpdate(_id, { ...update, order });
+      }
+    }));
+  }
+}

package/services/collateral-adjustments.service.d.ts

@@ -0,0 +1,38 @@
+/// <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 { ICollateralAdjustment, ICollateralAdjustmentItem, ICollateralAdjustmentSummary } from '../models/CollateralAdjustment.model';
+import { SignsService } from './signs.service';
+export declare class CollateralAdjustmentsService {
+    private readonly signsService;
+    constructor(signsService: SignsService);
+    getCollateralAdjustmentSummary(bbcDateId: string): Promise<ICollateralAdjustmentSummary>;
+    getCollateralAdjustment(bbcDateId: string): Promise<ICollateralAdjustment>;
+    saveCollateralAdjustment(bbcDateId: string, collateralAdjustmentsUpdate: Partial<ICollateralAdjustment>): Promise<mongoose.FlattenMaps<ICollateralAdjustment> & {
+        _id: mongoose.Types.ObjectId;
+    }>;
+    getLastCopyCollateralAdjustmentItems(bbcDateId: string): Promise<ICollateralAdjustmentItem[]>;
+    private calculateSummary;
+}

package/services/collateral-adjustments.service.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollateralAdjustmentsService = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const collaterals_enum_1 = require("../enums/collaterals.enum");
+const bbcDates_db_1 = require("../db/bbcDates.db");
+const collateral_adjustments_db_1 = require("../db/collateral-adjustments.db");
+class CollateralAdjustmentsService {
+    signsService;
+    constructor(signsService) {
+        this.signsService = signsService;
+    }
+    async getCollateralAdjustmentSummary(bbcDateId) {
+        const bbcDateIdID = new mongoose_1.default.Types.ObjectId(bbcDateId);
+        const collateralAdjustments = await (0, collateral_adjustments_db_1.getCollateralAdjustmentDocs)([bbcDateIdID]);
+        if (!collateralAdjustments.length) {
+            return {};
+        }
+        return collateralAdjustments[0].summary;
+    }
+    async getCollateralAdjustment(bbcDateId) {
+        const bbcDateIdID = new mongoose_1.default.Types.ObjectId(bbcDateId);
+        const cCollateralAdjustments = await (0, collateral_adjustments_db_1.getCollateralAdjustmentDocs)([bbcDateIdID]);
+        if (!!cCollateralAdjustments.length) {
+            return cCollateralAdjustments.pop();
+        }
+        const lastItems = await this.getLastCopyCollateralAdjustmentItems(bbcDateId);
+        const isBBCLockedResult = await this.signsService.isBBCLocked(bbcDateId);
+        if (isBBCLockedResult) {
+            const summary = this.calculateSummary(lastItems);
+            return await (0, collateral_adjustments_db_1.copyCollateralAdjustmentWithoutSaving)(bbcDateIdID, lastItems, summary);
+        }
+        return this.saveCollateralAdjustment(bbcDateId, { items: lastItems, notes: '' });
+    }
+    async saveCollateralAdjustment(bbcDateId, collateralAdjustmentsUpdate) {
+        const isBBCLockedResult = await this.signsService.isBBCLocked(bbcDateId);
+        if (isBBCLockedResult) {
+            return null;
+        }
+        const summary = this.calculateSummary(collateralAdjustmentsUpdate.items);
+        return await (0, collateral_adjustments_db_1.saveCollateralAdjustmentDoc)(new mongoose_1.default.Types.ObjectId(bbcDateId), {
+            ...collateralAdjustmentsUpdate,
+            summary,
+        });
+    }
+    ;
+    async getLastCopyCollateralAdjustmentItems(bbcDateId) {
+        const { borrowerId } = await (0, bbcDates_db_1.getBBCDateDoc)(bbcDateId.toString());
+        const collateralAdjustmentDocs = await (0, collateral_adjustments_db_1.getLastCollateralAdjustmentDocs)(bbcDateId, borrowerId.toString());
+        if (!!collateralAdjustmentDocs.length) {
+            return collateralAdjustmentDocs.pop().items;
+        }
+        return [];
+    }
+    calculateSummary(collateralAdjustmentItems) {
+        const summary = [];
+        const summaryOrder = [
+            collaterals_enum_1.ECollaterals.INVENTORY,
+            collaterals_enum_1.ECollaterals.RECEIVABLE,
+            collaterals_enum_1.ECollaterals.OTHER,
+        ];
+        const result = Object.keys(collaterals_enum_1.ECollaterals).map((equipmentType) => {
+            const typeSummary = { rowDef: equipmentType, amount: 0 };
+            collateralAdjustmentItems.map((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.CollateralAdjustmentsService = CollateralAdjustmentsService;