shuttlepro-shared 1.3.29 → 1.3.31

package/models/Automation.js

@@ -0,0 +1,238 @@
+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: {},
+  },
+});
+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/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/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

@@ -80,6 +80,7 @@ const conversationSchema = new mongoose.Schema(
     utilityMessage: [],
     orderId: [],
     isFetch: { type: Boolean, default: true },
+    isAwaitingFeedback: { type: Boolean, default: true },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

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

package/models/EscalationConfiguration.js

@@ -0,0 +1,123 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const EscalationLevelSchema = new Schema({
+  _id: false,
+  threshold: {
+    type: Number,
+    required: true,
+  },
+  actions: {
+    labels: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "Label",
+      },
+    ],
+    memberIds: [
+      {
+        type: Schema.Types.ObjectId,
+        ref: "User",
+      },
+    ],
+    ticketPriority: {
+      type: String,
+      enum: ["high", "medium", "low", ""],
+      default: "",
+    },
+    notification: {
+      action: {
+        type: String,
+        enum: ["email", "systemNotification", "both"],
+        default: "systemNotification",
+      },
+      integrationId: {
+        type: Schema.Types.ObjectId,
+        ref: "Integration",
+      },
+      templateId: {
+        type: Schema.Types.ObjectId,
+        ref: "DescriptionTemplate",
+      },
+      memberEmails: [
+        {
+          type: String,
+        },
+      ],
+    },
+  },
+});
+
+const EscalationGroupSchema = new Schema({
+  conditionalMatch: {
+    type: String,
+    enum: ["any", "all"],
+    default: "any",
+  },
+  contains: {
+    type: String,
+    enum: ["equalTo", "contains", "notEqualTo", "notContains", ""],
+    default: "",
+  },
+  conditions: [
+    {
+      _id: false,
+      type: {
+        type: String,
+        required: true,
+        enum: ["status", "label"],
+      },
+      values: [
+        {
+          type: String,
+        },
+      ],
+      subValues: [
+        {
+          type: String,
+        },
+      ],
+      //open/processing/hold/close/isCritical,assignedChat
+    },
+  ],
+  levels: [EscalationLevelSchema], // Each group contains multiple escalation levels
+});
+
+const EscalationConfigurationSchema = new Schema(
+  {
+    title: {
+      type: String,
+      required: true,
+    },
+    isDeleted: {
+      type: Boolean,
+      default: false,
+    },
+    type: {
+      type: String,
+      enum: ["conversation", "ticket", "both"],
+      default: "conversation",
+    },
+    workspaceId: {
+      type: String,
+      default: "",
+    },
+    createdBy: {
+      type: Schema.Types.ObjectId,
+      ref: "User",
+    },
+    enabled: {
+      type: Boolean,
+      default: true,
+    },
+    group: [EscalationGroupSchema], // Array of groups, each containing multiple levels
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const EscalationConfiguration = mongoose.model(
+  "EscalationConfiguration",
+  EscalationConfigurationSchema
+);
+
+module.exports = { EscalationConfiguration };