shuttlepro-shared 1.3.30 → 1.3.31

package/models/OrderPdf.js

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

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

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

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