payservedb 3.1.5 → 3.1.7

package/index.js

@@ -91,7 +91,6 @@ const models = {
     Resident:require('./src/models/resident'),
     Asset:require('./src/models/asset'),
     DutyRoster:require('./src/models/dutyroster'),
-    Lease:require('./src/models/lease'),
     LeaseTemplate:require('./src/models/leasetemplate'),
     Report:require('./src/models/report'),
     Ticket:require('./src/models/tickets'),
@@ -108,12 +107,8 @@ const models = {
     ServiceRequest:require('./src/models/servicerequest'),
     CountryTaxRate:require('./src/models/country_tax'),
     Meter:require('./src/models/water_meter'),
-    Concentrator:require('./src/models/water_meters_concentrator'),
-    HandoverChecklist:require('./src/models/handover_checklist'),
-    HandoverNotification:require('./src/models/handover_notification'),
-    HandoverSchedule:require('./src/models/handover_schedule'),
-    Handover:require('./src/models/handover'),
-    WelcomePack:require('./src/models/welcome_pack')
+    Concentrator:require('./src/models/water_meter_concentrator'),
+    Handover:require('./src/models/handover')
    
     
 };

package/package.json

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

package/src/models/handover.js

@@ -1,144 +1,144 @@
-const mongoose = require('mongoose');
+const mongoose = require("mongoose");
 
+// Schema for Handover Checklist Items
+const checklistItemSchema = new mongoose.Schema({
+  itemName: {
+    type: String,
+    required: true,
+  },
+  category: {
+    type: String,
+    required: true,
+    enum: ["Appliances", "Furniture", "Electronics", "Utilities", "Structure", "Other"]
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ["Working", "Not Working"]
+  },
+  notes: {
+    type: String,
+    default: ""
+  },
+  photos: [{
+    url: String,
+    uploadedAt: Date
+  }]
+}, {
+  timestamps: true
+});
+
+// Main Handover Schema
 const handoverSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
+  // Basic Information
+  handoverType: {
+    type: String,
+    required: true,
+    enum: ["Move-In", "Move-Out"]
+  },
+  company: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Company",
+    required: true
+  },
+  facility: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Facility",
+    required: true
+  },
+  unit: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Unit",
+    required: true
+  },
+  tenant: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Customer",
+    required: true
+  },
+  landlord: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Customer",
+    required: true
+  },
+  lease: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "LeaseAgreement",
+    required: true
+  },
+  propertyManager: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "User",
+    required: true
+  },
+
+  // Handover Details
+  scheduledDate: {
+    type: Date,
+    required: true
+  },
+  actualHandoverDate: {
+    type: Date
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ["Pending", "In Progress", "Completed", "Cancelled"],
+    default: "Pending"
+  },
+
+  // Checklist Items
+  checklistItems: [checklistItemSchema],
+
+  // Utility Readings
+  utilityReadings: {
+    electricity: {
+      meterNumber: String,
+      reading: Number,
+      photo: String
     },
-    unitNumber: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Unit',
-        required: true
+    water: {
+      meterNumber: String,
+      reading: Number,
+      photo: String
     },
+    gas: {
+      meterNumber: String,
+      reading: Number,
+      photo: String
+    }
+  },
+
+  // Documents (Optional)
+  documents: [{
     type: {
-        type: String,
-        enum: ['Initial', 'MoveOut'],
-        required: true
-    },
-    tenant: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Customer',
-        required: true
-    },
-    status: {
-        type: String,
-        enum: ['Pending', 'InProgress', 'Completed', 'Cancelled'],
-        default: 'Pending'
+      type: String,
+      enum: ["Welcome Pack", "User Manual", "Inspection Report", "Utility Transfer", "Other"]
     },
-    startDate: {
-        type: Date,
-        required: true
-    },
-    completionDate: {
-        type: Date
-    },
-    preHandoverInspection: {
-        scheduled: { type: Date },
-        completed: { type: Date },
-        inspector: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-        status: { 
-            type: String, 
-            enum: ['Pending', 'Scheduled', 'Completed'],
-            default: 'Pending'
-        },
-        checklist: { type: mongoose.Schema.Types.ObjectId, ref: 'HandoverChecklist' }
-    },
-    finalInspection: {
-        scheduled: { type: Date },
-        completed: { type: Date },
-        inspector: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-        status: { 
-            type: String, 
-            enum: ['Pending', 'Scheduled', 'Completed'],
-            default: 'Pending'
-        },
-        checklist: { type: mongoose.Schema.Types.ObjectId, ref: 'HandoverChecklist' }
-    },
-    utilities: [{
-        type: { type: String, enum: ['Water', 'Electricity', 'Gas', 'Internet'] },
-        meterNumber: String,
-        initialReading: Number,
-        finalReading: Number,
-        transferStatus: { 
-            type: String, 
-            enum: ['Pending', 'InProgress', 'Completed'],
-            default: 'Pending'
-        },
-        transferDate: Date
-    }],
-    securityDeposit: {
-        amount: { type: Number },
-        deductions: [{
-            reason: String,
-            amount: Number,
-            description: String
-        }],
-        refundAmount: { type: Number },
-        refundStatus: { 
-            type: String, 
-            enum: ['Pending', 'Processed', 'Completed'],
-            default: 'Pending'
-        },
-        refundDate: Date
-    },
-    documents: [{
-        type: { 
-            type: String, 
-            enum: ['Inspection', 'Utility', 'Welcome', 'Handover', 'Other']
-        },
-        title: String,
-        fileName: String,
-        fileUrl: String,
-        uploadedAt: { type: Date, default: Date.now }
-    }],
-    welcomePack: {
-        status: { 
-            type: String, 
-            enum: ['Pending', 'Prepared', 'Delivered'],
-            default: 'Pending'
-        },
-        deliveredDate: Date,
-        contents: [{
-            itemType: String,
-            description: String,
-            quantity: Number
-        }]
-    },
-    feedback: {
-        submitted: { type: Boolean, default: false },
-        submissionDate: Date,
-        ratings: {
-            overallExperience: { type: Number, min: 1, max: 5 },
-            processEfficiency: { type: Number, min: 1, max: 5 },
-            staffProfessionalism: { type: Number, min: 1, max: 5 }
-        },
-        comments: String
+    name: String,
+    url: String,
+    uploadedAt: Date
+  }],
+
+  // Feedback (for Move-Out)
+  feedback: {
+    rating: {
+      type: Number,
+      min: 1,
+      max: 5
     },
-    maintenanceRequests: [{
-        type: { type: String },
-        description: String,
-        status: { 
-            type: String, 
-            enum: ['Pending', 'Scheduled', 'InProgress', 'Completed'],
-            default: 'Pending'
-        },
-        scheduledDate: Date,
-        completionDate: Date,
-        cost: Number
-    }],
-    notes: [{
-        content: String,
-        addedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-        addedAt: { type: Date, default: Date.now }
-    }],
-    createdBy: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User'
-    }
+    comments: String,
+    submittedAt: Date
+  },
+
+  // Additional Notes
+  notes: {
+    type: String
+  }
 }, {
-    timestamps: true
+  timestamps: true
 });
-const Handover = mongoose.model('Handover', handoverSchema);
+
+const Handover = mongoose.model("Handover", handoverSchema);
 
 module.exports = Handover;

package/src/models/servicerequest.js

@@ -20,7 +20,7 @@ const serviceRequestSchema = new mongoose.Schema({
     status: {
         type: String,
         required: true,
-        enum: ['Pending', 'In Progress', 'Completed', 'Cancelled'],
+        enum: ['Pending', 'Awaiting', 'In Progress', 'Completed', 'Cancelled'],
     },
     customerId: {
         type: mongoose.Schema.Types.ObjectId,

package/src/models/handover_checklist.js

@@ -1,73 +0,0 @@
-const mongoose = require('mongoose');
-
-const handoverChecklistSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    type: {
-        type: String,
-        enum: ['PreHandover', 'MoveOut', 'FinalInspection'],
-        required: true
-    },
-    sections: [{
-        name: { type: String, required: true },
-        items: [{
-            itemName: { type: String, required: true },
-            condition: {
-                type: String,
-                enum: ['Excellent', 'Good', 'Fair', 'Poor', 'Damaged', 'Missing', 'NA']
-            },
-            photos: [{
-                url: String,
-                description: String,
-                uploadedAt: { type: Date, default: Date.now }
-            }],
-            notes: String,
-            actionRequired: {
-                type: Boolean,
-                default: false
-            },
-            actionDetails: {
-                description: String,
-                estimatedCost: Number,
-                deadline: Date,
-                status: {
-                    type: String,
-                    enum: ['Pending', 'InProgress', 'Completed'],
-                    default: 'Pending'
-                }
-            }
-        }]
-    }],
-    completedBy: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User'
-    },
-    signoffs: [{
-        role: {
-            type: String,
-            enum: ['Inspector', 'Tenant', 'PropertyManager'],
-            required: true
-        },
-        user: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User'
-        },
-        signature: String,
-        signedAt: Date,
-        comments: String
-    }],
-    status: {
-        type: String,
-        enum: ['Draft', 'InProgress', 'Completed', 'Rejected'],
-        default: 'Draft'
-    }
-}, {
-    timestamps: true
-});
-
-const HandoverChecklist = mongoose.model('HandoverChecklist', handoverChecklistSchema);
-
-module.exports = HandoverChecklist;

package/src/models/handover_notification.js

@@ -1,119 +0,0 @@
-const mongoose = require('mongoose');
-
-const handoverNotificationSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    handoverId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Handover',
-        required: true
-    },
-    tenant: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Customer',
-        required: true
-    },
-    type: {
-        type: String,
-        enum: ['MoveOutNotice', 'InspectionSchedule', 'DocumentRequest', 'WelcomePackReady', 'UtilityTransfer'],
-        required: true
-    },
-    noticeDate: {
-        type: Date,
-        required: true
-    },
-    plannedMoveOutDate: Date,
-    // Reference to main Notification schema
-    notifications: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Notification'
-    }],
-    // Reference to main Reminder schema
-    reminders: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Reminder'
-    }],
-    status: {
-        type: String,
-        enum: ['Pending', 'InProgress', 'Completed', 'Cancelled'],
-        default: 'Pending'
-    },
-    acknowledgement: {
-        acknowledgedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-        acknowledgedAt: Date,
-        comments: String
-    },
-    notificationConfig: {
-        methods: [{
-            type: String,
-            enum: ['Email', 'SMS', 'System', 'Letter'],
-            required: true
-        }],
-        reminderFrequency: {
-            type: String,
-            enum: ['daily', 'weekly', 'biweekly', 'monthly'],
-            required: true
-        },
-        messageTemplate: {
-            type: String,
-            required: true
-        }
-    }
-}, {
-    timestamps: true
-});
-
-// Pre-save middleware to create notifications and reminders
-handoverNotificationSchema.pre('save', async function(next) {
-    if (this.isNew) {
-        try {
-            // Create base notification
-            const notification = new Notification({
-                userId: this.tenant,
-                message: this.notificationConfig.messageTemplate,
-                dateSent: new Date()
-            });
-            await notification.save();
-            this.notifications.push(notification._id);
-
-            // Create reminder
-            const reminder = new Reminder({
-                name: `Handover_${this.type}_${this.handoverId}`,
-                type: 'recurring',
-                frequency: this.notificationConfig.reminderFrequency,
-                time: '09:00', // Default time
-                module: 'Handover',
-                isActive: true,
-                notificationTypes: this.notificationConfig.methods,
-                message: this.notificationConfig.messageTemplate,
-                facilityId: this.facilityId
-            });
-            await reminder.save();
-            this.reminders.push(reminder._id);
-
-            next();
-        } catch (error) {
-            next(error);
-        }
-    } else {
-        next();
-    }
-});
-
-// Clean up related notifications and reminders when deleted
-handoverNotificationSchema.pre('remove', async function(next) {
-    try {
-        await Notification.deleteMany({ _id: { $in: this.notifications } });
-        await Reminder.deleteMany({ _id: { $in: this.reminders } });
-        next();
-    } catch (error) {
-        next(error);
-    }
-});
-
-const HandoverNotification = mongoose.model('HandoverNotification', handoverNotificationSchema);
-
-module.exports = HandoverNotification;

package/src/models/handover_schedule.js

@@ -1,71 +0,0 @@
-const mongoose = require('mongoose');
-
-const handoverScheduleSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    handoverId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Handover',
-        required: true
-    },
-    inspectionType: {
-        type: String,
-        enum: ['PreHandover', 'MoveOut', 'Final'],
-        required: true
-    },
-    scheduledDate: {
-        type: Date,
-        required: true
-    },
-    duration: {
-        type: Number,  // in minutes
-        required: true
-    },
-    inspector: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User',
-        required: true
-    },
-    participants: [{
-        role: {
-            type: String,
-            enum: ['Tenant', 'PropertyManager', 'Contractor', 'Other'],
-            required: true
-        },
-        user: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
-        confirmed: { type: Boolean, default: false },
-        confirmationDate: Date
-    }],
-    status: {
-        type: String,
-        enum: ['Scheduled', 'Confirmed', 'InProgress', 'Completed', 'Cancelled', 'Rescheduled'],
-        default: 'Scheduled'
-    },
-    rescheduledFrom: {
-        date: Date,
-        reason: String
-    },
-    checklist: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'HandoverChecklist'
-    },
-    notes: String,
-    reminders: [{
-        recipientType: {
-            type: String,
-            enum: ['Inspector', 'Tenant', 'PropertyManager', 'All']
-        },
-        scheduledTime: Date,
-        sent: { type: Boolean, default: false },
-        sentAt: Date
-    }]
-}, {
-    timestamps: true
-});
-
-const HandoverSchedule = mongoose.model('HandoverSchedule', handoverScheduleSchema);
-
-module.exports = HandoverSchedule;

package/src/models/lease.js

@@ -1,77 +0,0 @@
-const mongoose = require("mongoose");
-
-const LeaseSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    customerId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Customer',
-        required: true
-    },
-    propertyManagerId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User', 
-        required: true
-    },
-    startDate: {
-        type: Date,
-        required: true
-    },
-    endDate: {
-        type: Date,
-        required: true
-    },
-    rentValue: {
-        type: Number,
-        required: true,
-        min: 0
-    },
-    levies: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Levy'
-    }],
-    securityDeposit: {
-        type: Number
-    },
-    responsibilities: {
-        type: String
-    },
-    penalties: [{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Penalty'
-    }],
-    paymentFrequency: {
-        type: String,
-        enum: ['monthly', 'quarterly', 'annually'],
-        required: true
-    },
-    status: {
-        type: String,
-        enum: ['active', 'expired', 'terminated', 'draft'],
-        required: true
-    },
-    templateId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'LeaseTemplate',
-        required: true
-    },
-    signedCopy: {
-        type: String
-    },
-    unsignedCopyUrl: {
-        type: String,
-        match: /^https?:\/\/.*/, 
-        required: false
-    },
-    createdAt: {
-        type: Date,
-        default: Date.now
-    }
-});
-
-const Lease = mongoose.model('Lease', LeaseSchema);
-
-module.exports = Lease;

package/src/models/welcome_pack.js

@@ -1,63 +0,0 @@
-const mongoose = require('mongoose');
-
-const welcomePackSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    name: {
-        type: String,
-        required: true
-    },
-    type: {
-        type: String,
-        enum: ['Standard', 'Premium', 'Custom'],
-        default: 'Standard'
-    },
-    items: [{
-        category: {
-            type: String,
-            enum: ['Keys', 'Documents', 'Manuals', 'AccessCards', 'Other'],
-            required: true
-        },
-        itemName: { type: String, required: true },
-        quantity: { type: Number, default: 1 },
-        description: String,
-        isRequired: { type: Boolean, default: true }
-    }],
-    documents: [{
-        name: String,
-        type: {
-            type: String,
-            enum: ['Manual', 'Guide', 'Policy', 'Emergency', 'Other']
-        },
-        fileUrl: String,
-        isRequired: { type: Boolean, default: true }
-    }],
-    facilitiesInfo: {
-        emergencyContacts: [{
-            name: String,
-            role: String,
-            contact: String
-        }],
-        amenities: [{
-            name: String,
-            location: String,
-            accessInstructions: String
-        }],
-        rules: [String]
-    },
-    status: {
-        type: String,
-        enum: ['Active', 'Inactive', 'Draft'],
-        default: 'Active'
-    }
-}, {
-    timestamps: true
-});
-
-
-const WelcomePack = mongoose.model('WelcomePack', welcomePackSchema);
-
-module.exports = WelcomePack;