payservedb 3.1.3 → 3.1.5

package/index.js

@@ -108,7 +108,12 @@ 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')
+    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')
    
     
 };

package/package.json

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

package/src/models/handover.js

@@ -0,0 +1,144 @@
+const mongoose = require('mongoose');
+
+const handoverSchema = new mongoose.Schema({
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true
+    },
+    unitNumber: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Unit',
+        required: true
+    },
+    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'
+    },
+    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
+    },
+    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'
+    }
+}, {
+    timestamps: true
+});
+const Handover = mongoose.model('Handover', handoverSchema);
+
+module.exports = Handover;

package/src/models/handover_checklist.js

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,71 @@
+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/valueaddedservices.js

@@ -12,10 +12,22 @@ const valueAddedServiceSchema = new mongoose.Schema({
         required: true,
         trim: true
     },
+    serviceType: {
+        type: String,
+        required: true,
+    },
     appliesTo: {
-        type: [String],  
-        default: []     
-    }
+        type: [String],
+        default: []
+    },
+    applicableTaxes: [{
+        taxId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'CountryTaxRate'
+        },
+        taxName: String,
+        taxRate: Number
+    }]
 }, {
     timestamps: true
 });

package/src/models/water_meter.js

@@ -42,9 +42,6 @@ const meterSchema = new mongoose.Schema({
     timestamps: true,
 });
 
-// Add index for better query performance
-meterSchema.index({ serialNumber: 1 });
-
 const Meter = mongoose.model('Meter', meterSchema);
 
 module.exports = Meter;

package/src/models/welcome_pack.js

@@ -0,0 +1,63 @@
+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;