shuttlepro-shared 1.3.29 → 1.3.31

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/Location.js

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

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

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

package/models/Order.js

@@ -136,6 +136,14 @@ const OrderSchema = new Schema(
       paymentDate: { type: String, default: "" },
       paymentDetails: {},
     },
+    merged: {
+      status: { type: String, default: "open" },
+      webOrderNumbers: [],
+      orderNumbers: [],
+      localOrderIds: [],
+      webOrderIds: [],
+      details: [],
+    },
     credentials: {},
     ticketId: { type: String, default: "" },
     sender: { type: String, default: "" },
@@ -159,6 +167,9 @@ const OrderSchema = new Schema(
     },
     orderName: { type: String, default: "" },
     totalWeight: { type: String, default: "" },
+    currency: {},
+    presentedCurrency: {},
+    exchangeRate: { type: Number, default: 0 },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

package/models/OrderPdf.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const OrderPdfScehma = new mongoose.Schema(
+  {
+    orderNumber: {
+      type: {
+        localMin: { type: String, default: "" },
+        localMax: { type: String, default: "" },
+        storeMin: { type: String, default: "" },
+        storeMax: { type: String, default: "" },
+      },
+    },
+    ordersCount: { type: String, default: "" },
+    url: { type: String, default: "" },
+    key: { type: String, default: "" },
+    status: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      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("OrderPdf", OrderPdfScehma);

package/models/PostsAutomation.js

@@ -0,0 +1,66 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const PostsAutomation = new mongoose.Schema(
+  {
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    platformType: {
+      type: String,
+      required: true,
+      enum: ["facebook", "instagram"],
+    },
+    attachments: [
+      {
+        type: String,
+        default: "",
+      },
+    ],
+    attachmentType: {
+      type: String,
+      default: "",
+    },
+    postId: {
+      type: String,
+      default: "",
+    },
+    verb: {
+      type: String,
+      default: "",
+    },
+    published: {
+      type: String,
+      default: "",
+    },
+    message: {
+      type: String,
+      default: "",
+    },
+    pageId: {
+      type: String,
+      default: "",
+    },
+    field: {
+      type: String,
+      default: "",
+    },
+    integratedAccount: {
+      type: Schema.Types.ObjectId,
+      ref: "Integration",
+      default: null,
+    },
+    status: {
+      type: String,
+      default: "",
+      emum: ["active", "pending", "removed"],
+    },
+    platformTimestamp: { type: String, default: "" },
+    body: [{}],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("PostsAutomation", PostsAutomation);