ExerciseRoute => Remove duplicates & get exercise

ExpressAPI/src/routes/ExerciseRoutes.ts

@@ -70,16 +70,16 @@ class ExerciseRoutes implements RoutesManager {
 
         backend.get('/exercises', SecurityMiddleware.check(true, SecurityCheckType.ADMIN), this.getAllExercises.bind(this) as RequestHandler);
         backend.get('/exercises/:exerciseIdOrUrl/assignment', SecurityMiddleware.check(false, SecurityCheckType.EXERCISE_SECRET), this.getAssignment.bind(this) as RequestHandler);
+        backend.get('/exercises/:exerciseIdOrUrl', SecurityMiddleware.check(true, SecurityCheckType.ADMIN, SecurityCheckType.EXERCISE_MEMBERS), this.getExercise.bind(this) as RequestHandler);
         backend.get('/exercises/:exerciseIdOrUrl/members', SecurityMiddleware.check(true, SecurityCheckType.ADMIN, SecurityCheckType.EXERCISE_MEMBERS), this.getExerciseMembers.bind(this) as RequestHandler);
         backend.get('/exercises/:exerciseIdOrUrl/results', SecurityMiddleware.check(true, SecurityCheckType.ADMIN, SecurityCheckType.EXERCISE_MEMBERS), this.getExerciseResults.bind(this) as RequestHandler);
 
         backend.delete('/exercises/:exerciseIdOrUrl', SecurityMiddleware.check(true, SecurityCheckType.ADMIN, SecurityCheckType.EXERCISE_MEMBERS), this.deleteExercise.bind(this) as RequestHandler);
 
-        backend.post('/exercises/:exerciseIdOrUrl/results', SecurityMiddleware.check(false, SecurityCheckType.EXERCISE_SECRET), ParamsValidatorMiddleware.validate(this.resultValidator), this.createResult.bind(this) as RequestHandler);
-
-        backend.get('/exercises', this.getAllExercises.bind(this));
+        backend.get('/users/:userId/exercises', SecurityMiddleware.check(true), this.getUserExercises.bind(this) as RequestHandler);
 
-        backend.get('/exercises/:exerciseIdOrLink/results', SecurityMiddleware.check(true), this.getExerciseResultsByIdOrLink.bind(this));
+        backend.get('/exercises/:exerciseIdOrLink/results', SecurityMiddleware.check(true), this.getExerciseResultsByIdOrLink.bind(this) as RequestHandler);
+        backend.post('/exercises/:exerciseIdOrUrl/results', SecurityMiddleware.check(false, SecurityCheckType.EXERCISE_SECRET), ParamsValidatorMiddleware.validate(this.resultValidator), this.createResult.bind(this) as RequestHandler);
     }
 
     private async getExerciseResultsByIdOrLink(req: express.Request, res: express.Response) {
@@ -87,30 +87,39 @@ class ExerciseRoutes implements RoutesManager {
 
 
         const exercise = await db.exercise.findFirst({
-            where: {
-                OR: [
-                    { id: exerciseIdOrLink },
-                    { gitlabLink: exerciseIdOrLink }
-                ]
-            }
-        });
+                                                         where: {
+                                                             OR: [ { id: exerciseIdOrLink }, { gitlabLink: exerciseIdOrLink } ]
+                                                         }
+                                                     });
 
-        if (!exercise) {
+        if ( !exercise ) {
             return res.status(StatusCodes.NOT_FOUND).send('Exercise not found');
         }
 
 
         const results = await db.result.findMany({
-            where: { exerciseId: exercise.id },
-        });
+                                                     where: { exerciseId: exercise.id }
+                                                 });
 
         return res.status(StatusCodes.OK).json(results);
     }
 
-
     private async getAllExercises(req: express.Request, res: express.Response) {
-        const exo = await db.exercise.findMany();
-        return req.session.sendResponse(res, StatusCodes.OK, exo);
+        const exos = await db.exercise.findMany();
+
+        return req.session.sendResponse(res, StatusCodes.OK, exos);
+    }
+
+    private async getUserExercises(req: express.Request, res: express.Response) {
+        if ( req.boundParams.user ) {
+            if ( req.session.profile.isAdmin || req.session.profile.id === req.boundParams.user.id ) {
+                return req.session.sendResponse(res, StatusCodes.OK, req.boundParams.user.exercises.filter(exercise => !exercise.deleted));
+            } else {
+                return req.session.sendResponse(res, StatusCodes.FORBIDDEN);
+            }
+        } else {
+            return req.session.sendResponse(res, StatusCodes.NOT_FOUND);
+        }
     }
 
     private getExerciseName(assignment: Assignment, members: Array<Gitlab.UserSchema>, suffix: number): string {
@@ -119,6 +128,10 @@ class ExerciseRoutes implements RoutesManager {
         return `DojoEx - ${ assignment.name } - ${ memberNames }${ suffixString }`;
     }
 
+    private async getExercise(req: express.Request, res: express.Response) {
+        return req.session.sendResponse(res, StatusCodes.OK, req.boundParams.exercise!);
+    }
+
     private async getExerciseMembers(req: express.Request, res: express.Response) {
         const repoId = req.boundParams.exercise!.gitlabId;
 
@@ -168,13 +181,6 @@ class ExerciseRoutes implements RoutesManager {
         return `dojo-ex_${ (assignment.gitlabLastInfo as unknown as Gitlab.ProjectSchema).path }_${ exerciseId }`;
     }
 
-    // Get all exercise
-    private async getAllExercises(req: express.Request, res: express.Response) {
-        const exos = await db.exercise.findMany();
-
-        return req.session.sendResponse(res, StatusCodes.OK, exos);
-    }
-
 
     private async checkExerciseLimit(assignment: Assignment, members: Array<Gitlab.UserSchema>): Promise<Array<Gitlab.UserSchema>> {
         const exercises: Array<Exercise> | undefined = await ExerciseManager.getFromAssignment(assignment.name, false, { members: true });
@@ -260,33 +266,42 @@ class ExerciseRoutes implements RoutesManager {
 
             await repoCreationFnExec(async () => Promise.all([ ...new Set([ ...assignment.staff, ...params.members ].map(member => member.id)) ].map(GlobalHelper.addRepoMember(repository.id))), 'Add repository members error');
 
-            const exercise: Exercise = await repoCreationFnExec(() => db.exercise.create({
-                                                                                             data: {
-                                                                                                 id                : exerciseId,
-                                                                                                 assignmentName    : assignment.name,
-                                                                                                 name              : repository.name,
-                                                                                                 secret            : secret,
-                                                                                                 gitlabId          : repository.id,
-                                                                                                 gitlabLink        : repository.web_url,
-                                                                                                 gitlabCreationInfo: repository as unknown as Prisma.JsonObject,
-                                                                                                 gitlabCreationDate: new Date(),
-                                                                                                 gitlabLastInfo    : repository as unknown as Prisma.JsonObject,
-                                                                                                 gitlabLastInfoDate: new Date(),
-                                                                                                 members           : {
-                                                                                                     connectOrCreate: [ ...params.members.map(gitlabUser => {
-                                                                                                         return {
-                                                                                                             create: {
-                                                                                                                 id            : gitlabUser.id,
-                                                                                                                 gitlabUsername: gitlabUser.name
-                                                                                                             },
-                                                                                                             where : {
-                                                                                                                 id: gitlabUser.id
-                                                                                                             }
-                                                                                                         };
-                                                                                                     }) ]
-                                                                                                 }
-                                                                                             }
-                                                                                         })) as Exercise;
+            let exercise: Exercise = await repoCreationFnExec(() => db.exercise.create({
+                                                                                           data: {
+                                                                                               id                : exerciseId,
+                                                                                               assignmentName    : assignment.name,
+                                                                                               name              : repository.name,
+                                                                                               secret            : secret,
+                                                                                               gitlabId          : repository.id,
+                                                                                               gitlabLink        : repository.web_url,
+                                                                                               gitlabCreationInfo: repository as unknown as Prisma.JsonObject,
+                                                                                               gitlabCreationDate: new Date(),
+                                                                                               gitlabLastInfo    : repository as unknown as Prisma.JsonObject,
+                                                                                               gitlabLastInfoDate: new Date(),
+                                                                                               members           : {
+                                                                                                   connectOrCreate: [ ...params.members.map(gitlabUser => {
+                                                                                                       return {
+                                                                                                           create: {
+                                                                                                               id            : gitlabUser.id,
+                                                                                                               gitlabUsername: gitlabUser.name
+                                                                                                           },
+                                                                                                           where : {
+                                                                                                               id: gitlabUser.id
+                                                                                                           }
+                                                                                                       };
+                                                                                                   }) ]
+                                                                                               }
+                                                                                           }
+                                                                                       })) as Exercise;
+
+            exercise = await ExerciseManager.get(exercise.id, {
+                members   : true,
+                assignment: {
+                    include: {
+                        staff: true
+                    }
+                }
+            }) as Exercise;
 
             req.session.sendResponse(res, StatusCodes.OK, exercise);
             return;