@ozdao/martyrs 0.2.473 → 0.2.474

package/dist/products.server.mjs

@@ -1,10 +1,18 @@
 import { g as getDefaultExportFromCjs } from "./_commonjsHelpers-CUmg6egw.mjs";
-import { r as requireOwnership_schema } from "./ownership.schema-C0w02Vw1.mjs";
+import { r as requireOwnership_schema } from "./ownership.schema-CNCotD3D.mjs";
+import { r as requireCommon_schema } from "./common.schema-C2m3O1XY.mjs";
+import { r as requireMetadata_schema } from "./metadata.schema--tle-GU8.mjs";
+import { r as requireEngagement_schema } from "./engagement.schema-DnDD7Bn3.mjs";
 import require$$0 from "uuid";
 import require$$0$1 from "mongoose";
 import "path";
 import require$$3 from "openai";
-import { r as requireQueryProcessor } from "./queryProcessor-CWnMIe2U.mjs";
+import { r as requireQueryProcessor } from "./queryProcessor-CVKI651_.mjs";
+import { r as requireGlobals_logger } from "./globals.logger-DusiFsxN.mjs";
+import { r as requireGlobals_cache } from "./globals.cache-BT6q3vOf.mjs";
+import { r as requireGlobals_verifier, a as requireGlobals_validator } from "./globals.verifier-BdJxc8-8.mjs";
+import { r as requireAuthJwt } from "./authJwt-DnXu3BFq.mjs";
+import { r as requireGlobals_abac } from "./globals.abac-DZpTRxKR.mjs";
 var product_model;
 var hasRequiredProduct_model;
 function requireProduct_model() {
@@ -130,25 +138,21 @@ function requireCategory_model() {
     const CategorySchema = new db.mongoose.Schema({
       name: { type: String, required: true, trim: true },
       description: { type: String, trim: true },
-      photo: {
-        type: String
-      },
-      status: {
-        type: String,
-        enum: ["draft", "internal", "published", "removed"],
-        default: "draft",
-        required: true
-      },
+      photo: { type: String },
       order: { type: Number, required: true },
-      url: { type: String, required: true, trim: true },
+      url: { type: String, required: true, trim: true, unique: true },
       parent: { type: db.mongoose.Schema.Types.ObjectId, ref: "Category" },
       localization: { type: Array },
       filters: { type: Array }
     }, {
       timestamps: { currentTime: () => Date.now() }
     });
+    requireCommon_schema()(CategorySchema, db);
+    requireOwnership_schema()(CategorySchema, db);
+    requireMetadata_schema()(CategorySchema, db);
+    requireEngagement_schema()(CategorySchema, db);
     CategorySchema.index({ parent: 1 });
-    CategorySchema.index({ "owner.target": 1, "creator.target": 1 });
+    CategorySchema.index({ name: 1 });
     const Category = db.mongoose.model("Category", CategorySchema, "categories");
     return Category;
   };
@@ -630,78 +634,61 @@ var hasRequiredCategories_controller;
 function requireCategories_controller() {
   if (hasRequiredCategories_controller) return categories_controller;
   hasRequiredCategories_controller = 1;
+  const globalsQuery = requireQueryProcessor();
+  const Logger = requireGlobals_logger();
+  const Cache = requireGlobals_cache();
   const controllerFactory = (db) => {
     const Category = db.category;
+    const logger = new Logger(db);
+    const cache = new Cache();
     return {
       async read(req, res) {
         try {
-          let buildAdjacencyTree = function(categories, sortParam2, sortOrder2) {
-            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[sortParam2] ?? (sortParam2 === "order" ? Number.MAX_SAFE_INTEGER : "");
-                const valueB = b[sortParam2] ?? (sortParam2 === "order" ? Number.MAX_SAFE_INTEGER : "");
-                if (typeof valueA === "number" && typeof valueB === "number") {
-                  return sortOrder2 === "asc" ? valueA - valueB : valueB - valueA;
-                } else {
-                  const stringA = String(valueA);
-                  const stringB = String(valueB);
-                  return sortOrder2 === "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);
-          };
-          let {
+          const {
             parent,
             url,
             search,
-            sortParam = "order",
-            sortOrder = "asc",
-            skip = 0,
-            limit = 10,
-            excludeChildren = "true",
-            rootOnly = false
-          } = req.query;
+            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 },
-            ...req.query.url && { url: req.query.url },
+            ...url && { url },
             ...search && { name: { $regex: search, $options: "i" } },
             ...parent ? { parent: new db.mongoose.Types.ObjectId(parent) } : {},
             ...rootOnly === "true" && !search ? { parent: null } : {}
           };
-          console.log("matchStage", matchStage);
-          if (search) excludeChildren = "true";
+          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";
+          }
           const pipeline = [
             { $match: matchStage },
+            globalsQuery.getCreatorUserLookupStage(),
+            globalsQuery.getCreatorOrganizationLookupStage(),
+            // For owner
+            globalsQuery.getOwnerUserLookupStage(),
+            globalsQuery.getOwnerOrganizationLookupStage(),
+            globalsQuery.getAddFieldsCreatorOwnerStage(),
             { $sort: { [sortParam]: sortOrder === "asc" ? 1 : -1 } },
             { $skip: Number(skip) },
-            { $limit: Number(limit) }
+            { $limit: Number(limit) },
+            globalsQuery.removeTempPropeties()
           ];
           if (excludeChildren !== "true") {
             pipeline.push({
@@ -716,69 +703,106 @@ function requireCategories_controller() {
             });
           }
           const results = await Category.aggregate(pipeline);
+          let response;
           if (excludeChildren === "true") {
-            console.log(results);
-            res.status(200).json(results);
-            return;
-          }
-          const allCategories = [];
-          results.forEach((doc) => {
-            const category = { ...doc };
-            delete category.allDescendants;
-            allCategories.push(category);
-            if (doc.allDescendants && doc.allDescendants.length > 0) {
-              allCategories.push(...doc.allDescendants);
-            }
-          });
-          const uniqueCategories = Array.from(
-            new Map(allCategories.map((item) => [item._id.toString(), item])).values()
-          );
-          const tree = buildAdjacencyTree(uniqueCategories, sortParam, sortOrder);
-          if (rootOnly === "true") {
-            res.json(tree);
+            response = results;
           } else {
-            const requestedCategoryIds = results.map((r) => r._id.toString());
-            const filteredTree = tree.filter(
-              (category) => requestedCategoryIds.includes(category._id.toString())
+            const allCategories = [];
+            results.forEach((doc) => {
+              const category = { ...doc };
+              delete category.allDescendants;
+              allCategories.push(category);
+              if (doc.allDescendants && doc.allDescendants.length > 0) {
+                allCategories.push(...doc.allDescendants);
+              }
+            });
+            const uniqueCategories = Array.from(
+              new Map(allCategories.map((item) => [item._id.toString(), item])).values()
             );
-            res.status(200).json(filteredTree);
+            const tree = buildAdjacencyTree(uniqueCategories, sortParam, sortOrder);
+            if (rootOnly === "true") {
+              response = tree;
+            } else {
+              const requestedCategoryIds = results.map((r) => r._id.toString());
+              response = tree.filter(
+                (category) => requestedCategoryIds.includes(category._id.toString())
+              );
+            }
+          }
+          const 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}`);
+            }
           }
+          await cache.setWithTags(cacheKey, response, tags);
+          res.status(200).json(response);
         } catch (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 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 category = new Category({
+            ...categoryData,
+            order
+          });
+          if (categoryData.parent) {
             const parent = await Category.findByIdAndUpdate(
-              req.body.parent,
+              categoryData.parent,
               { $push: { children: category._id } },
               { new: true }
             );
             if (!parent) throw new Error("Parent category not found");
             category.parent = parent._id;
           }
-          if (req.body.children && req.body.children.length > 0) {
+          if (categoryData.children && categoryData.children.length > 0) {
             await Category.updateMany(
-              { _id: { $in: req.body.children } },
+              { _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}`);
+          }
+          logger.info(`Category created: ${category._id}`);
           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 });
         }
       },
       async update(req, res) {
         try {
-          const category = req.body;
-          if (!category || !category._id) {
-            return res.status(400).json({ message: "Category ID is required" });
-          }
+          const category = req.verifiedBody;
           const updatedCategory = await Category.findByIdAndUpdate(
             category._id,
             { $set: category },
@@ -787,15 +811,21 @@ function requireCategories_controller() {
           if (!updatedCategory) {
             return res.status(404).json({ message: "Category not found" });
           }
+          await cache.delByTag(`category_${category._id}`);
+          await cache.delByTags(["categories"]);
+          if (updatedCategory.owner && updatedCategory.owner.type === "organization") {
+            await cache.delByTag(`organization_${updatedCategory.owner.target}`);
+          }
+          logger.info(`Category updated: ${category._id}`);
           res.status(200).json(updatedCategory);
         } catch (err) {
-          console.error("Category update error:", err);
+          logger.error(`Category update error: ${err.message}`);
           res.status(500).json({ message: "Failed to update category" });
         }
       },
       async updateOrder(req, res) {
         try {
-          const { categories } = req.body;
+          const { categories } = req.verifiedBody;
           const bulkOps = categories.map((category) => ({
             updateOne: {
               filter: { _id: category._id },
@@ -808,18 +838,44 @@ function requireCategories_controller() {
             }
           }));
           await Category.bulkWrite(bulkOps);
-          const updatedCategories = await Category.find().sort({ order: "asc" }).lean();
-          res.status(200).json(updatedCategories);
+          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);
         } catch (err) {
-          console.error("Category update error:", err);
-          res.status(500).json({ message: "Failed to update categories" });
+          logger.error(`Category order update error: ${err.message}`);
+          res.status(500).json({ message: "Failed to update categories order" });
         }
       },
       async delete(req, res) {
         try {
-          const category = await Category.findOne({ url: req.body.url });
-          if (!category) {
-            return res.status(404).json({ message: "Category not found" });
+          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 } },
@@ -837,72 +893,282 @@ function requireCategories_controller() {
             }
           ]);
           const idsToDelete = [category._id, ...(result[0]?.descendants || []).map(({ _id }) => _id)];
+          const categoryIdsTags = idsToDelete.map((id) => `category_${id}`);
           await Category.deleteMany({ _id: { $in: idsToDelete } });
+          await cache.delByTags(["categories"]);
+          await cache.delByTags(categoryIdsTags);
+          if (ownerOrgId) {
+            await cache.delByTag(`organization_${ownerOrgId}`);
+          }
+          logger.info(`Category and its subcategories deleted: ${category.url}`);
           res.status(200).json({ message: "Category and its subcategories deleted successfully" });
         } catch (err) {
-          console.error(err);
+          logger.error(`Error deleting category: ${err.message}`);
           res.status(500).json({ message: err.message || "Internal server error" });
         }
       }
     };
+    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);
+    }
   };
   categories_controller = controllerFactory;
   return categories_controller;
 }
-var verifyCategory;
-var hasRequiredVerifyCategory;
-function requireVerifyCategory() {
-  if (hasRequiredVerifyCategory) return verifyCategory;
-  hasRequiredVerifyCategory = 1;
-  const middlewareFactory = (db) => {
-    const Category = db.category;
-    const checkCategoryExistOrNot = async (req, res, next) => {
-      try {
-        const category = await Category.findOne({ url: req.body.url });
-        if (category) {
-          res.status(400).send({ message: "Failed! Category with this URL is already in use!" });
-          return;
-        }
-        next();
-      } catch (err) {
-        res.status(500).send({ message: err });
+var categories_verifier;
+var hasRequiredCategories_verifier;
+function requireCategories_verifier() {
+  if (hasRequiredCategories_verifier) return categories_verifier;
+  hasRequiredCategories_verifier = 1;
+  const Verifier = requireGlobals_verifier();
+  const Validator = requireGlobals_validator();
+  categories_verifier = function(db) {
+    const queryValidatorConfig = {
+      parent: { allowed: true, validator: Validator.schema().string() },
+      url: { allowed: true, validator: Validator.schema().string() },
+      search: { allowed: true, validator: Validator.schema().string() },
+      sortParam: { allowed: true, validator: Validator.schema().string().oneOf(["order", "name", "createdAt", "updatedAt"]), default: "order" },
+      sortOrder: { allowed: true, validator: Validator.schema().string().oneOf(["asc", "desc"]), default: "asc" },
+      skip: { allowed: true, validator: Validator.schema().number().integer().min(0), default: 0 },
+      limit: { allowed: true, validator: Validator.schema().number().integer().min(1).max(100), default: 10 },
+      excludeChildren: { allowed: true, validator: Validator.schema().string().oneOf(["true", "false"]), default: "true" },
+      rootOnly: { allowed: true, validator: Validator.schema().string().oneOf(["true", "false"]), default: "false" },
+      status: { allowed: true, validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]) },
+      type: { allowed: true, validator: Validator.schema().string().oneOf(["platform", "organization", "all"]), default: "all" },
+      organizationId: { allowed: true, validator: Validator.schema().string() }
+    };
+    const bodyValidatorConfig = {
+      _id: { allowed: true, validator: Validator.schema().string() },
+      name: { allowed: true, validator: Validator.schema().string().required() },
+      description: { allowed: true, validator: Validator.schema().string() },
+      photo: { allowed: true, validator: Validator.schema().string() },
+      status: { allowed: true, validator: Validator.schema().string().oneOf(["draft", "internal", "published", "removed"]), default: "draft" },
+      url: { allowed: true, validator: Validator.schema().string().required() },
+      parent: { allowed: true, validator: Validator.schema().oneOfTypes(["string", "null"]) },
+      localization: { allowed: true },
+      filters: { allowed: true },
+      owner: { allowed: true, validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["platform", "organization"]).required(),
+        target: Validator.schema().string()
+      }) },
+      creator: { allowed: true, validator: Validator.schema().object({
+        type: Validator.schema().string().oneOf(["user", "organization"]).required(),
+        target: Validator.schema().string()
+      }) },
+      children: { allowed: true, validator: Validator.schema().array() },
+      order: { allowed: true, validator: Validator.schema().number() }
+    };
+    const orderBodyValidatorConfig = {
+      categories: {
+        allowed: true,
+        validator: Validator.schema().array().required(),
+        default: []
       }
     };
-    return {
-      checkCategoryExistOrNot
+    const deleteBodyValidatorConfig = {
+      url: {
+        allowed: true,
+        validator: Validator.schema().string().required()
+      }
     };
-  };
-  verifyCategory = middlewareFactory;
-  return verifyCategory;
-}
-var middlewares;
-var hasRequiredMiddlewares;
-function requireMiddlewares() {
-  if (hasRequiredMiddlewares) return middlewares;
-  hasRequiredMiddlewares = 1;
-  const middlewareIndexFactory = (db) => {
-    const verifyCategory2 = requireVerifyCategory()(db);
+    const queryVerifier = new Verifier(queryValidatorConfig);
+    const bodyVerifier = new Verifier(bodyValidatorConfig);
+    const orderBodyVerifier = new Verifier(orderBodyValidatorConfig);
+    const deleteBodyVerifier = new Verifier(deleteBodyValidatorConfig);
     return {
-      verifyCategory: verifyCategory2
+      // Верификация параметров запроса
+      verifyQuery(req, res, next) {
+        const verification = queryVerifier.verify(req.query);
+        if (!verification.isValid) {
+          return res.status(400).json({
+            errors: verification.verificationErrors,
+            message: "Invalid query parameters"
+          });
+        }
+        req.verifiedQuery = verification.verifiedData;
+        next();
+      },
+      // Верификация тела запроса для создания/обновления категории
+      verifyBody(req, res, next) {
+        const verification = bodyVerifier.verify(req.body);
+        if (!verification.isValid) {
+          return res.status(400).json({
+            errors: verification.verificationErrors,
+            message: "Invalid request data"
+          });
+        }
+        req.verifiedBody = verification.verifiedData;
+        next();
+      },
+      // Верификация тела запроса для обновления порядка категорий
+      verifyOrderBody(req, res, next) {
+        const verification = orderBodyVerifier.verify(req.body);
+        if (!verification.isValid) {
+          return res.status(400).json({
+            errors: verification.verificationErrors,
+            message: "Invalid request data"
+          });
+        }
+        req.verifiedBody = verification.verifiedData;
+        next();
+      },
+      // Верификация тела запроса для удаления категории
+      verifyDeleteBody(req, res, next) {
+        const verification = deleteBodyVerifier.verify(req.body);
+        if (!verification.isValid) {
+          return res.status(400).json({
+            errors: verification.verificationErrors,
+            message: "Invalid request data"
+          });
+        }
+        req.verifiedBody = verification.verifiedData;
+        next();
+      },
+      // Проверка на существование категории с тем же URL (для создания)
+      async checkCategoryExistOrNot(req, res, next) {
+        try {
+          if (!req.verifiedBody.url) {
+            return res.status(400).json({ message: "URL 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
+            });
+          }
+          next();
+        } catch (error) {
+          res.status(500).json({ message: error.message });
+        }
+      },
+      // Загрузка категории для проверки ABAC (для обновления и удаления)
+      async loadCategoryForUpdate(req, res, next) {
+        try {
+          const categoryId = req.verifiedBody._id;
+          if (!categoryId) {
+            return res.status(400).json({ message: "Category ID is required" });
+          }
+          const category = await db.category.findById(categoryId).lean();
+          if (!category) {
+            return res.status(404).json({ message: "Category not found" });
+          }
+          req.currentResource = category;
+          next();
+        } catch (error) {
+          res.status(500).json({ message: error.message });
+        }
+      },
+      // Загрузка категории по URL для удаления
+      async loadCategoryForDelete(req, res, next) {
+        try {
+          const url = req.verifiedBody.url;
+          if (!url) {
+            return res.status(400).json({ message: "Category URL is required" });
+          }
+          const category = await db.category.findOne({ url }).lean();
+          if (!category) {
+            return res.status(404).json({ message: "Category not found" });
+          }
+          req.currentResource = category;
+          next();
+        } catch (error) {
+          res.status(500).json({ message: error.message });
+        }
+      }
     };
   };
-  middlewares = middlewareIndexFactory;
-  return middlewares;
+  return categories_verifier;
 }
 var hasRequiredCategories_routes;
 function requireCategories_routes() {
   if (hasRequiredCategories_routes) return categories_routes.exports;
   hasRequiredCategories_routes = 1;
   const controllerFactory = requireCategories_controller();
-  const middlewareFactoryProducts = requireMiddlewares();
+  const verifierFactory = requireCategories_verifier();
+  const jwtFactory = requireAuthJwt();
+  const { getInstance } = requireGlobals_abac();
   categories_routes.exports = function(app, db) {
+    const jwt = jwtFactory(db);
+    const verifier = verifierFactory(db);
+    const abac = getInstance(db);
     const controller = controllerFactory(db);
-    const { verifyCategory: verifyCategory2 } = middlewareFactoryProducts(db);
-    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/updateOrder", controller.updateOrder);
-    app.post("/api/categories/delete", controller.delete);
+    app.get(
+      "/api/categories",
+      jwt.verifyToken(true),
+      verifier.verifyQuery,
+      controller.read
+    );
+    app.post(
+      "/api/categories/create",
+      jwt.verifyToken(),
+      verifier.verifyBody,
+      verifier.checkCategoryExistOrNot,
+      abac.middleware("category", "create"),
+      controller.create
+    );
+    app.post(
+      "/api/categories/update",
+      jwt.verifyToken(),
+      verifier.verifyBody,
+      verifier.loadCategoryForUpdate,
+      abac.middleware("category", "edit"),
+      controller.update
+    );
+    app.post(
+      "/api/categories/updateOrder",
+      jwt.verifyToken(),
+      verifier.verifyOrderBody,
+      abac.middleware("category", "edit"),
+      controller.updateOrder
+    );
+    app.post(
+      "/api/categories/delete",
+      jwt.verifyToken(),
+      verifier.verifyDeleteBody,
+      verifier.loadCategoryForDelete,
+      abac.middleware("category", "delete"),
+      controller.delete
+    );
   };
   categories_routes.exports.controllerFactory = controllerFactory;
   return categories_routes.exports;