shuttlepro-shared 1.1.57 → 1.1.59

package/models/Integration.js

@@ -0,0 +1,53 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const IntegrationSchema = new mongoose.Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    type: {
+      type: String,
+      enum: [
+        "socialPlatforms",
+        "whatsapp",
+        "gmail",
+        "sms",
+        "map",
+        "facebook",
+        "instagram",
+        "webChat",
+        "smtp_gmail",
+      ],
+    },
+    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: Schema.Types.ObjectId, ref: "Chatbot", default: null },
+    members: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "User",
+      },
+    ],
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+IntegrationSchema.virtual("conversations", {
+  ref: "Conversation",
+  localField: "_id",
+  foreignField: "platformId",
+});
+
+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,46 @@
+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",
+      ],
+      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/Order.js

@@ -0,0 +1,131 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+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: "" },
+  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(
+  {
+    customerId: { type: Schema.Types.ObjectId, ref: "Customer", default: null },
+    swap: { type: String, default: "" },
+    shipperInformation: ShipperInformation,
+    trackingId: { type: String, default: "" },
+    cityName: { 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 },
+    customerName: { type: String, default: "" },
+    customerPhone: { type: String, default: "" },
+    customerAddress: { type: String, default: "" },
+    discountPercentage: { type: Number, default: 0 },
+    discountValue: { type: Number, default: 0 },
+    productDetails: { type: String, default: "" },
+    webOrderId: { type: String, default: "" },
+    webOrderNumber: { type: String, default: "" },
+    fulfillmentStatus: { type: String, default: "" },
+    webFulfillmentId: { type: String, default: "" },
+    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 },
+    orderNumber: { type: String, default: "" },
+    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 },
+    isBulk: { type: String, default: "" },
+    priority: { 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 },
+    platformFinancialStatus: { type: String, default: "pending" },
+    payment: {},
+    credentials: {},
+  },
+  { 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",
+});
+
+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);

package/models/Report.js

@@ -0,0 +1,27 @@
+const mongoose = require("mongoose");
+
+const reportSchema = new mongoose.Schema(
+  {
+    workspaceId: { type: String, default: "" },
+    type: {
+      type: String,
+      default: "",
+    },
+    title: { type: String, default: "" },
+    mode: { type: String, default: "combined" },
+    displayType: { type: String, default: "table" },
+    filter: {},
+    dateRange: {
+      startDate: { type: String, default: "" },
+      endDate: { type: String, default: "" },
+    },
+    actions: [],
+    processedData: [],
+  },
+  { timestamps: true }
+);
+
+reportSchema.index({ type: 1, workspaceId: 1 });
+reportSchema.index({ type: 1, workspaceId: 1, title: 1 });
+
+module.exports = mongoose.model("Report", reportSchema);

package/models/Shipper.js

@@ -0,0 +1,52 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const shipperInformationSchema = new Schema({
+  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: "" }, //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: "" },
+  cityData: { type: String, default: "" },
+  return_branch: { type: String, default: "" }, 
+  //M&P, TRAX, INSTA, RIDER, TCS, CC
+  //TRAX
+  paymentMode: { type: Number, default: 0 },
+  addressId: { type: Number, default: 0 }, //this will not be shown
+  itemProductType: { type: Number, default: 0 },
+  shippingMode: { type: Number, default: 0 },
+  itemInsurance: { type: Boolean, default: false }, //this will not be shown
+  informationDisplay: { type: String, default: "" },
+  //Call Courier (CC)
+  shipperName: { type: String, default: "" }, //this will not be shown
+  shipperEmail: { type: String, default: "" }, //this will not be shown
+  shipperCellNo: { type: String, default: "" }, //this will not be shown
+  shipperLandlineNo: { type: String, default: "" }, //this will not be shown
+  shipperAddress: { type: String, default: "" }, //this will not be shown
+  shipperCityId: { type: Number, default: 0 }, //this will not be shown
+  shipperAreaId: { type: Number, default: 0 }, //this will not be shown
+});
+
+const shipperSchema = new mongoose.Schema(
+  {
+    type: { type: String, default: "" },
+    userName: { type: String, default: "" },
+    password: { type: String, default: "" },
+    clientId: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    shipperInformation: shipperInformationSchema,
+    isDeleted: { type: Boolean, default: false },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("shipper", shipperSchema);

package/models/Status.js

@@ -0,0 +1,58 @@
+const { Schema, model } = require("mongoose");
+const { setRedisData, getRedisData } = require("../config/redis");
+
+const StatusSchema = new Schema(
+  {
+    value: { type: String, default: "" },
+    description: { type: String, default: "" },
+    severity: { type: String, default: "1" },
+    shipperType: { type: String, default: "" },
+    internalValue: { type: String, default: "" },
+    statusTypeId: { type: Schema.Types.ObjectId, ref: "StatusType" },
+    type: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+StatusSchema.post("save", async function (doc) {
+  try {
+    addOrUpdateStatusInCache(doc);
+  } catch (err) {
+    console.log("err", err);
+  }
+});
+
+StatusSchema.post("findOneAndUpdate", async function (doc) {
+  try {
+    addOrUpdateStatusInCache(doc);
+  } catch (err) {
+    console.log("err", err);
+  }
+});
+
+const addOrUpdateStatusInCache = async (doc) => {
+  try {
+    const docId = doc?._id.toString();
+    let statuses = (await getRedisData("statuses")) || [];
+    if (!statuses || statuses.length === 0) {
+      // Fetch all statuses from the database if not found in Redis
+      const allStatuses = await model("Status").find().lean().exec();
+      statuses = allStatuses;
+      await setRedisData("statuses", statuses);
+    } else {
+      const statusesMap = statuses.reduce((map, status) => {
+        map[status._id.toString()] = status;
+        return map;
+      }, {});
+      statusesMap[docId] = doc.toObject();
+      statuses = Object.values(statusesMap);
+      await setRedisData("statuses", statuses);
+    }
+    return { code: 200 };
+  } catch (err) {
+    console.log("Error in addOrUpdateOrderInCache:", err);
+    return { code: 400 };
+  }
+};
+
+module.exports = model("Status", StatusSchema);

package/models/StatusType.js

@@ -0,0 +1,10 @@
+const { Schema, model } = require("mongoose");
+
+const StatusTypeSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("StatusType", StatusTypeSchema);

package/models/Type.js

@@ -0,0 +1,25 @@
+const mongoose = require("mongoose");
+
+const typeSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    deleted: {
+      type: Boolean,
+      default: false,
+    },
+    workspaceId: { type: String, default: "" },
+    color: { type: String, default: "#4a90e2", required: true },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+typeSchema.virtual("cardList", {
+  ref: "Card",
+  localField: "_id",
+  foreignField: "typeId",
+});
+
+module.exports = mongoose.model("Type", typeSchema);

package/models/Workspace.js

@@ -0,0 +1,190 @@
+const mongoose = require("mongoose");
+
+const shiftSchema = new mongoose.Schema({
+  _id: {
+    type: mongoose.Schema.Types.ObjectId,
+    default: mongoose.Types.ObjectId,
+  },
+  shiftName: {
+    type: String,
+    required: true,
+  },
+  days: [
+    {
+      day: { type: String, required: true },
+      startTime: { type: String, required: true },
+      endTime: { type: String, required: true },
+      breakStartTime: { type: String, required: false },
+      breakEndTime: { type: String, required: false },
+      lateThreshold: { type: String, required: false },
+    },
+  ],
+});
+
+const scoreThresholdSchema = new mongoose.Schema({
+  operator: {
+    type: mongoose.Schema.Types.Mixed,
+    required: false,
+  },
+  value: {
+    type: mongoose.Schema.Types.Mixed,
+    required: true,
+  },
+  score: {
+    type: Number,
+    required: false,
+  },
+  additionalFields: {
+    type: mongoose.Schema.Types.Mixed,
+    default: {},
+  },
+});
+
+const kpiSchema = new mongoose.Schema({
+  weight: {
+    type: Number,
+    required: true,
+  },
+  scoreThresholds: {
+    type: [scoreThresholdSchema],
+    default: [],
+  },
+  relativeGrading: {
+    type: Boolean,
+    default: false,
+  },
+});
+
+const workspaceSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    iconUrl: { type: String, default: "" },
+    thumbUrl: { type: String, default: "" },
+    createdBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    updatedBy: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    productsCount: { type: Number, default: 0 },
+    ordersCount: { type: Number, default: 0 },
+    shippers: [{ type: String, trim: true }],
+    socialProfiles: [],
+    shiftConfigurations: [shiftSchema],
+    kpiConfiguration: {
+      type: Map,
+      of: kpiSchema,
+      default: {},
+    },
+    members: [],
+    contact: String,
+    email: String,
+    address: String,
+    websiteUrl: String,
+    facebookUrl: String,
+    twitterUrl: String,
+    instagramUrl: String,
+    isDeleted: { type: Boolean, default: false },
+    businessHours: {
+      startTime: { type: String, default: "" },
+      endTime: { type: String, default: "" },
+    },
+    remarks: [
+      {
+        reason: { type: String, default: "" },
+        type: { type: String, default: "" },
+      },
+    ],
+    chatGptApiKey: String,
+    skuSeparator: { type: String, default: "-" },
+    uniqueNo: { type: Number, default: 0 },
+    webhookStatus: { type: String, default: "" },
+    businessCategory: { type: String, default: "" },
+    numberOfProducts: { type: Number, default: 0 },
+    monthlyOrders: { type: Number, default: 0 },
+    queueTracking: { type: Boolean, default: false },
+    orderConfiguration: { type: String, default: "" },
+    defaultModule: { type: String, default: "dashboard" },
+    dynamicFieldsTemplate: [
+      {
+        groupName: { type: String, required: true, trim: true },
+        fields: [
+          {
+            fieldName: {
+              type: String,
+              required: true,
+              trim: true,
+            },
+            required: {
+              type: Boolean,
+              default: false,
+            },
+            enabled: {
+              type: Boolean,
+              default: true,
+            },
+            createdBy: {
+              type: mongoose.Schema.Types.ObjectId,
+              ref: "User",
+              default: null,
+            },
+            updatedBy: {
+              type: mongoose.Schema.Types.ObjectId,
+              ref: "User",
+              default: null,
+            },
+            fieldType: {
+              type: String,
+              enum: [
+                "text",
+                "autocomplete",
+                "radio",
+                "text area",
+                "number",
+                "date",
+                "time",
+                "email",
+                "range",
+                "url",
+                "colour",
+                "file",
+              ],
+            },
+            option: {
+              type: mongoose.Schema.Types.Mixed,
+            },
+          },
+        ],
+      },
+    ],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const commonOptions = {
+  type: String,
+  trim: true,
+  default: "",
+};
+
+workspaceSchema.add({
+  contact: commonOptions,
+  email: commonOptions,
+  address: commonOptions,
+  websiteUrl: commonOptions,
+  facebookUrl: commonOptions,
+  twitterUrl: commonOptions,
+  instagramUrl: commonOptions,
+  chatGptApiKey: commonOptions,
+});
+
+const Workspace = mongoose.model("Workspace", workspaceSchema);
+module.exports = Workspace;