shuttlepro-shared 1.3.30 → 1.3.31

package/models/ProductAttribute.js

@@ -0,0 +1,140 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const ProductAttributeSchema = new mongoose.Schema(
+  {
+    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
+    attributeId: {
+      type: Schema.Types.ObjectId,
+      ref: "Attribute",
+      default: null,
+    },
+    oldId: { type: String, default: "" },
+    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    isDeleted: { type: Boolean, default: false },
+    position: { type: String, default: "1" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+ProductAttributeSchema.virtual("attributes", {
+  ref: "Attribute",
+  localField: "attributeId",
+  foreignField: "_id",
+});
+
+const ProductAttribute = mongoose.model(
+  "ProductAttribute",
+  ProductAttributeSchema
+);
+
+const createNewProductAttribute = async (productAttributeData) => {
+  try {
+    return await ProductAttribute.create(productAttributeData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findProductAttributeById = async (productAttributeId) => {
+  try {
+    return await ProductAttribute.findById(productAttributeId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const updateProductAttributeById = async (
+  criteria,
+  updateData,
+  options = {}
+) => {
+  try {
+    return await ProductAttribute.findByIdAndUpdate(
+      criteria,
+      updateData,
+      options
+    );
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const deleteProductAttributeById = async (productAttributeId) => {
+  try {
+    return await ProductAttribute.findByIdAndDelete(productAttributeId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findProductAttribute = async (criteria) => {
+  try {
+    return await ProductAttribute.findOne(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findProductAttributes = async (criteria) => {
+  try {
+    return await ProductAttribute.find(criteria);
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+const productAttributesByAggregation = async (pipeline) => {
+  try {
+    return await ProductAttribute.aggregate(pipeline);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findProductAttributesByPopulate = async (criteria, populate) => {
+  try {
+    return await ProductAttribute.find(criteria).populate(populate);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const productAttributesUpdateMany = async (
+  criteria,
+  updateData,
+  options = {}
+) => {
+  try {
+    return await ProductAttribute.updateMany(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+module.exports = {
+  ProductAttribute,
+  createNewProductAttribute,
+  findProductAttributeById,
+  updateProductAttributeById,
+  deleteProductAttributeById,
+  findProductAttribute,
+  findProductAttributes,
+  productAttributesByAggregation,
+  productAttributesUpdateMany,
+  findProductAttributesByPopulate,
+};

package/models/ProductCategory.js

@@ -0,0 +1,128 @@
+const mongoose = require("mongoose");
+const { Schema, model } = mongoose;
+const ProductCategorySchema = new Schema(
+  {
+    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
+    categoryId: { type: Schema.Types.ObjectId, ref: "Category", default: null },
+    webProductCategoryId: { type: Number, default: null },
+    oldId: { 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 },
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+ProductCategorySchema.virtual("categoriesProducts", {
+  ref: "Product",
+  localField: "productId",
+  foreignField: "_id",
+});
+const ProductCategory = mongoose.model(
+  "ProductCategory",
+  ProductCategorySchema
+);
+
+const softDeleteProductCategories = async (
+  workspaceId,
+  convertingIds,
+  type
+) => {
+  const filter = {
+    workspaceId: workspaceId,
+    isDeleted: false,
+  };
+  filter[type] = { $in: convertingIds };
+  const update = { $set: { isDeleted: true } };
+  const result = await ProductCategory.updateMany(filter, update);
+  if (result.matchedCount === 0) {
+    return true;
+  }
+  if (result.modifiedCount === 0 && result.matchedCount > 0) {
+    return false;
+  }
+  return true;
+};
+
+const insertProductCategories = async (obj) => {
+  try {
+    return await ProductCategory.insertMany(obj);
+  } catch (err) {
+    return [];
+  }
+};
+
+const findProductCategory = async (criteria = {}) => {
+  try {
+    return await ProductCategory.findOne(criteria);
+  } catch (error) {
+    return null;
+  }
+};
+
+const findProductCategories = async (criteria = {}) => {
+  try {
+    return await ProductCategory.find(criteria);
+  } catch (error) {
+    return [];
+  }
+};
+
+const createProductCategory = async (obj) => {
+  try {
+    const productCategory = new ProductCategory(obj);
+    let newCategory = await productCategory.save();
+    return newCategory;
+  } catch (err) {
+    return null;
+  }
+};
+
+const findProductCategoriesWithPopulate = async (
+  criteria = {},
+  populate = ""
+) => {
+  try {
+    return await ProductCategory.find(criteria).populate(populate);
+  } catch (error) {
+    console.log("error", error);
+    return [];
+  }
+};
+
+const bulkWriteProductCategories = async (operations = []) => {
+  try {
+    return await ProductCategory.bulkWrite(operations);
+  } catch (error) {
+    return [];
+  }
+};
+
+const updateManyProductCategories = async (
+  criteria,
+  updatedData,
+  options = {}
+) => {
+  try {
+    return await ProductCategory.updateMany(criteria, updatedData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+module.exports = {
+  ProductCategory,
+  findProductCategory,
+  findProductCategories,
+  createProductCategory,
+  insertProductCategories,
+  softDeleteProductCategories,
+  findProductCategoriesWithPopulate,
+  bulkWriteProductCategories,
+  updateManyProductCategories,
+};

package/models/ProductLabels.js

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

package/models/ProductShopify.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const ProductShopifySchema = new Schema(
+  {
+    type: { type: String, default: "" },
+    body: {},
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const ProductShopify = mongoose.model("ProductShopify", ProductShopifySchema);
+module.exports = ProductShopify;

package/models/ProductTag.js

@@ -0,0 +1,124 @@
+const mongoose = require("mongoose");
+const { Schema, model } = mongoose;
+const ProductTagSchema = new Schema(
+  {
+    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
+    tagId: { type: Schema.Types.ObjectId, ref: "Tag", default: null },
+    webProductTagId: { type: String, default: " " },
+    oldId: { 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 },
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const ProductTag = mongoose.model("ProductTag", ProductTagSchema);
+
+const productTagsByAggregation = async (aggregate) => {
+  try {
+    let tags = await ProductTag.aggregate(aggregate);
+    return tags;
+  } catch (err) {
+    return [];
+  }
+};
+
+const findSingleProductTag = async (obj) => {
+  try {
+    let tag = await ProductTag.findOne(obj);
+    return tag;
+  } catch (err) {
+    return null;
+  }
+};
+
+const insertProductTags = async (obj) => {
+  try {
+    return await ProductTag.insertMany(obj);
+  } catch (err) {
+    console.log("null", err);
+    return [];
+  }
+};
+
+const createProductTag = async (obj) => {
+  try {
+    const tag = new ProductTag(obj);
+    let newTag = await tag.save();
+    return newTag;
+  } catch (err) {
+    console.log("null", err);
+    return null;
+  }
+};
+
+const softDeleteProductTags = async (workspaceId, convertingIds, type) => {
+  const filter = {
+    workspaceId: workspaceId,
+    isDeleted: false,
+  };
+  filter[type] = { $in: convertingIds };
+  const update = { $set: { isDeleted: true } };
+  const result = await ProductTag.updateMany(filter, update);
+  if (result.matchedCount === 0) {
+    return true;
+  }
+  if (result.modifiedCount === 0 && result.matchedCount > 0) {
+    return false;
+  }
+  return true;
+};
+
+const findProductTag = async (obj) => {
+  try {
+    let tag = await ProductTag.findOne(obj);
+    return tag;
+  } catch (err) {
+    return null;
+  }
+};
+
+const findProductTags = async (obj) => {
+  try {
+    let tag = await ProductTag.find(obj);
+    return tag;
+  } catch (err) {
+    return [];
+  }
+};
+
+const findProductTagsByPopulate = async (obj, populate) => {
+  try {
+    let tag = await ProductTag.find(obj).populate(populate);
+    return tag;
+  } catch (err) {
+    return [];
+  }
+};
+
+const updateManyProductTags = async (criteria, updatedData, options = {}) => {
+  try {
+    return await ProductTag.updateMany(criteria, updatedData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+module.exports = {
+  ProductTag,
+  productTagsByAggregation,
+  findSingleProductTag,
+  insertProductTags,
+  createProductTag,
+  softDeleteProductTags,
+  findProductTag,
+  findProductTags,
+  findProductTagsByPopulate,
+  updateManyProductTags,
+};

package/models/ProductVariant.js

@@ -0,0 +1,156 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const ProductVariantSchema = new Schema(
+  {
+    price: { type: Number, default: 0 },
+    costPrice: { type: Number, default: 0 },
+    name: { type: String, default: "" },
+    sku: { type: String, default: "" },
+    subSku: { type: String, default: "" },
+    salePrice: { type: Number, default: 0 },
+    quantity: { type: Number, default: null },
+    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
+    oldId: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    webVariantId: { type: Number, default: null },
+    inventoryPolicy: { type: String, default: "deny" }, //deny,continue
+    taxable: { type: Boolean, default: false },
+    tax: { type: Number, default: 0 },
+    weight: { type: Number, default: 0 },
+    weightUnit: { type: String, default: "" },
+    attachmentId: {
+      type: Schema.Types.ObjectId,
+      ref: "ProductAttachment",
+      default: null,
+    },
+    webAttachmentId: { type: Number, default: null },
+    inventoryManagement: { type: String, default: "shopify" }, //shopify, null, fulfillment_service
+    webInventoryItemId: { type: Number, default: null },
+    manufactureDate: { type: String, default: "" },
+    expiryDate: { type: String, default: "" },
+    attributes: [],
+    attributeIds: [
+      // {
+      //   type: Schema.Types.ObjectId,
+      //   ref: "Attribute",
+      //   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 },
+    isDeleted: { type: Boolean, default: false },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+ProductVariantSchema.virtual("variantLocations", {
+  ref: "VariantLocation",
+  localField: "_id",
+  foreignField: "variantId",
+});
+
+ProductVariantSchema.virtual("productAttachments", {
+  ref: "ProductAttachment",
+  localField: "_id",
+  foreignField: "variantIds",
+});
+
+const ProductVariant = mongoose.model("ProductVariant", ProductVariantSchema);
+
+const createNewProductVariant = async (variantData) => {
+  try {
+    return await ProductVariant.create(variantData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const insertProductVariants = async (data) => {
+  try {
+    return await ProductVariant.create(data);
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+const findProductVariants = async (criteria) => {
+  try {
+    const variants = await ProductVariant.find(criteria);
+    return variants;
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+const findSingleProductVariant = async (obj) => {
+  try {
+    let variant = await ProductVariant.findOne(obj);
+    return variant;
+  } catch (err) {
+    return null;
+  }
+};
+
+const updateManyProductVariants = async (
+  criteria,
+  updateData,
+  options = {}
+) => {
+  try {
+    return await ProductVariant.updateMany(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findOneAndUpdateProductVariant = async (query, data) => {
+  try {
+    return await ProductVariant.findOneAndUpdate(
+      query,
+      { $set: data },
+      { new: true }
+    );
+  } catch (error) {
+    console.log("eerr", error);
+    return null;
+  }
+};
+
+const aggregateProductVariants = async (pipeline) => {
+  try {
+    return await ProductVariant.aggregate(pipeline);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findSingleProductVariantWithPopulate = async (obj, populateObj) => {
+  try {
+    return await ProductVariant.findOne(obj).populate(populateObj);
+  } catch (err) {
+    return null;
+  }
+};
+
+module.exports = {
+  insertProductVariants,
+  createNewProductVariant,
+  updateManyProductVariants,
+  findOneAndUpdateProductVariant,
+  aggregateProductVariants,
+  findProductVariants,
+  findSingleProductVariant,
+  findSingleProductVariantWithPopulate,
+  ProductVariant,
+};

package/models/ServiceUsage.js

@@ -0,0 +1,26 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const ServiceUsageSchema = new Schema(
+  {
+    type: {
+      type: String,
+      enum: ["nlp", "google"],
+      required: true,
+    },
+    data: {},
+    labelId: {
+      type: Schema.Types.ObjectId,
+      ref: "Label",
+      required: false,
+    },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+    },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const ServiceUsage = mongoose.model("ServiceUsage", ServiceUsageSchema);
+module.exports = ServiceUsage;

package/models/ShipperSetting.js

@@ -0,0 +1,24 @@
+const mongoose = require("mongoose");
+
+const shipperSettingSchema = new mongoose.Schema(
+  {
+    publish: { type: Boolean, default: false },
+    defaultShipper: { type: String, default: "" },
+    codAmount: { type: Number, default: 0 },
+    workspaceId: { type: String, default: "" },
+    publishTime: [],
+    days: [],
+    minAmount: { type: Number, default: 0 },
+    tabs: [],
+    location: {
+      shippers: [],
+      citiesShippers: [],
+    },
+    weight: [],
+    prepaidOrder: [],
+    amount: [],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+module.exports = mongoose.model("ShipperSetting", shipperSettingSchema);