shuttlepro-shared 1.3.13 → 1.3.14

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: String,
-    },
-    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/ChatMember.js

@@ -1,17 +0,0 @@
-const { Schema, model } = require("mongoose");
-
-const ChatMemberSchema = new Schema(
-  {
-    userName: { type: String, default: "" },
-    phoneNo: { type: String, default: "" },
-    email: { type: String, default: "" },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = model("ChatMember", ChatMemberSchema);

package/models/Chatbot.js

@@ -1,20 +0,0 @@
-const { Schema, model } = require("mongoose");
-const ChatbotSchema = new Schema(
-  {
-    name: { type: String, default: "" },
-    workspaceId: {
-      type: String,
-      default: "",
-    },
-    initialMessage: {
-      type: String,
-      default: "",
-    },
-    expiryTime: {
-      type: Number,
-      default: 300,
-    },
-  },
-  { 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,87 +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",
-        "outlook",
-        "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: "" },
-      category: { type: String, default: "" },
-      color: { 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,36 +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: "" },
-    country: { type: String, default: "pk" },
-    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/CustomerProfile.js

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

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

@@ -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;

package/models/Integration.js

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

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

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