shuttlepro-shared 1.3.41 → 1.3.43

package/models/Location.js

@@ -0,0 +1,148 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+const LocationSchema = new Schema(
+  {
+    isDefault: { type: Boolean, default: false },
+    address1: { type: String, default: "" },
+    address2: { type: String, default: "" },
+    city: { type: String, default: "" },
+    zip: { type: String, default: "" },
+    province: { type: String, default: "" },
+    country: { type: String, default: "" },
+    phone: { type: String, default: "" },
+    active: { type: Boolean, default: true },
+    oldId: { type: String, default: "" },
+    webLocationId: { type: Number, default: null },
+    bcLocationId: { type: String, default: "" },
+    workspaceId: {
+      type: Schema.Types.ObjectId,
+      ref: "Workspace",
+      default: null,
+    },
+    legacy: { type: Boolean, default: false },
+    name: { type: String, default: "" },
+    isDeleted: { type: Boolean, default: false },
+    bcLocationId: { type: String, default: "" },
+    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 } }
+);
+
+LocationSchema.virtual("variantLocations", {
+  ref: "VariantLocation",
+  localField: "_id",
+  foreignField: "locationId",
+});
+
+const Location = mongoose.model("Location", LocationSchema);
+
+const createNewLocation = async (locationData) => {
+  try {
+    return await Location.create(locationData);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findLocationById = async (locationId) => {
+  try {
+    return await Location.findById(locationId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const updateLocationById = async (criteria, updateData, options) => {
+  try {
+    return await Location.findByIdAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+const updateLocation = async (criteria, updateData, options) => {
+  try {
+    return await Location.findOneAndUpdate(criteria, updateData, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findAndUpdateLocation = async (criteria, data, options) => {
+  try {
+    return await Location.findOneAndUpdate(criteria, data, options);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+const deleteLocationById = async (locationId) => {
+  try {
+    return await Location.findByIdAndDelete(locationId);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findLocation = async (criteria) => {
+  try {
+    return await Location.findOne(criteria);
+  } catch (error) {
+    console.log(error);
+    return null;
+  }
+};
+
+const findLocations = async (criteria) => {
+  try {
+    return await Location.find(criteria);
+  } catch (error) {
+    console.log(error);
+    return [];
+  }
+};
+
+const locationsByAggregation = async (aggregate = []) => {
+  try {
+    let locations = await Location.aggregate(aggregate);
+    return locations;
+  } catch (err) {
+    return [];
+  }
+};
+
+const locationsUpdateMany = async (criteria, updateData, options = {}) => {
+  try {
+    return await Location.updateMany(criteria, updateData, options);
+  } catch (error) {
+    return null;
+  }
+};
+
+const insertLocations = async (locations) => {
+  try {
+    return await Location.insertMany(locations);
+  } catch (err) {
+    return [];
+  }
+};
+
+module.exports = {
+  Location,
+  createNewLocation,
+  findLocationById,
+  updateLocationById,
+  updateLocation,
+  deleteLocationById,
+  findLocation,
+  findLocations,
+  locationsByAggregation,
+  locationsUpdateMany,
+  insertLocations,
+  findAndUpdateLocation,
+};

package/models/Logo.js

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

package/models/MailGroup.js

@@ -0,0 +1,21 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const MailGroupSchema = new Schema(
+  {
+    name: { type: String, default: "" },
+    emailIds: [
+      {
+        emailId: {
+          type: Schema.Types.ObjectId,
+          ref: "Email",
+        },
+      },
+    ],
+    workspaceId: { type: String, default: "" },
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const MailGroup = mongoose.model("MailGroup", MailGroupSchema);
+module.exports = MailGroup;

package/models/Notification.js

@@ -0,0 +1,32 @@
+const mongoose = require("mongoose");
+const { Schema } = mongoose;
+
+const NotificationSchema = new Schema(
+  {
+    type: { type: String, default: "" },
+    isRead: { type: Boolean, default: false },
+    operation: { type: String, default: "" },
+    actionId: { type: String, default: "" },
+    workspaceId: { type: String, default: "" },
+    workspaceName: { type: String, default: "" },
+    message: { type: String, default: "" },
+    email: { type: String, default: "" },
+    userId: { type: String, default: "" },
+    data: { type: mongoose.Schema.Types.Mixed },
+    isDeleted: { type: Boolean, default: false },
+    alertShow: { type: Boolean, default: false },
+    routes: {
+      routeType: { type: String, default: "" },
+      id: { type: String, default: "" },
+      query: { type: Boolean, default: false },
+      queryData: { type: String, default: "" },
+    },
+    permissions: [],
+    role: [String],
+  },
+  { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
+);
+
+const Notification = mongoose.model("Notification", NotificationSchema);
+
+module.exports = Notification;

package/models/Order.js

@@ -136,6 +136,14 @@ const OrderSchema = new Schema(
       paymentDate: { type: String, default: "" },
       paymentDetails: {},
     },
+    merged: {
+      status: { type: String, default: "open" },
+      webOrderNumbers: [],
+      orderNumbers: [],
+      localOrderIds: [],
+      webOrderIds: [],
+      details: [],
+    },
     credentials: {},
     ticketId: { type: String, default: "" },
     sender: { type: String, default: "" },
@@ -159,6 +167,9 @@ const OrderSchema = new Schema(
     },
     orderName: { type: String, default: "" },
     totalWeight: { type: String, default: "" },
+    currency: {},
+    presentedCurrency: {},
+    exchangeRate: { type: Number, default: 0 },
   },
   { timestamps: true, toJSON: { virtuals: true }, toObject: { virtuals: true } }
 );

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,337 @@
+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: [],
+    bcProductId: { type: String, default: "" },
+  },
+  { 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,
+};