payservedb 8.4.5 → 8.4.7

package/src/models/zohoAccount.js

@@ -0,0 +1,453 @@
+const mongoose = require("mongoose");
+
+const ZohoAccountSchema = new mongoose.Schema(
+  {
+    facilityId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Facility",
+      required: [true, "Facility ID is required"],
+      index: true,
+    },
+
+    // Account Identification
+    accountName: {
+      type: String,
+      required: [true, "Account name is required"],
+      trim: true,
+      maxlength: [255, "Account name cannot exceed 255 characters"],
+      index: true,
+    },
+    accountCode: {
+      type: String,
+      trim: true,
+      sparse: true,
+      default: null,
+      index: true,
+    },
+    description: {
+      type: String,
+      trim: true,
+      maxlength: [1000, "Description cannot exceed 1000 characters"],
+      default: null,
+    },
+
+    // Account Classification
+    accountType: {
+      type: String,
+      required: [true, "Account type is required"],
+      enum: ["income", "expense", "asset", "liability", "equity"],
+      index: true,
+    },
+    accountSubType: {
+      type: String,
+      trim: true,
+      default: null,
+    },
+
+    // Account Hierarchy
+    parentAccountId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "ZohoAccount",
+      default: null,
+      index: true,
+    },
+    zohoParentAccountId: {
+      type: String,
+      trim: true,
+      default: null,
+    },
+    isSubAccount: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    depth: {
+      type: Number,
+      default: 0,
+      min: [0, "Depth cannot be negative"],
+    },
+
+    // Zoho Sync Fields
+    zohoAccountId: {
+      type: String,
+      trim: true,
+      unique: true,
+      sparse: true,
+      default: null,
+      index: true,
+    },
+    zohoCurrencyId: {
+      type: String,
+      trim: true,
+      default: null,
+    },
+
+    // Financial Settings
+    currencyCode: {
+      type: String,
+      trim: true,
+      uppercase: true,
+      default: "KES",
+      maxlength: [3, "Currency code must be 3 characters"],
+    },
+    openingBalance: {
+      type: Number,
+      default: 0,
+    },
+    openingBalanceDate: {
+      type: Date,
+      default: null,
+    },
+    currentBalance: {
+      type: Number,
+      default: 0,
+    },
+    lastBalanceUpdate: {
+      type: Date,
+      default: null,
+    },
+
+    // Account Settings
+    isActive: {
+      type: Boolean,
+      default: true,
+      index: true,
+    },
+    isSystemAccount: {
+      type: Boolean,
+      default: false,
+    },
+    canBeDeleted: {
+      type: Boolean,
+      default: true,
+    },
+    showInPortal: {
+      type: Boolean,
+      default: false,
+    },
+
+    // Usage Tracking
+    usageCount: {
+      type: Number,
+      default: 0,
+      min: [0, "Usage count cannot be negative"],
+    },
+    lastUsedAt: {
+      type: Date,
+      default: null,
+    },
+    linkedItemsCount: {
+      type: Number,
+      default: 0,
+      min: [0, "Linked items count cannot be negative"],
+    },
+
+    // Sync Status
+    isSynced: {
+      type: Boolean,
+      default: false,
+      index: true,
+    },
+    lastSyncedAt: {
+      type: Date,
+      default: null,
+    },
+    syncStatus: {
+      type: String,
+      enum: ["pending", "syncing", "synced", "failed"],
+      default: "pending",
+      index: true,
+    },
+    syncError: {
+      type: String,
+      trim: true,
+      default: null,
+    },
+    lastSyncAttemptAt: {
+      type: Date,
+      default: null,
+    },
+
+    // Audit Fields
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    updatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    lastModifiedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+
+    // Metadata
+    notes: {
+      type: String,
+      trim: true,
+      maxlength: [1000, "Notes cannot exceed 1000 characters"],
+      default: null,
+    },
+    metadata: {
+      type: mongoose.Schema.Types.Mixed,
+      default: {},
+    },
+
+    // Zoho Specific Fields
+    zohoAccountNumber: {
+      type: String,
+      trim: true,
+      default: null,
+    },
+    zohoDepth: {
+      type: Number,
+      default: null,
+    },
+    zohoHasAttachment: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+// Compound Indexes
+ZohoAccountSchema.index({ facilityId: 1, accountName: 1 });
+ZohoAccountSchema.index({ facilityId: 1, accountType: 1 });
+ZohoAccountSchema.index({ facilityId: 1, isActive: 1 });
+ZohoAccountSchema.index({ facilityId: 1, isSynced: 1 });
+ZohoAccountSchema.index({ facilityId: 1, accountType: 1, isActive: 1 });
+ZohoAccountSchema.index({ zohoAccountId: 1, facilityId: 1 });
+
+// Text index for searching
+ZohoAccountSchema.index({
+  accountName: "text",
+  description: "text",
+  accountCode: "text",
+});
+
+// Virtual for full account path (for sub-accounts)
+ZohoAccountSchema.virtual("fullPath").get(function () {
+  if (this.parentAccountId) {
+    return `${this.parentAccountId.accountName} > ${this.accountName}`;
+  }
+  return this.accountName;
+});
+
+// Virtual for sync status indicator
+ZohoAccountSchema.virtual("needsSync").get(function () {
+  if (!this.zohoAccountId) return true;
+  if (!this.isSynced) return true;
+  return false;
+});
+
+// Method to mark as synced
+ZohoAccountSchema.methods.markAsSynced = function (zohoAccountId, zohoData = {}) {
+  this.zohoAccountId = zohoAccountId;
+  this.isSynced = true;
+  this.lastSyncedAt = new Date();
+  this.syncStatus = "synced";
+  this.syncError = null;
+
+  // Update Zoho-specific fields if provided
+  if (zohoData.currencyId) this.zohoCurrencyId = zohoData.currencyId;
+  if (zohoData.parentAccountId) this.zohoParentAccountId = zohoData.parentAccountId;
+  if (zohoData.accountNumber) this.zohoAccountNumber = zohoData.accountNumber;
+  if (zohoData.depth !== undefined) this.zohoDepth = zohoData.depth;
+
+  return this.save();
+};
+
+// Method to mark sync as failed
+ZohoAccountSchema.methods.markSyncFailed = function (errorMessage) {
+  this.syncStatus = "failed";
+  this.syncError = errorMessage;
+  this.lastSyncAttemptAt = new Date();
+  return this.save();
+};
+
+// Method to increment usage count
+ZohoAccountSchema.methods.incrementUsage = function () {
+  this.usageCount += 1;
+  this.lastUsedAt = new Date();
+  return this.save();
+};
+
+// Method to update balance
+ZohoAccountSchema.methods.updateBalance = function (newBalance) {
+  this.currentBalance = newBalance;
+  this.lastBalanceUpdate = new Date();
+  return this.save();
+};
+
+// Method to activate account
+ZohoAccountSchema.methods.activate = function () {
+  this.isActive = true;
+  return this.save();
+};
+
+// Method to deactivate account
+ZohoAccountSchema.methods.deactivate = function () {
+  this.isActive = false;
+  return this.save();
+};
+
+// Static method to find accounts by type
+ZohoAccountSchema.statics.findByType = function (facilityId, accountType) {
+  return this.find({
+    facilityId,
+    accountType,
+    isActive: true,
+  }).sort({ accountName: 1 });
+};
+
+// Static method to find income accounts (for items)
+ZohoAccountSchema.statics.findIncomeAccounts = function (facilityId) {
+  return this.find({
+    facilityId,
+    accountType: "income",
+    isActive: true,
+  }).sort({ accountName: 1 });
+};
+
+// Static method to find expense accounts
+ZohoAccountSchema.statics.findExpenseAccounts = function (facilityId) {
+  return this.find({
+    facilityId,
+    accountType: "expense",
+    isActive: true,
+  }).sort({ accountName: 1 });
+};
+
+// Static method to find unsynced accounts
+ZohoAccountSchema.statics.findUnsynced = function (facilityId) {
+  return this.find({
+    facilityId,
+    $or: [{ isSynced: false }, { zohoAccountId: null }],
+    isActive: true,
+  }).sort({ createdAt: 1 });
+};
+
+// Static method to search accounts
+ZohoAccountSchema.statics.searchAccounts = function (facilityId, searchText) {
+  return this.find({
+    facilityId,
+    isActive: true,
+    $text: { $search: searchText },
+  }).sort({ score: { $meta: "textScore" } });
+};
+
+// Pre-save hook to update timestamps
+ZohoAccountSchema.pre("save", function (next) {
+  if (this.isModified() && !this.isNew) {
+    this.updatedAt = new Date();
+  }
+  next();
+});
+
+// Pre-save validation
+ZohoAccountSchema.pre("save", function (next) {
+  // Validate sub-account
+  if (this.parentAccountId && !this.isSubAccount) {
+    this.isSubAccount = true;
+  }
+  if (!this.parentAccountId && this.isSubAccount) {
+    this.isSubAccount = false;
+  }
+
+  // System accounts cannot be deleted
+  if (this.isSystemAccount) {
+    this.canBeDeleted = false;
+  }
+
+  next();
+});
+
+// Instance method to convert to Zoho format
+ZohoAccountSchema.methods.toZohoFormat = function () {
+  const zohoAccount = {
+    account_name: this.accountName,
+    account_type: this.accountType,
+  };
+
+  // Add optional fields
+  if (this.accountCode) {
+    zohoAccount.account_code = this.accountCode;
+  }
+  if (this.description) {
+    zohoAccount.description = this.description;
+  }
+  if (this.zohoParentAccountId) {
+    zohoAccount.parent_account_id = this.zohoParentAccountId;
+  }
+  if (this.currencyCode) {
+    zohoAccount.currency_code = this.currencyCode;
+  }
+
+  return zohoAccount;
+};
+
+// Instance method to update from Zoho data
+ZohoAccountSchema.methods.updateFromZoho = function (zohoData) {
+  if (zohoData.account_id) this.zohoAccountId = zohoData.account_id;
+  if (zohoData.account_name) this.accountName = zohoData.account_name;
+  if (zohoData.account_code) this.accountCode = zohoData.account_code;
+  if (zohoData.account_type) this.accountType = zohoData.account_type;
+  if (zohoData.account_number) this.zohoAccountNumber = zohoData.account_number;
+  if (zohoData.description) this.description = zohoData.description;
+  if (zohoData.is_active !== undefined) this.isActive = zohoData.is_active;
+  if (zohoData.currency_id) this.zohoCurrencyId = zohoData.currency_id;
+  if (zohoData.currency_code) this.currencyCode = zohoData.currency_code;
+  if (zohoData.parent_account_id) this.zohoParentAccountId = zohoData.parent_account_id;
+  if (zohoData.depth !== undefined) {
+    this.depth = zohoData.depth;
+    this.zohoDepth = zohoData.depth;
+  }
+
+  this.isSynced = true;
+  this.lastSyncedAt = new Date();
+  this.syncStatus = "synced";
+
+  return this.save();
+};
+
+// Static method to build account hierarchy
+ZohoAccountSchema.statics.getAccountTree = async function (facilityId) {
+  const accounts = await this.find({ facilityId, isActive: true })
+    .populate("parentAccountId")
+    .sort({ accountType: 1, accountName: 1 });
+
+  // Build tree structure
+  const accountMap = {};
+  const tree = [];
+
+  accounts.forEach((account) => {
+    accountMap[account._id] = {
+      ...account.toObject(),
+      children: [],
+    };
+  });
+
+  accounts.forEach((account) => {
+    if (account.parentAccountId) {
+      const parent = accountMap[account.parentAccountId];
+      if (parent) {
+        parent.children.push(accountMap[account._id]);
+      }
+    } else {
+      tree.push(accountMap[account._id]);
+    }
+  });
+
+  return tree;
+};
+
+const ZohoAccount = mongoose.model("ZohoAccount", ZohoAccountSchema);
+
+module.exports = ZohoAccount;