shuttlepro-shared 1.3.30 → 1.3.32

package/models/Activity.js

@@ -0,0 +1,28 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const ActivitySchema = new Schema(
+  {
+    trackingId: { type: String, default: "" },
+    date: { type: String, default: "" },
+    name: { type: String, default: "" },
+    type: { type: String, default: "" },
+    orderId: { type: String, default: "" },
+    emailId: { type: Schema.Types.ObjectId, ref: "Email" },
+    mailGroupId: { type: Schema.Types.ObjectId, ref: "MailGroup" },
+    templateId: { type: Schema.Types.ObjectId, ref: "DescriptionTemplate" },
+    message: { type: String, default: "" },
+    status: { type: String, default: "" },
+    customerName: { type: String, default: "" },
+    contact: { type: String, default: "" },
+    notificationTimer: { type: String, default: "" },
+    scheduledTime: { type: String, default: "" },
+    workspaceId: { type: String, default: "" },
+    subject: { type: String, default: "" },
+    userName: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const Activity = mongoose.model("Activity", ActivitySchema);
+module.exports = Activity;

package/models/AgentActivity.js

@@ -164,7 +164,9 @@ const findOneAndUpdateAgentActivity = async (
     );
 
     if (bsonSize <= 1000000) {
-      return await AgentActivity.findOneAndUpdate(findQuery, updateQuery);
+      return await AgentActivity.findOneAndUpdate(findQuery, updateQuery, {
+        new: true,
+      });
     } else {
       const { breaks, activities, totalActivities, ...restData } =
         agentActivityForActivitiesUpdated.toObject();
@@ -175,7 +177,8 @@ const findOneAndUpdateAgentActivity = async (
 
       const agentActivityRecord = await AgentActivity.findOneAndUpdate(
         { ...findQuery, _id: newAgentActivity._id },
-        updateQuery
+        updateQuery,
+        { new: true }
       );
 
       return agentActivityRecord;

package/models/Attribute.js

@@ -0,0 +1,130 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const AttributeSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    webAttributeId: { type: Number, default: null },
+    parentId: { type: Schema.Types.ObjectId, ref: "Attribute", default: null },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    oldId: { type: String, default: "" },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    isDeleted: { type: Boolean, default: false },
+    isDefault: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+AttributeSchema.virtual("values", {
+  ref: "Attribute",
+  localField: "_id",
+  foreignField: "parentId",
+});
+
+const Attribute = mongoose.model("Attribute", AttributeSchema);
+
+const createNewAttribute = async (attributeData) => {
+  try {
+    return await Attribute.create(attributeData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const attributesInsertMany = async (data) => {
+  try {
+    return await Attribute.insertMany(data);
+  } catch (error) {
+    return [];
+  }
+};
+
+const findAttributeById = async (attributeId) => {
+  try {
+    return await Attribute.findById(attributeId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const updateAttributeById = async (criteria, updateData, options = {}) => {
+  try {
+    return await Attribute.findByIdAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const deleteAttributeById = async (attributeId) => {
+  try {
+    return await Attribute.findByIdAndDelete(attributeId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findAttribute = async (criteria) => {
+  try {
+    return await Attribute.findOne(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findAttributes = async (criteria) => {
+  try {
+    return await Attribute.find(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const attributesByAggregation = async (pipeline) => {
+  try {
+    return await Attribute.aggregate(pipeline);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const attributesUpdateMany = async (criteria, updateData, options = {}) => {
+  try {
+    return await Attribute.updateMany(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findAttributesWithPopulate = async (criteria, populate) => {
+  try {
+    return await Attribute.find(criteria).populate(populate);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+module.exports = {
+  Attribute,
+  createNewAttribute,
+  findAttributeById,
+  updateAttributeById,
+  deleteAttributeById,
+  findAttribute,
+  findAttributes,
+  attributesByAggregation,
+  attributesInsertMany,
+  attributesUpdateMany,
+  findAttributesWithPopulate,
+};

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