shuttlepro-shared 1.3.39 → 1.3.40

package/models/SocialGroup.js

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

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

@@ -1,56 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-
-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/Story.js

@@ -1,86 +0,0 @@
-const mongoose = require("mongoose");
-
-const StorySchema = new mongoose.Schema(
-  {
-    option: { type: String, default: "" },
-    images: [String],
-    shareAt: { type: String, default: "" },
-    userId: { type: String, default: "" },
-    delay: { type: String, default: "" },
-    status: { type: String, default: "pending" },
-    workspaceId: { type: String, default: "" },
-    timeZone: { type: String, default: "" },
-    pageId: { type: String, default: "" },
-    pageName: { type: String, default: "" },
-    pageLogo: { type: String, default: "" },
-    accessToken: { type: String, default: "" },
-    type: { type: String, default: "" },
-    productIds: [{ productId: { type: String, default: "" } }],
-    isDeleted: { type: Boolean, default: false },
-    isNotified: { type: Boolean, default: false },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-const Story = mongoose.model("Story", StorySchema);
-
-const storiesByAggregation = async (pipeline) => {
-  try {
-    return await Story.aggregate(pipeline);
-  } catch (err) {
-    return [];
-  }
-};
-const findStory = async (obj) => {
-  try {
-    return await Story.find(obj);
-  } catch (err) {
-    return err;
-  }
-};
-const findSingleStory = async (obj) => {
-  try {
-    return await Story.findOne(obj);
-  } catch (err) {
-    return err;
-  }
-};
-const deleteSingleStory = async (obj) => {
-  try {
-    return await Story.deleteOne(obj);
-  } catch (err) {
-    return err;
-  }
-};
-const saveStory = async (obj) => {
-  try {
-    let story = new Story(obj);
-    return await story.save();
-  } catch (err) {
-    return err;
-  }
-};
-const saveScheduledStory = async (obj) => {
-  try {
-    return await Story.insertMany(obj);
-  } catch (err) {
-    return [];
-  }
-};
-const findPendingStories = async (obj) => {
-  try {
-    return await Story.find(obj).exec();
-  } catch (err) {
-    return [];
-  }
-};
-module.exports = {
-  storiesByAggregation,
-  findStory,
-  findSingleStory,
-  deleteSingleStory,
-  saveStory,
-  saveScheduledStory,
-  findPendingStories,
-  Story,
-};

package/models/Tag.js

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

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

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

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

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

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