shuttlepro-shared 1.3.39 → 1.3.41

package/models/OrderPdf.js

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

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

package/models/Product.js

@@ -1,336 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-const axios = require("axios");
-const NewProduct = require("./NewProduct"); // Make sure to import NewProduct model
-
-const categorySchema = new Schema({
-  _id: false,
-  categoryId: { type: String, default: "" },
-  name: { type: String, default: "" },
-});
-
-const ProductSchema = new Schema(
-  {
-    name: { type: String, default: "" },
-    description: { type: String, default: "" },
-    sku: { type: String, default: "" },
-    price: { type: String, default: 0 },
-    quantity: { type: Number, default: 0 },
-    imageUrl: { type: String, default: "" },
-    costPrice: { type: String, default: 0 },
-    salePrice: { type: String, default: 0 },
-    preference: { type: Number, default: 10 },
-    oldId: { type: String, default: "" },
-    webProductId: { type: Number, default: null },
-    publishedAt: { type: String, default: "" },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-    storeType: { type: String, default: "LOCAL" },
-    isDeleted: { type: Boolean, default: false },
-    inventoryPolicy: { type: String, default: "deny" }, //deny,continue
-    inventoryManagement: { type: String, default: "shopify" }, //shopify, null, fulfillment_service
-    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    storeUrl: { type: String, default: "" },
-    status: { type: String, default: "active" }, //active, archived, draft
-    categories: [],
-    variantCount: { type: Number, default: 0 },
-    productType: { type: String, default: "" },
-    vendor: { type: String, default: "" },
-    handle: { type: String, default: "" },
-    isWebhookCase: { type: Boolean, default: false },
-    updating: { type: Boolean, default: false },
-    attributes: [],
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-ProductSchema.virtual("productCategories", {
-  ref: "ProductCategory",
-  localField: "_id",
-  foreignField: "productId",
-});
-ProductSchema.virtual("productTags", {
-  ref: "ProductTag",
-  localField: "_id",
-  foreignField: "productId",
-});
-ProductSchema.virtual("productAttributes", {
-  ref: "ProductAttribute",
-  localField: "_id",
-  foreignField: "productId",
-});
-ProductSchema.virtual("productAttachments", {
-  ref: "ProductAttachment",
-  localField: "_id",
-  foreignField: "productId",
-});
-ProductSchema.virtual("productVariants", {
-  ref: "ProductVariant",
-  localField: "_id",
-  foreignField: "productId",
-});
-ProductSchema.virtual("variantLocations", {
-  ref: "VariantLocation",
-  localField: "_id",
-  foreignField: "productId",
-});
-
-const transformProductData = async (product) => {
-  if (!product) return null;
-
-  const populatedProduct = await mongoose.models.Product.findById(product._id)
-    .populate({
-      path: "productVariants",
-      match: { isDeleted: false },
-    })
-    .populate({
-      path: "productAttachments",
-      match: { isDeleted: false },
-      populate: {
-        path: "variantIds",
-        model: "ProductVariant",
-        match: { isDeleted: false },
-      },
-    })
-    .lean()
-    .exec();
-
-  if (!populatedProduct) return null;
-
-  return {
-    name: populatedProduct.name || "",
-    id: populatedProduct._id || "",
-    description: populatedProduct.description || "",
-    sku: populatedProduct.sku || "",
-    price: populatedProduct.price || "",
-    quantity: populatedProduct.quantity || 0,
-    imageUrl: populatedProduct.imageUrl || "",
-    costPrice: populatedProduct.costPrice || 0,
-    salePrice: populatedProduct.salePrice || 0,
-    webProductId: populatedProduct.webProductId || "",
-    variants:
-      populatedProduct.productVariants?.map((p) => ({
-        id: p?._id,
-        name: p?.name || "",
-        sku: p?.sku || "",
-        subSku: p?.subSku || "",
-        productId: p?.productId || "",
-        price: p?.price || "",
-        costPrice: p?.costPrice || 0,
-        salePrice: p?.salePrice || 0,
-        quantity: p?.quantity || 0,
-      })) || [],
-    attachments:
-      populatedProduct.productAttachments?.map((x) => ({
-        id: x?._id,
-        thumbUrl: x?.thumbUrl,
-        remoteUrl: x?.remoteUrl,
-        url: x?.url,
-        type: x?.type,
-        variants:
-          x?.variantIds?.length > 0
-            ? x.variantIds.map((p) => ({
-                id: p?._id,
-                name: p?.name || "",
-                sku: p?.sku || "",
-                subSku: p?.subSku || "",
-                productId: p?.productId || "",
-                price: p?.price || "",
-                costPrice: p?.costPrice || 0,
-                salePrice: p?.salePrice || 0,
-                quantity: p?.quantity || 0,
-              }))
-            : [],
-      })) || [],
-    workspaceId: populatedProduct.workspaceId,
-  };
-};
-
-// Middleware for various operations
-const updateNewProduct = async (doc, next) => {
-  try {
-    // Skip if document is marked as deleted
-    if (doc.isDeleted) return;
-
-    // Transform and upsert product data
-    const newProductData = await transformProductData(doc);
-    if (newProductData) {
-      await NewProduct.findOneAndUpdate(
-        { id: newProductData.id },
-        newProductData,
-        { upsert: true, new: true }
-      );
-    }
-  } catch (error) {
-    console.error("Error updating NewProduct:", error);
-    // Call next with error if needed
-    next(error);
-  }
-};
-
-const deleteNewProduct = async (doc, next) => {
-  try {
-    if (doc) {
-      await NewProduct.deleteOne({ id: doc._id });
-    }
-  } catch (error) {
-    console.error("Error deleting from NewProduct:", error);
-    next(error);
-  }
-};
-
-// Post middleware for various Mongoose operations
-ProductSchema.post("save", async function (doc, next) {
-  console.log(doc, "doc");
-  await updateNewProduct(doc, next);
-});
-
-ProductSchema.post("findOneAndUpdate", async function (doc, next) {
-  await updateNewProduct(doc, next);
-});
-
-ProductSchema.post("updateOne", async function (doc, next) {
-  console.log(doc, "doc called");
-  await updateNewProduct(doc, next);
-});
-
-ProductSchema.post("create", async function (doc, next) {
-  await updateNewProduct(doc, next);
-});
-
-ProductSchema.post("findOneAndDelete", async function (doc, next) {
-  await deleteNewProduct(doc, next);
-});
-
-ProductSchema.post("deleteOne", async function (doc, next) {
-  await deleteNewProduct(doc, next);
-});
-
-const Product = mongoose.model("Product", ProductSchema);
-
-const newProductInstance = async (productData) => {
-  try {
-    return new Product(productData);
-  } catch (error) {
-    return null;
-  }
-};
-
-const createNewProduct = async (productData) => {
-  try {
-    return await Product.create(productData);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const findProductById = async (productId) => {
-  try {
-    return await Product.findById(productId);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const updateProductById = async (criteria, updateData, options) => {
-  try {
-    return await Product.findByIdAndUpdate(criteria, updateData, options);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const updateProducts = async (criteria, updateData, options = {}) => {
-  try {
-    return await Product.updateMany(criteria, updateData, options);
-  } catch (error) {
-    console.log(error);
-    return [];
-  }
-};
-
-const deleteProductById = async (productId) => {
-  try {
-    return await Product.findByIdAndDelete(productId);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const findProduct = async (criteria) => {
-  try {
-    return await Product.findOne(criteria);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const findProducts = async (criteria) => {
-  try {
-    return await Product.find(criteria);
-  } catch (error) {
-    console.log(error);
-    return [];
-  }
-};
-
-const findSingleProduct = async (obj) => {
-  try {
-    let product = await Product.findOne(obj);
-    return product;
-  } catch (err) {
-    return null;
-  }
-};
-
-const countProductDocument = async (obj) => {
-  try {
-    let product = await Product.countDocuments(obj);
-    return product;
-  } catch (err) {
-    return 0;
-  }
-};
-
-const findProductWithPopulateAndPagination = async (
-  condition,
-  pop,
-  page,
-  limit
-) => {
-  try {
-    const products = await Product.find(condition)
-      .sort({ _id: -1 })
-      .skip((page - 1) * parseInt(limit))
-      .limit(parseInt(limit))
-      .populate(pop);
-    return products;
-  } catch (err) {
-    return 0;
-  }
-};
-
-module.exports = {
-  newProductInstance,
-  createNewProduct,
-  findProductById,
-  updateProductById,
-  updateProducts,
-  deleteProductById,
-  findProduct,
-  findProducts,
-  findSingleProduct,
-  countProductDocument,
-  findProductWithPopulateAndPagination,
-  Product,
-  ProductModel: Product,
-};

package/models/ProductAttachment.js

@@ -1,158 +0,0 @@
-const mongoose = require("mongoose");
-const { Schema } = mongoose;
-const ProductAttachmentSchema = new Schema(
-  {
-    type: { type: String, default: "default" },
-    designJobId: {
-      type: Schema.Types.ObjectId,
-      ref: "JobDesign",
-      default: null,
-    },
-    oldId: { type: String, default: "" },
-    templateId: { type: Schema.Types.ObjectId, ref: "Template", default: null },
-    remoteUrl: { type: String, default: "" },
-    webImageId: { type: Number, default: null },
-    default: { type: Boolean, default: false },
-    productId: { type: Schema.Types.ObjectId, ref: "Product", default: null },
-    url: { type: String, default: "" },
-    thumbUrl: { type: String, default: "" },
-    width: { type: Number, default: 0 },
-    workspaceId: {
-      type: Schema.Types.ObjectId,
-      ref: "Workspace",
-      default: null,
-    },
-    height: { type: Number, default: 0 },
-    variantIds: [
-      { type: Schema.Types.ObjectId, ref: "ProductVariant", default: null },
-    ],
-    createdBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    position: { type: Number, default: 1 },
-    updatedBy: { type: Schema.Types.ObjectId, ref: "User", default: null },
-    isDeleted: { type: Boolean, default: false },
-  },
-  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
-);
-
-ProductAttachmentSchema.virtual("products", {
-  ref: "Product",
-  localField: "productId",
-  foreignField: "_id",
-});
-
-const ProductAttachment = mongoose.model(
-  "ProductAttachment",
-  ProductAttachmentSchema
-);
-
-const createNewProductAttachment = async (productAttachmentData) => {
-  try {
-    return await ProductAttachment.create(productAttachmentData);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const insertProductAttachments = async (data) => {
-  try {
-    return await ProductAttachment.create(data);
-  } catch (error) {
-    console.log(error);
-    return [];
-  }
-};
-
-const findProductAttachmentById = async (productAttachmentId) => {
-  try {
-    return await ProductAttachment.findById(productAttachmentId);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const updateProductAttachmentById = async (
-  criteria,
-  updateData,
-  options = {}
-) => {
-  try {
-    return await ProductAttachment.findByIdAndUpdate(
-      criteria,
-      updateData,
-      options
-    );
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const deleteProductAttachmentById = async (productAttachmentId) => {
-  try {
-    return await ProductAttachment.findByIdAndDelete(productAttachmentId);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const findProductAttachment = async (criteria) => {
-  try {
-    return await ProductAttachment.findOne(criteria);
-  } catch (error) {
-    console.log(error);
-    return null;
-  }
-};
-
-const findProductAttachments = async (criteria) => {
-  try {
-    return await ProductAttachment.find(criteria);
-  } catch (error) {
-    console.log(error);
-    return [];
-  }
-};
-
-const updateManyProductAttachments = async (
-  criteria,
-  updatedData,
-  options = {}
-) => {
-  try {
-    return await ProductAttachment.updateMany(criteria, updatedData, options);
-  } catch (error) {
-    return [];
-  }
-};
-
-const findAndUpdateProductAttachment = async (
-  criteria,
-  updatedData,
-  options
-) => {
-  try {
-    return await ProductAttachment.findOneAndUpdate(
-      criteria,
-      updatedData,
-      options
-    );
-  } catch (error) {
-    return [];
-  }
-};
-
-module.exports = {
-  createNewProductAttachment,
-  insertProductAttachments,
-  updateManyProductAttachments,
-  findProductAttachmentById,
-  updateProductAttachmentById,
-  deleteProductAttachmentById,
-  findProductAttachment,
-  findProductAttachments,
-  ProductAttachment,
-  findAndUpdateProductAttachment,
-};