payservedb 4.5.6 → 4.5.8

package/package.json

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

package/src/models/approvalsWorkflows.js

@@ -0,0 +1,49 @@
+const mongoose = require('mongoose');
+
+const approvalWorkflowSchema = new mongoose.Schema(
+  {
+    module: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    facilityId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Facility',
+      required: true,
+      index: true
+    },
+   
+    steps: {
+      type: [
+        {
+          stepNumber: {
+            type: Number,
+            required: true,
+            min: 1
+          },
+          name: {
+            type: String,
+            required: true,
+            trim: true
+          },
+          approvers: [
+            {
+              type: mongoose.Schema.Types.ObjectId,
+              ref: 'User', 
+              required: true
+            }
+          ]
+        }
+      ],
+      default: []
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+
+const ApprovalWorkflow = mongoose.model('ApprovalWorkflow', approvalWorkflowSchema);
+
+module.exports = ApprovalWorkflow;

package/src/models/customer.js

@@ -54,6 +54,12 @@ const CustomerSchema = new mongoose.Schema({
         required: false,
         enum: ['Active', 'Inactive']
     },
+    quickBooksId: {
+        type: String,
+    },
+    nonResidentUsage: {
+        type String,
+    },
 
     familyMembers: [
         {

package/src/models/water_meters.js

@@ -1,110 +1,47 @@
-const mongoose = require('mongoose');
+const payservedb = require('payservedb');
+const { getModel } = require('../../../../utils/getModel');
 
-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 getMeterDetailsByUnit = async (request, reply) => {
+  try {
+    const { facilityId, unitId } = request.params;
 
-waterMeterSchema.index({ meterNumber: 1, status: 1 });
+    const analogMeterModel = await getModel('WaterMeter', payservedb.WaterMeter.schema, facilityId);
+    const unitModel = await getModel('Unit', payservedb.Unit.schema, facilityId);
 
-const WaterMeter = mongoose.model('WaterMeter', waterMeterSchema);
+    // Find the unit first
+    const unit = await unitModel.findById(unitId);
+    if (!unit) {
+      return reply.code(404).send({ 
+        success: false,
+        error: 'Unit not found' 
+      });
+    }
 
-module.exports = WaterMeter;
+    // 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;