pristine-member-nest-api-database 1.0.1

package/interface/Audit.interface.ts

@@ -0,0 +1,5 @@
+export interface Audit {
+    userId: string;
+    auditedOn: Date;
+    actionType: string;
+}

package/models/AccessLog.model.ts

@@ -0,0 +1,26 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+interface AccessLogDocument extends Document {
+  user: mongoose.Types.ObjectId;
+  log:[{
+    logDate: Date,
+    mobileNo: string,
+    accessedUserName: string
+  }];
+}
+
+const accessLogSchema = new Schema<AccessLogDocument>({
+  user: {
+    type: Schema.Types.ObjectId,
+    ref: 'Users', // Reference to the 'Users' model  
+  },
+  log:[{ 
+    logDate: {type: Date, default:Date.now()},
+    mobileNo: {type: String},
+    accessedUserName: {type: String}
+  }]
+});
+
+const mongoAccessLog = mongoose.model<AccessLogDocument>('Access.Logs', accessLogSchema);
+
+export { AccessLogDocument, mongoAccessLog };

package/models/Appliance.ir.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface ApplianceDocument extends Document {
+  applianceCode: string;
+  applianceName: string;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const applianceSchema = new Schema<ApplianceDocument>({
+  applianceCode: { type: String },
+  applianceName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: null },
+    actionType: { type: String }
+  }]
+});
+
+const mongoAppliance = mongoose.model<ApplianceDocument>('ir.Appliances', applianceSchema);
+
+export { ApplianceDocument, mongoAppliance };

package/models/BankTransfer.model.ts

@@ -0,0 +1,42 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface BankTransferDocument extends Document {
+  transferId: number;
+  member: mongoose.Types.ObjectId;
+  branch: mongoose.Types.ObjectId;
+  datePaid: Date;
+  slipImageLocation: string;
+  remarks: string;
+  dateEntered: Date;
+  audit: Audit[];
+}
+
+mongoose.set('strictPopulate', false);
+
+const bankTransferSchema = new Schema<BankTransferDocument>({
+  transferId: { type: Number },
+  member: {
+    type: Schema.Types.ObjectId,
+    ref: 'Members' //Reference to the 'Members' model 
+  },
+  branch: {
+    type: Schema.Types.ObjectId,
+    ref: 'Branches' // Reference to the 'Branches' model  
+  },
+  datePaid: { type: Date, default:Date.now() },
+  slipImageLocation: { type: String },
+  remarks: { type: String },
+  dateEntered: { type: Date, default:Date.now() },
+  audit: [
+    {
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String }
+    }
+  ]
+});
+
+const mongoBankTransfer = mongoose.model<BankTransferDocument>('Bank.Transfers', bankTransferSchema);
+
+export { BankTransferDocument, mongoBankTransfer };

package/models/BarcodeCategory.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface BarcodeCategoryDocument extends Document {
+  barcodeCategoryCode: string;
+  barcodeCategoryName: string;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const barcodeCategorySchema = new Schema<BarcodeCategoryDocument>({
+  barcodeCategoryCode: { type: String },
+  barcodeCategoryName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: Date.now() },
+    actionType: { type: String }
+  }]
+});
+
+const mongoBarcodeCategory = mongoose.model<BarcodeCategoryDocument>('Barcode.Categories', barcodeCategorySchema);
+
+export { BarcodeCategoryDocument, mongoBarcodeCategory };

package/models/Branch.model.ts

@@ -0,0 +1,48 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface BranchDocument extends Document {
+  branchCode: string;
+  branchName: string;
+  branchShortCode: string;
+  branchType: mongoose.Types.ObjectId;
+  membershipTypes: [{
+    membershipType: mongoose.Types.ObjectId;
+  }],
+  logoFileLocation: string;
+  isPaymentGatewayEnabled:boolean;
+  isBarcodeEnabled: boolean;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+mongoose.set('strictPopulate', false);
+
+const branchSchema = new Schema<BranchDocument>({
+  branchCode: { type: String },
+  branchName: { type: String },
+  branchShortCode: { type: String },
+  branchType: {
+    type: Schema.Types.ObjectId,
+    ref: 'Branch.Types', // Reference to the 'BranchTypes' model  
+  },
+  membershipTypes: [{
+    membershipType: {
+      type: Schema.Types.ObjectId,
+      ref: 'Membership.Types', // Reference to the 'BranchTypes' model  
+    }
+  }],
+  isPaymentGatewayEnabled: { type:Boolean, default:true },
+  logoFileLocation: { type: String, default: ""},
+  isBarcodeEnabled: { type: Boolean, default: false },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: null },
+    actionType: { type: String }
+  }]
+});
+
+const mongoBranch = mongoose.model<BranchDocument>('Branches', branchSchema);
+
+export { BranchDocument, mongoBranch };

package/models/BranchType.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface BranchTypeDocument extends Document {
+  branchTypeCode: string;
+  branchTypeName: string;
+  isActive: boolean;
+  audit: [Audit];
+}
+
+const branchTypeSchema = new Schema<BranchTypeDocument>({
+  branchTypeCode: { type: String },
+  branchTypeName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: Date.now() },
+    actionType: { type: String }
+  }]
+});
+
+const mongoBranchType = mongoose.model<BranchTypeDocument>('Branch.Types', branchTypeSchema);
+
+export { BranchTypeDocument, mongoBranchType };

package/models/Counter.model.ts

@@ -0,0 +1,15 @@
+import mongoose, { Document, Schema } from 'mongoose';
+
+interface CounterDocument extends Document {
+  counterId: string;
+  seq: number;
+}
+
+const counterSchema = new Schema<CounterDocument>({
+  counterId: { type: String },
+  seq: { type: Number }
+});
+
+const mongoCounter = mongoose.model<CounterDocument>('Counters', counterSchema);
+
+export { CounterDocument, mongoCounter };

package/models/Country.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface CountryDocument extends Document {
+  countryCode: string;
+  countryName: string;
+  isActive: boolean;
+  audit: [Audit];
+}
+
+const countrySchema = new Schema<CountryDocument>({
+  countryCode: { type: String },
+  countryName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: Date.now() },
+    actionType: { type: String }
+  }]
+});
+
+const mongoCountry = mongoose.model<CountryDocument>('Countries', countrySchema);
+
+export { CountryDocument, mongoCountry };

package/models/FieldCategory.model.ts

@@ -0,0 +1,26 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface FieldCategoryDocument extends Document {
+  fieldCategoryCode: string;
+  fieldCategoryName: string;
+  fieldCategorySequence: number;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const fieldCategorySchema = new Schema<FieldCategoryDocument>({
+  fieldCategoryCode: { type: String },
+  fieldCategoryName: { type: String },
+  fieldCategorySequence: { type: Number },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: null },
+    actionType: { type: String }
+  }]
+});
+
+const mongoFieldCategory = mongoose.model<FieldCategoryDocument>('Field.Categories', fieldCategorySchema);
+
+export { FieldCategoryDocument, mongoFieldCategory };

package/models/Item.ir.model.ts

@@ -0,0 +1,29 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface ItemDocument extends Document {
+  itemCode: string;
+  itemName: string;
+  itemGroup: mongoose.Types.ObjectId;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const itemSchema = new Schema<ItemDocument>({
+  itemCode: { type: String },
+  itemName: { type: String },
+  itemGroup: {
+    type: Schema.Types.ObjectId,
+    ref: 'ir.Item.Groups', // Reference to the 'ir.Item.Group' model  
+  },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: null },
+    actionType: { type: String }
+  }]
+});
+
+const mongoItem = mongoose.model<ItemDocument>('ir.Items', itemSchema);
+
+export { ItemDocument, mongoItem };

package/models/ItemGroup.ir.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface ItemGroupDocument extends Document {
+  itemGroupCode: string;
+  itemGroupName: string;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const itemGroupSchema = new Schema<ItemGroupDocument>({
+  itemGroupCode: { type: String },
+  itemGroupName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: null },
+    actionType: { type: String }
+  }]
+});
+
+const mongoItemGroup = mongoose.model<ItemGroupDocument>('ir.Item.Groups', itemGroupSchema);
+
+export { ItemGroupDocument, mongoItemGroup };

package/models/ItemRequest.ir.model.ts

@@ -0,0 +1,100 @@
+import mongoose, { Document, Schema, now } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+type itemInfo = {
+    item: mongoose.Types.ObjectId;
+    quantity: number;
+    remarks: string;
+}
+
+
+interface ItemRequestDocument extends Document {
+    requisitionId: number;
+    requestedBranch: mongoose.Types.ObjectId;
+    requestedFromBranch: mongoose.Types.ObjectId;
+    documentDate: Date;
+    dateRequired: Date;
+    projectCode: string;
+    referenceDocument: string;
+    requestStatus: string; //Pending, Approved - Level 1, Approved, Confirmed, Rejected
+    statusDate: Date; 
+    requestedBy: mongoose.Types.ObjectId;
+    requestedOn: Date;
+    level1ApprovalUserRole: string;
+    level1ApprovedBy: mongoose.Types.ObjectId;
+    level1ApprovedOn: Date;
+    level1ActionRemarks: string;
+    confirmedBy: mongoose.Types.ObjectId;
+    confirmedOn: Date;
+    confirmationRemarks: string,
+    rejectedBy: mongoose.Types.ObjectId;
+    rejectedOn: Date;
+    rejectedRemarks: string;
+    items: itemInfo[];
+    isSAPSynced: boolean;
+    dateSAPSynced: Date;
+    audit: Audit[];
+}
+
+const itemRequestSchema = new Schema<ItemRequestDocument>({
+    requisitionId: { type: Number },
+    requestedBranch: {
+        type: Schema.Types.ObjectId,
+        ref: 'Branches', // Reference to the 'Branches' model  
+    },
+    requestedFromBranch: {
+        type: Schema.Types.ObjectId,
+        ref: 'Branches', // Reference to the 'Branches' model  
+    },
+    documentDate: {type: Date, default: now()},
+    dateRequired: {type: Date},
+    projectCode: {type: String},
+    referenceDocument: { type: String}, 
+    requestStatus: {type: String, default: "Pending"},
+    statusDate: {type: Date, default: now()},
+    requestedBy: {
+        type: Schema.Types.ObjectId,
+        ref: 'Users',
+        default: null
+    },
+    requestedOn: { type: Date, default: now()} ,
+    level1ApprovalUserRole: { type: String, default: ""},
+    level1ApprovedBy: {
+        type: Schema.Types.ObjectId,
+        ref: 'Users',
+        default: null
+    },
+    level1ApprovedOn: { type: Date, default: null},
+    level1ActionRemarks: { type: String, default: ""},
+    confirmedBy: {
+        type: Schema.Types.ObjectId,
+        ref: 'Users',
+        default: null
+    },
+    confirmedOn: { type: Date, default: null},
+    confirmationRemarks: { type: String, default: ""},
+    rejectedBy: {
+        type: Schema.Types.ObjectId,
+        ref: 'Users'
+    },
+    rejectedOn: { type: Date, default: null},
+    rejectedRemarks: { type: String, default: ""},
+    items: [{
+        item: {
+            type: Schema.Types.ObjectId,
+            ref: 'ir.Items', // Reference to the 'Branches' model  
+        },
+        quantity: {type: Number},
+        remarks: {type: String}
+    }],
+    isSAPSynced: { type: Boolean, default: false },
+    dateSAPSynced: { type: Date, default: null },
+    audit: [{
+        userId: { type: String },
+        auditedOn: { type: Date, default: null },
+        actionType: { type: String }
+    }]
+});
+
+const mongoItemRequest = mongoose.model<ItemRequestDocument>('ir.Item.Requests', itemRequestSchema);
+export { ItemRequestDocument, mongoItemRequest };

package/models/MeetingRoom.ir.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface MeetingRoomDocument extends Document {
+  meetingRoomCode: string;
+  meetingRoomName: string;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const meetingRoomSchema = new Schema<MeetingRoomDocument>({
+  meetingRoomCode: { type: String },
+  meetingRoomName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: null },
+    actionType: { type: String }
+  }]
+});
+
+const mongoMeetingRoom = mongoose.model<MeetingRoomDocument>('ir.Meeting.Rooms', meetingRoomSchema);
+
+export { MeetingRoomDocument, mongoMeetingRoom };

package/models/Member.model.ts

@@ -0,0 +1,201 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+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;
+    isSAPSynced: boolean;
+    lastSyncedOn: Date;       
+}
+
+type barcodeBranch = {
+    barcodeBranchMemberCode: string;
+    barcodeCategoryCode: string;
+    issueDate: Date;
+    isIssued: boolean;
+    countryCodeCode: string;
+    barCode: string;
+    changeDate: Date;
+    validFrom: Date;
+    validTo: Date;
+    registeredDate: Date;
+    remarks: 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;
+}
+
+interface MemberDocument extends Document {
+    memberId: number;
+    memberCode: string;
+    memberName: string;
+    isMemberOfMasterBranch: boolean;
+    taxIdentificationNo: string;
+    vatNo: string;
+    svatNo: string;
+    brNo: string;
+    nicNo: string;
+    webSite: string;
+    generalTelNo: string;
+    generalEmail: string;
+    isTaxRegistered: boolean;
+    conglomerateAddress: ConglomerateAddress,
+    isMemberContactSynced: boolean,
+    memberContactSyncedOn: Date,
+    isCreatedInSAP: boolean,   
+    isMemberSyncedWithSAP: boolean,
+    memberSyncedOn: Date,
+    isActive: boolean,
+    memberAssociation: MemberAssociation[],  
+    audit: Audit[];
+}
+
+mongoose.set('strictPopulate', false);
+
+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 },
+    svatNo: { type: String },
+    brNo: { type: String, default: "" },
+    nicNo: { type: String, default: "" },
+    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 }      
+    },
+    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 },
+                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: [
+                {
+                    barcodeBranchMemberCode: {type: String, default: "" },
+                    barcodeCategory: {
+                        type: Schema.Types.ObjectId,
+                        ref: 'Barcode.Categories',
+                    }, 
+                    issueDate: { type: Date, default: null },
+                    isIssued: { type: Boolean, default: true },
+                    country: {
+                        type: Schema.Types.ObjectId,
+                        ref: 'Countries',
+                    },
+                    barCode: { type: String, default: "" },
+                    changeDate: { type: Date, default: null },
+                    validFrom: { type: Date, default: null },
+                    validTo: { type: Date, default: null },
+                    registeredDate: { type: Date, default: null },
+                    remarks: { type: String, default: "" }
+                }
+            ],
+            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}
+        }
+    ],        
+    audit: [
+        {
+            userId: { type: String },
+            auditedOn: { type: Date, default: null },
+            actionType: { type: String }
+        }
+    ]
+});
+
+const mongoMember = mongoose.model<MemberDocument>('Members', memberSchema);
+
+export { MemberDocument, ConglomerateAddress, MemberContactInfo, MemberAssociation, mongoMember };

package/models/MembershipStatus.model.ts

@@ -0,0 +1,24 @@
+import mongoose, { Document, Schema } from 'mongoose';
+import { Audit } from '../interface/Audit.interface';
+
+interface MembershipStatusDocument extends Document {
+  membershipStatusCode: string;
+  membershipStatusName: string;
+  isActive: boolean;
+  audit: Audit[];
+}
+
+const membershipStatusSchema = new Schema<MembershipStatusDocument>({
+  membershipStatusCode: { type: String },
+  membershipStatusName: { type: String },
+  isActive: { type: Boolean, default: true },
+  audit: [{
+    userId: { type: String },
+    auditedOn: { type: Date, default: Date.now() },
+    actionType: { type: String }
+  }]
+});
+
+const mongoMembershipStatus = mongoose.model<MembershipStatusDocument>('Membership.Statuses', membershipStatusSchema);
+
+export { MembershipStatusDocument, mongoMembershipStatus };