payservedb 4.4.6 → 4.4.8

package/src/models/campaigns.js

@@ -1,78 +1,73 @@
-const mongoose = require('mongoose');
-
-const CampaignSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true,
-    },
-    name: {
-        type: String,
-        required: true,
-        trim: true,
-        maxlength: 100
-    },
-    objective: {
-        type: String,
-        enum: ['Brand Awareness', 'Lead Generation', 'Sales', 'Engagement'],
-        required: true
-    },
-    startDate: {
-        type: Date,
-        required: true
-    },
-    endDate: {
-        type: Date,
-        required: true,
-        validate: {
-            validator: function (value) {
-                return this.startDate <= value;
-            },
-            message: 'End date must be after or equal to start date'
-        }
-    },
-    targetAudience: {
-        type: String,
-        required: true,
-        trim: true,
-        maxlength: 200
-    },
-    channels: {
-        type: [String],
-        enum: ['Email', 'Social Media', 'SMS', 'Ads'],
-        required: true
-    },
-    status: {
-        type: String,
-        enum: ['Draft', 'Ongoing', 'Completed'],
-        default: 'Draft'
-    }, 
-    description: {
-        type: String,
-        trim: true,
-        maxlength: 500
-    },
-    message: {
-        type: String,
-        trim: true
-    },
-    createdAt: {
-        type: Date,
-        default: Date.now
-    },
-    updatedAt: {
-        type: Date,
-        default: Date.now
-    }
-}, {
-    timestamps: true
-});
-
-// Ensure at least one channel is selected
-CampaignSchema.path('channels').validate(function (value) {
-    return value.length > 0;
-}, 'At least one channel must be selected');
-
-const Campaign = mongoose.model('Campaign', CampaignSchema);
-
+const mongoose = require('mongoose');
+
+const CampaignSchema = new mongoose.Schema({
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+    },
+    name: {
+        type: String,
+        required: true,
+        trim: true,
+        maxlength: 100
+    },
+    objective: {
+        type: String,
+        enum: ['Brand Awareness', 'Lead Generation', 'Sales', 'Engagement'],
+        required: true
+    },
+    startDate: {
+        type: Date,
+        required: true
+    },
+    endDate: {
+        type: Date,
+        required: true,
+        validate: {
+            validator: function (value) {
+                return this.startDate <= value;
+            },
+            message: 'End date must be after or equal to start date'
+        }
+    },
+    targetAudience: {
+        type: String,
+        required: true,
+        trim: true,
+        maxlength: 200
+    },
+    channels: [{
+        type: String,
+        enum: ['Email', 'Social Media', 'SMS', 'Ads'],
+        required: true
+    }],
+    status: {
+        type: String,
+        enum: ['Draft', 'Ongoing', 'Completed'],
+        default: 'Draft'
+    }, description: {
+        type: String,
+        trim: true,
+        maxlength: 500
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now
+    },
+    updatedAt: {
+        type: Date,
+        default: Date.now
+    }
+}, {
+    timestamps: true
+});
+
+// Ensure at least one channel is selected
+CampaignSchema.path('channels').validate(function (value) {
+    return value.length > 0;
+}, 'At least one channel must be selected');
+
+const Campaign = mongoose.model('Campaign', CampaignSchema);
+
 module.exports =Campaign;

package/src/models/cashpayment.js

@@ -1,186 +1,263 @@
-// File: models/CashPayment.js
-const mongoose = require('mongoose');
-
-// Define the schema for Cash Payments
-const cashPaymentSchema = new mongoose.Schema({
-    // Payment reference details
-    paymentReference: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    // Invoice details
-    invoice: {
-        invoiceId: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Invoice',
-            required: true
-        },
-        invoiceNumber: {
-            type: String,
-            required: true,
-            trim: true
-        },
-        accountNumber: {
-            type: String,
-            required: true,
-            trim: true
-        },
-        totalAmount: {
-            type: Number,
-            required: true,
-            min: 0
-        }
-    },
-    // Client details
-    client: {
-        clientId: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Customer',
-            required: true
-        },
-        firstName: {
-            type: String,
-            required: true
-        },
-        lastName: {
-            type: String,
-            required: true
-        }
-    },
-    // Payment details
-    paymentAmount: {
-        type: Number,
-        required: true,
-        min: 0
-    },
-    currency: {
-        id: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'Currency',
-            required: true
-        },
-        name: {
-            type: String,
-            required: true
-        },
-        code: {
-            type: String,
-            required: true,
-            uppercase: true,
-            minlength: 3,
-            maxlength: 3
-        }
-    },
-    paymentDate: {
-        type: Date,
-        required: true,
-        default: Date.now
-    },
-    receivedBy: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User',
-        required: true
-    },
-    receiptNumber: {
-        type: String,
-        required: true,
-        unique: true
-    },
-    paymentMethod: {
-        type: String,
-        enum: ['Cash', 'Check', 'Bank Transfer'],
-        default: 'Cash'
-    },
-    paymentDetails: {
-        checkNumber: String,
-        bankName: String,
-        transferReference: String,
-        notes: String
-    },
-    // Reconciliation status
-    reconciliationStatus: {
-        type: String,
-        enum: ['Pending', 'Matched', 'Partial', 'Overpaid', 'Voided'],
-        default: 'Pending'
-    },
-    // Approval details
-    approvalStatus: {
-        type: String,
-        enum: ['Pending', 'Approved', 'Rejected'],
-        default: 'Pending'
-    },
-    approvedBy: {
-        userId: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User'
-        },
-        name: String,
-        approvalDate: Date,
-        comments: String
-    },
-    // Reconciliation details
-    reconciliationDetails: {
-        appliedAmount: {
-            type: Number,
-            default: 0
-        },
-        overpayAmount: {
-            type: Number,
-            default: 0
-        },
-        reconciliationDate: Date,
-        reconciledBy: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User'
-        }
-    },
-    // Exchange rate (for payments in different currencies)
-    exchangeRate: {
-        rate: {
-            type: Number,
-            default: 1
-        },
-        originalCurrency: {
-            code: String,
-            amount: Number
-        }
-    },
-    // Additional fields
-    isVoided: {
-        type: Boolean,
-        default: false
-    },
-    voidReason: {
-        type: String
-    },
-    voidedBy: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'User'
-    },
-    voidDate: Date,
-    attachments: [{
-        fileName: String,
-        fileUrl: String,
-        uploadDate: {
-            type: Date,
-            default: Date.now
-        },
-        uploadedBy: {
-            type: mongoose.Schema.Types.ObjectId,
-            ref: 'User'
-        }
-    }]
-}, {
-    timestamps: true
-});
-
-const CashPayment = mongoose.model('CashPayment', cashPaymentSchema);
-
-module.exports = CashPayment;
+const mongoose = require('mongoose');
+
+const cashPaymentSchema = new mongoose.Schema(
+    {
+        paymentReference: {
+            type: String,
+            required: true,
+            unique: true,
+            trim: true
+        },
+        receiptNumber: {
+            type: String,
+            required: true,
+            unique: true,
+            trim: true
+        },
+        invoice: {
+            invoiceId: {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: "Invoice",
+                required: true
+            },
+            invoiceNumber: {
+                type: String,
+                required: true,
+                trim: true
+            },
+            accountNumber: {
+                type: String,
+                trim: true
+            }
+        },
+        client: {
+            clientId: {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: "Customer",
+                required: true
+            },
+            firstName: {
+                type: String,
+                required: true,
+                trim: true
+            },
+            lastName: {
+                type: String,
+                required: true,
+                trim: true
+            }
+        },
+        facility: {
+            id: {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: "Facility",
+                required: true
+            },
+            name: {
+                type: String,
+                required: true,
+                trim: true
+            }
+        },
+        currency: {
+            id: {
+                type: mongoose.Schema.Types.ObjectId,
+                ref: "Currency",
+                required: true
+            },
+            name: {
+                type: String,
+                required: true,
+                trim: true
+            },
+            code: {
+                type: String,
+                required: true,
+                uppercase: true,
+                minlength: 3,
+                maxlength: 3
+            }
+        },
+        paymentAmount: {
+            type: Number,
+            required: true,
+            min: 0
+        },
+        paymentDate: {
+            type: Date,
+            required: true,
+            default: Date.now
+        },
+        paymentMethod: {
+            type: String,
+            enum: ['cash', 'bank-transfer', 'cheque'],
+            default: 'cash'
+        },
+        exchangeRate: {
+            rate: {
+                type: Number,
+                default: 1
+            },
+            sourceCurrency: {
+                type: String,
+                uppercase: true,
+                minlength: 3,
+                maxlength: 3
+            },
+            targetCurrency: {
+                type: String,
+                uppercase: true,
+                minlength: 3,
+                maxlength: 3
+            },
+            conversionDate: Date
+        },
+        approvalStatus: {
+            type: String,
+            enum: ['Pending', 'Approved', 'Rejected'],
+            default: 'Pending'
+        },
+        approvedBy: {
+            userId: mongoose.Schema.Types.ObjectId,
+            name: String,
+            approvalDate: Date,
+            comments: String
+        },
+        rejectedBy: {
+            userId: mongoose.Schema.Types.ObjectId,
+            name: String,
+            rejectionDate: Date,
+            reason: String
+        },
+        isVoided: {
+            type: Boolean,
+            default: false
+        },
+        voidedBy: {
+            userId: mongoose.Schema.Types.ObjectId,
+            name: String,
+            voidDate: Date,
+            reason: String
+        },
+        reconciliationStatus: {
+            type: String,
+            enum: ['Pending', 'Matched', 'Partial', 'Overpaid', 'Error'],
+            default: 'Pending'
+        },
+        reconciliationDetails: {
+            appliedAmount: Number,
+            overpayAmount: {
+                type: Number,
+                default: 0
+            },
+            reconciliationDate: Date,
+            reconciledBy: mongoose.Schema.Types.ObjectId,
+            paymentMethod: String, // To store the payment method used during reconciliation
+            notes: String
+        },
+        paymentNotes: String,
+        attachments: [
+            {
+                fileId: mongoose.Schema.Types.ObjectId,
+                fileName: String,
+                fileType: String,
+                uploadDate: Date,
+                uploadedBy: mongoose.Schema.Types.ObjectId
+            }
+        ],
+        metadata: {
+            createdBy: {
+                type: mongoose.Schema.Types.ObjectId,
+                required: true
+            },
+            source: {
+                type: String,
+                enum: ['manual', 'api', 'import', 'mobile'],
+                default: 'manual'
+            },
+            deviceInfo: {
+                deviceId: String,
+                deviceType: String,
+                ipAddress: String
+            }
+        }
+    },
+    {
+        timestamps: true
+    }
+);
+
+// Add indexes for frequently queried fields
+cashPaymentSchema.index({ 'paymentReference': 1 });
+cashPaymentSchema.index({ 'receiptNumber': 1 });
+cashPaymentSchema.index({ 'approvalStatus': 1 });
+cashPaymentSchema.index({ 'isVoided': 1 });
+cashPaymentSchema.index({ 'client.clientId': 1 });
+cashPaymentSchema.index({ 'invoice.invoiceId': 1 });
+cashPaymentSchema.index({ 'facility.id': 1 });
+cashPaymentSchema.index({ 'reconciliationStatus': 1 });
+cashPaymentSchema.index({ 'paymentDate': -1 });
+cashPaymentSchema.index({ 'currency.code': 1 });
+cashPaymentSchema.index({ 'paymentMethod': 1 });
+cashPaymentSchema.index({ 'paymentDate': -1, 'approvalStatus': 1 });
+cashPaymentSchema.index({ 'client.clientId': 1, 'approvalStatus': 1 });
+
+// Add virtual properties
+cashPaymentSchema.virtual('clientFullName').get(function () {
+    return `${this.client.firstName} ${this.client.lastName}`;
+});
+
+// Add instance methods
+cashPaymentSchema.methods.convertCurrency = function (targetCurrencyCode, exchangeRate) {
+    if (this.currency.code === targetCurrencyCode) {
+        return this.paymentAmount;
+    }
+    return this.paymentAmount * exchangeRate;
+};
+
+// Static methods
+cashPaymentSchema.statics.findByClientId = function (clientId) {
+    return this.find({ 'client.clientId': clientId }).sort({ paymentDate: -1 });
+};
+
+cashPaymentSchema.statics.findByInvoiceId = function (invoiceId) {
+    return this.find({ 'invoice.invoiceId': invoiceId }).sort({ paymentDate: -1 });
+};
+
+cashPaymentSchema.statics.findPendingPayments = function (facilityId) {
+    return this.find({
+        'facility.id': facilityId,
+        'approvalStatus': 'Pending',
+        'isVoided': false
+    }).sort({ paymentDate: -1 });
+};
+
+cashPaymentSchema.statics.findOverpaidPayments = function (facilityId) {
+    return this.find({
+        'facility.id': facilityId,
+        'approvalStatus': 'Approved',
+        'reconciliationStatus': 'Overpaid',
+        'isVoided': false
+    }).sort({ paymentDate: -1 });
+};
+
+// Pre-save middleware
+cashPaymentSchema.pre('save', function (next) {
+    // If the payment is approved, ensure the reconciliation status is set
+    if (this.isModified('approvalStatus') && this.approvalStatus === 'Approved' && this.reconciliationStatus === 'Pending') {
+        this.reconciliationStatus = 'Matched'; // Default status when approved
+    }
+
+    // If the payment is voided, clear certain fields
+    if (this.isModified('isVoided') && this.isVoided) {
+        this.approvalStatus = 'Pending';
+        this.reconciliationStatus = 'Pending';
+    }
+
+    next();
+});
+
+// Create model (only if not already defined by getModel utility)
+const CashPayment = mongoose.models.CashPayment || mongoose.model('CashPayment', cashPaymentSchema);
+
+module.exports = CashPayment;