payservedb 1.0.0

package/index.js

@@ -0,0 +1,78 @@
+const mongoose = require('mongoose');
+const SMSAfricastalking = require('./src/models/sms_africastalking');
+
+// Maintain a record of open connections for each database
+const connections = {};
+const url = '127.0.0.1';
+const source = ''
+
+// Utility function to connect to MongoDB
+async function connectToMongoDB(dbName) {
+    try {
+        const connectionString = `mongodb://${url}/${dbName}${source}`;
+        await mongoose.connect(connectionString, {
+            useNewUrlParser: true,
+            useUnifiedTopology: true,
+        });
+        console.log('Connected to MongoDB');
+    } catch (err) {
+        console.error('Error connecting to MongoDB:', err);
+        throw err;
+    }
+}
+
+// Function to switch databases dynamically
+async function switchDB(dbName) {
+    // Check if there's already a connection to the desired database
+    if (connections[dbName]) {
+        return connections[dbName]; // Return existing connection
+    }
+    try {
+        const connectionString = `mongodb://${url}/${dbName}${source}`;
+        const dbConnection = await mongoose.createConnection(connectionString, {
+            useNewUrlParser: true,
+            useUnifiedTopology: true,
+        });
+        connections[dbName] = dbConnection; // Store the connection for reuse
+        console.log(`Switched to database: ${dbName}`);
+        return dbConnection;
+    } catch (err) {
+        console.error(`Error switching to database: ${dbName}`, err);
+        throw err;
+    }
+}
+
+// Importing all model files (Note: models may need to be re-registered for different connections)
+const models = {
+    User: require('./src/models/user'),
+    AuditLog: require('./src/models/auditlog'),
+    Company: require('./src/models/company'),
+    Email: require('./src/models/email'),
+    Module: require('./src/models/module'),
+    Facility: require('./src/models/facility'),
+    RefreshToken: require('./src/models/refresh_token'),
+    ApiLog: require('./src/models/apilog'),
+    ArchivedApiLog: require('./src/models/archivedapilog'),
+    ArchivedAuditLog: require('./src/models/archivedauditlog'),
+    FacilityAsset: require('./src/models/facilityasset'),
+    Unit: require('./src/models/units'),
+    CombinedUnit: require('./src/models/combinedUnits'),
+    Message: require('./src/models/message'),
+    SMSAfricastalking: require('./src/models/sms_africastalking'),
+    SMSMeliora: require('./src/models/sms_meliora')
+};
+
+// Function to get models dynamically from a specific database connection
+async function getModelFromDB(dbConnection, modelName, schema) {
+    if (!dbConnection.models[modelName]) {
+        return dbConnection.model(modelName, schema); // Register the model in the db connection
+    }
+    return dbConnection.models[modelName]; // Return existing model if already registered
+}
+
+module.exports = {
+    connectToMongoDB,
+    switchDB,
+    getModelFromDB,
+    ...models // Spread operator to export all models
+};

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "payservedb",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "mongoose": "^8.3.5"
+  }
+}

package/src/models/apilog.js

@@ -0,0 +1,18 @@
+// models/apiLog.js
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+
+const apiLogSchema = new Schema({
+    url: { type: String, required: true, index: true },
+    method: { type: String, required: true, enum: ['GET', 'POST', 'PUT', 'DELETE'], index: true },
+    duration: { type: Number, required: true },
+    time: { type: Date, default: Date.now, required: true, index: true },
+    date: { type: String, required: true, index: true },
+});
+
+
+apiLogSchema.index({ time: 1 }, { expireAfterSeconds: 60 * 60 * 24 * 365 });
+
+const ApiLog = mongoose.model('ApiLog', apiLogSchema);
+
+module.exports = ApiLog;

package/src/models/archivedapilog.js

@@ -0,0 +1,18 @@
+
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+
+const ArchivedApiLogSchema = new Schema({
+    url: { type: String, required: true, index: true },
+    method: { type: String, required: true, enum: ['GET', 'POST', 'PUT', 'DELETE'], index: true },
+    duration: { type: Number, required: true },
+    time: { type: Date, default: Date.now, required: true, index: true },
+    date: { type: String, required: true, index: true },
+});
+
+
+ArchivedApiLogSchema.index({ time: 1 }, { expireAfterSeconds: 60 * 60 * 24 * 365 });
+
+const ArchivedApiLog = mongoose.model('ArchivedApiLog', ArchivedApiLogSchema);
+
+module.exports = ArchivedApiLog;

package/src/models/archivedauditlog.js

@@ -0,0 +1,83 @@
+const mongoose = require('mongoose');
+
+const ArchivedAuditLogSchema = new mongoose.Schema({
+    action: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    page: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Company',
+        required: true
+    },
+    userInfo: {
+        type: mongoose.Schema.Types.Mixed,
+        required: true
+    },
+    projectId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Project',
+        required: true
+    },
+    projectInfo: {
+        type: mongoose.Schema.Types.Mixed,
+        required: true
+    },
+    computerName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    browser: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    ipAddress: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    time: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    date: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    createdOn: {
+        type: Date,
+        default: Date.now,
+        required: true
+    },
+    oldData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    },
+    newData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    },
+    deletedData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    }
+}, {
+    timestamps: true 
+});
+
+ArchivedAuditLogSchema.index({ userId: 1, projectId: 1, createdOn: -1 });
+ArchivedAuditLogSchema.index({ action: 1 });
+ArchivedAuditLogSchema.index({ page: 1 });
+const ArchivedAuditLog = mongoose.model('ArchivedAuditLog', ArchivedAuditLogSchema);
+
+module.exports = ArchivedAuditLog;

package/src/models/auditlog.js

@@ -0,0 +1,83 @@
+const mongoose = require('mongoose');
+
+const auditLogSchema = new mongoose.Schema({
+    action: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    page: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    userId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Company',
+        required: true
+    },
+    userInfo: {
+        type: mongoose.Schema.Types.Mixed,
+        required: true
+    },
+    projectId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Project',
+        required: true
+    },
+    projectInfo: {
+        type: mongoose.Schema.Types.Mixed,
+        required: true
+    },
+    computerName: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    browser: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    ipAddress: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    time: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    date: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    createdOn: {
+        type: Date,
+        default: Date.now,
+        required: true
+    },
+    oldData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    },
+    newData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    },
+    deletedData: {
+        type: mongoose.Schema.Types.Mixed,
+        default: {}
+    }
+}, {
+    timestamps: true 
+});
+
+auditLogSchema.index({ userId: 1, projectId: 1, createdOn: -1 });
+auditLogSchema.index({ action: 1 });
+auditLogSchema.index({ page: 1 });
+const AuditLog = mongoose.model('AuditLog', auditLogSchema);
+
+module.exports = AuditLog;

package/src/models/combinedUnits.js

@@ -0,0 +1,62 @@
+const mongoose = require('mongoose');
+
+// Define the schema for companies
+const combinedUnitSchema = new mongoose.Schema({
+    combinedUnitName: {
+        type: String,
+        required: true
+    },
+    combinedDivision:{
+        type:String,
+        required:true
+    },
+    combinedUnitType:{
+        type:String,
+        required:true
+    },
+    combinedFloorUnit:{
+        type:String,
+        required:true
+    },
+    combinedLettableFloorArea:{
+        type:String,
+        required:false
+    },
+    combinedLRNumber:{
+        type:String,
+        required:true
+    },
+    combinedGrossArea:{
+        type:Number,
+        required:false
+    },
+    combinedNetLettableArea:{
+        type:Number,
+        required:false
+    },
+    combinedReason:{
+        type:String,
+        required:false
+    },
+    status:{
+        type:String,
+        required:true
+    },
+    selectedCombinedUnits:[],
+    facilityId:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+    }
+   
+  
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+combinedUnitSchema.index({ name: 1 });
+
+// Compile the model from the schema
+const CombinedUnit = mongoose.model('CombinedUnit', combinedUnitSchema);
+
+module.exports = CombinedUnit;

package/src/models/company.js

@@ -0,0 +1,52 @@
+const mongoose = require('mongoose');
+
+// Define the schema for companies
+const companySchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: [true, 'Company name is required'],
+        trim: true,
+        minlength: [1, 'Company name must be at least 1 character long']
+    },
+    address: {
+        type: String,
+        required: false
+    },
+    country: { type: String, required: false },
+    email: { type: String, required: true },
+    city: { type: String, required: true },
+    registrationNumber:{ type: String, required: true },
+    companyTaxNumber:{type:String,required:true},
+    logo: {
+        type: String,
+        trim: false,
+        default: null
+    },
+    isEnabled: { type: Boolean, default: false },
+    kyc: {
+        taxCertificate: {
+            type: String
+        },
+        Id: {
+            type: String
+        },
+        companyCertificate: {
+            type: String
+        }
+    },
+
+    facilities: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility'
+    }]
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+companySchema.index({ name: 1 });
+
+// Compile the model from the schema
+const Company = mongoose.model('Company', companySchema);
+
+module.exports = Company;

package/src/models/customer.js

@@ -0,0 +1,54 @@
+const mongoose = require('mongoose');
+
+// Define the schema for customers
+const customerSchema = new mongoose.Schema({
+    customerNumber: {
+        type: Number,
+        required: [true, 'Customer number is required'],
+        unique: true // Ensure customer number is unique
+    },
+    firstName: {
+        type: String,
+        required: [true, 'First name is required'],
+        trim: true
+    },
+    lastName: {
+        type: String,
+        required: [true, 'Last name is required'],
+        trim: true
+    },
+    email: {
+        type: String,
+        required: [true, 'Email is required'],
+        unique: true, // Ensure email uniqueness for data integrity
+        lowercase: true, // Normalize email to lowercase
+        trim: true,
+        match: [/\S+@\S+\.\S+/, 'Email format is invalid'] // Validate email format
+    },
+    phoneNumber: {
+        type: String,
+        required: [true, 'Phone number is required'],
+        trim: true
+    },
+    type: {
+        type: String,
+        required: [true, 'Type is required'],
+        enum: ['Tenant', 'Home Owner'],
+    },
+    projectId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Project',
+        required: [true, 'Project ID is required']
+    }
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+customerSchema.index({ email: 1 });
+customerSchema.index({ customerNumber: 1 });
+
+// Compile the model from the schema
+const Customer = mongoose.model('Customer', customerSchema);
+
+module.exports = Customer;

package/src/models/email.js

@@ -0,0 +1,25 @@
+const mongoose = require('mongoose');
+const EmailSchema = mongoose.Schema({
+    user: {
+        type: String,
+        required: true
+    },
+    from: {
+        type: String,
+        required: true
+    },
+    host: {
+        type: String,
+        required: true
+    },
+    port: {
+        type: Number,
+        required: true
+    },
+    auth: {
+        user: String,
+        pass: String
+    }
+})
+const Email = mongoose.model('Email', EmailSchema);
+module.exports = Email

package/src/models/facility.js

@@ -0,0 +1,39 @@
+const mongoose = require('mongoose');
+
+// Define the schema for companies
+const facilitySchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: [true, 'Facility name is required'],
+        trim: true,
+        minlength: [1, 'Facility name must be at least 1 character long']
+    },
+    location:{
+        type:String,
+        required:true
+    },
+    subDivision:{type:String,required:true},
+    isEnabled:{type:Boolean,required:true},
+    divisionArray:[],
+    landReferenceNumbers:[],
+    defaultMeasurement:{type:String,required:false},
+    totalCommonArea:{type:String,required:false},
+    totalLettableArea:{type:String,required:false},
+
+    logo: {
+        type: String,
+        trim: false,
+        default: null
+    }
+  
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+facilitySchema.index({ name: 1 });
+
+// Compile the model from the schema
+const Facility = mongoose.model('Facility', facilitySchema);
+
+module.exports = Facility;

package/src/models/facilityasset.js

@@ -0,0 +1,25 @@
+const mongoose = require('mongoose');
+
+// Define the schema for companies
+const facilityassetSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required:true
+    },
+    facilityId:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+    }
+
+  
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+facilityassetSchema.index({ name: 1 });
+
+// Compile the model from the schema
+const FacilityAsset = mongoose.model('FacilityAsset', facilityassetSchema);
+
+module.exports = FacilityAsset;

package/src/models/message.js

@@ -0,0 +1,39 @@
+const mongoose = require('mongoose');
+const MessageSchema = mongoose.Schema({
+    type: {
+        type: String,
+        required: true
+    },
+    recipient: {
+        type: String,
+        required: true,
+    },
+    subject: {
+        type: String,
+        required: false
+    },
+    body: {
+        type: String,
+        required: true
+    },
+    sentOn: {
+        type: Date,
+        required: false
+    },
+    createdOn:{
+        type:Date,
+        required:true
+    },
+    status: {
+        type: String,
+        required: true,
+        enum: ['Not Sent', 'In Queue', 'Sent']
+    },
+    messageId: {
+        type: String,
+        required: false
+    }
+
+})
+const Message = mongoose.model('Message', MessageSchema);
+module.exports = Message

package/src/models/module.js

@@ -0,0 +1,21 @@
+const mongoose = require('mongoose');
+
+// Define the schema for modules
+const moduleSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: [true, 'Module name is required'],
+        trim: true,
+        unique: true // Ensure module name is unique
+    }
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+moduleSchema.index({ name: 1 });
+
+// Compile the model from the schema
+const Module = mongoose.model('Module', moduleSchema);
+
+module.exports = Module;

package/src/models/refresh_token.js

@@ -0,0 +1,23 @@
+const mongoose = require('mongoose');
+
+const refreshTokenSchema = new mongoose.Schema({
+    userId: {
+        type: String,
+        required: true,
+        index: true, // Index for faster lookup by userId
+    },
+    token: {
+        type: String,
+        required: true,
+    },
+    createdAt: {
+        type: Date,
+        required: true,
+        default: Date.now,
+        expires: '30d', // Example: Token expires after 30 days
+    },
+},{timestamps: true});
+
+const RefreshToken = mongoose.model('RefreshToken', refreshTokenSchema);
+
+module.exports = RefreshToken;

package/src/models/sms_africastalking.js

@@ -0,0 +1,21 @@
+const mongoose = require('mongoose');
+const SMSAfricastalkingSchema = mongoose.Schema({
+    user: {
+        type: String,
+        required: true
+    },
+    senderId: {
+        type: String,
+        required: true
+    },
+    userName: {
+        type: String,
+        required: true,
+    },
+    apiKey: {
+        type: String,
+        required: true
+    }
+})
+const SMSAfricastalking = mongoose.model('SMSAfricastalking', SMSAfricastalkingSchema);
+module.exports = SMSAfricastalking

package/src/models/sms_meliora.js

@@ -0,0 +1,17 @@
+const mongoose = require('mongoose');
+const SMSMelioraSchema = mongoose.Schema({
+    user: {
+        type: String,
+        required: true
+    },
+    senderId: {
+        type: String,
+        required: true
+    },
+    apiKey: {
+        type: String,
+        required: true
+    }
+})
+const SMSMeliora = mongoose.model('SMSMeliora', SMSMelioraSchema);
+module.exports = SMSMeliora

package/src/models/units.js

@@ -0,0 +1,57 @@
+const mongoose = require('mongoose');
+
+// Define the schema for companies
+const unitSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    unitType:{
+        type:String,
+        required:true
+    },
+    division:{
+        type:String,
+        required:true
+    },
+    floorUnitNo:{
+        type:String,
+        required:true
+    },
+    lettableFloorArea:{
+        type:String,
+        required:false
+    },
+    landRateNumber:{
+        type:String,
+        required:false
+    },
+    grossArea:{
+        type:Number,
+        required:false
+    },
+    netLettableArea:{
+        type:Number,
+        required:false
+    },
+    status:{
+        type:String,
+        required:true
+    },
+    facilityId:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+    }
+   
+  
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+unitSchema.index({ name: 1 });
+
+// Compile the model from the schema
+const Unit = mongoose.model('Unit', unitSchema);
+
+module.exports = Unit;

package/src/models/user.js

@@ -0,0 +1,59 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+    fullName: {
+        type: String,
+        required: [true, 'Full name is required'],
+        trim: true,
+    },
+    email: {
+        type: String,
+        required: [true, 'Email is required'],
+        unique: true,
+        lowercase: true,
+        trim: true,
+    },
+    phoneNumber: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    idNumber:{
+        type:String,
+        required:false
+    },
+    type: {
+        type: String,
+        required: [true, 'Type is required'],
+        enum: ['Company', 'Project Manager', 'Universal', 'Core', 'Customer'],
+    },
+    role: {
+        type: String,
+        required: [true, 'Role is required'],
+        enum: ['admin', 'editor', 'user'],
+    },
+    kyc:{
+    
+        Id:{
+            type:String
+        }
+    },
+    companies: [{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Company',
+    }],
+    password: {
+        type: String,
+        required: [true, 'Password is required'],
+        minlength: 8,
+    },
+}, {
+    timestamps: true, // Automatically add createdAt and updatedAt fields
+});
+
+
+userSchema.index({ fullName: 'text', email: 'text' });
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = User;