shuttlepro-shared 1.1.58 → 1.1.59

package/models/AgentActivity.js

@@ -0,0 +1,189 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const breakSchema = new mongoose.Schema({
+  refId: { type: String, required: true },
+  breakId: { type: String, required: false },
+  startTime: { type: Date, required: true },
+  endTime: { type: Date, required: false },
+});
+
+const responseSchema = new mongoose.Schema({
+  queryMessageId: { type: [String], default: [] },
+  responseMessageId: { type: [String], default: [] },
+  responseTime: { type: Number, required: false },
+  accuracy: { type: Number, required: false, default: 10 },
+});
+
+const activitySchema = new mongoose.Schema({
+  refId: { type: String, required: true },
+  type: {
+    type: String,
+    required: true,
+    default: "other",
+    enum: ["conversation", "ticket", "order", "other"],
+  },
+  platformName: { type: String, required: false },
+  platformType: { type: String, required: false },
+  customerName: { type: String, default: "", required: false },
+  conversationId: { type: String, default: "", required: false },
+  profileId: { type: String, required: false },
+  conversationType: {
+    type: String,
+    enum: ["email", "comment", "message", ""],
+    default: "",
+    required: false,
+  },
+  status: { type: String, required: false, default: "unassigned" },
+  labels: [{ type: Schema.Types.ObjectId, ref: "Label" }],
+  platformId: { type: String, required: false },
+  assignTime: { type: Date, required: false },
+  qaScore: { type: Number, required: false, default: 10 },
+  startTime: { type: String, required: false },
+  endTime: { type: String, required: false },
+  resolutionTime: { type: String, required: false },
+  responses: { type: [responseSchema], default: [] },
+  remarks: { type: String, required: false },
+  avgAccuracy: { type: Number, required: false, default: 10 },
+});
+
+const totalActivitySchema = new mongoose.Schema({
+  type: { type: String, required: true },
+  platformType: { type: String, required: false },
+  count: { type: Number, required: true },
+});
+
+const agentActivitySchema = new mongoose.Schema(
+  {
+    _id: {
+      type: mongoose.Schema.Types.ObjectId,
+      default: mongoose.Types.ObjectId,
+    },
+    agentId: { type: String, required: true },
+    agentRole: { type: String, default: "" },
+    agentName: { type: String, required: false },
+    agentShift: { type: Object, default: {}, required: false },
+    workspaceId: {
+      type: mongoose.Schema.Types.ObjectId,
+      required: true,
+      ref: "Workspace",
+    },
+    date: { type: String, required: true },
+    lateMinutes: {
+      type: Number,
+      default: 0,
+    },
+    earlyLeaveMinutes: {
+      type: Number,
+      default: 0,
+    },
+    shiftStartTime: { type: [Date], default: [] },
+    shiftEndTime: { type: [Date], default: [] },
+    shifts: [
+      {
+        shiftStartTime: { type: Date, required: true, default: null },
+        shiftEndTime: { type: Date, required: false, default: null },
+      },
+    ],
+    isLate: { type: Boolean, required: true, default: false },
+    isEarlyLeave: { type: Boolean, required: true, default: false },
+    breaks: { type: [breakSchema], default: [] },
+    activities: { type: [activitySchema], default: [] },
+    totalPsc: { type: Number, required: false, default: 0 },
+    totalQa: { type: Number, required: false, default: 0 },
+    weightedQa: { type: Number, required: false, default: 0 },
+    weightedPsc: { type: Number, required: false, default: 0 },
+    kpiScore: { type: Number, required: false, default: 0 },
+    totalActivities: { type: [totalActivitySchema], default: [] },
+    totalWorkTime: { type: Number, required: false, default: 0 },
+    totalBreakTime: { type: Number, required: false, default: 0 },
+    totalIdleTime: { type: Number, required: false, default: 0 },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+agentActivitySchema.index({ workspaceId: 1 });
+agentActivitySchema.index({ date: 1 });
+agentActivitySchema.index({ agentId: 1 });
+agentActivitySchema.index({ "activities.platformId": 1 });
+agentActivitySchema.index({ "activities.labels": 1 });
+agentActivitySchema.index({ workspaceId: 1, date: 1, agentId: 1 });
+agentActivitySchema.index({
+  workspaceId: 1,
+  date: 1,
+  agentId: 1,
+  "activities.platformId": 1,
+  "activities.labels": 1,
+});
+agentActivitySchema.index({
+  workspaceId: 1,
+  date: 1,
+  agentId: 1,
+  "activities.platformId": 1,
+});
+agentActivitySchema.index({
+  workspaceId: 1,
+  date: 1,
+  agentId: 1,
+  "activities.labels": 1,
+});
+agentActivitySchema.index(
+  { "activities.platformId": 1, "activities.labels": 1 },
+  {
+    partialFilterExpression: {
+      "activities.platformId": { $exists: true },
+      "activities.labels": { $exists: true },
+    },
+  }
+);
+const AgentActivity = mongoose.model("AgentActivity", agentActivitySchema);
+
+const findOneAndUpdateAgentActivity = async (
+  findQuery = {},
+  updateQuery = null
+) => {
+  try {
+    if (!findQuery || Object.values(findQuery).length === 0) {
+      console.log("Find Query is required.");
+      return null;
+    }
+
+    const agentActivityForActivitiesUpdated = await AgentActivity.findOne(
+      findQuery
+    ).sort({ createdAt: -1 });
+
+    if (!agentActivityForActivitiesUpdated) {
+      console.log("No matching record found.");
+      return null;
+    }
+
+    const bsonSize = require("bson").calculateObjectSize(
+      agentActivityForActivitiesUpdated
+    );
+
+    if (bsonSize <= 1000000) {
+      return await AgentActivity.findOneAndUpdate(findQuery, updateQuery);
+    } else {
+      const { breaks, activities, totalActivities, ...restData } =
+        agentActivityForActivitiesUpdated.toObject();
+
+      const newAgentActivity = await AgentActivity.create({
+        ...restData,
+      });
+
+      const agentActivityRecord = await AgentActivity.findOneAndUpdate(
+        { ...findQuery, _id: newAgentActivity._id },
+        updateQuery
+      );
+
+      return agentActivityRecord;
+    }
+  } catch (err) {
+    console.error("Error:", err);
+    return null;
+  }
+};
+module.exports = {
+  AgentActivity,
+  findOneAndUpdateAgentActivity,
+};

package/models/Assignment.js

@@ -0,0 +1,23 @@
+const mongoose = require("mongoose");
+
+const assignmentSchema = new mongoose.Schema({
+  cardId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Card",
+    required: true,
+  },
+  id: {
+    type: String,
+    required: true,
+  },
+  name: {
+    type: String,
+  },
+  email: {
+    type: String,
+  },
+});
+
+const Assignment = mongoose.model("Assignment", assignmentSchema);
+
+module.exports = Assignment;

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