shuttlepro-shared 1.3.41 → 1.3.42

package/models/Automation.js

@@ -0,0 +1,242 @@
+const { repositories } = require("shuttlepro-shared");
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const userJoin = {
+  type: Schema.Types.ObjectId,
+  ref: "User",
+  default: null,
+};
+
+const descriptionJoin = {
+  type: Schema.Types.ObjectId,
+  ref: "DescriptionTemplate",
+  default: null,
+};
+
+const defaultStringType = {
+  type: String,
+  default: "",
+};
+
+const AutomationAction = new Schema({
+  addLabels: [
+    {
+      type: Schema.Types.ObjectId,
+      ref: "Label",
+      default: null,
+    },
+  ],
+  autoAssign: {
+    enabled: { type: Boolean, default: false },
+    membersId: [userJoin],
+  },
+  autoReply: {
+    enabled: { type: Boolean, default: false },
+    templateId: descriptionJoin,
+    delay: defaultStringType,
+  },
+  commentReplyPrivately: {
+    enabled: { type: Boolean, default: false },
+    templateId: descriptionJoin,
+    delay: defaultStringType,
+  },
+  conversationReply: {
+    enabled: { type: Boolean, default: false },
+    templateId: descriptionJoin,
+    delay: defaultStringType,
+  },
+  sendCollection: {
+    enabled: { type: Boolean, default: false },
+    template: { type: Object, default: null },
+    delay: defaultStringType,
+  },
+  autoTicket: {
+    enabled: { type: Boolean, default: false },
+    title: defaultStringType,
+    labelIds: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "Label",
+        default: null,
+      },
+    ],
+    alreadyTicketTemplateId: descriptionJoin,
+    templateId: descriptionJoin,
+    template: defaultStringType,
+    columnId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Column",
+    },
+    priority: {
+      type: String,
+      enum: ["high", "medium", "low"],
+    },
+    ticketDue: defaultStringType,
+    assignId: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+    members: [userJoin],
+  },
+  escalation: {
+    enabled: { type: Boolean, default: false },
+    escalationIds: {
+      type: Schema.Types.ObjectId,
+      ref: "EscalationConfiguration",
+    },
+  },
+  notification: {
+    enabled: { type: Boolean, default: false },
+    notificationMemberIds: [userJoin],
+  },
+  orderConfirmation: {
+    enabled: { type: Boolean, default: false },
+    integrationId: {
+      id: defaultStringType,
+      type: defaultStringType,
+      accountTitle: defaultStringType,
+      businessId: defaultStringType,
+      name: defaultStringType,
+    },
+    workflow: {},
+    otherConfirmationMode: {
+      type: String,
+      enum: ["ivr", "sms", ""],
+      default: "",
+    },
+  },
+  orderPublish: {
+    enabled: { type: Boolean, default: false },
+    integrationId: {
+      id: defaultStringType,
+      type: defaultStringType,
+      accountTitle: defaultStringType,
+      businessId: defaultStringType,
+      name: defaultStringType,
+    },
+    workflow: {},
+    otherConfirmationMode: {
+      type: String,
+      enum: ["ivr", "sms", ""],
+      default: "",
+    },
+  },
+  orderReview: {
+    enabled: { type: Boolean, default: false },
+    integrationId: {
+      id: defaultStringType,
+      type: defaultStringType,
+      accountTitle: defaultStringType,
+      businessId: defaultStringType,
+      name: defaultStringType,
+    },
+    flow: {},
+  },
+  chatbot: {
+   enabled: { type: Boolean, default: false },
+   id: defaultStringType,
+  },
+});
+const AutomationCondition = new Schema({
+  criteriaType: {
+    type: {
+      type: String,
+      required: true,
+      enum: [
+        "sender",
+        "content",
+        "order",
+        "time",
+        "ticketStatus",
+        "label",
+        "orderAutomation",
+        "post",
+      ],
+    },
+    keyValue: {
+      type: String,
+      required: true,
+      enum: [
+        "senderEmail",
+        "senderPhone",
+        "emailSubject",
+        "messageBody",
+        "orderTrackingUrl",
+        "withInBusinessHour",
+        "afterBusinessHour",
+        "allDay",
+        "closeTicket",
+        "openTicket",
+        "publishedPosts",
+        "label",
+        "orderConfirmation",
+        "orderPublish",
+      ],
+    },
+    subKeyValue: {
+      type: String,
+      required: false,
+      enum: ["trackingNo", "orderNumber", "both"],
+    },
+  },
+  values: [
+    {
+      type: String,
+    },
+  ],
+  contains: {
+    type: String,
+    enum: ["equalTo", "contains", "notEqualTo", "notContains"],
+  },
+});
+const AutomationIntegration = new Schema({
+  id: {
+    type: Schema.Types.ObjectId,
+    ref: "Integration",
+    required: true,
+  },
+  contentType: defaultStringType,
+  type: {
+    type: String,
+    required: true,
+  },
+  accountTitle: defaultStringType,
+  _id: false,
+});
+
+const AutomationSchema = new Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    event: {
+      type: String,
+      enum: ["newConversation", "message", "ticket", "order"],
+      default: "newConversation",
+      required: true,
+    },
+    integratedPlatformId: [AutomationIntegration],
+    workspaceId: defaultStringType,
+    enabled: {
+      type: Boolean,
+      default: true,
+    },
+    conditionGroups: [
+      {
+        conditionalMatch: {
+          type: String,
+          enum: ["any", "all"],
+          default: "any",
+        },
+        conditions: [AutomationCondition],
+        actions: AutomationAction,
+      },
+    ],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const Automation = mongoose.model("Automation", AutomationSchema);
+module.exports = { Automation };

package/models/BusinessRule.js

@@ -0,0 +1,16 @@
+const mongoose = require("mongoose");
+
+const businessRuleSchema = new mongoose.Schema(
+  {
+    allocation: { type: Number, default: "" },
+    threshold: { type: Number, default: "" },
+    cities: { type: String, default: "" },
+    shiftedShipper: { type: String, default: "" },
+    businessShifted: { type: Number, default: "" },
+    shipper: { type: String, default: "" },
+    workspaceId: { type: mongoose.Types.ObjectId, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("BusinessRule", businessRuleSchema);

package/models/BusinessRuleHelper.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+
+const businessRuleHelperSchema = new mongoose.Schema(
+  {
+    ruleId: { type: mongoose.Types.ObjectId, default: "" },
+    next: { type: String, default: "" },
+    active: { type: Boolean, default: "" },
+    frequency: { type: Number, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("BusinessRuleHelper", businessRuleHelperSchema);

package/models/Card.js

@@ -91,7 +91,20 @@ const cardSchema = new mongoose.Schema(
         },
         fieldType: {
           type: String,
-          enum: DYNAMIC_FIELD_TYPES,
+          enum: [
+            "text",
+            "autocomplete",
+            "radio",
+            "text area",
+            "number",
+            "date",
+            "time",
+            "email",
+            "range",
+            "url",
+            "colour",
+            "file",
+          ],
         },
         fieldValueId: {
           type: mongoose.Schema.Types.Mixed,
@@ -107,6 +120,42 @@ const cardSchema = new mongoose.Schema(
         },
       },
     ],
+    assignId: {
+      type: mongoose.Schema.Types.Mixed,
+      default: null,
+    },
+    mergedTickets: {
+      type: [
+        {
+          id: { type: String, required: false },
+          ticketId: { type: String, required: false },
+        },
+      ],
+      default: [],
+    },
+    mergedInto: {
+      type: {
+        id: { type: String, required: false, default: "" },
+        ticketId: { type: String, required: false, default: "" },
+      },
+      default: null,
+    },
+    customerName: {
+      type: String,
+      default: "",
+    },
+    customerEmail: {
+      type: String,
+      default: "",
+    },
+    phoneNo: {
+      type: String,
+      default: "",
+    },
+    body: {
+      type: mongoose.Schema.Types.Mixed,
+      default: {},
+    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/Catalogue.js

@@ -0,0 +1,22 @@
+const mongoose = require("mongoose");
+
+const CatalogueSchema = new mongoose.Schema(
+  {
+    name: { type: String, default: "" },
+    workspaceId: { type: String, default: "" },
+    isDeleted: { type: Boolean, default: false },
+    isDefault: { type: Boolean, default: false },
+    images: {
+      type: [
+        {
+          url: { type: String, default: "" },
+          name: { type: String, default: "" },
+        },
+      ],
+      default: [],
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("Catalogue", CatalogueSchema);

package/models/Category.js

@@ -0,0 +1,129 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const CategorySchema = new Schema(
+  {
+    image: { type: String, default: "" },
+    publishedAt: { type: String, default: "" },
+    name: { type: String, default: "" },
+    description: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    oldId: { type: String, default: "" },
+    webCategoryId: { type: Number, default: null },
+    parentId: { type: Schema.Types.ObjectId, ref: "Category", default: null },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+CategorySchema.virtual("productCategories", {
+  ref: "ProductCategory",
+  localField: "_id",
+  foreignField: "categoryId",
+});
+
+const Category = mongoose.model("Category", CategorySchema);
+
+const createNewCategory = async (categoryData) => {
+  try {
+    return await Category.create(categoryData);
+  } catch (error) {
+    return null;
+  }
+};
+
+const findCategoryById = async (categoryId) => {
+  try {
+    return await Category.findById(categoryId);
+  } catch (error) {
+    return null;
+  }
+};
+
+const updateCategoryById = async (criteria, updateData, options) => {
+  try {
+    return await Category.findByIdAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+const deleteCategoryById = async (categoryId) => {
+  try {
+    return await Category.findByIdAndDelete(categoryId);
+  } catch (error) {
+    return null;
+  }
+};
+
+const findCategory = async (criteria = {}) => {
+  try {
+    return await Category.findOne(criteria);
+  } catch (error) {
+    return null;
+  }
+};
+
+const findCategories = async (criteria = {}) => {
+  try {
+    return await Category.find(criteria);
+  } catch (error) {
+    return [];
+  }
+};
+
+const categoriesByAggregation = async (aggregate = []) => {
+  try {
+    let categories = await Category.aggregate(aggregate);
+    return categories;
+  } catch (err) {
+    return [];
+  }
+};
+
+const categoriesUpdateMany = async (criteria, updateData, options = {}) => {
+  try {
+    return await Category.updateMany(criteria, updateData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+const findOneAndUpdateCategory = async (
+  findQuery,
+  updateData,
+  options = {}
+) => {
+  try {
+    return await Category.findOneAndUpdate(findQuery, updateData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+const findCategoryByPopulate = async (criteria = {}, populate = "") => {
+  try {
+    return await Category.findOne(criteria).populate(populate);
+  } catch (error) {
+    return null;
+  }
+};
+
+module.exports = {
+  Category,
+  createNewCategory,
+  findCategoryById,
+  updateCategoryById,
+  deleteCategoryById,
+  findCategory,
+  findCategories,
+  categoriesByAggregation,
+  categoriesUpdateMany,
+  findOneAndUpdateCategory,
+  findCategoryByPopulate,
+};

package/models/ChatMemberSession.js

@@ -0,0 +1,21 @@
+const { Schema, model } = require("mongoose");
+
+const ChatMemberSessionSchema = new Schema(
+  {
+    userId: {
+      type: Schema.Types.ObjectId,
+      ref: "ChatMember",
+      default: null,
+    },
+    startTime: { type: String, default: "" },
+    endTime: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("ChatMemberSession", ChatMemberSessionSchema);

package/models/ChatMessage.js

@@ -0,0 +1,43 @@
+const { Schema, model } = require("mongoose");
+
+const ChatMessageSchema = new Schema(
+  {
+    senderId: {
+      type: Schema.Types.ObjectId,
+      ref: "ChatMember",
+      default: null,
+    },
+    receiverId: {
+      type: Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    message: { type: String, default: "" },
+    attachment: { type: Array, default: [] },
+    attachmentType: { type: String, default: "" },
+    sessionId: {
+      type: Schema.Types.ObjectId,
+      ref: "ChatMemberSession",
+      default: null,
+    },
+    workspaceId: {
+      type: String,
+      default: "",
+    },
+    type: {
+      type: String,
+      default: "",
+    },
+    complaintType: {
+      type: String,
+      default: "",
+    },
+    websiteName: {
+      type: String,
+      default: "",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("ChatMessage", ChatMessageSchema);

package/models/Chatbot.js

@@ -17,4 +17,4 @@ const ChatbotSchema = new Schema(
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );
-module.exports = model("Chatbot", ChatbotSchema);
+module.exports = ChatbotSchema;

package/models/Color.js

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

package/models/Column.js

@@ -14,6 +14,12 @@ const columnSchema = new mongoose.Schema(
       type: Boolean,
       default: false,
     },
+    type: {
+      type: String,
+      enum: ["open", "processing", "hold", "closed"],
+      required: true,
+      default: "open",
+    },
     workspaceId: { type: String, default: "" },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }

package/models/Conversation.js

@@ -10,6 +10,14 @@ const draftSchema = new mongoose.Schema({
   createdBy: { type: Schema.Types.ObjectId, ref: "User" },
 });
 
+const activitySchema = new mongoose.Schema({
+  action: { type: String, default: null },
+  previousAssignee: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  newAssignee: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  timestamp: { type: Date, default: Date.now },
+  performedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+});
+
 const conversationSchema = new mongoose.Schema(
   {
     platformType: {
@@ -76,12 +84,44 @@ const conversationSchema = new mongoose.Schema(
     draft: [draftSchema],
     isWebchatTicket: { type: Boolean, default: false },
     webchatComplaintType: { type: String, default: null },
+    isWebchatAutoReply: { type: Boolean, default: false },
+
     isComposed: { type: Boolean, default: false },
+    userMessageTime: { type: String, default: "" },
     utilityMessage: [],
     orderId: [],
     isFetch: { type: Boolean, default: true },
+    isAwaitingFeedback: { type: Boolean, default: true },
+    activities: [activitySchema],
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );
 
+conversationSchema.index({ workspaceId: 1, isSpam: 1 });
+conversationSchema.index({ workspaceId: 1, isSpam: 1, conversationStatus: 1 });
+conversationSchema.index({
+  workspaceId: 1,
+  isSpam: 1,
+  platformId: 1,
+});
+conversationSchema.index({
+  workspaceId: 1,
+  isSpam: 1,
+  platformId: 1,
+  conversationStatus: 1,
+});
+conversationSchema.index({
+  workspaceId: 1,
+  isSpam: 1,
+  platformId: 1,
+  conversationType: 1,
+});
+conversationSchema.index({
+  workspaceId: 1,
+  isSpam: 1,
+  platformId: 1,
+  conversationType: 1,
+  conversationStatus: 1,
+});
+
 module.exports = mongoose.model("Conversation", conversationSchema);

package/models/Customer.js

@@ -6,17 +6,18 @@ const CustomerSchema = new Schema(
     name: { type: String, default: "" },
     email: { type: String, default: "" },
     phone: { type: String, default: "" },
+    phone1: { type: String, default: "" },
     city: { type: String, default: "" },
     country: { type: String, default: "pk" },
     defaultAddress: { type: String, default: "" },
     currentShippingAddress: {},
     addresses: [],
+    webCustomerId: { type: String, default: "" },
     workspaceId: {
       type: Schema.Types.ObjectId,
       ref: "Workspace",
       default: null,
     },
-    phone1: { type: String, default: "" },
     isBlackListed: { type: Boolean, default: false },
     createdBy: {
       type: Schema.Types.ObjectId,

package/models/CustomerCheckpoint.js

@@ -0,0 +1,21 @@
+const { Schema, model } = require("mongoose");
+
+const CustomerCheckpointSchema = new Schema(
+  {
+    message: { type: String, default: "" },
+    type: { type: String, default: "" },
+    conversationPlatform: { type: String, default: null },
+    customerId: { type: Schema.Types.ObjectId, default: null, ref: "Customer" },
+    orderId: { type: Schema.Types.ObjectId, default: null, ref: "Order" },
+    conversationId: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    latestTimeStamp: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = model("CustomerCheckpoint", CustomerCheckpointSchema);

package/models/DeviceInfo.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const DeviceInfoSchema = new Schema(
+  {
+    userId: String,
+    token: String,
+    device: String,
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+const DeviceInfo = mongoose.model("DeviceInfo", DeviceInfoSchema);
+module.exports = DeviceInfo;