shuttlepro-shared 1.3.14 → 1.3.16

package/models/CustomerProfile.js

@@ -0,0 +1,27 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const CustomerProfileSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    email: { type: String, default: "" },
+    contact: { type: String, default: "" },
+    picture: { type: String, default: "" },
+    fbId: { type: String, default: "" },
+    igId: { type: String, default: "" },
+    blackList: { type: Boolean, default: false },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    mergedId: {
+      type: Schema.Types.ObjectId,
+      ref: "CustomerProfile",
+      default: null,
+    },
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("CustomerProfile", CustomerProfileSchema);

package/models/DefaultRolePermission.js

@@ -0,0 +1,34 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const DefaultRolePermissionSchema = new Schema(
+  {
+    type: {
+      type: String,
+      default: "",
+    },
+    roleId: {
+      type: Schema.Types.ObjectId,
+      ref: "Role",
+      default: null,
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const fields = ["role", "module", "action", "value"];
+
+fields.forEach((field) => {
+  DefaultRolePermissionSchema.add({
+    [field]: {
+      type: String,
+      required: true,
+      default: "",
+    },
+  });
+});
+
+module.exports = mongoose.model(
+  "DefaultRolePermission",
+  DefaultRolePermissionSchema
+);

package/models/DescriptionTemplate.js

@@ -0,0 +1,22 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const DescriptionTemplateSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    subject: { type: String, default: "" },
+    format: { type: String, default: "" },
+    workspaceId: { type: String, default: "" },
+    businessId: { type: String, default: "" },
+    integrationId: { type: String, default: "" },
+    type: { type: String, default: "" },
+    body: {},
+    arbitraryValues: {},
+    moduleType: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+const DescriptionTemplate =
+  mongoose.models.DescriptionTemplate ||
+  mongoose.model("DescriptionTemplate", DescriptionTemplateSchema);
+
+module.exports = DescriptionTemplate;

package/models/Integration.js

@@ -0,0 +1,51 @@
+const mongoose = require("mongoose");
+const IntegrationSchema = new mongoose.Schema(
+  {
+    workspaceId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    type: {
+      type: String,
+      enum: [
+        "socialPlatforms",
+        "whatsapp",
+        "gmail",
+        "sms",
+        "map",
+        "facebook",
+        "instagram",
+        "webChat",
+        "smtp_gmail",
+        "outlook",
+        "business_central",
+      ],
+    },
+    chatbot: { type: Boolean, default: false },
+    isNlp: { type: Boolean, default: false },
+    autoTicket: {
+      enabled: { type: Boolean, default: false },
+    },
+    signature: {
+      type: Map,
+      of: mongoose.Schema.Types.Mixed,
+      default: {},
+    },
+    chatbotId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Chatbot",
+      default: null,
+    },
+    members: [
+      {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "User",
+      },
+    ],
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("Integration", IntegrationSchema);

package/models/Label.js

@@ -0,0 +1,42 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const LabelSchema = new Schema(
+  {
+    color: { type: String },
+    title: {
+      type: String,
+      required: true,
+    },
+    type: {
+      type: String,
+      required: true,
+      default: "system",
+      enum: ["system", "custom", "escalation"],
+    },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+LabelSchema.virtual("conversationCount", {
+  ref: "Conversation",
+  localField: "_id",
+  foreignField: "labels",
+  count: true,
+});
+
+LabelSchema.virtual("conversations", {
+  ref: "Conversation",
+  localField: "_id",
+  foreignField: "labels",
+});
+
+LabelSchema.set("toObject", { virtuals: true });
+LabelSchema.set("toJSON", { virtuals: true });
+
+const Label = mongoose.model("Label", LabelSchema);
+
+module.exports = Label;

package/models/Message.js

@@ -0,0 +1,47 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const readBySchema = new Schema({
+  receiptTrigger: { type: Boolean, default: false },
+  readerId: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  readTime: { type: String, default: "" },
+  responseTime: { type: String, default: "" },
+});
+
+const newMessageSchema = new mongoose.Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    readBy: [readBySchema],
+    messageType: {
+      type: String,
+      enum: [
+        "system",
+        "user",
+        "internal",
+        "chatbot",
+        "auto-generated",
+        "facebook",
+        "instagram",
+        "webChat",
+        "chat-status",
+      ],
+      required: true,
+    },
+    conversationId: {
+      type: Schema.Types.ObjectId,
+      ref: "Conversation",
+      default: null,
+    },
+    conversationType: { type: String },
+    activityId: { type: String, default: "" },
+
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("Message", newMessageSchema);

package/models/NewProduct.js

@@ -0,0 +1,71 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const NewProductSchema = new Schema(
+  {
+    id: {
+      type: Schema.Types.ObjectId,
+      ref: "Product",
+      default: null,
+    },
+    name: { type: String, default: "" },
+    description: { type: String, default: "" },
+    sku: { type: String, default: "" },
+    price: { type: String, default: 0 },
+    quantity: { type: Number, default: 0 },
+    imageUrl: { type: String, default: "" },
+    costPrice: { type: String, default: 0 },
+    salePrice: { type: String, default: 0 },
+    webProductId: { type: Number, default: null },
+    variants: [],
+    attachments: [],
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+  },
+  {
+    timestamps: true,
+    toJSON: { virtuals: true },
+    toObject: { virtuals: true },
+  }
+);
+
+// Adding compound text index for name, sku, and variants
+NewProductSchema.index({
+  name: "text",
+  sku: "text",
+  "variants.name": "text",
+  "variants.sku": "text",
+});
+
+// Adding separate indexes for frequent query conditions
+NewProductSchema.index({
+  workspaceId: 1,
+  name: 1,
+});
+
+NewProductSchema.index({
+  workspaceId: 1,
+  sku: 1,
+});
+
+NewProductSchema.index({
+  workspaceId: 1,
+  "variants.name": 1,
+});
+
+NewProductSchema.index({
+  workspaceId: 1,
+  "variants.sku": 1,
+});
+
+// Index for attachments existence check
+NewProductSchema.index({
+  attachments: 1,
+});
+
+const NewProduct = mongoose.model("NewProduct", NewProductSchema);
+
+module.exports = NewProduct;

package/models/NotificationSettings.js

@@ -0,0 +1,130 @@
+const { model, Schema } = require("mongoose");
+
+const NotificationSettingsSchema = new Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+
+    orders: {
+      type: {
+        createOrder: {
+          type: Boolean,
+          default: false,
+        },
+        orderAssign: {
+          type: Boolean,
+          default: false,
+        },
+        orderComment: {
+          type: Boolean,
+          default: false,
+        },
+      },
+      default: {
+        createOrder: false,
+        orderAssign: false,
+        orderComment: false,
+      },
+    },
+
+    products: {
+      type: Boolean,
+      default: false,
+    },
+
+    socialProfiles: {
+      type: {
+        socialProfileComment: {
+          type: Boolean,
+          default: false,
+        },
+        story: {
+          type: Boolean,
+          default: false,
+        },
+      },
+      default: {
+        socialProfileComment: false,
+        story: false,
+      },
+    },
+
+    conversation: {
+      type: {
+        instaMessage: {
+          type: Boolean,
+          default: false,
+        },
+        fbMessage: {
+          type: Boolean,
+          default: false,
+        },
+        whatsapp: {
+          type: Boolean,
+          default: false,
+        },
+        instaComment: {
+          type: Boolean,
+          default: false,
+        },
+        fbComment: {
+          type: Boolean,
+          default: false,
+        },
+        email: {
+          type: Boolean,
+          default: false,
+        },
+      },
+      default: {
+        instaMessage: false,
+        fbMessage: false,
+        instaComment: false,
+        fbComment: false,
+        email: false,
+        whatsapp: false,
+      },
+    },
+
+    taskManager: {
+      type: {
+        cardAssign: {
+          type: Boolean,
+          default: false,
+        },
+        cardMove: {
+          type: Boolean,
+          default: false,
+        },
+      },
+      default: {
+        cardAssign: false,
+        cardMove: false,
+      },
+    },
+
+    sound: {
+      type: {
+        play: {
+          type: Boolean,
+          default: true,
+        },
+      },
+      default: {
+        play: true,
+      },
+    },
+
+    default: {
+      type: Boolean,
+      default: true,
+    },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("NotificationSettings", NotificationSettingsSchema);

package/models/Order.js

@@ -0,0 +1,236 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const normalizePhoneNumber = (phone) => {
+  let normalized = phone.replace(/[^\d]/g, "");
+  if (normalized.startsWith("92")) {
+    normalized = normalized.replace(/^92/, "");
+  }
+  if (normalized.startsWith("0")) {
+    normalized = normalized.substring(1);
+  }
+  return normalized;
+};
+const getPhoneRegex = (phone) => {
+  const normalizedPhone = normalizePhoneNumber(phone);
+  return new RegExp(
+    `^0?${normalizedPhone}$|^\\+92${normalizedPhone}$|^${normalizedPhone}$`,
+    "i"
+  );
+};
+const _ = require("lodash");
+
+const ShipperInformation = new Schema({
+  _id: false,
+  shipperType: { type: String, default: "" },
+  weight: { type: Number, default: 0 }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  fragile: { type: Boolean, default: false }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  serviceType: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  serviceTypeId: { type: String, default: 1 }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  pieces: { type: Number, default: 0 }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  originCityName: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  remarks: { type: String, default: "" },
+  customer_note: { type: String, default: "" },
+  orderId: { type: Schema.Types.ObjectId, ref: "Order", default: null },
+  return_branch: { type: String, default: "" },
+  cityData: { type: String, default: "" }, //M&P, TRAX, INSTA, RIDER, TCS, CC
+  //TRAX
+  paymentMode: { type: Number, default: 0 },
+  addressId: { type: Number, default: 0 },
+  itemProductType: { type: Number, default: 0 },
+  shippingMode: { type: Number, default: 0 },
+  itemInsurance: { type: Boolean, default: false },
+  informationDisplay: { type: String, default: "" },
+  //Call Courier (CC)
+  shipperName: { type: String, default: "" },
+  shipperEmail: { type: String, default: "" },
+  shipperCellNo: { type: String, default: "" },
+  shipperLandlineNo: { type: String, default: "" },
+  shipperAddress: { type: String, default: "" },
+  shipperCityId: { type: Number, default: 0 },
+  shipperAreaId: { type: Number, default: 0 },
+});
+
+const OrderSchema = new Schema(
+  {
+    webOrderId: { type: String, default: "" },
+    webOrderNumber: { type: String, default: "" },
+    orderNumber: { type: String, default: "" },
+    customerId: { type: Schema.Types.ObjectId, ref: "Customer", default: null },
+    customerName: { type: String, default: "" },
+    customerPhone: { type: String, default: "" },
+    customerAddress: { type: String, default: "" },
+    cityName: { type: String, default: "" },
+    trackingId: { type: String, default: "" },
+    shipperInformation: ShipperInformation,
+    isCnGenerated: { type: Boolean, default: false },
+    swap: { type: String, default: "" },
+    status: { type: String, default: "" },
+    lastStatusTime: { type: String, default: "" },
+    statusType: { type: String, default: "" },
+    returnOrder: {
+      received: { type: Boolean, default: false },
+      restocked: { type: Boolean, default: false },
+      remarks: { type: String, default: "" },
+    },
+    statusTypeId: {
+      type: Schema.Types.ObjectId,
+      ref: "StatusType",
+      default: null,
+    },
+    statusId: {
+      type: Schema.Types.ObjectId,
+      ref: "Status",
+      default: null,
+    },
+    totalAmount: { type: Number, default: 0 },
+    payableAmount: { type: Number, default: 0 },
+    parcelValue: { type: Number, default: 0 },
+    payableAmount: { type: Number, default: 0 },
+    discountPercentage: { type: Number, default: 0 },
+    discountValue: { type: Number, default: 0 },
+    productDetails: { type: String, default: "" },
+    webOrderId: { type: String, default: "" },
+    parentOrderId: { type: Schema.Types.ObjectId, ref: "Order", default: null },
+    webOrderNumber: { type: String, default: "" },
+    fulfillmentStatus: { type: String, default: "" },
+    webFulfillmentId: { type: String, default: "" },
+    platformFinancialStatus: { type: String, default: "pending" },
+    pinLocation: { type: String, default: "" },
+    deliveryCharges: { type: Number, default: 0 },
+    tax: { type: Number, default: 0 },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    orderType: { type: String, default: "" },
+    barCode: { type: String, default: "" },
+    quantity: { type: Number, default: 0 },
+    assignTo: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    isLoadSheetGenerated: { type: Boolean, default: false },
+    orderDate: { type: String, default: "" },
+    returnDate: { type: String, default: "" },
+    receivedDate: { type: String, default: "" },
+    published: { type: Boolean, default: false },
+    isFlagged: { type: Boolean, default: false },
+    publishedTime: { type: String, default: "" },
+    paymentType: { type: String, default: "COD" },
+    isDeleted: { type: Boolean, default: false },
+    isFake: { type: Boolean, default: false },
+    statusUpdatedAt: { type: String, default: "" },
+    invalidCity: { type: Boolean, default: false },
+    invalidCredentials: { type: Boolean, default: false },
+    isConfirmed: { type: Boolean, default: false },
+    confirmedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    priority: { type: String, default: "" },
+    isBulk: { type: String, default: "" },
+    conversationId: { type: String, default: "" },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    publishedStatus: { type: String, default: "pending" },
+    isDuplicate: { type: Boolean, default: false },
+    ivrGenerated: { type: Boolean, default: false },
+    isActivityGenerated: { type: Boolean, default: false },
+    payment: {
+      isPaid: { type: Boolean, default: false },
+      paymentDate: { type: String, default: "" },
+      paymentDetails: {},
+    },
+    credentials: {},
+    ticketId: { type: String, default: "" },
+    sender: { type: String, default: "" },
+    orderName: { type: String, default: "" },
+    totalWeight: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+OrderSchema.virtual("checkPoints", {
+  ref: "Checkpoint",
+  localField: "_id",
+  foreignField: "orderId",
+});
+
+OrderSchema.virtual("orderProducts", {
+  ref: "OrderProduct",
+  localField: "_id",
+  foreignField: "orderId",
+});
+
+OrderSchema.post("save", async function (doc) {
+  try {
+    if (doc) {
+      markOrUnMarkOrderAsDuplicate(doc);
+    }
+    return { code: 200 };
+  } catch (err) {
+    console.log("err", err);
+    return { code: 400 };
+  }
+});
+
+OrderSchema.post("findOneAndUpdate", async function (doc) {
+  try {
+    if (doc) {
+      markOrUnMarkOrderAsDuplicate(doc);
+    }
+    return { code: 200 };
+  } catch (err) {
+    console.log("err", err);
+    return { code: 400 };
+  }
+});
+
+const markOrUnMarkOrderAsDuplicate = async (doc) => {
+  try {
+    if (["pending", "cancelled", "published"].includes(doc?.statusType)) {
+      if (["cancelled"].includes(doc?.statusType)) {
+        await Order.updateOne(
+          { _id: doc?._id },
+          { $set: { isDuplicate: false } }
+        );
+      }
+      const phoneRegex = getPhoneRegex(doc?.customerPhone);
+      let orders = await Order.find({
+        workspaceId: doc?.workspaceId,
+        isDeleted: false,
+        statusType: "pending",
+        customerPhone: phoneRegex,
+      })
+        .lean()
+        .exec();
+      if (orders?.length > 1) {
+        const ordersByCity = _.groupBy(orders, "cityName");
+        const bulkOps = [];
+        for (const cityName in ordersByCity) {
+          const cityOrders = ordersByCity[cityName];
+          const isDuplicate = cityOrders.length > 1;
+          const orderIds = cityOrders.map((order) => order?._id);
+          bulkOps.push({
+            updateMany: {
+              filter: { _id: { $in: orderIds } },
+              update: { $set: { isDuplicate } },
+            },
+          });
+        }
+        if (bulkOps.length > 0) {
+          await Order.bulkWrite(bulkOps);
+        }
+      } else {
+        await Order.updateMany(
+          { _id: { $in: orders.map((d) => d?._id?.toString()) } },
+          { $set: { isDuplicate: false } }
+        );
+      }
+      return { code: 200 };
+    }
+    return { code: 200 };
+  } catch (err) {
+    console.log("err", err);
+    return { code: 400 };
+  }
+};
+
+const Order = mongoose.model("Order", OrderSchema);
+
+module.exports = Order;

package/models/OrderProduct.js

@@ -0,0 +1,37 @@
+const { Schema, model } = require("mongoose");
+const OrderProductSchema = new Schema(
+  {
+    orderId: { type: Schema.Types.ObjectId, ref: "Order", default: null },
+    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
+    variantId: {
+      type: Schema.Types.ObjectId,
+      ref: "ProductVariant",
+      default: null,
+    },
+    locationId: {
+      type: Schema.Types.ObjectId,
+      ref: "Location",
+      default: null,
+    },
+    quantity: { type: Number, default: 0 },
+    price: { type: Number, default: 0 },
+    totalAmount: { type: Number, default: 0 },
+    discountPercentage: { type: Number, default: 0 },
+    webFulfillmentOrderId: { type: String, default: "" },
+    webFulfillmentId: { type: String, default: "" },
+    isFullfilled: { type: Boolean, default: false },
+    isDeleted: { type: Boolean, default: false },
+    discountValue: { type: Number, default: 0 },
+    webLineItemId: { type: String, default: "" },
+    status: { type: String, default: "open" },
+    hyperLink: { type: String, default: "" },
+    parentOrderProductId: { type: Schema.Types.ObjectId, default: null },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+module.exports = model("OrderProduct", OrderProductSchema);