shuttlepro-shared 1.3.41 → 1.3.43

package/models/TemplateFrame.js

@@ -0,0 +1,55 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const templateFrameSchema = new mongoose.Schema(
+  {
+    fullImageUrl: { type: String, default: "" },
+    frameUrl: { type: String, default: "" },
+    name: { type: String, default: "" },
+    height: { type: Number },
+    width: { type: Number },
+    displayImageHeight: { type: Number },
+    displayImageWidth: { type: Number },
+    type: { type: String, default: "" },
+    categoryId: { type: Schema.Types.ObjectId, ref: "Catalogue" },
+    subCategoryId: { type: String, default: "" },
+    workspaceId: { type: String, default: "" },
+    colorIds: [
+      {
+        colorId: {
+          type: Schema.Types.ObjectId,
+          ref: "Color",
+        },
+      },
+    ],
+    tagIds: [
+      {
+        tagId: {
+          type: Schema.Types.ObjectId,
+          ref: "Tag",
+        },
+      },
+    ],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+templateFrameSchema.virtual("templateTag", {
+  ref: "TemplateTag",
+  localField: "_id",
+  foreignField: "frameId",
+});
+
+templateFrameSchema.virtual("templateColors", {
+  ref: "TemplateColor",
+  localField: "_id",
+  foreignField: "frameId",
+});
+
+templateFrameSchema.virtual("templateCategories", {
+  ref: "TemplateCategory",
+  localField: "_id",
+  foreignField: "frameId",
+});
+
+module.exports = mongoose.model("TemplateFrame", templateFrameSchema);

package/models/TemplateTag.js

@@ -0,0 +1,10 @@
+const mongoose = require("mongoose");
+
+const tagSchema = new mongoose.Schema(
+  {
+    name: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("TemplateTag", tagSchema);

package/models/UserGuide.js

@@ -0,0 +1,21 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const UserGuideSchema = new Schema(
+  {
+    category: {
+      type: String,
+      required: true,
+    },
+    subcategory: {
+      type: String,
+      required: true,
+    },
+    pdfUrl: {
+      type: String,
+      required: true,
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+const UserGuide = mongoose.model("UserGuide", UserGuideSchema);
+module.exports = UserGuide;

package/models/UserSession.js

@@ -0,0 +1,47 @@
+const mongoose = require("mongoose");
+
+const userSessionSchema = new mongoose.Schema(
+  {
+    userId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "User",
+      default: null,
+    },
+    browserId: {
+      type: String,
+      default: "",
+    },
+    ipAddress: {
+      type: String,
+      default: "",
+    },
+    userAgent: {
+      type: String,
+      default: "",
+    },
+    createdTime: {
+      type: String,
+      default: "",
+    },
+    lastActivity: {
+      type: String,
+      default: "",
+    },
+    valid: {
+      type: Boolean,
+      default: true,
+    },
+    uuid: {
+      type: String,
+      default: "",
+    },
+    type: {
+      type: String,
+      default: "web",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const UserSession = mongoose.model("UserSession", userSessionSchema);
+module.exports = UserSession;

package/models/VariantLocation.js

@@ -0,0 +1,145 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const VariantLocationSchema = new Schema(
+  {
+    variantId: {
+      type: Schema.Types.ObjectId,
+      ref: "ProductVariant",
+      default: null,
+    },
+    quantity: { type: Number, default: 0 },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
+    locationId: { type: Schema.Types.ObjectId, ref: "Location", default: null },
+    webVariantLocationId: { type: Number, default: null },
+    rackNo: { type: String, default: "" },
+    boxNo: { type: String, default: "" },
+    shelfNo: { type: String, default: "" },
+    uuid: { 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 },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const VariantLocation = mongoose.model(
+  "VariantLocation",
+  VariantLocationSchema
+);
+
+const createNewVariantLocation = async (variantLocationData) => {
+  try {
+    return await VariantLocation.create(variantLocationData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const insertVariantLocations = async (data) => {
+  try {
+    return await VariantLocation.insertMany(data);
+  } catch (error) {
+    console.log(error);
+    return [null];
+  }
+};
+
+const updateManyVariantsLocations = async (
+  criteria,
+  updateData,
+  options = {}
+) => {
+  try {
+    return await VariantLocation.updateMany(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findVariantLocationById = async (variantLocationId) => {
+  try {
+    return await VariantLocation.findById(variantLocationId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const updateVariantLocationById = async (criteria, updateData, options) => {
+  try {
+    return await VariantLocation.findByIdAndUpdate(
+      criteria,
+      updateData,
+      options
+    );
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const deleteVariantLocationById = async (variantLocationId) => {
+  try {
+    return await VariantLocation.findByIdAndDelete(variantLocationId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findVariantLocation = async (criteria) => {
+  try {
+    return await VariantLocation.findOne(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findVariantLocations = async (criteria) => {
+  try {
+    return await VariantLocation.find(criteria);
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+const findSingleVariantLocation = async (obj) => {
+  try {
+    let variantLocation = await VariantLocation.findOne(obj);
+    return variantLocation;
+  } catch (err) {
+    return null;
+  }
+};
+
+const findVariantLocationsByPopulate = async (criteria, populate) => {
+  try {
+    return await VariantLocation.find(criteria).populate(populate);
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+module.exports = {
+  insertVariantLocations,
+  createNewVariantLocation,
+  updateManyVariantsLocations,
+  findVariantLocationById,
+  updateVariantLocationById,
+  findVariantLocationsByPopulate,
+  deleteVariantLocationById,
+  findVariantLocation,
+  findVariantLocations,
+  findSingleVariantLocation,
+  VariantLocation,
+};

package/models/WhatsappFlow.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose");
+
+const whatsappFlowSchema = new mongoose.Schema(
+  {
+    referenceId: {
+      type: String,
+      default: "",
+    },
+    flowName: {
+      type: String,
+      default: "",
+    },
+    workspaceId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Workspace",
+    },
+    response: {
+      type: Object,
+      default: {},
+    },
+  },
+  {
+    timestamps: true,
+  }
+);
+
+const WhatsappFlow = mongoose.model("WhatsappFlow", whatsappFlowSchema);
+
+module.exports = WhatsappFlow;

package/models/Workflow.js

@@ -0,0 +1,34 @@
+const mongoose = require("mongoose");
+
+const WorkflowSchema = new mongoose.Schema(
+  {
+    workspaceId: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Workspace",
+      required: true,
+    },
+    orders: {
+      enabled: { type: Boolean, default: false },
+      maxOrders: { type: Number, default: 100 },
+      currentCount: { type: Number, default: 0 },
+    },
+    chatbot: { type: Boolean, default: true },
+    nlpBot: {
+      enabled: { type: Boolean, default: true },
+      shared: {
+        maxRequests: { type: Number, default: 5000 },
+        maxTokens: { type: Number, default: 80000 },
+        requestsCount: { type: Number, default: 0 },
+        tokensCount: { type: Number, default: 0 },
+      },
+      custom: {
+        requestsCount: { type: Number, default: 0 },
+        tokensCount: { type: Number, default: 0 },
+      },
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const Workflow = mongoose.model("Workflow", WorkflowSchema);
+module.exports = Workflow;

package/models/Workspace.js

@@ -1,7 +1,24 @@
 const mongoose = require("mongoose");
+const SettingModel = require("./Setting");
+const SocialMediaSettingModel = require("./SocialMediaSetting");
+const { Schema } = mongoose;
+
+const generateSlug = (input) => {
+  return input
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9\s-]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-");
+};
+
 //TODO: task manager and default location creation
 const shiftSchema = new mongoose.Schema(
   {
+    _id: {
+      type: mongoose.Schema.Types.ObjectId,
+      default: () => new mongoose.Types.ObjectId(),
+    },
     shiftName: {
       type: String,
       required: true,
@@ -161,6 +178,13 @@ const workspaceSchema = new mongoose.Schema(
       required: true,
       trim: true,
     },
+    slug: {
+      type: String,
+      required: true,
+      trim: true,
+      default: "",
+      unique: true,
+    },
     iconUrl: { type: String, default: "" },
     thumbUrl: { type: String, default: "" },
     createdBy: {
@@ -273,6 +297,9 @@ const workspaceSchema = new mongoose.Schema(
                 "url",
                 "colour",
                 "file",
+                "starRating",
+                "paragraph",
+                "heading",
               ],
             },
             option: {
@@ -292,9 +319,44 @@ const workspaceSchema = new mongoose.Schema(
       default: "everyone",
     },
     defaultShift: { type: String, default: "" },
+    automationManager: {
+      delayThreshold: {
+        type: Number,
+        default: 5,
+      },
+      messageCount: {
+        type: Number,
+        default: 3,
+      },
+    },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );
+
+workspaceSchema.virtual("products", {
+  ref: "Product",
+  localField: "_id",
+  foreignField: "workspaceId",
+});
+
+workspaceSchema.virtual("orders", {
+  ref: "Order",
+  localField: "_id",
+  foreignField: "workspaceId",
+});
+
+workspaceSchema.virtual("socialProfilesArr", {
+  ref: "socialProfile",
+  localField: "_id",
+  foreignField: "workspaceId",
+});
+
+workspaceSchema.virtual("integrations", {
+  ref: "Integration",
+  localField: "_id",
+  foreignField: "workspaceId",
+});
+
 const commonOptions = {
   type: String,
   trim: true,
@@ -311,10 +373,22 @@ workspaceSchema.add({
   chatGptApiKey: commonOptions,
 });
 
-workspaceSchema.virtual("integrations", {
-  ref: "Integration",
-  localField: "_id",
-  foreignField: "workspaceId",
+workspaceSchema.pre("save", async function (next) {
+  if (this.isModified("name")) {
+    let slug = generateSlug(this.name);
+    let slugExists = await mongoose.models.Workspace.findOne({ slug });
+
+    let counter = 1;
+    while (slugExists) {
+      slug = `${slug}-${counter}`;
+      slugExists = await mongoose.models.Workspace.findOne({ slug });
+      counter++;
+    }
+
+    this.slug = slug;
+  }
+  next();
 });
+
 const Workspace = mongoose.model("Workspace", workspaceSchema);
 module.exports = Workspace;