@lyxa.ai/core 1.4.312 → 1.4.313-alpha-2

package/dist/types/libraries/cash-settlement/providers/bob.js

@@ -0,0 +1,634 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOBService = exports.BOBTransferStatus = void 0;
+const axios_1 = __importDefault(require("axios"));
+const models_1 = require("../../mongo/models");
+const typedi_1 = require("typedi");
+const https_1 = __importDefault(require("https"));
+const zlib_1 = __importDefault(require("zlib"));
+const enum_1 = require("../../../utilities/enum");
+const __1 = require("../../..");
+const error_common_1 = require("../../../utilities/error-common");
+const currency_1 = require("../../../utilities/shared/currency");
+const dayjs_1 = __importDefault(require("dayjs"));
+const event_1 = require("../../event");
+const events_1 = require("../../event/events");
+var BOBTransferStatus;
+(function (BOBTransferStatus) {
+    BOBTransferStatus["NOT_PAID"] = "NOT PAID";
+    BOBTransferStatus["PAID"] = "PAID";
+})(BOBTransferStatus || (exports.BOBTransferStatus = BOBTransferStatus = {}));
+let BOBService = class BOBService {
+    model;
+    riderModel;
+    financeSettlementModel;
+    BOB_USER_NAME;
+    BOB_PASSWORD;
+    BOB_URL;
+    logger;
+    constructor(secrets) {
+        this.BOB_USER_NAME = secrets.BOB_USER_NAME;
+        this.BOB_PASSWORD = secrets.BOB_PASSWORD;
+        this.BOB_URL = secrets.BOB_URL;
+        this.logger = (0, __1.getLibraries)().getLoggerKit();
+        this.model = models_1.BOBFinanceModel;
+        this.riderModel = models_1.RiderModel;
+        this.financeSettlementModel = models_1.FinanceSettlementModel;
+    }
+    async initiateSettlement(amount, currency, reference, firstName, lastName, riderId, location) {
+        this.logger.info('Initiating BOB settlement', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_INITIATE,
+            data: {
+                amount,
+                currency,
+                reference,
+                firstName,
+                lastName,
+                riderId: riderId.toString(),
+                location,
+            },
+        });
+        if (amount > 20000000) {
+            (0, error_common_1.badRequestError)('Please provide a value between 0 and 20000000');
+        }
+        const crmNumber = reference;
+        const bobData = {
+            ChannelType: enum_1.BobChannelType.CO,
+            Credentials: {
+                User: this.BOB_USER_NAME,
+                Password: this.BOB_PASSWORD,
+            },
+            Model: enum_1.BobModel.C2B,
+            FirstName: firstName,
+            LastName: lastName,
+            CRMNumber: crmNumber,
+            Amount: String(amount),
+            Currency: currency,
+        };
+        let data;
+        try {
+            ({ data } = await axios_1.default.post(`${this.BOB_URL}InsertTransferData`, bobData, {
+                httpsAgent: new https_1.default.Agent({ rejectUnauthorized: false }),
+            }));
+        }
+        catch (error) {
+            const axiosError = error;
+            const bobResponse = axiosError?.response?.data;
+            this.logger.error('Error posting to BOB API:', error, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_INITIATE,
+                data: {
+                    crmNumber,
+                    requestId: bobResponse?.RequestId,
+                    errorCode: bobResponse?.ErrorCode,
+                    errorDescription: bobResponse?.ErrorDescription,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to post data to BOB API.');
+        }
+        if (data.ErrorCode != 100) {
+            this.logger.error('Error in BOB initiateSettlement:', data, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_INITIATE,
+                data: {
+                    crmNumber,
+                    requestId: data.RequestId,
+                    errorCode: data.ErrorCode,
+                    errorDescription: data.ErrorDescription,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to post data to BOB API.');
+        }
+        const responseObject = await this.decompressResponse(data.Response);
+        if (!responseObject || !responseObject.isSuccess) {
+            this.logger.error('Failed to initiate settlement in BOB', responseObject, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_INITIATE,
+                data: {
+                    responseObject,
+                    crmNumber,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to initiate settlement in BOB.');
+        }
+        const bobSettlement = await this.model.create({
+            amount: currency === 'USD' ? amount : 0,
+            secondaryAmount: currency === 'USD' ? 0 : amount,
+            crmNumber: crmNumber,
+            rider: riderId,
+            bobLocation: location,
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+            settlementType: enum_1.BobSettlementType.SETTLE_CASH,
+            bobModel: enum_1.BobModel.C2B,
+            bobType: enum_1.BobType.INWARD,
+        });
+        this.logger.info('Created BOB settlement in database', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_INITIATE,
+            data: {
+                bobSettlementId: bobSettlement._id.toString(),
+                crmNumber,
+            },
+        });
+        return true;
+    }
+    async markSettlementAsPaid(settlementId) {
+        this.logger.info('Marking BOB settlement as paid', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+            data: {
+                settlementId: settlementId.toString(),
+            },
+        });
+        const settlement = await this.model.findById(settlementId);
+        if (!settlement) {
+            this.logger.error('Settlement not found', undefined, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+                data: {
+                    settlementId: settlementId.toString(),
+                },
+            });
+            throw (0, error_common_1.notFoundError)('Settlement not found.');
+        }
+        if (settlement.status === enum_1.BobSettlementStatus.PAID) {
+            this.logger.error('Settlement is already marked as paid', undefined, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+                data: {
+                    settlementId: settlementId.toString(),
+                },
+            });
+            throw (0, error_common_1.badRequestError)('Settlement is already marked as paid.');
+        }
+        await this.settlePayment(settlement);
+        if (settlement.status === enum_1.BobSettlementStatus.NOT_PAID) {
+            await this.removeTransfer(settlement.crmNumber);
+        }
+        this.logger.info('BOB settlement marked as paid', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+            data: {
+                settlementId: settlementId.toString(),
+            },
+        });
+        return true;
+    }
+    async settlePayment(settlement) {
+        this.logger.info('Settling BOB payment', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+            data: {
+                settlementId: settlement._id.toString(),
+                crmNumber: settlement.crmNumber,
+            },
+        });
+        const updatedSettlement = await this.model.findByIdAndUpdate(settlement._id, { status: enum_1.BobSettlementStatus.PAID }, { new: true, runValidators: true });
+        const financeSettlement = await this.financeSettlementModel.create({
+            amount: settlement.amount,
+            secondaryAmount: settlement.secondaryAmount,
+            rider: settlement.rider,
+            settlementType: enum_1.SettlementType.RIDER_SETTLE_CASH,
+            accountType: enum_1.AccountType.RIDER,
+        });
+        const rider = await this.riderModel.findById(settlement.rider);
+        if (!rider) {
+            this.logger.error(`Rider with ID ${settlement.rider} not found.`, undefined, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+                data: {
+                    settlementId: settlement._id.toString(),
+                },
+            });
+            throw (0, error_common_1.notFoundError)('Rider not found.');
+        }
+        const settings = (await (0, __1.getLibraries)().getCachedSettingsService().getSettings());
+        const exchangeRate = settings?.currencySetting?.exchangeRate || 1;
+        const totalSettlement = settlement.amount || 0;
+        const totalSecondarySettlement = settlement.secondaryAmount || 0;
+        const { deltaPrimary, deltaSecondary } = this.calculateAmountsToDeduct({
+            exchangeRate,
+            totalSettlement,
+            totalSecondarySettlement,
+            cashInHandAmount: rider.cashInHand?.amount ?? 0,
+            cashInHandSecondaryAmount: rider.cashInHand?.secondaryAmount ?? 0,
+        });
+        const bobCashSettlementLimit = settings?.riderSetting?.bobCashSettlementLimit || Infinity;
+        const limitForRider = rider.useIndividualCashSettlementLimit && rider.cashSettlementLimit
+            ? rider.cashSettlementLimit
+            : bobCashSettlementLimit;
+        const totalCashInHand = (rider.cashInHand?.amount || 0) +
+            deltaPrimary +
+            (0, currency_1.roundBaseCurrency)(((rider.cashInHand?.secondaryAmount || 0) + deltaSecondary) / exchangeRate);
+        const isLimitReached = totalCashInHand >= limitForRider;
+        const unsetUpdate = !isLimitReached ? { cashLimitReason: 1, isCashSettlementLimitReached: 1 } : {};
+        const updatedRider = await this.riderModel.findByIdAndUpdate(rider._id, {
+            $inc: {
+                'cashInHand.secondaryAmount': deltaSecondary,
+                'cashInHand.amount': deltaPrimary,
+            },
+            $unset: unsetUpdate,
+        }, { new: true, runValidators: true });
+        this.logger.info('Settled BOB payment and updated rider cash in hand', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_SETTLE,
+            data: {
+                settlementId: settlement._id.toString(),
+                crmNumber: settlement.crmNumber,
+                deltaSecondary,
+                deltaPrimary,
+                riderId: rider._id.toString(),
+                previousRiderCashInHand: rider.cashInHand,
+                updatedRiderCashInHand: updatedRider?.cashInHand,
+                financeSettlementId: financeSettlement._id.toString(),
+            },
+        });
+        (0, event_1.publishEvent)(new events_1.RiderCashSettledEvent(rider._id));
+    }
+    calculateAmountsToDeduct(data) {
+        let primaryToDeduct = data.totalSettlement;
+        let secondaryToDeduct = 0;
+        let availablePrimary = data.cashInHandAmount;
+        let availableSecondary = data.cashInHandSecondaryAmount;
+        let deductedPrimary = Math.min(availablePrimary, primaryToDeduct);
+        primaryToDeduct -= deductedPrimary;
+        availablePrimary -= deductedPrimary;
+        if (primaryToDeduct > 0) {
+            const neededSecondary = (0, currency_1.roundSecondaryCurrency)(primaryToDeduct * data.exchangeRate);
+            const deductedSecondary = Math.min(availableSecondary, neededSecondary);
+            secondaryToDeduct += deductedSecondary;
+            availableSecondary -= deductedSecondary;
+            primaryToDeduct = 0;
+        }
+        let deductedSecondaryDirect = Math.min(availableSecondary, data.totalSecondarySettlement);
+        secondaryToDeduct += deductedSecondaryDirect;
+        availableSecondary -= deductedSecondaryDirect;
+        const remainingSecondary = data.totalSecondarySettlement - deductedSecondaryDirect;
+        if (remainingSecondary > 0) {
+            const neededPrimary = (0, currency_1.roundBaseCurrency)(remainingSecondary / data.exchangeRate);
+            const deductedPrimaryFallback = Math.min(availablePrimary, neededPrimary);
+            deductedPrimary += deductedPrimaryFallback;
+            availablePrimary -= deductedPrimaryFallback;
+        }
+        const deltaPrimary = -deductedPrimary;
+        const deltaSecondary = -secondaryToDeduct;
+        return { deltaPrimary, deltaSecondary };
+    }
+    async revokeSettlement(reference) {
+        this.logger.info('Revoking BOB settlement', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_REVOKE,
+            data: {
+                reference,
+            },
+        });
+        const settlement = await this.model.findOne({
+            crmNumber: reference,
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+        });
+        if (!settlement) {
+            this.logger.error('Settlement with reference not found', undefined, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_REVOKE,
+                data: {
+                    reference,
+                },
+            });
+            throw (0, error_common_1.notFoundError)('Settlement not found.');
+        }
+        await this.removeTransfer(reference);
+        const result = await this.model.findOneAndUpdate({
+            crmNumber: reference,
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+        }, {
+            status: enum_1.BobSettlementStatus.REVOKED,
+        }, { new: true, runValidators: true });
+        this.logger.info('BOB settlement revoked', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_REVOKE,
+            data: {
+                reference,
+                settlementId: settlement._id.toString(),
+                result,
+            },
+        });
+        return true;
+    }
+    async revokeRiderSettlements(rider) {
+        this.logger.info('Revoking BOB settlements for rider', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_REVOKE,
+            data: {
+                riderId: rider.toString(),
+            },
+        });
+        const settlements = await this.model.find({
+            rider: rider,
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+        });
+        if (!settlements.length) {
+            this.logger.info('No unpaid BOB settlements found for rider', {
+                tag: enum_1.LogTag.BOB_TRANSACTION_REVOKE,
+                data: {
+                    riderId: rider.toString(),
+                },
+            });
+            (0, error_common_1.notFoundError)('No unpaid settlements found.');
+        }
+        for (const settlement of settlements) {
+            await this.removeTransfer(settlement.crmNumber);
+            await this.model.findByIdAndUpdate(settlement._id, {
+                status: enum_1.BobSettlementStatus.REVOKED,
+            });
+        }
+        this.logger.info('BOB settlements revoked for rider', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_REVOKE,
+            data: {
+                riderId: rider.toString(),
+                settlementIds: settlements.map(s => s._id.toString()),
+            },
+        });
+        return true;
+    }
+    async removeTransfer(crmNumber) {
+        this.logger.info('Removing transfer from BOB', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_REMOVE,
+            data: {
+                crmNumber,
+            },
+        });
+        const transferExists = await this.hasUnpaidTransfer(crmNumber);
+        if (!transferExists) {
+            this.logger.error('No transfer exists for this crm number in bob', undefined, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                data: {
+                    crmNumber,
+                },
+            });
+            return;
+        }
+        const bobData = {
+            ChannelType: enum_1.BobChannelType.CO,
+            Credentials: {
+                User: this.BOB_USER_NAME,
+                Password: this.BOB_PASSWORD,
+            },
+            Model: enum_1.BobModel.C2B,
+            CRMNumber: crmNumber,
+        };
+        const { data } = await axios_1.default.post(`${this.BOB_URL}RemoveTransfer`, bobData, {
+            httpsAgent: new https_1.default.Agent({ rejectUnauthorized: false }),
+        });
+        if (data.ErrorCode == 213) {
+            return;
+        }
+        if (data.ErrorCode != 100) {
+            this.logger.error('Error in BOB removeTransfer', data, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_REMOVE,
+                data: {
+                    crmNumber,
+                    requestId: data.RequestId,
+                    errorCode: data.ErrorCode,
+                    errorDescription: data.ErrorDescription,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to post data to BOB API.');
+        }
+        const responseObject = await this.decompressResponse(data.Response);
+        if (!responseObject || !responseObject.isSuccess) {
+            this.logger.error('Failed to remove transfer in BOB', responseObject, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_REMOVE,
+                data: {
+                    crmNumber,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to remove transfer in BOB.');
+        }
+        this.logger.info('Removed transfer from BOB', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_REMOVE,
+            data: {
+                crmNumber,
+                responseObject,
+            },
+        });
+    }
+    async hasPendingSettlements(reference) {
+        const pendingSettlements = await this.model.find({
+            crmNumber: reference,
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+        });
+        return pendingSettlements.length > 0;
+    }
+    async hasPendingRiderSettlements(riderId) {
+        const pendingSettlements = await this.model.find({
+            rider: riderId,
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+            settlementType: enum_1.BobSettlementType.SETTLE_CASH,
+        });
+        return pendingSettlements.length > 0;
+    }
+    async getLastSettlement(reference) {
+        const pendingSettlements = await this.model
+            .findOne({
+            crmNumber: reference,
+        })
+            .sort({ createdAt: -1 });
+        if (!pendingSettlements)
+            return null;
+        return {
+            amount: pendingSettlements.amount || pendingSettlements.secondaryAmount || 0,
+            currency: pendingSettlements.amount ? 'USD' : 'LBP',
+            referenceNumber: pendingSettlements.crmNumber,
+            status: (pendingSettlements.status ?? enum_1.BobSettlementStatus.NOT_PAID),
+            createdAt: pendingSettlements.createdAt ?? new Date(),
+            updatedAt: pendingSettlements.createdAt ?? new Date(),
+        };
+    }
+    async getLastRiderSettlement(rider) {
+        const lastSettlement = await this.model
+            .findOne({
+            rider: rider,
+            settlementType: enum_1.BobSettlementType.SETTLE_CASH,
+        })
+            .sort({ createdAt: -1 });
+        if (!lastSettlement)
+            return null;
+        return {
+            amount: lastSettlement.amount || lastSettlement.secondaryAmount || 0,
+            currency: lastSettlement.amount ? 'USD' : 'LBP',
+            referenceNumber: lastSettlement.crmNumber,
+            status: (lastSettlement.status ?? enum_1.BobSettlementStatus.NOT_PAID),
+            createdAt: lastSettlement.createdAt ?? new Date(),
+            updatedAt: lastSettlement.updatedAt ?? new Date(),
+        };
+    }
+    async getTransfers(timeframe, model = enum_1.BobModel.C2B) {
+        const DateTimeFrom = new Date(timeframe.startDate).toISOString().split('.')[0];
+        const DateTimeTo = new Date(timeframe.endDate).toISOString().split('.')[0];
+        const bobData = {
+            ChannelType: enum_1.BobChannelType.CO,
+            Credentials: {
+                User: this.BOB_USER_NAME,
+                Password: this.BOB_PASSWORD,
+            },
+            Model: model,
+            DateTimeFrom,
+            DateTimeTo,
+        };
+        const { data } = await axios_1.default.post(`${this.BOB_URL}GetTransfers`, bobData, {
+            httpsAgent: new https_1.default.Agent({ rejectUnauthorized: false }),
+        });
+        if (data.ErrorCode != 100) {
+            this.logger.error('Error in BOB getTransfers', data, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                data: {
+                    timeframe,
+                    requestId: data.RequestId,
+                    errorCode: data.ErrorCode,
+                    errorDescription: data.ErrorDescription,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to post data to BOB API.');
+        }
+        const responseObject = await this.decompressResponse(data.Response);
+        if (!responseObject) {
+            this.logger.error('Failed to get transfers in BOB', data, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                data: {
+                    timeframe,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to get transfers in BOB.');
+        }
+        return responseObject;
+    }
+    async decompressResponse(response) {
+        return new Promise((resolve, reject) => {
+            const decodedBuffer = Buffer.from(response, 'base64');
+            zlib_1.default.gunzip(decodedBuffer, (err, decompressedBuffer) => {
+                if (err) {
+                    this.logger.error('Error decompressing GZIP', err, {
+                        tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                        data: {
+                            responseLength: response?.length,
+                        },
+                    });
+                    try {
+                        reject((0, error_common_1.internalServerError)('Failed to decompress data from BOB API.'));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }
+                else {
+                    const decodedString = decompressedBuffer.toString('utf-8');
+                    const responseObject = JSON.parse(decodedString);
+                    resolve(responseObject);
+                }
+            });
+        });
+    }
+    async hasUnpaidTransfer(crmNumber) {
+        const bobData = {
+            ChannelType: enum_1.BobChannelType.CO,
+            Credentials: {
+                User: this.BOB_USER_NAME,
+                Password: this.BOB_PASSWORD,
+            },
+            Model: enum_1.BobModel.C2B,
+            CRMNumber: crmNumber,
+        };
+        const { data } = await axios_1.default.post(`${this.BOB_URL}GetTransferStatus`, bobData, {
+            httpsAgent: new https_1.default.Agent({ rejectUnauthorized: false }),
+        });
+        if (data.ErrorCode == 213) {
+            return false;
+        }
+        if (data.ErrorCode != 100) {
+            this.logger.error('Error in BOB getTransferStatus', data, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                data: {
+                    crmNumber,
+                    requestId: data.RequestId,
+                    errorCode: data.ErrorCode,
+                    errorDescription: data.ErrorDescription,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to post data to BOB API.');
+        }
+        const responseObject = await this.decompressResponse(data.Response);
+        if (!responseObject) {
+            this.logger.error('Failed to get settlement status in BOB', data, {
+                tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                data: {
+                    crmNumber,
+                },
+            });
+            throw (0, error_common_1.internalServerError)('Failed to get settlement status in BOB.');
+        }
+        const hasUnpaidTransfer = responseObject.some((item) => item.CRMNumber == crmNumber && item.Status == BOBTransferStatus.NOT_PAID);
+        return hasUnpaidTransfer;
+    }
+    async checkAllPendingTransfers() {
+        const notPaidSettlements = await this.model.find({
+            status: enum_1.BobSettlementStatus.NOT_PAID,
+        });
+        if (!notPaidSettlements.length) {
+            return;
+        }
+        this.logger.info('Checking pending settlements', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+            data: {
+                count: notPaidSettlements.length,
+                settlementIds: notPaidSettlements.map(s => s._id.toString()),
+            },
+        });
+        let maxDate = (0, dayjs_1.default)();
+        let minDate = (0, dayjs_1.default)();
+        const createdAtDates = notPaidSettlements.map(item => (0, dayjs_1.default)(item.createdAt));
+        if (createdAtDates.length > 0) {
+            maxDate = dayjs_1.default.max(...createdAtDates);
+            minDate = dayjs_1.default.min(...createdAtDates);
+        }
+        const maxDatePlusOneDay = maxDate.add(1, 'day').toDate();
+        const minDateMinusOneDay = minDate.subtract(1, 'day').toDate();
+        const transfers = await this.getTransfers({
+            startDate: minDateMinusOneDay,
+            endDate: maxDatePlusOneDay,
+        });
+        this.logger.info('Transactions on BOB', {
+            tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+            data: {
+                count: transfers.length,
+                transfers: transfers.map(t => ({ ReferenceNumber: t.ReferenceNumber, Status: t.Status })),
+                startDate: minDateMinusOneDay,
+                endDate: maxDatePlusOneDay,
+            },
+        });
+        if (!transfers || transfers.length === 0) {
+            return;
+        }
+        const transferStatusMap = new Map();
+        for (const trx of transfers) {
+            transferStatusMap.set(trx.ReferenceNumber, trx.Status);
+        }
+        await Promise.all(notPaidSettlements.map(async (settlement) => {
+            try {
+                const status = transferStatusMap.get(settlement.crmNumber);
+                if (status == BOBTransferStatus.PAID) {
+                    await this.settlePayment(settlement);
+                }
+                this.logger.info(`Settled payment for crmNumber ${settlement.crmNumber}`, {
+                    tag: enum_1.LogTag.BOB_TRANSACTION_CHECK,
+                    data: { status },
+                });
+            }
+            catch (err) {
+                this.logger.error(`Failed settlement with crmNumber ${settlement.crmNumber}, id: ${settlement._id}`, err, { tag: enum_1.LogTag.BOB_TRANSACTION_CHECK });
+            }
+        }));
+    }
+};
+exports.BOBService = BOBService;
+exports.BOBService = BOBService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [Object])
+], BOBService);
+//# sourceMappingURL=bob.js.map