Rule Dashboard Parsing

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

@@ -1,6 +1,7 @@
 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) {
@@ -13,6 +14,16 @@ export default class RulesController {
     }
   }
 
+  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;
@@ -273,4 +284,36 @@ export default class RulesController {
       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);
+    }
+  }
 }

src/backend/src/prisma-query-args/rules.query-args.ts

@@ -71,3 +71,18 @@ export const getRulesetQueryArgs = () =>
       }
     }
   });
+
+export const getRulesetPreviewQueryArgs = () =>
+  Prisma.validator<Prisma.RulesetDefaultArgs>()({
+    select: {
+      name: true,
+      dateCreated: true,
+      rulesetType: true,
+      active: true,
+      car: {
+        include: {
+          wbsElement: true
+        }
+      }
+    }
+  });

src/backend/src/prisma/seed-data/rules.seed.ts

@@ -61,6 +61,14 @@ const rulesetType1 = (userCreatedId: string, organizationId: string): Prisma.Rul
   };
 };
 
+const rulesetType2 = (userCreatedId: string, organizationId: string): Prisma.Ruleset_TypeCreateInput => {
+  return {
+    name: 'FHE',
+    createdBy: { connect: { userId: userCreatedId } },
+    organization: { connect: { organizationId } }
+  };
+};
+
 const emptyRulesetType = (userCreatedId: string, organizationId: string): Prisma.Ruleset_TypeCreateInput => {
   return {
     name: 'Empty Ruleset Type',
@@ -115,7 +123,6 @@ const projectRule2 = (projectId: string, ruleId: string, createdByUserId: string
 
 export const seedRulesetType = async (submitter: User, name: string, organization: Organization) => {
   const createdRulesetType = await RulesService.createRulesetType(submitter, name, organization);
-
   return createdRulesetType;
 };
 
@@ -125,6 +132,7 @@ export const ruleSeedData = {
   thirdLevelRule,
   leafRule,
   rulesetType1,
+  rulesetType2,
   emptyRulesetType,
   ruleset1,
   secondActiveRuleset,

src/backend/src/prisma/seed.ts

@@ -15,9 +15,7 @@ import {
   Task_Priority,
   Task_Status,
   Team,
-  Part_Tag,
-  Prisma,
-  Ruleset_Type
+  Part_Tag
 } from '@prisma/client';
 import { createUser, dbSeedAllUsers } from './seed-data/users.seed';
 import { dbSeedAllTeams } from './seed-data/teams.seed';
@@ -51,7 +49,6 @@ import AnnouncementService from '../services/announcement.services';
 import OnboardingServices from '../services/onboarding.services';
 import { dbSeedAllParts, dbSeedAllPartTags } from './seed-data/parts.seed';
 import FinanceServices from '../services/finance.services';
-import { getUserQueryArgs } from '../prisma-query-args/user.query-args';
 import { ruleSeedData } from './seed-data/rules.seed';
 import RulesService from '../services/rules.services';
 import { seedRulesetType } from './seed-data/rules.seed';
@@ -807,16 +804,6 @@ const performSeed: () => Promise<void> = async () => {
     ner
   );
 
-  /**
-   * Ruleset Types
-   */
-
-  /** FSAE ruleset type */
-  const rulesetTypeFSAE = await seedRulesetType(joeShmoe, 'FSAE', ner);
-
-  /** FHE ruleset type */
-  const rulesetTypeFHE = await seedRulesetType(joeBlow, 'FHE', ner);
-
   /**
    * Graphs
    */
@@ -3073,43 +3060,6 @@ const performSeed: () => Promise<void> = async () => {
     }
   });
 
-  /**
-   * Rules
-   */
-
-  // ruleset types
-  const fsaeRulesetType = await prisma.ruleset_Type.create({
-    data: ruleSeedData.rulesetType1(batman.userId, ner.organizationId)
-  });
-
-  const emptyRulesetType = await prisma.ruleset_Type.create({
-    data: ruleSeedData.emptyRulesetType(batman.userId, ner.organizationId)
-  });
-
-  // rulesets
-  const ruleset1 = await prisma.ruleset.create({
-    data: ruleSeedData.ruleset1(fergus.carId, batman.userId, fsaeRulesetType.rulesetTypeId)
-  });
-
-  const secondActiveRuleset = await prisma.ruleset.create({
-    data: ruleSeedData.secondActiveRuleset(fergus.carId, batman.userId, fsaeRulesetType.rulesetTypeId)
-  });
-
-  // rules
-  const ruleT = await prisma.rule.create({ data: ruleSeedData.topLevelRule(ruleset1.rulesetId, batman.userId) });
-  const ruleT2 = await prisma.rule.create({
-    data: ruleSeedData.secondLevelRule(ruleset1.rulesetId, batman.userId, ruleT.ruleId)
-  });
-  const ruleT21 = await prisma.rule.create({
-    data: ruleSeedData.thirdLevelRule(ruleset1.rulesetId, batman.userId, ruleT2.ruleId)
-  });
-  const ruleT211 = await prisma.rule.create({
-    data: ruleSeedData.leafRule(ruleset1.rulesetId, batman.userId, ruleT21.ruleId)
-  });
-
-  // project rules
-  await RulesService.createProjectRule(batman, ner, ruleT211.ruleId, project1Id);
-
   const goldSponsorTier = await FinanceServices.createSponsorTier(thomasEmrax, 'Gold', ner, '#9F9156', 3000);
   await FinanceServices.createSponsorTier(thomasEmrax, 'Silver', ner, '#C0C0C0', 200);
   await FinanceServices.createSponsorTier(thomasEmrax, 'Bronze', ner, '#CD7F32', 10);
@@ -3140,18 +3090,31 @@ const performSeed: () => Promise<void> = async () => {
   );
 
   /**
-   * RULESET TYPES AND RULESETS
+   * Rules
    */
 
-  const formulaStudentRulesetType = await prisma.ruleset_Type.create({
-    data: {
-      name: 'Formula Student Rules',
-      createdByUserId: superman.userId,
-      organizationId: ner.organizationId
-    }
+  // ruleset types
+  const fsaeRulesetType = await prisma.ruleset_Type.create({
+    data: ruleSeedData.rulesetType1(batman.userId, ner.organizationId)
+  });
+
+  const fheRulesetType = await prisma.ruleset_Type.create({
+    data: ruleSeedData.rulesetType2(batman.userId, ner.organizationId)
+  });
+
+  const emptyRulesetType = await prisma.ruleset_Type.create({
+    data: ruleSeedData.emptyRulesetType(batman.userId, ner.organizationId)
+  });
+
+  // rulesets
+  const ruleset1 = await prisma.ruleset.create({
+    data: ruleSeedData.ruleset1(fergus.carId, batman.userId, fsaeRulesetType.rulesetTypeId)
+  });
+
+  const secondActiveRuleset = await prisma.ruleset.create({
+    data: ruleSeedData.secondActiveRuleset(fergus.carId, batman.userId, fsaeRulesetType.rulesetTypeId)
   });
 
-  // Create rulesets
   const fsae2025Ruleset = await prisma.ruleset.create({
     data: {
       fileId: 'fsae-2025-rules-file-id',
@@ -3174,9 +3137,21 @@ const performSeed: () => Promise<void> = async () => {
     }
   });
 
-  /**
-   * RULES
-   */
+  // rules
+  const ruleT = await prisma.rule.create({ data: ruleSeedData.topLevelRule(ruleset1.rulesetId, batman.userId) });
+  const ruleT2 = await prisma.rule.create({
+    data: ruleSeedData.secondLevelRule(ruleset1.rulesetId, batman.userId, ruleT.ruleId)
+  });
+  const ruleT21 = await prisma.rule.create({
+    data: ruleSeedData.thirdLevelRule(ruleset1.rulesetId, batman.userId, ruleT2.ruleId)
+  });
+  const ruleT211 = await prisma.rule.create({
+    data: ruleSeedData.leafRule(ruleset1.rulesetId, batman.userId, ruleT21.ruleId)
+  });
+
+  // project rules
+  await RulesService.createProjectRule(batman, ner, ruleT211.ruleId, project1Id);
+
   // Technical Rules Section
   const techRule = await prisma.rule.create({
     data: {
@@ -3227,13 +3202,6 @@ const performSeed: () => Promise<void> = async () => {
       createdByUserId: thomasEmrax.userId
     }
   });
-  const rulesetType = await prisma.ruleset_Type.create({
-    data: {
-      name: 'FSAE',
-      createdByUserId: thomasEmrax.userId,
-      organizationId: ner.organizationId
-    }
-  });
 
   // Powertrain Rules
   const powertrainRule = await prisma.rule.create({
@@ -3512,30 +3480,6 @@ const performSeed: () => Promise<void> = async () => {
       createdByUserId: thomasEmrax.userId
     }
   });
-
-  const ruleset = await prisma.ruleset.create({
-    data: {
-      name: 'FSAE Rules 2025',
-      fileId: 'fsae-rules-2025',
-      active: true,
-      dateCreated: new Date('2025-01-01T10:00:00Z'),
-      rulesetTypeId: rulesetType.rulesetTypeId,
-      createdByUserId: thomasEmrax.userId,
-      carId: fergus.carId
-    }
-  });
-
-  await prisma.rule.create({
-    data: {
-      ruleCode: 'T2.1.1',
-      ruleContent:
-        'The vehicle must be open-wheeled and open-cockpit (a formula style body) with four (4) wheels that are not in a straight line.',
-      imageFileIds: [],
-      dateCreated: new Date('2025-09-01T10:00:00Z'),
-      ruleset: { connect: { rulesetId: ruleset.rulesetId } },
-      createdBy: { connect: { userId: thomasEmrax.userId } }
-    }
-  });
 };
 
 performSeed()

src/backend/src/routes/rules.routes.ts

@@ -2,10 +2,13 @@ import express from 'express';
 import RulesController from '../controllers/rules.controllers';
 import { nonEmptyString, validateInputs } from '../utils/validation.utils';
 import { body } from 'express-validator';
+import { MAX_FILE_SIZE } from 'shared';
+import multer, { memoryStorage } from 'multer';
 
 const rulesRouter = express.Router();
 
 rulesRouter.get('/rulesetType/:rulesetTypeId/active', RulesController.getActiveRuleset);
+rulesRouter.get('/ruleset/:rulesetId', RulesController.getRulesetById);
 
 rulesRouter.post(
   '/rule/create',
@@ -89,4 +92,15 @@ rulesRouter.get('/ruleset/:rulesetId/project/:projectId/rules', RulesController.
 rulesRouter.get('/:ruleId/subrules', RulesController.getChildRules);
 rulesRouter.get('/:rulesetId/parentRules', RulesController.getTopLevelRules);
 
+rulesRouter.post(
+  '/ruleset/:rulesetId/parse',
+  nonEmptyString(body('fileId')),
+  nonEmptyString(body('parserType')), // 'FSAE' or 'FHE'
+  validateInputs,
+  RulesController.parseRuleset
+);
+
+const upload = multer({ limits: { fileSize: MAX_FILE_SIZE }, storage: memoryStorage() });
+rulesRouter.post('/upload/file', upload.single('file'), RulesController.uploadRulesetFile);
+
 export default rulesRouter;