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

package/models/Member.model.ts

@@ -2,54 +2,7 @@ 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 = {
+type barcodeBranchMemberhipdetails = {
   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;
@@ -72,35 +25,21 @@ type barcodeBranch = {
   terminationReason: string;
 };
 
-type MemberAssociation = {
-  branch: mongoose.Types.ObjectId;
+type noneGs1MembershipDetails = {
   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
+  isMembershipSynced: boolean;
+  SyncOn: Date;
+  electedDate: Date;
 };
 
 interface MemberDocument extends Document {
@@ -108,266 +47,253 @@ interface MemberDocument extends Document {
   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;
+  pureStaticMemberLevelFieldValues: [
+    {
+      fieldId: mongoose.Types.ObjectId;
+      value: string;
+    },
+  ];
+  //Member Level Sync
   isCreatedInSAP: boolean;
   isMemberSyncedWithSAP: boolean;
   memberSyncedOn: Date;
   isActive: boolean;
-  memberAssociation: MemberAssociation[];
+
+  //new
+  memberAssociation: [
+    {
+      applicationId: mongoose.Types.ObjectId;
+      branchId: mongoose.Types.ObjectId;
+
+      categoryData: [
+        {
+          categoryId: mongoose.Types.ObjectId;
+          fieldValues: [
+            {
+              fieldId: mongoose.Types.ObjectId;
+              value: string | number | any;
+            },
+          ];
+        },
+      ];
+      membershipData: {
+        fieldId: mongoose.Types.ObjectId;
+        value: barcodeBranchMemberhipdetails[] | noneGs1MembershipDetails;
+      };
+
+      isCreatedInSAP: boolean;
+      isMemberSyncedWithSAP: boolean;
+      memberSyncedOn: Date;
+      dynamicDetails: JSON;
+
+      applicationStatus: string;
+      isEnrolmentCreatedInSAP: boolean;
+      isEnrolmentSyncedWithSAP: boolean;
+      enrolmentSyncedOn: Date;
+      salesOrderDocEntry: string; // SAP sales order doc entry when creating BP in SAP
+      salesOrderStatus: string; // SAP sales order status when creating BP in SAP
+      isActive: boolean;
+      createdDate: Date;
+      approverOneData: {
+        fieldId: mongoose.Types.ObjectId;
+        remarks: string;
+        userId: string;
+        attachment: IFile[];
+      };
+      approverTwoData: {
+        fieldId: mongoose.Types.ObjectId;
+        remarks: string;
+        userId: string;
+        attachment: IFile[];
+      };
+    },
+  ];
   audit: Audit[];
 }
 
 mongoose.set("strictPopulate", false);
 
-// File schema
+/* ------------------------------------------------ */
+/* 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 },
+/* ------------------------------------------------ */
+/* Barcode Membership Schema */
+/* ------------------------------------------------ */
+
+const barcodeMembershipSchema = new Schema({
+  isRegisteredMembership: { type: Boolean, required: true },
+  isMembershipRequested: { type: Boolean, default: true },
+  membershipType: {
+    type: Schema.Types.ObjectId,
+    ref: "Membership.Types",
+    required: true,
   },
-  otherAttachment: [fileSchema],
-  typeOfOrganization: {
+  membershipStatus: {
     type: Schema.Types.ObjectId,
-    ref: "OrganizationType.Master",
+    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 },
+  terminationDate: { type: Date },
+  terminationReason: { type: String },
+});
 
-  natureOfBusiness: {
-    type: [Schema.Types.ObjectId],
-    ref: "NatureOfBusiness.Master",
+/* ------------------------------------------------ */
+/* None GS1 Membership Schema */
+/* ------------------------------------------------ */
+
+const noneGs1MembershipSchema = new Schema({
+  associationMemberCode: { type: String },
+  membershipStatus: {
+    type: Schema.Types.ObjectId,
+    ref: "Membership.Statuses",
   },
+  membershipType: {
+    type: Schema.Types.ObjectId,
+    ref: "Membership.Types",
+  },
+  isTerminated: { type: Boolean },
+  terminatedDate: { type: Date },
+  reasonForTermination: { type: String },
+  isTerminationRequested: { type: Boolean },
+  terminationRequestedDate: { type: Date },
+  terminationRequestedBy: { type: String },
+  terminationRequestRemarks: { type: String },
+  onOfSubscriptionMonths: { type: Number },
+  isMembershipSynced: { type: Boolean },
+  SyncOn: { type: Date },
+  electedDate: { type: Date },
+});
+
+/* ------------------------------------------------ */
+/* Category Field Value */
+/* ------------------------------------------------ */
 
-  mainProductsOrServices: {
-    type: [Schema.Types.ObjectId],
-    ref: "Products.ServicesMaster",
+const fieldValueSchema = new Schema({
+  fieldId: {
+    type: Schema.Types.ObjectId,
+    ref: "Editor.Fields.Master",
   },
-  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: "" },
+  value: { type: Schema.Types.Mixed },
+});
+
+/* ------------------------------------------------ */
+/* Category Schema */
+/* ------------------------------------------------ */
+
+const categorySchema = new Schema({
+  categoryId: {
+    type: Schema.Types.ObjectId,
+    ref: "Field.Categories",
+  },
+  fieldValues: [fieldValueSchema],
+});
+
+/* ------------------------------------------------ */
+/* Membership Data */
+/* ------------------------------------------------ */
+
+const membershipDataSchema = new Schema({
+  fieldId: {
+    type: Schema.Types.ObjectId,
   },
+  barcodeBranchMembership: [barcodeMembershipSchema],
+  noneGs1Membership: noneGs1MembershipSchema,
+});
+
+/* ------------------------------------------------ */
+/* Approver Schema */
+/* ------------------------------------------------ */
+
+const approverSchema = new Schema({
+  fieldId: { type: Schema.Types.ObjectId },
+  remarks: { type: String },
+  userId: { type: String },
+  attachment: [fileSchema],
+});
+
+/* ------------------------------------------------ */
+/* Member Association */
+/* ------------------------------------------------ */
 
-  isMemberContactSynced: { type: Boolean, default: false },
-  memberContactSyncedOn: { type: Date, default: null },
+const memberAssociationSchema = new Schema({
+  applicationId: {
+    type: Schema.Types.ObjectId,
+  },
+  branchId: {
+    type: Schema.Types.ObjectId,
+    ref: "Branches",
+  },
+  categoryData: [categorySchema],
+  membershipData: membershipDataSchema,
   isCreatedInSAP: { type: Boolean, default: false },
   isMemberSyncedWithSAP: { type: Boolean, default: false },
-  memberSyncedOn: { type: Date, default: null },
-  isActive: { type: Boolean },
-  memberAssociation: [
+  memberSyncedOn: { type: Date },
+  dynamicDetails: { type: JSON, default: null },
+  applicationStatus: { type: String },
+  isEnrolmentCreatedInSAP: { type: Boolean, default: false },
+  isEnrolmentSyncedWithSAP: { type: Boolean, default: false },
+  enrolmentSyncedOn: { type: Date },
+  salesOrderDocEntry: { type: String },
+  salesOrderStatus: { type: String },
+  isActive: { type: Boolean, default: true },
+  createdDate: {
+    type: Date,
+    default: Date.now,
+  },
+  approverOneData: approverSchema,
+  approverTwoData: approverSchema,
+});
+
+/* ------------------------------------------------ */
+/* Member Schema */
+/* ------------------------------------------------ */
+
+const memberSchema = new Schema<MemberDocument>({
+  memberId: { type: Number },
+  memberCode: { type: String, default: "" },
+  memberName: { type: String },
+  isMemberOfMasterBranch: { type: Boolean, default: false },
+  pureStaticMemberLevelFieldValues: [
     {
-      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: {
+      fieldId: {
         type: Schema.Types.ObjectId,
-        ref: "Users", // Reference to the 'Users' model
-        default: null,
+        ref: "Editor.Fields.Master",
       },
-      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: "" },
+      value: { type: String },
     },
   ],
+
+  isCreatedInSAP: { type: Boolean, default: false },
+  isMemberSyncedWithSAP: { type: Boolean, default: false },
+  memberSyncedOn: { type: Date },
+  isActive: { type: Boolean },
+  memberAssociation: [memberAssociationSchema],
   audit: [
     {
       userId: { type: String },
-      auditedOn: { type: Date, default: null },
+      auditedOn: { type: Date },
       actionType: { type: String },
     },
   ],
@@ -375,10 +301,4 @@ const memberSchema = new Schema<MemberDocument>({
 
 const mongoMember = mongoose.model<MemberDocument>("Members", memberSchema);
 
-export {
-  ConglomerateAddress,
-  MemberAssociation,
-  MemberContactInfo,
-  MemberDocument,
-  mongoMember,
-};
+export { mongoMember };

package/package.json

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

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

@@ -1,35 +0,0 @@
-//Editor.PureStaticFieldsMapping.ts
-
-import mongoose, { Document, ObjectId, Schema, Types } from "mongoose";
-import { Audit } from "../interface/Audit.interface";
-
-interface PureStaticFieldsCategoryMapping extends Document {
-  categoryId: mongoose.Types.ObjectId;
-  fieldId: mongoose.Types.ObjectId;
-  isSystemDefined: boolean;
-  isActive: boolean;
-  audit: Audit[];
-}
-
-const pureStaticFieldMappingSchema =
-  new Schema<PureStaticFieldsCategoryMapping>({
-    categoryId: { type: Schema.Types.ObjectId, ref: "Field.Categories" },
-    fieldId: { type: 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.model<PureStaticFieldsCategoryMapping>(
-    "Editor.PureStatic.Category.Field.Mapping",
-    pureStaticFieldMappingSchema,
-  );
-
-export { PureStaticFieldsCategoryMapping, mongopureStaticFieldMappingSchema };