payservedb 6.2.6 → 6.2.8

package/src/models/facilityWalletTransactionsMetadata.js

@@ -1,68 +1,265 @@
-const mongoose = require("mongoose");
-
-const faclityWalletTransactionsMetadataSchema = new mongoose.Schema({
-  invoiceId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Invoice",
-    required: true,
-    unique: true,
-  },
-  invoiceNumber: {
-    type: String,
-    required: true,
-    unique: true,
-  },
-  amount: {
-    type: Number,
-    required: true,
-  },
-  walletId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Wallet",
-    required: true,
-  },
-  status: {
-    type: String,
-    enum: ["partial", "paid", "cancelled"],
-    required: true,
-  },
-  amountToLandlord: {
-    type: Number,
-    default: 0,
-  },
-  amountToPropertyManager: {
-    type: Number,
-    default: 0,
-  },
-  paidToLandlord: {
-    type: Boolean,
-    default: false,
-  },
-  paidToPropertyManager: {
-    type: Boolean,
-    default: false,
-  },
-  propertyManager: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "User",
-    required: true,
-  },
-  landlord: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Customer",
-    required: true,
-  },
-  facility: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: "Facility",
-    required: true,
-  },
-});
-
-faclityWalletTransactionsMetadataSchema.index({ invoiceId: 1 });
-const FacilityWalletTransactionsMetadata = mongoose.model(
-  "FacilityWalletTransactionsMetadata",
-  faclityWalletTransactionsMetadataSchema,
-);
-
-module.exports = FacilityWalletTransactionsMetadata;
+const mongoose = require("mongoose");
+
+const facilityWalletTransactionsMetadataSchema = new mongoose.Schema(
+  {
+    invoiceId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Invoice",
+      required: true,
+      unique: true,
+    },
+    invoiceNumber: {
+      type: String,
+      required: true,
+      unique: true,
+    },
+    amount: {
+      type: Number,
+      required: true,
+      min: 0.01,
+    },
+    walletId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Wallet",
+      required: true,
+    },
+    // Updated status enum to include pending, approved, and rejected
+    status: {
+      type: String,
+      enum: ["pending", "partial", "paid", "approved", "rejected", "cancelled"],
+      required: true,
+      default: "pending",
+    },
+    amountToLandlord: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    amountToPropertyManager: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    paidToLandlord: {
+      type: Boolean,
+      default: false,
+    },
+    paidToPropertyManager: {
+      type: Boolean,
+      default: false,
+    },
+    propertyManager: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: true,
+    },
+    landlord: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Customer",
+      required: true,
+    },
+    facility: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Facility",
+      required: true,
+    },
+    // New approval tracking fields
+    approvedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    approvedAt: {
+      type: Date,
+      default: null,
+    },
+    approvalNotes: {
+      type: String,
+      maxlength: 500,
+      default: null,
+    },
+    // New rejection tracking fields
+    rejectedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    rejectedAt: {
+      type: Date,
+      default: null,
+    },
+    rejectionReason: {
+      type: String,
+      maxlength: 500,
+      default: null,
+    },
+    // Link to created transaction when approved
+    transactionId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "WalletTransaction",
+      default: null,
+    },
+    // Additional metadata fields
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: false,
+    },
+    updatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      required: false,
+    },
+  },
+  {
+    timestamps: true, // Adds createdAt and updatedAt automatically
+  },
+);
+
+// Indexes for better query performance
+facilityWalletTransactionsMetadataSchema.index({ invoiceId: 1 });
+facilityWalletTransactionsMetadataSchema.index({ facility: 1, status: 1 });
+facilityWalletTransactionsMetadataSchema.index({ walletId: 1, status: 1 });
+facilityWalletTransactionsMetadataSchema.index({ status: 1, createdAt: -1 });
+facilityWalletTransactionsMetadataSchema.index({ approvedBy: 1 });
+facilityWalletTransactionsMetadataSchema.index({ rejectedBy: 1 });
+
+// Virtual for checking if metadata is approvable
+facilityWalletTransactionsMetadataSchema
+  .virtual("isApprovable")
+  .get(function () {
+    return this.status === "pending";
+  });
+
+// Virtual for checking if metadata has been processed
+facilityWalletTransactionsMetadataSchema
+  .virtual("isProcessed")
+  .get(function () {
+    return ["approved", "rejected", "cancelled"].includes(this.status);
+  });
+
+// Pre-save middleware to validate status transitions
+facilityWalletTransactionsMetadataSchema.pre("save", function (next) {
+  if (this.isModified("status")) {
+    const validTransitions = {
+      pending: ["approved", "rejected", "cancelled"],
+      partial: ["paid", "cancelled"],
+      approved: ["paid", "cancelled"],
+      rejected: ["pending"], // Allow resubmission
+      paid: [], // Terminal state
+      cancelled: ["pending"], // Allow reactivation
+    };
+
+    if (this.isNew) {
+      // New documents can have any status
+      return next();
+    }
+
+    const previousStatus = this.$locals.previousStatus;
+    if (
+      previousStatus &&
+      !validTransitions[previousStatus]?.includes(this.status)
+    ) {
+      return next(
+        new Error(
+          `Invalid status transition from ${previousStatus} to ${this.status}`,
+        ),
+      );
+    }
+  }
+
+  // Set approval/rejection timestamps
+  if (this.isModified("status")) {
+    if (this.status === "approved" && !this.approvedAt) {
+      this.approvedAt = new Date();
+    }
+    if (this.status === "rejected" && !this.rejectedAt) {
+      this.rejectedAt = new Date();
+    }
+  }
+
+  next();
+});
+
+// Pre-save middleware to store previous status
+facilityWalletTransactionsMetadataSchema.pre("save", function (next) {
+  if (!this.isNew && this.isModified("status")) {
+    this.$locals.previousStatus = this.$locals.wasNew
+      ? undefined
+      : this.$__.wasModified("status")
+        ? this.$__.$originalValue.status
+        : this.status;
+  }
+  next();
+});
+
+// Static method to find pending metadata
+facilityWalletTransactionsMetadataSchema.statics.findPending = function (
+  facilityId,
+  options = {},
+) {
+  const query = { facility: facilityId, status: "pending" };
+
+  if (options.walletId) {
+    query.walletId = options.walletId;
+  }
+
+  return this.find(query).sort({ createdAt: -1 });
+};
+
+// Static method to get summary stats
+facilityWalletTransactionsMetadataSchema.statics.getSummaryStats = function (
+  facilityId,
+) {
+  return this.aggregate([
+    { $match: { facility: new mongoose.Types.ObjectId(facilityId) } },
+    {
+      $group: {
+        _id: "$status",
+        count: { $sum: 1 },
+        totalAmount: { $sum: "$amount" },
+      },
+    },
+  ]);
+};
+
+// Instance method to approve metadata
+facilityWalletTransactionsMetadataSchema.methods.approve = function (
+  approvedBy,
+  notes,
+) {
+  if (this.status !== "pending") {
+    throw new Error(`Cannot approve metadata with status: ${this.status}`);
+  }
+
+  this.status = "approved";
+  this.approvedBy = approvedBy;
+  this.approvedAt = new Date();
+  if (notes) this.approvalNotes = notes;
+
+  return this.save();
+};
+
+// Instance method to reject metadata
+facilityWalletTransactionsMetadataSchema.methods.reject = function (
+  rejectedBy,
+  reason,
+) {
+  if (this.status !== "pending") {
+    throw new Error(`Cannot reject metadata with status: ${this.status}`);
+  }
+
+  this.status = "rejected";
+  this.rejectedBy = rejectedBy;
+  this.rejectedAt = new Date();
+  this.rejectionReason = reason;
+
+  return this.save();
+};
+
+const FacilityWalletTransactionsMetadata = mongoose.model(
+  "FacilityWalletTransactionsMetadata",
+  facilityWalletTransactionsMetadataSchema,
+);
+
+module.exports = FacilityWalletTransactionsMetadata;

package/src/models/facility_departements.js

@@ -1,20 +1,20 @@
-const mongoose = require('mongoose');
-
-const facilityDepartmentSchema = new mongoose.Schema({
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true
-    },
-    name: {
-        type: String,
-        required: true,
-        trim: true
-    }
-}, {
-    timestamps: true
-});
-
-const FacilityDepartment = mongoose.model('FacilityDepartment', facilityDepartmentSchema);
-
-module.exports = FacilityDepartment;
+const mongoose = require('mongoose');
+
+const facilityDepartmentSchema = new mongoose.Schema({
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true
+    },
+    name: {
+        type: String,
+        required: true,
+        trim: true
+    }
+}, {
+    timestamps: true
+});
+
+const FacilityDepartment = mongoose.model('FacilityDepartment', facilityDepartmentSchema);
+
+module.exports = FacilityDepartment;

package/src/models/facility_payment_details.js

@@ -1,21 +1,21 @@
-const mongoose = require("mongoose");
-
-const facilityPaymentDetailsSchema = new mongoose.Schema({
-    facility: {
-        type: mongoose.Schema.Types.ObjectId,
-    },
-    shortCode: { type: String },
-    passkey: { type: String },
-    authorizationKey: {
-        type: String,
-    },
-    module: {
-        type: String,
-        enum: ["All", "Water", "Electricity", "Levy","Lease"],
-        default: "All"
-    },
-});
-
-const FacilityPaymentDetails = mongoose.model('FacilityPaymentDetails', facilityPaymentDetailsSchema);
-
+const mongoose = require("mongoose");
+
+const facilityPaymentDetailsSchema = new mongoose.Schema({
+    facility: {
+        type: mongoose.Schema.Types.ObjectId,
+    },
+    shortCode: { type: String },
+    passkey: { type: String },
+    authorizationKey: {
+        type: String,
+    },
+    module: {
+        type: String,
+        enum: ["All", "Water", "Electricity", "Levy","Lease"],
+        default: "All"
+    },
+});
+
+const FacilityPaymentDetails = mongoose.model('FacilityPaymentDetails', facilityPaymentDetailsSchema);
+
 module.exports = FacilityPaymentDetails;

package/src/models/facilityasset.js

@@ -1,25 +1,25 @@
-const mongoose = require('mongoose');
-
-// Define the schema for companies
-const facilityassetSchema = new mongoose.Schema({
-    name: {
-        type: String,
-        required:true
-    },
-    facilityId:{
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-    }
-
-  
-}, {
-    timestamps: true // Automatically add createdAt and updatedAt fields
-});
-
-// Indexes for improved performance
-facilityassetSchema.index({ name: 1 });
-
-// Compile the model from the schema
-const FacilityAsset = mongoose.model('FacilityAsset', facilityassetSchema);
-
-module.exports = FacilityAsset;
+const mongoose = require('mongoose');
+
+// Define the schema for companies
+const facilityassetSchema = new mongoose.Schema({
+    name: {
+        type: String,
+        required:true
+    },
+    facilityId:{
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+    }
+
+  
+}, {
+    timestamps: true // Automatically add createdAt and updatedAt fields
+});
+
+// Indexes for improved performance
+facilityassetSchema.index({ name: 1 });
+
+// Compile the model from the schema
+const FacilityAsset = mongoose.model('FacilityAsset', facilityassetSchema);
+
+module.exports = FacilityAsset;

package/src/models/faq.js

@@ -1,18 +1,18 @@
-// models/apiLog.js
-const mongoose = require('mongoose');
-const { Schema } = mongoose;
-
-const faqSchema = new Schema({
-    question:{type:String,required:true},
-    answer:{type:String,required:true},
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility'
-    },
-});
-
-
-
-const FAQ = mongoose.model('FAQ', faqSchema);
-
-module.exports = FAQ;
+// models/apiLog.js
+const mongoose = require('mongoose');
+const { Schema } = mongoose;
+
+const faqSchema = new Schema({
+    question:{type:String,required:true},
+    answer:{type:String,required:true},
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility'
+    },
+});
+
+
+
+const FAQ = mongoose.model('FAQ', faqSchema);
+
+module.exports = FAQ;

package/src/models/gl_account_double_entries.js

@@ -1,25 +1,25 @@
-const mongoose = require('mongoose');
-
-const glAccountDoubleEntriesSchema = new mongoose.Schema({
-    accountdebited: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'GLAccount',
-        required: true,
-    },
-    accountcredited: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'GLAccount',
-        required: true,
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true,
-    },
-    createdAt: {
-        type: Date,
-        default: Date.now,
-    },
-});
-
-module.exports = mongoose.model('GLAccountDoubleEntries', glAccountDoubleEntriesSchema);
+const mongoose = require('mongoose');
+
+const glAccountDoubleEntriesSchema = new mongoose.Schema({
+    accountdebited: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'GLAccount',
+        required: true,
+    },
+    accountcredited: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'GLAccount',
+        required: true,
+    },
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now,
+    },
+});
+
+module.exports = mongoose.model('GLAccountDoubleEntries', glAccountDoubleEntriesSchema);

package/src/models/gl_accounts.js

@@ -1,57 +1,57 @@
-const mongoose = require('mongoose');
-
-const glAccountsSchema = new mongoose.Schema({
-    accountCode: {
-        type: String,
-        required: true,
-        unique: true,
-        trim: true,
-    },
-    accountName: {
-        type: String,
-        required: true,
-        trim: true,
-    },
-    accountType: {
-        type: String,
-        required: true,
-        trim: true,
-    },
-    accountBalance: {
-        type: Number,
-        default: 0,
-    },
-    facilityId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'Facility',
-        required: true,
-    },
-    parentAccountId: {
-        type: mongoose.Schema.Types.ObjectId,
-        ref: 'GLAccount',
-        default: null,
-    },
-    accountLevel: {
-        type: Number,
-        required: true,
-        default: 0,
-    },
-    isFinal: {
-        type: Boolean,
-        default: false,
-    },
-    isActive: {
-        type: Boolean,
-        default: true,
-    },
-    createdAt: {
-        type: Date,
-        default: Date.now,
-    },
-    updatedAt: {
-        type: Date,
-        default: Date.now,
-    },
-});
-
+const mongoose = require('mongoose');
+
+const glAccountsSchema = new mongoose.Schema({
+    accountCode: {
+        type: String,
+        required: true,
+        unique: true,
+        trim: true,
+    },
+    accountName: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    accountType: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    accountBalance: {
+        type: Number,
+        default: 0,
+    },
+    facilityId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Facility',
+        required: true,
+    },
+    parentAccountId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'GLAccount',
+        default: null,
+    },
+    accountLevel: {
+        type: Number,
+        required: true,
+        default: 0,
+    },
+    isFinal: {
+        type: Boolean,
+        default: false,
+    },
+    isActive: {
+        type: Boolean,
+        default: true,
+    },
+    createdAt: {
+        type: Date,
+        default: Date.now,
+    },
+    updatedAt: {
+        type: Date,
+        default: Date.now,
+    },
+});
+
 module.exports = mongoose.model('GLAccount', glAccountsSchema);