ExpressAPI/src/managers/UserManager.ts

@@ -24,7 +24,7 @@ class UserManager {
                                         }) as unknown as User ?? undefined;
     }
 
-    async getUpdateFromGitlabProfile(gitlabProfile: GitlabProfile, refreshToken: string): Promise<User> {
+    async getUpdateFromGitlabProfile(gitlabProfile: GitlabProfile): Promise<User> {
         await db.user.upsert({
                                  where : {
                                      id: gitlabProfile.id

ExpressAPI/src/middlewares/ClientVersionMiddleware.ts → ExpressAPI/src/middlewares/ClientVersionCheckerMiddleware.ts

@@ -6,7 +6,7 @@ import { HttpStatusCode } from 'axios';
 import DojoStatusCode     from '../shared/types/Dojo/DojoStatusCode';
 
 
-class ClientVersionMiddleware {
+class ClientVersionCheckerMiddleware {
     register(): (req: express.Request, res: express.Response, next: express.NextFunction) => void {
         return async (req: express.Request, res: express.Response, next: express.NextFunction) => {
             if ( req.headers['client'] && req.headers['client-version'] ) {
@@ -32,4 +32,4 @@ class ClientVersionMiddleware {
 }
 
 
-export default new ClientVersionMiddleware();
\ No newline at end of file
+export default new ClientVersionCheckerMiddleware();
\ No newline at end of file

ExpressAPI/src/middlewares/ParamsCallbackManager.ts

@@ -5,16 +5,16 @@ import ExerciseManager   from '../managers/ExerciseManager';
 import AssignmentManager from '../managers/AssignmentManager';
 
 
-type GetFunction = (id: string | number, ...args: Array<any>) => Promise<any>
+type GetFunction = (id: string | number, ...args: Array<unknown>) => Promise<unknown>
 
 
 class ParamsCallbackManager {
-    protected listenParam(paramName: string, backend: Express, getFunction: GetFunction, args: Array<any>, indexName: string) {
+    protected listenParam(paramName: string, backend: Express, getFunction: GetFunction, args: Array<unknown>, indexName: string) {
         backend.param(paramName, (req: express.Request, res: express.Response, next: express.NextFunction, id: string | number) => {
             getFunction(id, ...args).then(result => {
                 if ( result ) {
                     this.initBoundParams(req);
-                    (req.boundParams as any)[indexName] = result;
+                    (req.boundParams as Record<string, unknown>)[indexName] = result;
 
                     next();
                 } else {
@@ -33,7 +33,7 @@ class ParamsCallbackManager {
         }
     }
 
-    register(backend: Express) {
+    registerOnBackend(backend: Express) {
         this.listenParam('assignmentNameOrUrl', backend, (AssignmentManager.get as GetFunction).bind(AssignmentManager), [ {
             exercises: true,
             staff    : true

ExpressAPI/src/middlewares/SecurityMiddleware.ts

@@ -31,7 +31,7 @@ class SecurityMiddleware {
                                 isAllowed = isAllowed || (req.boundParams.assignment?.published ?? false);
                                 break;
                             case SecurityCheckType.EXERCISE_SECRET:
-                                isAllowed = isAllowed || req.headers.authorization?.replace('ExerciseSecret ', '') === req.boundParams.exercise!.secret;
+                                isAllowed = isAllowed || (req.headers.ExerciseSecret as string | undefined) === req.boundParams.exercise!.secret;
                                 break;
                             default:
                                 break;

ExpressAPI/src/middlewares/SessionMiddleware.ts

 import express     from 'express';
 import Session     from '../controllers/Session';
+import { Express } from 'express-serve-static-core';
 
 
 class SessionMiddleware {
-    register(): (req: express.Request, res: express.Response, next: express.NextFunction) => void {
-        return async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+    registerOnBackend(backend: Express) {
+        backend.use(async (req: express.Request, res: express.Response, next: express.NextFunction) => {
             req.session = new Session();
             await req.session.initSession(req, res);
 
             return next();
-        };
+        });
     }
 }
 

ExpressAPI/src/routes/AssignmentRoutes.ts

@@ -49,8 +49,8 @@ class AssignmentRoutes implements RoutesManager {
         backend.get('/assignments/:assignmentNameOrUrl', SecurityMiddleware.check(true), this.getAssignment);
         backend.post('/assignments', SecurityMiddleware.check(true, SecurityCheckType.TEACHING_STAFF), ParamsValidatorMiddleware.validate(this.assignmentValidator), this.createAssignment);
 
-        backend.patch('/assignments/:assignmentNameOrUrl/publish', SecurityMiddleware.check(true, SecurityCheckType.ASSIGNMENT_STAFF), this.changeAssignmentPublishedStatus(true));
-        backend.patch('/assignments/:assignmentNameOrUrl/unpublish', SecurityMiddleware.check(true, SecurityCheckType.ASSIGNMENT_STAFF), this.changeAssignmentPublishedStatus(false));
+        backend.patch('/assignments/:assignmentNameOrUrl/publish', SecurityMiddleware.check(true, SecurityCheckType.ASSIGNMENT_STAFF), this.publishAssignment);
+        backend.patch('/assignments/:assignmentNameOrUrl/unpublish', SecurityMiddleware.check(true, SecurityCheckType.ASSIGNMENT_STAFF), this.unpublishAssignment);
     }
 
     // Get an assignment by its name or gitlab url
@@ -58,18 +58,25 @@ class AssignmentRoutes implements RoutesManager {
         const assignment: Assignment | undefined = req.boundParams.assignment;
 
         if ( assignment && !assignment.published && !await AssignmentManager.isUserAllowedToAccessAssignment(assignment, req.session.profile) ) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.gitlabId;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.gitlabLink;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.gitlabCreationInfo;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.gitlabLastInfo;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.gitlabLastInfoDate;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.staff;
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
             delete assignment.exercises;
         }
@@ -160,6 +167,14 @@ class AssignmentRoutes implements RoutesManager {
         }
     }
 
+    private async publishAssignment(req: express.Request, res: express.Response) {
+        return this.changeAssignmentPublishedStatus(true)(req, res);
+    }
+
+    private async unpublishAssignment(req: express.Request, res: express.Response) {
+        return this.changeAssignmentPublishedStatus(false)(req, res);
+    }
+
     private changeAssignmentPublishedStatus(publish: boolean): (req: express.Request, res: express.Response) => Promise<void> {
         return async (req: express.Request, res: express.Response): Promise<void> => {
             if ( publish ) {

ExpressAPI/src/routes/BaseRoutes.ts

@@ -6,8 +6,16 @@ import RoutesManager   from '../express/RoutesManager';
 
 class BaseRoutes implements RoutesManager {
     registerOnBackend(backend: Express) {
-        backend.get('/', (req: express.Request, res: express.Response) => { res.status(StatusCodes.OK).end(); });
-        backend.get('/health_check', (req: express.Request, res: express.Response) => { res.status(StatusCodes.OK).end(); });
+        backend.get('/', this.homepage);
+        backend.get('/health_check', this.healthCheck);
+    }
+
+    private async homepage(req: express.Request, res: express.Response) {
+        return req.session.sendResponse(res, StatusCodes.OK);
+    }
+
+    private async healthCheck(req: express.Request, res: express.Response) {
+        return req.session.sendResponse(res, StatusCodes.OK);
     }
 }
 

ExpressAPI/src/routes/ExerciseRoutes.ts

@@ -29,6 +29,7 @@ import AssignmentFile            from '../shared/types/Dojo/AssignmentFile';
 import ExerciseResultsFile       from '../shared/types/Dojo/ExerciseResultsFile';
 import DojoStatusCode            from '../shared/types/Dojo/DojoStatusCode';
 import GlobalHelper              from '../helpers/GlobalHelper';
+import { IFileDirStat }          from '../shared/helpers/recursiveFilesStats/RecursiveFilesStats';
 
 
 class ExerciseRoutes implements RoutesManager {
@@ -187,8 +188,8 @@ class ExerciseRoutes implements RoutesManager {
         const repoTree: Array<GitlabTreeFile> = await GitlabManager.getRepositoryTree(req.boundParams.exercise!.assignment.gitlabId);
 
         let assignmentHjsonFile!: GitlabFile;
-        let immutableFiles: Array<GitlabFile> = await Promise.all(Config.assignment.baseFiles.map(async (baseFile: string) => {
-            let file = await GitlabManager.getFile(req.boundParams.exercise!.assignment.gitlabId, baseFile);
+        const immutableFiles: Array<GitlabFile> = await Promise.all(Config.assignment.baseFiles.map(async (baseFile: string) => {
+            const file = await GitlabManager.getFile(req.boundParams.exercise!.assignment.gitlabId, baseFile);
 
             if ( baseFile === Config.assignment.filename ) {
                 assignmentHjsonFile = file;
@@ -220,7 +221,7 @@ class ExerciseRoutes implements RoutesManager {
     }
 
     private async createResult(req: express.Request, res: express.Response) {
-        const params: { exitCode: number, commit: any, results: ExerciseResultsFile, files: any, archiveBase64: string } = req.body;
+        const params: { exitCode: number, commit: Record<string, string>, results: ExerciseResultsFile, files: Array<IFileDirStat>, archiveBase64: string } = req.body;
         const exercise: Exercise = req.boundParams.exercise!;
 
         const result = await db.result.create({

ExpressAPI/src/routes/GitlabRoutes.ts

@@ -8,13 +8,13 @@ import GitlabManager      from '../managers/GitlabManager';
 
 class GitlabRoutes implements RoutesManager {
     registerOnBackend(backend: Express) {
-        backend.get('/gitlab/project/:idOrNamespace/checkTemplateAccess', SecurityMiddleware.check(true, SecurityCheckType.TEACHING_STAFF), this.checkTemplateAccess);
+        backend.get('/gitlab/project/:gitlabProjectIdOrNamespace/checkTemplateAccess', SecurityMiddleware.check(true, SecurityCheckType.TEACHING_STAFF), this.checkTemplateAccess);
     }
 
     private async checkTemplateAccess(req: express.Request, res: express.Response) {
-        const idOrNamespace: string = req.params.idOrNamespace;
+        const gitlabProjectIdOrNamespace: string = req.params.gitlabProjectIdOrNamespace;
 
-        return res.status(await GitlabManager.checkTemplateAccess(idOrNamespace, req)).send();
+        return res.status(await GitlabManager.checkTemplateAccess(gitlabProjectIdOrNamespace, req)).send();
     }
 }
 

ExpressAPI/src/routes/SessionRoutes.ts

@@ -34,7 +34,7 @@ class SessionRoutes implements RoutesManager {
     registerOnBackend(backend: Express) {
         backend.post('/login', ParamsValidatorMiddleware.validate(this.loginValidator), this.login);
         backend.post('/refresh_tokens', ParamsValidatorMiddleware.validate(this.refreshTokensValidator), this.refreshTokens);
-        backend.get('/test_session', SecurityMiddleware.check(true), (req: express.Request, res: express.Response) => req.session.sendResponse(res, StatusCodes.OK));
+        backend.get('/test_session', SecurityMiddleware.check(true), this.testSession);
     }
 
     private async login(req: express.Request, res: express.Response) {
@@ -46,7 +46,7 @@ class SessionRoutes implements RoutesManager {
             const gitlabUser = await GitlabManager.getUserProfile(params.accessToken);
 
             if ( gitlabUser ) {
-                req.session.profile = await UserManager.getUpdateFromGitlabProfile(gitlabUser, params.refreshToken);
+                req.session.profile = await UserManager.getUpdateFromGitlabProfile(gitlabUser);
 
                 req.session.sendResponse(res, StatusCodes.OK);
                 return;
@@ -71,6 +71,10 @@ class SessionRoutes implements RoutesManager {
             req.session.sendResponse(res, StatusCodes.INTERNAL_SERVER_ERROR, {}, 'Unknown error while refresh tokens', DojoStatusCode.REFRESH_TOKENS_FAILED);
         }
     }
+
+    private async testSession(req: express.Request, res: express.Response) {
+        req.session.sendResponse(res, StatusCodes.OK);
+    }
 }
 
 

shared @ 101cc268

-Subproject commit 4a5eb68209ae9204b6d4cc8020bd62cf6a5be989
+Subproject commit 101cc26895eb0b5fe97e03bb96039e0cddd94391