payservedb 1.1.4 → 1.1.6

package/index.js

@@ -63,11 +63,8 @@ const models = {
     SMSAfricastalking: require('./src/models/sms_africastalking'),
     SMSMeliora: require('./src/models/sms_meliora'),
     WaterConcentrator:require('./src/models/waterConcentrator'),
-    UnitAsset: require('./src/models/unitasset'),
-    Customer: require('./src/models/customer'),
-    Visitor: require('./src/models/visitor'),
-    Access: require('./src/models/access'),
-    Guard: require('./src/models/guard'),
+    WaterMeterSettings:require('./src/models/waterMeterSetting'),
+    Brian:require('./src/models/brian')
 };
 
 // Function to get models dynamically from a specific database connection

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payservedb",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/models/brian.js

@@ -0,0 +1,6 @@
+const mongoose = require('mongoose');
+const BrianS = mongoose.Schema({
+    name:String
+})
+const Brian = mongoose.model('Brian',BrianS)
+module.exports= Brian

package/src/models/customer.js

@@ -1,132 +1,76 @@
 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
-    },
+const VisitorSchema = new mongoose.Schema({
     firstName: {
         type: String,
-        required: [true, 'First name is required'],
-        trim: true
+        required: 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
+        required: true,
     },
     phoneNumber: {
         type: String,
-        required: [true, 'Phone number is required'],
-        trim: true
+        required: true,
     },
     idNumber: {
         type: String,
-        required: [true, 'ID number is required'],
-        trim: true
-    },
-    nextOfKinName: {
-        type: String,
-        required: [true, 'Next of kin name is required'],
-        trim: true
-    },
-    nextOfKinRelationship: {
-        type: String,
-        required: [true, 'Next of kin relationship is required'],
-        trim: true
+        required: true,
     },
-    nextOfKinContact: {
+    vehicleRegistration: {
         type: String,
-        required: [true, 'Next of kin contact is required'],
-        trim: true
+        required: true,
     },
-    units:[],
-    customerType: {
-        type: String,
-        required: [true, 'customerType is required'],
-        enum: ['home owner', 'tenant'],
-    },
-    residentType: {
-        type: String,
-        required: [true, 'residentType is required'],
-        enum: ['resident', 'non-resident'],
-    },
-    familyMembers: [{
-        name: {
-            type: String,
-            required: [true, 'Family member name is required'],
-            trim: true
-        },
-        phone: {
-            type: String,
-            required: [true, 'Family member phone number is required'],
-            trim: true
+    familyMembers: [
+        {
+            name: {
+                type: String,
+                required: true,
+            },
+            phoneNumber: {
+                type: String,
+                required: true,
+            },
+            relation: {
+                type: String,
+                required: true,
+            },
         },
-        relation: {
-            type: String,
-            required: [true, 'Family member relation is required'],
-            trim: true
-        }
-    }],
-    vehicles: [{
-        name: {
-            type: String,
-            required: [true, 'Vehicle name is required'],
-            trim: true
+    ],
+    staff: [
+        {
+            name: {
+                type: String,
+                required: true,
+            },
+            phoneNumber: {
+                type: String,
+                required: true,
+            },
+            jobRole: {
+                type: String,
+                required: true,
+            },
         },
-        model: {
-            type: String,
-            required: [true, 'Vehicle model is required'],
-            trim: true
+    ],
+    vehicles: [
+        {
+            name: {
+                type: String,
+                required: true,
+            },
+            model: {
+                type: String,
+                required: true,
+            },
+            plateNumber: {
+                type: String,
+                required: true,
+            },
         },
-        plateNumber: {
-            type: String,
-            required: [true, 'Vehicle number is required'],
-            trim: true
-        }
-    }],
-    staff: [{
-        name: {
-            type: String,
-            required: [true, 'Staff member name is required'],
-            trim: true
-        },
-        phone: {
-            type: String,
-            required: [true, 'Staff member phone number is required'],
-            trim: true
-        },
-        job: {
-            type: String,
-            required: [true, 'Staff member name is required'],
-            trim: true
-        }
-    }],
-    isEnabled: { type: Boolean, default: false },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: [true, 'Facility 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);
+const Visitor = mongoose.model('Visitor', VisitorSchema);
 
-module.exports = Customer;
+module.exports = Visitor;

package/src/models/facility.js

@@ -24,11 +24,7 @@ const facilitySchema = new mongoose.Schema({
         type: String,
         trim: false,
         default: null
-    },
-    units: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Unit'  // Reference to the Unit model
-    }]
+    }
   
 }, {
     timestamps: true // Automatically add createdAt and updatedAt fields

package/src/models/units.js

@@ -6,52 +6,44 @@ const unitSchema = new mongoose.Schema({
         type: String,
         required: true
     },
-    unitType: {
-        type: String,
-        required: true
+    unitType:{
+        type:String,
+        required:true
     },
-    division: {
-        type: String,
-        required: true
+    division:{
+        type:String,
+        required:true
     },
-    floorUnitNo: {
-        type: String,
-        required: true
+    floorUnitNo:{
+        type:String,
+        required:true
     },
-    lettableFloorArea: {
-        type: String,
-        required: false
+    lettableFloorArea:{
+        type:String,
+        required:false
     },
-    landRateNumber: {
-        type: String,
-        required: false
+    landRateNumber:{
+        type:String,
+        required:false
     },
-    grossArea: {
-        type: Number,
-        required: false
+    grossArea:{
+        type:Number,
+        required:false
     },
-    netLettableArea: {
-        type: Number,
-        required: false
+    netLettableArea:{
+        type:Number,
+        required:false
     },
-    status: {
-        type: String,
-        required: true
+    status:{
+        type:String,
+        required:true
     },
-    facilityId: {
+    facilityId:{
         type: mongoose.Schema.Types.ObjectId,
         ref: 'Facility',
-    },
-    homeOwnerId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Customer',
-    },
-    tenantId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Customer',
     }
-
-
+   
+  
 }, {
     timestamps: true // Automatically add createdAt and updatedAt fields
 });

package/src/models/waterMeterSetting.js

@@ -0,0 +1,25 @@
+const mongoose = require('mongoose');
+
+const waterMeterSettingsSchema = mongoose.Schema({
+    manufacturers: {
+        type: [String],
+        required: false
+    },
+    meterSizes: {
+        type: [String],
+        required: false
+    }
+});
+
+// Middleware to ensure only one record exists
+waterMeterSettingsSchema.pre('save', async function (next) {
+    const existingSettings = await WaterMeterSettings.findOne();
+    if (existingSettings && !existingSettings._id.equals(this._id)) {
+        throw new Error('Only one water meter settings record is allowed.');
+    }
+    next();
+});
+
+const WaterMeterSettings = mongoose.model("WaterMeterSettings", waterMeterSettingsSchema);
+
+module.exports = WaterMeterSettings;

package/src/models/access.js

@@ -1,38 +0,0 @@
-const mongoose = require('mongoose');
-
-// Define the schema for customers
-const accessSchema = new mongoose.Schema({
-    name: {
-        type: String,
-        required: [true, 'Name is required'],
-        trim: true
-    },
-    location: {
-        type: String,
-        required: [true, 'Location is required'],
-        trim: true
-    },
-    purpose: {
-        type: String,
-        required: [true, 'Purpose is required'],
-        trim: true
-    },
-    disabled: {
-        type: Boolean,
-        default: false,
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    },
-}, {
-    timestamps: true // Automatically add createdAt and updatedAt fields
-});
-
-// Indexes for improved performance
-accessSchema.index({ name: 1 });
-
-// Compile the model from the schema
-const Access = mongoose.model('Access', accessSchema);
-
-module.exports = Access;

package/src/models/contract.js

@@ -1,39 +0,0 @@
-const mongoose = require('mongoose');
-
-// Define the schema for customers
-const contractSchema = new mongoose.Schema({
-    contractName: {
-        type: String,
-        required: [true, 'Contract Name is required'],
-        trim: true
-    },
-    contractPhoneNumber: {
-        type: String,
-        required: [true, 'Phone number is required'],
-        trim: true
-    },
-    contractStart: {
-        type: String,
-        required: [true, 'Start date is required'],
-        trim: true
-    },
-    contractEnd: {
-        type: String,
-        required: [true, 'Contract end date is required'],
-        trim: true
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    },
-}, {
-    timestamps: true // Automatically add createdAt and updatedAt fields
-});
-
-// Indexes for improved performance
-contractSchema.index({ name: 1 });
-
-// Compile the model from the schema
-const Contract = mongoose.model('Contract', contractSchema);
-
-module.exports = Contract;

package/src/models/guard.js

@@ -1,54 +0,0 @@
-const mongoose = require('mongoose');
-
-// Define the schema for customers
-const guardSchema = new mongoose.Schema({
-    firstName: {
-        type: String,
-        required: [true, 'First name is required'],
-        trim: true
-    },
-    lastName: {
-        type: String,
-        required: [true, 'Last name is required'],
-        trim: true
-    },
-    phoneNumber: {
-        type: String,
-        required: [true, 'Phone number is required'],
-        trim: true
-    },
-    entryPoint: {
-        type: mongoose.Schema.Types.ObjectId,
-        required: [true, 'Entry point is required'],
-        trim: true,
-        ref: 'Access'
-    },
-    startTime: {
-        type: String,
-        required: [true, 'Start time is required'],
-        trim: true
-    },
-    endTime: {
-        type: String,
-        required: [true, 'End time is required'],
-        trim: true
-    },
-    disabled: {
-        type: Boolean,
-        default: false,
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    },
-}, {
-    timestamps: true // Automatically add createdAt and updatedAt fields
-});
-
-// Indexes for improved performance
-guardSchema.index({ firstName: 1 });
-
-// Compile the model from the schema
-const Guard = mongoose.model('Guard', guardSchema);
-
-module.exports = Guard;

package/src/models/levy.js

@@ -1,49 +0,0 @@
-const mongoose = require('mongoose');
-
-// Define the schema for customers
-const levySchema = new mongoose.Schema({
-    levyName: {
-        type: String,
-        required: [true, 'Levy Name is required'],
-        trim: true
-    },
-    levyType: {
-        type: String,
-        required: [true, 'Levy type is required'],
-        trim: true
-    },
-    levyApplicant: {
-        type: String,
-        required: [true, 'Levy Applicant is required'],
-        trim: true
-    },
-    collectionFrequency: {
-        type: String,
-        required: [true, 'Collection frequency is required'],
-        trim: true
-    },
-    invoiceDate: {
-        type: String,
-        required: [true, 'Date is required'],
-        trim: true
-    },
-    amount: {
-        type: String,
-        required: [true, 'Amount is required'],
-        trim: true
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    },
-}, {
-    timestamps: true // Automatically add createdAt and updatedAt fields
-});
-
-// Indexes for improved performance
-levySchema.index({ name: 1 });
-
-// Compile the model from the schema
-const Levy = mongoose.model('Levy', levySchema);
-
-module.exports = Levy;

package/src/models/unitasset.js

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

package/src/models/visitor.js

@@ -1,73 +0,0 @@
-const mongoose = require('mongoose');
-
-// Define the schema for customers
-const visitorSchema = new mongoose.Schema({
-    firstName: {
-        type: String,
-        required: [true, 'First name is required'],
-        trim: true
-    },
-    lastName: {
-        type: String,
-        required: [true, 'Last name is required'],
-        trim: true
-    },
-    phoneNumber: {
-        type: String,
-        required: [true, 'Phone number is required'],
-        trim: true
-    },
-    idNumber: {
-        type: String,
-        required: [true, 'ID number is required'],
-        trim: true
-    },
-    carRegistration: {
-        type: String,
-        trim: true
-    },
-    carMake: {
-        type: String,
-        trim: true
-    },
-    carOccupants: {
-        type: String,
-        trim: true
-    },
-    carColor: {
-        type: String,
-        trim: true
-    },
-    visitorType: {
-        type: String,
-        trim: true
-    },
-    entryPoint: {
-        type: String,
-        trim: true
-    },
-    houseNumber: {
-        type: String,
-        trim: true
-    },
-    resident: {
-        type: mongoose.Schema.Types.ObjectId,
-        required: [true, 'Resident is required'],
-        trim: true,
-        ref: 'Customer',
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    },
-}, {
-    timestamps: true // Automatically add createdAt and updatedAt fields
-});
-
-// Indexes for improved performance
-visitorSchema.index({ fullName: 1 });
-
-// Compile the model from the schema
-const Visitor = mongoose.model('Visitor', visitorSchema);
-
-module.exports = Visitor;