Feature/rules dashboard

src/backend/index.ts

@@ -25,6 +25,7 @@ import statisticsRouter from './src/routes/statistics.routes';
 import retrospectiveRouter from './src/routes/retrospective.routes';
 import partsRouter from './src/routes/parts.routes';
 import financeRouter from './src/routes/finance.routes';
+import rulesRouter from './src/routes/rules.routes';
 
 const app = express();
 
@@ -87,6 +88,7 @@ app.use('/statistics', statisticsRouter);
 app.use('/retrospective', retrospectiveRouter);
 app.use('/parts', partsRouter);
 app.use('/finance', financeRouter);
+app.use('/rules', rulesRouter);
 app.use('/', (_req, res) => {
   res.status(200).json('Welcome to FinishLine');
 });

src/backend/package.json

@@ -32,6 +32,7 @@
     "jsonwebtoken": "^8.5.1",
     "multer": "^1.4.5-lts.1",
     "nodemailer": "^6.9.1",
+    "pdf-parse-new": "^1.4.1",
     "prisma": "^6.2.1",
     "shared": "1.0.0"
   },

src/backend/src/controllers/rules.controllers.ts

@@ -0,0 +1,339 @@
+import { NextFunction, Request, Response } from 'express';
+import RulesService from '../services/rules.services';
+import { ProjectRule, Rule, Ruleset } from 'shared';
+import { HttpException } from '../utils/errors.utils';
+
+export default class RulesController {
+  static async getActiveRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetTypeId } = req.params;
+      const rulesetType = await RulesService.getActiveRuleset(req.currentUser, rulesetTypeId, req.organization);
+      res.status(200).json(rulesetType);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getRulesetById(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId } = req.params;
+      const ruleset = await RulesService.getRulesetById(rulesetId, req.organization.organizationId);
+      res.status(200).json(ruleset);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async createRule(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { ruleCode, ruleContent, rulesetId, parentRuleId, referencedRules, imageFileIds } = req.body;
+
+      const rule = await RulesService.createRule(
+        req.currentUser,
+        ruleCode,
+        ruleContent,
+        rulesetId,
+        req.organization,
+        parentRuleId,
+        referencedRules || [],
+        imageFileIds || []
+      );
+
+      res.status(201).json(rule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async deleteRule(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { ruleId } = req.params;
+      const deletedRule = await RulesService.deleteRule(ruleId, req.currentUser, req.organization);
+      res.status(200).json(deletedRule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async createRulesetType(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { name } = req.body;
+      const rulesetType = await RulesService.createRulesetType(req.currentUser, name, req.organization);
+      res.status(200).json(rulesetType);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async createProjectRule(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { ruleId, projectId } = req.body;
+      const projectRule: ProjectRule = await RulesService.createProjectRule(
+        req.currentUser,
+        req.organization,
+        ruleId,
+        projectId
+      );
+
+      res.status(200).json(projectRule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async editRule(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { ruleId } = req.params;
+      const { ruleContent, ruleCode, imageFileIds, parentRuleId } = req.body;
+
+      const rule = await RulesService.editRule(
+        req.currentUser,
+        ruleContent,
+        ruleId,
+        ruleCode,
+        imageFileIds,
+        req.organization,
+        parentRuleId
+      );
+      res.status(200).json(rule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getAllRulesetTypes(req: Request, res: Response, next: NextFunction) {
+    try {
+      const rulesets = await RulesService.getAllRulesetTypes(req.organization);
+      res.status(200).json(rulesets);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getRulesetsByRulesetType(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetTypeId } = req.params;
+      const rulesets = await RulesService.getRulesetsByRulesetType(rulesetTypeId, req.organization.organizationId);
+      res.status(200).json(rulesets);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getRulesetType(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetTypeId } = req.params;
+      const rulesetType = await RulesService.getRulesetType(rulesetTypeId, req.organization.organizationId);
+      res.status(200).json(rulesetType);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async deleteRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId } = req.params;
+      const ruleset = await RulesService.deleteRuleset(rulesetId, req.currentUser.userId, req.organization.organizationId);
+      res.status(200).json(ruleset);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async deleteProjectRule(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { projectRuleId } = req.params;
+      const deletedProjectRule = await RulesService.deleteProjectRule(projectRuleId, req.currentUser, req.organization);
+      res.status(200).json(deletedProjectRule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async editProjectRuleStatus(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { projectRuleId } = req.params;
+      const { newStatus } = req.body;
+
+      const projectRule: ProjectRule = await RulesService.editProjectRuleStatus(
+        req.currentUser,
+        req.organization,
+        projectRuleId,
+        newStatus
+      );
+
+      res.status(200).json(projectRule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async toggleRuleTeam(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { ruleId } = req.params;
+      const { teamId } = req.body;
+
+      const changedRule = await RulesService.toggleRuleTeam(ruleId, teamId, req.currentUser, req.organization);
+
+      res.status(200).json(changedRule);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async createRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { name, rulesetTypeId, carNumber, active, fileId } = req.body;
+
+      const ruleset = await RulesService.createRuleset(
+        req.currentUser,
+        req.organization,
+        name,
+        rulesetTypeId,
+        carNumber,
+        active,
+        fileId
+      );
+
+      res.status(200).json(ruleset);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async deleteRulesetType(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetTypeId } = req.params;
+
+      const rulesetType = await RulesService.deleteRulesetType(req.currentUser, rulesetTypeId, req.organization);
+
+      res.status(200).json(rulesetType);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async updateRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId } = req.params;
+      const { name, isActive } = req.body;
+
+      const ruleset: Ruleset = await RulesService.updateRuleset(
+        req.currentUser,
+        req.organization.organizationId,
+        rulesetId,
+        name,
+        isActive
+      );
+
+      res.status(200).json(ruleset);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getChildRules(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { ruleId: parentRuleId } = req.params;
+      const childrenRules: Rule[] = await RulesService.getChildRules(parentRuleId, req.organization);
+
+      res.status(200).json(childrenRules);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getUnassignedRules(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId } = req.params;
+      const rules = await RulesService.getUnassignedRules(rulesetId, req.organization);
+      res.status(200).json(rules);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getUnassignedRulesForRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId, teamId } = req.params;
+      const rules = await RulesService.getUnassignedRulesForRuleset(rulesetId, teamId, req.organization.organizationId);
+      res.status(200).json(rules);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getProjectRules(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId, projectId } = req.params;
+
+      const projectRules = await RulesService.getProjectRules(rulesetId, projectId, req.organization);
+
+      res.status(200).json(projectRules);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getTeamRulesInRulesetType(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetTypeId, teamId } = req.params;
+      const rules = await RulesService.getTeamRulesInRulesetType(teamId, rulesetTypeId, req.organization);
+      res.status(200).json(rules);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getTopLevelRules(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId } = req.params;
+      const rules = await RulesService.getTopLevelRules(rulesetId, req.organization.organizationId);
+      res.status(200).json(rules);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async parseRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { fileId, parserType } = req.body;
+      const { rulesetId } = req.params;
+
+      const parseResult = await RulesService.parseRuleset(
+        req.currentUser,
+        req.organization.organizationId,
+        fileId,
+        rulesetId,
+        parserType
+      );
+
+      res.status(200).json(parseResult);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async uploadRulesetFile(req: Request, res: Response, next: NextFunction) {
+    try {
+      if (!req.file) {
+        throw new HttpException(400, 'Invalid or undefined file data');
+      }
+
+      const fileId = await RulesService.uploadRulesetFile(req.file, req.currentUser, req.organization);
+      res.status(200).json(fileId);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+
+  static async getSingleRuleset(req: Request, res: Response, next: NextFunction) {
+    try {
+      const { rulesetId } = req.params;
+      const ruleset = await RulesService.getSingleRuleset(req.currentUser, rulesetId, req.organization);
+      res.status(200).json(ruleset);
+    } catch (error: unknown) {
+      next(error);
+    }
+  }
+}