@ozdao/martyrs 0.2.506 → 0.2.507

package/dist/products.server.js

@@ -15,133 +15,200 @@ const controllerFactory$1 = (db) => {
   const Category = db.category;
   const logger = new Logger(db);
   const cache = new Cache();
+  const generateSlug = async (name, parentId = null) => {
+    const baseSlug = name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim("-");
+    let slug = baseSlug;
+    let counter = 1;
+    while (await Category.exists({ slug, parent: parentId })) {
+      slug = `${baseSlug}-${counter++}`;
+    }
+    return slug;
+  };
+  const buildTreeFromUrl = (categories, sortParam = "order", sortOrder = "asc") => {
+    console.log("cat buildtree", categories);
+    categories.sort((a, b) => a.url.localeCompare(b.url));
+    const tree = [];
+    const nodeMap = /* @__PURE__ */ new Map();
+    console.log("cat buildtree", categories);
+    categories.forEach((cat) => {
+      const node = { ...cat, children: [] };
+      nodeMap.set(cat.url, node);
+      const parentUrl = cat.url.substring(0, cat.url.lastIndexOf("/"));
+      console.log("cat parent buildtree", parentUrl);
+      if (parentUrl && nodeMap.has(parentUrl)) {
+        nodeMap.get(parentUrl).children.push(node);
+        console.log("cat nodeMap buildtree", nodeMap);
+      } else if (cat.level === 0) {
+        tree.push(node);
+      }
+    });
+    const sortNodes = (nodes) => {
+      nodes.sort((a, b) => {
+        const va = a[sortParam] ?? Number.MAX_SAFE_INTEGER;
+        const vb = b[sortParam] ?? Number.MAX_SAFE_INTEGER;
+        const diff = typeof va === "number" ? va - vb : String(va).localeCompare(String(vb));
+        return sortOrder === "asc" ? diff : -diff;
+      });
+      nodes.forEach((n) => n.children?.length && sortNodes(n.children));
+    };
+    sortNodes(tree);
+    return tree;
+  };
+  const updateCategoryPaths = async (categoryId, newParentId = null) => {
+    const category = await Category.findById(categoryId);
+    if (!category) return;
+    let newPath = [];
+    let newLevel = 0;
+    let newUrl = `/${category.slug}`;
+    if (newParentId) {
+      const parent = await Category.findById(newParentId);
+      if (parent) {
+        newPath = [...parent.path, newParentId];
+        newLevel = parent.level + 1;
+        newUrl = `${parent.url}/${category.slug}`;
+      }
+    }
+    await Category.updateOne(
+      { _id: categoryId },
+      { path: newPath, level: newLevel, url: newUrl }
+    );
+    const oldUrlPattern = new RegExp(`^${category.url}/`);
+    await Category.updateMany(
+      { url: oldUrlPattern },
+      [{
+        $set: {
+          url: { $concat: [newUrl, { $substr: ["$url", { $strLenCP: category.url }, -1] }] },
+          level: { $add: ["$level", newLevel - category.level] }
+        }
+      }]
+    );
+  };
   return {
     async read(req, res) {
       try {
-        let { parent, url, search, sortParam, sortOrder, skip, limit, excludeChildren, rootOnly, type } = req.verifiedQuery;
-        const cacheKey = JSON.stringify(req.verifiedQuery);
-        let cachedResult = await cache.get(cacheKey);
-        if (cachedResult) {
-          return res.status(200).json(cachedResult);
-        }
-        const matchStage = {
-          ...req.query.status && { status: req.query.status },
-          ...url && { url },
+        const {
+          _id,
+          parent,
+          url,
+          status,
+          search,
+          sortParam = "order",
+          sortOrder = "asc",
+          skip,
+          limit,
+          root = false,
+          owner,
+          type,
+          tree,
+          depth = -1
+        } = req.query;
+        const depthNum = parseInt(depth, 10);
+        const isTree = tree === "true" || tree === true;
+        const isRoot = root === "true" || root === true;
+        console.log("🚀 Read categories params:", { url, depth: depthNum, tree: isTree, root });
+        const cacheKey = JSON.stringify(req.query);
+        const cached = await cache.get(cacheKey);
+        if (cached) return res.json(cached);
+        const match = {
+          ..._id && { _id: new db.mongoose.Types.ObjectId(_id) },
+          ...status && { status },
           ...search && { name: { $regex: search, $options: "i" } },
-          ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
-          ...rootOnly === "true" && !search ? { parent: null } : {}
+          ...type && { "owner.type": type },
+          ...owner && { "owner.target": new db.mongoose.Types.ObjectId(owner) },
+          ...parent && { parent: new db.mongoose.Types.ObjectId(parent) }
+          // Исправлено: было owner вместо parent
         };
-        if (type === "platform") {
-          matchStage["owner.type"] = "platform";
-        } else if (type === "organization" && req.query.organizationId) {
-          matchStage["owner.type"] = "organization";
-          matchStage["owner.target"] = new db.mongoose.Types.ObjectId(req.query.organizationId);
-        }
-        if (search) {
-          excludeChildren = "true";
+        if (url && !_id) {
+          if (depth === 0) {
+            match.url = url;
+          } else if (depth === 1) {
+            match.$or = [
+              { url },
+              { url: { $regex: "^${url}/[^/]+$" } }
+            ];
+          } else {
+            match.$or = [
+              { url },
+              { url: { $regex: `^${url}/` } }
+            ];
+          }
+        } else if (isRoot && !_id) {
+          match.url = { $regex: "^/[^/]+$" };
         }
-        let pipeline = [
-          { $match: matchStage },
-          queryProcessorGlobals.getCreatorUserLookupStage(),
-          queryProcessorGlobals.getCreatorOrganizationLookupStage(),
-          // For owner
-          queryProcessorGlobals.getOwnerUserLookupStage(),
-          queryProcessorGlobals.getOwnerOrganizationLookupStage(),
-          queryProcessorGlobals.getAddFieldsCreatorOwnerStage(),
-          { $sort: { [sortParam]: sortOrder === "asc" ? 1 : -1 } },
-          { $skip: Number(skip) },
-          { $limit: Number(limit) },
-          queryProcessorGlobals.removeTempPropeties()
+        console.log("🔎 Match object:", JSON.stringify(match, null, 2));
+        const pipeline = [
+          { $match: match },
+          ...queryProcessorGlobals.getSortingOptions(sortParam, sortOrder)
+          // ...(skip || limit ? globalsQuery.getPaginationOptions(skip, limit) : []),
         ];
-        if (excludeChildren !== "true") {
-          pipeline.push({
-            $graphLookup: {
-              from: "categories",
-              startWith: "$_id",
-              connectFromField: "_id",
-              connectToField: "parent",
-              as: "allDescendants",
-              maxDepth: 10
-            }
+        console.log("🔧 Pipeline:", JSON.stringify(pipeline, null, 2));
+        let results = await Category.aggregate(pipeline);
+        console.log("🔍 Aggregate results:", results.length, "categories found");
+        console.log("🔍 Results URLs:", results.map((r) => r.url));
+        if (url && depthNum > 1) {
+          const maxLevel = url.split("/").filter(Boolean).length + depthNum - 1;
+          results = results.filter((cat) => {
+            const catLevel = cat.url.split("/").filter(Boolean).length;
+            return cat.url === url || catLevel <= maxLevel;
           });
+          console.log("🔍 After depth filter:", results.length, "categories");
         }
-        const results = await Category.aggregate(pipeline);
-        let response;
-        if (excludeChildren === "true") {
-          response = results;
-        } else {
-          let allCategories = [];
-          results.forEach((doc) => {
-            let category = { ...doc };
-            delete category.allDescendants;
-            allCategories.push(category);
-            if (doc.allDescendants && doc.allDescendants.length > 0) {
-              allCategories.push(...doc.allDescendants);
-            }
-          });
-          let uniqueCategories = Array.from(new Map(allCategories.map((item) => [item._id.toString(), item])).values());
-          let tree = buildAdjacencyTree(uniqueCategories, sortParam, sortOrder);
-          if (rootOnly === "true") {
-            response = tree;
+        if (isTree && results.length > 0) {
+          console.log("🌳 Building tree from results");
+          results = buildTreeFromUrl(results, sortParam, sortOrder);
+        } else if (!isTree && depthNum === 1 && url && results.length > 0) {
+          console.log("📋 Processing tree=false, depth=1");
+          console.log("📋 Looking for main category with url:", url);
+          const mainCategory = results.find((c) => c.url === url);
+          console.log("📋 Main category found:", !!mainCategory, mainCategory?.url);
+          if (mainCategory) {
+            const children = results.filter(
+              (c) => c.url !== url && c.url.startsWith(url + "/")
+            );
+            console.log("📋 Children found:", children.length, children.map((c) => c.url));
+            mainCategory.children = children;
+            results = [mainCategory];
+            console.log("📋 Final result with children:", results[0].url, "children:", results[0].children.length);
           } else {
-            const requestedCategoryIds = results.map((r) => r._id.toString());
-            response = tree.filter((category) => requestedCategoryIds.includes(category._id.toString()));
-          }
-        }
-        let tags = ["categories"];
-        if (type === "organization" && req.query.organizationId) {
-          tags.push(`organization_${req.query.organizationId}`);
-        }
-        for (const cat of response) {
-          if (cat._id) {
-            tags.push(`category_${cat._id}`);
+            console.log("❌ Main category not found in results!");
           }
         }
-        await cache.setWithTags(cacheKey, response, tags);
-        res.status(200).json(response);
+        const tags = ["categories"];
+        if (owner) tags.push(`organization_${owner}`);
+        await cache.setWithTags(cacheKey, results, tags);
+        console.log("✅ Final results count:", results.length);
+        res.json(results);
       } catch (err) {
-        console.log(err);
         logger.error(`Error reading categories: ${err.message}`);
         res.status(500).json({ message: err.message });
       }
     },
     async create(req, res) {
       try {
-        const categoryData = req.verifiedBody;
-        if (!categoryData.creator && req.userId) {
-          categoryData.creator = {
-            type: "user",
-            target: req.userId
-          };
-        }
-        if (!categoryData.owner) {
-          if (req.query.organizationId) {
-            categoryData.owner = {
-              type: "organization",
-              target: req.query.organizationId
-            };
-          } else {
-            categoryData.owner = {
-              type: "platform",
-              target: null
-            };
-          }
+        const data = req.verifiedBody;
+        data.creator ||= { type: "user", target: req.userId };
+        data.owner ||= req.query.owner ? { type: "organization", target: req.query.owner } : { type: "platform", target: null };
+        const slug = await generateSlug(data.name, data.parent);
+        let path = [];
+        let level = 0;
+        let url = `/${slug}`;
+        if (data.parent) {
+          const parent = await Category.findById(data.parent);
+          if (!parent) throw new Error("Parent category not found");
+          path = [...parent.path, data.parent];
+          level = parent.level + 1;
+          url = `${parent.url}/${slug}`;
         }
-        const highestOrder = await Category.findOne().sort("-order");
-        const order = highestOrder ? highestOrder.order + 1 : 1;
-        const category = new Category({
-          ...categoryData,
+        const maxOrder = await Category.findOne({ parent: data.parent || null }).sort("-order").select("order");
+        const order = (maxOrder?.order || 0) + 1;
+        const category = await Category.create({
+          ...data,
+          slug,
+          url,
+          path,
+          level,
           order
         });
-        if (categoryData.parent) {
-          const parent = await Category.findByIdAndUpdate(categoryData.parent, { $push: { children: category._id } }, { new: true });
-          if (!parent) throw new Error("Parent category not found");
-          category.parent = parent._id;
-        }
-        if (categoryData.children && categoryData.children.length > 0) {
-          await Category.updateMany({ _id: { $in: categoryData.children } }, { $set: { parent: category._id } });
-        }
-        await category.save();
         await cache.delByTags(["categories"]);
         if (category.owner.type === "organization") {
           await cache.delByTag(`organization_${category.owner.target}`);
@@ -150,23 +217,30 @@ const controllerFactory$1 = (db) => {
         res.status(201).json(category);
       } catch (err) {
         logger.error(`Error creating category: ${err.message}`);
-        res.status(err.message === "Parent category not found" ? 404 : 500).json({ message: err.message });
+        res.status(err.message.includes("not found") ? 404 : 500).json({ message: err.message });
       }
     },
     async update(req, res) {
       try {
-        const category = req.verifiedBody;
-        const updatedCategory = await Category.findByIdAndUpdate(category._id, { $set: category }, { new: true }).lean();
-        if (!updatedCategory) {
+        const data = req.verifiedBody;
+        const oldCategory = await Category.findById(data._id);
+        if (!oldCategory) {
           return res.status(404).json({ message: "Category not found" });
         }
-        await cache.delByTag(`category_${category._id}`);
+        if (data.parent !== void 0 && data.parent != oldCategory.parent) {
+          await updateCategoryPaths(data._id, data.parent);
+        }
+        const updated = await Category.findByIdAndUpdate(
+          data._id,
+          { $set: data },
+          { new: true }
+        ).lean();
         await cache.delByTags(["categories"]);
-        if (updatedCategory.owner && updatedCategory.owner.type === "organization") {
-          await cache.delByTag(`organization_${updatedCategory.owner.target}`);
+        if (updated.owner?.type === "organization") {
+          await cache.delByTag(`organization_${updated.owner.target}`);
         }
-        logger.info(`Category updated: ${category._id}`);
-        res.status(200).json(updatedCategory);
+        logger.info(`Category updated: ${data._id}`);
+        res.json(updated);
       } catch (err) {
         logger.error(`Category update error: ${err.message}`);
         res.status(500).json({ message: "Failed to update category" });
@@ -175,45 +249,20 @@ const controllerFactory$1 = (db) => {
     async updateOrder(req, res) {
       try {
         const { categories } = req.verifiedBody;
-        const bulkOps = categories.map((category) => ({
+        const bulkOps = categories.map((cat) => ({
           updateOne: {
-            filter: { _id: category._id },
-            update: {
-              $set: {
-                order: category.order,
-                parent: category.parent ? new db.mongoose.Types.ObjectId(category.parent) : null
-              }
-            }
+            filter: { _id: cat._id },
+            update: { $set: { order: cat.order } }
           }
         }));
+        const movedCategories = categories.filter((cat) => cat.parent !== void 0);
+        for (const cat of movedCategories) {
+          await updateCategoryPaths(cat._id, cat.parent);
+        }
         await Category.bulkWrite(bulkOps);
-        const categoryIds = categories.map((cat) => cat._id);
-        const organizationIds = /* @__PURE__ */ new Set();
-        const updatedCategories = await Category.find({ _id: { $in: categoryIds } }).lean();
-        updatedCategories.forEach((cat) => {
-          if (cat.owner && cat.owner.type === "organization") {
-            organizationIds.add(cat.owner.target.toString());
-          }
-        });
         await cache.delByTags(["categories"]);
-        for (const catId of categoryIds) {
-          await cache.delByTag(`category_${catId}`);
-        }
-        for (const orgId of organizationIds) {
-          await cache.delByTag(`organization_${orgId}`);
-        }
-        let query = {};
-        if (req.query.type === "platform") {
-          query = { "owner.type": "platform" };
-        } else if (req.query.type === "organization" && req.query.organizationId) {
-          query = {
-            "owner.type": "organization",
-            "owner.target": new db.mongoose.Types.ObjectId(req.query.organizationId)
-          };
-        }
-        const result = await Category.find(query).sort({ order: "asc" }).lean();
-        logger.info(`Categories order updated: ${categoryIds.join(", ")}`);
-        res.status(200).json(result);
+        logger.info(`Categories order updated: ${categories.map((c) => c._id).join(", ")}`);
+        res.json({ message: "Order updated successfully" });
       } catch (err) {
         logger.error(`Category order update error: ${err.message}`);
         res.status(500).json({ message: "Failed to update categories order" });
@@ -222,83 +271,33 @@ const controllerFactory$1 = (db) => {
     async delete(req, res) {
       try {
         const category = req.currentResource;
-        let ownerOrgId = null;
-        if (category.owner && category.owner.type === "organization") {
-          ownerOrgId = category.owner.target;
-        }
-        const result = await Category.aggregate([
-          { $match: { _id: category._id } },
-          {
-            $graphLookup: {
-              from: "categories",
-              startWith: "$_id",
-              connectFromField: "_id",
-              connectToField: "parent",
-              as: "descendants"
-            }
-          },
+        await Category.updateMany(
+          { parent: category._id },
           {
-            $project: { descendants: 1 }
+            $set: { parent: category.parent },
+            $inc: { level: -1 }
           }
-        ]);
-        const idsToDelete = [category._id, ...(result[0]?.descendants || []).map(({ _id }) => _id)];
-        const categoryIdsTags = idsToDelete.map((id) => `category_${id}`);
-        await Category.deleteMany({ _id: { $in: idsToDelete } });
+        );
+        if (category.parent) {
+          const parent = await Category.findById(category.parent);
+          const children = await Category.find({ parent: category.parent });
+          for (const child of children) {
+            await updateCategoryPaths(child._id, category.parent);
+          }
+        }
+        await Category.deleteOne({ _id: category._id });
         await cache.delByTags(["categories"]);
-        await cache.delByTags(categoryIdsTags);
-        if (ownerOrgId) {
-          await cache.delByTag(`organization_${ownerOrgId}`);
+        if (category.owner?.type === "organization") {
+          await cache.delByTag(`organization_${category.owner.target}`);
         }
-        logger.info(`Category and its subcategories deleted: ${category.url}`);
-        res.status(200).json({ message: "Category and its subcategories deleted successfully" });
+        logger.info(`Category deleted: ${category.slug}`);
+        res.json({ message: "Category deleted successfully" });
       } catch (err) {
         logger.error(`Error deleting category: ${err.message}`);
-        res.status(500).json({ message: err.message || "Internal server error" });
+        res.status(500).json({ message: err.message });
       }
     }
   };
-  function buildAdjacencyTree(categories, sortParam, sortOrder) {
-    const categoryMap = /* @__PURE__ */ new Map();
-    categories.forEach((category) => {
-      categoryMap.set(category._id.toString(), {
-        ...category,
-        children: []
-      });
-    });
-    const rootCategories = [];
-    categories.forEach((category) => {
-      const categoryWithChildren = categoryMap.get(category._id.toString());
-      if (category.parent && categoryMap.has(category.parent.toString())) {
-        const parentCategory = categoryMap.get(category.parent.toString());
-        parentCategory.children.push(categoryWithChildren);
-      } else if (!category.parent) {
-        rootCategories.push(categoryWithChildren);
-      }
-    });
-    function sortCategories(nodes) {
-      if (!nodes || nodes.length === 0) {
-        return nodes;
-      }
-      nodes.sort((a, b) => {
-        const valueA = a[sortParam] ?? (sortParam === "order" ? Number.MAX_SAFE_INTEGER : "");
-        const valueB = b[sortParam] ?? (sortParam === "order" ? Number.MAX_SAFE_INTEGER : "");
-        if (typeof valueA === "number" && typeof valueB === "number") {
-          return sortOrder === "asc" ? valueA - valueB : valueB - valueA;
-        } else {
-          const stringA = String(valueA);
-          const stringB = String(valueB);
-          return sortOrder === "asc" ? stringA.localeCompare(stringB) : stringB.localeCompare(stringA);
-        }
-      });
-      nodes.forEach((node) => {
-        if (node.children && node.children.length > 0) {
-          sortCategories(node.children);
-        }
-      });
-      return nodes;
-    }
-    return sortCategories(rootCategories);
-  }
 };
 class OpenAIGlobal {
   constructor() {
@@ -389,15 +388,42 @@ const openaiGlobal = new OpenAIGlobal();
 const ObjectId = Types.ObjectId;
 function getCategoriesFilterStage(categories) {
   if (!categories) return [];
-  const categoryIds = categories.split(",").filter(Boolean);
-  if (categoryIds.length === 0) return [];
-  return [{
-    $match: {
-      category: {
-        $in: categoryIds.map((id) => new ObjectId(id))
+  if (typeof categories === "string") {
+    return [
+      {
+        $lookup: {
+          from: "categories",
+          localField: "category",
+          foreignField: "_id",
+          as: "categoryData"
+        }
+      },
+      {
+        $match: {
+          "categoryData.url": {
+            $regex: `^${categories}(/|$)`
+          }
+        }
+      },
+      {
+        $project: {
+          categoryData: 0
+        }
       }
-    }
-  }];
+    ];
+  }
+  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 [];
 }
 function getDeliveryFilterStage(delivery) {
   if (!delivery) return [];
@@ -439,13 +465,134 @@ function getAttributeFiltersStage(filtersString) {
     return [];
   }
 }
+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 [];
+  }
+}
+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
+      }
+    }
+  ];
+}
 function escapeRegex(string) {
   return string.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
 }
 const queryProcessorProducts = {
   getAttributeFiltersStage,
   getCategoriesFilterStage,
-  getDeliveryFilterStage
+  getDeliveryFilterStage,
+  getVariantPriceFilterStage,
+  getAvailabilityFilterStage
 };
 const productLookupConfigs = {
   // NEW: Лукап для availability продуктов из inventory модуля
@@ -556,6 +703,15 @@ const productLookupConfigs = {
         }
       }
     }]
+  },
+  // Лукап для аренд продукта
+  rents: {
+    lookup: {
+      from: "rents",
+      localField: "_id",
+      foreignField: "product",
+      as: "rents"
+    }
   }
 };
 const controllerFactory = (db) => {
@@ -585,10 +741,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(),
         queryProcessorGlobals.getCreatorOrganizationLookupStage(),
@@ -704,8 +861,10 @@ const CategoryModel = (db) => {
       description: { type: String, trim: true },
       photo: { type: String },
       order: { type: Number, required: true },
+      slug: { type: String, required: true, trim: true },
       url: { type: String, required: true, trim: true, unique: true },
       parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
+      level: { type: Number, required: true, default: 0 },
       localization: { type: Array },
       filters: { type: Array }
     },
@@ -717,23 +876,12 @@ const CategoryModel = (db) => {
   applyOwnershipSchema(CategorySchema, db);
   applyMetadataSchema(CategorySchema);
   applyEngagementSchema(CategorySchema);
-  CategorySchema.index({ name: 1 });
   CategorySchema.index({ name: "text", description: "text" });
-  CategorySchema.index({ "owner.type": 1, "owner.target": 1, status: 1, parent: 1 });
-  CategorySchema.index({ "owner.type": 1, "owner.target": 1, order: 1 });
+  CategorySchema.index({ url: 1, "owner.target": 1, status: 1, level: 1 });
+  CategorySchema.index({ "owner.type": 1, "owner.target": 1, status: 1, level: 1 });
   CategorySchema.index({ parent: 1, status: 1, order: 1 });
-  CategorySchema.index({ parent: 1, status: 1, "owner.type": 1 });
-  CategorySchema.index({ parent: 1, name: 1 });
-  CategorySchema.index({ parent: 1, createdAt: -1 });
-  CategorySchema.index({ parent: 1, updatedAt: -1 });
+  CategorySchema.index({ level: 1, status: 1, order: 1 });
   CategorySchema.index({ status: 1, order: 1 });
-  CategorySchema.index({ status: 1, name: 1 });
-  CategorySchema.index({ status: 1, createdAt: -1 });
-  CategorySchema.index({ status: 1, updatedAt: -1 });
-  CategorySchema.index({ _id: 1, parent: 1 });
-  CategorySchema.index({ order: 1 });
-  CategorySchema.index({ createdAt: -1 });
-  CategorySchema.index({ updatedAt: -1 });
   const Category = db.mongoose.model("Category", CategorySchema, "categories");
   return Category;
 };
@@ -970,9 +1118,21 @@ const VariantModel = (db) => {
   return Variant;
 };
 const verifierFactory$1 = function(db) {
+  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",
@@ -1021,7 +1181,7 @@ const verifierFactory$1 = 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" },
@@ -1050,7 +1210,7 @@ const verifierFactory$1 = function(db) {
     }
   };
   const deleteBodyValidatorConfig = {
-    url: {
+    _id: {
       rule: "optional",
       validator: Validator.schema().string().required()
     }
@@ -1109,18 +1269,31 @@ const verifierFactory$1 = 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
+        let categorySlug = slug;
+        if (!categorySlug) {
+          const existingSlugs = await db.category.find({
+            parent: parent || null
+          }).distinct("slug");
+          categorySlug = generateSlug(name, existingSlugs);
+          req.verifiedBody.slug = categorySlug;
+        } else {
+          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) {
@@ -1144,14 +1317,14 @@ const verifierFactory$1 = 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" });
         }