@ozdao/martyrs 0.2.546 → 0.2.548

package/src/modules/governance/controllers/routes/initiatives.routes.js

@@ -1,11 +1,106 @@
-import initiativeFactory from '../factories/initiatives.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = initiativeFactory(db);
-  app.get('/api/initiatives', controller.getAllInitiatives);
-  app.get('/api/initiatives/:id', controller.getInitiativeById);
-  app.post('/api/initiatives', controller.createInitiative);
-  app.put('/api/initiatives/:id', controller.updateInitiative);
-  app.delete('/api/initiatives/:id', controller.deleteInitiative);
-  app.post('/api/initiatives/:id/approve', controller.approveInitiative);
-  app.post('/api/initiatives/:id/reject', controller.rejectInitiative);
-});
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import initiativesVerifierFactory from '../../middlewares/initiatives.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function (app, db) {
+  const abac = getInstance(db);
+  const verifier = initiativesVerifierFactory(db);
+
+  // Основной CRUD для initiatives
+  const initiativesCRUD = new CRUD({
+    app,
+    db,
+    model: db.initiative,
+    modelName: 'initiative',
+    basePath: '/api/initiatives',
+
+    auth: { read: false },
+
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+
+    abac: abac,
+
+    policies: {
+      read: { enabled: false }
+    },
+
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['initiatives', 'governance']
+    },
+
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Кастомные роуты через addAction
+
+  // Get initiative milestones - /api/initiatives/:id/milestones
+  initiativesCRUD.addAction('milestones', {
+    method: 'get',
+    path: '/:id/milestones',
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const milestones = await db.milestone.find({
+          initiative: req.params.id
+        }).populate('owner contributors');
+        res.json(milestones);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Propose task for initiative - /api/initiatives/:id/propose-task
+  initiativesCRUD.addAction('propose-task', {
+    method: 'post',
+    path: '/:id/propose-task',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const { title, description, milestone, dueDate } = req.body;
+
+        // Создаём голосование для создания задачи
+        const voting = await db.voting.create({
+          type: 'create_task',
+          targetModel: 'Task',
+          title: `Create task: ${title}`,
+          description: `Proposal to create task: ${description}`,
+          initiative: req.params.id,
+          milestone: milestone,
+          threshold: 51,
+          participants: [],
+          metadata: {
+            taskData: {
+              title,
+              description,
+              milestone,
+              dueDate,
+              initiative: req.params.id
+            }
+          }
+        });
+
+        res.status(201).json(voting);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return initiativesCRUD;
+}

package/src/modules/governance/controllers/routes/milestones.routes.js

@@ -0,0 +1,111 @@
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import milestonesVerifierFactory from '../../middlewares/milestones.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function (app, db) {
+  const abac = getInstance(db);
+  const verifier = milestonesVerifierFactory(db);
+
+  // Основной CRUD для milestones
+  const milestonesCRUD = new CRUD({
+    app,
+    db,
+    model: db.milestone,
+    modelName: 'milestone',
+    basePath: '/api/milestones',
+
+    auth: { read: false },
+
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+
+    abac: abac,
+
+    policies: {
+      read: { enabled: false }
+    },
+
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['milestones', 'governance']
+    },
+
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Кастомные роуты через addAction
+
+  // Get milestone tasks - /api/milestones/:id/tasks
+  milestonesCRUD.addAction('tasks', {
+    method: 'get',
+    path: '/:id/tasks',
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const tasks = await db.task.find({
+          milestone: req.params.id
+        }).populate('assignedTo');
+        res.json(tasks);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Propose task for milestone - /api/milestones/:id/propose-task
+  milestonesCRUD.addAction('propose-task', {
+    method: 'post',
+    path: '/:id/propose-task',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const milestone = await db.milestone.findById(req.params.id);
+        if (!milestone) {
+          return res.status(404).json({ error: 'Milestone not found' });
+        }
+
+        const { title, description, dueDate } = req.body;
+
+        // Создаём голосование для создания задачи
+        const voting = await db.voting.create({
+          type: 'create_task',
+          targetModel: 'Task',
+          title: `Create task: ${title}`,
+          description: `Proposal to create task in milestone "${milestone.name}": ${description}`,
+          initiative: milestone.initiative,
+          milestone: req.params.id,
+          threshold: 51,
+          participants: [],
+          metadata: {
+            taskData: {
+              title,
+              description,
+              milestone: req.params.id,
+              initiative: milestone.initiative,
+              dueDate
+            }
+          }
+        });
+
+        res.status(201).json(voting);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return milestonesCRUD;
+}

package/src/modules/governance/controllers/routes/tasks.routes.js

@@ -1,11 +1,164 @@
-import taskFactory from '../factories/tasks.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = taskFactory(db);
-  app.get('/api/tasks', controller.getAllTasks);
-  app.get('/api/tasks/:id', controller.getTaskById);
-  app.post('/api/tasks', controller.createTask);
-  app.put('/api/tasks/:id', controller.updateTask);
-  app.delete('/api/tasks/:id', controller.deleteTask);
-  app.post('/api/tasks/:id/assign', controller.assignTask);
-  app.post('/api/tasks/:id/complete', controller.completeTask);
-});
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import tasksVerifierFactory from '../../middlewares/tasks.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function (app, db) {
+  const abac = getInstance(db);
+  const verifier = tasksVerifierFactory(db);
+
+  // Основной CRUD для tasks
+  const tasksCRUD = new CRUD({
+    app,
+    db,
+    model: db.task,
+    modelName: 'task',
+    basePath: '/api/tasks',
+
+    auth: { read: false },
+
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+
+    abac: abac,
+
+    policies: {
+      read: { enabled: false }
+    },
+
+    cache: {
+      enabled: true,
+      ttl: 300,
+      tags: ['tasks', 'governance']
+    },
+
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Кастомные действия через addAction
+
+  // Assign task - /api/tasks/:id/assign
+  tasksCRUD.addAction('assign', {
+    method: 'post',
+    path: '/:id/assign',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const task = await db.task.findById(req.params.id);
+        if (!task) {
+          return res.status(404).json({ error: 'Task not found' });
+        }
+
+        const { userId } = req.body;
+        const user = await db.user.findById(userId);
+        if (!user) {
+          return res.status(404).json({ error: 'User not found' });
+        }
+
+        task.assignedTo = userId;
+        task.status = 'in_progress';
+        await task.save();
+
+        res.json({ message: 'Task assigned successfully', task });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Submit for review - /api/tasks/:id/submit-for-review
+  tasksCRUD.addAction('submit-for-review', {
+    method: 'post',
+    path: '/:id/submit-for-review',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const task = await db.task.findById(req.params.id)
+          .populate('assignedTo')
+          .populate('milestone');
+
+        if (!task) {
+          return res.status(404).json({ error: 'Task not found' });
+        }
+
+        if (task.status !== 'in_progress') {
+          return res.status(400).json({ error: 'Task must be in progress to submit for review' });
+        }
+
+        // Создаём голосование для приёмки задачи
+        const voting = await db.voting.create({
+          type: 'approve_task',
+          targetModel: 'Task',
+          targetId: task._id,
+          title: `Approve completion of task: ${task.title}`,
+          description: `Review and approve the completion of task "${task.title}"`,
+          initiative: task.initiative,
+          milestone: task.milestone,
+          threshold: 51,
+          participants: [],
+          metadata: {
+            taskId: task._id,
+            completedBy: task.assignedTo
+          }
+        });
+
+        task.status = 'review';
+        task.completionVoting = voting._id;
+        await task.save();
+
+        res.json({ message: 'Task submitted for review', task, voting });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Complete task - /api/tasks/:id/complete
+  tasksCRUD.addAction('complete', {
+    method: 'post',
+    path: '/:id/complete',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const task = await db.task.findById(req.params.id);
+
+        if (!task) {
+          return res.status(404).json({ error: 'Task not found' });
+        }
+
+        if (task.status !== 'review') {
+          return res.status(400).json({ error: 'Task must be in review to complete' });
+        }
+
+        // Проверяем результат голосования если есть
+        if (task.completionVoting) {
+          const voting = await db.voting.findById(task.completionVoting);
+          if (voting && voting.result !== 'approved') {
+            return res.status(400).json({ error: 'Task completion not approved by voting' });
+          }
+        }
+
+        task.status = 'completed';
+        task.completedDate = new Date();
+        await task.save();
+
+        res.json({ message: 'Task completed successfully', task });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return tasksCRUD;
+}

package/src/modules/governance/controllers/routes/votes.routes.js

@@ -1,9 +1,50 @@
-import voteFactory from '../factories/votes.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = voteFactory(db);
-  app.post('/api/votings/:votingId/vote', controller.castVote);
-  app.get('/api/votings/:votingId/votes', controller.getVotesForVoting);
-  app.get('/api/users/:userId/votes', controller.getUserVotes);
-  app.put('/api/votes/:id', controller.updateVote);
-  app.delete('/api/votes/:id', controller.deleteVote);
-});
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import votesVerifierFactory from '../../middlewares/votes.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function (app, db) {
+  const abac = getInstance(db);
+  const verifier = votesVerifierFactory(db);
+
+  // Основной CRUD для votes
+  const votesCRUD = new CRUD({
+    app,
+    db,
+    model: db.vote,
+    modelName: 'vote',
+    basePath: '/api/votes',
+
+    auth: {
+      read: false,
+      create: true  // Votes are typically created via /api/votings/:id/vote
+    },
+
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+
+    abac: abac,
+
+    policies: {
+      read: { enabled: false }
+    },
+
+    cache: {
+      enabled: true,
+      ttl: 60,
+      tags: ['votes', 'governance']
+    },
+
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  return votesCRUD;
+}

package/src/modules/governance/controllers/routes/votings.routes.js

@@ -1,12 +1,209 @@
-import votingFactory from '../factories/votings.controller.js';
-export default (function (app, db, origins, publicPath) {
-  const controller = votingFactory(db);
-  app.get('/api/votings', controller.getAllVotings);
-  app.get('/api/votings/:id', controller.getVotingById);
-  app.post('/api/votings', controller.createVoting);
-  app.put('/api/votings/:id', controller.updateVoting);
-  app.delete('/api/votings/:id', controller.deleteVoting);
-  app.post('/api/votings/:id/start', controller.startVoting);
-  app.post('/api/votings/:id/end', controller.endVoting);
-  app.get('/api/votings/:id/results', controller.getVotingResults);
-});
+import CRUD from '@martyrs/src/modules/globals/controllers/classes/crud/crud.js';
+import ABAC from '@martyrs/src/modules/globals/controllers/classes/abac/abac.js';
+import votingsVerifierFactory from '../../middlewares/votings.verifier.js';
+
+const { getInstance } = ABAC;
+
+export default function (app, db) {
+  const abac = getInstance(db);
+  const verifier = votingsVerifierFactory(db);
+
+  // Основной CRUD для votings
+  const votingsCRUD = new CRUD({
+    app,
+    db,
+    model: db.voting,
+    modelName: 'voting',
+    basePath: '/api/votings',
+
+    auth: { read: false },
+
+    verifiers: {
+      create: verifier.createVerifier,
+      read: verifier.readVerifier,
+      update: verifier.updateVerifier,
+      delete: verifier.deleteVerifier
+    },
+
+    abac: abac,
+
+    policies: {
+      read: { enabled: false }
+    },
+
+    cache: {
+      enabled: true,
+      ttl: 60,
+      tags: ['votings', 'governance']
+    },
+
+    events: {
+      enabled: true,
+      logReads: false
+    }
+  });
+
+  // Кастомные действия
+
+  // Cast vote - /api/votings/:id/vote
+  votingsCRUD.addAction('vote', {
+    method: 'post',
+    path: '/:id/vote',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const voting = await db.voting.findById(req.params.id);
+
+        if (!voting) {
+          return res.status(404).json({ error: 'Voting not found' });
+        }
+
+        if (voting.result !== 'pending') {
+          return res.status(400).json({ error: 'Voting is closed' });
+        }
+
+        const { value, comment } = req.body;
+        const userId = req.user?._id;
+
+        // Проверяем, может ли пользователь голосовать
+        if (voting.participants?.length > 0 && !voting.participants.includes(userId)) {
+          return res.status(403).json({ error: 'Not authorized to vote' });
+        }
+
+        // Проверяем, не голосовал ли пользователь уже
+        const existingVote = await db.vote.findOne({
+          voting: voting._id,
+          voter: userId
+        });
+
+        if (existingVote) {
+          return res.status(400).json({ error: 'Already voted' });
+        }
+
+        // Создаём голос
+        const vote = await db.vote.create({
+          voting: voting._id,
+          voter: userId,
+          value: value,
+          comment: comment
+        });
+
+        // Проверяем результаты голосования
+        await checkVotingResults(voting, db);
+
+        res.status(201).json({ message: 'Vote cast successfully', vote });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Get voting results - /api/votings/:id/results
+  votingsCRUD.addAction('results', {
+    method: 'get',
+    path: '/:id/results',
+    auth: false,
+    abac: { enabled: false },
+    handler: async (req, res) => {
+      try {
+        const voting = await db.voting.findById(req.params.id);
+
+        if (!voting) {
+          return res.status(404).json({ error: 'Voting not found' });
+        }
+
+        const votes = await db.vote.find({ voting: voting._id })
+          .populate('voter', 'name email');
+
+        const totalVotes = votes.length;
+        const yesVotes = votes.filter(v => v.value === 1 || v.value === true).length;
+        const noVotes = votes.filter(v => v.value === 0 || v.value === false).length;
+        const abstainVotes = totalVotes - yesVotes - noVotes;
+
+        const results = {
+          voting: voting,
+          totalVotes: totalVotes,
+          yesVotes: yesVotes,
+          noVotes: noVotes,
+          abstainVotes: abstainVotes,
+          percentageYes: totalVotes > 0 ? (yesVotes / totalVotes * 100).toFixed(2) : 0,
+          percentageNo: totalVotes > 0 ? (noVotes / totalVotes * 100).toFixed(2) : 0,
+          threshold: voting.threshold || 51,
+          result: voting.result,
+          votes: votes
+        };
+
+        res.json(results);
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  // Close voting - /api/votings/:id/close
+  votingsCRUD.addAction('close', {
+    method: 'post',
+    path: '/:id/close',
+    auth: true,
+    handler: async (req, res) => {
+      try {
+        const voting = await db.voting.findById(req.params.id);
+
+        if (!voting) {
+          return res.status(404).json({ error: 'Voting not found' });
+        }
+
+        if (voting.result !== 'pending') {
+          return res.status(400).json({ error: 'Voting is already closed' });
+        }
+
+        const result = await checkVotingResults(voting, db);
+
+        res.json({ message: 'Voting closed', result: result });
+      } catch (error) {
+        console.error(error);
+        res.status(500).json({ error: error.message });
+      }
+    }
+  });
+
+  return votingsCRUD;
+}
+
+// Вспомогательная функция для проверки результатов голосования
+async function checkVotingResults(voting, db) {
+  const votes = await db.vote.find({ voting: voting._id });
+  const totalVotes = votes.length;
+  const yesVotes = votes.filter(v => v.value === 1 || v.value === true).length;
+  const percentageYes = totalVotes > 0 ? (yesVotes / totalVotes * 100) : 0;
+
+  // Проверяем, достигнут ли порог
+  if (percentageYes >= (voting.threshold || 51)) {
+    voting.result = 'approved';
+
+    // Выполняем действие в зависимости от типа голосования
+    if (voting.type === 'create_task' && voting.metadata?.taskData) {
+      const task = await db.task.create({
+        ...voting.metadata.taskData,
+        proposedByVoting: voting._id,
+        status: 'not_started'
+      });
+
+      voting.targetId = task._id;
+    } else if (voting.type === 'approve_task' && voting.targetId) {
+      const task = await db.task.findById(voting.targetId);
+      if (task) {
+        task.status = 'completed';
+        task.completedDate = new Date();
+        await task.save();
+      }
+    }
+  } else if (totalVotes >= (voting.participants?.length || 1)) {
+    voting.result = 'rejected';
+  }
+
+  await voting.save();
+  return voting.result;
+}