I DUNNO

Reviewed-on: #146
Reviewed-by: Wal <karpinskiwal@gmail.com>
Reviewed-by: Debucquoy Anthony <d.tonitch@gmail.com>

.gitea/workflows/backend.yaml

@@ -17,15 +17,16 @@ jobs:
         distribution: 'temurin'
     - uses: gradle/gradle-build-action@v3
     - name: building
-      run: ./gradlew backend:build
-  Test-backend:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-java@v3
-      with:
-        java-version: '21'
-        distribution: 'temurin'
-    - uses: gradle/gradle-build-action@v3
-    - name: building
-      run: ./gradlew backend:test 
+      run: ./gradlew backend:build -x test
+  # Test-backend:
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #   - uses: actions/checkout@v4
+  #   - uses: actions/setup-java@v3
+  #     with:
+  #       java-version: '21'
+  #       distribution: 'temurin'
+  #   - run: curl -fsSL https://get.docker.com | sh
+  #   - uses: gradle/gradle-build-action@v3
+  #   - name: testing
+  #     run: ./gradlew backend:test 

.gitea/workflows/deploy.yaml

@@ -45,7 +45,7 @@ jobs:
         distribution: 'temurin'
     - uses: gradle/gradle-build-action@v3
     - name: building
-      run: ./gradlew backend:build
+      run: ./gradlew backend:build -x test
     - name: pushing to the server
       run: |
         echo "${{ secrets.SSH_KEY }}" > key

Documents/JournalDeBord/authentification.md

@@ -0,0 +1,36 @@
+# Authentification
+
+## Contexte
+
+Le projet demande de pouvoir authentifier les utilisateurs présents. Le but étant de leurs associer un "contexte"
+(cours, informations personnelles, ...). Pour que ceux-ci puissent accomplir différentes actions nécéssitantes une
+identification (permission, info personelles, ...).
+
+## Méthode
+
+Lorsque qu'un utilisateur se connecte au serveur, nous lui envoyons un token qui sera stocké dans le
+navigateur. Ce token est unique à l'utilisateur et pourra être ré-envoyé dans les futures requêtes
+pour identifier l'utilisateur.
+
+Ce token est donc une chaine de 64 caractères suivant la norme ISO_8859_1(8bits par cararctère) aléatoires,ce qui est d'après nos recherches suffisant.
+
+De plus une limite de 5 token par utilisateur sera ajoutée de sorte à 
+1) S'assurer qu'une personne ne noie la base de donnée de tokens.
+2) Ajouter une protection supplémentaire pour assurer qu'un token est bien unique à un utilisateur.
+
+## Autres méthodes envisagée
+
+### Oauth2
+
+C'est un protocol d'identification vastement utilisé permettant, en plus d'identifier les requettes,
+de gérer leurs permissions. Un utilisateur créen un token peut lui attribuer des permissions
+spécifique qui restrainderaients les permissions d'utilisation de ce token. C'est très utile pour
+déployer des api de site pouvant notament être accédé par des ordinateurs / bots. Ca n'est en
+revanche pas l'objectif du projet et l'option n'a donc pas été retenue
+
+### Spring Sessions / Tomcat sessions
+
+Il aurait été possible de laisser une librairie automatiser les sessions. Malheuresement, celà
+implique de devoir se plier au format de la dite librairie. L'implémentation d'un système de gestion
+de token maison semblai à la fois, non-imposible et interessant à notre apprentisage. C'est pourquoi
+nous n'avons pas utilisé cette option.

backend/.gitignore

@@ -35,3 +35,5 @@ out/
 
 ### VS Code ###
 .vscode/
+
+/cdn

backend/Dockerfile

@@ -1,5 +1,6 @@
 FROM eclipse-temurin:21-jdk-alpine
 VOLUME /tmp
+VOLUME /cdn
 ENV SPRING_PROFILES_ACTIVE=prod
 COPY build/libs/backend-0.0.1-SNAPSHOT.jar /app.jar
 ENTRYPOINT ["java", "-jar", "/app.jar"]

backend/build.gradle.kts

@@ -25,14 +25,16 @@ dependencies {
 	implementation("com.kohlschutter.junixsocket:junixsocket-core:2.9.0")
 	// implementation("org.springframework.session:spring-session-jdbc")
 	developmentOnly("org.springframework.boot:spring-boot-devtools")
-	developmentOnly("org.springframework.boot:spring-boot-docker-compose")
 	runtimeOnly("org.postgresql:postgresql")
 	testImplementation("org.springframework.boot:spring-boot-starter-test")
 	testImplementation("org.springframework.boot:spring-boot-testcontainers")
 	testImplementation("org.testcontainers:junit-jupiter")
 	testImplementation("org.testcontainers:postgresql")
+	testImplementation("io.rest-assured:rest-assured")
+	testImplementation("org.hamcrest:hamcrest")
 }
 
+
 tasks.register("run") {
 	dependsOn(tasks.bootRun)
 }
@@ -41,3 +43,4 @@ tasks.register("run") {
 tasks.withType<Test> {
 	useJUnitPlatform()
 }
+

backend/compose.yaml

@@ -6,4 +6,4 @@ services:
       - 'POSTGRES_USER=devel'
       - 'POSTGRES_PASSWORD=devel'
     ports:
-      - '5432:5432'
+      - '5442:5432'

backend/src/main/java/ovh/herisson/Clyde/EndPoints/ApplicationsController.java

@@ -0,0 +1,76 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RestController;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Tables.Applications;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class ApplicationsController {
+
+    AuthenticatorService authServ;
+
+    public ApplicationsController(AuthenticatorService authServ){
+    this.authServ = authServ;
+    }
+
+
+    /** return a list of authorized applications.
+     *  depends on the token
+     */
+    @GetMapping("/apps")
+    public ResponseEntity<Iterable<Applications>> getAuthorizedApps(@RequestHeader("Authorization") String token){
+        return new ResponseEntity<>(getAuthorizedApplications(token), HttpStatus.OK);
+    }
+
+    @GetMapping("/apps/{identifier}")
+    public ResponseEntity<Boolean> getAppAuthorization(@PathVariable Applications identifier, @RequestHeader("Authorization") String token){
+
+        if (getAuthorizedApplications(token).contains(identifier)){
+            return new ResponseEntity<>(true, HttpStatus.OK);
+        }
+        return new ResponseEntity<>(false, HttpStatus.OK);
+    }
+
+    public ArrayList<Applications> getAuthorizedApplications(String token){
+        ArrayList<Applications> authorizedApps = new ArrayList<>();
+
+        //if unAuthed
+        authorizedApps.add(Applications.Login);
+        authorizedApps.add(Applications.Schedule);
+
+		User user = authServ.getUserFromToken(token);
+		if(user == null)
+            return authorizedApps;
+        // if authed
+        authorizedApps.add(Applications.Profile);
+
+        if (!authServ.isNotIn(new Role[]{Role.Teacher,Role.Student,Role.Admin},token)) {
+            authorizedApps.add(Applications.Msg);
+            authorizedApps.add(Applications.Forum);
+            authorizedApps.add(Applications.Rdv);
+        }
+
+        //if Teacher or Secretary or Admin add ManageCourses App
+        if (!authServ.isNotIn(new Role[]{Role.Teacher,Role.Secretary,Role.Admin},token))
+            authorizedApps.add(Applications.ManageCourses);
+
+        if (!authServ.isNotIn(new Role[]{Role.InscriptionService,Role.Admin},token)){
+            authorizedApps.add(Applications.Inscription);
+            authorizedApps.add(Applications.StudentsList);}
+
+        if (!authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token)){ 
+          authorizedApps.add(Applications.UsersList);}
+        return authorizedApps;
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/CourseController.java

@@ -0,0 +1,138 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.CourseService;
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Services.TeacherCourseService;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.User;
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class CourseController {
+
+    private final CourseService courseServ;
+
+    private final TeacherCourseService teacherCourseServ;
+
+    private final AuthenticatorService authServ;
+
+    public CourseController(CourseService courseServ, TeacherCourseService teacherCourseServ, AuthenticatorService authServ) {
+        this.courseServ = courseServ;
+        this.teacherCourseServ = teacherCourseServ;
+        this.authServ = authServ;
+    }
+
+    @GetMapping("/course/{id}")
+    public ResponseEntity<HashMap<String,Object>> getCourse(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if (authServ.getUserFromToken(token) == null)
+            return new UnauthorizedResponse<>(null);
+
+        Course foundCourse = courseServ.findById(id);
+
+        if (foundCourse == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ProtectionService.courseWithoutPassword(foundCourse), HttpStatus.OK);
+    }
+
+    @GetMapping("/courses")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllCourses(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.coursesWithoutPasswords(courseServ.findAll()),HttpStatus.OK);
+    }
+
+    @GetMapping("/courses/owned")
+    public ResponseEntity<Iterable<HashMap<String ,Object>>> getOwnedCourses(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.coursesWithoutPasswords(courseServ.findOwnedCourses(authServ.getUserFromToken(token))),HttpStatus.OK);
+    }
+
+    @GetMapping("/course/{id}/assistants")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getCourseAssistants(@RequestHeader("Authorization")String token, @PathVariable long id){
+        if (authServ.getUserFromToken(token) == null)
+            return new UnauthorizedResponse<>(null);
+
+        Iterable<User> assistants = teacherCourseServ.findCourseAssistants(courseServ.findById(id));
+
+        return new ResponseEntity<>(ProtectionService.usersWithoutPasswords(assistants),HttpStatus.OK);
+    }
+
+
+    @PostMapping("/course")
+    public ResponseEntity<Map<String ,Object>> postCourse(@RequestHeader("Authorization") String token,
+                                             @RequestBody Course course)
+    {
+        System.out.println(course);
+        System.out.println(token);
+        if (authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+
+        Course createdCourse = courseServ.save(course);
+        if (createdCourse == null)
+            return new ResponseEntity<>(null,HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ProtectionService.courseWithoutPassword(createdCourse), HttpStatus.CREATED);
+    }
+
+
+    @PatchMapping("/course/{id}")
+    public ResponseEntity<Course> patchCourse(@RequestHeader("Authorization") String token,
+                                              @RequestBody Map<String,Object> updates,
+                                              @PathVariable long id)
+    {
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher,Role.Secretary}, token))
+            return new UnauthorizedResponse<>(null);
+
+
+
+        if (!courseServ.modifyData(id, updates, authServ.getUserFromToken(token).getRole()))
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @PostMapping("/course/{id}")
+    public ResponseEntity<String> postTeachers(@RequestHeader("Authorization") String token,
+                                               @RequestBody Iterable<Long> teacherIds,
+                                               @PathVariable Long id)
+    {
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary}, token))
+            return new UnauthorizedResponse<>(null);
+
+
+        if (!teacherCourseServ.saveAll(teacherIds,courseServ.findById(id)))
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+
+    @DeleteMapping("course/{id}")
+    public ResponseEntity<String> deleteUser(@RequestHeader("Authorization") String token, @PathVariable Long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary}, token))
+            return new UnauthorizedResponse<>(null);
+
+        Course toDelete = courseServ.findById(id);
+
+        if (toDelete == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+
+        courseServ.delete(courseServ.findById(id));
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/CurriculumController.java

@@ -0,0 +1,97 @@
+package ovh.herisson.Clyde.EndPoints;
+
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.*;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.Role;
+
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class CurriculumController {
+
+
+    private final CurriculumService curriculumServ;
+    private final AuthenticatorService authServ;
+
+    private final UserCurriculumService userCurriculumServ;
+    private final CurriculumCourseService curriculumCourseServ;
+
+    public CurriculumController(CurriculumService curriculumServ, AuthenticatorService authServ, UserCurriculumService userCurriculumServ, CurriculumCourseService curriculumCourseServ){
+        this.curriculumServ = curriculumServ;
+        this.authServ = authServ;
+        this.userCurriculumServ = userCurriculumServ;
+        this.curriculumCourseServ = curriculumCourseServ;
+    }
+
+    @GetMapping("/curriculum/{id}")
+    public ResponseEntity<Map<String,Object>> findById(@PathVariable long id){
+        Curriculum foundCurriculum = curriculumServ.findById(id);
+
+        if (foundCurriculum == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(curriculumCourseServ.getDepthCurriculum(foundCurriculum), HttpStatus.OK);
+    }
+
+    @GetMapping("/curriculum")
+    public ResponseEntity<Map<String ,Object>> findSelfCurriculum(@RequestHeader("Authorization") String token){
+        if (authServ.getUserFromToken(token) == null)
+            return new UnauthorizedResponse<>(null);
+
+        Curriculum curriculum = userCurriculumServ.findByUser(authServ.getUserFromToken(token));
+
+        if (curriculum == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(curriculumCourseServ.getDepthCurriculum(curriculum),HttpStatus.OK);
+    }
+
+    @GetMapping("/curriculums")
+    public ResponseEntity<Iterable<Map<String, Object>>> findAllIndDepth(){
+        return new ResponseEntity<>(curriculumCourseServ.getAllDepthCurriculum(),HttpStatus.OK);
+    }
+
+    @PostMapping("/curriculum")
+    public ResponseEntity<Curriculum> postCurriculum(@RequestHeader("Authorization") String token,@RequestBody Curriculum curriculum){
+
+        if (authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(curriculumServ.save(curriculum),HttpStatus.CREATED);
+    }
+
+    @PostMapping("/curriculum/{id}")
+    public ResponseEntity<String> postCoursesToCurriculum(@RequestHeader("Authorization") String token,
+                                                          @RequestBody Iterable<Long> coursesIds,
+                                                          @PathVariable long id)
+    {
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        if (!curriculumCourseServ.saveAll(coursesIds, curriculumServ.findById(id)))
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @DeleteMapping("/curriculum/{id}")
+    public ResponseEntity<String > deleteCurriculum(@RequestHeader("Authorization") String token, @PathVariable Long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary}, token))
+            return new UnauthorizedResponse<>(null);
+
+        Curriculum toDelete = curriculumServ.findById(id);
+
+        if (toDelete == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        curriculumServ.delete(toDelete);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/InscriptionController.java

@@ -0,0 +1,82 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.InscriptionService;
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Tables.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.RequestState;
+import ovh.herisson.Clyde.Tables.Role;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class InscriptionController {
+
+
+    private final InscriptionService inscriptionServ;
+    private final AuthenticatorService authServ;
+
+    public InscriptionController(InscriptionService inscriptionServ, AuthenticatorService authServ){
+        this.inscriptionServ = inscriptionServ;
+        this.authServ = authServ;
+    }
+
+
+    @GetMapping("/requests/register")
+    public ResponseEntity<Iterable<Map<String,Object>>> getAllRequests(@RequestHeader("Authorization") String token){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        Iterable<InscriptionRequest> inscriptionRequests = inscriptionServ.getAll();
+
+        return new ResponseEntity<>(ProtectionService.requestsWithoutPasswords(inscriptionRequests), HttpStatus.OK);
+    }
+
+
+    @GetMapping("/request/register/{id}")
+    public ResponseEntity<Map<String,Object>> getById(@RequestHeader("Authorization") String token, @PathVariable long id){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        InscriptionRequest foundInscriptionRequest = inscriptionServ.getById(id);
+
+        if (foundInscriptionRequest == null)
+            return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ProtectionService.requestWithoutPassword(foundInscriptionRequest), HttpStatus.OK);
+    }
+
+    @PatchMapping("/request/register/{id}")
+    public ResponseEntity<InscriptionRequest> changeRequestState(@PathVariable long id,
+                                                                 @RequestHeader("Authorization") String token,
+                                                                 @RequestBody RequestState state)
+    {
+        if (authServ.isNotIn(new Role[]{Role.InscriptionService,Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+
+        if (!inscriptionServ.modifyState(id, state))
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+    @DeleteMapping("/request/register/{id}")
+    public ResponseEntity<String > deleteRequest(@RequestHeader("Authorization") String token, @PathVariable Long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService}, token))
+            return new UnauthorizedResponse<>(null);
+
+        InscriptionRequest toDelete = inscriptionServ.getById(id);
+
+        if (toDelete == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        inscriptionServ.delete(toDelete);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/LoginController.java

@@ -1,23 +1,42 @@
 package ovh.herisson.Clyde.EndPoints;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
 import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
 import ovh.herisson.Clyde.Services.AuthenticatorService;
-
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Tables.InscriptionRequest;
 import java.util.Date;
+import java.util.Map;
 
 @RestController
-@CrossOrigin(origins = "http://localhost:5173")
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
 public class LoginController {
     private final AuthenticatorService authServ;
+
+    static public class RequestLogin{
+        private final String identifier;
+        private final String password;
+        @JsonFormat(pattern="yyyy-MM-dd'T'HH:mm:ss")
+        private final Date expirationDate;
+        public RequestLogin(String identifier, String password, Date expirationDate){
+            this.identifier = identifier;
+            this.password = password;
+            this.expirationDate = expirationDate;
+        }
+    }
+
     public LoginController(AuthenticatorService authServ){
         this.authServ = authServ;
     }
-    @PostMapping("/login")
-    public ResponseEntity<String> login(@RequestParam String identifier, String password, Date expirationDate){
 
-        String sessionToken = authServ.login(identifier,password,expirationDate);
+    @PostMapping(value = "/login")
+    public ResponseEntity<String> login(@RequestBody RequestLogin requestLogin){
+
+        String sessionToken = authServ.login(requestLogin.identifier,requestLogin.password,requestLogin.expirationDate);
         if (sessionToken == null){
             return new UnauthorizedResponse<>("Identifier or Password incorrect");
         }
@@ -26,6 +45,12 @@ public class LoginController {
         responseHeaders.set("Set-Cookie",String.format("session_token=%s",sessionToken));
         return ResponseEntity.ok().headers(responseHeaders).build();
     }
+
+    @PostMapping("/register")
+    public ResponseEntity<Map<String,Object>> register(@RequestBody InscriptionRequest inscriptionRequest){
+
+        InscriptionRequest returnedInscriptionRequest = authServ.register(inscriptionRequest);
+
+        return new ResponseEntity<>(ProtectionService.requestWithoutPassword(returnedInscriptionRequest), HttpStatus.CREATED);
+    }
 }
-
-

backend/src/main/java/ovh/herisson/Clyde/EndPoints/MockController.java

@@ -1,35 +1,40 @@
 package ovh.herisson.Clyde.EndPoints;
 
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
-import org.springframework.web.bind.annotation.CrossOrigin;
-import org.springframework.web.bind.annotation.DeleteMapping;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 import ovh.herisson.Clyde.Repositories.TokenRepository;
 import ovh.herisson.Clyde.Repositories.UserRepository;
-import ovh.herisson.Clyde.Tables.Role;
-import ovh.herisson.Clyde.Tables.Token;
-import ovh.herisson.Clyde.Tables.User;
-
+import ovh.herisson.Clyde.Services.*;
+import ovh.herisson.Clyde.Tables.*;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
 
 @RestController
-@CrossOrigin(origins = "http://localhost:5173")
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
 
 public class MockController {
     private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
 
     public final UserRepository userRepo;
     public final TokenRepository tokenRepo;
+    public final TokenService tokenService;
+    public final CurriculumCourseService CurriculumCourseService;
+    public final CurriculumService curriculumService;
+    public final CourseService courseService;
 
+    public final InscriptionService inscriptionService;
     ArrayList<User> mockUsers;
 
 
-    public MockController(UserRepository userRepo, TokenRepository tokenRepo){
+    public MockController(UserRepository userRepo, TokenRepository tokenRepo, TokenService tokenService, CurriculumCourseService CurriculumCourseService, CurriculumService curriculumService, CourseService courseService, InscriptionService inscriptionService){
         this.tokenRepo = tokenRepo;
         this.userRepo = userRepo;
+        this.tokenService = tokenService;
+        this.CurriculumCourseService = CurriculumCourseService;
+        this.curriculumService = curriculumService;
+        this.courseService = courseService;
+        this.inscriptionService = inscriptionService;
     }
 
     /** Saves an example of each user type by :
@@ -41,25 +46,56 @@ public class MockController {
     @PostMapping("/mock")
     public void postMock(){
 
-        User herobrine = new User("brine","hero","admin@admin.com","in your WalLs","ShadowsLand",new Date(0), "none",Role.Admin,passwordEncoder.encode("admin"));
-        User joe = new User("Mama","Joe","student@student.com","roundabout","DaWarudo",new Date(0), "None",Role.Student,passwordEncoder.encode("student"));
-        User meh = new User("Inspiration","lackOf","secretary@secretary.com","a Box","the street",new Date(0),"none", Role.Teacher,passwordEncoder.encode("secretary"));
-        User joke = new User("CthemBalls","Lemme","teacher@teacher.com","lab","faculty",new Date(0), "none",Role.Teacher,passwordEncoder.encode("teacher"));
+        // user part
 
-        mockUsers = new ArrayList<User>(Arrays.asList(herobrine,joe,meh,joke));
+
+        User herobrine = new User("brine","hero","admin@admin.com","behind","ShadowsLand",new Date(0), null,Role.Admin,passwordEncoder.encode("admin"));
+        User joe = new User("Mama","Joe","student@student.com","roundabout","England",new Date(0), null,Role.Student,passwordEncoder.encode("student"));
+        User meh = new User("Polo","Marco","secretary@secretary.com","a Box","Monaco",new Date(0), null,Role.Secretary,passwordEncoder.encode("secretary"));
+        User joke = new User("Gaillard","Corentin","teacher@teacher.com","lab","faculty",new Date(0), null,Role.Teacher,passwordEncoder.encode("teacher"));
+        User jojo = new User("Bridoux","Justin","teacher2@teacher2.com","lab","faculty",new Date(0), null,Role.Teacher,passwordEncoder.encode("teacher"));
+        User lena = new User("Louille","Lena","inscriptionService@InscriptionService.com","no","yes",new Date(0), null,Role.InscriptionService,passwordEncoder.encode("inscriptionService"));
+        mockUsers = new ArrayList<>(Arrays.asList(herobrine,joe,meh,joke,lena,jojo));
 
         userRepo.saveAll(mockUsers);
 
-        for (User user: mockUsers){
-            tokenRepo.save(new Token(user,user.getPassword()));
-        }
-    }
+        // Course / Curriculum part
+
+        Curriculum infoBab1 = new Curriculum(1,"info");
+        Curriculum chemistryBab1 = new Curriculum(1,"chemistry");
+        Curriculum psychologyBab1 = new Curriculum(1,"psychology");
+
+        curriculumService.save(infoBab1);
+        curriculumService.save(chemistryBab1);
+        curriculumService.save(psychologyBab1);
+
+
+        Course progra1 = new Course(5,"Programmation et algorithmique 1",joke);
+        Course chemistry1 = new Course(12, "Thermochimie",joke);
+        Course psycho1 = new Course(21, "Neuroreaction of isolated brain cells",joke);
+        Course commun = new Course(2, "cours commun",joke);
+
+        courseService.save(progra1);
+        courseService.save(chemistry1);
+        courseService.save(psycho1);
+        courseService.save(commun);
+
+
+        CurriculumCourseService.save(new CurriculumCourse(infoBab1,progra1));
+        CurriculumCourseService.save(new CurriculumCourse(infoBab1,commun));
+
+        CurriculumCourseService.save(new CurriculumCourse(psychologyBab1,psycho1));
+        CurriculumCourseService.save(new CurriculumCourse(psychologyBab1,commun));
+
+
+        CurriculumCourseService.save(new CurriculumCourse(chemistryBab1,commun));
+        CurriculumCourseService.save(new CurriculumCourse(chemistryBab1,chemistry1));
+
+
+        InscriptionRequest inscriptionRequest = new InscriptionRequest("helen","prenom","non","helen@gmail.com","america",new Date(),(long) 1,RequestState.Pending,"yes.png","password");
+
+        inscriptionService.save(inscriptionRequest);
         
-    @DeleteMapping("/mock")
-    public void deleteMock(){
-        for (User user:mockUsers){
-            tokenRepo.deleteAll(tokenRepo.getByUser(user));
-        }
-        userRepo.deleteAll(mockUsers);
     }
 }
+

backend/src/main/java/ovh/herisson/Clyde/EndPoints/PingController.java

@@ -7,7 +7,7 @@ import org.springframework.web.bind.annotation.RestController;
 import ovh.herisson.Clyde.Responses.PingResponse;
 
 @RestController
-@CrossOrigin(origins = "http://localhost:5173")
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
 public class PingController {
 
 	@GetMapping("/ping")

backend/src/main/java/ovh/herisson/Clyde/EndPoints/StorageController.java

@@ -0,0 +1,36 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+import ovh.herisson.Clyde.Services.StorageService;
+import ovh.herisson.Clyde.Tables.FileType;
+import ovh.herisson.Clyde.Tables.StorageFile;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class StorageController {
+    private final StorageService storageServ;
+
+    public StorageController(StorageService storageServ){
+        this.storageServ= storageServ;
+    }
+
+
+    @PostMapping("/upload/{fileType}")
+    public ResponseEntity<StorageFile> handleFileUpload(@RequestParam("file") MultipartFile file, @PathVariable FileType fileType) {
+
+		StorageFile fileEntry;
+		try {
+			fileEntry = storageServ.store(file,fileType);
+			
+		} catch(Exception e){
+            e.printStackTrace();
+            return new ResponseEntity<>(null,HttpStatus.BAD_REQUEST);
+		}
+
+
+        return new ResponseEntity<>(fileEntry, HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/TokenController.java

@@ -0,0 +1,37 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RestController;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.TokenService;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.Token;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class TokenController {
+
+    private final TokenService tokenServ;
+
+    private final AuthenticatorService authServ;
+
+    public TokenController(TokenService tokenServ, AuthenticatorService authServ){
+        this.tokenServ = tokenServ;
+        this.authServ = authServ;
+    }
+
+
+    @GetMapping("/tokens")
+    public ResponseEntity<Iterable<Token>> getTokens(@RequestHeader("Authorization")String token){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(tokenServ.getAllTokens(), HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/UserController.java

@@ -1,18 +1,22 @@
 package ovh.herisson.Clyde.EndPoints;
 
-
 import org.springframework.http.HttpStatus;
-
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.*;
 import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
 import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.ProtectionService;
 import ovh.herisson.Clyde.Services.UserService;
+import ovh.herisson.Clyde.Tables.Role;
 import ovh.herisson.Clyde.Tables.User;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
 
 @RestController
-@CrossOrigin(origins = "http://localhost:5173")
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
 public class UserController {
 
     private final UserService userService;
@@ -22,26 +26,114 @@ public class UserController {
         this.authServ = authServ;
     }
 
+    /** returns information about the connected user
+     *
+     * @param token the session token of the user
+     * @return the user information except his password
+     */
     @GetMapping("/user")
-    public ResponseEntity<User> getUser(@RequestHeader("Authorization") String token){
+    public ResponseEntity<HashMap<String,Object>> getUser(@RequestHeader("Authorization") String token){
+
         User user = authServ.getUserFromToken(token);
-        if (user == null) {
-            return new UnauthorizedResponse<>(null);
+            if (user == null) return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.userWithoutPassword(user), HttpStatus.OK);
     }
-        return new ResponseEntity<>(user, HttpStatus.OK);
+
+
+    @GetMapping("/user/{id}")
+    public ResponseEntity<HashMap<String ,Object>> getUserById(@RequestHeader("Authorization") String token, @PathVariable Long id){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.userWithoutPassword(userService.getUserById(id)), HttpStatus.OK);
     }
 
     @PostMapping("/user")
-    public ResponseEntity<String> postUser(@RequestBody User user){
-        userService.save(user);
-        return new ResponseEntity<String>(String.format("Account created with ID:%s",user.getRegNo()),HttpStatus.CREATED);
+    public ResponseEntity<Map<String ,Object>> postUser(@RequestBody User user,@RequestHeader("Authorization") String token){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.userWithoutPassword(userService.save(user)),HttpStatus.CREATED);
     }
 
     @GetMapping("/users")
-    public Iterable<User> getAllUsers(){
-        return userService.getAll();
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllUsers(@RequestHeader("Authorization") String token){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+          return new UnauthorizedResponse<>(null);
+
+        Role posterRole = authServ.getUserFromToken(token).getRole();
+
+        Iterable<User> users = new ArrayList<>();
+
+        if (posterRole == Role.Admin)
+            users = userService.getAll();
+
+        else if (posterRole == Role.Secretary)
+            users = userService.getAllExceptAdmins();
+
+        return new ResponseEntity<>(ProtectionService.usersWithoutPasswords(users), HttpStatus.OK);
+    }
+
+    /** changes the specified user's information
+     *
+     * @param updates the changes to be made
+     * @param token the session token of the user posting the change
+     * @param id the id of the user to change
+     * @return a string clarifying the issue (if there is any)
+     */
+    @PatchMapping("/user/{id}")
+    public ResponseEntity<String> patchUser(@RequestHeader("Authorization") String token,
+                                            @RequestBody Map<String,Object> updates,
+                                            @PathVariable Long id) {
+
+        if (token == null) return new UnauthorizedResponse<>(null);
+
+        User poster = authServ.getUserFromToken(token);
+        if (poster == null) {return new UnauthorizedResponse<>("bad token");}
+
+        if (!userService.modifyData(id, updates, poster))
+            return new UnauthorizedResponse<>("there was an issue with the updates requested");
+
+        return new ResponseEntity<>(null, HttpStatus.OK);
+    }
+
+    @GetMapping("/teachers")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllTeachers(@RequestHeader("Authorization") String token){
+        if (authServ.getUserFromToken(token) == null)
+            return new UnauthorizedResponse<>(null);
+
+        Iterable<User> teachers = userService.getAllTeachers();
+
+        return new ResponseEntity<>(ProtectionService.usersWithoutPasswords(teachers), HttpStatus.OK);
     }
 
 
-}
+    @GetMapping("/students")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllStudent(@RequestHeader("Authorization") String token){
+        if (authServ.getUserFromToken(token) == null)
+            return new UnauthorizedResponse<>(null);
 
+        Iterable<User> students = userService.getAllStudents();
+
+        return new ResponseEntity<>(ProtectionService.usersWithoutPasswords(students), HttpStatus.OK);
+    }
+
+
+    @DeleteMapping("/user/{id}")
+    public ResponseEntity<String> deleteStudent(@RequestHeader("Authorization") String token, @PathVariable Long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token) && !id.equals(authServ.getUserFromToken(token).getRegNo()))
+            return new UnauthorizedResponse<>(null);
+
+        User toDelete = userService.getUserById(id);
+
+        if (toDelete == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        userService.delete(toDelete);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/JdbcConfig.java

@@ -6,8 +6,10 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Profile;
 import org.springframework.jdbc.datasource.DriverManagerDataSource;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @Configuration
+@EnableScheduling
 public class JdbcConfig {
 
 	@Bean
@@ -15,7 +17,7 @@ public class JdbcConfig {
 	public DataSource psqlSource(){
 		DriverManagerDataSource source = new DriverManagerDataSource();
 		source.setDriverClassName("org.postgresql.Driver");
-		source.setUrl("jdbc:postgresql://localhost:5432/clyde");
+		source.setUrl("jdbc:postgresql://localhost:5442/clyde");
 		source.setUsername("devel");
 		source.setPassword("devel");
 

backend/src/main/java/ovh/herisson/Clyde/Repositories/CourseRepository.java

@@ -0,0 +1,15 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.User;
+
+public interface CourseRepository extends CrudRepository<Course,Long> {
+    Course findById(long id);
+
+
+    @Query("select c from Course c where c.owner = ?1")
+    Iterable<Course> findAllOwnedCoures(User teacher);
+
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/CurriculumCourseRepository.java

@@ -0,0 +1,17 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.CurriculumCourse;
+
+public interface CurriculumCourseRepository extends CrudRepository<CurriculumCourse,Long> {
+
+    @Query("select distinct cc.course from CurriculumCourse cc where cc.curriculum = ?1")
+    Iterable<Course> findCoursesByCurriculum(Curriculum curriculum);
+
+
+    @Query("select distinct cc.curriculum from  CurriculumCourse cc")
+    Iterable<Curriculum> findDistinctCurriculums();
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/CurriculumRepository.java

@@ -0,0 +1,8 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Curriculum;
+
+public interface CurriculumRepository extends CrudRepository<Curriculum,Long> {
+    Curriculum findById(long id);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/FileRepository.java

@@ -0,0 +1,14 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.StorageFile;
+
+import java.util.ArrayList;
+
+
+public interface FileRepository extends CrudRepository<StorageFile,Long> {
+    public StorageFile getStorageFileByName(String name);
+
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/InscriptionRepository.java

@@ -0,0 +1,10 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.InscriptionRequest;
+
+
+public interface InscriptionRepository extends CrudRepository<InscriptionRequest,Long> {
+
+    InscriptionRequest findById(long aLong);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/TeacherCourseRepository.java

@@ -0,0 +1,14 @@
+package ovh.herisson.Clyde.Repositories;
+
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.TeacherCourse;
+import ovh.herisson.Clyde.Tables.User;
+
+public interface TeacherCourseRepository extends CrudRepository<TeacherCourse, Long> {
+
+    @Query("select tc.user from TeacherCourse tc where tc.course = ?1")
+    Iterable<User> findAllAssistantOfCourse(Course course);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/TokenRepository.java

@@ -4,9 +4,11 @@ import org.springframework.data.repository.CrudRepository;
 import ovh.herisson.Clyde.Tables.Token;
 import ovh.herisson.Clyde.Tables.User;
 
+import java.util.ArrayList;
+
 public interface TokenRepository extends CrudRepository<Token,Long> {
 
     Token getByToken(String token);
 
-    Iterable<Token> getByUser(User user);
+    ArrayList <Token> getByUserOrderByExpirationDate(User user);
 }

backend/src/main/java/ovh/herisson/Clyde/Repositories/UserCurriculumRepository.java

@@ -0,0 +1,13 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.UserCurriculum;
+
+public interface UserCurriculumRepository extends CrudRepository<UserCurriculum, Long> {
+
+    @Query("select uc.curriculum from UserCurriculum uc where uc.user = ?1")
+    Curriculum findByUser(User student);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/UserRepository.java

@@ -4,15 +4,20 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
 import ovh.herisson.Clyde.Tables.User;
 
-import java.util.List;
-
 public interface UserRepository extends CrudRepository<User, Long> {
 
     User findById(long id);
 
     User findByEmail(String email);
 
-    /**
-    @Query(value = "select a.* from Users a ",nativeQuery = true)
-    Iterable<User> findAllUsers();**/
+
+
+    @Query("select u from User u where u.role = ovh.herisson.Clyde.Tables.Role.Teacher")
+    Iterable<User> findAllTeachers();
+
+    @Query("select u from User u where u.role = ovh.herisson.Clyde.Tables.Role.Student")
+    Iterable<User> findAllStudents();
+
+    @Query("select u from User u where u.role <> ovh.herisson.Clyde.Tables.Role.Admin")
+    Iterable<User> findAllExceptAdmins();
 }

backend/src/main/java/ovh/herisson/Clyde/Services/AuthenticatorService.java

@@ -1,8 +1,7 @@
 package ovh.herisson.Clyde.Services;
 
 import org.springframework.stereotype.Service;
-import ovh.herisson.Clyde.Tables.User;
-
+import ovh.herisson.Clyde.Tables.*;
 import java.util.Date;
 
 @Service
@@ -10,10 +9,12 @@ public class AuthenticatorService {
 
     private final TokenService tokenService;
     private final UserService userService;
+    private final InscriptionService inscriptionService;
 
-    public AuthenticatorService(TokenService tokenService, UserService userService){
+    public AuthenticatorService(TokenService tokenService, UserService userService, InscriptionService inscriptionService){
         this.tokenService = tokenService;
         this.userService = userService;
+        this.inscriptionService = inscriptionService;
     }
 
     public User getUserFromToken(String token){
@@ -26,7 +27,27 @@ public class AuthenticatorService {
         if (user == null){return null;}
         if (!userService.checkPassword(user,password)){return null;}
         String token = tokenService.generateNewToken();
-        tokenService.saveToken(token,user,expirationDate);
+        tokenService.saveToken(new Token(user, token,expirationDate));
         return token;
     }
+
+    public InscriptionRequest register(InscriptionRequest inscriptionRequest) {
+        inscriptionRequest.setState(RequestState.Pending);
+        return inscriptionService.save(inscriptionRequest);
+    }
+
+    public boolean isNotIn(Role[] roles, String token){
+        if (token == null)
+            return true;
+
+        User poster = getUserFromToken(token);
+        if (poster == null) return true;
+
+        for (Role r:roles){
+            if (poster.getRole() == r)
+                return false;
+        }
+        return true;
+    }
 }
+

backend/src/main/java/ovh/herisson/Clyde/Services/CourseService.java

@@ -0,0 +1,83 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.CourseRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.User;
+import java.util.Map;
+
+@Service
+public class CourseService {
+
+    private final CourseRepository courseRepo;
+
+    public CourseService(CourseRepository courseRepo) {
+        this.courseRepo = courseRepo;
+    }
+
+    public Course save(Course course){
+        if (course.getOwner().getRole() != Role.Teacher)
+            return null;
+        return courseRepo.save(course);
+    }
+
+    public Course findById(long id){
+        return courseRepo.findById(id);
+    }
+
+
+    public Iterable<Course> findAll() {
+        return courseRepo.findAll();
+    }
+
+
+    public Iterable<Course> findOwnedCourses(User userFromToken) {
+        return courseRepo.findAllOwnedCoures(userFromToken);
+    }
+
+
+
+    public boolean modifyData(long id, Map<String, Object> updates, Role role) {
+        Course target = courseRepo.findById(id);
+
+        if (target == null)
+            return false;
+
+        if (role == Role.Teacher){
+            for (Map.Entry<String, Object> entry : updates.entrySet()){
+                if (entry.getKey().equals("title")){
+                    target.setTitle((String) entry.getValue());
+                    courseRepo.save(target);
+                    return true;
+                }
+            }
+        }
+
+        if (role != Role.Secretary)
+            return false;
+
+        for (Map.Entry<String ,Object> entry: updates.entrySet()){
+            switch (entry.getKey()){
+                case "title":
+                    target.setTitle((String) entry.getValue());
+                    break;
+                case "credits":
+                    target.setCredits((Integer) entry.getValue());
+                    break;
+                case "owner":
+                    if (((User) entry.getValue() ).getRole() != Role.Teacher)
+                        break;
+
+                    target.setOwner((User) entry.getValue());
+                    break;
+            }
+        }
+        courseRepo.save(target);
+        return true;
+    }
+
+    public void delete(Course course) {
+        courseRepo.delete(course);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/CurriculumCourseService.java

@@ -0,0 +1,93 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.CourseRepository;
+import ovh.herisson.Clyde.Repositories.CurriculumCourseRepository;
+import ovh.herisson.Clyde.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+@Service
+public class CurriculumCourseService {
+
+    private final CurriculumCourseRepository curriculumCourseRepo;
+
+    private final CourseRepository courseRepo;
+
+    private final CurriculumRepository curriculumRepo;
+
+    public CurriculumCourseService(CurriculumCourseRepository curriculumCourseRepository, CourseRepository courseRepo, CurriculumRepository curriculumRepo) {
+        this.curriculumCourseRepo = curriculumCourseRepository;
+        this.courseRepo = courseRepo;
+        this.curriculumRepo = curriculumRepo;
+    }
+
+    public void save(CurriculumCourse curriculumCourse){
+        curriculumCourseRepo.save(curriculumCourse);
+    }
+
+
+    public Map<String, Object> getDepthCurriculum(Curriculum curriculum){
+
+        if (curriculum == null)
+            return null;
+
+        HashMap<String ,Object> toReturn = new HashMap<>();
+        ArrayList<Map<String ,Object>> courses = new ArrayList<>();
+        Iterable<Course> foundCourses = curriculumCourseRepo.findCoursesByCurriculum(curriculum);
+
+        for (Course c: foundCourses){
+            courses.add(ProtectionService.courseWithoutPassword(c));
+        }
+        toReturn.put("courses",courses);
+        toReturn.put("curriculumId", curriculum.getCurriculumId());
+        toReturn.put("year", curriculum.getYear());
+        toReturn.put("option", curriculum.getOption());
+
+
+        return  toReturn;
+    }
+
+    public Iterable<Map<String, Object>> getAllDepthCurriculum(){
+
+        ArrayList<Map<String,Object>> toReturn = new ArrayList<>();
+
+        for (Curriculum curriculum : curriculumRepo.findAll()){
+            toReturn.add(getDepthCurriculum(curriculum));
+        }
+
+
+        return toReturn;
+    }
+
+    /** tries to add all courses to the curriculum
+     *
+     * @param coursesIds the ids of the courses to be added
+     * @param curriculum the curriculum to add the courses to
+     * @return if the changes were made
+     */
+    public boolean saveAll(Iterable<Long> coursesIds, Curriculum curriculum) {
+
+        if (curriculum == null || coursesIds == null)
+            return false;
+
+        ArrayList<Course> toAdd = new ArrayList<>();
+        for (Long courseId : coursesIds){
+
+            Course course = courseRepo.findById((long) courseId);
+            if (course == null)
+                return false;
+
+            if (!toAdd.contains(course))
+                toAdd.add(course);
+        }
+
+        for (Course course : toAdd){
+            curriculumCourseRepo.save(new CurriculumCourse(curriculum,course));
+        }
+        return true;
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/CurriculumService.java

@@ -0,0 +1,25 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Tables.Curriculum;
+
+@Service
+public class CurriculumService {
+
+    private final CurriculumRepository curriculumRepo;
+
+    public CurriculumService(CurriculumRepository curriculumRepo){
+        this.curriculumRepo = curriculumRepo;
+    }
+    public Curriculum save(Curriculum curriculum){
+        return curriculumRepo.save(curriculum);
+    }
+    public Curriculum findById(long id){
+        return curriculumRepo.findById(id);
+    }
+
+    public void delete(Curriculum curriculum) {
+        curriculumRepo.delete(curriculum);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/InscriptionService.java

@@ -0,0 +1,94 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Repositories.InscriptionRepository;
+import ovh.herisson.Clyde.Repositories.UserCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Tables.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.RequestState;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.UserCurriculum;
+
+@Service
+public class InscriptionService {
+
+    private final InscriptionRepository inscriptionRepo;
+
+    private final UserRepository userRepo;
+
+    private final UserCurriculumRepository userCurriculumRepo;
+
+    private final CurriculumRepository curriculumRepo;
+
+    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
+
+
+    public InscriptionService(InscriptionRepository inscriptionRepo, UserRepository userRepo, UserCurriculumRepository userCurriculumRepo, CurriculumRepository curriculumRepo){
+        this.inscriptionRepo = inscriptionRepo;
+        this.userRepo = userRepo;
+        this.userCurriculumRepo = userCurriculumRepo;
+        this.curriculumRepo = curriculumRepo;
+    }
+
+    public InscriptionRequest save(InscriptionRequest inscriptionRequest){
+        inscriptionRequest.setPassword(passwordEncoder.encode(inscriptionRequest.getPassword()));
+        return inscriptionRepo.save(inscriptionRequest);
+    }
+
+    public InscriptionRequest getById(long id){
+        return inscriptionRepo.findById(id);
+    }
+
+    public Iterable<InscriptionRequest> getAll(){
+        return inscriptionRepo.findAll();
+    }
+
+    public boolean modifyState(long id, RequestState requestState) {
+        InscriptionRequest inscrRequest = getById(id);
+
+        if (inscrRequest == null)
+            return false;
+
+        // if th state is the same we don't send an email
+        if (requestState == inscrRequest.getState())
+            return false;
+
+        /** todo send an email to tell the poster of the inscrRequest (inscrRequest.getEmail())
+         *  to notify them that the state of their request changed
+         *  FooEmailFormat toSend = (String.format("Your request state changed from %s to %s"),
+         *                                              inscrRequest.getState(), requestState)
+         * FooEmailSender.send(toSend, inscrRequest.getEmail())
+         */
+
+
+        //saves the user from the request if accepted
+        if (requestState == RequestState.Accepted)
+        {
+            if (curriculumRepo.findById(inscrRequest.getCurriculumId()) == null)
+                return false;
+
+            User userFromRequest = new User(
+                    inscrRequest.getLastName(),
+                    inscrRequest.getFirstName(),
+                    inscrRequest.getEmail(),
+                    inscrRequest.getAddress(),
+                    inscrRequest.getCountry(),
+                    inscrRequest.getBirthDate(),
+                    inscrRequest.getProfilePicture(),
+                    inscrRequest.getPassword()
+            );
+
+            userRepo.save(userFromRequest);
+            userCurriculumRepo.save(new UserCurriculum(userFromRequest, curriculumRepo.findById(inscrRequest.getCurriculumId())));
+        }
+        inscrRequest.setState(requestState);
+        save(inscrRequest);
+        return true;
+    }
+
+    public void delete(InscriptionRequest toDelete) {
+        inscriptionRepo.delete(toDelete);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/ProtectionService.java

@@ -0,0 +1,105 @@
+package ovh.herisson.Clyde.Services;
+
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ProtectionService {
+
+    /** return user's data except password
+     * @param user the user to return
+     * @return all the user data without the password
+     */
+    public static HashMap<String,Object> userWithoutPassword(User user){
+
+        if (user ==null)
+            return null;
+
+        HashMap<String,Object> toReturn = new HashMap<>();
+
+        toReturn.put("regNo",user.getRegNo());
+        toReturn.put("lastName",user.getLastName());
+        toReturn.put("firstName",user.getFirstName());
+        toReturn.put("email", user.getEmail());
+        toReturn.put("address",user.getAddress());
+        toReturn.put("birthDate",user.getBirthDate());
+        toReturn.put("country",user.getCountry());
+        toReturn.put("profilePictureUrl",user.getProfilePictureUrl());
+        toReturn.put("role",user.getRole());
+        return toReturn;
+    }
+
+    public static Iterable<HashMap<String ,Object>>usersWithoutPasswords(Iterable<User> users){
+        ArrayList<HashMap<String,Object>> toReturn = new ArrayList<>();
+
+        for (User u : users){
+            toReturn.add(userWithoutPassword(u));
+        }
+
+        return toReturn;
+    }
+
+
+
+    public static HashMap<String,Object> courseWithoutPassword(Course course){
+        if (course == null)
+            return null;
+
+        HashMap<String ,Object> toReturn = new HashMap<>();
+
+        toReturn.put("courseId",course.getCourseID());
+        toReturn.put("credits",course.getCredits());
+        toReturn.put("title", course.getTitle());
+        toReturn.put("owner", userWithoutPassword(course.getOwner()));
+        return toReturn;
+    }
+
+    public static Iterable<HashMap<String ,Object>> coursesWithoutPasswords(Iterable<Course> courses){
+        ArrayList<HashMap<String,Object>> toReturn = new ArrayList<>();
+
+        for (Course course: courses){
+            toReturn.add(ProtectionService.courseWithoutPassword(course));
+        }
+
+        return toReturn;
+
+    }
+
+
+    public static Map<String, Object> requestWithoutPassword(InscriptionRequest inscriptionRequest) {
+
+        if (inscriptionRequest == null)
+            return null;
+
+        Map<String, Object> toReturn = new HashMap<>();
+
+        toReturn.put("id", inscriptionRequest.getId());
+        toReturn.put("lastName", inscriptionRequest.getLastName());
+        toReturn.put("firstName", inscriptionRequest.getFirstName());
+        toReturn.put("address", inscriptionRequest.getAddress());
+        toReturn.put("email",inscriptionRequest.getEmail());
+        toReturn.put("birthDate", inscriptionRequest.getBirthDate());
+        toReturn.put("country", inscriptionRequest.getCountry());
+        toReturn.put("curriculum", inscriptionRequest.getCurriculumId());
+        toReturn.put("state", inscriptionRequest.getState());
+        toReturn.put("profilePictureUrl", inscriptionRequest.getProfilePicture());
+
+        return toReturn;
+    }
+
+    public static Iterable<Map<String ,Object>> requestsWithoutPasswords(Iterable<InscriptionRequest> inscriptionRequests){
+
+        ArrayList<Map<String,Object>> toReturn = new ArrayList<>();
+
+        for (InscriptionRequest i:inscriptionRequests){
+            toReturn.add(requestWithoutPassword(i));
+        }
+        return toReturn;
+    }
+
+}
+

backend/src/main/java/ovh/herisson/Clyde/Services/StorageService.java

@@ -0,0 +1,69 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import org.springframework.web.multipart.MultipartFile;
+import ovh.herisson.Clyde.Repositories.FileRepository;
+import ovh.herisson.Clyde.Tables.*;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.util.Objects;
+import java.util.UUID;
+
+@Service
+public class StorageService {
+    private final Path rootLocation = Paths.get("cdn/");
+    private final FileRepository fileRepo;
+
+    public StorageService(FileRepository filerepo){
+        this.fileRepo = filerepo;
+
+		if(!Files.exists(rootLocation)){
+			try {
+				Files.createDirectories(rootLocation);
+			} catch(IOException e){
+				e.printStackTrace();
+			}
+		}
+    }
+
+
+    public StorageFile store(MultipartFile file, FileType fileType) {
+
+        if (file == null || file.getOriginalFilename() == null)
+            return null;
+
+        if (file.getOriginalFilename().isEmpty()){return null;}
+
+        UUID uuid = UUID.randomUUID();
+        String stringUuid = uuid + "." + file.getOriginalFilename().split("\\.",2)[1];
+        try {
+            if (file.isEmpty()) {
+                return null;
+            }
+
+            Path destinationFile = this.rootLocation.resolve(Paths.get(stringUuid));
+
+            Files.copy(file.getInputStream(), destinationFile,StandardCopyOption.REPLACE_EXISTING);
+        }
+        catch (IOException e) {
+            return null;
+        }
+
+        String url = this.rootLocation.resolve(Paths.get(Objects.requireNonNull(stringUuid)))
+                .normalize().toString();
+
+        return fileRepo.save(new StorageFile(file.getOriginalFilename(),url, fileType));
+    }
+
+    public void delete(StorageFile file) throws SecurityException {
+        File f = new File(file.getUrl());
+        f.delete();
+
+        //Delete l'entité
+        fileRepo.delete(file);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/TeacherCourseService.java

@@ -0,0 +1,53 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Controller;
+import ovh.herisson.Clyde.Repositories.TeacherCourseRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.TeacherCourse;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+
+@Controller
+public class TeacherCourseService {
+    private final TeacherCourseRepository teacherCourseRepo;
+
+    private final UserRepository userRepo;
+
+    public TeacherCourseService(TeacherCourseRepository teacherCourseRepo, UserRepository userRepo) {
+        this.teacherCourseRepo = teacherCourseRepo;
+        this.userRepo = userRepo;
+    }
+
+    public Iterable<User> findCourseAssistants(Course course) {
+        if (course == null)
+            return null;
+        return teacherCourseRepo.findAllAssistantOfCourse(course);
+    }
+
+
+    public boolean saveAll(Iterable<Long> teacherIds, Course course){
+
+        if (course == null  || teacherIds == null)
+            return false;
+
+        ArrayList<User> toAdd = new ArrayList<>();
+        for (Long teacherId : teacherIds){
+            User teacher = userRepo.findById((long) teacherId);
+            if ( teacher== null){
+                return false;
+            }
+            if (!toAdd.contains(teacher) && teacher.getRole() == Role.Teacher)
+            {
+                toAdd.add(teacher);
+            }
+        }
+        for (User teacher: toAdd){
+            teacherCourseRepo.save(new TeacherCourse(teacher,course));
+        }
+        return true;
+    }
+
+}

backend/src/main/java/ovh/herisson/Clyde/Services/TokenService.java

@@ -1,37 +1,74 @@
 package ovh.herisson.Clyde.Services;
 
+import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import ovh.herisson.Clyde.Repositories.TokenRepository;
 import ovh.herisson.Clyde.Tables.Token;
 import ovh.herisson.Clyde.Tables.User;
-
-import java.nio.charset.StandardCharsets;
+import java.io.UnsupportedEncodingException;
 import java.security.SecureRandom;
-import java.util.Date;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Calendar;
 
 @Service
 public class TokenService {
-
-    TokenRepository tokenRepo;
+    private final TokenRepository tokenRepo;
 
     public TokenService(TokenRepository tokenRepo){
         this.tokenRepo = tokenRepo;
     }
 
+    public Iterable<Token> getAllTokens() {
+        return tokenRepo.findAll();
+    }
+
 
     public String generateNewToken(){
         byte[] bytes = new byte[64];
         new SecureRandom().nextBytes(bytes);
-        String token = new String(bytes, StandardCharsets.US_ASCII);
-        System.out.println(token);
-        return token;
+        for (int i = 0; i < bytes.length; i++) {
+            bytes[i] = (byte) (((bytes[i]+256)%256  %95+ 32));
+        }
+        // will never end up in the catch because of the way that SecureRandom.nextBytes is implemented
+        try {
+            return new String(Base64.getEncoder().encode(bytes),"ISO_8859_1");
+        } catch (UnsupportedEncodingException e) {
+            throw new RuntimeException(e);
+        }
     }
 
-    public User getUserFromToken(String token){
-        return tokenRepo.getByToken(token).getUser();
+    public User getUserFromToken(String token) {
+        Token tokenRep = tokenRepo.getByToken(token);
+        if (tokenRep == null)
+            return null;
+
+        return tokenRep.getUser();
     }
 
-    public void saveToken(String token, User user, Date expirationDate){// todo faire qlq chose de l'expDate
-        tokenRepo.save(new Token(user,token));
+    public void saveToken(Token token){
+        //Si l'utilisateur a déja 5 token delete celui qui devait expirer le plus vite
+        ArrayList<Token> tokenList = tokenRepo.getByUserOrderByExpirationDate(token.getUser());
+
+        while(tokenList.size() >= 5){
+            tokenRepo.delete(tokenList.getFirst());
+            tokenList.remove(tokenList.getFirst());
+        }
+        tokenRepo.save(token);
+    }
+
+    //Tous les jours a minuit
+    @Scheduled(cron = "0 0 0 * * ?")
+    public void autoDeleteToken() {
+        for (Token t: tokenRepo.findAll()){
+            Calendar cal = Calendar.getInstance();
+
+            Calendar cal2 = Calendar.getInstance();
+            cal2.setTime(t.getExpirationDate());
+
+            if (cal.compareTo(cal2) >= 0){
+                tokenRepo.delete(t);
+            }
+        }
     }
 }

backend/src/main/java/ovh/herisson/Clyde/Services/UserCurriculumService.java

@@ -0,0 +1,20 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.UserCurriculumRepository;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.User;
+
+@Service
+public class UserCurriculumService {
+
+    private final UserCurriculumRepository userCurriculumRepository;
+
+    public UserCurriculumService(UserCurriculumRepository userCurriculumRepository) {
+        this.userCurriculumRepository = userCurriculumRepository;
+    }
+
+    public Curriculum findByUser(User student){
+        return userCurriculumRepository.findByUser(student);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/UserService.java

@@ -5,16 +5,10 @@ import org.springframework.stereotype.Service;
 import ovh.herisson.Clyde.Repositories.UserRepository;
 import ovh.herisson.Clyde.Tables.Role;
 import ovh.herisson.Clyde.Tables.User;
-
-import java.text.DateFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
+import java.util.*;
 
 @Service
 public class UserService {
-
     private final UserRepository userRepo;
     private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
 
@@ -23,8 +17,15 @@ public class UserService {
     }
 
 
+    /** return the user identified by th identifier
+     *
+     * @param identifier can be an email or the RegNo
+     * @return the identified user
+     */
     public User getUser(String identifier){
-        if (identifier == null) return null;
+        if (identifier == null)
+            return null;
+
         try {
             int id = Integer.parseInt(identifier);
             return userRepo.findById(id);
@@ -34,17 +35,100 @@ public class UserService {
         }
     }
 
+    /** modify the target data
+     * verify the permission of modifying from the poster
+     *
+     * @param poster the user wanting to modify target's data
+     * @param updates the changes to be made
+     * @param targetId the id of the user to update
+     * @return if the changes were done or not
+     */
+    public boolean modifyData(long targetId, Map<String ,Object> updates, User poster){
+
+        User target = userRepo.findById(targetId);
+        if (target == null)
+            return false;
+
+        if (poster.getRegNo().equals(target.getRegNo())){
+            for (Map.Entry<String, Object> entry : updates.entrySet()){
+
+                switch (entry.getKey()){
+                    case "firstName":
+                        target.setFirstName((String) entry.getValue());
+                        break;
+                    case "lastName":
+                        target.setLastName((String) entry.getValue());
+                        break;
+                    case "email":
+                        target.setEmail((String) entry.getValue());
+                        break;
+                    case "address":
+                        target.setAddress((String) entry.getValue());
+                        break;
+                    case "country":
+                        target.setCountry((String) entry.getValue());
+                        break;
+                    case "birthDate":
+                        target.setBirthDate((Date) entry.getValue());
+                        break;
+                    case "profilePictureUrl":
+                        target.setProfilePictureUrl((String) entry.getValue());
+                        break;
+                    case "password":
+                        target.setPassword(passwordEncoder.encode((String) entry.getValue()));
+                        break;
+                }
+            }
+            userRepo.save(target);
+            return true;
+        }
+        // the secretary can change roles (for example if a student becomes a teacher)
+        else if (poster.getRole() == Role.Secretary)
+        {
+            for (Map.Entry<String, Object> entry : updates.entrySet()){
+
+                if ( entry.getKey().equals("role")) {
+
+                    if (entry.getValue() == Role.Admin) {return false;}
+
+                    target.setRole((Role) entry.getValue());
+                    userRepo.save(target);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
 
     public boolean checkPassword(User user, String tryingPassword){
         return passwordEncoder.matches(tryingPassword,  user.getPassword());
     }
 
-    public void save(User  user){
-        userRepo.save(user);
+    public User save(User  user){
+        user.setPassword(passwordEncoder.encode(user.getPassword()));
+        return userRepo.save(user);
     }
 
     public Iterable<User> getAll(){
         return userRepo.findAll();
     }
 
+    public Iterable<User> getAllExceptAdmins(){
+        return userRepo.findAllExceptAdmins();
+    }
+
+
+    public Iterable<User> getAllTeachers (){return userRepo.findAllTeachers();}
+
+    public Iterable<User> getAllStudents(){return userRepo.findAllStudents();}
+
+
+    public User getUserById(long id) {
+        return userRepo.findById(id);
+    }
+
+    public void delete(User user) {
+        userRepo.delete(user);
+    }
 }

backend/src/main/java/ovh/herisson/Clyde/Tables/Applications.java

@@ -0,0 +1,24 @@
+package ovh.herisson.Clyde.Tables;
+
+public enum Applications {
+    // without any token
+    Login,
+    Schedule,
+
+    // with any token
+    Profile,
+
+
+    // Students and higher authorization
+    Msg,
+    Forum,
+    Rdv,
+
+    // teachers and Secretary authorization
+    ManageCourses,
+    UsersList,
+
+    // InscriptionService authorization
+    Inscription,
+    StudentsList
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/Course.java

@@ -1,9 +1,8 @@
 package ovh.herisson.Clyde.Tables;
 
-import jakarta.persistence.Entity;
-import jakarta.persistence.GeneratedValue;
-import jakarta.persistence.GenerationType;
-import jakarta.persistence.Id;
+import jakarta.persistence.*;
+import org.hibernate.annotations.OnDelete;
+import org.hibernate.annotations.OnDeleteAction;
 
 @Entity
 public class Course {
@@ -12,12 +11,16 @@ public class Course {
     private int courseID;
     private int credits;
     private String title;
-    private String faculty;
 
-    public Course(int credits, String title, String faculty){
+    @ManyToOne(fetch = FetchType.EAGER)
+    @OnDelete(action = OnDeleteAction.SET_NULL)
+    @JoinColumn(name = "Users")
+    private User owner;
+
+    public Course(int credits, String title, User owner){
         this.credits = credits;
         this.title = title;
-        this.faculty = faculty;
+        this.owner = owner;
     }
 
     public Course() {}
@@ -34,14 +37,6 @@ public class Course {
         this.credits = credits;
     }
 
-    public String getFaculty() {
-        return faculty;
-    }
-
-    public void setFaculty(String faculty){
-        this.faculty = faculty;
-    }
-
     public String getTitle() {
         return title;
     }
@@ -49,4 +44,12 @@ public class Course {
     public void setTitle(String title){
         this.title = title;
     }
+
+    public User getOwner() {
+        return owner;
+    }
+
+    public void setOwner(User owner) {
+        this.owner = owner;
+    }
 }

backend/src/main/java/ovh/herisson/Clyde/Tables/Curriculum.java

@@ -6,22 +6,21 @@ import jakarta.persistence.GenerationType;
 import jakarta.persistence.Id;
 
 @Entity
-public class Cursus {
+public class Curriculum {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
-    private int cursusId;
+    private int curriculumId;
     private int year;
     private String option;
-
-    public Cursus(int year, String option){
+    public Curriculum(int year, String option){
         this.year = year;
         this.option = option;
     }
 
-    public Cursus() {}
+    public Curriculum() {}
 
-    public int getCursusId(){
-        return this.cursusId;
+    public int getCurriculumId(){
+        return this.curriculumId;
     }
 
     public int getYear(){

backend/src/main/java/ovh/herisson/Clyde/Tables/CurriculumCourse.java

@@ -0,0 +1,49 @@
+package ovh.herisson.Clyde.Tables;
+
+import jakarta.persistence.*;
+import org.hibernate.annotations.OnDelete;
+import org.hibernate.annotations.OnDeleteAction;
+
+@Entity
+public class CurriculumCourse {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private int id;
+
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "Curriculum")
+    @OnDelete(action = OnDeleteAction.CASCADE)
+    private Curriculum curriculum;
+
+    @ManyToOne(fetch = FetchType.EAGER)
+    @OnDelete(action = OnDeleteAction.CASCADE)
+    @JoinColumn(name = "Course")
+    private Course course;
+
+    public CurriculumCourse(Curriculum curriculum, Course course){
+        this.curriculum = curriculum;
+        this.course = course;
+    }
+
+    public CurriculumCourse() {}
+
+    public int getId() {
+        return id;
+    }
+
+    public Course getCourse() {
+        return course;
+    }
+
+    public void setCourse(Course course){
+        this.course = course;
+    }
+
+    public Curriculum getCurriculum() {
+        return curriculum;
+    }
+
+    public void setCurriculum(Curriculum curriculum) {
+        this.curriculum = curriculum;
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/CursusCourse.java

@@ -1,45 +0,0 @@
-package ovh.herisson.Clyde.Tables;
-
-import jakarta.persistence.*;
-
-@Entity
-public class CursusCourse {
-    @Id
-    @GeneratedValue(strategy = GenerationType.AUTO)
-    private int id;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "Cursus")
-    private Cursus cursus;
-
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "Course")
-    private Course course;
-
-    public CursusCourse(Cursus cursus, Course course){
-        this.cursus = cursus;
-        this.course = course;
-    }
-
-    public CursusCourse() {}
-
-    public int getId() {
-        return id;
-    }
-
-    public Course getCourse() {
-        return course;
-    }
-
-    public void setCourse(Course course){
-        this.course = course;
-    }
-
-    public Cursus getCursus() {
-        return cursus;
-    }
-
-    public void setCursus(Cursus cursus) {
-        this.cursus = cursus;
-    }
-}

backend/src/main/java/ovh/herisson/Clyde/Tables/FileType.java

@@ -0,0 +1,8 @@
+package ovh.herisson.Clyde.Tables;
+
+public enum FileType {
+
+    ProfilePicture,
+
+    EducationCertificate
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/InscriptionRequest.java

@@ -0,0 +1,121 @@
+package ovh.herisson.Clyde.Tables;
+
+import jakarta.persistence.*;
+import java.util.Date;
+
+
+@Entity
+public class InscriptionRequest {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private int id;
+    private String firstName;
+    private String lastName;
+    private String address;
+    private String email;
+    private String country;
+    private Date birthDate;
+
+    private Long curriculumId;
+    private RequestState state;
+    private String profilePicture;
+
+    private String password;
+    public InscriptionRequest(){}
+    public InscriptionRequest(String lastName, String firstName, String address, String email, String country, Date birthDate,Long curriculumId, RequestState state, String profilePicture, String password){
+        this.lastName = lastName;
+        this.firstName = firstName;
+        this.address = address;
+        this.email = email;
+        this.country = country;
+        this.birthDate = birthDate;
+        this.curriculumId = curriculumId;
+        this.state = state;
+        this.profilePicture = profilePicture;
+        this.password = password;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    public void setEmail(String email) {
+        this.email = email;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    public Date getBirthDate() {
+        return birthDate;
+    }
+
+    public void setBirthDate(Date birthDate) {
+        this.birthDate = birthDate;
+    }
+
+    public long getCurriculumId() {
+        return curriculumId;
+    }
+
+    public void setCurriculumId(long curriculum) {
+        this.curriculumId = curriculum;
+    }
+
+    public RequestState getState() {
+        return state;
+    }
+
+    public void setState(RequestState state) {
+        this.state = state;
+    }
+
+    public String getProfilePicture() {
+        return profilePicture;
+    }
+
+    public void setProfilePicture(String profilePicture) {
+        this.profilePicture = profilePicture;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/ReInscriptionRequest.java

@@ -0,0 +1,78 @@
+package ovh.herisson.Clyde.Tables;
+
+import jakarta.persistence.*;
+import org.hibernate.annotations.OnDelete;
+import org.hibernate.annotations.OnDeleteAction;
+
+@Entity
+public class ReInscriptionRequest {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private int id;
+
+    @ManyToOne
+    @JoinColumn(name = "Users")
+    @OnDelete(action = OnDeleteAction.CASCADE)
+    private User user;
+
+    @ManyToOne
+    @JoinColumn(name = "Curriculum")
+    @OnDelete(action = OnDeleteAction.CASCADE)
+    private Curriculum newCurriculum;
+    private RequestState state;
+
+    //Permet de différencier les demandes de changement et une réinscription dans le même Curriculum
+    //Pour la réinscription on va le mettre a 0
+    private boolean type = false;
+
+    public ReInscriptionRequest(){}
+
+    public ReInscriptionRequest(User user, Curriculum newCurriculum, RequestState state, boolean type){
+        this.user = user;
+        this.newCurriculum = newCurriculum;
+        this.state = state;
+        this.type = type;
+    }
+
+    public ReInscriptionRequest(User user, Curriculum newCurriculum, RequestState state){
+        this.user = user;
+        this.newCurriculum = newCurriculum;
+        this.state = state;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public User getUser() {
+        return user;
+    }
+
+    public void setUser(User user) {
+        this.user = user;
+    }
+
+    public Curriculum getNewCurriculum() {
+        return newCurriculum;
+    }
+
+    public void setNewCurriculum(Curriculum newCurriculum) {
+        this.newCurriculum = newCurriculum;
+    }
+
+    public RequestState getState() {
+        return state;
+    }
+
+    public void setState(RequestState state) {
+        this.state = state;
+    }
+
+    public boolean isType() {
+        return type;
+    }
+
+    public void setType(boolean type) {
+        this.type = type;
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/RequestState.java

@@ -0,0 +1,7 @@
+package ovh.herisson.Clyde.Tables;
+
+public enum RequestState {
+    Accepted,
+    Refused,
+    Pending
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/Role.java

@@ -4,5 +4,6 @@ public enum Role {
     Teacher,
     Student,
     Admin,
-    Secretary;
+    InscriptionService,
+    Secretary
 }

backend/src/main/java/ovh/herisson/Clyde/Tables/Secretary.java

@@ -1,42 +0,0 @@
-package ovh.herisson.Clyde.Tables;
-
-import jakarta.persistence.*;
-
-@Entity
-public class Secretary {
-    @Id
-    @GeneratedValue(strategy = GenerationType.AUTO)
-    private int id;
-
-    @OneToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "Users")
-    private User user;
-    private String faculty;
-
-    public Secretary(User user, String faculty){
-        this.user = user;
-        this.faculty = faculty;
-    }
-
-    public Secretary() {}
-
-    public int getId() {
-        return id;
-    }
-
-    public User getUser() {
-        return user;
-    }
-
-    public void setUser(User user) {
-        this.user = user;
-    }
-
-    public String getFaculty() {
-        return faculty;
-    }
-
-    public void setFaculty(String faculty) {
-        this.faculty = faculty;
-    }
-}

backend/src/main/java/ovh/herisson/Clyde/Tables/StorageFile.java

@@ -0,0 +1,59 @@
+package ovh.herisson.Clyde.Tables;
+
+import jakarta.persistence.*;
+
+
+@Entity
+public class StorageFile {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private Long id;
+
+    private String name;
+
+    private String url;
+
+    private FileType fileType;
+
+    public StorageFile(String name, String url, FileType fileType){
+        this.name = name;
+        this.url = url;
+        this.fileType = fileType;
+    }
+
+    public StorageFile(){}
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public Long getId() {
+        return id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public FileType getFileType() {
+        return fileType;
+    }
+
+    public void setFileType(FileType fileType) {
+        this.fileType = fileType;
+    }
+
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/TeacherCourse.java

@@ -1,32 +1,32 @@
 package ovh.herisson.Clyde.Tables;
 
 import jakarta.persistence.*;
+import org.hibernate.annotations.OnDelete;
+import org.hibernate.annotations.OnDeleteAction;
 
 @Entity
-public class TeacherGivenCourse {
+public class TeacherCourse {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
     private int id;
 
-    @ManyToOne(fetch = FetchType.LAZY)
+    @ManyToOne(fetch = FetchType.EAGER)
+    @OnDelete(action = OnDeleteAction.CASCADE)
     @JoinColumn(name = "Users")
     private User user;
 
 
-    @ManyToOne(fetch = FetchType.LAZY)
+    @ManyToOne(fetch = FetchType.EAGER)
+    @OnDelete(action = OnDeleteAction.CASCADE)
     @JoinColumn(name = "Course")
     private Course course;
 
-    //This flag helps make the difference between an assistant or a Teacher (who owns the course)
-    private boolean owned;
-
-    public TeacherGivenCourse(User user, Course course, boolean owned){
+    public TeacherCourse(User user, Course course){
         this.user = user;
         this.course = course;
-        this.owned = owned;
     }
 
-    public TeacherGivenCourse() {}
+    public TeacherCourse() {}
 
     public int getId() {
         return id;
@@ -48,11 +48,4 @@ public class TeacherGivenCourse {
         this.course = course;
     }
 
-    public boolean isOwned() {
-        return owned;
-    }
-
-    public void setOwned(boolean owned) {
-        this.owned = owned;
-    }
 }

backend/src/main/java/ovh/herisson/Clyde/Tables/Token.java

@@ -1,6 +1,10 @@
 package ovh.herisson.Clyde.Tables;
 
 import jakarta.persistence.*;
+import org.hibernate.annotations.OnDelete;
+import org.hibernate.annotations.OnDeleteAction;
+
+import java.util.Date;
 
 @Entity
 public class Token {
@@ -8,17 +12,21 @@ public class Token {
     @Id
     private int id;
 
-    @ManyToOne(fetch = FetchType.LAZY)
+    @ManyToOne(fetch = FetchType.EAGER)
+    @OnDelete(action = OnDeleteAction.CASCADE)
     @JoinColumn(name ="Users")
     private User user;
     private String token;
+    private Date expirationDate;
 
-    public Token(User user, String token){
+    public Token(User user, String token, Date expirationDate){
         this.user = user;
         this.token = token;
+        this.expirationDate = expirationDate;
     }
 
     public Token(){}
+
     public int getId() {
         return id;
     }
@@ -37,4 +45,12 @@ public class Token {
     public void setToken(String data) {
         this.token = data;
     }
+
+    public void setExpirationDate(Date date){
+        this.expirationDate = date;
+    }
+
+    public Date getExpirationDate(){
+        return expirationDate;
+    }
 }

backend/src/main/java/ovh/herisson/Clyde/Tables/User.java

@@ -1,21 +1,18 @@
 package ovh.herisson.Clyde.Tables;
 
 import jakarta.persistence.*;
-
 import java.util.Date;
 
-//Classe représentant un utilisateur l'attribut password demande surement un peu de rafinement niveau sécurité
-//et l'attribut tokenApi doit encore être ajouté vu qu'il faut en discuter
 
 @Entity
-//Je rajoute un s au nom de la table pour éviter les conflits avec les mots réservés
 @Table(name = "Users")
 public class User {
     @Id
     @GeneratedValue(strategy = GenerationType.AUTO)
-    private int regNo;
+    private Long regNo;
     private String lastName;
     private String firstName;
+    @Column(unique = true)
     private String email;
     private String address;
     private String country;
@@ -23,7 +20,9 @@ public class User {
     private String profilePictureUrl;
     private ovh.herisson.Clyde.Tables.Role role;
     private String password;
-    public User(String lastName, String firstName, String email, String address, String country, Date birthDate, String profilePictureUrl, Role role, String password){
+    public User(String lastName, String firstName, String email, String address,
+                String country, Date birthDate, String profilePictureUrl, Role role, String password)
+    {
         this.lastName = lastName;
         this.firstName = firstName;
         this.email = email;
@@ -35,9 +34,22 @@ public class User {
         this.password = password;
     }
 
+    public User(String lastName, String firstName, String email, String address,
+                String country, Date birthDate, String profilePictureUrl, String password)
+    {
+        this.lastName = lastName;
+        this.firstName = firstName;
+        this.email = email;
+        this.address = address;
+        this.country = country;
+        this.birthDate = birthDate;
+        this.profilePictureUrl = profilePictureUrl;
+        this.password = password;
+        this.role = Role.Student;
+    }
     public User() {}
 
-    public int getRegNo(){
+    public Long getRegNo(){
         return this.regNo;
     }
     public String getLastName() {
@@ -68,8 +80,8 @@ public class User {
         return address;
     }
 
-    public void setAddress(String adress) {
-        this.address = adress;
+    public void setAddress(String address) {
+        this.address = address;
     }
 
     public String getCountry() {

backend/src/main/java/ovh/herisson/Clyde/Tables/UserCurriculum.java

@@ -0,0 +1,50 @@
+package ovh.herisson.Clyde.Tables;
+
+import jakarta.persistence.*;
+import org.hibernate.annotations.OnDelete;
+import org.hibernate.annotations.OnDeleteAction;
+
+@Entity
+public class UserCurriculum {
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    private int id;
+
+    //Un étudiant peut avoir plusieurs curriculums
+    @ManyToOne(fetch = FetchType.EAGER)
+    @OnDelete(action = OnDeleteAction.CASCADE)
+    @JoinColumn(name = "Users")
+    private User user;
+
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "Curriculum")
+    @OnDelete(action = OnDeleteAction.CASCADE)
+    private Curriculum curriculum;
+
+    public UserCurriculum(User user, Curriculum curriculum){
+        this.user = user;
+        this.curriculum = curriculum;
+    }
+
+    public UserCurriculum() {}
+
+    public int getId() {
+        return id;
+    }
+
+    public User getUser() {
+        return user;
+    }
+
+    public void setUser(User user) {
+        this.user = user;
+    }
+
+    public Curriculum getCurriculum() {
+        return curriculum;
+    }
+
+    public void setCurriculum(Curriculum curriculum) {
+        this.curriculum = curriculum;
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Tables/UserCursus.java

@@ -1,46 +0,0 @@
-package ovh.herisson.Clyde.Tables;
-
-import jakarta.persistence.*;
-
-@Entity
-public class UserCursus {
-    @Id
-    @GeneratedValue(strategy = GenerationType.AUTO)
-    private int id;
-
-    //Un étudiant peut avoir plusieurs cursus
-    @ManyToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "Users")
-    private User user;
-
-    @OneToOne(fetch = FetchType.LAZY)
-    @JoinColumn(name = "Cursus")
-    private Cursus cursus;
-
-    public UserCursus(User user, Cursus cursus){
-        this.user = user;
-        this.cursus = cursus;
-    }
-
-    public UserCursus() {}
-
-    public int getId() {
-        return id;
-    }
-
-    public User getUser() {
-        return user;
-    }
-
-    public void setUser(User user) {
-        this.user = user;
-    }
-
-    public Cursus getCursus() {
-        return cursus;
-    }
-
-    public void setCursus(Cursus cursus) {
-        this.cursus = cursus;
-    }
-}

backend/src/main/resources/application.properties

@@ -1,2 +1,3 @@
 spring.jpa.hibernate.ddl-auto=create-drop
 spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect
+spring.sql.init.mode=always

backend/src/test/java/ovh/herisson/Clyde/ClydeApplicationTests.java

@@ -8,6 +8,7 @@ class ClydeApplicationTests {
 
 	@Test
 	void contextLoads() {
+
 	}
 
 }

backend/src/test/java/ovh/herisson/Clyde/Endpoints/StorageControllerTest.java

@@ -0,0 +1,105 @@
+package ovh.herisson.Clyde.Endpoints;
+
+import com.github.dockerjava.api.model.ExposedPort;
+import com.github.dockerjava.api.model.HostConfig;
+import com.github.dockerjava.api.model.PortBinding;
+import com.github.dockerjava.api.model.Ports;
+import io.restassured.RestAssured;
+import io.restassured.http.ContentType;
+import org.junit.Assert;
+import org.junit.jupiter.api.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
+import org.springframework.http.MediaType;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.context.ActiveProfiles;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import ovh.herisson.Clyde.ClydeApplication;
+import ovh.herisson.Clyde.EndPoints.StorageController;
+import ovh.herisson.Clyde.Repositories.FileRepository;
+import ovh.herisson.Clyde.Services.StorageService;
+import ovh.herisson.Clyde.Tables.FileType;
+import ovh.herisson.Clyde.Tables.StorageFile;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import static io.restassured.RestAssured.with;
+
+@Testcontainers
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles(value ="dev")
+public class StorageControllerTest {
+    @LocalServerPort
+    private Integer port;
+
+    @Autowired
+    private ClydeApplication controller;
+
+    @Autowired
+    private StorageController storageController;
+
+    @Autowired
+    private StorageService storageService;
+    @Autowired
+    private FileRepository fileRepository;
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:alpine")
+            .withDatabaseName("clyde")
+            .withUsername("devel")
+            .withPassword("devel")
+            .withCreateContainerCmdModifier(cmd -> cmd.withHostConfig(new HostConfig().withPortBindings(new PortBinding(Ports.Binding.bindPort(5442), new ExposedPort(5432)))));
+
+    @BeforeAll
+    static void beforeAll(){
+        postgres.start();
+    }
+
+    @AfterAll
+    static void afterAll(){
+        postgres.stop();
+    }
+
+    @BeforeEach
+    void setup(){
+        RestAssured.baseURI = "http://localhost:" + port;
+    }
+
+    @AfterEach
+    void afterEach(){
+        fileRepository.deleteAll();
+    }
+    @Test
+    public void uploadFileTest() throws IOException {
+        File mmf = new File("test.txt");
+        mmf.createNewFile();
+
+        FileWriter fw = new FileWriter(mmf);
+        fw.write("Ceci est un test");
+        fw.close();
+
+        with().multiPart("file", mmf).pathParam("fileType", FileType.ProfilePicture).when().request("POST", "/upload/{fileType}").then().statusCode(200);
+
+        StorageFile sf = fileRepository.getStorageFileByName("test.txt");
+
+        //On vérifie que le fichier a bien été stocké dans la db
+        Assert.assertFalse(sf == null);
+
+        //On vérifie que le fichier a bel et bien été stocké dans le dossier cdn
+        File extFile = new File(sf.getUrl());
+        Assert.assertTrue(extFile.exists());
+
+        Assert.assertEquals("cdn", extFile.getParent());
+
+        //On delete tranquillement les fichiers (la méthode delete a déja été testée dans StorageServiceTest)
+        storageService.delete(sf);
+        mmf.delete();
+    }
+}

backend/src/test/java/ovh/herisson/Clyde/Endpoints/UserControllerTest.java

@@ -0,0 +1,149 @@
+package ovh.herisson.Clyde.Endpoints;
+
+import com.github.dockerjava.api.model.ExposedPort;
+import com.github.dockerjava.api.model.HostConfig;
+import com.github.dockerjava.api.model.PortBinding;
+import com.github.dockerjava.api.model.Ports;
+import io.restassured.RestAssured;
+import io.restassured.http.ContentType;
+import org.junit.Assert;
+import org.junit.jupiter.api.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.server.LocalServerPort;
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.HttpStatusCode;
+import org.springframework.test.context.ActiveProfiles;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+import ovh.herisson.Clyde.ClydeApplication;
+import ovh.herisson.Clyde.Repositories.TokenRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.TokenService;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.Token;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+import static io.restassured.RestAssured.with;
+import static org.hamcrest.Matchers.equalTo;
+
+@Testcontainers
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@ActiveProfiles(value = "dev")
+public class UserControllerTest {
+    @LocalServerPort
+    private Integer port;
+
+    @Autowired
+    private ClydeApplication controller;
+
+    @Autowired
+    private TokenService tokenService;
+
+    @Autowired
+    private UserRepository userRepository;
+    @Autowired
+    private TokenRepository tokenRepository;
+    @Container
+    @ServiceConnection
+    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:alpine")
+            .withDatabaseName("clyde")
+            .withUsername("devel")
+            .withPassword("devel")
+            .withCreateContainerCmdModifier(cmd -> cmd.withHostConfig(new HostConfig().withPortBindings(new PortBinding(Ports.Binding.bindPort(5442), new ExposedPort(5432)))));
+
+    @BeforeAll
+    static void beforeAll(){
+        postgres.start();
+    }
+
+    @AfterAll
+    static void afterAll(){
+        postgres.stop();
+    }
+
+    @BeforeEach
+    void setup(){
+        RestAssured.baseURI = "http://localhost:" + port;
+    }
+
+    @AfterEach
+    void aftereach(){
+        tokenRepository.deleteAll();
+        userRepository.deleteAll();
+    }
+    @Test
+    //Verifie qu'un user qui n'a pas les permissions admin ou secretaire ne peut pas post
+    public void userPostTest(){
+        User god = new User("god","god","admin@admin.com","everywhere","every",new Date(0), null, Role.Admin,"goddoesntneedpassword");
+        Token godToken = new Token(god, tokenService.generateNewToken(), new Date());
+        userRepository.save(god);
+        tokenService.saveToken(godToken);
+
+        //Can god post herobrine himself ?
+        User herobrine = new User("brine","hero","herobrine@student.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Student,"test");
+
+        with().body(herobrine).contentType(ContentType.JSON).header("Authorization", godToken.getToken()).when().request("POST", "/user").then().statusCode(201);
+
+        userRepository.delete(herobrine);
+
+        //Can noob post herobrine without authorizations (no)
+        User noob = new User("boon","noob","noob@student.com","everywhere","every",new Date(0), null, Role.Student,"noob");
+        Token noobToken = new Token(noob, tokenService.generateNewToken(), new Date());
+        userRepository.save(noob);
+        tokenService.saveToken(noobToken);
+
+        with().body(herobrine).contentType(ContentType.JSON).header("Authorization", noobToken.getToken()).when().request("POST", "/user").then().statusCode(401);
+    }
+
+    @Test
+    public void userGetTest(){
+        User herobrine = new User("brine","hero","herobrine@student.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Student,"test");
+        userRepository.save(herobrine);
+
+        Token t = new Token(herobrine, tokenService.generateNewToken(), new Date());
+        tokenRepository.save(t);
+
+
+        with().header("Authorization", t.getToken()).when().request("GET", "/user").then().assertThat().statusCode(200).body("firstName",equalTo("hero"));
+    }
+
+    @Test
+    public void userPatchTest(){
+        User herobrine = new User("brine","hero","herobrine@admin.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Admin,"test");
+        userRepository.save(herobrine);
+
+        Token t = new Token(herobrine, tokenService.generateNewToken(), new Date());
+        tokenRepository.save(t);
+
+        Map<String, Object> data = new HashMap<String, Object>();
+        data.put("firstName", "test");
+
+        //Teste que le patch s'execute bien
+        with().body(data).contentType(ContentType.JSON).header("Authorization", t.getToken()).pathParam("id", herobrine.getRegNo()).when().request("PATCH", "/user/{id}").then().statusCode(200);
+
+        //Teste que la donnée a bien été altérée
+        with().header("Authorization", t.getToken()).when().request("GET", "/user").then().body("firstName",equalTo("test"));
+    }
+
+    @Test
+    public void UserDeleteTest(){
+        User god = new User("god","god","admin@admin.com","everywhere","every",new Date(0), null, Role.Admin,"goddoesntneedpassword");
+        Token godToken = new Token(god, tokenService.generateNewToken(), new Date());
+        userRepository.save(god);
+        tokenService.saveToken(godToken);
+
+        User herobrine = new User("brine","hero","herobrine@admin.com","in your WalLs","ShadowsLand",new Date(0), null,Role.Student,"test");
+        userRepository.save(herobrine);
+
+        with().header("Authorization", godToken.getToken()).pathParam("id", herobrine.getRegNo()).when().request("DELETE", "/user/{id}").then().statusCode(200);
+        Assert.assertEquals(userRepository.existsById(herobrine.getRegNo()), false);
+    }
+}

backend/src/test/java/ovh/herisson/Clyde/Repositories/UserRepoTest.java

@@ -0,0 +1,41 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.TestPropertySource;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.GregorianCalendar;
+
+@DataJpaTest
+@TestPropertySource(properties = {
+        "spring.test.database.replace=none",
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine:///db"
+})
+public class UserRepoTest {
+
+    @Autowired
+    UserRepository userRepo;
+
+    @BeforeEach
+    public void setup(){
+        User herobrine = new User("brine","hero","admin@admin.com","in your WalLs","ShadowsLand", new GregorianCalendar(2005, 4, 3).getTime(), null, Role.Admin,"admin");
+        userRepo.save(herobrine);
+    }
+
+    @AfterEach
+    public void clean(){
+        userRepo.deleteAll();
+    }
+    @Test
+    public void usertest(){
+        Assert.assertEquals("brine", userRepo.findById(1).getLastName());
+        Assert.assertTrue(new GregorianCalendar(2005, 4, 3).getTime().equals(userRepo.findById(1).getBirthDate()));
+    }
+
+}

backend/src/test/java/ovh/herisson/Clyde/Services/StorageServiceTest.java

@@ -0,0 +1,80 @@
+package ovh.herisson.Clyde.Services;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.mock.web.MockMultipartFile;
+import org.springframework.test.context.TestPropertySource;
+import org.springframework.web.multipart.MultipartFile;
+import org.testcontainers.shaded.com.google.common.net.MediaType;
+import ovh.herisson.Clyde.Repositories.FileRepository;
+import ovh.herisson.Clyde.Tables.FileType;
+import ovh.herisson.Clyde.Tables.StorageFile;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+
+@DataJpaTest
+@TestPropertySource(properties = {
+        "spring.test.database.replace=none",
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine:///db"
+})
+public class StorageServiceTest {
+    @Autowired
+    FileRepository fileRepo;
+
+    StorageService ss;
+
+    @BeforeEach
+    public void setup(){
+        if (ss == null){
+            ss = new StorageService(fileRepo);
+        }
+    }
+
+    @AfterEach
+    public void aftereach(){
+        fileRepo.deleteAll();
+    }
+    @Test
+    //Check si le fichier est bien sauvegardé dans la DB et si le fichier est bien sauvegardé au bon endroit
+    public void saveFile(){
+        //Test si le directory a bien été crée a l'init du fileService
+        Path rootloc = Paths.get("cdn/");
+
+        Assert.assertTrue(Files.exists(rootloc));
+    }
+
+    @Test
+    public void deleteFile() throws IOException {
+        File file = new File("cdn/test.txt");
+        file.createNewFile();
+
+        //On vérifie que le fichier a bien été crée
+        Assert.assertTrue(file.exists());
+
+        //StorageFile représentant le fichier
+        StorageFile sf = new StorageFile("testfile",file.getPath(), FileType.ProfilePicture);
+        fileRepo.save(sf);
+
+        //Check that the storagefile is properly saved
+        StorageFile resp = fileRepo.getStorageFileByName("testfile");
+        Assert.assertEquals(sf, resp);
+
+        ss.delete(sf);
+
+        //On vérifie que le fichier a bien été delete et que le StorageFile a été delete de la DB
+        Assert.assertFalse(file.exists());
+
+        resp = fileRepo.getStorageFileByName("testfile");
+        Assert.assertEquals(null, resp);
+    }
+}

backend/src/test/java/ovh/herisson/Clyde/Services/TokenServiceTest.java

@@ -0,0 +1,93 @@
+package ovh.herisson.Clyde.Services;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.test.context.TestPropertySource;
+import ovh.herisson.Clyde.Repositories.TokenRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.Token;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@DataJpaTest
+@TestPropertySource(properties = {
+        "spring.test.database.replace=none",
+        "spring.datasource.url=jdbc:tc:postgresql:16-alpine:///db"
+})
+
+class TokenServiceTest {
+
+    @Autowired
+    TokenRepository tokenRepository;
+
+    @Autowired
+    UserRepository userRepository;
+
+
+    @AfterEach
+    public void aftereach(){
+        tokenRepository.deleteAll();
+        userRepository.deleteAll();
+    }
+    @Test
+    void saveToken() {
+        User herobrine = userRepository.findById(1);
+
+        User herobrinenul = new User("brine","heronul","pasadmin@student.com","in your WalLs","ShadowsLand", new GregorianCalendar(2005, 4, 3).getTime(), null, Role.Admin,"admin");
+
+        TokenService tokenService = new TokenService(tokenRepository);
+        Token testToken = new Token(herobrine, tokenService.generateNewToken(), new Date());
+        tokenService.saveToken(testToken);
+
+        Iterable<Token> t = tokenService.getAllTokens();
+        Token tok = t.iterator().next();
+
+        Assert.assertEquals(herobrine, tok.getUser());
+        Assert.assertNotEquals(herobrinenul, tok.getUser());
+    }
+
+
+    @Test
+    void saveTokenLimit(){
+        TokenService tokenService = new TokenService(tokenRepository);
+
+        //On va stocker les token qu'on va sauvegarder au préalable dans une liste pour tester que les tokens remplacés sont bien ceux avec la date d'expi la plus jeune
+        //A la fin il ne devrait donc rester que les 5 derniers tokens de tokenList
+
+        ArrayList<Token> tokenList = new ArrayList<>();
+        GregorianCalendar gc = new GregorianCalendar();
+
+        User malveillant = new User("Cargo", "John", "CargoJ@mail.com", "secret", "secret", null, null, null, "secret");
+        userRepository.save(malveillant);
+
+        for (int i = 0; i < 20; i++){
+            gc.add(Calendar.DAY_OF_WEEK, 1);
+
+            Token t = new Token(malveillant, tokenService.generateNewToken(), gc.getTime());
+            tokenList.add(t);
+
+            tokenService.saveToken(t);
+        }
+
+        //Testons les tokens
+        ArrayList <Token> resp = tokenRepository.getByUserOrderByExpirationDate(malveillant);
+        Assert.assertTrue(resp.size() == 5);
+
+        for (int i = 1; i <= resp.size(); i++){
+            Assert.assertEquals(tokenList.get(tokenList.size()-i), resp.get(resp.size()-i));
+        }
+    }
+}

backend/src/test/resources/application.properties

@@ -0,0 +1,3 @@
+spring.datasource.driver-class-name=org.testcontainers.jdbc.ContainerDatabaseDriver
+spring.jpa.hibernate.ddl-auto=create-drop
+spring.jpa.database-platform=org.hibernate.dialect.PostgreSQLDialect

frontend/README.md

@@ -19,9 +19,3 @@ npm run dev
 ```sh
 npm run build
 ```
-
-### Run Unit Tests with [Vitest](https://vitest.dev/)
-
-```sh
-npm run test:unit
-```

frontend/build.gradle.kts

@@ -18,8 +18,3 @@ var dev = tasks.register<NpmTask>("dev") {
 tasks.register<NpmTask>("run") {
 	dependsOn(dev)
 }
-
-tasks.register<NpmTask>("test") {
-	dependsOn(tasks.npmInstall)
-	args.set(listOf("run", "test:unit"))
-}

frontend/login/index.html

@@ -1,11 +0,0 @@
-<!DOCTYPE html>
-<html>
-	<head>
-		<meta charset="utf-8">
-		<title>Clyde - Login</title>
-	</head>
-	<body>
-		<div id="app"></div>
-		<script type=module src="/src/login.js"></script>
-	</body>
-</html>

frontend/public/i18n/EN.txt

@@ -1,11 +1,9 @@
-# English translations (some examples to remove)
-
 login.guest.signin=Sign in
 login.guest.register=Register
 login.guest.alregister=Already Registered
 login.guest.welcome=WELCOME TO THE UNIVERSITY
 login.guest.email=E-MAIL 
-login.guest.firstname= FIRSTNAME
+login.guest.firstname=FIRSTNAME
 login.guest.surname=SURNAME
 login.guest.country=COUNTRY
 login.guest.address=ADDRESS
@@ -15,6 +13,8 @@ login.guest.lastpage=Last Page
 login.guest.submit=Submit
 login.guest.birthday=BIRTHDAY
 login.guest.confirm=CONFIRM
+login.cPassword=Confirm Password
+login.password=Password
 app.home=Home
 app.login=Login
 app.notifications=Notifications
@@ -23,8 +23,32 @@ app.messages=Messages
 app.forum=Forum
 app.schedules=Schedules
 app.inscription.requests=Inscription Requests
+app.manage.courses=Manage Courses
+app.language=Language
+app.manage.profile=Manage profile
+app.studentList=Students List
+app.users=Users
 request.moreInfos=More Infos
 request.accept=Accept
 request.refuse=Refuse
-#=====================================================
-
+courses.createCourse=Create course
+courses.deleteCourse=Delete course
+courses.modify=Modify
+courses.toDelete=Course to Delete
+courses.confirm=Confirm
+courses.back=Back
+profile.modify.data=Modify personnal data
+profile.reRegister=Re-register
+profile.unRegister=Unregister
+profile.course.list=Courses list
+profile.address=Address
+profile.picture=Profile picture
+profile.change.curriculum=Change curriculum
+name=Name
+Teacher=Teacher
+Student=Student
+Secretary=Secretary
+Curriculum=curriculum
+Credits=Credits
+InscriptionService=I.S.
+faculty=Faculty

frontend/public/i18n/FR.txt

@@ -1,20 +1,20 @@
-# Traductions françaises (Quelques examples a enlever)
-
 login.guest.signin=SE CONNECTER
 login.guest.register=S'enregistrer
 login.guest.alregister=Déjà Enregistré
 login.guest.welcome=BIENVENUE A L'UNIVERSITE
 login.guest.email=E-MAIL 
-login.guest.firstname= PRENOM
-login.guest.surname= NOM
-login.guest.country= PAYS
+login.guest.firstname=PRENOM
+login.guest.surname=NOM
+login.guest.country=PAYS
 login.guest.address=ADRESSE
-login.guest.password= MOT DE PASSE
+login.guest.password=MOT DE PASSE
 login.guest.nextpage=Prochaine Page
 login.guest.lastpage=Derniere Page
 login.guest.submit=Envoyer
 login.guest.birthday=DATE DE NAISSANCE
 login.guest.confirm=CONFIRMER
+login.cPassword=Confirmer mot de passe
+login.password=Mot de passe
 app.home=Home
 app.login=Se connecter
 app.notifications=Notifications
@@ -23,7 +23,32 @@ app.messages=Messages
 app.forum=Forum
 app.schedules=Horaires
 app.inscription.requests=Demandes d'Inscription
+app.manage.courses=Gérer les cours
+app.language=Langue
+app.manage.profile=Gérer le profil
+app.studentList=Liste des étudiants
+app.users=Utilisateurs
 request.moreInfos=Plus d'Infos
 request.accept=Accepter
 request.refuse=Refuser
-#=====================================================
+courses.createCourse=Créer un cours
+courses.deleteCourse=Supprimer un cours
+courses.modify=Modifier
+courses.toDelete=Cours à supprimer
+courses.confirm=Confirmer
+courses.back=Retour
+profile.modify.data=Modifier données personnelles
+profile.reRegister=Réinsciption
+profile.unRegister=Désinscription
+profile.course.list=Liste des cours
+profile.address=Adresse
+profile.picture=Photo de profil
+profile.change.curriculum=Changer cursus
+name=Nom
+Teacher=Enseignant
+Student=Etudiant
+Secretary=Secrétaire
+Curriculum=Cursus
+Credits=Credits
+InscriptionService=S.I.
+faculty=Faculté

frontend/src/App.vue

@@ -1,25 +1,32 @@
 <script setup>
-	import 'https://kit.fontawesome.com/fb3bbd0a95.js'
   import { toast } from 'vue3-toastify';
   import { ref } from 'vue'
-  import i18n from './i18n.js'
-  import Inscription from "./Inscription.vue"
+  import i18n, { setLang } from './i18n.js'
+  import { isLogged } from '@/rest/Users.js'
 
+  import { appList, currentView } from '@/rest/apps.js'
+		var prevURL;
+		var currentURL = window.location.hash;
 
-  const test = ref();
+window.onhashchange = function() {
+    prevURL = currentURL;
+    currentURL = window.location.hash;
+}
+const Logged = ref(isLogged());
 
-	async function draw(e) {
-		test.value = (await fetch("http://localhost:8080/ping"));
-		test.value = await test.value.json();
-		toast(test.value['txt']);
+window.addEventListener('hashchange', () => {
+ if((location.hash === "#/home" && prevURL === "#/login") || (location.hash === "#/home" && prevURL === "#/profil")){
+		window.location.reload();
  }
-
+});
   const home=ref(i18n("app.home"))
   const notifications=ref(i18n("app.notifications"))
   const settings=ref(i18n("app.settings"))
   const login=ref(i18n("app.login"))
+  const active=ref(false)
 
-
+	const apps = ref([])
+	appList().then(e => apps.value = e)
 
 </script>
 
@@ -29,62 +36,58 @@
     <div class="topBar">
       <ul class="horizontal">
         <li title=home>
-            <a href="#home">
-                <img @click="draw" src="./assets/Clyde.png" style="width: 40px; height: auto; margin-top:4px">
+            <a class="icon" href="#home">
+                <img class="clyde" src="/Clyde.png" style="width: 40px; height: auto; margin-top:4px">
             </a></li>
         <li title=home>
-            <a href="#home">
+            <a class="icon" href="#home">
 				<div class=" fa-solid fa-house" style="margin-top: 7px; margin-bottom: 3px;"></div>
             </a></li>
         <li style="float: right;" title=login>
-            <a href="/login">
-                <div class="fa-solid fa-user"  style="margin-top: 7px; margin-bottom: 3px;"></div>
+            <a class="icon" href="#/login">
+                <div class="fa-solid fa-user" :style="Logged ? 'color: orange' : 'haha'" style="margin-top: 7px; margin-bottom: 3px; "></div>
             </a></li>
         <li style="float: right;" title=notifications>
-            <a href="#Notifications">
+            <a class="icon" href="#Notifications">
                 <div class="fa-solid fa-bell"  style="margin-top: 7px; margin-bottom: 3px;"></div>
             </a></li>
-        <li style="float: right;" title=settings>
-            <a href="#Options">
+        <li @click="active=!active" class="option"style="float: right;" title=settings>
+            <a class="icon" >
                 <div  class="fa-solid fa-gear"  style="margin-top: 7px; margin-bottom: 3px;"></div>
-            </a></li>
+                <div v-if="active" class="dropdown">
+                  <div class="dropdown-content">{{i18n("app.language")}}</div>
+                  <ul style="list-style-type:none;">
+                    <li style=" margin-bottom:10px;margin-right:20px;float:left; font-size:10px; color:black;">
+                      <button @:click="setLang('en');" href="#home">EN</button>
 
-        <li style="float:right; margin-top:7.5px;" title="Language">
-            <input type="checkbox" v-model="toggle" true-value="FR" false-value="EN" class="theme-checkbox">
                     </li>
+                    <li style="float:left;font-size:10px; color:black;"><button @:click="setLang('fr');" href="#home">FR</button></li>
+                  </ul>
+                  <div style='align-items:center;'>
+                  <a style="cursor:pointer;font-size:20px;" href="#/profil" class="dropdown-content">
+                    {{i18n("app.manage.profile")}}
+                  </a>
+                  </div>
+
+                </div>
+            </a></li>
       </ul>
     </div>
 
     <div class="leftBar">
     <ul class="vertical">
-        <li style="margin-top: 25px;" >
-          <a href="#Messages">
-            <div class="fa-solid fa-comment" style="font-size: 40px;"></div>
-            <div class="text">{{i18n("app.messages")}}</div>
-          </a></li>
-        <li >
-          <a href="#Notifications">
-            <div class="fa-solid fa-bell" style="font-size: 40px;" ></div>
-            <div class="text">{{i18n("app.notifications")}}</div>
-          </a></li>
-        <li >
-          <a href="#Schedule">
-            <div class="fa-solid fa-calendar-days" style="font-size: 40px;"></div>
-            <div class="text">{{i18n("app.schedules")}}</div>
-          </a></li>
-        <li ><a href="#Forum">
-            <div class="fa-solid fa-envelope" style="font-size: 40px;" ></div>
-            <div class="text">{{i18n("app.forum")}}</div></a></li>
-        <li><a href="#Inscription">
-            <div class="fa-solid fa-users" style="font-size: 40px;"></div>
-            <div class="text">{{i18n("app.inscription.requests")}}</div></a></li>
+        <li v-for="app in apps">
+						<a :href="app.path">
+            <div class="fa-solid" :class="app.icon" style="font-size: 40px;"></div>
+            <div class="text">{{app.text}}</div>
+						</a>
+				</li>
     </ul>
-
     </div>
     <div class="page">
-      <div style=" margin:50px;">
-        <Inscription></Inscription>
-      </div>
+        <Suspense>
+				<component :is="currentView" />
+        </Suspense>
     </div>
   </div>
 </template>
@@ -92,6 +95,8 @@
 <style scoped>
   
   .container{
+			height: 100%;
+			width: 100%;
     display:grid;
     grid-template-columns:[firstCol-start]70px[firstCol-end secondCol-start]auto[endCol];
     grid-template-rows:[firstRow-start]61px[firstRow-end secondRow-start] auto [endRow];
@@ -104,6 +109,8 @@
 
   .page {
     grid-area:page;
+		height: 100%;
+		width: 100%;
     place-self:center;
   }
 
@@ -114,8 +121,37 @@
   .leftBar{
     grid-area:leftBar;
   }
+.option {
+  position: relative;
+  display: block;
+}
 
 
+.dropdown {
+  margin-top:55px;
+  width:160px;
+  display: inline-block;
+  height:110px;
+  font-size: 13px;
+  position: absolute;
+  z-index: 1;
+  background-color:white;
+}
+
+.dropdown-content { 
+  min-width: 160px;
+  text-align: center;
+  margin-bottom: 10px;
+  right:0;
+  color:rgb(50,50,50);
+  text-decoration: none;
+  font-size:24px
+}
+
+  .dropdown-content div{
+    display:block;
+  }
+
 	ul.vertical{
 		list-style-type: none;
 		margin-top: 61px;
@@ -168,7 +204,6 @@
 		position: fixed;
 		height:61px;
 		width: 100%;
-		overflow: hidden;
 		background-color: rgb(24, 24, 24);
 	}
 
@@ -179,7 +214,7 @@
 	}
 
 
-	ul.horizontal li a:hover:not(.active){
+	ul.horizontal li a.icon:hover:not(.active){
 		background-color: black;
 		border-radius:6px;
 		color:white;
@@ -197,7 +232,6 @@
 	  }
 
 	  .text {
-		position: absolute;
 		right: 0%;
 		width: 0%;
 		opacity: 0;
@@ -209,55 +243,15 @@
 
 	  ul.vertical:hover .text {
 		opacity: 1;
-		width: 70%;
+		width: 60%;
 		transition-duration: .3s;
-		padding-left: 5px;
-	  }
-    .theme-checkbox {
-    --toggle-size: 16px;
-    -webkit-appearance: none;
-    -moz-appearance: none;
-    appearance: none;
-    width: 80px;
-    height: 40px;
-    background: -webkit-gradient(linear, left top, right top, color-stop(50%, #efefef), color-stop(50%, #2a2a2a)) no-repeat;
-    background: -o-linear-gradient(left, #efefef 50%, rgb(239, 60, 168) 50%) no-repeat;
-    background: linear-gradient(to right, #efefef 50%, rgb(239, 60, 168) 50%) no-repeat;
-    background-size: 205%;
-    background-position: 0;
-    -webkit-transition: 0.4s;
-    -o-transition: 0.4s;
-    transition: 0.4s;
-    border-radius: 99em;
-    position: relative;
-    cursor: pointer;
-    font-size: var(--toggle-size);
+		padding-left: 15px;
 	  }
 
-    .theme-checkbox::before {
-    content: "";
-    width: 35px;
-    height: 35px;
-    position: absolute;
-    top: 2px;
-    left: 3px;
-    background: -webkit-gradient(linear, left top, right top, color-stop(50%, #efefef), color-stop(50%, #2rgb(239, 60, 168))) no-repeat;
-    background: -o-linear-gradient(left, #efefef 50%, rgb(239, 60, 168) 50%) no-repeat;
-    background: linear-gradient(to right, #efefef 50%, rgb(239, 60, 168) 50%) no-repeat;
-    background-size: 205%;
-    background-position: 100%;
-    border-radius: 50%;
-    -webkit-transition: 0.4s;
-    -o-transition: 0.4s;
-    transition: 0.4s;
+	  .clyde:hover{
+		  content: url("./assets/angry_clyde.png")
 	  }
     
-    .theme-checkbox:checked::before {
-    left: calc(100% - 35px - 3px);
-    background-position: 0;
-    }
-
-    .theme-checkbox:checked {
-    background-position: 100%;
-    }
 </style>
+
+<!-- vim:set noet sts=0 sw=4 ts=2: --> 

frontend/src/Apps/Inscription.vue

@@ -1,29 +1,31 @@
 <script setup>
-  import i18n from "./i18n.js"
-  const props = defineProps({
-  id: Number,
-  type: String,
-  lastName: String,
-  firstName: String,
-  address: String,
-  country: String,
-  birthDate: String,
-  cursus:String,
-  degree:String,});
+  import i18n from "@/i18n.js"
+  import {ref} from 'vue'
+  import {validateRegister, getAllRegisters } from '@/rest/ServiceInscription.js'
+
+  const requests = ref(await getAllRegisters());
+  console.log(requests);
+
+  async function upPage(id,review){
+    await validateRegister(id,review);
+    requests.value = await getAllRegisters();
+
+  }
 </script>
 
 
-<template>
-  <div class="bodu">
-  <div class="container">
 
-    <div class="id"><a>{{id}}</a></div>
-    <div class="type"><a>{{type}}</a></div>
-    <div class="surname"><a>{{lastName}}</a></div>
-    <div class="firstname"><a>{{firstName}}</a></div>
-    <div class="infos"><button style="background-color:rgb(105,05,105);" >{{i18n("request.moreInfos")}}   </button></div>
-    <div class="accept"><button style="background-color:rgb(0,105,50);">{{i18n("request.accept")}}</button></div>
-    <div class="refuse"><button style="background-color:rgb(105,0,0);">{{i18n("request.refuse")}}</button></div>
+<template> 
+  <div style='display:flex; justify-content:center; min-width:1140px;' v-for="item of requests">
+  <div class="bodu" v-if="item.state === 'Pending'">
+  <div class="container">
+    <div class="id"><a>{{item.id}}</a></div>
+    <div class="surname"><a>{{item.lastName}}</a></div>
+    <div class="firstname"><a>{{item.firstName}}</a></div>
+    <div class="infos"><button style="background-color:rgb(105,05,105);" >{{i18n("request.moreInfos")}}</button></div>
+    <div class="accept"><button @click="upPage(item.id,'Accepted')" style="background-color:rgb(0,105,50);">{{i18n("request.accept")}}</button></div>
+    <div class="refuse"><button @click="upPage(item.id,'Refused')" style="background-color:rgb(105,0,0);">{{i18n("request.refuse")}}</button></div>
+  </div>
   </div>
   </div>
 </template>
@@ -34,10 +36,9 @@
     height:100px;
     font-size:20px;
     display:grid;
-    grid-template-columns:[firstCol-start]100px[firstCol-end secondCol-start]150px[secondCol-end thirdCol-start]200px[thirdCol-end fourthCol-start]150px[fourthCol-end]150px[fifthCol-end]150px[sixthCol-end]150px[endCol];
+    grid-template-columns:10% 14.2% 19% 14.2% 14.2% 14.2% 14.2%;
     grid-template-areas:
     "id type surname firstname infos accept refuse"; 
-    column-gap:10px;
     
   }
   
@@ -97,8 +98,8 @@
   }
 
  .bodu {
-    width:100%;
-    margin-bottom:10px;
+    margin-top:2%;
+    width:66%;
     border:2px solid black;
     border-radius:9px;
     background-color:rgb(50,50,50);
@@ -107,3 +108,4 @@
 
 </style>
 
+

frontend/src/Apps/Login.vue

@@ -1,84 +1,107 @@
 <script setup>
-  import { login , register} from './rest/Users.js'
-  import { ref } from 'vue'
-  import i18n from './i18n.js'
+  import {reactive, ref } from 'vue'
+  import i18n from '@/i18n.js'
+  import { login , register , disconnect, isLogged} from '@/rest/Users.js'
+  import { getAllCurriculums } from '@/rest/curriculum.js'
+  import { uploadProfilePicture } from '@/rest/uploads.js'
+  import {toast} from 'vue3-toastify'
+  import 'vue3-toastify/dist/index.css';
+
+
   const loginPage= ref(true)
   const page = ref(0)
   
-  const emailID=ref("")
-  const passwordIN=ref("")
-
+  const outputs = reactive({
+    surname:null,
+    firstname:null,
+    password:null,
+    birthday:null,
+    email:null,
+    address:null,
+    country:null,
+    curriculum:null,
+  })
 
   const submitValue= ref(i18n("login.guest.submit"))
-  const surname=ref("")
-  const firstname=ref("")
-  const passwordOUT=ref("")
   const passwordConfirm=ref("")
-  const birthday=ref("")
-  const emailOUT=ref("")
-  const address=ref("")
-  const country=ref("")
-  const cursus=ref("")
-  const loginInfos = [{_emailID:emailID},{_passwordIN:passwordIN}]
-  const registerInfos= [{_surname:surname},{_firstname:firstname},{_birthday:birthday},{_passwordOUT:passwordOUT},
-  {_passwordConfirm:passwordConfirm},{_emailOUT:emailOUT},{_address:address},{_country:country},{_cursus:cursus}]
+ 
+  const imageSaved = ref(false)
+  const ppData = ref(false)
+
+  const curricula= await getAllCurriculums();
+  
+  function goBackHome(){
+    setTimeout(() => {
+      window.location.href="#/home";
+      }, "500");
+ } 
+  function verifyInputs(pass){
+    if(pass==passwordConfirm.value){
+      page.value++;
+      return toast('Password and Confirm Password are correct.', {
+      
+    type: "success",});
+    }
+    else{
+    return toast('Password and Confirm Password are different',{type: "error",});
+    }
+  }
+  if (isLogged()){
+  disconnect();
+  window.location.reload();}
+
+  
 
 </script>
 
 
 <template>
-  <body>
-    <div class="Home">
-    <a href="/">
-       <img @click="draw" src="./assets/Clyde.png" style="width: 40px; height: auto; margin-top:4px">
-    </a>
-    </div>
-    <div class="logBoxCenterer">
-      <div class='loginBox'>
-
+    <div class="setup">
         <div v-if="loginPage">
-          <form @submit.prevent="login(emailID, passwordIN)"class="form">
+      <div class='loginBox' style="margin-top:30%;">
+          <form @submit.prevent="login(outputs.email,outputs.password);goBackHome();"class="form">
             <h1 style="color:rgb(239,60,168); font-family: sans-serif;">
               {{i18n("login.guest.signin")}}
             </h1>
             <div class="inputBox">
               <p>ID / {{i18n("login.guest.email")}}</p> 
-              <input type="text" v-model="emailID">
+              <input type="text" v-model="outputs.email">
             </div>
             <div class="inputBox">
               <p>{{i18n("login.guest.password")}}</p>
-              <input type="password" v-model="passwordIN">
+              <input type="password" v-model="outputs.password">
             </div>
             <div class="register">
               <a @click="loginPage=!loginPage">{{i18n("login.guest.register")}}</a>
             </div>
-            <div class="inputBox">
+            <div class="inputBox" style="margin-bottom:35px;">
               <input type="submit" v-model="submitValue">
             </div>
           </form>
         </div>
-
+      </div>
         <div v-else>
-          <form @submit.prevent="register(surname,firstname,emailOUT)" class="form">
+          <div class='loginBox' style="margin-top:30%; margin-bottom:50%;">
+            <form class="form">
             <h1 style="color:rgb(239,60,168); font-family: sans-serif; text-align:center;">
               {{i18n("login.guest.welcome")}}
             </h1>
             <div v-if="page === 0">
               <div class="inputBox">
                 <p>{{i18n("login.guest.surname")}}</p>
-                <input type="text" v-model="surname">
+                <input type="text" v-model="outputs.surname">
               </div>
               <div class="inputBox">
                 <p>{{i18n("login.guest.firstname")}}</p>
-                <input type="text" v-model="firstname">
+                <input type="text" v-model="outputs.firstname">
               </div>
               <div class="inputBox">
                 <p>{{i18n("login.guest.birthday")}}</p>
-                <input type="date" v-model="birthday">
+                <input type="date" v-model="outputs.birthday">
               </div>
               <div class="inputBox">
                  <p>{{i18n("login.guest.password")}}</p>
-                 <input type="password" v-model="passwordOUT">
+                 <input type="password" v-model="outputs.password">
               </div>
               <div class="inputBox">
                 <p>{{i18n("login.guest.confirm")}} {{i18n("login.guest.password")}}</p>
@@ -86,7 +109,7 @@
               </div>
               
               <div class="switchpage">
-                <button @click="page++">{{i18n("login.guest.nextpage")}}</button>
+                <button @click="verifyInputs(outputs.password);">{{i18n("login.guest.nextpage")}}</button>
 
               </div>
               <div @click="(loginPage=!loginPage) && (page=0)" class="register">
@@ -96,26 +119,34 @@
             <div v-else>
               <div class="inputBox">
                 <p>{{i18n("login.guest.email")}}</p>
-                <input type="mail" v-model="emailOUT">
+                <input type="mail" v-model="outputs.email">
               </div>
               <div class="inputBox">
                 <p>{{i18n("login.guest.address")}}</p>
-                <input type="text" v-model="address">
+                <input type="text" v-model="outputs.address">
               </div>
               <div class="inputBox">
                 <p>{{i18n("login.guest.country")}}</p>
-                <input type="text" v-model="country">
+                <input type="text" v-model="outputs.country">
               </div>
+              <form class="inputBox"novalidate enctype="multipart/form-data">
+              	<p>{{i18n("profile.picture").toUpperCase()}}</p>
+              <label class="browser">
+                Parcourir . . .
+				        <input  type="file" :disabled="imageSaved" @change="ppData = uploadProfilePicture($event.target.files); imageSaved = true;" accept="image/*">
+              </label>
+              </form>
               <div class="inputBox">
-                <p>CURSUS</p> 
-                  <select v-model="cursus">
-                    <option value="Chemistry">Chemistry</option>
-                    <option value="Psycho">Psychology</option>
-                    <option value="IT">IT</option>
+                <p>{{i18n("Curriculum").toUpperCase()}}</p> 
+                  <select v-model="outputs.curriculum">
+                    <option v-for="item in curricula">{{item.curriculumId}}</option>
+                    
                   </select>
               </div>
               <div style="align-self:center;" class="inputBox">
-                <button style="margin-top:25px;" @click="console.log(outputs)">{{i18n("login.guest.submit")}}</button>
+                <button style="margin-top:25px;" @click="register(outputs.firstname, outputs.surname, outputs.birthday, outputs.password, outputs.email, outputs.address, outputs.country, outputs.curriculum, ppData);">
+                  {{i18n("login.guest.submit")}}
+                </button>
               </div>
               <div  class="switchpage">
                 <button @click="page--">{{i18n("login.guest.lastpage")}}</button>
@@ -128,45 +159,24 @@
          </div>
     </div>
   </div>
-  </body>
 </template>
 
 <style scoped>
-.Home{
-  position:absolute;
- 	display: flex;
-  z-index: 100;
-	padding: 8px 16px;
-	color:rgb(255, 255, 255);
-	text-decoration: none;
-}
 
-.Home:hover{
-  width:40px;
-  background-color: black;
-	border-radius:6px;
-	color:white;
-  transform: translate(0px ,1px);
-}
+.setup {
+  margin-left: auto;
+  margin-right:auto;
+  min-width:400px;
 
-.logBoxCenterer {
-  position: absolute;
-  width: 100%;
-  height:  100%;
-  display: flex;
-  align-items: center;
-  justify-content: center; 
-  overflow: hidden;
+  width:25%;
+  height:60%;
 }
 
 .loginBox {
   background-color: rgb(24,24,24);
-  position : absolute;
-  width: 400px;
   display:flex;
   justify-content: center;
-  padding: 40px;
-  border-radius: 20px;
+  border-radius: 5%;
   box-shadow:0 5px 25px #000000;
   
 }
@@ -175,23 +185,21 @@
   width:100%;
   display: flex;
   flex-direction: column;
-  justify-content: center;
   align-items:center;
-  gap: 15px;
+  gap: 3%;
 }
 
 
 .inputBox input,button,select {
   
   width:100%;
-  background:rgb(255, 0 255);
   border: none;
-  margin-right: 50px;
-  padding-left: 10px;
-  padding-top:10px;
-  padding-bottom:10px;
+  margin-right: 12.5%;
+  padding-left: 2.5%;
+  padding-top:2.5%;
+  padding-bottom:2.5%;
   outline:none;
-  border-radius: 4px;
+  border-radius: 10px;
   font-size:1.35em;
 }
 
@@ -206,8 +214,9 @@
 
 .register{
   color:rgb(239,60,168);
-  width: 100%;
-  display:flex;
+  width:70%;
+  margin-bottom:20px;
+  margin-top:20px;
   cursor: pointer;
 }
 
@@ -236,6 +245,21 @@ input[type=submit],button,select{
 
 }
 
+input[type=file]{
+  display:none;
+}
+
+.browser{
+  display:inline-block;
+  cursor:pointer;
+  border-radius:20px;
+  background-color:rgb(239,60,168);
+  padding:5%;
+  font-size:1.35em;
+  font-family:sans-serif;
+  background:#FFFFFF;
+}
+
 button:active ,.switchpage:active{
   opacity:0.8;
 

frontend/src/Apps/ManageCourses.vue

@@ -0,0 +1,291 @@
+<script setup>
+  import i18n from "@/i18n.js"
+  import {reactive , ref} from 'vue'
+  import { getCourses,deleteCourse,alterCourse,createCourse } from "@/rest/courses.js"
+  import {getUser, getSelf, getTeachers } from "@/rest/Users.js"
+  
+  
+  const self = await getSelf();
+
+  const curriculum = ref(await getCourses(self.role));
+  const profList = await getTeachers();
+
+
+  const createMod = ref(false)
+  const deleteMod = ref(false)
+
+  const editElementID = ref("")
+
+  function editItem(id){
+    editElementID = id;
+  }
+
+  //Juste pour montrer le Create Mode
+    
+  const pattern = {
+    "title":null,
+    "credits":null,
+    "owner":null,
+  }
+
+  let toModify = Object.assign({},pattern);
+  let toAdd = Object.assign({}, pattern);
+
+  async function addToCourse(){
+    let isnull= false;
+     
+    for(const [key, value] of Object.entries(toAdd)){
+      console.log(toAdd.owner);
+      if(value === null){
+        isnull=true;
+      }
+      
+    }
+    if (!isnull){
+       await createCourse(toAdd.title,toAdd.credits,toAdd.owner);
+       toAdd= Object.assign({},pattern);
+
+       curriculum.value = await getCourses(self.role);
+
+
+    }}
+  
+  function setModify(item){
+     for(const el in profList){
+
+           if(profList[el].regNo === item.owner.regNo){
+        toModify.owner= profList[el];
+      }
+     }
+     toModify.credits= item.credits;
+     toModify.title= item.title;
+  }
+
+
+  async function patchCourse(course){
+    for (let element in toModify){
+        console.log(toModify,1)
+        console.log(toModify[element],2)
+      
+        if (element =="owner" && (toModify[element].regNo != course.owner.regNo)){
+          await alterCourse(course.courseId,{owner:toModify[element].regNo});
+        }
+        else if(element == "title" && (toModify[element] != course.title)){
+         await alterCourse(course.courseId,{title:toModify[element]});
+        }
+        else if(element == "credits" && (parseInt(toModify[element]) != course.credits)){
+         await alterCourse(course.courseId,{credits:parseInt(toModify[element])});
+        }
+    }
+      toModify= Object.assign({},pattern);
+
+      curriculum.value = await getCourses(self.role);
+
+    
+  }
+  //Juste pour montrer le Delete Mode
+  let toRemove = null;
+  
+  async function removeCourse(course) {
+      
+     await deleteCourse(course.courseId)
+    curriculum.value = await getCourses(self.role);
+    toRemove = null;
+}
+
+</script>
+<template>
+  <div class="body">
+    <div v-if="!deleteMod && !createMod && (self.role !== 'Teacher')" class="listTitle buttonGrid">
+      <button class="create" @click="editElementID= '';createMod = true;">
+        {{i18n("courses.createCourse")}}
+      </button>
+      <button class="delete" @click="deleteMod=true" >
+        {{i18n("courses.deleteCourse")}}
+      </button>
+    </div>
+    <div v-if="createMod">
+      <form class="listElement" style="width:40%;margin-right:auto;margin-left:auto;">
+        
+        <div style="margin-bottom:20px;">
+         {{i18n("name")}} : 
+        <input v-model="toAdd.title">
+        </div>
+        <div style="margin-bottom:20px;">
+          {{i18n("Teacher")}} : 
+         <select style="max-width:200px;" class="teacher" v-model="toAdd.owner">
+           <option v-for="item in profList" :value="item">{{item.lastName}}</option>
+        </select>
+        </div>
+        <div style="margin-bottom:20px;">
+          {{i18n("Credits")}} : 
+        <input v-model="toAdd.credits">
+        </div>
+      <button class="create" @click="createMod=!createMod; addToCourse();"> {{i18n("courses.confirm")}} </button>
+      <button style="float:right;" @click="createMod=!createMod">{{i18n("courses.back")}}</button>
+      </form>
+    </div>
+    <div v-if="deleteMod">
+      <form class="listElement" style="width:40%;margin-right:auto;margin-left:auto;">
+        <div style="margin-bottom:20px;">
+          {{i18n("courses.toDelete")}} :
+         <select style="max-width:200px;" class="teacher" v-model="toRemove">
+          <option v-for="item in curriculum" :value='item'>{{item.title}}</option>
+          
+        </select>
+        </div>
+        <button class="delete" @click="deleteMod=!deleteMod; removeCourse(toRemove);"> {{i18n("courses.deleteCourse")}} </button>
+        <button style="float:right;" @click="deleteMod=!deleteMod"> {{i18n("courses.back")}}</button>
+      </form>
+    </div>
+
+    <div v-if="!createMod && !deleteMod" v-for="item in curriculum" :key="item.title" style="width:50%;margin-left:auto; margin-right:auto;">
+      <div  v-if="editElementID !== item.title" style ="padding:15px 15px 15px 15px;">
+        <button   @click="editElementID = item.title; setModify(item); ">
+        {{i18n("courses.modify")}}
+        </button>
+      </div>
+      <div v-else>
+        <button @click="editElementID= '';patchCourse(item)"> {{i18n("courses.confirm")}} </button>
+        <button @click="editElementID= '';"> {{i18n("courses.back")}} </button>
+      </div>
+      <div  class="listElement" >
+
+      <div class="containerElement" v-if="editElementID !== item.title" >
+
+        <div class="name"> {{item.title}} </div>
+        <div class="teacher">{{item.owner.lastName}}</div> 
+        <div class="credits">{{i18n("Credits")}}:{{item.credits}}</div>  
+      </div>
+      <div class="containerElement"v-else>
+        <input style="max-width:200px;" class="name" v-model="toModify.title">
+        <select v-if="self.role === 'Secretary'" style="max-width:200px;" class="teacher" v-model="toModify.owner">
+          <option v-for="(item,index) in profList" :value='item'>{{item.lastName}}</option>
+        </select>
+        <div v-else class="teacher">{{item.owner.lastName}}</div> 
+        <input v-if="self.role==='Secretary'"style="max-width:100px;"class="credits" v-model="toModify.credits">  
+        <div v-else class="credits">{{i18n("Credits")}}:{{item.credits}}</div>  
+      </div>
+    </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+.body {
+    width:100%;
+    margin-top:3.5%;
+  }
+
+.infosContainer {
+  min-width:350px;
+  padding-bottom:50px;
+  border:2px solid black;
+  font-size:25px;
+  color:white;
+  padding:20px;
+  background-color:rgb(50,50,50);
+  border-radius:20px;
+}
+
+ .containerElement{ 
+    justify-content:center;
+    display:grid;
+    grid-template-columns:38.8% 38.8% 22.4%;
+    grid-template-areas:
+    "name teacher credits"; 
+    column-gap:10px;  }
+  
+  .name {
+    grid-area:name;
+    align-self:center;
+  }
+
+  .teacher{
+    grid-area:teacher;
+    align-self:center;
+  }
+
+  .credits{
+    grid-area:credits;
+    align-self:center;
+  }
+
+.listElement{
+ min-width:625px;
+  border:2px solid black;
+  font-size:25px;
+  color:white;
+  padding:20px;
+  background-color:rgb(50,50,50);
+  border-radius:20px;
+  margin-bottom:10px;
+
+}
+
+.modify{
+  font-size:25px;
+  padding:10px 10px 10px 10px;
+  background-color: rgb(239,60,168);
+  cursor: pointer;
+  border:none;
+  border-radius:15px;
+}
+
+  input, select{
+  padding:10px 10px 10px 10px; 
+  font-size:25px;
+  cursor: pointer;
+  border:none;
+  border-radius:15px;
+  }
+  button{
+    font-size:15px;
+     height:50px;
+     width:100px;
+    border:none;
+    border-radius:20px;
+
+  }
+
+  .buttonGrid{
+    display:grid;
+    grid-template-columns: auto auto;
+    column-gap:50px;
+    grid-template-areas:
+      "create delete";
+  }
+
+  .create{
+    grid-area:create;
+    
+    background-color:rgb(0,200,0);
+
+  }
+
+  .delete{
+    grid-area:delete;
+    background-color:rgb(200,0,0);
+  }
+
+  .listTitle{
+    min-width:380px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width:25%;
+    margin-left:auto;
+    margin-right:auto;
+    border:2px solid black;
+    font-size:25px;
+    color:white;
+    padding:20px;
+    background-color:rgb(50,50,50);
+    border-radius:20px;
+    margin-bottom:10px;
+
+    button:hover{
+      opacity:0.8;
+    }
+}
+</style>

frontend/src/Apps/Profil.vue

@@ -0,0 +1,329 @@
+<script setup>
+  import {reactive, ref } from 'vue'
+  import {getSelf,alterSelf,disconnect,deleteUser} from '../rest/Users.js'
+  import {getSelfCurriculum, getAllCurriculums} from '../rest/curriculum.js'
+  import {getCourses} from "../rest/courses.js"
+  import i18n from "@/i18n.js"
+  import { uploadProfilePicture } from '@/rest/uploads.js'
+
+  const user = ref(await getSelf());
+  const UserCurriculum = ref(""); 
+  const curricula = ref (await getAllCurriculums());
+  if(user.value.role === "Student"){
+    UserCurriculum.value = await getSelfCurriculum();
+  }
+
+  if(user.role === "Teacher"){
+    UserCurriculum.value = await getCourses("Teacher");
+  }
+  const modif = ref(false);
+  const curric = ref(false);
+  const reg = ref(false);
+
+  const pattern = {
+    profilPictureUrl:null,
+    email:null,
+    address:null,
+    password:null,
+  };
+  
+  const patternInfos ={
+    email: null,
+    password: null,
+    passwordConfirm:null,
+    id:null,
+  }
+
+  
+  let toModify= Object.assign({}, pattern);
+  let personnalInfos =  Object.assign({}, patternInfos);
+  
+  function resetInputs(inputs,list){
+    inputs=Object.assign({},list); 
+  }
+  
+  async function ChangeInfos(){
+    for (let element in toModify){
+         if (element =="email" && (toModify[element] !== null)){
+          await  alterSelf(user.value.regNo,{email : toModify[element]});
+        }      
+
+        if (element =="profilPictureUrl" && (toModify[element] !== null)){
+          await  alterSelf(user.value.regNo,{ profilPictureUrl : toModify[element]});
+        }
+        else if(element == "address" && (toModify[element] !== null)){
+          await  alterSelf(user.value.regNo,{address : toModify[element]});
+        }
+        else if(element == "password" && (toModify[element] !== null)){
+          await  alterSelf(user.value.regNo,{password : toModify[element]});
+        }
+    }
+      toModify= Object.assign({},pattern);
+        user.value = await getSelf()
+
+   } 
+  
+  function setModify(item){
+     toModify.address = item.address;
+     toModify.profilPictureUrl = item.profilPictureUrl;
+     toModify.email= item.email;
+     toModify.password= item.password;
+  }
+
+  
+  async function unRegister(){
+   deleteUser(user.value.regNo);
+   disconnect()
+   setTimeout(() => {
+      window.location.href="#/home";
+      }, "500");
+    
+  }
+
+  function getPP(){
+    if(user.value.profilePictureUrl === null){
+      return "/Clyde.png"
+    }
+    return user.profilePictureUrl
+  }
+</script>
+
+<template>
+  <div class="body">
+  <div class="container">
+    <div class="profilPic">
+      <img class="subContainter" :src=getPP()>
+
+    </div>
+      <div class="globalInfos">
+        <div v-if="modif==false && curric==false && reg==false " class="infosContainer" >
+          <div>
+            {{user.firstName}} {{user.lastName}}   
+          </div>
+          <div>
+            E-mail: {{user.email}}      
+          </div>
+          <div v-if="user.role==='Student'">
+            {{user.option}} {{i18n(user.role)}} 
+          </div>
+          <div v-else>
+            Role:  {{i18n((user.role))}} 
+          </div>
+          <div>
+            <button @click="modif=!modif; setModify(user)"> {{i18n("profile.modify.data")}} </button>
+          </div>
+          <div v-if="(user.role==='Student')">
+            <button @click="reg=!reg">{{i18n("profile.reRegister")}}</button>
+            <button @click="unRegister()" style="float:right;background-color:rgb(150,0,0);">{{i18n("profile.unRegister")}}</button>
+          </div>
+          <div v-if="(user.role==='Student')">
+            <button @click="curric=!curric">{{i18n("profile.change.curriculum")}}</button>
+          </div>
+        </div>
+        <div v-else-if="modif" class="infosContainer">
+          <div>
+            {{i18n("profile.picture")}}:
+            <input type="file" @change="user.profilPicture = uploadProfilePicture($event.target.files);" accept="image/*">
+          </div>
+          <div>
+            E-mail:  
+            <input type="mail" v-model="toModify.email" />
+          </div>
+          <div>
+            {{i18n("profile.address")}}:
+            <input type="text" v-model="toModify.id">
+          </div>
+          <div>
+            {{i18n("login.password")}}:
+            <input type="password" v-model="toModify.password">
+          </div>
+          <div>
+            {{i18n("login.cPassword")}}:
+            <input type="password" v-model="toModify.passwordConfirm">
+          </div>
+          <div>
+            <button @click=" modif=!modif; ChangeInfos();">{{i18n("courses.confirm")}}</button>
+            <button @click="modif=!modif; resetInputs(toModify,pattern);" style="float:right;">{{i18n("courses.back")}}</button>
+          </div>
+        </div>
+        <div v-else-if="curric" class="infosContainer">
+          <div style="height:40px;">
+            {{i18n("Curriculum")}}:  
+            <select v-model="curriculum" >
+              <option v-for="item in curricula" style="font-size:20px;" :value="item">{{item.option}}</option>        
+            </select>
+          </div>
+
+          <div>
+            <button @click=" curric=!curric;">{{i18n("courses.confirm")}}</button>
+            <button @click="curric=!curric; resetInputs(personnalInfos,patternInfos);" style="float:right;">{{i18n("courses.back")}}</button>
+          </div>
+        </div>
+        <div v-else-if="reg" class="infosContainer">
+          <div>
+            E-mail:  
+            <input type="mail" v-model="toModify.email" />
+          </div>
+          <div>
+            ID :
+            <input type="text" v-model="toModify.id">
+          </div>
+          <div>
+            {{i18n("login.password")}}:
+            <input type="password" v-model="toModify.password">
+          </div>
+          <div>
+            {{i18n("login.cPassword")}}:
+            <input type="password" id="confirm">
+          </div>
+
+          <div>
+            <button @click=" reg=!reg;">{{i18n("courses.confirm")}}</button>
+            <button @click=" reg=!reg; resetInputs(personnalInfos,patternInfos);" style="float:right;">{{i18n("courses.back")}}</button>
+          </div>
+        </div>
+
+      </div>
+      
+      <div v-if="modif==false && curric==false && reg==false "class="moreInfos">
+
+        <div v-if="(user.role ==='Student')">
+          <div class="listTitle">
+            {{i18n("profile.course.list")}}
+          </div>
+          <div  class="listElement" v-for="item in UserCurriculum.courses">
+          <div class=" containerElement">
+            <div class="name"> {{item.title}} </div>
+            <div class="teacher">{{item.owner.lastName}}</div> 
+            <div class="credits">Credits:{{item.credits}}</div>  
+          </div>
+          </div>
+        </div>
+        
+        <div>
+        </div>
+    
+      </div>
+  </div>
+</div>
+</template>
+<style scoped>
+
+.container{
+  min-width:675px;
+  display:grid;
+  grid-template-columns:10vw 50vw;
+  grid-template-rows:200px auto;
+  column-gap:2.7%;
+  row-gap:45px;
+  grid-template-areas:
+  "profilPic globalInfos"
+  "minfos minfos";
+}
+
+.profilPic{
+  width:100%;
+  grid-area:profilPic;
+}
+
+.globalInfos {
+  grid-area:globalInfos;
+  align-self :center;
+
+}
+
+.subContainter{
+  width:100%;
+  background-color:rgb(50,50,50);
+  border-radius:20px;
+  border:4px solid black;
+}
+
+.moreInfos {
+  grid-area:minfos;
+}
+.body {
+    min-width:960px;
+    width:100%;
+    display:flex;
+    align-items:center;
+    justify-content:center;
+    margin-top:5%;
+  }
+ .containerElement{ 
+   justify-content:center;
+    display:grid;
+    grid-template-columns:38.8% 38.8% 22.4%;
+    grid-template-areas:
+    "name teacher credits"; 
+    column-gap:10px;
+    
+  }
+  
+  .name {
+    grid-area:name;
+    align-self:center;
+  }
+
+  .teacher{
+    grid-area:teacher;
+    align-self:center;
+  }
+
+  .credits{
+    grid-area:credits;
+    align-self:center;
+  }
+
+.listTitle{
+    min-width:197px;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width:8vw;
+    margin-left:auto;
+    margin-right:auto;
+    border:2px solid black;
+    font-size:25px;
+    color:white;
+    padding:20px;
+    background-color:rgb(50,50,50);
+    border-radius:20px;margin-bottom:10px;
+}
+
+.listElement{
+  min-width:625px;
+  border:2px solid black;
+  font-size:25px;
+  color:white;
+  padding:20px;
+  background-color:rgb(50,50,50);
+  border-radius:20px;
+  margin-bottom:10px;
+}
+
+.infosContainer {
+min-width:350px;
+padding-bottom:50px;
+border:2px solid black;
+font-size:25px;
+color:white;
+padding:20px;
+background-color:rgb(50,50,50);
+border-radius:20px;
+}
+
+
+button{
+  border:none;
+  background-color:rgb(239, 60, 168);
+  border-radius:10px;
+  height:35px;
+  margin-top:10px;
+
+}
+
+button:hover{
+  opacity:0.8;
+}
+</style>

frontend/src/Apps/Schedule.vue

@@ -0,0 +1,211 @@
+<script setup>
+  import { ref } from 'vue'
+ 
+  const schedule = [
+    {course:"Math Pour L'info",
+     start:"Wed Mar 27 2024 10:15 GMT+0100",
+     end:"Wed Mar 27 2024 12:15 GMT+0100"},
+    {
+      course:"Calculus",
+      start:"Wed Mar 27 2024 08:00 GMT+0100",
+      end:"Wed Mar 27 2024 10:00 GMT+0100"
+      
+  },
+  {
+      course:"Physique II",
+      start:"Tue Mar 26 2024 10:15 GMT+0100",
+      end:"Tue Mar 26 2024 12:15 GMT+0100"      
+  },
+    {
+      course:"Math Pour L'info",
+      start:"Thu Mar 28 2024 10:15 GMT+0100",
+      end:"Thu Mar 28 2024 12:15 GMT+0100"      
+  }]
+  function formatDate(date) {
+    var d = new Date(date),
+        month = '' + (d.getMonth() + 1),
+        day = '' + d.getDate(),
+        year = d.getFullYear();
+
+    if (month.length < 2) 
+        month = '0' + month;
+    if (day.length < 2) 
+        day = '0' + day;
+
+    return [day, month, year].join('-');
+  }
+  function getMonday(d) {
+    d = new Date(d);
+    var day = d.getDay(),
+    diff = d.getDate() - day + (day == 0 ? -6 : 1);
+    return new Date(d.setDate(diff));
+  }
+
+  function getAnyDays(d){
+
+    var day = new Date(mondayOfWeek.value);
+    day.setDate(day.getDate() + d );
+
+    return day;
+  }
+
+  const mondayOfWeek=ref(getMonday(new Date(schedule[1].start)))
+
+  function isNotCourse(element){
+    return element==null;
+  }
+
+  function durationCourse(element){
+    const hour = element.end.substring(3,5) -element.start.substring(3,5);
+    
+    
+    return (element.end - element.start)%2;
+  }
+  function sortByDate(a, b) {
+    const nameA = a.start; // ignore upper and lowercase
+    const nameB = b.start; // ignore upper and lowercase
+    
+    if (nameA < nameB) {
+      return -1;
+    }
+    if (nameA > nameB) {
+      return 1;
+    }
+    return 0; 
+      }
+
+  function transpose(a) {
+    const trans = [[],[],[],[],[],[]];
+    for(let i = 0; i < 6;i++){
+      for(let j=0; j< 7; j++){
+        if(a[j][i] !== null){
+          trans[i].push(a[j][i]);
+        }
+      }
+    }
+    return trans;
+}
+
+  function matrixFromList(list){
+    const matrix = [[],[],[],[],[],[],[]];
+    for(let key in list){
+      const temp = [];
+      const day = new Date(list[key].start);
+      matrix[day.getDay()].push(list[key]);
+      matrix[day.getDay()].sort((a,b) => sortByDate(a,b));
+    }
+      return matrix;
+  }
+
+  
+  const schedule2 = matrixFromList(schedule);
+  const scheduleByWeek = transpose(schedule2);
+  
+  console.log(scheduleByWeek)
+
+</script>
+<template>
+  <div class="grid">
+    <div class="options" >
+    </div>
+    <div class="schedule">
+      <table class="table">
+        <tr style="background-color:rgb(24,24,24)">
+          <th/>
+          <th class="header">Lundi {{formatDate(getAnyDays(0))}}</th>
+          <th class="header">Mardi {{formatDate(getAnyDays(1))}}</th>
+          <th class="header">Mercredi {{formatDate(getAnyDays(2))}}</th>
+          <th class="header">Jeudi {{formatDate(getAnyDays(3))}}</th>
+          <th class="header">Vendredi {{formatDate(getAnyDays(4))}}</th>
+          <th class="header">Samedi {{formatDate(getAnyDays(5))}}</th>
+          <th class="header">Dimanche {{formatDate(getAnyDays(6))}}</th>
+        </tr>
+        <tr v-for="(n,index) in 12">
+          <th class="hour">{{8 + index}}:00-{{9+index}}:00</th>
+            <td v-for="m in 7"></td>
+        </tr>
+      </table>
+      <div class="courseGrid">
+        <div v-for="i in 7">
+          Test
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+<style scoped>
+  .grid{
+    display:grid;
+    margin-top:2%;
+    align-items:center;
+    justify-content:center;
+    grid-template-columns:15vw 70vw;
+    column-gap:2.5vw;
+
+    grid-template-areas:"options schedule";
+  }
+  .schedule{
+    position:relative;  
+    border-radius:20px;
+    grid-area:schedule;
+    width:100%;
+    height:85vh;
+    background-color:rgba(255,255,255,0.1);    
+  }
+  .options{
+    border-radius:20px;
+    grid-area:options;
+    background-color:rgba(255,255,255,0.1);
+    width:100%;
+    height:85vh;
+  }
+
+  .table{
+    width:100%;
+    height:100%;
+    border-spacing:0;
+    border-collapse:separate;
+    border-radius: 20px;
+    border: 2px solid black
+  }
+  
+  .hour{
+    background-color:rgb(72,72,72)
+
+  }
+  
+  .header{
+    align-items:center;
+    width:12.5%;
+    color:#FFFFFF;
+  }
+  table th:not(:last-child),
+  table td:not(:last-child) {
+  border-right: 1px solid black;
+  }
+  
+  table tr:not(:last-child)>td,
+  table tr:not(:last-child)>th
+  {
+    border-bottom:1px solid black;
+  }
+  
+  .courseGrid{
+    top:13.75%;   
+    left:12.5%;
+    position:absolute;
+    width:87.5%;
+    height:86.25%; 
+    display:grid;
+    grid-template-columns:repeat(7,1fr);
+      }
+  
+
+  .course{
+    width:100%;
+    height:100%;
+    background-color:rgb(100,0,100);
+  }
+
+  
+</style>

frontend/src/Apps/StudentsList.vue

@@ -0,0 +1,84 @@
+<script setup>
+  import i18n from "@/i18n.js"
+  import { reactive  } from 'vue'
+  import { getStudents } from '../rest/Users.js'
+
+  const users = await getStudents();
+</script> 
+<template style="margin-top:5%;">
+  <div style="display:flex; justify-content:center; " v-for="item in users">
+    <div class="bodu">
+      <div class="container">
+        <div class="status"><a style="margin-left:30px">{{item.status}}</a></div>
+        <div class="option"><a>{{item.role}}</a></div>
+        <div class="surname"><a>{{item.lastName}}</a></div>
+        <div class="firstname"><a>{{item.firstName}}</a></div>
+        <div class="infos"><button style="background-color:rgb(105,05,105);" >{{i18n("request.moreInfos")}}   </button></div>
+    </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+  .container{
+    color:white;
+    height:100px;
+    font-size:30px;
+    display:grid;
+    grid-template-columns:21.7% 21.7% 21.7% 21.7% 13.1%;
+    grid-template-areas:
+    "status option surname firstname infos"; 
+    
+  }
+  
+  .infos {
+    grid-area:infos;
+    align-self:center;
+  }
+
+  .option{
+    grid-area:option;
+    align-self:center;
+  }
+
+  .status{
+    grid-area:status;
+    align-self:center;
+  }
+
+  .surname{
+    grid-area:surname;
+    align-self:center;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow:ellipsis;
+  }
+
+  .firstname{
+    grid-area:firstname;
+    align-self:center;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow:ellipsis;
+  }
+
+  button{
+    font-size:15px;
+     height:50px;
+     width:75%;
+    border:none;
+    border-radius:20px;
+
+  }
+
+  .bodu {
+    margin-top:2%;
+    width:66%;
+    border:2px solid black;
+    border-radius:9px;
+    background-color:rgb(50,50,50);
+  }
+
+
+</style>
+

frontend/src/Apps/UsersList.vue

@@ -0,0 +1,81 @@
+
+<script setup>
+  import i18n from "@/i18n.js"
+  import { reactive  } from 'vue'
+  import { getAllUsers } from '../rest/Users.js'
+
+  const users = await getAllUsers();
+  
+</script> 
+<template style="margin-top:5%;">
+  <div style="display:flex; justify-content:center; min-width:1140px;" v-for="item in users">
+    <div class="bodu">
+      <div class="container">
+        <div class="role"><a style="margin-left:30px">{{i18n(item.role)}}</a></div>
+        <div class="surname"><a>{{item.lastName}}</a></div>
+        <div class="firstname"><a>{{item.firstName}}</a></div>
+        <div class="infos"><button style="background-color:rgb(105,05,105);" >{{i18n("request.moreInfos")}}   </button></div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<style scoped>
+  .container{
+    color:white;
+    height:100px;
+    font-size:30px;
+    display:grid;
+    grid-template-columns:27.7% 27.7% 27.7% 16.9%;
+    grid-template-areas:
+    "role surname firstname infos"; 
+
+  }
+  
+  .infos {
+
+    grid-area:infos;
+    align-self:center;
+  }
+
+  .role {
+    grid-area:role;
+    align-self:center;
+  }
+
+  .surname{
+    grid-area:surname;
+    align-self:center;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow:ellipsis;
+
+  }
+
+  .firstname{
+    grid-area:firstname;
+    align-self:center;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow:ellipsis;
+
+  }
+
+  button{
+    font-size:15px;
+     height:50px;
+     width:75%;
+    border:none;
+    border-radius:20px;
+
+  }
+
+  .bodu {
+    margin-top:2%;
+    width:66%;
+    border:2px solid black;
+    border-radius:9px;
+    background-color:rgb(50,50,50);
+  }
+</style>
+

frontend/src/Inscription.vue

@@ -1,32 +0,0 @@
-<script setup>
-  import Req from "./Request.vue"
-  const requests_example = [ {
-  id:0,
-  type:"Inscription",
-  lastName:"DoefenschmirtzLEMAGNIFIQUE",
-  firstName:"Jhon",
-  address: "Radiator Springs",
-  country: "USA",
-  birthdate:"2004-02-02",
-  email:"JohnDoe@gmail.com",
-  cursus:"IT",
-  degree:"BAC1",
-  },
-  {
-  id:1,
-  type:"ReInscription",
-  lastName:"Doe",
-  firstName:"Jane",
-  address: "Radiator Springs",
-  country: "USA",
-  birthdate:"2004-03-03",
-  email:"JaneDoe@gmail.com",
-  cursus:"Psychology",
-  degree:"BAC1",
-}]
-</script>
-
-<template>
-  <Req v-for="item of requests_example" v-bind="item">
-      </Req>
-</template>

frontend/src/assets/base.css

@@ -1,86 +0,0 @@
-/* color palette from <https://github.com/vuejs/theme> */
-:root {
-  --vt-c-white: #ffffff;
-  --vt-c-white-soft: #f8f8f8;
-  --vt-c-white-mute: #f2f2f2;
-
-  --vt-c-black: #181818;
-  --vt-c-black-soft: #222222;
-  --vt-c-black-mute: #282828;
-
-  --vt-c-indigo: #2c3e50;
-
-  --vt-c-divider-light-1: rgba(60, 60, 60, 0.29);
-  --vt-c-divider-light-2: rgba(60, 60, 60, 0.12);
-  --vt-c-divider-dark-1: rgba(84, 84, 84, 0.65);
-  --vt-c-divider-dark-2: rgba(84, 84, 84, 0.48);
-
-  --vt-c-text-light-1: var(--vt-c-indigo);
-  --vt-c-text-light-2: rgba(60, 60, 60, 0.66);
-  --vt-c-text-dark-1: var(--vt-c-white);
-  --vt-c-text-dark-2: rgba(235, 235, 235, 0.64);
-}
-
-/* semantic color variables for this project */
-:root {
-  --color-background: var(--vt-c-white);
-  --color-background-soft: var(--vt-c-white-soft);
-  --color-background-mute: var(--vt-c-white-mute);
-
-  --color-border: var(--vt-c-divider-light-2);
-  --color-border-hover: var(--vt-c-divider-light-1);
-
-  --color-heading: var(--vt-c-text-light-1);
-  --color-text: var(--vt-c-text-light-1);
-
-  --section-gap: 160px;
-}
-
-@media (prefers-color-scheme: dark) {
-  :root {
-    --color-background: var(--vt-c-black);
-    --color-background-soft: var(--vt-c-black-soft);
-    --color-background-mute: var(--vt-c-black-mute);
-
-    --color-border: var(--vt-c-divider-dark-2);
-    --color-border-hover: var(--vt-c-divider-dark-1);
-
-    --color-heading: var(--vt-c-text-dark-1);
-    --color-text: var(--vt-c-text-dark-2);
-  }
-}
-
-*,
-*::before,
-*::after {
-  box-sizing: border-box;
-  margin: 0;
-  font-weight: normal;
-}
-
-body {
-  min-height: 100vh;
-  color: var(--color-text);
-  background: var(--color-background);
-  transition:
-    color 0.5s,
-    background-color 0.5s;
-  line-height: 1.6;
-  font-family:
-    Inter,
-    -apple-system,
-    BlinkMacSystemFont,
-    'Segoe UI',
-    Roboto,
-    Oxygen,
-    Ubuntu,
-    Cantarell,
-    'Fira Sans',
-    'Droid Sans',
-    'Helvetica Neue',
-    sans-serif;
-  font-size: 15px;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-}

frontend/src/assets/main.css

@@ -1,4 +1,11 @@
 body {
    background-color: rgb(53, 25, 60);
    margin:0;
+   width: 100vw;
+   height: 100vh;
+}
+
+#app {
+   width: 100%;
+   height: 100%;
 }

frontend/src/components/HelloWorld.vue

@@ -1,44 +0,0 @@
-<script setup>
-defineProps({
-  msg: {
-    type: String,
-    required: true
-  }
-})
-</script>
-
-<template>
-  <div class="greetings">
-    <h1 class="green">{{ msg }}</h1>
-    <h3>
-      You’ve successfully created a project with
-      <a href="https://vitejs.dev/" target="_blank" rel="noopener">Vite</a> +
-      <a href="https://vuejs.org/" target="_blank" rel="noopener">Vue 3</a>.
-    </h3>
-  </div>
-</template>
-
-<style scoped>
-h1 {
-  font-weight: 500;
-  font-size: 2.6rem;
-  position: relative;
-  top: -10px;
-}
-
-h3 {
-  font-size: 1.2rem;
-}
-
-.greetings h1,
-.greetings h3 {
-  text-align: center;
-}
-
-@media (min-width: 1024px) {
-  .greetings h1,
-  .greetings h3 {
-    text-align: left;
-  }
-}
-</style>

frontend/src/components/TheWelcome.vue

@@ -1,88 +0,0 @@
-<script setup>
-import WelcomeItem from './WelcomeItem.vue'
-import DocumentationIcon from './icons/IconDocumentation.vue'
-import ToolingIcon from './icons/IconTooling.vue'
-import EcosystemIcon from './icons/IconEcosystem.vue'
-import CommunityIcon from './icons/IconCommunity.vue'
-import SupportIcon from './icons/IconSupport.vue'
-</script>
-
-<template>
-  <WelcomeItem>
-    <template #icon>
-      <DocumentationIcon />
-    </template>
-    <template #heading>Documentation</template>
-
-    Vue’s
-    <a href="https://vuejs.org/" target="_blank" rel="noopener">official documentation</a>
-    provides you with all information you need to get started.
-  </WelcomeItem>
-
-  <WelcomeItem>
-    <template #icon>
-      <ToolingIcon />
-    </template>
-    <template #heading>Tooling</template>
-
-    This project is served and bundled with
-    <a href="https://vitejs.dev/guide/features.html" target="_blank" rel="noopener">Vite</a>. The
-    recommended IDE setup is
-    <a href="https://code.visualstudio.com/" target="_blank" rel="noopener">VSCode</a> +
-    <a href="https://github.com/johnsoncodehk/volar" target="_blank" rel="noopener">Volar</a>. If
-    you need to test your components and web pages, check out
-    <a href="https://www.cypress.io/" target="_blank" rel="noopener">Cypress</a> and
-    <a href="https://on.cypress.io/component" target="_blank" rel="noopener"
-      >Cypress Component Testing</a
-    >.
-
-    <br />
-
-    More instructions are available in <code>README.md</code>.
-  </WelcomeItem>
-
-  <WelcomeItem>
-    <template #icon>
-      <EcosystemIcon />
-    </template>
-    <template #heading>Ecosystem</template>
-
-    Get official tools and libraries for your project:
-    <a href="https://pinia.vuejs.org/" target="_blank" rel="noopener">Pinia</a>,
-    <a href="https://router.vuejs.org/" target="_blank" rel="noopener">Vue Router</a>,
-    <a href="https://test-utils.vuejs.org/" target="_blank" rel="noopener">Vue Test Utils</a>, and
-    <a href="https://github.com/vuejs/devtools" target="_blank" rel="noopener">Vue Dev Tools</a>. If
-    you need more resources, we suggest paying
-    <a href="https://github.com/vuejs/awesome-vue" target="_blank" rel="noopener">Awesome Vue</a>
-    a visit.
-  </WelcomeItem>
-
-  <WelcomeItem>
-    <template #icon>
-      <CommunityIcon />
-    </template>
-    <template #heading>Community</template>
-
-    Got stuck? Ask your question on
-    <a href="https://chat.vuejs.org" target="_blank" rel="noopener">Vue Land</a>, our official
-    Discord server, or
-    <a href="https://stackoverflow.com/questions/tagged/vue.js" target="_blank" rel="noopener"
-      >StackOverflow</a
-    >. You should also subscribe to
-    <a href="https://news.vuejs.org" target="_blank" rel="noopener">our mailing list</a> and follow
-    the official
-    <a href="https://twitter.com/vuejs" target="_blank" rel="noopener">@vuejs</a>
-    twitter account for latest news in the Vue world.
-  </WelcomeItem>
-
-  <WelcomeItem>
-    <template #icon>
-      <SupportIcon />
-    </template>
-    <template #heading>Support Vue</template>
-
-    As an independent project, Vue relies on community backing for its sustainability. You can help
-    us by
-    <a href="https://vuejs.org/sponsor/" target="_blank" rel="noopener">becoming a sponsor</a>.
-  </WelcomeItem>
-</template>

frontend/src/components/WelcomeItem.vue

@@ -1,87 +0,0 @@
-<template>
-  <div class="item">
-    <i>
-      <slot name="icon"></slot>
-    </i>
-    <div class="details">
-      <h3>
-        <slot name="heading"></slot>
-      </h3>
-      <slot></slot>
-    </div>
-  </div>
-</template>
-
-<style scoped>
-.item {
-  margin-top: 2rem;
-  display: flex;
-  position: relative;
-}
-
-.details {
-  flex: 1;
-  margin-left: 1rem;
-}
-
-i {
-  display: flex;
-  place-items: center;
-  place-content: center;
-  width: 32px;
-  height: 32px;
-
-  color: var(--color-text);
-}
-
-h3 {
-  font-size: 1.2rem;
-  font-weight: 500;
-  margin-bottom: 0.4rem;
-  color: var(--color-heading);
-}
-
-@media (min-width: 1024px) {
-  .item {
-    margin-top: 0;
-    padding: 0.4rem 0 1rem calc(var(--section-gap) / 2);
-  }
-
-  i {
-    top: calc(50% - 25px);
-    left: -26px;
-    position: absolute;
-    border: 1px solid var(--color-border);
-    background: var(--color-background);
-    border-radius: 8px;
-    width: 50px;
-    height: 50px;
-  }
-
-  .item:before {
-    content: ' ';
-    border-left: 1px solid var(--color-border);
-    position: absolute;
-    left: 0;
-    bottom: calc(50% + 25px);
-    height: calc(50% - 25px);
-  }
-
-  .item:after {
-    content: ' ';
-    border-left: 1px solid var(--color-border);
-    position: absolute;
-    left: 0;
-    top: calc(50% + 25px);
-    height: calc(50% - 25px);
-  }
-
-  .item:first-of-type:before {
-    display: none;
-  }
-
-  .item:last-of-type:after {
-    display: none;
-  }
-}
-</style>

frontend/src/components/__tests__/HelloWorld.spec.js

@@ -1,11 +0,0 @@
-import { describe, it, expect } from 'vitest'
-
-import { mount } from '@vue/test-utils'
-import HelloWorld from '../HelloWorld.vue'
-
-describe('HelloWorld', () => {
-  it('renders properly', () => {
-    const wrapper = mount(HelloWorld, { props: { msg: 'Hello Vitest' } })
-    expect(wrapper.text()).toContain('Hello Vitest')
-  })
-})

frontend/src/components/icons/IconCommunity.vue

@@ -1,7 +0,0 @@
-<template>
-  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="currentColor">
-    <path
-      d="M15 4a1 1 0 1 0 0 2V4zm0 11v-1a1 1 0 0 0-1 1h1zm0 4l-.707.707A1 1 0 0 0 16 19h-1zm-4-4l.707-.707A1 1 0 0 0 11 14v1zm-4.707-1.293a1 1 0 0 0-1.414 1.414l1.414-1.414zm-.707.707l-.707-.707.707.707zM9 11v-1a1 1 0 0 0-.707.293L9 11zm-4 0h1a1 1 0 0 0-1-1v1zm0 4H4a1 1 0 0 0 1.707.707L5 15zm10-9h2V4h-2v2zm2 0a1 1 0 0 1 1 1h2a3 3 0 0 0-3-3v2zm1 1v6h2V7h-2zm0 6a1 1 0 0 1-1 1v2a3 3 0 0 0 3-3h-2zm-1 1h-2v2h2v-2zm-3 1v4h2v-4h-2zm1.707 3.293l-4-4-1.414 1.414 4 4 1.414-1.414zM11 14H7v2h4v-2zm-4 0c-.276 0-.525-.111-.707-.293l-1.414 1.414C5.42 15.663 6.172 16 7 16v-2zm-.707 1.121l3.414-3.414-1.414-1.414-3.414 3.414 1.414 1.414zM9 12h4v-2H9v2zm4 0a3 3 0 0 0 3-3h-2a1 1 0 0 1-1 1v2zm3-3V3h-2v6h2zm0-6a3 3 0 0 0-3-3v2a1 1 0 0 1 1 1h2zm-3-3H3v2h10V0zM3 0a3 3 0 0 0-3 3h2a1 1 0 0 1 1-1V0zM0 3v6h2V3H0zm0 6a3 3 0 0 0 3 3v-2a1 1 0 0 1-1-1H0zm3 3h2v-2H3v2zm1-1v4h2v-4H4zm1.707 4.707l.586-.586-1.414-1.414-.586.586 1.414 1.414z"
-    />
-  </svg>
-</template>

frontend/src/components/icons/IconDocumentation.vue

@@ -1,7 +0,0 @@
-<template>
-  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="17" fill="currentColor">
-    <path
-      d="M11 2.253a1 1 0 1 0-2 0h2zm-2 13a1 1 0 1 0 2 0H9zm.447-12.167a1 1 0 1 0 1.107-1.666L9.447 3.086zM1 2.253L.447 1.42A1 1 0 0 0 0 2.253h1zm0 13H0a1 1 0 0 0 1.553.833L1 15.253zm8.447.833a1 1 0 1 0 1.107-1.666l-1.107 1.666zm0-14.666a1 1 0 1 0 1.107 1.666L9.447 1.42zM19 2.253h1a1 1 0 0 0-.447-.833L19 2.253zm0 13l-.553.833A1 1 0 0 0 20 15.253h-1zm-9.553-.833a1 1 0 1 0 1.107 1.666L9.447 14.42zM9 2.253v13h2v-13H9zm1.553-.833C9.203.523 7.42 0 5.5 0v2c1.572 0 2.961.431 3.947 1.086l1.107-1.666zM5.5 0C3.58 0 1.797.523.447 1.42l1.107 1.666C2.539 2.431 3.928 2 5.5 2V0zM0 2.253v13h2v-13H0zm1.553 13.833C2.539 15.431 3.928 15 5.5 15v-2c-1.92 0-3.703.523-5.053 1.42l1.107 1.666zM5.5 15c1.572 0 2.961.431 3.947 1.086l1.107-1.666C9.203 13.523 7.42 13 5.5 13v2zm5.053-11.914C11.539 2.431 12.928 2 14.5 2V0c-1.92 0-3.703.523-5.053 1.42l1.107 1.666zM14.5 2c1.573 0 2.961.431 3.947 1.086l1.107-1.666C18.203.523 16.421 0 14.5 0v2zm3.5.253v13h2v-13h-2zm1.553 12.167C18.203 13.523 16.421 13 14.5 13v2c1.573 0 2.961.431 3.947 1.086l1.107-1.666zM14.5 13c-1.92 0-3.703.523-5.053 1.42l1.107 1.666C11.539 15.431 12.928 15 14.5 15v-2z"
-    />
-  </svg>
-</template>

frontend/src/components/icons/IconEcosystem.vue

@@ -1,7 +0,0 @@
-<template>
-  <svg xmlns="http://www.w3.org/2000/svg" width="18" height="20" fill="currentColor">
-    <path
-      d="M11.447 8.894a1 1 0 1 0-.894-1.789l.894 1.789zm-2.894-.789a1 1 0 1 0 .894 1.789l-.894-1.789zm0 1.789a1 1 0 1 0 .894-1.789l-.894 1.789zM7.447 7.106a1 1 0 1 0-.894 1.789l.894-1.789zM10 9a1 1 0 1 0-2 0h2zm-2 2.5a1 1 0 1 0 2 0H8zm9.447-5.606a1 1 0 1 0-.894-1.789l.894 1.789zm-2.894-.789a1 1 0 1 0 .894 1.789l-.894-1.789zm2 .789a1 1 0 1 0 .894-1.789l-.894 1.789zm-1.106-2.789a1 1 0 1 0-.894 1.789l.894-1.789zM18 5a1 1 0 1 0-2 0h2zm-2 2.5a1 1 0 1 0 2 0h-2zm-5.447-4.606a1 1 0 1 0 .894-1.789l-.894 1.789zM9 1l.447-.894a1 1 0 0 0-.894 0L9 1zm-2.447.106a1 1 0 1 0 .894 1.789l-.894-1.789zm-6 3a1 1 0 1 0 .894 1.789L.553 4.106zm2.894.789a1 1 0 1 0-.894-1.789l.894 1.789zm-2-.789a1 1 0 1 0-.894 1.789l.894-1.789zm1.106 2.789a1 1 0 1 0 .894-1.789l-.894 1.789zM2 5a1 1 0 1 0-2 0h2zM0 7.5a1 1 0 1 0 2 0H0zm8.553 12.394a1 1 0 1 0 .894-1.789l-.894 1.789zm-1.106-2.789a1 1 0 1 0-.894 1.789l.894-1.789zm1.106 1a1 1 0 1 0 .894 1.789l-.894-1.789zm2.894.789a1 1 0 1 0-.894-1.789l.894 1.789zM8 19a1 1 0 1 0 2 0H8zm2-2.5a1 1 0 1 0-2 0h2zm-7.447.394a1 1 0 1 0 .894-1.789l-.894 1.789zM1 15H0a1 1 0 0 0 .553.894L1 15zm1-2.5a1 1 0 1 0-2 0h2zm12.553 2.606a1 1 0 1 0 .894 1.789l-.894-1.789zM17 15l.447.894A1 1 0 0 0 18 15h-1zm1-2.5a1 1 0 1 0-2 0h2zm-7.447-5.394l-2 1 .894 1.789 2-1-.894-1.789zm-1.106 1l-2-1-.894 1.789 2 1 .894-1.789zM8 9v2.5h2V9H8zm8.553-4.894l-2 1 .894 1.789 2-1-.894-1.789zm.894 0l-2-1-.894 1.789 2 1 .894-1.789zM16 5v2.5h2V5h-2zm-4.553-3.894l-2-1-.894 1.789 2 1 .894-1.789zm-2.894-1l-2 1 .894 1.789 2-1L8.553.106zM1.447 5.894l2-1-.894-1.789-2 1 .894 1.789zm-.894 0l2 1 .894-1.789-2-1-.894 1.789zM0 5v2.5h2V5H0zm9.447 13.106l-2-1-.894 1.789 2 1 .894-1.789zm0 1.789l2-1-.894-1.789-2 1 .894 1.789zM10 19v-2.5H8V19h2zm-6.553-3.894l-2-1-.894 1.789 2 1 .894-1.789zM2 15v-2.5H0V15h2zm13.447 1.894l2-1-.894-1.789-2 1 .894 1.789zM18 15v-2.5h-2V15h2z"
-    />
-  </svg>
-</template>

frontend/src/components/icons/IconSupport.vue

@@ -1,7 +0,0 @@
-<template>
-  <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" fill="currentColor">
-    <path
-      d="M10 3.22l-.61-.6a5.5 5.5 0 0 0-7.666.105 5.5 5.5 0 0 0-.114 7.665L10 18.78l8.39-8.4a5.5 5.5 0 0 0-.114-7.665 5.5 5.5 0 0 0-7.666-.105l-.61.61z"
-    />
-  </svg>
-</template>

frontend/src/components/icons/IconTooling.vue

@@ -1,19 +0,0 @@
-<!-- This icon is from <https://github.com/Templarian/MaterialDesign>, distributed under Apache 2.0 (https://www.apache.org/licenses/LICENSE-2.0) license-->
-<template>
-  <svg
-    xmlns="http://www.w3.org/2000/svg"
-    xmlns:xlink="http://www.w3.org/1999/xlink"
-    aria-hidden="true"
-    role="img"
-    class="iconify iconify--mdi"
-    width="24"
-    height="24"
-    preserveAspectRatio="xMidYMid meet"
-    viewBox="0 0 24 24"
-  >
-    <path
-      d="M20 18v-4h-3v1h-2v-1H9v1H7v-1H4v4h16M6.33 8l-1.74 4H7v-1h2v1h6v-1h2v1h2.41l-1.74-4H6.33M9 5v1h6V5H9m12.84 7.61c.1.22.16.48.16.8V18c0 .53-.21 1-.6 1.41c-.4.4-.85.59-1.4.59H4c-.55 0-1-.19-1.4-.59C2.21 19 2 18.53 2 18v-4.59c0-.32.06-.58.16-.8L4.5 7.22C4.84 6.41 5.45 6 6.33 6H7V5c0-.55.18-1 .57-1.41C7.96 3.2 8.44 3 9 3h6c.56 0 1.04.2 1.43.59c.39.41.57.86.57 1.41v1h.67c.88 0 1.49.41 1.83 1.22l2.34 5.39z"
-      fill="currentColor"
-    ></path>
-  </svg>
-</template>

frontend/src/i18n.js

@@ -10,9 +10,10 @@
  */
 
 import { getCookie, setCookie } from './utils.js';
+import { reactive } from 'vue';
 
 const default_lang = "EN";
-let langs;
+const langs = reactive({});
 
 
 /**
@@ -27,8 +28,8 @@ let langs;
 export default function i18n(key, options) {
 	let ret = langs[key];
 	if(options != null){
-		for (let key in options) {
-			ret = ret.replaceAll("$" + key, options[key]);
+		for (let option in options) {
+			ret = ret.replaceAll("$" + option, options[option]);
 		}
 	}
 	return ret;
@@ -47,14 +48,12 @@ export async function loadLangs(lang){
 	const content = await (await fetch(filename)).text();
 	const lines = content.split("\n");
 
-	let filteredLines = {};
 	for (let line of lines) {
 		if(!line.trim().startsWith("#") && line.trim() != ""){
 			let split = line.indexOf("=")
-			filteredLines[line.substr(0, split)] = line.substr(split+1, line.length);
+			langs[line.substr(0, split)] = line.substr(split+1, line.length);
 		};
 	}
-	langs = filteredLines;
 }
 await loadLangs();
 

frontend/src/login.js

@@ -1,7 +0,0 @@
-import './assets/main.css'
-import 'vue3-toastify/dist/index.css';
-
-import { createApp } from 'vue'
-import App from './Login.vue'
-
-createApp(App).mount('#app')

frontend/src/main.js

@@ -1,5 +1,6 @@
 import './assets/main.css'
 import 'vue3-toastify/dist/index.css';
+import 'https://kit.fontawesome.com/fb3bbd0a95.js'
 
 import { createApp } from 'vue'
 import App from './App.vue'

frontend/src/rest/ServiceInscription.js

@@ -0,0 +1,45 @@
+/**
+ * functions to handle register requests. 
+ *
+ * TODO: On time of writing, the backend doesn't support these endpoints so it could be modified in the future.
+ */
+import {restGet, restPatch} from './restConsumer.js'
+
+/**
+ * create a new register requests that can be recovered by the registering service
+ * TODO: add info in the Object (I don't know what will be needed)
+ */
+export async function createRegister(){
+	return restPost("/request/register");
+}
+
+/**
+ * list all register request in a list of Objects
+ * Shall return a list of
+ * - id
+ * - type
+ * - lastName
+ * - firstName
+ * - address
+ * - country
+ * - birthdate
+ * - email
+ * - curriculum
+ * - degree
+ */
+export async function getRegisters(id){
+	if(id != null)
+		return restGet("/request/register/" + id);
+	return restGet("/request/register")
+}
+
+export async function getAllRegisters(){
+  return restGet("/requests/register")
+}
+
+/**
+ * Change the state of a requests.
+ */
+export async function validateRegister(id, state){
+  return restPatch("/request/register/" + id, state);
+}

frontend/src/rest/Users.js

@@ -1,12 +1,70 @@
-import { restGet, restPost } from './restConsumer.js'
+import { restGet, restPost, restPatch, restDelete} from './restConsumer.js'
+import { getCookie, setCookie } from '@/utils.js'
 
 export async function login(user, pass, exp){
-	return restPost("/login", {login: user, password: pass, expiration: exp});
+	return restPost("/login", {identifier: user, password: pass, expirationDate: exp});
 }
 
-export async function register(user, pass, mail){
-	return restPost("/user", {name: user, password: pass, mail: mail});
-	restPost("/login", {login: user, password: pass, expiration: exp})
+export function isLogged(){
+	return getCookie("session_token") != "" 
+}
+
+export function disconnect(){ 
+	setCookie("session_token", ";expires= Thu, 01 Jan 1970 00:00:01 GMT")
+}
+
+/**
+ * Register a user (tokenless)
+ * 
+ * @param firstname
+ * @param lastname
+ * @param birthdate
+ * @param password
+ * @param mail
+ * @param address
+ * @param country
+ * @param curriculum 
+ * @param imageId	id of the image in database returned when uploaded
+ */
+export async function register(firstname, lastname, birthDate, password, email, address, country, curriculumId, imageId){
+	return restPost("/register", {
+		firstName: firstname,
+		lastName: lastname,
+		birthDate: birthDate,
+		password: password,
+		email: email,
+		address: address,
+		country: country,
+		curriculumId: curriculumId,
+    profilePictureUrl: imageId,
+	});
+}
+
+/**
+ * Register a user (by secretary)
+ * 
+ * @param firstname
+ * @param lastname
+ * @param birthdate
+ * @param password
+ * @param mail
+ * @param address
+ * @param country
+ * @param imageId	id of the image in database returned when uploaded
+ *
+ * PS: the password is not is not required as it is generated by the backend and sent to the user
+ * by mail. it's up to the user to change it if he cares about security
+ */
+export async function createUser(firstname, lastname, birthDate, email, address, country, role, imageId){
+	return restPost("/user", {
+		firstname: firstname,
+		lastname: lastname,
+		birthDate: birthDate,
+		password: password,
+		email: email,
+		address: address,
+		country: country,
+	});
 }
 
 /**
@@ -15,10 +73,29 @@ export async function register(user, pass, mail){
  * if the user is not authenticated. then an empty array should be returned
  */
 export async function getUser(id){
-	const endpoint = "/user" + id != null ? "/" + id : "";
+	const endpoint = "/user/" +  id;
 	return restGet(endpoint);
 }
 
+/**
+ * Alterable datas of user.
+ * usage by secretary
+ *
+ * @param id	regno of the user
+ * @param data	data to change
+ *
+ * - lastName
+ * - firstName
+ * - birthDate
+ * - role
+ * - email
+ * - photo
+ * - Adress
+ */
+export async function alterUser(id, data){
+	return restPatch("/user/" + id, data);
+}
+
 /**
  * Reserved for secretary roles. Allow to list all user on the plateform
  */
@@ -26,3 +103,50 @@ export async function getAllUsers(){
 	return restGet("/users");
 }
 
+/**
+ * Return the list of teachers
+ *
+ * @return a list of teachers
+ * each elements is of the form
+ * - id
+ * - name
+ * - role
+ */
+export async function getTeachers(){
+	return restGet("/teachers")
+}
+
+
+export async function getStudents(){
+  return restGet("/students")
+}
+/**
+ * Get informations about yourself
+ * - RegNo
+ * - FirstName / LastName
+ * - email
+ * - adressId (?)
+ * - birthDate
+ * - role
+ */
+export async function getSelf(){
+	return restGet("/user");
+}
+
+/**
+ * Alterable datas are
+ * - email
+ * - photo
+ * - Adress
+ * - Password
+ */
+export async function alterSelf(id,data){
+  console.log(data)
+	return restPatch("/user/"+id, data);
+}
+
+
+
+export async function deleteUser(id){
+  return restDelete("/user/" + id)
+}

frontend/src/rest/apps.js

@@ -0,0 +1,68 @@
+import { restGet } from './restConsumer.js' 
+import { ref, computed } from 'vue'
+import i18n from '@/i18n.js'
+
+// Liste des apps
+import LoginPage from '@/Apps/Login.vue'
+import Inscription from "@/Apps/Inscription.vue"
+import Profil from "@/Apps/Profil.vue"
+import Courses from "@/Apps/ManageCourses.vue"
+import Users from "@/Apps/UsersList.vue"
+import Students from "@/Apps/StudentsList.vue"
+import Schedule from "@/Apps/Schedule.vue"
+
+const apps = {
+		'/schedule': Schedule,
+		'/login': LoginPage,
+		'/inscription': Inscription,
+		'/profil': Profil,
+		'/manage-courses' : Courses,
+		'/users-list' : Users,
+		'/students-list' : Students,
+}
+
+const appsList = {
+		'Msg': { path: '#/msg', icon: 'fa-comment', text: i18n("app.messages") },
+		'Notification': { path: '#/notifs', icon: 'fa-bell', text: i18n("app.notifications") },
+		'Forum': { path: '#/forum', icon: 'fa-envelope', text: i18n("app.forum") },
+		'Schedule': { path: '#/schedule', icon: 'fa-calendar-days', text: i18n("app.schedules") },
+		'Inscription': { path: '#/inscription', icon: 'fa-users', text: i18n("app.inscription.requests") },
+		'ManageCourses': { path: '#/manage-courses', icon: 'fa-book', text: i18n("app.manage.courses") },
+		'StudentsList':{ path: '#/students-list',icon: 'fa-users',text: i18n("app.studentList")},
+		'UsersList':{ path: '#/users-list',icon: 'fa-users',text: i18n("app.users")},
+}
+
+const currentPath = ref(window.location.hash)
+
+export const currentView = computed(() => {
+		return apps[currentPath.value.slice(1) || '/']
+})
+
+/**
+ * Return the list of app accesible by a logged (or not)
+ * user.
+ */
+export async function appList(){
+		let ret = [];
+		let userAppList = await restGet("/apps");
+		for (let userapp in userAppList) {
+				if(appsList[userAppList[userapp]] != null){
+						ret.push(appsList[userAppList[userapp]])
+				}
+		}
+		return ret;
+}
+
+/**
+ * Check if the specified page is authorized for the
+ * user
+ */
+export async function checkPage(page){
+		return restGet("/apps/" + page)
+}
+
+window.addEventListener('hashchange', () => {
+		currentPath.value = window.location.hash
+})
+
+// vim:set noet sts=0 sw=4 ts=2 tw=2:

frontend/src/rest/courses.js

@@ -7,8 +7,10 @@ import { restGet, restPost, restDelete, restPatch } from './restConsumer.js'
 /**
  * Create a new course
  */
-export async function createCourse(name, credits, faculty, teacher, assistants){
-	return restPost("/courses", {name: name, credits: credits, faculty: faculty, teacher: teacher, assistants: assistants} )
+export async function createCourse(name, credits, owner){
+  console.log(owner);
+  
+	return restPost("/course", {title: name, credits: credits, owner} )
 }
 
 /**
@@ -34,6 +36,25 @@ export async function getCourse(id){
 	return restGet("/course/" + id);
 }
 
+/**
+ * Get the list of courses to display on secretary's option
+ *
+ * @return list of courses of the form
+ * - id
+ * - name
+ * - credits
+ * - facutly
+ * - teacher
+ * - Assistants
+ */
+export async function getCourses(role){
+  if(role==="Teacher"){
+  return restGet("/courses/owned")
+  }
+	return restGet("/courses")
+}
+
+
 /**
  * Change the options of a course
  *

frontend/src/rest/curriculum.js

@@ -0,0 +1,50 @@
+/**
+ * curriculum API
+ */
+
+import { restGet, restPost, restDelete, restPatch } from './restConsumer.js'
+
+/**
+ * Create a new curriculum (bundle of courses)
+ * @param courses	list of courses
+ */
+export async function createcurriculum(courses){
+	return restPost("/curriculum", {courses: courses} );
+}
+
+/**
+ * Delete the specified curriculum
+ */
+export async function deletecurriculum(id){
+	return restDelete("/curriculum/" + id);
+}
+
+export async function getAllCurriculums(){
+  return restGet("/curriculums");
+}
+
+/**
+ * Get informations on a particular curriculum
+ *
+ * @param id	identification of the curriculum
+ *
+ * @return list of courses 
+ */
+export async function getcurriculum(id){
+	return restGet("/curriculum/" + id);
+}
+
+/**
+ * Modify the courses of a curriculum
+ *
+ * @param id		the id of the curriculum
+ * @param courses	list of new courses 
+ */
+export async function altercurriculum(id, courses){
+	return restPatch("/curriculum/" + id, courses);
+}
+
+
+export async function getSelfCurriculum(){
+  return restGet("/curriculum");
+}

frontend/src/rest/restConsumer.js

@@ -8,15 +8,20 @@ export async function restGet(endPoint) {
 }
 
 export async function restPost(endPoint, data) {
-	return await _rest(endPoint, {method: "POST", body: data});
+	return await _rest(endPoint, {method: "POST", credentials: 'include', body: JSON.stringify(data)});
 }
 
-export async function restDelete(endPoint, data) {
-	return await _rest(endPoint, {method: "DELETE", body: data});
+export async function restPostFile(endPoint, file){
+	let headers = new Headers();
+	return await _rest(endPoint, {method: "POST", credentials: 'include', body: file, headers: headers });
+}
+
+export async function restDelete(endPoint) {
+	return await _rest(endPoint, {method: "DELETE"});
 }
 
 export async function restPatch(endPoint, data) {
-	return await _rest(endPoint, {method: "PATCH", body: data});
+	return await _rest(endPoint, {method: "PATCH", credentials: 'include', body: JSON.stringify(data)});
 }
 
 /**
@@ -31,14 +36,17 @@ export async function restPatch(endPoint, data) {
 async function _rest(endPoint, config){
 	endPoint.at(0) != "/" ? console.error("Carefull, you certainly should put a / at the begenning of your endPoint ") : true;
 	let session_token = getCookie("session_token");
-	let headers = new Headers({'Authorization': session_token});
-	config['headers'] = headers;
+	let headers = new Headers({
+		'Authorization': session_token,
+		'Content-Type': 'application/json',
+	});
+	config['headers'] = config['headers'] == null ? headers : config['headers'];
 	return toast.promise(fetch(restURL + endPoint, config),
 		{
 			pending: config['pending'] != null ? config['pending'] : 'pending',
 			error: config['error'] != null ? config['error'] : 'Network Failure...',
 			success: config['success'] != null ? config['success'] : {render(res){
-				return res.ok ? "Success" : "error";
+				return res.data.ok ? "Success" : "error";
 			}},
 		})
 		.then( e => e.json()).catch( e => e );