@ozdao/prometheus-framework 0.2.222 → 0.2.223

package/src/modules/products/components/pages/Product.vue

@@ -50,7 +50,7 @@
 	};
 
 	onMounted(async ()=> {
-		await products.actions.fetchProduct(route.params.product);
+		await products.actions.read({_id: route.params.product});
 
 	})
 	

package/src/modules/products/components/sections/MenuSection.vue

@@ -11,7 +11,7 @@
 
 			<ul v-else class="gap-thin grid-container">
 				<router-link :to="getMarketplaceLink([category.url])"
-					v-for="(category,index) in store.categories.state.all" 
+					v-for="(category,index) in store.categories.state.all.slice(0,5)" 
 					:key="category" 
 					class="cursor-pointer hover-scale-0 flex-v-center flex-h-center flex-nowrap flex-row flex bg-light radius-big pd-medium grid-item"
 				>
@@ -65,7 +65,7 @@
 
 <script setup>
 	import { ref, onMounted,computed } from 'vue'
-		import Loader from '@pf/src/components/Loader/Loader.vue'
+	import Loader from '@pf/src/components/Loader/Loader.vue'
 
 	import { useRouter } from 'vue-router'
 	import { useStore } from '@/store';	

package/src/modules/products/controllers/products.controller.js

@@ -29,114 +29,230 @@ const controllerFactory = (db) => {
       res.status(500).send({ message: err.message });
     }
   };
-  const ReadCount = async (req, res) => {
-    
-  }
+
   // Read products
   const Read = async (req, res) => {
-    try {
-      let query = {};
-      let options = {};
+  try {
+    const query = {};
 
-      if (req.query.organization) {
-        query.organization = new ObjectId(req.query.organization);
-      }
-
-      if (req.query._id) {
-        query._id = req.query._id;
-      }
+    if (req.query.organization) {
+      query.organization = new ObjectId(req.query.organization);
+    }
 
-      if (req.query.status) {
-        query.status = req.query.status;
-      }
+    if (req.query._id) {
+      query._id = new ObjectId(req.query._id);
+    }
 
-      const categories = req.query.categories?.split(',') || [];
+    if (req.query.status) {
+      query.status = req.query.status;
+    }
 
-      if (categories.length) {
-        query.category = { $in: categories };
-      }
+    const categories = req.query.categories?.split(',') || [];
+    if (categories.length) {
+      query.category = { $in: categories.map(cat => new ObjectId(cat)) };
+    }
 
-      const deliveryOptions = req.query.delivery?.split(',') || [];
+    const deliveryOptions = req.query.delivery?.split(',') || [];
+    if (deliveryOptions.length) {
+      query.delivery = { $in: deliveryOptions };
+    }
 
-      if (deliveryOptions.length) {
-        query.delivery = { $in: deliveryOptions };
+    const search = req.query.search;
+    if (search) {
+      const parts = search.split('.');
+      let regexPattern = '';
+      if (parts.length === 2) {
+        regexPattern = parts.map(part => part.substr(0, part.length - 1) + '.{1}').join('\\.');
+      } else {
+        regexPattern = search.substr(0, search.length - 1) + '.{1}';
       }
+      query.name = { $regex: regexPattern, $options: 'i' };
+    }
 
-      const search = req.query.search;
-
-      if (search) {
-        const parts = search.split('.');
-
-        let regexPattern = '';
-
-        if (parts.length === 2) {
-          // Создаем паттерн, который допускает замену одного символа в каждой части
-          regexPattern = parts.map(part => part.substr(0, part.length - 1) + '.{1}').join('\\.');
-        } else {
-          // Если нет точки, применяем аналогичный подход к всей строке
-          regexPattern = search.substr(0, search.length - 1) + '.{1}';
+    const prices = req.query.prices?.split(',') || [];
+    if (prices.length) {
+      const priceConditions = prices.map(priceRange => {
+        if (priceRange.startsWith('<')) {
+          return { price: { $lt: parseInt(priceRange.slice(1)) } };
+        }
+        if (priceRange.startsWith('>')) {
+          return { price: { $gt: parseInt(priceRange.slice(1)) } };
         }
+        const [min, max] = priceRange.split('-').map(Number);
+        return { price: { $gte: min, $lte: max } };
+      });
 
-        query.name = { $regex: regexPattern, $options: 'i' } 
+      if (priceConditions.length) {
+        query.$or = priceConditions;
       }
+    }
 
-      // Handle price ranges
-      const prices = req.query.prices?.split(',') || [];
-
-      console.log(prices)
-      if (prices.length) {
-        const priceConditions = prices.map(priceRange => {
-          if (priceRange.startsWith('<')) {
-            return { price: { $lt: parseInt(priceRange.slice(1)) } };
-          }
-          if (priceRange.startsWith('>')) {
-            return { price: { $gt: parseInt(priceRange.slice(1)) } };
-          }
-          
-          const [min, max] = priceRange.split('-').map(Number);
+    const options = {
+      skip: parseInt(req.query.skip) || 0,
+      limit: parseInt(req.query.limit) || 10,
+      sort: { createdAt: -1 }
+    };
 
-          return { price: { $gte: min, $lte: max } };
-        });
+     // {
+    //   $lookup: {
+    //     from: "modifications",
+    //     let: { "productId": "$_id" },
+    //     pipeline: [{ 
+    //       $match: { 
+    //         "$expr": { 
+    //           "$eq": ["$product", "$$productId"] 
+    //         }
+    //       }
+    //     },{
+    //       $lookup: {
+    //         from: "leftovers",
+    //         let: { "productId": "$_id" },
+    //         pipeline: [{
+    //           $unwind: "$positions"
+    //         },{ 
+    //           "$match": { "$expr": { "$eq": ["$positions._id", "$$productId"] }}
+    //         },{ 
+    //           "$project": {
+    //             _id: "$positions._id",
+    //             quantity: "$positions.quantity",
+    //             name: "$positions.name",
+    //           }
+    //         }],
+    //         as: "variantsMods"
+    //       },
+    //     },{ 
+    //       $set: { 
+    //         quantity:{
+    //           $sum:["$quantity",{$sum:"$variantsMods.quantity"}]
+    //         } 
+    //       }
+    //     },{ 
+    //       $unset: "variants" 
+    //     }],
+    //     as: "modifications"
+    //   },
+    // }
 
-        console.log(priceConditions)
-        if (priceConditions.length) {
-          query = {
-            ...query,
-            ...{ $or: priceConditions }
+    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: []
+            }
           }
         }
-      }
-      
-      // Handle pagination and sorting
-      options.skip = parseInt(req.query.skip) || 0;
-      options.limit = parseInt(req.query.limit) || 10;
-      options.sort = { createdAt: -1 };
-
-      // Count functionality
-      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 });
+      },
+      {
+        $set: {
+          quantity: {
+            $cond: {
+              if: { $gt: [{ $size: { $ifNull: ["$ingredients", []] } }, 0] },
+              then: { $floor: { $min: "$ingredientsQuantities" } },
+              else: { $sum: "$leftovers.quantity" }
+            }
+          }
         }
-      }
+      },
+      { $unset: ["leftovers", "ingredientsQuantities"] }
+    ];
 
-      console.log(query)
-
-      // Fetching products
-      const products = await Product.find(query, null, options).populate('ingredients._id')
-
-      if (!products.length) {
-        return res.status(200).json([]);
-      }
+    // Выполнение агрегации
+    const products = await Product.aggregate(aggregationPipeline);
 
-      res.status(200).json(products);
-    } catch (err) {
-      return res.status(500).json({ message: err.message });
+    if (req.query.count) {
+      const count = products.length;
+      return res.status(200).json({ count });
     }
-  };
 
+    res.status(200).json(products);
+  } catch (err) {
+    return res.status(500).json({ message: err.message });
+  }
+};
   const Update = async (req, res) => {
     try {
       const { _id } = req.params;
@@ -186,155 +302,6 @@ const controllerFactory = (db) => {
     }
   };
 
-
-  const getProducts = (req, res) => {
-
-    // {
-    //   $lookup: {
-    //     from: "modifications",
-    //     let: { "productId": "$_id" },
-    //     pipeline: [{ 
-    //       $match: { 
-    //         "$expr": { 
-    //           "$eq": ["$product", "$$productId"] 
-    //         }
-    //       }
-    //     },{
-    //       $lookup: {
-    //         from: "leftovers",
-    //         let: { "productId": "$_id" },
-    //         pipeline: [{
-    //           $unwind: "$positions"
-    //         },{ 
-    //           "$match": { "$expr": { "$eq": ["$positions._id", "$$productId"] }}
-    //         },{ 
-    //           "$project": {
-    //             _id: "$positions._id",
-    //             quantity: "$positions.quantity",
-    //             name: "$positions.name",
-    //           }
-    //         }],
-    //         as: "variantsMods"
-    //       },
-    //     },{ 
-    //       $set: { 
-    //         quantity:{
-    //           $sum:["$quantity",{$sum:"$variantsMods.quantity"}]
-    //         } 
-    //       }
-    //     },{ 
-    //       $unset: "variants" 
-    //     }],
-    //     as: "modifications"
-    //   },
-    // }
-
-    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 error
-      if (err) {return res.status(500).send({ message: err }); }
-      // If not found
-      if (!products) {return res.status(404).send({ message: "Products not found." }); }
-      // If succes
-      res.status(200).send(products);
-      console.log(products)
-    }); 
-  };
   const getProductRecommendation = async (req, res) => {
     const { mood } = req.body;
 
@@ -422,146 +389,13 @@ const controllerFactory = (db) => {
       res.status(200).send(products);
     });
   };
-  // Get product
-  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 }
-    );
-
-    // console.log('Popularity updated:', updatedProduct);
-
-   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
   };
 };

package/src/modules/products/routes/products.routes.js

@@ -28,10 +28,5 @@ module.exports = function(app, db, allowedOrigins) {
     "/api/product/recommended",
     controller.getProductRecommendation
   );
-  // // Get product
-  app.get(
-    "/api/products/:_id",
-    controller.getProduct
-  );
 };
 

package/src/modules/products/store/categories.js

@@ -2,11 +2,10 @@
 // DEPENDENCIES
 /////////////////////////////
 import { reactive, watch, computed  } from "vue";
-import axios from 'axios';
 // Globals 
 import { setError }   from '@pf/src/modules/globals/views/store/globals'
 // Setup Axios
-const $axios = axios.create({baseURL: process.env.API_URL, withCredentials: true}) 
+import $axios from '@pf/src/modules/globals/views/utils/axios-instance.js';
 
 const state = reactive({
   all: [],

package/src/modules/products/store/leftovers.js

@@ -2,11 +2,10 @@
 // DEPENDENCIES
 /////////////////////////////
 import { reactive, watch, computed  } from "vue";
-import axios from 'axios';
 // Globals 
 import { setError }   from '@pf/src/modules/globals/views/store/globals'
 // Setup Axios
-const $axios = axios.create({baseURL: process.env.API_URL, withCredentials: true}) 
+import $axios from '@pf/src/modules/globals/views/utils/axios-instance.js';
 
 const state = reactive({
   all: [],