shuttlepro-shared 1.3.39 → 1.3.41

package/models/Automation.js

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

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

@@ -1,13 +0,0 @@
-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/Catalogue.js

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

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

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

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

@@ -1,10 +0,0 @@
-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/CustomerCheckpoint.js

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

@@ -1,13 +0,0 @@
-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/Email.js

@@ -1,21 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const EmailSchema = new Schema(
-  {
-    name: { type: String, default: "" },
-    address: { type: String, default: "" },
-    contact: { type: String, default: "" },
-    email: { type: String, default: "" },
-    reference: { type: String, default: "" },
-    city: { type: String, default: "" },
-    isBlackListed: { type: Boolean, default: false },
-    customerId: { type: String, default: "" },
-    workspaceId: { type: String, default: "" },
-    designation: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-const Email = mongoose.model("Email", EmailSchema);
-module.exports = Email;

package/models/EmailMessage.js

@@ -1,30 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const EmailMessageSchema = new Schema(
-  {
-    workspaceId: { type: String, default: "" },
-    threadId: { type: String, default: "" },
-    messageId: { type: String, default: "" },
-    message: { type: String, default: "" },
-    subject: { type: String, default: "" },
-    trackingId: { type: String, default: "" },
-    integratedEmail: { type: String, default: "" },
-    receiverEmail: { type: String, default: "" },
-    senderEmail: { type: String, default: "" },
-    agentId: { type: String, default: "" },
-    isRead: { type: Boolean, default: false },
-    type: { type: String, default: "email" },
-    attachmentArr: [
-      {
-        attachmentId: { type: String, default: "" },
-        attachemntName: { type: String, default: "" },
-        attachmentSize: { type: String, default: "" },
-      },
-    ],
-    right: { type: Boolean, default: true },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = EmailMessageSchema;

package/models/EmailNotification.js

@@ -1,17 +0,0 @@
-const mongoose = require("mongoose");
-
-const emailNotificationSchema = new mongoose.Schema(
-  {
-    threadId: { type: String, default: "" },
-    messageId: { type: String, default: "" },
-    message: { type: String, default: "" },
-    subject: { type: String, default: "" },
-    trackingId: { type: String, default: "" },
-    integratedEmail: { type: String, default: "" },
-    receiverEmail: { type: String, default: "" },
-    senderEmail: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = mongoose.model("EmailNotification", emailNotificationSchema);