Revert Data Visauliztion

backend/app.ts

@@ -14,6 +14,7 @@ import metricRoutes from './routes/metricRoutes';
 import teamRoutes from './routes/teamRoutes';
 import teamSetRoutes from './routes/teamSetRoutes';
 import userRoutes from './routes/userRoutes';
+import codeAnalysisRoutes from './routes/codeAnalysisRoutes';
 import { connectToDatabase } from './utils/database';
 
 const env = process.env.NODE_ENV ?? 'development';
@@ -44,6 +45,7 @@ app.use('/api/assessments', assessmentRoutes);
 app.use('/api/jira', jiraRoutes);
 app.use('/api/metrics', metricRoutes);
 app.use('/api/user', userRoutes);
+app.use('/api/codeanalysis', codeAnalysisRoutes);
 
 app.listen(port, () => {
   console.log(`Server is running at http://localhost:${port}`);

backend/controllers/codeAnalysisController.ts

@@ -0,0 +1,66 @@
+import { Request, Response } from 'express';
+import {
+  fetchAllCodeAnalysisData,
+  fetchAllCodeAnalysisDataForOrg,
+  getAuthorizedCodeAnalysisDataByCourse,
+} from '../services/codeAnalysisService';
+import { MissingAuthorizationError, NotFoundError } from '../services/errors';
+import { getAccountId } from '../utils/auth';
+
+export const getAllCodeAnalysisData = async (req: Request, res: Response) => {
+  try {
+    const codeAnalysisData = await fetchAllCodeAnalysisData();
+    return res.status(200).json({ codeAnalysisData });
+  } catch (error) {
+    console.error('Error retrieving all code analysis data:', error);
+    return res
+      .status(500)
+      .json({ error: 'Failed to get all code analysis data' });
+  }
+};
+
+export const getAllCodeAnalysisDataByOrg = async (
+  req: Request,
+  res: Response
+) => {
+  try {
+    const codeAnalysisDataas = await fetchAllCodeAnalysisDataForOrg(
+      req.params.gitHubOrgName
+    );
+    return res.status(200).json(codeAnalysisDataas);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ message: error.message });
+    } else {
+      console.error('Error retrieving code analysis datas for org:', error);
+      return res
+        .status(500)
+        .json({ error: 'Failed to get code analysis datas for org' });
+    }
+  }
+};
+
+export const getAllCodeAnalysisDataByCourse = async (
+  req: Request,
+  res: Response
+) => {
+  const courseId = req.params.id;
+
+  try {
+    const accountId = await getAccountId(req);
+    const codeAnalyses = await getAuthorizedCodeAnalysisDataByCourse(
+      accountId,
+      courseId
+    );
+    res.status(200).json(codeAnalyses);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else if (error instanceof MissingAuthorizationError) {
+      res.status(400).json({ error: 'Missing authorization' });
+    } else {
+      console.error('Error fetching teams:', error);
+      res.status(500).json({ error: 'Failed to fetch code analyses' });
+    }
+  }
+};

backend/controllers/courseController.ts

@@ -3,11 +3,13 @@ import { addAssessmentsToCourse } from '../services/assessmentService';
 import {
   addFacultyToCourse,
   addMilestoneToCourse,
+  addRepositoriesToCourse,
   addSprintToCourse,
   addStudentsToCourse,
   addTAsToCourse,
   createNewCourse,
   deleteCourseById,
+  editRepository,
   getAssessmentsFromCourse,
   getCourseById,
   getCourseCodeById,
@@ -17,9 +19,11 @@ import {
   getCoursesForUser,
   getPeopleFromCourse,
   getProjectManagementBoardFromCourse,
+  getRepositoriesFromCourse,
   getTeamSetNamesFromCourse,
   getTeamSetsFromCourse,
   removeFacultyFromCourse,
+  removeRepositoryFromCourse,
   removeStudentsFromCourse,
   removeTAsFromCourse,
   updateCourseById,
@@ -323,6 +327,74 @@ export const getPeople = async (req: Request, res: Response) => {
   }
 };
 
+/*-------------------------------------Repositories-------------------------------------*/
+export const getRepositories = async (req: Request, res: Response) => {
+  const courseId = req.params.id;
+  try {
+    const repositories = await getRepositoriesFromCourse(courseId);
+    res.status(200).json(repositories);
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error fetching repositories:', error);
+      res.status(500).json({ error: 'Failed to retrieve repositories' });
+    }
+  }
+};
+
+export const addRepositories = async (req: Request, res: Response) => {
+  const courseId = req.params.id;
+  const repositories = req.body.items;
+  try {
+    await addRepositoriesToCourse(courseId, repositories);
+    res
+      .status(200)
+      .json({ message: 'Repositories added to the course successfully' });
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error adding repositories:', error);
+      res.status(500).json({ error: 'Failed to add repositories' });
+    }
+  }
+};
+
+export const updateRepository = async (req: Request, res: Response) => {
+  const { id, repositoryIndex } = req.params;
+  const updateData = req.body;
+
+  try {
+    await editRepository(id, Number(repositoryIndex), updateData);
+    res.status(200).json({ message: 'Repository updated successfully' });
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error editing repository:', error);
+      res.status(500).json({ error: 'Failed to update repository' });
+    }
+  }
+};
+
+export const removeRepository = async (req: Request, res: Response) => {
+  const { id, repositoryIndex } = req.params;
+  try {
+    await removeRepositoryFromCourse(id, Number(repositoryIndex));
+    res
+      .status(200)
+      .json({ message: 'Repository removed from the course successfully' });
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      res.status(404).json({ error: error.message });
+    } else {
+      console.error('Error removing repository:', error);
+      res.status(500).json({ error: 'Failed to remove repository' });
+    }
+  }
+};
+
 /*----------------------------------------TeamSet----------------------------------------*/
 export const addTeamSet = async (req: Request, res: Response) => {
   const courseId = req.params.id;

backend/jobs/codeAnalysisJob.ts

@@ -57,7 +57,7 @@ const getCourseCodeData = async (octokit: Octokit, course: any) => {
 
     await createProjectIfNotExists(gitHubOrgName + '_' + repo.name);
 
-    await getLatestCommit(gitHubOrgName, repo.name);
+    await getLatestCommit(octokit, gitHubOrgName, repo, course);
 
     await scanRepo(gitHubOrgName, repo.name, buildTool);
 
@@ -175,26 +175,42 @@ const createProjectIfNotExists = async (repo: string) => {
   }
 };
 
-const getLatestCommit = async (gitHubOrgName: string, repoName: string) => {
+const getLatestCommit = async (
+  octokit: Octokit,
+  gitHubOrgName: string,
+  repo: any,
+  course: any
+) => {
   try {
     const repoPath = path.join(
       process.env.REPO_PATH || '',
       gitHubOrgName,
-      repoName
+      repo.name
     );
 
+    const installationTokenResponse =
+      await octokit.rest.apps.createInstallationAccessToken({
+        installation_id: course.installationId,
+      });
+    const installationToken = installationTokenResponse.data.token;
+
+    const cloneUrl = `https://oauth2:${installationToken}@github.com/${gitHubOrgName}/${repo.name}.git`;
+
     if (!fs.existsSync(repoPath)) {
-      console.log(`Cloning repository ${repoName}...`);
-      await execShellCommand(
-        `git clone https://github.com/${gitHubOrgName}/${repoName}.git ${repoPath}`
-      );
+      fs.mkdirSync(repoPath, { recursive: true });
+    }
+
+    if (!fs.existsSync(path.join(repoPath, '.git'))) {
+      console.log(`Cloning repository ${repo.name}...`);
+      fs.rmSync(repoPath, { recursive: true, force: true });
+      fs.mkdirSync(repoPath, { recursive: true });
+      await execShellCommand(`git clone ${cloneUrl} ${repoPath}`);
     } else {
-      await execShellCommand(`git -C ${repoPath} pull`);
+      console.log(`Pulling repository ${repo.name}`);
+      await execShellCommand(`git -C ${repoPath} pull ${cloneUrl}`);
     }
   } catch (error) {
-    console.error(
-      `Error updating repository ${repoName}: ${(error as Error).message}`
-    );
+    console.error(`Error updating repository ${repo.name}: ${error}`);
   }
 };