feat: Tracking is now fully functionnal except PDF upload part (TODO by Amine)

src/config/index.ts

 import { IConfig } from './config.model';
 import { readFileSync } from 'fs';
 import * as path from 'path';
+import { exit } from 'process';
 
 // Store file local path in var for lisibility
 const CONFIG_DEV = 'config.json';
@@ -22,10 +23,11 @@ switch (process.env.NODE_ENV) {
     ) as IConfig;
     break;
   default:
-    // This shouldn't happen
-    console.log('\x1b[31mFATAL: Cannot load config.\x1b[0m');
-    config = null;
-    break;
+    // This happens when the environment isn't set
+    console.log(
+      '\x1b[31mFATAL: Cannot load config.\nInvalid application environment. Did you read the \x1b[4mREADME\x1b[0m\x1b[31m ?\x1b[0m',
+    );
+    exit(-1);
 }
 
 // Export config

src/internships/dao/internships.dao.ts

 import { Injectable, NotFoundException } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
-import { BAD_REQUEST, CONFLICT, INTERNAL } from 'src/shared/HttpError';
-import { STATE_STUDENT_ENTERS_INTERNSHIP_INFORMATION } from 'src/shared/InternshipState';
+import { BAD_REQUEST, CONFLICT } from 'src/shared/HttpError';
+import {
+  isStateValid,
+  STATE_COMPANY_SIGNS_INTERNSHIP_AGREEMENT,
+  STATE_DEAN_SIGNS_INTERNSHIP_AGREEMENT,
+  STATE_RESPONSIBLE_ACCEPTS_INTERNSHIP_INFORMATION,
+  STATE_RESPONSIBLE_SIGNS_INTERNSHIP_AGREEMENT,
+  STATE_SECRETARY_ESTABLISHES_INTERNSHIP_AGREEMENT,
+  STATE_STUDENT_ENTERS_INTERNSHIP_INFORMATION,
+  STATE_STUDENT_SIGNS_INTERNSHIP_AGREEMENT,
+} from 'src/shared/InternshipState';
 import { CreateInternshipDto } from '../dto/create-internship.dto';
 import { InternshipDto } from '../dto/internship.dto';
 import { Internship } from '../schemas/internship.schema';
@@ -78,6 +87,128 @@ export class InternshipDao {
       );
     });
 
+  private updateTrackingState = (
+    studentId: string,
+    state: string,
+    nextState: string,
+    contentHolder: string,
+    content: string | boolean,
+    callback: (err: any, value: any) => void,
+  ) => {
+    this._internshipModel.findOneAndUpdate(
+      {
+        studentId,
+        'tracking.state': state,
+      },
+      {
+        $set: {
+          'tracking.state': nextState,
+          [contentHolder]: content,
+        },
+      },
+      {
+        new: true,
+        runValidators: true,
+      },
+      callback,
+    );
+  };
+
+  findByStudentIdAndUpdateTracking = (
+    studentId: string,
+    state: string,
+    content: string | boolean,
+  ): Promise<Internship | void> =>
+    new Promise((resolve, reject) => {
+      if (!isStateValid(state)) reject(BAD_REQUEST);
+      console.log(typeof content);
+      let nextState: string, contentHolder: string;
+      let valid = false;
+      switch (state) {
+        case STATE_STUDENT_ENTERS_INTERNSHIP_INFORMATION: {
+          if (typeof content === 'boolean' && content === true) {
+            nextState = STATE_RESPONSIBLE_ACCEPTS_INTERNSHIP_INFORMATION;
+            contentHolder = 'tracking.studentEntersInternshipInformation';
+            valid = true;
+          } else reject(BAD_REQUEST);
+          break;
+        }
+        case STATE_RESPONSIBLE_ACCEPTS_INTERNSHIP_INFORMATION: {
+          if (typeof content === 'boolean' && content === true) {
+            // content === true -> Responsible agrees with internship
+            nextState = STATE_SECRETARY_ESTABLISHES_INTERNSHIP_AGREEMENT;
+            contentHolder = 'tracking.responsibleAcceptsInternshipInformation';
+            valid = true;
+          } else if (typeof content === 'boolean' && content === false) {
+            // content === false -> Responsible did not agree with internship, go back to student entering information
+            nextState = STATE_STUDENT_ENTERS_INTERNSHIP_INFORMATION;
+            contentHolder = 'tracking.responsibleAcceptsInternshipInformation';
+            valid = true;
+          } else reject(BAD_REQUEST);
+          break;
+        }
+        case STATE_SECRETARY_ESTABLISHES_INTERNSHIP_AGREEMENT: {
+          if (typeof content !== 'string') reject(BAD_REQUEST);
+          else {
+            nextState = STATE_STUDENT_SIGNS_INTERNSHIP_AGREEMENT;
+            contentHolder = 'tracking.secretaryEstablishesInternshipAgreement';
+            valid = true;
+          }
+          break;
+        }
+        case STATE_STUDENT_SIGNS_INTERNSHIP_AGREEMENT: {
+          if (typeof content !== 'string') reject(BAD_REQUEST);
+          else {
+            nextState = STATE_RESPONSIBLE_SIGNS_INTERNSHIP_AGREEMENT;
+            contentHolder = 'tracking.studentSignsInternshipAgreement';
+            valid = true;
+          }
+          break;
+        }
+        case STATE_RESPONSIBLE_SIGNS_INTERNSHIP_AGREEMENT: {
+          if (typeof content !== 'string') reject(BAD_REQUEST);
+          else {
+            nextState = STATE_COMPANY_SIGNS_INTERNSHIP_AGREEMENT;
+            contentHolder = 'tracking.responsibleSignsInternshipAgreement';
+            valid = true;
+          }
+          break;
+        }
+        case STATE_COMPANY_SIGNS_INTERNSHIP_AGREEMENT: {
+          if (typeof content !== 'string') reject(BAD_REQUEST);
+          else {
+            nextState = STATE_DEAN_SIGNS_INTERNSHIP_AGREEMENT;
+            contentHolder = 'tracking.companySignsInternshipAgreement';
+            valid = true;
+          }
+          break;
+        }
+        case STATE_DEAN_SIGNS_INTERNSHIP_AGREEMENT: {
+          if (typeof content !== 'string') reject(BAD_REQUEST);
+          else {
+            nextState = '/';
+            contentHolder = 'tracking.deanSignsInternshipAgreement';
+            valid = true;
+          }
+          break;
+        }
+      }
+      if (valid) {
+        this.updateTrackingState(
+          studentId,
+          state,
+          nextState,
+          contentHolder,
+          content,
+          (err, value) => {
+            if (err) reject(err);
+            else if (!value) reject(BAD_REQUEST);
+            else resolve(value);
+          },
+        );
+      }
+    });
+
   findByStudentIdAndRemove = (studentId: string): Promise<Internship | void> =>
     new Promise((resolve, reject) => {
       this._internshipModel.findOneAndDelete({ studentId }, {}, (err) => {

src/internships/internships.controller.ts

@@ -18,25 +18,25 @@ import { InternshipService } from './internships.service';
 @Controller('internships')
 @UseInterceptors(HttpInterceptor)
 export class InternshipsController {
-  constructor(private readonly _groupsService: InternshipService) {}
+  constructor(private readonly _internshipsService: InternshipService) {}
 
   @Get()
   findAll(): Promise<InternshipEntity[] | void> {
-    return this._groupsService.findAll();
+    return this._internshipsService.findAll();
   }
 
   @Get(':studentId')
   findOne(
     @Param() params: { studentId: string },
   ): Promise<InternshipEntity | void> {
-    return this._groupsService.findOne(params.studentId);
+    return this._internshipsService.findOne(params.studentId);
   }
 
   @Post()
   create(
     @Body() internshipDto: CreateInternshipDto,
   ): Promise<InternshipEntity> {
-    return this._groupsService.create(internshipDto);
+    return this._internshipsService.create(internshipDto);
   }
 
   @Put(':studentId')
@@ -44,23 +44,28 @@ export class InternshipsController {
     @Param() params: { studentId: string },
     @Body() internshipDto: CreateInternshipDto,
   ): Promise<InternshipEntity | void> {
-    return this._groupsService.update(params.studentId, internshipDto);
+    return this._internshipsService.update(params.studentId, internshipDto);
   }
 
   @Put(':studentId/tracking')
   updateState(
     @Param() params: { studentId: string },
-    @Body() body: { state: string; content: string },
-  ) {
+    @Body() body: { state: string; content?: string | boolean },
+  ): Promise<InternshipEntity | void> {
     if (!InternshipStates.isStateValid(body.state))
       throw BAD_TRACKING_STATE(body.state);
-    // Treat request and update tracking -> implement service + dao
+    // AMINE : Handle PDF file upload -> save file in /pdf/ folder and set content as local file URL. In case of step with no file, set content as true/false
+    return this._internshipsService.updateTracking(
+      params.studentId,
+      body.state,
+      body.content,
+    );
   }
 
   @Delete(':studentId')
   delete(
     @Param() params: { studentId: string },
   ): Promise<InternshipEntity | void> {
-    return this._groupsService.delete(params.studentId);
+    return this._internshipsService.delete(params.studentId);
   }
 }

src/internships/internships.service.ts

@@ -22,6 +22,17 @@ export class InternshipService {
   ): Promise<InternshipEntity | void> =>
     this._internshipsDao.findByStudentIdAndUpdate(studentId, internship);
 
+  updateTracking = (
+    studentId: string,
+    state: string,
+    content: string | boolean,
+  ): Promise<InternshipEntity | void> =>
+    this._internshipsDao.findByStudentIdAndUpdateTracking(
+      studentId,
+      state,
+      content,
+    );
+
   delete = (studentId: string): Promise<InternshipEntity | void> =>
     this._internshipsDao.findByStudentIdAndRemove(studentId);
 }

src/main.ts

 import { ValidationPipe } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
-import { exit } from 'process';
 import { AppModule } from './app.module';
 import config from './config';
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
   const env = process.env.NODE_ENV;
+  const app = await NestFactory.create(AppModule);
   if (env === 'dev') {
     app.enableCors();
   } else if (env === 'prod') {
     // enableCors for SPECIFIC origin only, aka the way it's supposed to be
   } else {
-    console.log(
-      '\x1b[31mFATAL: Invalid application environment.\nDid you read the \x1b[4mREADME\x1b[0m\x1b[31m ?\x1b[0m',
-    );
-    exit(-1);
+    // unknown environement ?
   }
   await app.useGlobalPipes(
     new ValidationPipe({