shuttlepro-shared 1.3.41 → 1.3.42

package/models/Email.js

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

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

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

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", "formBuilder"],
+      },
+      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 };

package/models/EscalationManager.js

@@ -0,0 +1,50 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const EscalationManagerSchema = new Schema(
+  {
+    type: {
+      type: String,
+      required: true,
+      enum: ["conversation", "ticket"],
+    },
+    refId: {
+      type: String,
+      required: true,
+    },
+    escalationId: {
+      type: Schema.Types.ObjectId,
+      ref: "Escalation",
+    },
+    groupId: {
+      type: String,
+    },
+    status: {
+      type: String,
+      enum: ["pending", "processing", "close"],
+    },
+    managerStatus: [
+      {
+        escalationLevel: {
+          type: Number,
+        },
+        status: {
+          type: String,
+          enum: ["pending", "done", "failed"],
+        },
+      },
+    ],
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const EscalationManager = mongoose.model(
+  "EscalationManager",
+  EscalationManagerSchema
+);
+
+module.exports = EscalationManager;

package/models/Faq.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const FaqItemSchema = new Schema({
+  question: { type: String, required: true },
+  answer: { type: String, required: true },
+});
+
+const FaqSchema = new Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+    },
+    list: {
+      type: [FaqItemSchema],
+      required: true,
+    },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const Faq = mongoose.model("Faq", FaqSchema);
+
+module.exports = Faq;

package/models/FeedbackResponse.js

@@ -0,0 +1,72 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const { v4: uuidv4 } = require("uuid");
+
+const FeedbackResponseSchema = new Schema(
+  {
+    paramId: {
+      type: String,
+      default: uuidv4(),
+    },
+    type: {
+      type: String,
+      enum: ["conversation", "order"],
+      default: "conversation",
+    },
+    refId: {
+      type: String,
+      default: "",
+    },
+    workspaceId: {
+      type: String,
+      default: "",
+    },
+    agentId: {
+      type: String,
+      default: "",
+    },
+    feedbackFormId: {
+      type: String,
+      default: "",
+    },
+    data: {
+      type: Schema.Types.Mixed,
+      default: {},
+    },
+    responseAdded: {
+      type: Boolean,
+      default: false,
+    },
+    customerInfo: {
+      type: Schema.Types.Mixed,
+      default: {},
+    },
+    platformInfo: {
+      type: Schema.Types.Mixed,
+      default: {},
+    },
+    timeStamp: {
+      type: Date,
+      default: Date.now,
+    },
+
+    workspaceId: {
+      type: String,
+      default: "",
+    },
+    feedbackFormId: {
+      type: String,
+      default: "",
+    },
+    qr: {
+      link: {
+        type: String,
+        default: "",
+        trim: true,
+      },
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("FeedbackResponse", FeedbackResponseSchema);

package/models/FormTemplate.js

@@ -0,0 +1,27 @@
+const mongoose = require("mongoose");
+
+const FormTemplateSchema = new mongoose.Schema(
+  {
+    type: {
+      type: String,
+      required: true,
+      enum: ["feedback", "ticket"],
+    },
+    subType: {
+      type: String,
+      enum: ["formBuilder","complaint", "order", "ticket", "product"],
+    },
+    workspaceId: {
+      type: String,
+      default: "",
+    },
+    body: {
+      type: mongoose.Schema.Types.Mixed,
+      default: {},
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const FormTemplate = mongoose.model("FormTemplate", FormTemplateSchema);
+module.exports = FormTemplate;

package/models/Integration.js

@@ -48,4 +48,10 @@ const IntegrationSchema = new mongoose.Schema(
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );
 
+IntegrationSchema.virtual("conversations", {
+  ref: "Conversation",
+  localField: "_id",
+  foreignField: "platformId",
+});
+
 module.exports = mongoose.model("Integration", IntegrationSchema);

package/models/InternalComments.js

@@ -0,0 +1,27 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const InternalCommentSchema = new Schema(
+  {
+    comment: { type: String, default: "" },
+    item_id: { type: String, default: "" },
+    sender_profile_url: { type: String, default: "" },
+    workspace_id: { type: String, default: "" },
+    sender_name: { type: String, default: "" },
+    senderId: { type: String, default: "" },
+    commentType: { type: String, default: "" },
+    mention_id: [{ id: String, name: String }],
+    pageId: { type: String, default: "" },
+    attachments: [],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+InternalCommentSchema.virtual("internalThreads", {
+  ref: "InternalThreads",
+  localField: "_id",
+  foreignField: "internalCommentId",
+});
+const InternalComment = mongoose.model(
+  "InternalComment",
+  InternalCommentSchema
+);
+module.exports = InternalComment;

package/models/InternalThreads.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const InternalThreadsSchema = new Schema(
+  {
+    internalCommentId: { type: Schema.Types.ObjectId, ref: "InternalComment" },
+    comment: { type: String, default: "" },
+    sender_name: { type: String, default: "" },
+    senderId: { type: String, default: "" },
+    sender_profile_url: { type: String, default: "" },
+    mention_id: [{ id: String, name: String }],
+    pageId: { type: String, default: "" },
+    attachments: [],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+const InternalThreads = mongoose.model(
+  "InternalThreads",
+  InternalThreadsSchema
+);
+module.exports = InternalThreads;

package/models/JobDesign.js

@@ -0,0 +1,32 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const jobDesignSchema = new mongoose.Schema(
+  {
+    name: { type: String, default: "" },
+    products: { type: Number, default: 0 },
+    productIds: [],
+    status: { type: String, default: "processing" },
+    data: [
+      {
+        url: { type: String, default: "" },
+        bucket: { type: String, default: "" },
+        key: { type: String, default: "" },
+      },
+    ],
+    downloads: [],
+    tagName: { type: String, default: "" },
+    tagId: { type: String, default: "" },
+    userId: { type: Schema.Types.ObjectId, ref: "User" },
+    userName: { type: String, default: "" },
+    organizationId: { type: Number, default: 0 },
+    workspaceId: { type: Schema.Types.ObjectId, ref: "Workspace" },
+    templateId: {
+      type: Schema.Types.ObjectId,
+      ref: "Template",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("JobDesign", jobDesignSchema);

package/models/JobQueue.js

@@ -0,0 +1,17 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const jobQueueSchema = new mongoose.Schema(
+  {
+    jobId: { type: String },
+    templateData: { type: Object },
+    imageUrl: { type: String },
+    imageId: { type: String, default: "" },
+    workspaceId: { type: Schema.Types.ObjectId, ref: "Product" },
+    status: { type: String, default: "Processing" },
+    message: { type: String, default: "" },
+    attempt: { type: Number, default: 0 },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("JobQueue", jobQueueSchema);

package/models/LabelsPdf.js

@@ -0,0 +1,12 @@
+const mongoose = require("mongoose");
+
+const LabelsPdfSchema = new mongoose.Schema(
+  {
+    url: { type: String, default: "" },
+    organizationId: { type: Number, default: 0 },
+    storeId: { type: Number, default: 0 }
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("LabelsPdf", LabelsPdfSchema);

package/models/Layout.js

@@ -0,0 +1,12 @@
+const mongoose = require("mongoose");
+
+const layoutSchema = new mongoose.Schema(
+  {
+    name: { type: String, default: "" },
+    height: { type: Number, default: 0 },
+    width: { type: Number, default: 0 }
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("Layout", layoutSchema);

package/models/LoadSheet.js

@@ -0,0 +1,31 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const loadSheetSchema = new mongoose.Schema(
+  {
+    uuid: { type: String, default: "" },
+    courierName: { type: String, default: "" },
+    courierId: { type: String, default: "" },
+    orders: [
+      {
+        orderId: {
+          type: Schema.Types.ObjectId,
+          ref: "Order",
+          default: null,
+        },
+      },
+    ],
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    isDeleted: { type: Boolean, default: false },
+    generatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("LoadSheet", loadSheetSchema);

package/models/Location.js

@@ -0,0 +1,148 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const LocationSchema = new Schema(
+  {
+    isDefault: { type: Boolean, default: false },
+    address1: { type: String, default: "" },
+    address2: { type: String, default: "" },
+    city: { type: String, default: "" },
+    zip: { type: String, default: "" },
+    province: { type: String, default: "" },
+    country: { type: String, default: "" },
+    phone: { type: String, default: "" },
+    active: { type: Boolean, default: true },
+    oldId: { type: String, default: "" },
+    webLocationId: { type: Number, default: null },
+    bcLocationId: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    legacy: { type: Boolean, default: false },
+    name: { type: String, default: "" },
+    isDeleted: { type: Boolean, default: false },
+    bcLocationId: { type: String, default: "" },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+LocationSchema.virtual("variantLocations", {
+  ref: "VariantLocation",
+  localField: "_id",
+  foreignField: "locationId",
+});
+
+const Location = mongoose.model("Location", LocationSchema);
+
+const createNewLocation = async (locationData) => {
+  try {
+    return await Location.create(locationData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findLocationById = async (locationId) => {
+  try {
+    return await Location.findById(locationId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const updateLocationById = async (criteria, updateData, options) => {
+  try {
+    return await Location.findByIdAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+const updateLocation = async (criteria, updateData, options) => {
+  try {
+    return await Location.findOneAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findAndUpdateLocation = async (criteria, data, options) => {
+  try {
+    return await Location.findOneAndUpdate(criteria, data, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+const deleteLocationById = async (locationId) => {
+  try {
+    return await Location.findByIdAndDelete(locationId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findLocation = async (criteria) => {
+  try {
+    return await Location.findOne(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findLocations = async (criteria) => {
+  try {
+    return await Location.find(criteria);
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+const locationsByAggregation = async (aggregate = []) => {
+  try {
+    let locations = await Location.aggregate(aggregate);
+    return locations;
+  } catch (err) {
+    return [];
+  }
+};
+
+const locationsUpdateMany = async (criteria, updateData, options = {}) => {
+  try {
+    return await Location.updateMany(criteria, updateData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+const insertLocations = async (locations) => {
+  try {
+    return await Location.insertMany(locations);
+  } catch (err) {
+    return [];
+  }
+};
+
+module.exports = {
+  Location,
+  createNewLocation,
+  findLocationById,
+  updateLocationById,
+  updateLocation,
+  deleteLocationById,
+  findLocation,
+  findLocations,
+  locationsByAggregation,
+  locationsUpdateMany,
+  insertLocations,
+  findAndUpdateLocation,
+};