pristine-member-nest-api-database 1.0.80 → 1.0.82

package/dist/models/Editor.Application.model.js

@@ -1,2 +1,108 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoApplicationSchema = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const ApplicationSchemSchema = new mongoose_1.Schema({
+    branchId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Branches" },
+    dynamicTemplateId: { type: mongoose_1.Schema.Types.ObjectId, ref: "DynamicTemplates" },
+    BPCompanyTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Editor.BPCompany.Types",
+        default: null,
+    },
+    membershipTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Membership.Types",
+        default: null,
+    },
+    applicationName: { type: String },
+    applicationDescription: { type: String },
+    categories: {
+        type: [
+            {
+                categoryId: {
+                    type: mongoose_1.Schema.Types.ObjectId,
+                    ref: "Field.Categories",
+                    required: true,
+                },
+                categorySequence: {
+                    type: Number,
+                    required: true,
+                },
+                fields: [
+                    {
+                        fieldId: {
+                            type: mongoose_1.Schema.Types.ObjectId,
+                            ref: "Field.Categories", // (optional: should be Field.Master probably)
+                            required: true,
+                        },
+                        fieldSequence: {
+                            type: Number,
+                            required: true,
+                        },
+                        fieldDescription: {
+                            type: String,
+                            default: "",
+                        },
+                        activeStatus: {
+                            type: Boolean,
+                            default: true,
+                        },
+                    },
+                ],
+            },
+        ],
+        required: true,
+    },
+    approverOneEnabled: { type: Boolean, default: true },
+    approverTwoEnabled: { type: Boolean, default: true },
+    IsMembershipExtraDetailsEnabled: { type: Boolean, default: true },
+    IsMembershipRatesTableEnabled: { type: Boolean, default: true },
+    organizationApplicationEnabled: { type: Boolean, default: true },
+    SLITOptionEnabled: { type: Boolean, default: true },
+    OtherInfoEnabled: { type: Boolean, default: true },
+    createdDate: { type: Date, default: null },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+ApplicationSchemSchema.index({
+    branchId: 1,
+    BPCompanyTypeId: 1,
+    membershipTypeId: 1,
+}, {
+    unique: true,
+    partialFilterExpression: {
+        branchId: { $exists: true },
+    },
+});
+const mongoApplicationSchema = mongoose_1.default.model("Editor.Application", ApplicationSchemSchema);
+exports.mongoApplicationSchema = mongoApplicationSchema;

package/dist/models/Editor.BPcompanyTpes.Branch.Field.Category.Mapping.js

@@ -0,0 +1,47 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoBranchBpCompanyTypesFieldMappingSchema = void 0;
+// Editor.BPcompanyTpes.Branch.Field.Category.Mapping.ts
+const mongoose_1 = __importStar(require("mongoose"));
+const BranchCompanyTypesFieldMappingSchema = new mongoose_1.Schema({
+    BranchId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Branch" },
+    companyTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Editor.BPCompany.Types",
+    },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoBranchBpCompanyTypesFieldMappingSchema = mongoose_1.default.model("Editor.Branch.CompanyTypes.Field.Mapping", BranchCompanyTypesFieldMappingSchema);
+exports.mongoBranchBpCompanyTypesFieldMappingSchema = mongoBranchBpCompanyTypesFieldMappingSchema;

package/dist/models/Editor.BPcompanyTypes.Branch.Field.Mapping.js

@@ -27,7 +27,7 @@ exports.mongoBpCompanyBranchFieldMapping = void 0;
 // Editor.BPcompanyTpes.Branch.Field.Category.Mapping.ts
 const mongoose_1 = __importStar(require("mongoose"));
 const BpCompanyBranchFieldMappingSchema = new mongoose_1.Schema({
-    BranchId: { type: mongoose_1.Schema.Types.ObjectId, ref: "branches" },
+    BranchId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Branch" },
     companyTypeId: {
         type: mongoose_1.Schema.Types.ObjectId,
         ref: "Editor.BPCompany.Types",

package/dist/models/Editor.PureStatic.Category.Field.Mapping.js

@@ -0,0 +1,43 @@
+"use strict";
+//Editor.PureStaticFieldsMapping.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongopureStaticFieldMappingSchema = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const pureStaticFieldMappingSchema = new mongoose_1.Schema({
+    categoryId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Field.Categories" },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongopureStaticFieldMappingSchema = mongoose_1.default.model("Editor.PureStatic.Category.Field.Mapping", pureStaticFieldMappingSchema);
+exports.mongopureStaticFieldMappingSchema = mongopureStaticFieldMappingSchema;

package/dist/models/Editor.SLIITO.Category.Field.Mapping.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoSLITOBranchMembershipTypeFieldMapping = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const SLITOCategoryFieldMappingSchema = new mongoose_1.Schema({
+    branchId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Editor.Fields.Master" },
+    fieldId: { type: mongoose_1.Schema.Types.ObjectId, ref: "Branches" },
+    membershipTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Membership.Types",
+    },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+//(composite unique key)
+SLITOCategoryFieldMappingSchema.index({ branchId: 1, membershipTypeId: 1, fieldId: 1 }, { unique: true });
+const mongoSLITOBranchMembershipTypeFieldMapping = mongoose_1.default.model("Editor.SLITO.Branch.Membership.Field.Mapping", SLITOCategoryFieldMappingSchema);
+exports.mongoSLITOBranchMembershipTypeFieldMapping = mongoSLITOBranchMembershipTypeFieldMapping;

package/dist/models/EditorFieldMaster.model.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoEditorField = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const fieldSchema = new mongoose_1.Schema({
+    fieldCode: { type: String },
+    fieldName: { type: String },
+    FieldTypeId: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "Field.Types", // Reference to the 'Container' model
+        required: false,
+        default: null,
+    },
+    ManagerEdit: { type: Boolean, default: false },
+    MemberEdit: { type: Boolean, default: false },
+    SapSync: { type: Boolean, default: false },
+    fieldConfig: {
+        mandatory: { type: Boolean, default: false },
+        minLength: { type: Number, default: null },
+        maxLength: { type: Number, default: null },
+        pattern: { type: String, default: null },
+    },
+    isSystemDefined: { type: Boolean, default: false },
+    isActive: { type: Boolean, default: true },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoEditorField = mongoose_1.default.model("Editor.Fields.Master", fieldSchema);
+exports.mongoEditorField = mongoEditorField;

package/dist/models/FieldTypes.model.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoEditorFieldType = exports.FieldTypeEnum = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+/* =========================
+   FIELD TYPE ENUM
+========================= */
+var FieldTypeEnum;
+(function (FieldTypeEnum) {
+    FieldTypeEnum["TEXT"] = "TEXT";
+    FieldTypeEnum["WHOLENUMBER"] = "WHOLENUMBER";
+    FieldTypeEnum["DECIMALNUMBER"] = "DECIMALNUMBER";
+    FieldTypeEnum["EMAIL"] = "EMAIL";
+    FieldTypeEnum["DATE"] = "DATE";
+    FieldTypeEnum["CHECKBOX"] = "CHECKBOX";
+    FieldTypeEnum["DROPDOWN"] = "DROPDOWN";
+    FieldTypeEnum["MULTISELECT"] = "MULTISELECT";
+    FieldTypeEnum["SINGLECOUNTRYFLAG"] = "SINGLECOUNTRYFLAG";
+    FieldTypeEnum["MULTIPLECOUNTRYFLAG"] = "MULTIPLECOUNTRYFLAG";
+    FieldTypeEnum["SINGLEATTACHMENT"] = "SINGLEATTACHMENT";
+    FieldTypeEnum["MULTIPLEATTACHMENT"] = "MULTIPLEATTACHMENT";
+    FieldTypeEnum["TABLE"] = "TABLE";
+    FieldTypeEnum["MATRIX"] = "MATRIX";
+    FieldTypeEnum["SCHEMA"] = "SCHEMA";
+})(FieldTypeEnum || (exports.FieldTypeEnum = FieldTypeEnum = {}));
+/* =========================
+   SCHEMA
+========================= */
+const fieldTypeSchema = new mongoose_1.Schema({
+    fieldTypeCode: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    fieldEnum: {
+        type: String,
+        required: true,
+        enum: Object.values(FieldTypeEnum), // store only enum values
+    },
+    fieldTypeName: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    fieldTypeDescription: {
+        type: String,
+        trim: true,
+    },
+    isSystemDefined: {
+        type: Boolean,
+        default: false,
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+    },
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+}, {
+    timestamps: true,
+});
+/* =========================
+   MODEL
+========================= */
+exports.mongoEditorFieldType = mongoose_1.default.model("Editor.FieldType", fieldTypeSchema);

package/dist/models/MemberNEW.model.js

@@ -0,0 +1,254 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mongoMember = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+mongoose_1.default.set("strictPopulate", false);
+// File schema
+const fileSchema = new mongoose_1.Schema({
+    baseURL: { type: String },
+    fileName: { type: String },
+    fileExtension: { type: String },
+});
+const memberSchema = new mongoose_1.Schema({
+    memberId: { type: Number },
+    memberCode: { type: String, default: "" },
+    memberName: { type: String },
+    isMemberOfMasterBranch: { type: Boolean, default: false },
+    taxIdentificationNo: { type: String },
+    vatNo: { type: String },
+    vatAttachment: fileSchema,
+    svatNo: { type: String },
+    svatAttachment: fileSchema,
+    brNo: { type: String, default: "" },
+    brAttachment: fileSchema,
+    nicNo: { type: String, default: "" },
+    nicAttachment: fileSchema,
+    webSite: { type: String, default: "" },
+    generalTelNo: { type: String },
+    generalEmail: { type: String },
+    isTaxRegistered: { type: Boolean, default: false },
+    conglomerateAddress: {
+        addressLine1: { type: String },
+        addressLine2: { type: String, default: "" },
+        addressLine3: { type: String, default: "" },
+        block: { type: String, default: "" },
+        city: { type: String },
+        country: { type: String },
+    },
+    otherAttachment: [fileSchema],
+    typeOfOrganization: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: "OrganizationType.Master",
+    },
+    natureOfBusiness: {
+        type: [mongoose_1.Schema.Types.ObjectId],
+        ref: "NatureOfBusiness.Master",
+    },
+    mainProductsOrServices: {
+        type: [mongoose_1.Schema.Types.ObjectId],
+        ref: "Products.ServicesMaster",
+    },
+    countryOfExportsOrImports: { type: [String], default: [] },
+    noOfExecutiveEmployees: { type: Number, default: 0 },
+    noOfNoneOfExecutiveEmployees: { type: Number, default: 0 },
+    keyExecutivesDetails: {
+        chairmanName: { type: String, default: "" },
+        chairmanEmail: { type: String, default: "" },
+        chairmanphone: { type: String, default: "" },
+        managingDirectorName: { type: String, default: "" },
+        managingDirectorEmail: { type: String, default: "" },
+        managingDirectorPhone: { type: String, default: "" },
+        ceoName: { type: String, default: "" },
+        ceoEmail: { type: String, default: "" },
+        ceoPhone: { type: String, default: "" },
+        headOfHrName: { type: String, default: "" },
+        headofHrEmail: { type: String, default: "" },
+        headofHrPhone: { type: String, default: "" },
+        headOfMarketingName: { type: String, default: "" },
+        headOfMarketingEmail: { type: String, default: "" },
+        headOfMarketingPhone: { type: String, default: "" },
+        cfoName: { type: String, default: "" },
+        cfoEmail: { type: String, default: "" },
+        cfoPhone: { type: String, default: "" },
+        countryManagerName: { type: String, default: "" },
+        countryManagerEmail: { type: String, default: "" },
+        countryManagerPhone: { type: String, default: "" },
+    },
+    isMemberContactSynced: { type: Boolean, default: false },
+    memberContactSyncedOn: { type: Date, default: null },
+    isCreatedInSAP: { type: Boolean, default: false },
+    isMemberSyncedWithSAP: { type: Boolean, default: false },
+    memberSyncedOn: { type: Date, default: null },
+    isActive: { type: Boolean },
+    memberAssociation: [
+        {
+            branch: {
+                type: mongoose_1.Schema.Types.ObjectId,
+                ref: "Branches", // Reference to the 'Branches' model
+            },
+            associationMemberCode: { type: String, default: "" },
+            membershipStatus: {
+                type: mongoose_1.Schema.Types.ObjectId,
+                ref: "Membership.Statuses", // Reference to the 'Membership.Statuses' model
+            },
+            membershipType: {
+                type: mongoose_1.Schema.Types.ObjectId,
+                ref: "Membership.Types", // Reference to the 'Membership.Types' model
+            },
+            electedDate: { type: Date, default: null },
+            contactInfo: {
+                bpShortCode: { type: String, default: "" },
+                firstName: { type: String },
+                lastName: { type: String },
+                contactTelNo1: { type: String },
+                contactEmail1: { type: String },
+                contactDesignation: { type: String },
+                contactAddress: { type: String },
+                contactAddress2: { type: String },
+                city: { type: String },
+                isSAPSynced: { type: Boolean, default: false },
+                lastSyncedOn: { type: Date, default: null },
+            },
+            isTerminated: { type: Boolean, default: false },
+            terminatedDate: { type: Date, default: null },
+            reasonForTermination: { type: String, default: "" },
+            barcodeAssociation: {
+                type: [
+                    {
+                        isRegisteredMembership: {
+                            type: Boolean,
+                            required: true,
+                        },
+                        isMembershipRequested: {
+                            type: Boolean,
+                            default: true,
+                        },
+                        membershipType: {
+                            type: mongoose_1.default.Types.ObjectId,
+                            ref: "Membership.Types",
+                            required: true,
+                        },
+                        membershipStatus: {
+                            type: mongoose_1.default.Types.ObjectId,
+                            ref: "Membership.Statuses",
+                            required: true,
+                        },
+                        remarks: {
+                            type: String,
+                        },
+                        requestedDate: {
+                            type: Date,
+                            default: Date.now,
+                        },
+                        isMembershipSynced: {
+                            type: Boolean,
+                            default: false,
+                        },
+                        noOfSubscriptionMonths: {
+                            type: Number,
+                        },
+                        isIssued: {
+                            type: Boolean,
+                        },
+                        electedDate: {
+                            type: Date,
+                        },
+                        barcodeBranchMemberCode: {
+                            type: String,
+                        },
+                        barCode: {
+                            type: Number,
+                        },
+                        validFrom: {
+                            type: Date,
+                        },
+                        validTo: {
+                            type: Date,
+                        },
+                        countryCode: {
+                            type: Number,
+                        },
+                        changeDate: {
+                            type: Date,
+                        },
+                        isTerminationRequested: {
+                            type: Boolean,
+                            default: false,
+                        },
+                        isTerminationSynced: {
+                            type: Boolean,
+                            default: false,
+                        },
+                        terminationRequestedDate: {
+                            type: Date,
+                        },
+                        terminationDate: {
+                            type: Date,
+                        },
+                        terminationReason: {
+                            type: String,
+                        },
+                    },
+                ],
+            },
+            dynamicDetails: { type: JSON, default: null },
+            isTerminationRequested: { type: Boolean, default: false },
+            terminationRequestedDate: { type: Date, default: null },
+            terminationRequestedBy: { type: String, default: "" },
+            terminationRequestRemarks: { type: String, default: "" },
+            onOfSubscriptionMonths: { type: Number, default: 0 },
+            applicationStatus: { type: String, default: "PENDING" },
+            reviewedBy: {
+                type: mongoose_1.Schema.Types.ObjectId,
+                ref: "Users", // Reference to the 'Users' model
+                default: null,
+            },
+            reviewedOn: { type: Date, default: null },
+            isEnrolmentCreatedInSAP: { type: Boolean, default: false },
+            isEnrolmentSyncedWithSAP: { type: Boolean, default: false },
+            enrolmentSyncedOn: { type: Date, default: null },
+            isActive: { type: Boolean, default: true },
+            createdDate: {
+                type: mongoose_1.Schema.Types.Date,
+                required: false,
+                default: Date.now,
+            },
+            salesOrderDocEntry: { type: String, default: "" },
+            salesOrderStatus: { type: String, default: "" },
+            approveRemarks: { type: String, default: "" },
+            rejectRemarks: { type: String, default: "" },
+        },
+    ],
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String },
+        },
+    ],
+});
+const mongoMember = mongoose_1.default.model("Members", memberSchema);
+exports.mongoMember = mongoMember;

package/models/Editor.Application.model.ts

@@ -8,10 +8,12 @@ import IApplicationCategory from "../interface/IApplicationCategory.interface";
 
 interface IApplicationDocument extends Document {
   branchId: Types.ObjectId;
+  dynamicTemplateId: Types.ObjectId;
+  BPCompanyTypeId: Types.ObjectId;
+  membershipTypeId: Types.ObjectId;
   applicationName: string;
   applicationDescription: string;
   categories: IApplicationCategory[];
-  dynamicTemplateId: Types.ObjectId;
 
   // STATIC VARIBLE CONFIG ON BRANCH CONFIG LEVEL
   SLITOptionEnabled: boolean;
@@ -24,5 +26,101 @@ interface IApplicationDocument extends Document {
 
   // STATIC VARIBLE CONFIG ON BRANCH CONFIG LEVEL END HERE
   createdDate: Schema.Types.Date;
+  isActive: boolean;
   audit: Audit[];
 }
+
+const ApplicationSchemSchema = new Schema<IApplicationDocument>({
+  branchId: { type: Schema.Types.ObjectId, ref: "Branches" },
+  dynamicTemplateId: { type: Schema.Types.ObjectId, ref: "DynamicTemplates" },
+  BPCompanyTypeId: {
+    type: Schema.Types.ObjectId,
+    ref: "Editor.BPCompany.Types",
+    default: null,
+  },
+  membershipTypeId: {
+    type: Schema.Types.ObjectId,
+    ref: "Membership.Types",
+    default: null,
+  },
+  applicationName: { type: String },
+  applicationDescription: { type: String },
+  categories: {
+    type: [
+      {
+        categoryId: {
+          type: Schema.Types.ObjectId,
+          ref: "Field.Categories",
+          required: true,
+        },
+
+        categorySequence: {
+          type: Number,
+          required: true,
+        },
+
+        fields: [
+          {
+            fieldId: {
+              type: Schema.Types.ObjectId,
+              ref: "Field.Categories", // (optional: should be Field.Master probably)
+              required: true,
+            },
+
+            fieldSequence: {
+              type: Number,
+              required: true,
+            },
+
+            fieldDescription: {
+              type: String,
+              default: "",
+            },
+
+            activeStatus: {
+              type: Boolean,
+              default: true,
+            },
+          },
+        ],
+      },
+    ],
+    required: true,
+  },
+  approverOneEnabled: { type: Boolean, default: true },
+  approverTwoEnabled: { type: Boolean, default: true },
+  IsMembershipExtraDetailsEnabled: { type: Boolean, default: true },
+  IsMembershipRatesTableEnabled: { type: Boolean, default: true },
+  organizationApplicationEnabled: { type: Boolean, default: true },
+  SLITOptionEnabled: { type: Boolean, default: true },
+  OtherInfoEnabled: { type: Boolean, default: true },
+  createdDate: { type: Date, default: null },
+  isActive: { type: Boolean, default: true },
+  audit: [
+    {
+      userId: { type: String },
+      auditedOn: { type: Date, default: null },
+      actionType: { type: String },
+    },
+  ],
+});
+
+ApplicationSchemSchema.index(
+  {
+    branchId: 1,
+    BPCompanyTypeId: 1,
+    membershipTypeId: 1,
+  },
+  {
+    unique: true,
+    partialFilterExpression: {
+      branchId: { $exists: true },
+    },
+  },
+);
+const mongoApplicationSchema = mongoose.model<IApplicationDocument>(
+  "Editor.Application",
+  ApplicationSchemSchema,
+);
+
+export { IApplicationDocument, mongoApplicationSchema };

package/models/Editor.BPcompanyTypes.Branch.Field.Mapping.ts

@@ -13,7 +13,7 @@ interface BPCompanyBranchFieldMapping extends Document {
 
 const BpCompanyBranchFieldMappingSchema =
   new Schema<BPCompanyBranchFieldMapping>({
-    BranchId: { type: Schema.Types.ObjectId, ref: "branches" },
+    BranchId: { type: Schema.Types.ObjectId, ref: "Branch" },
     companyTypeId: {
       type: Schema.Types.ObjectId,
       ref: "Editor.BPCompany.Types",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pristine-member-nest-api-database",
-  "version": "1.0.80",
+  "version": "1.0.82",
   "description": "application verification database changes with gs1 branch. not tested. ",
   "main": "dist/index.js",
   "scripts": {