Merge pull request #10 from CODESPACE-CE-PROJECT/CE-008-Compiler

add: analyze code

Author: UnixVextor

src/controllers/compiler.controller.ts

@@ -1,9 +1,13 @@
 import { Request, Response } from "express";
-import { ISubmissionLearnify, ISubmissionRequest } from "../interfaces/submission.interface";
+import {
+  ISubmissionLearnify,
+  ISubmissionRequest,
+} from "../interfaces/submission.interface";
 import { ICompileRequest } from "../interfaces/compiler.interface";
 import { rabbitMQService } from "../services/rabbitmq.service";
 import { RequestWithUser } from "../interfaces/auth.interface";
 import { redisClient } from "../services/redis.service";
+import { analyzeCode } from "../utils/analyze.util";
 
 export const compilerController = {
   addSubmissionToRabbitMQ: async (req: Request, res: Response) => {
@@ -13,11 +17,24 @@ export const compilerController = {
         message: "Missing Required Fields",
       });
     }
+
     submission.token = (req as RequestWithUser).user.token;
-    submission.username = (req as RequestWithUser).user.username
+    submission.username = (req as RequestWithUser).user.username;
+    const resultAnalyzeCode = await analyzeCode(submission);
+    if (
+      resultAnalyzeCode.imports.length > 0 ||
+      resultAnalyzeCode.functions.length > 0
+    ) {
+      return res.status(406).json({
+        message: "Has Constraint In Your Code",
+        data: resultAnalyzeCode,
+      });
+    }
     await rabbitMQService.sendDataToQueue("submission", submission);
 
-    redisClient.set(`submissionState-${submission.username}`, "true", { EX: 240 })
+    redisClient.set(`submissionState-${submission.username}`, "true", {
+      EX: 240,
+    });
 
     return res.status(200).json({
       message: "Add To Queue Successfully",
@@ -37,11 +54,11 @@ export const compilerController = {
     });
   },
   compilerCodeLearnify: async (req: Request, res: Response) => {
-    const data: ISubmissionLearnify = req.body
+    const data: ISubmissionLearnify = req.body;
     // check valid user in learnify database
-    await rabbitMQService.sendDataToQueue("learnify-submission", data)
+    await rabbitMQService.sendDataToQueue("learnify-submission", data);
     return res.status(200).json({
       message: "Add To Queue Successfully",
-    })
-  }
+    });
+  },
 };

src/interfaces/testcase.interface.ts

@@ -2,22 +2,24 @@ export interface ITestCase {
   message: string;
   data: {
     testCases: {
-      testCaseId: string,
+      testCaseId: string;
       input: string;
       output: string;
       isHidden: boolean;
-    }[],
+    }[];
     constraint: {
-      constraintId: string,
-      type: ConstraintType,
-      keyword: string,
-      qunatities: number,
-      problemId: string
-    }[]
+      constraintId: string;
+      type: ConstraintType;
+      keyword: string;
+      qunatities: number;
+      problemId: string;
+    }[];
+    isRegex: boolean;
   };
 }
 
 export enum ConstraintType {
   FUNCTION = "FUNCTION",
   METHOD = "METHOD",
+  CLASS = "CLASS",
 }

src/utils/analyze.util.ts

@@ -0,0 +1,62 @@
+import { languageType } from "../interfaces/compiler.interface";
+import { ISubmissionRequest } from "../interfaces/submission.interface";
+import { ConstraintType, ITestCase } from "../interfaces/testcase.interface";
+import { problemService } from "../services/problem.service";
+
+export const analyzeCode = async (submission: ISubmissionRequest) => {
+  let functionRegex: RegExp;
+  let importRegex: RegExp;
+
+  const testCase: ITestCase = await problemService.getTestCases(
+    submission.problemId,
+    submission.token,
+  );
+
+  const targetFunctions: string[] = testCase.data.constraint.flatMap((item) =>
+    item.type === ConstraintType.FUNCTION ? [item.keyword] : [],
+  );
+
+  const targetImports: string[] = testCase.data.constraint.flatMap((item) =>
+    item.type === ConstraintType.CLASS ? [item.keyword] : [],
+  );
+
+  switch (submission.language) {
+    case languageType.PYTHON:
+      functionRegex = new RegExp(
+        `\\b(${targetFunctions.join("|")})\\s*\\(`,
+        "g",
+      );
+      importRegex = /^(?:import\s+(\w+)|from\s+(\w+)\s+import)/gm;
+      break;
+    case languageType.C:
+    case languageType.CPP:
+      functionRegex = new RegExp(
+        `\\b(${targetFunctions.join("|")})\\s*\\(`,
+        "g",
+      );
+      importRegex = /^#include\s*[<"]([^">]+)[>"]/gm;
+      break;
+    case languageType.JAVA:
+      functionRegex = new RegExp(
+        `\\b(${targetFunctions.join("|")})\\s*\\(`,
+        "g",
+      );
+      importRegex = /^import\s+([\w.*]+);/gm;
+      break;
+    default:
+      throw new Error("Unsupported language!");
+  }
+
+  const functionMatches = [
+    ...submission.sourceCode.matchAll(functionRegex),
+  ].map((match) => match[1]);
+
+  const importMatches = [...submission.sourceCode.matchAll(importRegex)]
+    .map((match) => match[1] || match[2])
+    .filter((importName) => targetImports.includes(importName));
+
+  return {
+    functions: functionMatches,
+    imports: importMatches,
+  };
+};