@ozdao/prometheus-framework 0.2.222 → 0.2.223

package/dist/products.server.mjs

@@ -4,7 +4,7 @@ import "uuid";
 import require$$0 from "mongoose";
 import "path";
 import require$$3 from "openai";
-import { q as queryProcessor } from "./queryProcessor-DQSFR9YA.mjs";
+import { q as queryProcessor } from "./queryProcessor-CU4A6Y4N.mjs";
 var product_model = (mongoose) => {
   const ProductSchema = new mongoose.Schema({
     status: { type: String },
@@ -237,20 +237,19 @@ const controllerFactory$5 = (db) => {
   };
   const Read = async (req, res) => {
     try {
-      let query = {};
-      let options = {};
+      const query = {};
       if (req.query.organization) {
         query.organization = new ObjectId(req.query.organization);
       }
       if (req.query._id) {
-        query._id = req.query._id;
+        query._id = new ObjectId(req.query._id);
       }
       if (req.query.status) {
         query.status = req.query.status;
       }
       const categories = req.query.categories?.split(",") || [];
       if (categories.length) {
-        query.category = { $in: categories };
+        query.category = { $in: categories.map((cat) => new ObjectId(cat)) };
       }
       const deliveryOptions = req.query.delivery?.split(",") || [];
       if (deliveryOptions.length) {
@@ -268,7 +267,6 @@ const controllerFactory$5 = (db) => {
         query.name = { $regex: regexPattern, $options: "i" };
       }
       const prices = req.query.prices?.split(",") || [];
-      console.log(prices);
       if (prices.length) {
         const priceConditions = prices.map((priceRange) => {
           if (priceRange.startsWith("<")) {
@@ -280,29 +278,125 @@ const controllerFactory$5 = (db) => {
           const [min, max] = priceRange.split("-").map(Number);
           return { price: { $gte: min, $lte: max } };
         });
-        console.log(priceConditions);
         if (priceConditions.length) {
-          query = {
-            ...query,
-            ...{ $or: priceConditions }
-          };
+          query.$or = priceConditions;
         }
       }
-      options.skip = parseInt(req.query.skip) || 0;
-      options.limit = parseInt(req.query.limit) || 10;
-      options.sort = { createdAt: -1 };
+      const options = {
+        skip: parseInt(req.query.skip) || 0,
+        limit: parseInt(req.query.limit) || 10,
+        sort: { createdAt: -1 }
+      };
+      const aggregationPipeline = [
+        { $match: query },
+        { $sort: options.sort },
+        { $skip: options.skip },
+        { $limit: options.limit },
+        {
+          $lookup: {
+            from: "leftovers",
+            let: { productId: "$_id", ingredientsIds: "$ingredients._id" },
+            pipeline: [
+              { $unwind: "$positions" },
+              {
+                $match: {
+                  $expr: {
+                    $or: [
+                      { $eq: ["$positions._id", "$$productId"] },
+                      { $in: ["$positions._id", { $ifNull: ["$$ingredientsIds", []] }] }
+                    ]
+                  }
+                }
+              },
+              {
+                "$addFields": {
+                  "positions.quantity": {
+                    $cond: {
+                      if: { $eq: ["$type", "stock-in"] },
+                      then: "$positions.quantity",
+                      else: { $multiply: ["$positions.quantity", -1] }
+                    }
+                  }
+                }
+              },
+              {
+                "$project": {
+                  _id: "$positions._id",
+                  quantity: "$positions.quantity",
+                  name: "$positions.name"
+                }
+              }
+            ],
+            as: "leftovers"
+          }
+        },
+        {
+          $addFields: {
+            ingredientsQuantities: {
+              $cond: {
+                if: { $isArray: "$ingredients" },
+                then: {
+                  $map: {
+                    input: "$ingredients",
+                    as: "ingredient",
+                    in: {
+                      $let: {
+                        vars: {
+                          ingredientId: "$$ingredient._id",
+                          ingredientQuantity: { $ifNull: ["$$ingredient.quantity", 0] }
+                        },
+                        in: {
+                          $divide: [
+                            {
+                              $sum: {
+                                $map: {
+                                  input: "$leftovers",
+                                  as: "leftover",
+                                  in: {
+                                    $cond: {
+                                      if: { $eq: ["$$leftover._id", "$$ingredientId"] },
+                                      then: "$$leftover.quantity",
+                                      else: 0
+                                    }
+                                  }
+                                }
+                              }
+                            },
+                            {
+                              $cond: {
+                                if: { $eq: ["$$ingredientQuantity", 0] },
+                                then: 1,
+                                else: "$$ingredientQuantity"
+                              }
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  }
+                },
+                else: []
+              }
+            }
+          }
+        },
+        {
+          $set: {
+            quantity: {
+              $cond: {
+                if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
+                then: { $floor: { $min: "$ingredientsQuantities" } },
+                else: { $sum: "$leftovers.quantity" }
+              }
+            }
+          }
+        },
+        { $unset: ["leftovers", "ingredientsQuantities"] }
+      ];
+      const products = await Product.aggregate(aggregationPipeline);
       if (req.query.count) {
-        try {
-          const count = await Product.countDocuments(query);
-          return res.status(200).json({ count });
-        } catch (err) {
-          return res.status(500).json({ message: err.message });
-        }
-      }
-      console.log(query);
-      const products = await Product.find(query, null, options).populate("ingredients._id");
-      if (!products.length) {
-        return res.status(200).json([]);
+        const count = products.length;
+        return res.status(200).json({ count });
       }
       res.status(200).json(products);
     } catch (err) {
@@ -351,114 +445,6 @@ const controllerFactory$5 = (db) => {
       res.status(500).send({ message: err.message });
     }
   };
-  const getProducts = (req, res) => {
-    Product.aggregate([
-      {
-        $facet: {
-          "withIngredients": [
-            {
-              $match: {
-                ingredients: { $exists: true, $not: { $size: 0 } }
-                // Продукты с ингредиентами
-              }
-            },
-            {
-              $lookup: {
-                from: "products",
-                localField: "ingredients",
-                foreignField: "_id",
-                as: "ingredientDetails"
-              }
-            },
-            // { $unwind: "$ingredientDetails" },
-            {
-              $lookup: {
-                from: "leftovers",
-                let: { "ingredientId": "$ingredientDetails._id" },
-                pipeline: [
-                  { $unwind: "$positions" },
-                  {
-                    $match: {
-                      $expr: {
-                        $eq: ["$positions._id", "$$ingredientId"]
-                      }
-                    }
-                  },
-                  {
-                    $project: {
-                      quantity: "$positions.quantity"
-                    }
-                  }
-                ],
-                as: "ingredientLeftovers"
-              }
-            },
-            {
-              $group: {
-                _id: "$_id",
-                name: { $first: "$name" },
-                minQuantity: { $min: "$ingredientLeftovers.quantity" }
-              }
-            }
-          ],
-          "withoutIngredients": [
-            {
-              $match: {
-                $or: [
-                  { ingredients: { $exists: false } },
-                  // Продукты без ингредиентов
-                  { ingredients: { $size: 0 } }
-                ]
-              }
-            },
-            {
-              $lookup: {
-                from: "leftovers",
-                let: { "productId": "$_id" },
-                pipeline: [
-                  { $unwind: "$positions" },
-                  {
-                    $match: {
-                      $expr: {
-                        $eq: ["$positions._id", "$$productId"]
-                      }
-                    }
-                  },
-                  {
-                    $project: {
-                      quantity: "$positions.quantity"
-                    }
-                  }
-                ],
-                as: "productLeftovers"
-              }
-            },
-            {
-              $set: {
-                minQuantity: { $sum: "$productLeftovers.quantity" }
-              }
-            }
-          ]
-        }
-      },
-      {
-        $project: {
-          products: { $setUnion: ["$withIngredients", "$withoutIngredients"] }
-        }
-      },
-      { $unwind: "$products" },
-      { $replaceRoot: { newRoot: "$products" } }
-    ]).exec((err, products) => {
-      if (err) {
-        return res.status(500).send({ message: err });
-      }
-      if (!products) {
-        return res.status(404).send({ message: "Products not found." });
-      }
-      res.status(200).send(products);
-      console.log(products);
-    });
-  };
   const getProductRecommendation = async (req, res) => {
     const { mood } = req.body;
     try {
@@ -532,141 +518,12 @@ const controllerFactory$5 = (db) => {
       res.status(200).send(products);
     });
   };
-  const getProduct = async (req, res) => {
-    try {
-      const product = await Product.aggregate([
-        {
-          $match: { "_id": new ObjectId(req.params._id) }
-        },
-        {
-          $lookup: {
-            from: "leftovers",
-            let: { productId: "$_id", ingredientsIds: "$ingredients._id" },
-            pipeline: [
-              {
-                $unwind: "$positions"
-              },
-              {
-                $match: {
-                  $expr: {
-                    $or: [
-                      { $eq: ["$positions._id", "$$productId"] },
-                      { $in: ["$positions._id", { $ifNull: ["$$ingredientsIds", []] }] }
-                      // Исправлено
-                    ]
-                  }
-                }
-              },
-              {
-                "$addFields": {
-                  "positions.quantity": {
-                    $cond: {
-                      if: { $eq: ["$type", "stock-in"] },
-                      then: "$positions.quantity",
-                      else: { $multiply: ["$positions.quantity", -1] }
-                    }
-                  }
-                }
-              },
-              {
-                "$project": {
-                  _id: "$positions._id",
-                  quantity: "$positions.quantity",
-                  name: "$positions.name"
-                }
-              }
-            ],
-            as: "leftovers"
-          }
-        },
-        {
-          $addFields: {
-            ingredientsQuantities: {
-              $cond: {
-                if: { $isArray: "$ingredients" },
-                then: {
-                  $map: {
-                    input: "$ingredients",
-                    as: "ingredient",
-                    in: {
-                      $let: {
-                        vars: {
-                          ingredientId: "$$ingredient._id",
-                          ingredientQuantity: { $ifNull: ["$$ingredient.quantity", 0] }
-                        },
-                        in: {
-                          $divide: [
-                            {
-                              $sum: {
-                                $map: {
-                                  input: "$leftovers",
-                                  as: "leftover",
-                                  in: {
-                                    $cond: {
-                                      if: { $eq: ["$$leftover._id", "$$ingredientId"] },
-                                      then: "$$leftover.quantity",
-                                      else: 0
-                                    }
-                                  }
-                                }
-                              }
-                            },
-                            {
-                              $cond: {
-                                if: { $eq: ["$$ingredientQuantity", 0] },
-                                then: 1,
-                                else: "$$ingredientQuantity"
-                              }
-                            }
-                          ]
-                        }
-                      }
-                    }
-                  }
-                },
-                else: []
-              }
-            }
-          }
-        },
-        {
-          $set: {
-            quantity: {
-              $cond: {
-                if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
-                // Снова проверяем, не пустой ли массив ингредиентов
-                then: { $floor: { $min: "$ingredientsQuantities" } },
-                else: { $sum: "$leftovers.quantity" }
-                // Просто суммируем quantity из leftovers, если ингредиентов нет
-              }
-            }
-          }
-        },
-        { $unset: ["leftovers", "ingredientsQuantities"] }
-      ]);
-      console.log(product);
-      if (!product || product.length < 1) {
-        return res.status(404).send({ message: "Product not found." });
-      }
-      const updatedProduct = await Product.findOneAndUpdate(
-        { _id: req.params._id },
-        { $inc: { popularity: 1 } },
-        { new: true }
-      );
-      res.status(200).send(product);
-    } catch (err) {
-      console.error("Error:", err);
-      res.status(500).send({ message: err });
-    }
-  };
   return {
     Create,
     Read,
     Update,
     Delete,
-    getProducts,
     getProductsPopular,
-    getProduct,
     getProductRecommendation
   };
 };
@@ -694,10 +551,6 @@ var products_routes = function(app, db, allowedOrigins) {
     "/api/product/recommended",
     controller.getProductRecommendation
   );
-  app.get(
-    "/api/products/:_id",
-    controller.getProduct
-  );
 };
 const products_routes$1 = /* @__PURE__ */ getDefaultExportFromCjs(products_routes);
 const controllerFactory$3 = (db) => {