@ozdao/martyrs 0.2.473 → 0.2.474

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

@@ -0,0 +1,177 @@
+// middlewares/categories.verifier.js
+const Verifier = require('@martyrs/src/modules/globals/controllers/classes/globals.verifier');
+const Validator = require('@martyrs/src/modules/globals/controllers/classes/globals.validator');
+
+module.exports = 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: [] 
+    }
+  };
+  
+  const deleteBodyValidatorConfig = {
+    url: { 
+      allowed: true, 
+      validator: Validator.schema().string().required()
+    }
+  };
+  
+  const queryVerifier = new Verifier(queryValidatorConfig);
+  const bodyVerifier = new Verifier(bodyValidatorConfig);
+  const orderBodyVerifier = new Verifier(orderBodyValidatorConfig);
+  const deleteBodyVerifier = new Verifier(deleteBodyValidatorConfig);
+
+  return {
+    // Верификация параметров запроса
+    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; // Устанавливаем для ABAC
+        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; // Устанавливаем для ABAC
+        next();
+      } catch (error) {
+        res.status(500).json({ message: error.message });
+      }
+    }
+  };
+};

package/src/modules/products/models/category.model.js

@@ -1,29 +1,27 @@
+// models/category.model.js
 module.exports = (db) => {
   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() }
   });
-
+  
+  // Применяем глобальные схемы
+  require('@martyrs/src/modules/globals/models/schemas/common.schema')(CategorySchema, db);
+  require('@martyrs/src/modules/globals/models/schemas/ownership.schema')(CategorySchema, db);
+  require('@martyrs/src/modules/globals/models/schemas/metadata.schema')(CategorySchema, db);
+  require('@martyrs/src/modules/globals/models/schemas/engagement.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;
-};
+};

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

@@ -1,18 +1,57 @@
-// Factories
-const controllerFactory = require("../controllers/categories.controller");
-// Middlewares
-const middlewareFactoryProducts = require('@martyrs/src/modules/products/middlewares');
+// routes/categories.routes.js
+const controllerFactory = require("../controllers/categories.controller.js");
+const verifierFactory = require('../middlewares/categories.verifier.js');
+const jwtFactory = require('@martyrs/src/modules/auth/controllers/middlewares/authJwt.js');
+
+const { getInstance } = require('@martyrs/src/modules/globals/controllers/classes/globals.abac.js');
 
 module.exports = function(app, db) {
+  const jwt = jwtFactory(db);
+  const verifier = verifierFactory(db);
+  const abac = getInstance(db);
   const controller = controllerFactory(db);
   
-  const { verifyCategory } = middlewareFactoryProducts(db);
-
-  app.get('/api/categories', controller.read);
-  app.post('/api/categories/create', [verifyCategory.checkCategoryExistOrNot], controller.create);
-  app.post('/api/categories/update', controller.update);  // For single category updates
-  app.post('/api/categories/updateOrder', controller.updateOrder);  // For updating order of multiple categories
-  app.post('/api/categories/delete', controller.delete);
+  // Маршруты API
+  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
+  );
 };
 
 module.exports.controllerFactory = controllerFactory;

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

@@ -18,6 +18,8 @@ const state = reactive({
     name: "",
     url: "",
     status: "draft",
+    creator: null,
+    owner: null,
     parent: null,
     children: [],
     filters: [],

package/src/modules/spots/components/pages/SpotEdit.vue

@@ -18,15 +18,11 @@
     </Block>
     
 
-    <div class="cols-2 gap-thin">
-    
+    <div class="cols-2 gap-thin"> 
       <Block
         title="Profile"
         class="mn-b-semi"
       >
-
-
-
         <div class="gap-small mn-b-small cols-2-fit-content">
           <UploadImage 
              v-model:photo="spots.state.spot.profile.photo"
@@ -52,6 +48,14 @@
           </div>
         </div>
 
+        <Field 
+          v-model:field="spots.state.spot.minorder"     
+          label="Min.order"  
+          placeholder="Enter minimum order value" 
+          class="bg-white radius-small mn-b-small pd-small"
+          :validation="organizationName" 
+        />  
+
         <Select 
           v-model:select="spots.state.spot.status"
           label="Status"
@@ -60,10 +64,10 @@
             'published',
             'archivied'
           ]"
-          placeholder="Display product"
+          placeholder="Status"
           class="pos-relative w-100 mn-b-small bg-white radius-small pd-medium"
         />
-          
+
         <p class="p-medium mn-b-small">Please the available delivery options:</p>
 
         <Checkbox 
@@ -125,6 +129,12 @@
             spots.state.spot.address = newAddress;
           }"
         />
+        
+        <WorktimeEdit 
+          v-model:worktime="spots.state.spot.worktime"
+          class="mn-b-small"
+        />
+
         <p class="mn-b-small p-medium">Options:</p>
         <Checkbox 
           :label="'Hide address'"
@@ -132,18 +142,10 @@
           class="w-100 mn-r-small bg-white radius-small pd-small"
           :radio="spots.state.spot.position?.hide"
           @update:radio="event => spots.state.spot.position.hide = event"
-
         />
 
-        <Field 
-          v-model:field="spots.state.spot.minorder"     
-          label="Min.order"  
-          placeholder="Enter minimum order value" 
-          class="bg-white radius-small pd-medium"
-          :validation="organizationName" 
-        />  
-
       </Block>
+
     </div>
 
     <Button :submit="onDelete" :callback="redirectDash" class="w-100 bg-light">Delete Spot</Button>
@@ -166,6 +168,8 @@ import LocationMarker from "@martyrs/src/components/LocationMarker/LocationMarke
 import Button from "@martyrs/src/components/Button/Button.vue";
 import Popup from "@martyrs/src/components/Popup/Popup.vue";
 
+import WorktimeEdit from "../sections/WorktimeEdit.vue"; 
+
 import * as spots from "@martyrs/src/modules/spots/store/spots";
 
 const router = useRouter();
@@ -214,7 +218,7 @@ async function onSubmit() {
 
 function redirectTo() {
   // router.replace({ name: "Spot", params: { _id: route.params._id, spot: spots.state.spot._id } });
-   router.push({ name: "Organization", params: { _id: route.params._id }});
+   router.push({ name: "Organization",  query: { tab: 'spots' }, params: { _id: route.params._id }});
 }
 
 async function onDelete() {