shuttlepro-shared 1.1.91 → 1.1.93

package/models/AgentActivity.js

@@ -1,189 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,144 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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;