shuttlepro-shared 1.3.39 → 1.3.40

package/models/EscalationConfiguration.js

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,147 +0,0 @@
-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 },
-    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,
-};

package/models/Logo.js

@@ -1,11 +0,0 @@
-const mongoose = require("mongoose");
-
-const logoSchema = new mongoose.Schema(
-  {
-    url: { type: String, default: "" },
-    workspaceId: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-module.exports = mongoose.model("Logo", logoSchema);

package/models/MailGroup.js

@@ -1,21 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const MailGroupSchema = new Schema(
-  {
-    name: { type: String, default: "" },
-    emailIds: [
-      {
-        emailId: {
-          type: Schema.Types.ObjectId,
-          ref: "Email",
-        },
-      },
-    ],
-    workspaceId: { type: String, default: "" },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-const MailGroup = mongoose.model("MailGroup", MailGroupSchema);
-module.exports = MailGroup;

package/models/Notification.js

@@ -1,32 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-const NotificationSchema = new Schema(
-  {
-    type: { type: String, default: "" },
-    isRead: { type: Boolean, default: false },
-    operation: { type: String, default: "" },
-    actionId: { type: String, default: "" },
-    workspaceId: { type: String, default: "" },
-    workspaceName: { type: String, default: "" },
-    message: { type: String, default: "" },
-    email: { type: String, default: "" },
-    userId: { type: String, default: "" },
-    data: { type: mongoose.Schema.Types.Mixed },
-    isDeleted: { type: Boolean, default: false },
-    alertShow: { type: Boolean, default: false },
-    routes: {
-      routeType: { type: String, default: "" },
-      id: { type: String, default: "" },
-      query: { type: Boolean, default: false },
-      queryData: { type: String, default: "" },
-    },
-    permissions: [],
-    role: [String],
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-const Notification = mongoose.model("Notification", NotificationSchema);
-
-module.exports = Notification;