payservedb 4.5.9 → 4.6.1

package/index.js

@@ -134,7 +134,8 @@ const models = {
     ServiceChargeInvoiceUpload: require('./src/models/service_charge_invoice_upload'),
     Campaign: require('./src/models/campaigns'),
     InspectionItem: require('./src/models/item_inspection'),
-    Supplier: require('./src/models/suppliers')
+    Supplier: require('./src/models/suppliers'),
+    PurchaseRequest: require('./src/models/purchase_request')
 
 };
 

package/package.json

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

package/src/models/purchase_order.js

@@ -0,0 +1,192 @@
+const mongoose = require('mongoose');
+
+const purchaseOrderSchema = new mongoose.Schema({
+    // Main Purchase Order Information
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+        index: true
+    },
+    poNumber: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+        index: true
+    },
+    prNumber: {
+        type: String,
+        required: true,
+        trim: true,
+        index: true,
+        ref: 'PurchaseRequest'
+    },
+    supplier: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Supplier',
+        required: true
+    },
+    department: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    currency: {
+        type: String,
+        required: true,
+        trim: true,
+        default: 'KES'
+    },
+    date: {
+        type: Date,
+        required: true,
+        default: Date.now
+    },
+    internalNotes: {
+        type: String,
+        trim: true
+    },
+    supplierNotes: {
+        type: String,
+        trim: true
+    },
+    budget: {
+        type: String,
+        trim: true
+    },
+    status: {
+        type: String,
+        enum: ['pending approval', 'approved', 'rejected', 'sent', 'received', 'completed', 'canceled'],
+        default: 'pending approval',
+        index: true
+    },
+
+    // Items Details
+    items: [{
+        itemDescription: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        quantity: {
+            type: Number,
+            required: true
+        },
+        unitOfMeasure: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        unitPrice: {
+            type: Number,
+            required: true
+        },
+        taxRate: {
+            type: Number,
+            default: 0
+        },
+        totalPrice: {
+            type: Number,
+            required: true
+        }
+    }],
+
+    // Calculated Totals
+    subtotal: {
+        type: Number,
+        required: true
+    },
+    taxTotal: {
+        type: Number,
+        required: true,
+        default: 0
+    },
+    grandTotal: {
+        type: Number,
+        required: true
+    },
+
+    // Approvers Section
+    approvers: [{
+        approverId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'User',
+            required: true
+        },
+        approverName: {
+            type: String,
+            required: true
+        },
+        approverRole: {
+            type: String,
+            required: true
+        },
+        approvalStatus: {
+            type: String,
+            enum: ['pending', 'approved', 'rejected'],
+            default: 'pending'
+        },
+        approvalDate: {
+            type: Date
+        },
+        comments: {
+            type: String,
+            trim: true
+        }
+    }],
+
+    // Document attachments
+    attachments: [{
+        name: {
+            type: String,
+            required: true
+        },
+        fileType: {
+            type: String,
+            required: true
+        },
+        filePath: {
+            type: String,
+            required: true
+        },
+        uploadDate: {
+            type: Date,
+            default: Date.now
+        }
+    }]
+}, {
+    timestamps: true
+});
+
+// Virtual for tracking approval progress
+purchaseOrderSchema.virtual('approvalProgress').get(function () {
+    if (!this.approvers || this.approvers.length === 0) return 0;
+
+    const approvedCount = this.approvers.filter(
+        approver => approver.approvalStatus === 'approved'
+    ).length;
+
+    return (approvedCount / this.approvers.length) * 100;
+});
+
+// Pre-save middleware to calculate totals
+purchaseOrderSchema.pre('save', function (next) {
+    // Calculate subtotal
+    this.subtotal = this.items.reduce((sum, item) => sum + (item.unitPrice * item.quantity), 0);
+
+    // Calculate tax total
+    this.taxTotal = this.items.reduce((sum, item) => {
+        const itemTax = (item.unitPrice * item.quantity) * (item.taxRate / 100);
+        return sum + itemTax;
+    }, 0);
+
+    // Calculate grand total
+    this.grandTotal = this.subtotal + this.taxTotal;
+
+    next();
+});
+
+const PurchaseOrder = mongoose.model('PurchaseOrder', purchaseOrderSchema);
+
+module.exports = PurchaseOrder;

package/src/models/purchase_request.js

@@ -0,0 +1,65 @@
+const mongoose = require('mongoose');
+
+const purchaseRequestSchema = new mongoose.Schema({
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+        index: true
+    },
+    itemDescription: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    from: {
+        type: String,
+        ref: 'User',
+        trim: true
+    },
+    quantity: {
+        type: Number,
+        required: true
+    },
+    unitOfMeasure: {
+        type: String,
+        required: true,
+        trim: true
+    },
+    remarksSpecification: {
+        type: String,
+        trim: true
+    },
+    date: {
+        type: Date,
+        required: true,
+        default: Date.now
+    },
+    irfNumber: {
+        type: String,
+        required: true,
+        trim: true,
+        index: true
+    },
+    department: {
+        type: String,
+        trim: true
+    },
+    status: {
+        type: String,
+        default: 'pending',
+        index: true
+    },
+    poStatus: {
+        type: String,
+        enum: ['PO Raised', 'pending'],
+        default: 'pending',
+        index: true
+    }
+}, {
+    timestamps: true
+});
+
+const PurchaseRequest = mongoose.model('PurchaseRequest', purchaseRequestSchema);
+
+module.exports = PurchaseRequest;

package/src/models/quotation.js

@@ -0,0 +1,268 @@
+const mongoose = require('mongoose');
+
+const rfqSchema = new mongoose.Schema({
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+        index: true
+    },
+    name: {
+        type: String,
+        required: true,
+        trim: true,
+        index: true
+    },
+    rfqNumber: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+        index: true
+    },
+    startDate: {
+        type: Date,
+        required: true
+    },
+    closingDate: {
+        type: Date,
+        required: true
+    },
+    currency: {
+        type: String,
+        required: true,
+        default: 'KES',
+        trim: true
+    },
+    rfqType: {
+        type: String,
+        required: true,
+        enum: ['open', 'closed'],
+        default: 'closed'
+    },
+    rfqFee: {
+        type: Number,
+        default: 0
+    },
+    rfqEvaluationType: {
+        type: String,
+        required: true,
+        enum: ['automatic', 'approvers'],
+        default: 'approvers'
+    },
+    notes: {
+        type: String,
+        trim: true
+    },
+    status: {
+        type: String,
+        enum: ['open','closed', 'awarded', 'canceled'],
+        default: 'open',
+        index: true
+    },
+    // RFQ Categories (Products or Services)
+    categories: [{
+        name: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        // For Product type
+        products: [{
+            productName: {
+                type: String,
+                trim: true,
+                required: function() {
+                    return this.parent().categoryType === 'product';
+                }
+            },
+            sku: {
+                type: String,
+                trim: true
+            },
+            quantity: {
+                type: Number,
+                required: function() {
+                    return this.parent().categoryType === 'product';
+                }
+            },
+            unitOfMeasure: {
+                type: String,
+                trim: true
+            },
+            estimatedUnitPrice: {
+                type: Number
+            }
+        }],
+        // For Service type
+        services: [{
+            serviceDescription: {
+                type: String,
+                trim: true,
+                required: function() {
+                    return this.parent().categoryType === 'service';
+                }
+            },
+            quantity: {
+                type: Number,
+                required: function() {
+                    return this.parent().categoryType === 'service';
+                }
+            },
+            unitOfMeasure: {
+                type: String,
+                trim: true
+            },
+            estimatedUnitPrice: {
+                type: Number
+            }
+        }]
+    }],
+    
+    // Suppliers invited to respond to the RFQ
+    suppliers: [{
+        supplierId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Supplier',
+            required: true
+        },
+        supplierName: {
+            type: String,
+            required: true,
+            trim: true
+        },
+        invitationStatus: {
+            type: String,
+            enum: ['pending', 'accepted', 'declined', 'no-response'],
+            default: 'pending'
+        },
+        invitationDate: {
+            type: Date,
+            default: Date.now
+        },
+        responseDate: {
+            type: Date
+        },
+        quotationSubmitted: {
+            type: Boolean,
+            default: false
+        },
+        quotationDetails: {
+            submissionDate: {
+                type: Date
+            },
+            totalAmount: {
+                type: Number
+            },
+            items: [{
+                categoryId: {
+                    type: mongoose.Schema.Types.ObjectId,
+                    required: true
+                },
+                itemId: {
+                    type: mongoose.Schema.Types.ObjectId,
+                    required: true
+                },
+                unitPrice: {
+                    type: Number,
+                    required: true
+                },
+                quantity: {
+                    type: Number,
+                    required: true
+                },
+                totalPrice: {
+                    type: Number,
+                    required: true
+                },
+                notes: {
+                    type: String,
+                    trim: true
+                }
+            }],
+            attachments: [{
+                name: {
+                    type: String,
+                    required: true
+                },
+                fileType: {
+                    type: String,
+                    required: true
+                },
+                filePath: {
+                    type: String,
+                    required: true
+                },
+                uploadDate: {
+                    type: Date,
+                    default: Date.now
+                }
+            }],
+            notes: {
+                type: String,
+                trim: true
+            }
+        },
+        evaluationScore: {
+            type: Number,
+            min: 0,
+            max: 100
+        },
+        evaluationNotes: {
+            type: String,
+            trim: true
+        }
+    }],
+    
+    
+    // Award details after RFQ is closed
+    awardDetails: {
+        awarded: {
+            type: Boolean,
+            default: false
+        },
+        awardedSupplierId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'Supplier'
+        },
+        awardedSupplierName: {
+            type: String,
+            trim: true
+        },
+        awardDate: {
+            type: Date
+        },
+        awardNotes: {
+            type: String,
+            trim: true
+        },
+        purchaseOrderCreated: {
+            type: Boolean,
+            default: false
+        },
+        purchaseOrderId: {
+            type: mongoose.Schema.Types.ObjectId,
+            ref: 'PurchaseOrder'
+        }
+    }
+}, {
+    timestamps: true
+});
+
+// Virtual for tracking participation rate
+rfqSchema.virtual('participationRate').get(function() {
+    if (!this.suppliers || this.suppliers.length === 0) return 0;
+    
+    const respondedCount = this.suppliers.filter(
+        supplier => supplier.quotationSubmitted === true
+    ).length;
+    
+    return (respondedCount / this.suppliers.length) * 100;
+});
+
+// Index for efficient querying by date ranges
+rfqSchema.index({ startDate: 1, closingDate: 1 });
+
+const RFQ = mongoose.model('RFQ', rfqSchema);
+
+module.exports = RFQ;

package/src/models/water_meters.js

@@ -1,47 +1,110 @@
-const payservedb = require('payservedb');
-const { getModel } = require('../../../../utils/getModel');
+const mongoose = require('mongoose');
 
-const getMeterDetailsByUnit = async (request, reply) => {
-  try {
-    const { facilityId, unitId } = request.params;
+const waterMeterSchema = new mongoose.Schema({
+    meterType: {
+        type: String,
+        required: true,
+        enum: ['analog', 'smart']
+    },
+    meterNumber: { 
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+        index: true
+    },
+    accountNumber: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true
+    },
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+    },
+    unitId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Unit',
+    },
+    customerId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Customer',
+    },
+    manufacturer: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'MeterManufacturer',
+    },
+    protocol: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'MeterProtocol',
+    },
+    size: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'MeterSize',
+    },
+    initialReading: {
+        type: Number,
+        required: true,
+        min: 0,
+        default: 0
+    },
+    previousReading: {
+        type: Number,
+        min: 0,
+    },
+    currentReading: {
+        type: Number,
+        min: 0,
+        default: 0
+    },
+    lastReadingDate: {
+        type: Date,
+        default: Date.now
+    },
+    readingHistory: [{
+        previousReading: Number,
+        currentReading: Number,
+        readingDate: {
+            type: Date,
+            default: Date.now
+        },
+        readBy: String,
+        consumption: Number
+    }],
+    status: {
+        type: String,
+        required: true,
+        enum: ['open', 'closed', 'maintenance', 'faulty'],
+        default: 'open',
+    },
+    customerType: { 
+        type: String,
+        enum: ['postpaid', 'prepaid'],
+    },
+    isInstalled: {
+        type: Boolean,
+        default: false
+    },
+    valveType: { // Specific to smart meters
+        type: String,
+        enum: ['automatic', 'manual'],
+        default: 'automatic'
+    },
+    accountBalance: { // Specific to smart meters
+        type: Number,
+        default: 0
+    },
+    negativeBalance: { // Specific to smart meters
+        type: Number,
+        default: 0
+    },
+}, {
+    timestamps: true
+});
 
-    const analogMeterModel = await getModel('WaterMeter', payservedb.WaterMeter.schema, facilityId);
-    const unitModel = await getModel('Unit', payservedb.Unit.schema, facilityId);
+waterMeterSchema.index({ meterNumber: 1, status: 1 });
 
-    // Find the unit first
-    const unit = await unitModel.findById(unitId);
-    if (!unit) {
-      return reply.code(404).send({ 
-        success: false,
-        error: 'Unit not found' 
-      });
-    }
+const WaterMeter = mongoose.model('WaterMeter', waterMeterSchema);
 
-    // Find the meter associated with this unit
-    const meter = await analogMeterModel.findOne({ unitId: unitId });
-    if (!meter) {
-      return reply.code(404).send({ 
-        success: false,
-        error: 'No meter found for this unit' 
-      });
-    }
-
-    // Return only the simplified meter information
-    return reply.code(200).send({
-      status: meter.status,
-      meterNumber: meter.meterNumber,
-      currentReading: meter.currentReading,
-      previousReading: meter.previousReading,
-      lastReadingDate: meter.lastReadingDate,
-      lastUpdated: meter.updatedAt
-    });
-  } catch (err) {
-    console.error('Error in retrieving analog meter details by unit:', err);
-    return reply.code(400).send({ 
-      success: false,
-      error: err.message 
-    });
-  }
-};
-
-module.exports = getMeterDetailsByUnit;
+module.exports = WaterMeter;