gemcap-be-common 1.2.140 → 1.3.0

package/db/payable-accounts.d.ts

@@ -0,0 +1,30 @@
+/// <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 { IAccountPayableItemDoc } from '../models/AccountPayableItem.model';
+export declare const getAllAPCustomers: (borrowerId: string) => Promise<{
+    customers: string[];
+}[]>;
+export declare const getBBCAPByAPPeriod: (bbcSheetsIds: mongoose.Types.ObjectId[], rangeStart: any, rangeEnd: any) => Promise<IAccountPayableItemDoc[]>;

package/db/payable-accounts.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBBCAPByAPPeriod = exports.getAllAPCustomers = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const AccountPayableItem_model_1 = require("../models/AccountPayableItem.model");
+const collaterals_db_1 = require("./collaterals.db");
+const collaterals_enum_1 = require("../enums/collaterals.enum");
+const getAllAPCustomers = async (borrowerId) => {
+    const bbcSheets = await (0, collaterals_db_1.getBBCSheetsForBorrowerAndType)(borrowerId, collaterals_enum_1.ECollaterals.ACCOUNT_PAYABLE);
+    return AccountPayableItem_model_1.AccountPayableItemModel.aggregate([
+        {
+            $match: {
+                'bbcSheetId': {
+                    $in: bbcSheets.map((bbcSheet) => new mongoose_1.default.Types.ObjectId(String(bbcSheet._id)))
+                }
+            }
+        },
+        {
+            $group: {
+                '_id': null,
+                'customers': {
+                    $addToSet: '$customerName'
+                }
+            }
+        },
+        {
+            $project: {
+                '_id': 0
+            }
+        },
+    ]);
+};
+exports.getAllAPCustomers = getAllAPCustomers;
+const getBBCAPByAPPeriod = async (bbcSheetsIds, rangeStart, rangeEnd) => {
+    return AccountPayableItem_model_1.AccountPayableItemModel.aggregate([
+        {
+            $match: {
+                $and: [
+                    { 'bbcSheetId': { $in: bbcSheetsIds } },
+                    { 'apDate': { $gte: new Date(rangeStart) } },
+                    { 'apDate': { $lte: new Date(rangeEnd) } },
+                ]
+            }
+        },
+        {
+            $sort: {
+                'apDate': 1
+            }
+        },
+    ]);
+};
+exports.getBBCAPByAPPeriod = getBBCAPByAPPeriod;

package/db/payable-accounts.ts

@@ -0,0 +1,50 @@
+import mongoose from 'mongoose';
+
+import { AccountPayableItemModel, IAccountPayableItemDoc } from '../models/AccountPayableItem.model';
+import { getBBCSheetsForBorrowerAndType } from './collaterals.db';
+import { ECollaterals } from '../enums/collaterals.enum';
+
+export const getAllAPCustomers = async (borrowerId: string) => {
+  const bbcSheets = await getBBCSheetsForBorrowerAndType(borrowerId, ECollaterals.ACCOUNT_PAYABLE);
+  return AccountPayableItemModel.aggregate<{ customers: string[] }>([
+    {
+      $match: {
+        'bbcSheetId': {
+          $in: bbcSheets.map((bbcSheet) => new mongoose.Types.ObjectId(String(bbcSheet._id)))
+        }
+      }
+    },
+    {
+      $group: {
+        '_id': null,
+        'customers': {
+          $addToSet: '$customerName'
+        }
+      }
+    },
+    {
+      $project: {
+        '_id': 0
+      }
+    },
+  ]);
+};
+
+export const getBBCAPByAPPeriod = async (bbcSheetsIds: mongoose.Types.ObjectId[], rangeStart, rangeEnd) => {
+  return AccountPayableItemModel.aggregate<IAccountPayableItemDoc>([
+    {
+      $match: {
+        $and: [
+          { 'bbcSheetId': { $in: bbcSheetsIds } },
+          { 'apDate': { $gte: new Date(rangeStart) } },
+          { 'apDate': { $lte: new Date(rangeEnd) } },
+        ]
+      }
+    },
+    {
+      $sort: {
+        'apDate': 1
+      }
+    },
+  ]);
+}

package/db/reserve.db.d.ts

@@ -0,0 +1,34 @@
+/// <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, IReserveDoc, IReserveItem, IReserveSummary } from '../models/Reserve.model';
+export declare const getReserveDocs: (bbcDateIds: mongoose.Types.ObjectId[]) => Promise<IReserveDoc[]>;
+export declare const saveReserveDoc: (bbcDateId: mongoose.Types.ObjectId, reserveUpdate: Partial<IReserve>) => Promise<mongoose.FlattenMaps<IReserveDoc> & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const copyReserveWithoutSaving: (bbcDateId: mongoose.Types.ObjectId, items: IReserveItem[], summary: IReserveSummary) => Promise<mongoose.Document<unknown, {}, IReserveDoc> & IReserveDoc & {
+    _id: mongoose.Types.ObjectId;
+}>;
+export declare const getLastReserveDocs: (bbcDateId: string, borrowerId: string) => Promise<IReserveDoc[]>;

package/db/reserve.db.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLastReserveDocs = exports.copyReserveWithoutSaving = exports.saveReserveDoc = exports.getReserveDocs = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const Reserve_model_1 = __importDefault(require("../models/Reserve.model"));
+const bbcDates_db_1 = require("./bbcDates.db");
+const getReserveDocs = async (bbcDateIds) => {
+    return Reserve_model_1.default.aggregate([
+        {
+            $match: {
+                'bbcDateId': {
+                    $in: bbcDateIds
+                }
+            }
+        },
+    ]);
+};
+exports.getReserveDocs = getReserveDocs;
+const saveReserveDoc = async (bbcDateId, reserveUpdate) => {
+    return Reserve_model_1.default
+        .findOneAndUpdate({ bbcDateId }, reserveUpdate, { upsert: true, new: true })
+        .lean();
+};
+exports.saveReserveDoc = saveReserveDoc;
+const copyReserveWithoutSaving = async (bbcDateId, items, summary) => {
+    return new Reserve_model_1.default({ bbcDateId, items, summary });
+};
+exports.copyReserveWithoutSaving = copyReserveWithoutSaving;
+const getLastReserveDocs = async (bbcDateId, borrowerId) => {
+    const bbcDates = await (0, bbcDates_db_1.getBBCDatesByBorrower)(borrowerId);
+    const bbcDateIds = bbcDates.map((bbc) => bbc._id);
+    return Reserve_model_1.default.aggregate([
+        {
+            $match: {
+                $and: [
+                    { 'bbcDateId': { $in: bbcDateIds } },
+                    { 'bbcDateId': { $ne: new mongoose_1.default.Types.ObjectId(bbcDateId) } },
+                ],
+            },
+        },
+        {
+            $sort: { 'updatedAt': -1 }
+        },
+        {
+            $limit: 1
+        }
+    ]);
+};
+exports.getLastReserveDocs = getLastReserveDocs;

package/db/reserve.db.ts

@@ -0,0 +1,48 @@
+import mongoose from 'mongoose';
+
+import Reserve, { IReserve, IReserveDoc, IReserveItem, IReserveSummary } from '../models/Reserve.model';
+import { getBBCDatesByBorrower } from './bbcDates.db';
+
+export const getReserveDocs = async (bbcDateIds: mongoose.Types.ObjectId[]) => {
+  return Reserve.aggregate<IReserveDoc>([
+    {
+      $match: {
+        'bbcDateId': {
+          $in: bbcDateIds
+        }
+      }
+    },
+  ]);
+};
+
+export const saveReserveDoc = async (bbcDateId: mongoose.Types.ObjectId, reserveUpdate: Partial<IReserve>) => {
+  return Reserve
+    .findOneAndUpdate({ bbcDateId }, reserveUpdate, { upsert: true, new: true })
+    .lean();
+};
+
+export const copyReserveWithoutSaving = async (bbcDateId: mongoose.Types.ObjectId, items: IReserveItem[], summary: IReserveSummary) => {
+  return new Reserve({ bbcDateId, items, summary });
+}
+
+export const getLastReserveDocs = async (bbcDateId: string, borrowerId: string) => {
+  const bbcDates = await getBBCDatesByBorrower(borrowerId);
+  const bbcDateIds = bbcDates.map((bbc) => bbc._id);
+  return Reserve.aggregate<IReserveDoc>([
+    {
+      $match:
+        {
+          $and: [
+            { 'bbcDateId': { $in: bbcDateIds } },
+            { 'bbcDateId': { $ne: new mongoose.Types.ObjectId(bbcDateId) } },
+          ],
+        },
+    },
+    {
+      $sort: { 'updatedAt': -1 }
+    },
+    {
+      $limit: 1
+    }
+  ]);
+};

package/db/uploads.db.d.ts

@@ -0,0 +1,2 @@
+import { IUploadedSheetDocWithFile } from '../models/UploadedSheet.model';
+export declare const getSheetWithFile: (sheetId: any) => Promise<IUploadedSheetDocWithFile[]>;

package/db/uploads.db.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSheetWithFile = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const UploadedSheet_model_1 = __importDefault(require("../models/UploadedSheet.model"));
+const getSheetWithFile = async (sheetId) => {
+    return UploadedSheet_model_1.default.aggregate([
+        {
+            $match: {
+                '_id': new mongoose_1.default.Types.ObjectId(sheetId)
+            }
+        }, {
+            $lookup: {
+                from: 'uploadedfiles',
+                localField: 'fileId',
+                foreignField: '_id',
+                as: 'file'
+            }
+        }, {
+            $unwind: {
+                path: '$file'
+            }
+        }
+    ]);
+};
+exports.getSheetWithFile = getSheetWithFile;

package/db/uploads.db.ts

@@ -0,0 +1,24 @@
+import mongoose from 'mongoose';
+
+import UploadedSheetModel, { IUploadedSheetDocWithFile } from '../models/UploadedSheet.model';
+
+export const getSheetWithFile = async (sheetId) => {
+  return UploadedSheetModel.aggregate<IUploadedSheetDocWithFile>([
+    {
+      $match: {
+        '_id': new mongoose.Types.ObjectId(sheetId)
+      }
+    }, {
+      $lookup: {
+        from: 'uploadedfiles',
+        localField: 'fileId',
+        foreignField: '_id',
+        as: 'file'
+      }
+    }, {
+      $unwind: {
+        path: '$file'
+      }
+    }
+  ]);
+}

package/helpers/main.helper.d.ts

@@ -0,0 +1,31 @@
+/// <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 Joi from 'joi';
+export type TDictionary = Record<string, string | object>;
+export declare const fieldsToUnset: string[];
+export declare const removeFields: <T>(document: mongoose.Document, fieldsToUnset: string[]) => T;
+export declare const replaceErrors: (error: Joi.ValidationError, dictionary: TDictionary) => string;
+export declare const getUUID: () => string;

package/helpers/main.helper.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUUID = exports.replaceErrors = exports.removeFields = exports.fieldsToUnset = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const uuid_1 = require("uuid");
+exports.fieldsToUnset = ['__v', 'createdAt', 'updatedAt'];
+const deepCloneAndConvertMaps = (obj) => {
+    if (obj instanceof Map) {
+        return Object.fromEntries(obj);
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepCloneAndConvertMaps(item));
+    }
+    if (Buffer.isBuffer(obj) || ArrayBuffer.isView(obj)) {
+        return obj;
+    }
+    if (mongoose_1.default.isValidObjectId(obj)) {
+        return obj.toString();
+    }
+    if (typeof obj === 'object' && obj !== null) {
+        const newObj = Object.assign({}, obj);
+        Object.keys(newObj).forEach((key) => {
+            newObj[key] = deepCloneAndConvertMaps(newObj[key]);
+        });
+        return newObj;
+    }
+    return obj;
+};
+const removeFields = (document, fieldsToUnset) => {
+    return document.toObject({
+        transform: (_doc, ret) => {
+            fieldsToUnset.forEach((field) => delete ret[field]);
+            return deepCloneAndConvertMaps(ret);
+        },
+    });
+};
+exports.removeFields = removeFields;
+const replaceErrors = (error, dictionary) => {
+    const getValue = (d, keys) => {
+        let currentValue = d;
+        for (const part of keys) {
+            if (currentValue && currentValue[part]) {
+                currentValue = currentValue[part];
+            }
+            else {
+                return part;
+            }
+        }
+        return currentValue;
+    };
+    const refinedErrors = error.details.map((detail) => {
+        const pathFull = detail.path.join('.');
+        const value = getValue(dictionary, detail.path);
+        return detail.message.replace(pathFull, value);
+    });
+    return refinedErrors.join(', ');
+};
+exports.replaceErrors = replaceErrors;
+const getUUID = () => (0, uuid_1.v4)();
+exports.getUUID = getUUID;

package/helpers/main.helper.ts

@@ -0,0 +1,63 @@
+import mongoose from 'mongoose';
+import Joi from 'joi';
+import { v4 as uuidV4 } from 'uuid';
+
+export type TDictionary = Record<string, string | object>;
+
+export const fieldsToUnset = ['__v', 'createdAt', 'updatedAt'];
+
+const deepCloneAndConvertMaps = <T>(obj: T): T => {
+  if (obj instanceof Map) {
+    return Object.fromEntries(obj) as T;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepCloneAndConvertMaps(item)) as T;
+  }
+  if (Buffer.isBuffer(obj) || ArrayBuffer.isView(obj)) {
+    return obj;
+  }
+  if (mongoose.isValidObjectId(obj)) {
+    return obj.toString() as T;
+  }
+  if (typeof obj === 'object' && obj !== null) {
+    const newObj = Object.assign({}, obj);
+    Object.keys(newObj).forEach((key) => {
+      newObj[key] = deepCloneAndConvertMaps(newObj[key]);
+    });
+    return newObj as T;
+  }
+  return obj;
+};
+
+export const removeFields = <T>(document: mongoose.Document, fieldsToUnset: string[]): T => {
+  return document.toObject({
+    transform: (_doc, ret) => {
+      fieldsToUnset.forEach((field) => delete ret[field]);
+      return deepCloneAndConvertMaps(ret) as Omit<T, keyof T>;
+    },
+  });
+};
+
+export const replaceErrors = (error: Joi.ValidationError, dictionary: TDictionary) => {
+  const getValue = (d: TDictionary, keys: string[]): string => {
+    let currentValue: TDictionary | string = d;
+
+    for (const part of keys) {
+      if (currentValue && currentValue[part]) {
+        currentValue = currentValue[part];
+      } else {
+        return part;
+      }
+    }
+    return currentValue as string;
+  }
+
+  const refinedErrors = error.details.map((detail) => {
+    const pathFull = detail.path.join('.');
+    const value = getValue(dictionary, detail.path as string[]);
+    return detail.message.replace(pathFull, value);
+  });
+  return refinedErrors.join(', ');
+};
+
+export const getUUID = () => uuidV4();

package/models/AccountPayableItem.model.d.ts

@@ -43,10 +43,10 @@ export declare const AccountPayableItemSchema: mongoose.Schema<any, mongoose.Mod
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
-    bbcSheetId: mongoose.Types.ObjectId;
     order: number;
-    apDate: Date;
     amount: number;
+    bbcSheetId: mongoose.Types.ObjectId;
+    apDate: Date;
     __v?: number;
     poNumber?: string;
     customerName?: string;
@@ -57,10 +57,10 @@ export declare const AccountPayableItemSchema: mongoose.Schema<any, mongoose.Mod
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
-    bbcSheetId: mongoose.Types.ObjectId;
     order: number;
-    apDate: Date;
     amount: number;
+    bbcSheetId: mongoose.Types.ObjectId;
+    apDate: Date;
     __v?: number;
     poNumber?: string;
     customerName?: string;
@@ -71,10 +71,10 @@ export declare const AccountPayableItemSchema: mongoose.Schema<any, mongoose.Mod
     createdAt: NativeDate;
     updatedAt: NativeDate;
 } & {
-    bbcSheetId: mongoose.Types.ObjectId;
     order: number;
-    apDate: Date;
     amount: number;
+    bbcSheetId: mongoose.Types.ObjectId;
+    apDate: Date;
     __v?: number;
     poNumber?: string;
     customerName?: string;

package/models/AllocatedBankTransaction.model.d.ts

@@ -0,0 +1,54 @@
+/// <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, { Model } from 'mongoose';
+import { IUploadedBankTransactionWithInfo } from './UploadedBankTransaction.model';
+export interface IAllocatedBankTransaction {
+    _id?: mongoose.Types.ObjectId;
+    order: number;
+    uploadedBankTransactionId: mongoose.Types.ObjectId;
+    date: Date;
+    accountNumber: string;
+    amount: number;
+    reference: string;
+    cashAllocationProductId: mongoose.Types.ObjectId;
+    accounts: {
+        [companyId: string]: {
+            accountId1: mongoose.Types.ObjectId | 'BANK';
+            accountId2: mongoose.Types.ObjectId | 'BANK';
+        };
+    };
+    class: string;
+    location: string;
+    cashAllocationReferenceId: mongoose.Types.ObjectId;
+    splitTransactionId: mongoose.Types.ObjectId;
+    memo: string;
+}
+type AllocatedBankTransactionModel = Model<IAllocatedBankTransaction>;
+export type PreSplitUploadedBankTransactionWithInfo = IUploadedBankTransactionWithInfo & {
+    splitTransactionId: mongoose.Types.ObjectId;
+    splitMemo: string;
+};
+export declare const AllocatedBankTransaction: AllocatedBankTransactionModel;
+export {};

package/models/AllocatedBankTransaction.model.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllocatedBankTransaction = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const CashAllocationProduct_model_1 = require("./CashAllocationProduct.model");
+const _models_1 = require("./_models");
+const AllocatedBankTransactionSchema = new mongoose_1.default.Schema({
+    uploadedBankTransactionId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: _models_1.MODEL_NAMES.uploadedBankTransactions,
+        required: false,
+    },
+    order: {
+        type: Number,
+        required: true,
+    },
+    date: {
+        type: Date,
+        required: true,
+    },
+    accountNumber: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    amount: {
+        type: Number,
+        required: true,
+    },
+    reference: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    class: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    location: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    cashAllocationReferenceId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: _models_1.MODEL_NAMES.cashAllocationReferences,
+        required: false,
+    },
+    cashAllocationProductId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: _models_1.MODEL_NAMES.cashAllocationProducts,
+        required: false,
+    },
+    splitTransactionId: {
+        type: mongoose_1.default.Schema.Types.ObjectId,
+        ref: _models_1.MODEL_NAMES.cashAllocationReferences,
+        required: false,
+    },
+    memo: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    accounts: CashAllocationProduct_model_1.AccountSchema,
+}, { timestamps: { createdAt: true, updatedAt: false } });
+exports.AllocatedBankTransaction = mongoose_1.default.model(_models_1.MODEL_NAMES.allocatedBankTransactions, AllocatedBankTransactionSchema);