@ozdao/prometheus-framework 0.2.309 → 0.2.311

package/dist/products.server.js

@@ -9,7 +9,13 @@ const queryProcessor = require("./queryProcessor-B3NJuQbL.js");
 const applyOwnershipSchema$1 = ownership_schema.ownership_schema;
 var product_model = (db) => {
   const ProductSchema = new db.mongoose.Schema({
-    status: { type: String },
+    status: {
+      type: String
+    },
+    listing: {
+      type: String,
+      enum: ["sale", "rent"]
+    },
     name: { type: String },
     category: { type: Array },
     description: { type: String },
@@ -24,7 +30,13 @@ var product_model = (db) => {
       value: { type: String }
     }],
     // ЗАДАЧА: Нужно отрефачить price, перенести его в default variant
-    price: { type: Number },
+    price: {
+      type: Number
+    },
+    price_currency: {
+      type: String,
+      default: "$"
+    },
     prices: { type: Array },
     // 
     variants: [{
@@ -71,16 +83,7 @@ var product_model = (db) => {
         min: [0, "Quantity-based discount cannot be less than 0"],
         max: [100, "Quantity-based discount cannot be more than 100"]
       }
-    }],
-    // Refactor
-    owner: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "User"
-    },
-    organization: {
-      type: db.mongoose.Schema.Types.ObjectId,
-      ref: "Organization"
-    }
+    }]
   }, {
     timestamps: {
       currentTime: () => Date.now()
@@ -93,76 +96,26 @@ var product_model = (db) => {
   return Product;
 };
 var category_model = (db) => {
-  const СategorySchema = new db.mongoose.Schema({
-    name: {
-      type: String,
-      required: true,
-      trim: true
-    },
+  const CategorySchema = new db.mongoose.Schema({
+    name: { type: String, required: true, trim: true },
     status: {
       type: String,
       enum: ["draft", "internal", "published", "removed"],
       default: "draft",
       required: true
     },
-    order: {
-      type: Number,
-      required: true
-    },
-    url: {
-      type: String,
-      required: true,
-      trim: true
-    },
-    subcategories: {
-      type: Array
-    },
-    localization: {
-      type: Array
-    },
-    filters: {
-      type: Array
-    }
-    // owner: {
-    //   type: {
-    //     type: String,
-    //     required: true
-    //   },
-    //   target: {
-    //     type: mongoose.Schema.Types.ObjectId,
-    //     ref: function (value) {
-    //       if (this.owner.type === 'user') return 'User';
-    //       if (this.owner.type === 'organization') return 'Organization';
-    //     },
-    //     required: true,
-    //   },
-    // },
-    // creator: {
-    //   hidden: {
-    //     type: Boolean,
-    //     required: true
-    //   },
-    //   type: {
-    //     type: String,
-    //     required: true
-    //   },
-    //   target: {
-    //     type: mongoose.Schema.Types.ObjectId,
-    //     ref: function (value) {
-    //       if (this.owner.type === 'user') return 'User';
-    //       if (this.owner.type === 'organization') return 'Organization';
-    //     },
-    //     required: true,
-    //   },
-    // }
+    order: { type: Number, required: true },
+    url: { type: String, required: true, trim: true },
+    parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
+    localization: { type: Array },
+    filters: { type: Array }
   }, {
-    timestamps: {
-      currentTime: () => Date.now()
-    }
+    timestamps: { currentTime: () => Date.now() }
   });
-  СategorySchema.index({ "owner.target": 1, "creator.target": 1 });
-  const Сategory = db.mongoose.model("Сategory", СategorySchema, "categories");
-  return Сategory;
+  CategorySchema.index({ parent: 1 });
+  CategorySchema.index({ "owner.target": 1, "creator.target": 1 });
+  const Category = db.mongoose.model("Category", CategorySchema, "categories");
+  return Category;
 };
 const applyOwnershipSchema = ownership_schema.ownership_schema;
 var leftover_model = (db) => {
@@ -237,8 +190,8 @@ const controllerFactory$5 = (db) => {
   const Read = async (req, res) => {
     try {
       const query = {};
-      if (req.query.organization) {
-        query.organization = new ObjectId(req.query.organization);
+      if (req.query.owner) {
+        query["owner.target"] = new ObjectId(req.query.owner);
       }
       if (req.query._id) {
         query._id = new ObjectId(req.query._id);
@@ -411,8 +364,10 @@ const controllerFactory$5 = (db) => {
         {
           name: req.body.name,
           status: req.body.status,
+          listing: req.body.listing,
           description: req.body.description,
           price: req.body.price,
+          price_currency: req.body.price_currency,
           sale: req.body.sale,
           category: req.body.category,
           images: req.body.images,
@@ -551,104 +506,167 @@ var products_routes = function(app, db, allowedOrigins) {
     controller.getProductRecommendation
   );
 };
+var categories_routes = { exports: {} };
 const controllerFactory$3 = (db) => {
   const Category = db.category;
-  const getCategories = async (req, res) => {
-    console.log(Category);
-    try {
-      let query = {};
-      let options = {};
-      if (req.query.status) {
-        query.status = req.query.status;
-      }
-      const categories = await Category.find(query, null, options).sort({ "order": "asc" }).exec();
-      if (!categories) {
-        return res.status(404).send({ message: "Categories not found." });
+  return {
+    async read(req, res) {
+      try {
+        let buildTree = function(items) {
+          const itemMap = {};
+          const roots = [];
+          items.forEach((item) => {
+            itemMap[item._id.toString()] = {
+              ...item,
+              children: []
+            };
+          });
+          items.forEach((item) => {
+            const itemId = item._id.toString();
+            const parentId = item.parent?._id?.toString();
+            if (parentId && itemMap[parentId]) {
+              itemMap[parentId].children.push(itemMap[itemId]);
+            } else {
+              roots.push(itemMap[itemId]);
+            }
+          });
+          const sortByOrder = (a, b) => {
+            const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+            const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+            return orderA - orderB;
+          };
+          const sortChildren = (node) => {
+            if (node.children && node.children.length > 0) {
+              node.children.sort(sortByOrder);
+              node.children.forEach(sortChildren);
+            }
+          };
+          roots.sort(sortByOrder);
+          roots.forEach(sortChildren);
+          return roots;
+        };
+        const {
+          parent,
+          url,
+          search,
+          sort = "order",
+          order = 1,
+          page = 1,
+          limit = 10,
+          excludeChildren = false,
+          rootOnly = false
+        } = req.query;
+        const matchStage = {
+          ...req.query.status && { status: req.query.status },
+          ...req.query.url && { url: req.query.url },
+          ...search && { name: { $regex: search, $options: "i" } },
+          ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
+          ...rootOnly ? { parent: null } : {}
+        };
+        const pipeline = [
+          { $match: matchStage },
+          {
+            $graphLookup: {
+              from: "categories",
+              startWith: "$_id",
+              connectFromField: "_id",
+              connectToField: "parent",
+              as: "allDescendants",
+              maxDepth: 10
+            }
+          },
+          { $sort: { [sort]: order === "asc" ? 1 : -1 } },
+          { $skip: (page - 1) * limit },
+          { $limit: Number(limit) }
+        ];
+        const flatResults = await Category.aggregate(pipeline);
+        const treeResults = flatResults.map((doc) => {
+          const descendants = doc.allDescendants || [];
+          const allItems = [doc, ...descendants];
+          const tree = buildTree(allItems);
+          return tree.find((node) => node._id.toString() === doc._id.toString());
+        });
+        treeResults.sort((a, b) => {
+          const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
+          const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
+          return orderA - orderB;
+        });
+        res.json(treeResults);
+      } catch (err) {
+        res.status(500).json({ message: err.message });
       }
-      res.status(200).send(categories);
-    } catch (err) {
-      console.log(err);
-      res.status(500).send({ message: err });
-    }
-  };
-  const updateCategories = async (req, res) => {
-    console.log(req.body);
-    try {
-      const bulkOps = req.body.map((categoryUpdated) => ({
-        updateOne: {
-          filter: { url: categoryUpdated.url },
-          update: { $set: categoryUpdated },
-          upsert: false
+    },
+    async create(req, res) {
+      try {
+        const highestOrder = await Category.findOne().sort("-order");
+        const order = highestOrder ? highestOrder.order + 1 : 1;
+        const category = new Category({ ...req.body, order });
+        if (req.body.parent) {
+          const parent = await Category.findByIdAndUpdate(
+            req.body.parent,
+            { $push: { children: category._id } },
+            { new: true }
+          );
+          if (!parent) throw new Error("Parent category not found");
+          category.parent = parent._id;
         }
-      }));
-      const result = await Category.bulkWrite(bulkOps, { ordered: false });
-      console.log("Success", result);
-      res.status(200).send({ message: "Categories updated successfully." });
-    } catch (err) {
-      console.error("Error processing bulk update", err);
-      res.status(500).send({ message: err.message });
-    }
-  };
-  const getCategory = async (req, res) => {
-    try {
-      const category = await Category.findOne({ url: req.params.url }).exec();
-      if (!category) {
-        return res.status(404).send({ message: "Category not found." });
-      }
-      res.status(200).send(category);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
-  };
-  const addCategory = async (req, res) => {
-    try {
-      const highestOrderDoc = await Category.findOne().sort("-order");
-      req.body.order = highestOrderDoc ? highestOrderDoc.order + 1 : 1;
-      const category = await Category.create(req.body);
-      if (!category) {
-        return res.status(404).send({ message: "Category is not created." });
+        if (req.body.children && req.body.children.length > 0) {
+          await Category.updateMany(
+            { _id: { $in: req.body.children } },
+            { $set: { parent: category._id } }
+          );
+        }
+        await category.save();
+        res.status(201).json(category);
+      } catch (err) {
+        res.status(err.message === "Parent category not found" ? 404 : 500).json({ message: err.message });
       }
-      res.status(200).send(category);
-    } catch (err) {
-      console.log(req.body);
-      console.log(req.category);
-      res.status(500).send({ message: err });
-    }
-  };
-  const updateCategory = async (req, res) => {
-    try {
-      const category = await Category.findOneAndUpdate(
-        { url: req.params.url },
-        { $set: req.body },
-        { new: true }
-      ).exec();
-      if (!category) {
-        return res.status(404).send({ message: "Something wrong when updating category." });
+    },
+    async update(req, res) {
+      try {
+        const { categories } = req.body;
+        const bulkOps = categories.map((category) => ({
+          updateOne: {
+            filter: { _id: category._id },
+            update: {
+              $set: {
+                order: category.order,
+                parent: category.parent ? new db.mongoose.Types.ObjectId(category.parent) : null
+              }
+            }
+          }
+        }));
+        await Category.bulkWrite(bulkOps);
+        const updatedCategories = await Category.find().sort({ order: "asc" }).lean();
+        res.status(200).json(updatedCategories);
+      } catch (err) {
+        console.error("Category update error:", err);
+        res.status(500).json({ message: "Failed to update categories" });
       }
-      res.status(200).send(category);
-    } catch (err) {
-      res.status(500).send({ message: err });
-    }
-  };
-  const deleteCategory = async (req, res) => {
-    try {
-      const category = await Category.findOneAndDelete({ url: req.params.url }).exec();
-      if (!category) {
-        return res.status(404).send({ message: "Category is not deleted." });
+    },
+    async delete(req, res) {
+      try {
+        const category = await Category.findOne({ url: req.body.url });
+        if (!category) throw new Error("Category not found");
+        const deleteSubcategories = async (categoryId) => {
+          const cat = await Category.findById(categoryId);
+          if (cat) {
+            for (const childId of cat.children) {
+              await deleteSubcategories(childId);
+            }
+            await Category.findByIdAndDelete(categoryId);
+          }
+        };
+        if (category.parent) {
+          await Category.findByIdAndUpdate(category.parent, { $pull: { children: category._id } });
+        }
+        await deleteSubcategories(category._id);
+        res.status(200).json({ message: "Category deleted successfully" });
+      } catch (err) {
+        res.status(err.message === "Category not found" ? 404 : 500).json({ message: err.message });
       }
-      res.status(200).send(category);
-    } catch (err) {
-      res.status(500).send({ message: err });
     }
   };
-  return {
-    getCategories,
-    updateCategories,
-    getCategory,
-    addCategory,
-    updateCategory,
-    deleteCategory
-  };
 };
 var categories_controller = controllerFactory$3;
 var verifyCategory;
@@ -686,37 +704,16 @@ const middlewareIndexFactory = (db) => {
 var middlewares = middlewareIndexFactory;
 const controllerFactory$2 = categories_controller;
 const middlewareFactoryProducts = middlewares;
-var categories_routes = function(app, db) {
+categories_routes.exports = function(app, db) {
   const controller = controllerFactory$2(db);
   const { verifyCategory: verifyCategory2 } = middlewareFactoryProducts(db);
-  app.get(
-    "/categories",
-    controller.getCategories
-  );
-  app.post(
-    "/categories",
-    controller.updateCategories
-  );
-  app.get(
-    "/categories/:url",
-    controller.getCategory
-  );
-  app.post(
-    "/categories/add",
-    [
-      verifyCategory2.checkCategoryExistOrNot
-    ],
-    controller.addCategory
-  );
-  app.post(
-    "/categories/:url",
-    controller.updateCategory
-  );
-  app.delete(
-    "/categories/:url",
-    controller.deleteCategory
-  );
+  app.get("/api/categories", controller.read);
+  app.post("/api/categories/create", [verifyCategory2.checkCategoryExistOrNot], controller.create);
+  app.post("/api/categories/update", controller.update);
+  app.post("/api/categories/delete", controller.delete);
 };
+categories_routes.exports.controllerFactory = controllerFactory$2;
+var categories_routesExports = categories_routes.exports;
 const queryProcessorGlobals = queryProcessor.queryProcessor;
 const controllerFactory$1 = (db) => {
   const Leftover = db.leftover;
@@ -864,7 +861,7 @@ const ProductModel = product_model;
 const CategoryModel = category_model;
 const LeftoverModel = leftover_model;
 const productsRoutes = products_routes;
-const categoriesRoutes = categories_routes;
+const categoriesRoutes = categories_routesExports;
 const leftoversRoutes = leftovers_routes;
 const ProductController = products_controller;
 const CategoryController = categories_controller;
@@ -875,7 +872,7 @@ function initializeProduct(app, db, origins, publicPath) {
   db.leftover = LeftoverModel(db);
   if (app) {
     productsRoutes(app, db);
-    categoriesRoutes(app, db);
+    categoriesRoutes(app, db, origins, publicPath);
     leftoversRoutes(app, db);
   }
 }