payservedb 9.0.0 → 9.0.2

package/index.js

@@ -259,8 +259,76 @@ const models = {
   MoveinLandlord: require("./src/models/movein_landlord"),
   MoveinUser: require("./src/models/movein_user"),
   InvoiceWithholdingTax: require("./src/models/InvoiceWithholdingTax"),
+  // Customer Obsession admin-managed config
+  EmailCcConfig: require("./src/models/email_cc_config"),
+  AutoReplyRule: require("./src/models/auto_reply_rule"),
+  RecipientGroup: require("./src/models/recipient_group"),
+  RecipientGroupMember: require("./src/models/recipient_group_member"),
 };
 
+// ── Move-In platform model schema sources (keyed by model name) ─────────────
+const moveInModelDefs = {
+  MoveInUser:         { file: "./src/models/movein_user",         name: "MoveInUser" },
+  MoveInUnit:         { file: "./src/models/movein_unit",         name: "MoveInUnit" },
+  MoveInLandlord:     { file: "./src/models/movein_landlord",     name: "MoveInLandlord" },
+  MoveInApplication:  { file: "./src/models/movein_application",  name: "MoveInApplication" },
+  CustomerPreference: { file: "./src/models/customer_preference", name: "CustomerPreference" },
+  MoveInViewingSlot:  { file: "./src/models/movein_viewing_slot", name: "MoveInViewingSlot" },
+  MoveInBooking:      { file: "./src/models/movein_booking",      name: "MoveInBooking" },
+  MoveInReservation:  { file: "./src/models/movein_reservation",  name: "MoveInReservation" },
+  MoveInPayment:      { file: "./src/models/movein_payment",      name: "MoveInPayment" },
+  MoveInDeal:         { file: "./src/models/movein_deal",         name: "MoveInDeal" },
+  MoveInCommission:   { file: "./src/models/movein_commission",   name: "MoveInCommission" },
+  MoveInNotification: { file: "./src/models/movein_notification", name: "MoveInNotification" },
+  MoveInAuditLog:     { file: "./src/models/movein_audit_log",    name: "MoveInAuditLog" },
+  MoveInOtp:          { file: "./src/models/movein_otp",          name: "MoveInOtp" },
+  MoveInConversation: { file: "./src/models/movein_conversation", name: "MoveInConversation" },
+  MoveInMessage:      { file: "./src/models/movein_message",      name: "MoveInMessage" },
+  MoveInLandlordUser: { file: "./src/models/movein_landlord_user", name: "MoveInLandlordUser" },
+  MoveInHandoffToken: { file: "./src/models/movein_handoff_token", name: "MoveInHandoffToken" },
+};
+
+// Initial moveIn namespace — models on default connection (payserve_property).
+// connectToMoveInDB replaces these with models bound to payserve_movein.
+const moveInModels = {};
+for (const [key, def] of Object.entries(moveInModelDefs)) {
+  moveInModels[key] = require(def.file);
+}
+
+// Opens a dedicated connection to payserve_movein and re-registers all
+// Move-In models on that connection so queries hit the correct database.
+async function connectToMoveInDB(dbName, secured, username, password, url, port) {
+  try {
+    let connectionString;
+    if (secured === false) {
+      connectionString = `mongodb://${url}:${port}/${dbName}`;
+    } else {
+      const source = "?authSource=admin";
+      connectionString = `mongodb://${username}:${password}@${url}:${port}/${dbName}${source}`;
+    }
+
+    const conn = await mongoose.createConnection(connectionString, {
+      useNewUrlParser: true,
+    });
+
+    console.log(`Connected to Move-In DB: ${dbName}`);
+
+    for (const [key, def] of Object.entries(moveInModelDefs)) {
+      const baseModel = require(def.file);
+      const schema = baseModel.schema;
+      moveInModels[key] = conn.models[def.name]
+        ? conn.models[def.name]
+        : conn.model(def.name, schema);
+    }
+
+    module.exports.moveInConnection = conn;
+    return conn;
+  } catch (err) {
+    console.error("Error connecting to Move-In DB:", err);
+    throw err;
+  }
+}
+
 // Function to get models dynamically from a specific database connection
 async function getModelFromDB(dbConnection, modelName, schema) {
   if (!dbConnection.models[modelName]) {
@@ -323,6 +391,7 @@ function initializeService(modelNames = []) {
 
 module.exports = {
   connectToMongoDB,
+  connectToMoveInDB,
   switchDB,
   getModelFromDB,
   initializeService,

package/package.json

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

package/src/models/auto_reply_rule.js

@@ -0,0 +1,68 @@
+const mongoose = require('mongoose');
+
+/**
+ * Admin-managed auto-reply rules. On every inbound email or WhatsApp
+ * message, the matcher (utils/auto_reply.js) walks enabled rules ordered by
+ * priority and fires the FIRST rule whose keyword appears in the body as a
+ * whole word (case-insensitive). Senders from @payserve.co.ke are skipped.
+ *
+ * Replaces the legacy per-agent immediate / delay UI that used to live in
+ * customer_obsession/settings/agent_settings.js (PR4).
+ */
+const autoReplyRuleSchema = new mongoose.Schema({
+  channel: {
+    type: String,
+    enum: ['email', 'whatsapp'],
+    required: [true, 'channel is required'],
+    index: true,
+  },
+  keyword: {
+    type: String,
+    required: [true, 'keyword is required'],
+    trim: true,
+    maxlength: 100,
+  },
+  reply: {
+    type: String,
+    required: [true, 'reply text is required'],
+    trim: true,
+    maxlength: 1000,
+  },
+  priority: {
+    type: Number,
+    default: 0,
+    index: true,
+  },
+  enabled: {
+    type: Boolean,
+    default: true,
+  },
+  created_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  updated_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  created_at: {
+    type: Date,
+    default: Date.now,
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now,
+  },
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
+});
+
+// First-match-wins semantics — duplicate (channel, keyword) makes lower-priority
+// rules unreachable. Enforced at the DB level.
+autoReplyRuleSchema.index({ channel: 1, keyword: 1 }, {
+  unique: true,
+  collation: { locale: 'en', strength: 2 }, // case-insensitive
+});
+autoReplyRuleSchema.index({ channel: 1, priority: 1 });
+
+module.exports = mongoose.model('AutoReplyRule', autoReplyRuleSchema);

package/src/models/email_cc_config.js

@@ -0,0 +1,48 @@
+const mongoose = require('mongoose');
+
+/**
+ * Admin-managed always-CC list for outbound agent-sent emails.
+ *
+ * Every enabled row is appended to the CC of every email reply / new send /
+ * bulk send that originates from an agent. Auto-replies bypass this list.
+ *
+ * Managed from core_main at /core/customer-obsession/email-cc-config. Agents
+ * read the enabled subset via /api/customer_obsession/settings/email-cc.
+ */
+const emailCcConfigSchema = new mongoose.Schema({
+  address: {
+    type: String,
+    required: [true, 'Email address is required'],
+    trim: true,
+    lowercase: true,
+    maxlength: 254,
+    match: [/^[^\s@]+@[^\s@]+\.[^\s@]+$/, 'Invalid email address'],
+  },
+  enabled: {
+    type: Boolean,
+    default: true,
+  },
+  added_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  updated_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  created_at: {
+    type: Date,
+    default: Date.now,
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now,
+  },
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
+});
+
+emailCcConfigSchema.index({ address: 1 }, { unique: true });
+emailCcConfigSchema.index({ enabled: 1 });
+
+module.exports = mongoose.model('EmailCcConfig', emailCcConfigSchema);

package/src/models/movein_audit_log.js

@@ -0,0 +1,21 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInAuditLogSchema = new mongoose.Schema(
+    {
+        adminId:      { type: ObjectId, ref: 'User', default: null, index: true },
+        action:       { type: String, required: true },
+        resourceType: {
+            type: String,
+            enum: ['listing', 'application', 'customer', 'landlord', 'reservation', 'payment', 'viewing', 'other'],
+            required: true,
+        },
+        resourceId:   { type: ObjectId, default: null, index: true },
+        details:      { type: String, default: null },
+        ipAddress:    { type: String, default: null },
+    },
+    { timestamps: true }
+);
+
+const MoveInAuditLog = mongoose.model('MoveInAuditLog', moveInAuditLogSchema);
+module.exports = MoveInAuditLog;

package/src/models/movein_booking.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInBookingSchema = new mongoose.Schema(
+    {
+        slotId:       { type: ObjectId, ref: 'MoveInViewingSlot', default: null, index: true },
+        tenantId:     { type: ObjectId, ref: 'MoveInUser', default: null, index: true },
+        tenantName:   { type: String, default: null },
+        tenantEmail:  { type: String, default: null },
+        tenantPhone:  { type: String, default: null },
+        isGuest:      { type: Boolean, default: false, index: true },
+        unitId:       { type: ObjectId, required: true, index: true },
+        unitName:     { type: String, default: null },
+        facilityId:   { type: ObjectId, ref: 'Facility', default: null, index: true },
+        landlordId:   { type: ObjectId, ref: 'User', default: null, index: true },
+        scheduledDate:{ type: Date, default: null },
+        scheduledTime:{ type: String, default: null },
+        status: {
+            type: String,
+            enum: ['pending', 'confirmed', 'cancelled', 'completed'],
+            default: 'pending',
+            index: true,
+        },
+        tenantNote:   { type: String, default: null },
+        landlordNote: { type: String, default: null },
+        cancelledAt:  { type: Date, default: null },
+        cancelReason: { type: String, default: null },
+    },
+    { timestamps: true }
+);
+
+const MoveInBooking = mongoose.model('MoveInBooking', moveInBookingSchema);
+module.exports = MoveInBooking;

package/src/models/movein_commission.js

@@ -0,0 +1,46 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInCommissionSchema = new mongoose.Schema(
+    {
+        dealId:      { type: ObjectId, ref: 'MoveInDeal', required: true, index: true },
+        unitId:      { type: ObjectId, required: true, index: true },
+        unitName:    { type: String, default: null },
+        landlordId:  { type: ObjectId, default: null, index: true },
+        tenantId:    { type: ObjectId, ref: 'MoveInUser', default: null, index: true },
+        tenantEmail: { type: String, default: null, index: true },
+        payerType: {
+            type: String,
+            enum: ['landlord', 'tenant', 'owner', 'admin'],
+            default: 'landlord',
+            index: true,
+        },
+        ruleType: {
+            type: String,
+            enum: ['percentage_of_rent', 'fixed', 'manual'],
+            default: 'percentage_of_rent',
+        },
+        ruleValue:     { type: Number, default: 10 },
+        baseAmount:    { type: Number, required: true },
+        amount:        { type: Number, required: true },
+        currency:      { type: String, default: 'KES' },
+        status: {
+            type: String,
+            enum: ['due', 'invoiced', 'paid', 'waived', 'refunded', 'disputed', 'cancelled'],
+            default: 'due',
+            index: true,
+        },
+        dueAt:         { type: Date, default: null },
+        invoiceRef:    { type: String, default: null, index: true },
+        paymentRef:    { type: String, default: null, index: true },
+        paymentMethod: { type: String, default: null },
+        paidAt:        { type: Date, default: null },
+        notes:         { type: String, default: null },
+    },
+    { timestamps: true }
+);
+
+moveInCommissionSchema.index({ dealId: 1, status: 1 });
+
+const MoveInCommission = mongoose.model('MoveInCommission', moveInCommissionSchema);
+module.exports = MoveInCommission;

package/src/models/movein_conversation.js

@@ -0,0 +1,25 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInConversationSchema = new mongoose.Schema(
+    {
+        tenantId:      { type: ObjectId, ref: 'MoveInUser', required: true, index: true },
+        landlordId:    { type: ObjectId, ref: 'User', required: true, index: true },
+        unitId:        { type: ObjectId, required: true, index: true },
+        unitName:      { type: String, default: null },
+        lastMessage:   { type: String, default: null },
+        lastMessageAt: { type: Date, default: null },
+        tenantUnread:  { type: Number, default: 0 },
+        landlordUnread:{ type: Number, default: 0 },
+        status: {
+            type: String,
+            enum: ['active', 'closed'],
+            default: 'active',
+            index: true,
+        },
+    },
+    { timestamps: true }
+);
+
+const MoveInConversation = mongoose.model('MoveInConversation', moveInConversationSchema);
+module.exports = MoveInConversation;

package/src/models/movein_deal.js

@@ -0,0 +1,79 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInDealSchema = new mongoose.Schema(
+    {
+        unitId:        { type: ObjectId, required: true, index: true },
+        unitName:      { type: String, default: null },
+        source: {
+            type: String,
+            enum: ['standalone', 'payserve'],
+            default: 'standalone',
+            index: true,
+        },
+        sourceFacilityId: { type: ObjectId, ref: 'Facility', default: null, index: true },
+        sourceUnitId:     { type: ObjectId, default: null, index: true },
+        landlordId:       { type: ObjectId, default: null, index: true },
+        tenantId:         { type: ObjectId, ref: 'MoveInUser', default: null, index: true },
+        tenantName:       { type: String, default: null },
+        tenantEmail:      { type: String, default: null, index: true },
+        tenantPhone:      { type: String, default: null },
+        isGuest:          { type: Boolean, default: false, index: true },
+        applicationId:    { type: ObjectId, ref: 'MoveInApplication', default: null, index: true },
+        reservationId:    { type: ObjectId, ref: 'MoveInReservation', default: null, index: true },
+        bookingId:        { type: ObjectId, ref: 'MoveInBooking', default: null, index: true },
+        desiredMoveInDate:{ type: Date, default: null },
+        agreedMoveInDate: { type: Date, default: null },
+        agreedRentAmount: { type: Number, default: null },
+        currency:         { type: String, default: 'KES' },
+        status: {
+            type: String,
+            enum: [
+                'lead',
+                'viewing_requested',
+                'viewing_confirmed',
+                'applied',
+                'application_approved',
+                'reserved',
+                'offer_sent',
+                'tenant_confirmed',
+                'payment_pending',
+                'rented',
+                'cancelled',
+                'expired',
+                'lost',
+            ],
+            default: 'lead',
+            index: true,
+        },
+        commissionStatus: {
+            type: String,
+            enum: ['not_due', 'due', 'invoiced', 'paid', 'waived', 'refunded', 'disputed'],
+            default: 'not_due',
+            index: true,
+        },
+        lastEvent:       { type: String, default: null },
+        cancelledReason: { type: String, default: null },
+        notes:           { type: String, default: null },
+        payserveSync: {
+            status: {
+                type: String,
+                enum: ['not_applicable', 'pending', 'synced', 'failed'],
+                default: 'not_applicable',
+            },
+            residentId: { type: ObjectId, default: null },
+            leaseId:    { type: ObjectId, default: null },
+            invoiceId:  { type: ObjectId, default: null },
+            lastError:  { type: String, default: null },
+            syncedAt:   { type: Date, default: null },
+        },
+    },
+    { timestamps: true }
+);
+
+moveInDealSchema.index({ unitId: 1, status: 1 });
+moveInDealSchema.index({ tenantId: 1, unitId: 1 });
+moveInDealSchema.index({ tenantEmail: 1, unitId: 1 });
+
+const MoveInDeal = mongoose.model('MoveInDeal', moveInDealSchema);
+module.exports = MoveInDeal;

package/src/models/movein_handoff_token.js

@@ -0,0 +1,16 @@
+const mongoose = require('mongoose');
+
+// Short-lived, single-use token that lets a landlord_main session
+// bootstrap a Move-In session without re-logging in.
+const moveInHandoffTokenSchema = new mongoose.Schema(
+    {
+        token:      { type: String, required: true, unique: true, index: true },
+        landlordId: { type: mongoose.Schema.Types.ObjectId, required: true, index: true },
+        used:       { type: Boolean, default: false },
+        expiresAt:  { type: Date, required: true },
+    },
+    { timestamps: true }
+);
+
+const MoveInHandoffToken = mongoose.model('MoveInHandoffToken', moveInHandoffTokenSchema);
+module.exports = MoveInHandoffToken;

package/src/models/movein_landlord_user.js

@@ -0,0 +1,20 @@
+const mongoose = require('mongoose');
+
+const moveInLandlordUserSchema = new mongoose.Schema(
+    {
+        fullName:       { type: String, required: true, trim: true },
+        email:          { type: String, required: true, unique: true, lowercase: true, trim: true },
+        phoneNumber:    { type: String, required: true, unique: true },
+        // Standalone landlords have a bcrypt password.
+        // PayServe-linked landlords have MANAGED_BY_PAYSERVE — auth defers to payserve_property.
+        password:       { type: String, default: 'MANAGED_BY_PAYSERVE' },
+        companyName:    { type: String, trim: true, default: null },
+        isEnabled:      { type: Boolean, default: true },
+        // Set when provisioned from an existing PayServe landlord account.
+        payserveUserId: { type: mongoose.Schema.Types.ObjectId, default: null, index: true },
+    },
+    { timestamps: true }
+);
+
+const MoveInLandlordUser = mongoose.model('MoveInLandlordUser', moveInLandlordUserSchema);
+module.exports = MoveInLandlordUser;

package/src/models/movein_message.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInMessageSchema = new mongoose.Schema(
+    {
+        conversationId: { type: ObjectId, ref: 'MoveInConversation', required: true, index: true },
+        senderId:       { type: ObjectId, required: true, index: true },
+        senderType: {
+            type: String,
+            enum: ['tenant', 'landlord'],
+            required: true,
+        },
+        body:          { type: String, required: true },
+        type: {
+            type: String,
+            enum: ['text', 'image'],
+            default: 'text',
+        },
+        attachmentUrl: { type: String, default: null },
+        isRead:        { type: Boolean, default: false, index: true },
+        readAt:        { type: Date, default: null },
+    },
+    { timestamps: true }
+);
+
+const MoveInMessage = mongoose.model('MoveInMessage', moveInMessageSchema);
+module.exports = MoveInMessage;

package/src/models/movein_notification.js

@@ -0,0 +1,27 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInNotificationSchema = new mongoose.Schema(
+    {
+        recipientId: { type: ObjectId, required: true, index: true },
+        recipientType: {
+            type: String,
+            enum: ['tenant', 'landlord'],
+            required: true,
+        },
+        title:   { type: String, required: true },
+        body:    { type: String, required: true },
+        type: {
+            type: String,
+            enum: ['application', 'viewing', 'reservation', 'payment', 'message', 'general'],
+            default: 'general',
+        },
+        relatedId:   { type: ObjectId, default: null },
+        isRead:      { type: Boolean, default: false, index: true },
+        readAt:      { type: Date, default: null },
+    },
+    { timestamps: true }
+);
+
+const MoveInNotification = mongoose.model('MoveInNotification', moveInNotificationSchema);
+module.exports = MoveInNotification;

package/src/models/movein_otp.js

@@ -0,0 +1,14 @@
+const mongoose = require('mongoose');
+
+const moveInOtpSchema = new mongoose.Schema(
+    {
+        email:     { type: String, required: true, lowercase: true, trim: true, index: true },
+        otp:       { type: String, required: true },
+        expiresAt: { type: Date, required: true },
+        used:      { type: Boolean, default: false },
+    },
+    { timestamps: true }
+);
+
+const MoveInOtp = mongoose.model('MoveInOtp', moveInOtpSchema);
+module.exports = MoveInOtp;

package/src/models/movein_payment.js

@@ -0,0 +1,46 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInPaymentSchema = new mongoose.Schema(
+    {
+        tenantId:    { type: ObjectId, ref: 'MoveInUser', default: null, index: true },
+        tenantName:  { type: String, default: null },
+        unitId:      { type: ObjectId, default: null, index: true },
+        unitName:    { type: String, default: null },
+        reservationId: { type: ObjectId, ref: 'MoveInReservation', default: null, index: true },
+        dealId: { type: ObjectId, ref: 'MoveInDeal', default: null, index: true },
+        commissionId: { type: ObjectId, ref: 'MoveInCommission', default: null, index: true },
+        type: {
+            type: String,
+            enum: ['reservation_fee', 'deposit', 'first_month_rent', 'commission', 'other'],
+            required: true,
+        },
+        amount:        { type: Number, required: true },
+        currency:      { type: String, default: 'KES' },
+        status: {
+            type: String,
+            enum: ['pending', 'paid', 'failed', 'refunded', 'waived', 'cancelled', 'disputed'],
+            default: 'pending',
+            index: true,
+        },
+        reference:     { type: String, default: null },
+        externalReference: { type: String, default: null, index: true },
+        paymentMethod: {
+            type: String,
+            enum: ['mpesa', 'card', 'cash', 'other'],
+            default: null,
+        },
+        payerType: {
+            type: String,
+            enum: ['tenant', 'landlord', 'owner', 'admin'],
+            default: 'tenant',
+            index: true,
+        },
+        paidAt:  { type: Date, default: null },
+        notes:   { type: String, default: null },
+    },
+    { timestamps: true }
+);
+
+const MoveInPayment = mongoose.model('MoveInPayment', moveInPaymentSchema);
+module.exports = MoveInPayment;

package/src/models/movein_reservation.js

@@ -0,0 +1,31 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInReservationSchema = new mongoose.Schema(
+    {
+        tenantId:         { type: ObjectId, ref: 'MoveInUser', default: null, index: true },
+        tenantName:       { type: String, default: null },
+        tenantEmail:      { type: String, default: null },
+        tenantPhone:      { type: String, default: null },
+        isGuest:          { type: Boolean, default: false, index: true },
+        unitId:           { type: ObjectId, required: true, index: true },
+        unitName:         { type: String, default: null },
+        facilityId:       { type: ObjectId, ref: 'Facility', default: null, index: true },
+        landlordId:       { type: ObjectId, ref: 'User', default: null, index: true },
+        desiredMoveInDate:{ type: Date, default: null },
+        monthsToStay:     { type: Number, default: null },
+        status: {
+            type: String,
+            enum: ['pending', 'confirmed', 'expired', 'cancelled'],
+            default: 'pending',
+            index: true,
+        },
+        expiresAt:    { type: Date, default: null },
+        adminNote:    { type: String, default: null },
+        landlordNote: { type: String, default: null },
+    },
+    { timestamps: true }
+);
+
+const MoveInReservation = mongoose.model('MoveInReservation', moveInReservationSchema);
+module.exports = MoveInReservation;

package/src/models/movein_unit.js

@@ -0,0 +1,59 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInUnitSchema = new mongoose.Schema(
+    {
+        landlordId: { type: ObjectId, ref: 'User', required: true, index: true },
+        title: { type: String, required: true, trim: true },
+        description: { type: String, default: null },
+        listingType: {
+            type: String,
+            enum: ['Apartment', 'Studio', 'Bedsitter', 'Bungalow', 'Maisonette', 'Townhouse', 'Villa', 'Office'],
+            default: null,
+        },
+        bedrooms: { type: Number, default: null },
+        bathrooms: { type: Number, default: null },
+        grossArea: { type: Number, default: null },
+        price: { type: Number, required: true },
+        location: {
+            address: { type: String, default: null },
+            area: { type: String, default: null, index: true },
+            city: { type: String, default: null, index: true },
+            county: { type: String, default: null },
+            landmarks: { type: [String], default: [] },
+            googleMapsUrl: { type: String, default: null },
+            coordinates: {
+                lat: { type: Number, default: null },
+                lng: { type: Number, default: null },
+            },
+        },
+        amenities: { type: [String], default: [] },
+        nearbyServices: { type: [String], default: [] },
+        images: {
+            type: [{
+                category: { type: String, default: 'Other' },
+                label:    { type: String, default: '' },
+                url:      { type: String, required: true },
+            }],
+            default: [],
+        },
+        moveInApproval: {
+            type: String,
+            enum: ['pending', 'approved', 'rejected'],
+            default: null,
+            index: true,
+        },
+        isListed: { type: Boolean, default: false, index: true },
+        moveInStatus: {
+            type: String,
+            enum: ['draft', 'pending_approval', 'approved_unlisted', 'listed', 'under_offer', 'reserved', 'rented', 'suspended'],
+            default: 'draft',
+            index: true,
+        },
+        activeDealId: { type: ObjectId, ref: 'MoveInDeal', default: null, index: true },
+    },
+    { timestamps: true }
+);
+
+const MoveInUnit = mongoose.model('MoveInUnit', moveInUnitSchema);
+module.exports = MoveInUnit;

package/src/models/movein_viewing_slot.js

@@ -0,0 +1,21 @@
+const mongoose = require('mongoose');
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const moveInViewingSlotSchema = new mongoose.Schema(
+    {
+        landlordId:  { type: ObjectId, ref: 'User', required: true, index: true },
+        unitId:      { type: ObjectId, required: true, index: true },
+        unitName:    { type: String, default: null },
+        facilityId:  { type: ObjectId, ref: 'Facility', default: null, index: true },
+        date:        { type: Date, required: true, index: true },
+        time:        { type: String, required: true },           // "14:00"
+        durationMins:{ type: Number, default: 30 },
+        capacity:    { type: Number, default: 1 },              // max bookings for this slot
+        bookedCount: { type: Number, default: 0 },
+        isAvailable: { type: Boolean, default: true, index: true },
+    },
+    { timestamps: true }
+);
+
+const MoveInViewingSlot = mongoose.model('MoveInViewingSlot', moveInViewingSlotSchema);
+module.exports = MoveInViewingSlot;

package/src/models/recipient_group.js

@@ -0,0 +1,61 @@
+const mongoose = require('mongoose');
+
+/**
+ * Admin-managed recipient group. Agents pick from these groups when sending
+ * bulk email or WhatsApp messages. Membership lives in `recipient_group_member`.
+ *
+ * Channel determines what kind of bulk send can target this group:
+ *   - 'email'   : every member needs an email
+ *   - 'whatsapp': every member needs a phone
+ *   - 'both'    : every member needs both
+ */
+const recipientGroupSchema = new mongoose.Schema({
+  name: {
+    type: String,
+    required: [true, 'Group name is required'],
+    trim: true,
+    maxlength: 120,
+  },
+  channel: {
+    type: String,
+    enum: ['email', 'whatsapp', 'both'],
+    required: [true, 'channel is required'],
+    index: true,
+  },
+  description: {
+    type: String,
+    trim: true,
+    maxlength: 500,
+  },
+  member_count: {
+    type: Number,
+    default: 0,
+    min: 0,
+  },
+  created_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  updated_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  created_at: {
+    type: Date,
+    default: Date.now,
+  },
+  updated_at: {
+    type: Date,
+    default: Date.now,
+  },
+}, {
+  timestamps: { createdAt: 'created_at', updatedAt: 'updated_at' },
+});
+
+recipientGroupSchema.index({ name: 1 }, {
+  unique: true,
+  collation: { locale: 'en', strength: 2 },
+});
+recipientGroupSchema.index({ channel: 1, created_at: -1 });
+
+module.exports = mongoose.model('RecipientGroup', recipientGroupSchema);

package/src/models/recipient_group_member.js

@@ -0,0 +1,62 @@
+const mongoose = require('mongoose');
+
+/**
+ * Members of a recipient group. Either references an existing Customer
+ * (`customer_id`) for first-class membership or carries free-form
+ * `email`/`phone`/`name` for ad-hoc additions (landlords, contractors, etc.).
+ *
+ * Dedup happens at insert time: see add_members controller. The group's
+ * `member_count` is denormalised on the parent for cheap listing.
+ */
+const recipientGroupMemberSchema = new mongoose.Schema({
+  group_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'RecipientGroup',
+    required: true,
+    index: true,
+  },
+  customer_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Customer',
+  },
+  name: {
+    type: String,
+    trim: true,
+    maxlength: 200,
+  },
+  email: {
+    type: String,
+    trim: true,
+    lowercase: true,
+    maxlength: 254,
+  },
+  phone: {
+    type: String,
+    trim: true,
+    maxlength: 30,
+  },
+  added_by: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'User',
+  },
+  added_at: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+// Dedup helpers
+recipientGroupMemberSchema.index({ group_id: 1, customer_id: 1 }, {
+  unique: true,
+  partialFilterExpression: { customer_id: { $type: 'objectId' } },
+});
+recipientGroupMemberSchema.index({ group_id: 1, email: 1 }, {
+  unique: true,
+  partialFilterExpression: { email: { $type: 'string' } },
+});
+recipientGroupMemberSchema.index({ group_id: 1, phone: 1 }, {
+  unique: true,
+  partialFilterExpression: { phone: { $type: 'string' } },
+});
+
+module.exports = mongoose.model('RecipientGroupMember', recipientGroupMemberSchema);