@ozdao/martyrs 0.2.506 → 0.2.507

package/src/modules/products/controllers/configs/products.lookup.config.js

@@ -108,5 +108,14 @@ export default  {
         }
       }
     }]
+  },
+  // Лукап для аренд продукта
+  rents: {
+    lookup: {
+      from: 'rents',
+      localField: '_id',
+      foreignField: 'product',
+      as: 'rents'
+    }
   }
 };

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

@@ -37,10 +37,11 @@ const controllerFactory = db => {
           start: 'startDate',
           end: 'endDate',
         }),
-        ...queryProcessorGlobals.getPriceConditions(req.query.prices),
         ...queryProcessorProducts.getCategoriesFilterStage(req.query.categories),
         ...queryProcessorProducts.getDeliveryFilterStage(req.query.delivery),
         ...queryProcessorProducts.getAttributeFiltersStage(req.query.filters),
+        ...queryProcessorProducts.getVariantPriceFilterStage(req.query.prices),
+        ...queryProcessorProducts.getAvailabilityFilterStage(req.query.dateStart, req.query.dateEnd),
         ...queryProcessorGlobals.getLookupStages(requestedLookups, productLookupConfigs),
         
         queryProcessorGlobals.getCreatorUserLookupStage(),

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

@@ -4,22 +4,53 @@ const ObjectId = Types.ObjectId;
 
 /**
  * Обрабатывает фильтрацию по категориям
- * @param {string} categories - строка с ID категорий, разделенная запятыми
+ * @param {string|Array} categories - URL категории или массив ID категорий для обратной совместимости
  * @returns {Array} этапы агрегации для фильтрации по категориям
  */
 function getCategoriesFilterStage(categories) {
   if (!categories) return [];
   
-  const categoryIds = categories.split(',').filter(Boolean);
-  if (categoryIds.length === 0) return [];
+  // Если передан URL как строка, используем новую логику с materialised path
+  if (typeof categories === 'string') {
+    return [
+      {
+        $lookup: {
+          from: 'categories',
+          localField: 'category',
+          foreignField: '_id',
+          as: 'categoryData'
+        }
+      },
+      {
+        $match: {
+          'categoryData.url': {
+            $regex: `^${categories}(/|$)`
+          }
+        }
+      },
+      {
+        $project: {
+          categoryData: 0
+        }
+      }
+    ];
+  }
   
-  return [{
-    $match: {
-      category: {
-        $in: categoryIds.map(id => new ObjectId(id))
+  // Обратная совместимость: если передан массив ID
+  if (Array.isArray(categories)) {
+    const categoryIds = categories.filter(Boolean);
+    if (categoryIds.length === 0) return [];
+    
+    return [{
+      $match: {
+        category: {
+          $in: categoryIds.map(id => new ObjectId(id))
+        }
       }
-    }
-  }];
+    }];
+  }
+  
+  return [];
 }
 
 /**
@@ -89,6 +120,143 @@ function getAttributeFiltersStage(filtersString) {
   }
 }
 
+/**
+ * Обрабатывает фильтрацию по цене вариантов
+ * @param {string} prices - строка с ценовыми диапазонами
+ * @returns {Array} этапы агрегации для фильтрации по ценам вариантов
+ */
+function getVariantPriceFilterStage(prices) {
+  if (!prices) return [];
+  
+  try {
+    const priceRanges = prices.split(',');
+    const priceConditions = [];
+    
+    priceRanges.forEach(priceRange => {
+      if (priceRange.startsWith('<')) {
+        priceConditions.push({
+          variants: {
+            $elemMatch: {
+              price: { $lt: parseFloat(priceRange.slice(1)) }
+            }
+          }
+        });
+      } else if (priceRange.startsWith('>')) {
+        priceConditions.push({
+          variants: {
+            $elemMatch: {
+              price: { $gt: parseFloat(priceRange.slice(1)) }
+            }
+          }
+        });
+      } else {
+        const [min, max] = priceRange.split('-').map(Number);
+        if (!isNaN(min) && !isNaN(max)) {
+          priceConditions.push({
+            variants: {
+              $elemMatch: {
+                price: { $gte: min, $lte: max }
+              }
+            }
+          });
+        }
+      }
+    });
+    
+    return priceConditions.length > 0 ? [{ $match: { $or: priceConditions } }] : [];
+  } catch (error) {
+    console.error('Error parsing price filters:', error);
+    return [];
+  }
+}
+
+/**
+ * Обрабатывает фильтрацию по доступности с учетом количества
+ * @param {string} dateStart - начальная дата
+ * @param {string} dateEnd - конечная дата
+ * @returns {Array} этапы агрегации для фильтрации по доступности
+ */
+function getAvailabilityFilterStage(dateStart, dateEnd) {
+  if (!dateStart || !dateEnd) return [];
+  
+  const startDate = new Date(dateStart);
+  const endDate = new Date(dateEnd);
+  
+  return [
+    {
+      $lookup: {
+        from: 'rents',
+        let: { productId: '$_id' },
+        pipeline: [
+          {
+            $match: {
+              $expr: {
+                $and: [
+                  { $eq: ['$product', '$$productId'] },
+                  { $in: ['$status', ['confirmed', 'active']] },
+                  {
+                    $or: [
+                      {
+                        $and: [
+                          { $gte: ['$startDate', startDate] },
+                          { $lte: ['$startDate', endDate] }
+                        ]
+                      },
+                      {
+                        $and: [
+                          { $gte: ['$endDate', startDate] },
+                          { $lte: ['$endDate', endDate] }
+                        ]
+                      },
+                      {
+                        $and: [
+                          { $lte: ['$startDate', startDate] },
+                          { $gte: ['$endDate', endDate] }
+                        ]
+                      }
+                    ]
+                  }
+                ]
+              }
+            }
+          },
+          {
+            $group: {
+              _id: null,
+              totalRented: { $sum: { $ifNull: ['$quantity', 1] } }
+            }
+          }
+        ],
+        as: 'rentInfo'
+      }
+    },
+    {
+      $addFields: {
+        rentedQuantity: {
+          $ifNull: [{ $arrayElemAt: ['$rentInfo.totalRented', 0] }, 0]
+        },
+        availableQuantity: {
+          $subtract: [
+            { $ifNull: ['$quantity', 1] },
+            { $ifNull: [{ $arrayElemAt: ['$rentInfo.totalRented', 0] }, 0] }
+          ]
+        }
+      }
+    },
+    {
+      $match: {
+        availableQuantity: { $gt: 0 }
+      }
+    },
+    {
+      $project: {
+        rentInfo: 0,
+        rentedQuantity: 0
+      }
+    }
+  ];
+}
+
 /**
  * Экранирует специальные символы в регулярном выражении
  * @private
@@ -102,11 +270,15 @@ function escapeRegex(string) {
 export { 
   getAttributeFiltersStage,
   getCategoriesFilterStage,
-  getDeliveryFilterStage
+  getDeliveryFilterStage,
+  getVariantPriceFilterStage,
+  getAvailabilityFilterStage
 };
 
 export default { 
   getAttributeFiltersStage,
   getCategoriesFilterStage,
-  getDeliveryFilterStage 
+  getDeliveryFilterStage,
+  getVariantPriceFilterStage,
+  getAvailabilityFilterStage
 };

package/src/modules/products/middlewares/categories.verifier.js

@@ -2,10 +2,32 @@ import Validator from '@martyrs/src/modules/globals/controllers/classes/globals.
 import Verifier from '@martyrs/src/modules/globals/controllers/classes/globals.verifier.js';
 
 export default (function (db) {
+  // Функция для генерации slug из имени
+  const generateSlug = (name, existingSlugs = []) => {
+    let baseSlug = name
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, '')
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .trim('-');
+    
+    let slug = baseSlug;
+    let counter = 1;
+    
+    while (existingSlugs.includes(slug)) {
+      slug = `${baseSlug}-${counter}`;
+      counter++;
+    }
+    
+    return slug;
+  };
+
   // Конфигурация валидатора для запросов
   const queryValidatorConfig = {
     parent: { rule: 'optional', validator: Validator.schema().string() },
+    slug: { rule: 'optional', validator: Validator.schema().string() },
     url: { rule: 'optional', validator: Validator.schema().string() },
+    parentUrl: { rule: 'optional', validator: Validator.schema().string() },
     search: { rule: 'optional', validator: Validator.schema().string() },
     sortParam: {
       rule: 'optional',
@@ -54,7 +76,7 @@ export default (function (db) {
       validator: Validator.schema().string().oneOf(['draft', 'internal', 'published', 'removed']),
       default: 'draft',
     },
-    url: { rule: 'optional', validator: Validator.schema().string().required() },
+    slug: { rule: 'optional', validator: Validator.schema().string() },
     parent: { rule: 'optional', validator: Validator.schema().oneOfTypes(['string', 'null']) },
     localization: { rule: 'optional' },
     filters: { rule: 'optional' },
@@ -83,7 +105,7 @@ export default (function (db) {
     },
   };
   const deleteBodyValidatorConfig = {
-    url: {
+    _id: {
       rule: 'optional',
       validator: Validator.schema().string().required(),
     },
@@ -143,19 +165,40 @@ export default (function (db) {
       req.verifiedBody = verification.verifiedData;
       next();
     },
-    // Проверка на существование категории с тем же URL (для создания)
+    // Проверка на существование категории с тем же slug в рамках parent
     async checkCategoryExistOrNot(req, res, next) {
       try {
-        if (!req.verifiedBody.url) {
-          return res.status(400).json({ message: 'URL is required' });
+        const { name, parent, slug } = req.verifiedBody;
+        
+        if (!name) {
+          return res.status(400).json({ message: 'Name is required' });
         }
-        const existingCategory = await db.category.findOne({ url: req.verifiedBody.url });
-        if (existingCategory) {
-          return res.status(409).json({
-            message: 'Category with this URL already exists',
-            category: existingCategory,
+
+        // Генерируем slug если не передан
+        let categorySlug = slug;
+        if (!categorySlug) {
+          // Получаем существующие slug в рамках parent
+          const existingSlugs = await db.category.find({
+            parent: parent || null
+          }).distinct('slug');
+          
+          categorySlug = generateSlug(name, existingSlugs);
+          req.verifiedBody.slug = categorySlug;
+        } else {
+          // Проверяем уникальность переданного slug
+          const existingCategory = await db.category.findOne({ 
+            slug: categorySlug, 
+            parent: parent || null 
           });
+          
+          if (existingCategory) {
+            return res.status(409).json({
+              message: 'Category with this slug already exists in this parent',
+              category: existingCategory,
+            });
+          }
         }
+        
         next();
       } catch (error) {
         res.status(500).json({ message: error.message });
@@ -178,14 +221,14 @@ export default (function (db) {
         res.status(500).json({ message: error.message });
       }
     },
-    // Загрузка категории по URL для удаления
+    // Загрузка категории по _id для удаления
     async loadCategoryForDelete(req, res, next) {
       try {
-        const url = req.verifiedBody.url;
-        if (!url) {
-          return res.status(400).json({ message: 'Category URL is required' });
+        const _id = req.verifiedBody._id;
+        if (!_id) {
+          return res.status(400).json({ message: 'Category _id is required' });
         }
-        const category = await db.category.findOne({ url }).lean();
+        const category = await db.category.findById(_id).lean();
         if (!category) {
           return res.status(404).json({ message: 'Category not found' });
         }