shuttlepro-shared 1.3.30 → 1.3.31

package/models/SocialGroup.js

@@ -0,0 +1,127 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const SocialGroupSchema = new mongoose.Schema(
+  {
+    name: { type: String, default: "" },
+    products: [
+      {
+        productId: {
+          type: Schema.Types.ObjectId,
+          ref: "Product",
+        },
+        orderNo: {
+          type: String,
+          default: "",
+        },
+      },
+    ],
+    deletedArr: [],
+    productCount: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    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 } }
+);
+
+const SocialGroup = mongoose.model("SocialGroup", SocialGroupSchema);
+
+const createNewSocialGroup = async (socialGroupData) => {
+  try {
+    return await SocialGroup.create(socialGroupData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findSocialGroupById = async (socialGroupId) => {
+  try {
+    return await SocialGroup.findById(socialGroupId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const updateSocialGroupById = async (criteria, updateData, options = {}) => {
+  try {
+    return await SocialGroup.findByIdAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const deleteSocialGroupById = async (socialGroupId) => {
+  try {
+    return await SocialGroup.findByIdAndDelete(socialGroupId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findSocialGroup = async (criteria, selectFields, populateOptions) => {
+  try {
+    let query = SocialGroup.findOne(criteria);
+
+    if (selectFields) {
+      query = query.select(selectFields);
+    }
+
+    if (populateOptions) {
+      query = query.populate(populateOptions);
+    }
+
+    return await query.exec();
+  } catch (error) {
+    console.error(error);
+    return null;
+  }
+};
+
+const findSocialGroups = async (criteria) => {
+  try {
+    return await SocialGroup.find(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const socialGroupByAggregation = async (pipeline) => {
+  try {
+    return await SocialGroup.aggregate(pipeline);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const socialGroupUpdateMany = async (criteria, updateData, options = {}) => {
+  try {
+    return await SocialGroup.updateMany(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+module.exports = {
+  SocialGroup,
+  createNewSocialGroup,
+  findSocialGroupById,
+  updateSocialGroupById,
+  deleteSocialGroupById,
+  findSocialGroup,
+  findSocialGroups,
+  socialGroupByAggregation,
+  socialGroupUpdateMany,
+};

package/models/SocialPost.js

@@ -0,0 +1,40 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const SocialPostSchema = new Schema(
+  {
+    type: { type: String, default: "single" },
+    postType: { type: String, default: "post" },
+    platformType: { type: String, default: "facebook" },
+    isScheduledPost: { type: Boolean, default: false },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    pageId: { type: String, default: "" },
+    pageName: { type: String, default: "" },
+    pageLogo: { type: String, default: "" },
+    pageToken: { type: String, default: "" },
+    caption: { type: String, default: "" },
+    permanentLink: { type: String, default: "" },
+    attachments: [{
+      link: { type: String, default: ""},
+      src: { type: String, default: "" },
+      caption: { type: String, default: "" },
+      mediaType: { type: String, default: "" }
+    }],
+    socialProfile: { type: Schema.Types.ObjectId, ref: "Integration", default: null },
+    status: { type: String, default: "scheduled" },
+    scheduleDate: {type: Date, default: null },
+    queued: { type: Boolean, default: false },
+    isDeleted: { type: Boolean, default: false },
+    publishedAt: { type: String, default: ""  },
+    publishedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const SocialPost = mongoose.model("SocialPost", SocialPostSchema);
+module.exports = SocialPost;
+

package/models/SocialProfile.js

@@ -0,0 +1,57 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+// const { Workspace } = require("./Workspace");
+
+const socialProfileSchema = new mongoose.Schema(
+  {
+    pageName: { type: String, default: "" },
+    pageToken: { type: String, default: "" },
+    platformType: { type: String, default: "" },
+    pageId: { type: String, default: "" },
+    pageIcon: { type: String, default: "" },
+    pageCoverUrl: { type: String, default: "" },
+    username: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    isDeleted: { type: Boolean, default: false },
+    userId: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    options: {
+      type: Object,
+      default: null,
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const SocialProfile = mongoose.model("socialProfile", socialProfileSchema);
+
+const getSocialProfile = async (profileId) => {
+  try {
+    return await SocialProfile.findOne({
+      _id: mongoose.Types.ObjectId(profileId),
+    });
+  } catch (error) {
+    throw error;
+  }
+};
+const findByPageId = async (pageId) => {
+  try {
+    let obj = { pageId: pageId, isDeleted: false };
+    const fetchingSocialProfile = await SocialProfile.findOne(obj);
+    if (fetchingSocialProfile) {
+      return fetchingSocialProfile;
+    }
+    return null;
+  } catch (err) {
+    return null;
+  }
+};
+
+module.exports = {
+  getSocialProfile,
+  findByPageId,
+  SocialProfile,
+};

package/models/Tag.js

@@ -0,0 +1,77 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const TagSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    oldId: { type: String, default: "" },
+    webTagId: { type: Number, 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 Tag = mongoose.model("Tag", TagSchema);
+
+const tagsByAggregation = async (aggregate) => {
+  try {
+    return await Tag.aggregate(aggregate);
+  } catch (err) {
+    return [];
+  }
+};
+
+const findTags = async (obj) => {
+  try {
+    return await Tag.find(obj);
+  } catch (err) {
+    return [];
+  }
+};
+
+const findSingleTag = async (obj) => {
+  try {
+    return await Tag.findOne(obj);
+  } catch (err) {
+    return null;
+  }
+};
+
+const createTag = async (obj) => {
+  try {
+    const tag = new Tag(obj);
+    return await tag.save();
+  } catch (err) {
+    return null;
+  }
+};
+const softDeleteTags = async (workspaceId, convertingIds, type) => {
+  try {
+    const filter = {
+      workspaceId: workspaceId,
+      isDeleted: false,
+    };
+    filter[type] = { $in: convertingIds };
+    const update = { $set: { isDeleted: true } };
+    const result = await Tag.updateMany(filter, update);
+    return result;
+  } catch (err) {
+    return [];
+  }
+};
+
+module.exports = {
+  Tag,
+  tagsByAggregation,
+  findTags,
+  findSingleTag,
+  createTag,
+  softDeleteTags,
+  Tag,
+};

package/models/Template.js

@@ -0,0 +1,76 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const templateSchema = new mongoose.Schema({
+  text: [
+    {
+      id: String,
+      textId: String,
+      text: String,
+      fontSize: String,
+      color: String,
+      fontFamily: String,
+      fontWeight: String,
+      textDecoration: String,
+      fontStyle: String,
+      x: Number,
+      y: Number,
+      width: Number,
+      rotation: { type: Number, default: 0 },
+    },
+  ],
+  image: [
+    {
+      id: String,
+      src: String,
+      url: String,
+      x: Number,
+      y: Number,
+      height: Number,
+      width: Number,
+      type: { type: String, default: "logo" },
+    },
+  ],
+  height: String,
+  width: String,
+  back: [
+    {
+      src: String,
+      id: String,
+      x: Number,
+      y: Number,
+      height: Number,
+      width: Number,
+    },
+  ],
+  display: [
+    {
+      id: String,
+      src: String,
+      x: Number,
+      y: Number,
+      height: Number,
+      width: Number,
+      rotation: { type: Number, default: 0 },
+    },
+  ],
+  preview: {
+    id: String,
+    src: String,
+    x: Number,
+    y: Number,
+    height: Number,
+    width: Number,
+    rotation: { type: Number, default: 0 },
+  },
+  frameId: {
+    type: Schema.Types.ObjectId,
+    ref: "TemplateFrame",
+  },
+  name: { type: String, default: "" },
+  canColor: String,
+  userId: String,
+  workspaceId: { type: String, default: "" },
+});
+
+module.exports = mongoose.model("Template", templateSchema);

package/models/TemplateFrame.js

@@ -0,0 +1,37 @@
+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: "TemplateTag",
+        },
+      },
+    ],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+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/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/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

@@ -273,6 +273,9 @@ const workspaceSchema = new mongoose.Schema(
                 "url",
                 "colour",
                 "file",
+                "starRating",
+                "paragraph",
+                "heading",
               ],
             },
             option: {