shuttlepro-shared 1.1.96 → 1.1.98

package/models/BusinessDistribution.js

@@ -0,0 +1,23 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const businessDistributionSchema = new mongoose.Schema(
+  {
+    name: { type: String, default: "" },
+    deliveryCharges: { type: String, default: "" },
+    shippers: [],
+    type: {
+      type: String,
+      enum: ["default", "cities"],
+      required: true,
+    },
+    index: { type: String, default: "" },
+    workspaceId: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model(
+  "BusinessDistribution",
+  businessDistributionSchema
+);

package/models/Card.js

@@ -0,0 +1,144 @@
+const mongoose = require("mongoose");
+const { DYNAMIC_FIELD_TYPES } = require("../constants");
+
+const cardSchema = new mongoose.Schema(
+  {
+    cardId: { type: String, required: true },
+    columnId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Column",
+      required: false,
+      default: null,
+      set: (v) => (v === "" ? null : v),
+    },
+    title: {
+      type: String,
+      default: "",
+      // required: true,
+    },
+    description: {
+      type: String,
+    },
+    priority: {
+      type: String,
+      enum: ["high", "medium", "low"],
+    },
+    typeId: [
+      {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "Label",
+      },
+    ],
+    type: {
+      type: String,
+      required: true,
+    },
+    assignedBy: {
+      type: Object,
+    },
+    attachmentId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Attachment",
+    },
+    attachments: {
+      type: [String],
+      default: [],
+    },
+    product: {
+      type: Object,
+    },
+    courierId: {
+      type: String,
+    },
+    orderId: {
+      type: Object,
+    },
+    conversation: {
+      type: Object,
+    },
+    deleted: {
+      type: Boolean,
+      default: false,
+    },
+    isExpired: {
+      type: Boolean,
+      default: false,
+    },
+    isUpdated: {
+      type: Boolean,
+      default: false,
+    },
+    completionDate: {
+      type: String,
+    },
+    updatedDate: {
+      type: Date,
+      default: Date.now,
+    },
+    ticketId: {
+      type: Number,
+    },
+    category: {
+      type: String,
+      default: "ticket",
+      enum: ["ticket", "conversation"],
+    },
+    dynamicFieldValue: [
+      {
+        dynamicFieldId: {
+          type: String,
+          default: "",
+        },
+        fieldType: {
+          type: String,
+          enum: DYNAMIC_FIELD_TYPES,
+        },
+        fieldValueId: {
+          type: mongoose.Schema.Types.Mixed,
+        },
+      },
+    ],
+    workspaceId: { type: String, default: "" },
+    activities: [
+      {
+        data: {
+          type: mongoose.Schema.Types.Mixed,
+          default: {},
+        },
+      },
+    ],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+cardSchema.index({ workspaceId: 1, createdAt: 1 }); // Common filter
+
+// Virtual for the assignedTo user
+cardSchema.virtual("assignedToUser", {
+  ref: "User",
+  localField: "assignedTo",
+  foreignField: "_id",
+});
+
+// Virtual for the attachment
+cardSchema.virtual("attachment", {
+  ref: "Attachment",
+  localField: "attachmentId",
+  foreignField: "_id",
+});
+
+// Virtual for the comment
+cardSchema.virtual("comments", {
+  ref: "CardComment",
+  localField: "_id",
+  foreignField: "cardId",
+});
+
+// Virtual for the assignmentList
+cardSchema.virtual("assignedTo", {
+  ref: "Assignment",
+  localField: "_id", // Change to 'cardId' to match the 'cardId' field in the Assignment model
+  foreignField: "cardId",
+});
+
+module.exports = mongoose.model("Card", cardSchema);

package/models/CardComments.js

@@ -0,0 +1,33 @@
+const mongoose = require("mongoose");
+
+const cardCommentSchema = new mongoose.Schema(
+  {
+    cardId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Card",
+      required: true,
+    },
+    commentText: {
+      type: String,
+      required: true,
+    },
+    createdBy: {
+      type: Object,
+      required: true,
+    },
+    readers: {
+      type: [],
+      default: [],
+    },
+    deleted: {
+      type: Boolean,
+      default: false,
+    },
+    updatedDate: {
+      type: Date,
+    },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("CardComment", cardCommentSchema);

package/models/Chatbot.js

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

package/models/Checkpoint.js

@@ -0,0 +1,50 @@
+const { Schema, model } = require("mongoose");
+const Order = require("./Order");
+const CheckpointSchema = new Schema(
+  {
+    bookingDate: { type: String, default: "" },
+    shipperType: { type: String, default: "" },
+    statusTime: { type: String, default: "" },
+    orderId: { type: Schema.Types.ObjectId, default: null, ref: "Order" },
+    statusId: { type: Schema.Types.ObjectId, default: null, ref: "Status" },
+    statusValue: { type: String, default: "" },
+    description: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const initialStatuses = {
+  POSTEX: "departed to postex. warehouse",
+  DAEWOO: "booking",
+  TRAX: "shipment - arrived at origin",
+};
+
+CheckpointSchema.post("save", async function (doc) {
+  try {
+    if (
+      doc?.shipperType &&
+      doc?.statusValue.toLowerCase() === initialStatuses[doc?.shipperType]
+    ) {
+      let order = await Order.findOneAndUpdate(
+        {
+          _id: doc.orderId,
+          workspaceId: doc.workspaceId,
+        },
+        { $set: { statusUpdatedAt: doc.bookingDate } },
+        { new: true }
+      );
+      console.log(order, "initial status from shipper");
+    }
+    return { code: 200 };
+  } catch (err) {
+    console.log("err", err);
+    return { code: 400 };
+  }
+});
+
+module.exports = model("Checkpoint", CheckpointSchema);

package/models/City.js

@@ -0,0 +1,17 @@
+const { Schema, model } = require("mongoose");
+
+const CitySchema = new Schema(
+  {
+    cityName: { type: String, default: "" },
+    correctedCityName: { type: String, default: "" },
+    cityCode: { type: String, default: "" },
+    area: { type: String, default: "" },
+    shipperType: { type: String, default: "" },
+    webCityId: { type: String, default: "" },
+    hubId: { type: String, default: "" },
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("City", CitySchema);

package/models/Column.js

@@ -0,0 +1,28 @@
+const mongoose = require("mongoose");
+
+const columnSchema = new mongoose.Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    position: {
+      type: Number,
+      required: true,
+    },
+    deleted: {
+      type: Boolean,
+      default: false,
+    },
+    workspaceId: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+columnSchema.virtual("cardList", {
+  ref: "Card",
+  localField: "_id", // Change to '_id' to match the column's '_id'
+  foreignField: "columnId",
+});
+
+module.exports = mongoose.model("Column", columnSchema);

package/models/Conversation.js

@@ -0,0 +1,84 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const draftSchema = new mongoose.Schema({
+  _id: {
+    type: Schema.Types.ObjectId,
+    default: () => new mongoose.Types.ObjectId(),
+  },
+  messageBody: {},
+  createdBy: { type: Schema.Types.ObjectId, ref: "User" },
+});
+
+const conversationSchema = new mongoose.Schema(
+  {
+    platformType: {
+      type: String,
+      enum: [
+        "gmail",
+        "instagram",
+        "whatsapp",
+        "linkedin",
+        "facebook",
+        "tiktok",
+        "webChat",
+        "smtp_gmail",
+      ],
+      required: true,
+    },
+    members: [{ type: Schema.Types.ObjectId, ref: "User" }],
+    conversationType: {
+      type: String,
+      enum: ["comment", "message", "email"],
+      required: true,
+    },
+    messageCount: { type: Number, default: 0 },
+    conversationStatus: {
+      type: String,
+      enum: ["assigned", "unassigned", "archived"],
+      required: true,
+      default: "unassigned",
+    },
+    assignId: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    platformId: {
+      type: Schema.Types.ObjectId,
+      ref: "Integration",
+      default: null,
+    },
+    labels: [{ type: Schema.Types.ObjectId, ref: "Label" }],
+    title: { type: String },
+    platformTimestamp: { type: String, default: "" },
+    status: {
+      type: String,
+      enum: ["open", "processing", "hold", "closed"],
+      required: true,
+      default: "open",
+    },
+    isSpam: { type: Boolean, default: false },
+    threadId: { type: String, default: "" },
+    messageId: { type: String, default: "" },
+    profileId: { type: Schema.Types.ObjectId, ref: "Profile" },
+    conversationCloseTime: { type: String },
+    workspaceId: { type: Schema.Types.ObjectId, ref: "Workspace" },
+    postId: { type: String, default: "" },
+    postUrl: { type: String, default: "" },
+    sender: { type: String, default: "" },
+    reasonForClosing: {
+      reason: { type: String, default: "" },
+      closedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    },
+    integratedAccount: { type: String, default: "" },
+    isRead: { type: Boolean, default: false },
+    ticketId: { type: String, default: "" },
+    draft: [draftSchema],
+    isWebchatTicket: { type: Boolean, default: false },
+    webchatComplaintType: { type: String, default: null },
+    isComposed: { type: Boolean, default: false },
+    utilityMessage: [],
+    orderId: [],
+    isFetch: { type: Boolean, default: true },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("Conversation", conversationSchema);

package/models/Customer.js

@@ -0,0 +1,35 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const CustomerSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    email: { type: String, default: "" },
+    phone: { type: String, default: "" },
+    city: { type: String, default: "" },
+    defaultAddress: { type: String, default: "" },
+    currentShippingAddress: {},
+    addresses: [],
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    phone1: { type: String, default: "" },
+    isBlackListed: { type: Boolean, default: false },
+    createdBy: {
+      type: Schema.Types.ObjectId,
+      ref: "User",
+    },
+    updatedBy: {
+      type: Schema.Types.ObjectId,
+      ref: "User",
+    },
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const Customer = mongoose.model("Customer", CustomerSchema);
+
+module.exports = Customer;

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,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,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);