pristine-member-nest-api-database 1.0.62 → 1.0.64

package/models/Editor.Application.model.ts

@@ -11,43 +11,16 @@ interface IApplicationDocument extends Document {
   applicationName: string;
   applicationDescription: string;
   categories: IApplicationCategory[];
-  SLITOOptionEnabled: boolean;
+
+  // STATIC VARIBLE CONFIG ON BRANCH CONFIG LEVEL
+  SLITOptionEnabled: boolean;
   organizationApplicationEnabled: boolean;
   approverOneEnabled: boolean;
   approverTwoEnabled: boolean;
-  createdDate: Schema.Types.Date;
-  IsMembershipTableEnabled: boolean;
+  IsMembershipRatesTableEnabled: boolean;
   IsMembershipExtraDetailsEnabled: boolean;
-  // BranchManagerData: {
-  //   attachment: {
-  //     fileName: string;
-  //     fileType: string;
-  //     fileSize: number;
-  //     fileUrl: string;
-  //   };
-  //   remarks: string;
-  //   electedDate: Date;
-  //   InvoiceDiscount: number;
-  // };
-  // approverOneData: {
-  //   remarks: string;
-  //   userId: string;
-  //   attachment: {
-  //     fileName: string;
-  //     fileType: string;
-  //     fileSize: number;
-  //     fileUrl: string;
-  //   };
-  // };
-  // approverTwoData: {
-  //   remarks: string;
-  //   userId: string;
-  //   attachment: {
-  //     fileName: string;
-  //     fileType: string;
-  //     fileSize: number;
-  //     fileUrl: string;
-  //   };
-  // };
+  OtherInfoEnabled: boolean;
+  // STATIC VARIBLE CONFIG ON BRANCH CONFIG LEVEL END HERE
+  createdDate: Schema.Types.Date;
   audit: Audit[];
 }

package/models/Editor.Category.Field.Mapping.ts

@@ -0,0 +1,47 @@
+//Editor.PureStaticFieldsMapping.ts
+
+import mongoose, { Document, ObjectId, Schema, Types } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface CategoryFieldMappingDocument extends Document {
+  categoryId: mongoose.Types.ObjectId;
+  fields: [
+    {
+      field: mongoose.Types.ObjectId;
+    },
+  ];
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const CategoryFieldMappingSchema = new Schema<CategoryFieldMappingDocument>({
+  categoryId: {
+    type: Schema.Types.ObjectId,
+    ref: "Field.Categories",
+  },
+  fields: [
+    {
+      field: {
+        type: Schema.Types.ObjectId,
+        ref: "Editor.Fields.Master",
+      },
+    },
+  ],
+  isActive: { type: Boolean, default: true },
+  audit: [
+    {
+      userId: { type: String },
+      auditedOn: { type: Date, default: null },
+      actionType: { type: String },
+    },
+  ],
+});
+
+const mongoCategoryFieldMappingSchema =
+  mongoose.model<CategoryFieldMappingDocument>(
+    "Editor.Category.Fields.Mapping",
+    CategoryFieldMappingSchema,
+  );
+
+export { CategoryFieldMappingDocument, mongoCategoryFieldMappingSchema };

package/models/Editor.Container.Category.mapping.ts

@@ -0,0 +1,41 @@
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+
+interface ContainerCategoryMapping extends Document {
+  ContainerId: mongoose.Types.ObjectId;
+  CategoryId: mongoose.Types.ObjectId;
+  isSystemDefined: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const ContainerCategoryMappingSchema = new Schema<ContainerCategoryMapping>({
+  ContainerId: {
+    type: Schema.Types.ObjectId,
+    ref: "Editor.Container", // Reference to the ontainers
+    required: false,
+    default: null,
+  },
+  CategoryId: {
+    type: Schema.Types.ObjectId,
+    ref: "Field.Categories", // Reference to the Categories
+    required: false,
+    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.model<ContainerCategoryMapping>(
+  "Editor.Container.Category.mapping",
+  ContainerCategoryMappingSchema,
+);
+
+export { ContainerCategoryMapping, mongoEditorField };

package/models/Editor.FieldMaster.model.ts

@@ -2,7 +2,7 @@ import mongoose, { Document, Schema } from "mongoose";
 import { Audit } from "../interface/Audit.interface";
 import { FieldTypeEnum } from "./Editor.FieldTypeMaster.model";
 
-// TEXT
+// TEXT OR TEXT AREA
 export interface TextFieldConfig {
   pattern?: string | null; // regex pattern for validation
   minLength?: number | null;
@@ -24,7 +24,7 @@ export interface WholeNumberFieldConfig {
   maxLength?: number | null;
 }
 
-// OPTIONS (checkbox / dropdown)
+// OPTIONS (checkbox / dropdown / Radio)
 export interface OptionConfig {
   value: string;
   label: string;
@@ -97,6 +97,7 @@ interface EditorField extends Document {
   fieldConfig: FieldConfig;
   isActive: boolean;
   audit: Audit[];
+  IsMemberLevelData: boolean;
 }
 
 const fieldSchema = new Schema<EditorField>({
@@ -124,6 +125,11 @@ const fieldSchema = new Schema<EditorField>({
       actionType: { type: String },
     },
   ],
+  IsMemberLevelData: {
+    type: Boolean,
+    default: false,
+    required: true,
+  },
 });
 
 const mongoEditorField = mongoose.model<EditorField>(

package/models/Editor.FieldTypeMaster.model.ts

@@ -6,11 +6,13 @@ import { Audit } from "../interface/Audit.interface";
 ========================= */
 export enum FieldTypeEnum {
   TEXT = "TEXT",
+  TEXTAREA = "TEXTAREA",
   WHOLENUMBER = "WHOLENUMBER",
   DECIMALNUMBER = "DECIMALNUMBER",
   EMAIL = "EMAIL",
   DATE = "DATE",
   CHECKBOX = "CHECKBOX",
+  RADIO = "RADIO",
   DROPDOWN = "DROPDOWN",
   MULTISELECT = "MULTISELECT",
   SINGLECOUNTRYFLAG = "SINGLECOUNTRYFLAG",

package/models/Member-old.model.ts

@@ -0,0 +1,384 @@
+import mongoose, { Document, Schema } from "mongoose";
+import { Audit } from "../interface/Audit.interface";
+import IFile from "../interface/IFile.interface";
+
+type keyExecutivesDetails = {
+  chairmanName: string;
+  chairmanEmail: string;
+  chairmanphone: string;
+  managingDirectorName: string;
+  managingDirectorEmail: string;
+  managingDirectorPhone: string;
+  ceoName: string;
+  ceoEmail: string;
+  ceoPhone: string;
+  headOfHrName: string;
+  headofHrEmail: string;
+  headofHrPhone: string;
+  headOfMarketingName: string;
+  headOfMarketingEmail: string;
+  headOfMarketingPhone: string;
+  cfoName: string;
+  cfoEmail: string;
+  cfoPhone: string;
+  countryManagerName: string;
+  countryManagerEmail: string;
+  countryManagerPhone: string;
+};
+
+type ConglomerateAddress = {
+  addressLine1: string;
+  addressLine2: string;
+  addressLine3: string;
+  block: string;
+  city: string;
+  country: string;
+};
+
+type MemberContactInfo = {
+  bpShortCode: string;
+  firstName: string;
+  lastName: string;
+  contactTelNo1: string;
+  contactEmail1: string;
+  contactDesignation: string;
+  contactAddress: string;
+  contactAddress2: String;
+  city: String;
+  isSAPSynced: boolean;
+  lastSyncedOn: Date;
+};
+
+type barcodeBranch = {
+  isRegisteredMembership: boolean; //field is used to check whether membership is created on first time registering
+  isMembershipRequested: boolean; //means membership request is waiting for approval
+  membershipType: mongoose.Types.ObjectId;
+  membershipStatus: mongoose.Types.ObjectId;
+  remarks: String;
+  requestedDate: Date;
+  isMembershipSynced: boolean; //used to check whether SAP sync done or not
+  noOfSubscriptionMonths: number;
+  isIssued: boolean; //means subscription is issued or not
+  electedDate: Date;
+  barcodeBranchMemberCode: string;
+  barCode: number;
+  validFrom: Date;
+  validTo: Date;
+  countryCode: number;
+  changeDate: Date;
+  isTerminationRequested: boolean;
+  isTerminationSynced: boolean; //used to check whether SAP sync done or not
+  terminationDate: Date;
+  terminationReason: string;
+};
+
+type MemberAssociation = {
+  branch: mongoose.Types.ObjectId;
+  associationMemberCode: string;
+  membershipStatus: mongoose.Types.ObjectId;
+  membershipType: mongoose.Types.ObjectId;
+  electedDate: Date;
+  contactInfo: MemberContactInfo;
+  isTerminated: boolean;
+  terminatedDate: Date;
+  reasonForTermination: string;
+  barcodeAssociation: barcodeBranch[];
+  dynamicDetails: JSON;
+  isTerminationRequested: boolean;
+  terminationRequestedDate: Date;
+  terminationRequestedBy: string;
+  terminationRequestRemarks: string;
+  onOfSubscriptionMonths: number;
+  applicationStatus: string;
+  reviewedBy: mongoose.Types.ObjectId;
+  reviewedOn: Date;
+  isEnrolmentCreatedInSAP: boolean;
+  isEnrolmentSyncedWithSAP: boolean;
+  enrolmentSyncedOn: Date;
+  isActive: boolean;
+  createdDate: Date;
+  salesOrderDocEntry: string; // SAP sales order doc entry when creating BP in SAP
+  salesOrderStatus: string; // SAP sales order status when creating BP in SAP
+  approveRemarks: string; //application verification approve remarks
+  rejectRemarks: string; //application verification reject remarks
+};
+
+interface MemberDocument extends Document {
+  memberId: number;
+  memberCode: string;
+  memberName: string;
+  isMemberOfMasterBranch: boolean;
+  taxIdentificationNo: string;
+  vatNo: string;
+  vatAttachment: IFile;
+  svatNo: string;
+  svatAttachment: IFile;
+  brNo: string;
+  brAttachment: IFile;
+  nicNo: string;
+  nicAttachment: IFile;
+  webSite: string;
+  generalTelNo: string;
+  generalEmail: string;
+  isTaxRegistered: boolean;
+  conglomerateAddress: ConglomerateAddress;
+  otherAttachment: IFile;
+
+  typeOfOrganization: mongoose.Types.ObjectId;
+  natureOfBusiness: mongoose.Types.ObjectId[];
+  mainProductsOrServices: mongoose.Types.ObjectId[];
+  countryOfExportsOrImports: string[];
+  noOfExecutiveEmployees: number;
+  noOfNoneOfExecutiveEmployees: number;
+  keyExecutivesDetails: keyExecutivesDetails;
+
+  isMemberContactSynced: boolean;
+  memberContactSyncedOn: Date;
+  isCreatedInSAP: boolean;
+  isMemberSyncedWithSAP: boolean;
+  memberSyncedOn: Date;
+  isActive: boolean;
+  memberAssociation: MemberAssociation[];
+  audit: Audit[];
+}
+
+mongoose.set("strictPopulate", false);
+
+// File schema
+const fileSchema = new Schema<IFile>({
+  baseURL: { type: String },
+  fileName: { type: String },
+  fileExtension: { type: String },
+});
+
+const memberSchema = new Schema<MemberDocument>({
+  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: Schema.Types.ObjectId,
+    ref: "OrganizationType.Master",
+  },
+
+  natureOfBusiness: {
+    type: [Schema.Types.ObjectId],
+    ref: "NatureOfBusiness.Master",
+  },
+
+  mainProductsOrServices: {
+    type: [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: Schema.Types.ObjectId,
+        ref: "Branches", // Reference to the 'Branches' model
+      },
+      associationMemberCode: { type: String, default: "" },
+      membershipStatus: {
+        type: Schema.Types.ObjectId,
+        ref: "Membership.Statuses", // Reference to the 'Membership.Statuses' model
+      },
+      membershipType: {
+        type: 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.Types.ObjectId,
+              ref: "Membership.Types",
+              required: true,
+            },
+            membershipStatus: {
+              type: mongoose.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: 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: 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.model<MemberDocument>("Members", memberSchema);
+
+export {
+  ConglomerateAddress,
+  MemberAssociation,
+  MemberContactInfo,
+  MemberDocument,
+  mongoMember,
+};