fix max's scroll issue

Reviewed-on: #178

.gitattributes

@@ -0,0 +1,9 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+

.gitea/workflows/backend.yaml

@@ -0,0 +1,20 @@
+name: Build and test backend 
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  Build-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:build -x test

.gitea/workflows/deploy.yaml

@@ -0,0 +1,50 @@
+name: deploy to production
+run-name: ${{ gitea.actor }} has pushed to production
+
+on:
+  push:
+    branches:
+      - master 
+  workflow_run:
+    workflows:
+      - Build and test backend 
+      - Build and test frontend 
+    types:
+      - completed
+  workflow_dispatch:
+
+jobs:
+  deploy-frontend:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      working-directory: ./frontend
+    - run: npm ci 
+      name: clean install
+      working-directory: ./frontend
+    - name: building 
+      working-directory: ./frontend
+      run: npm run build
+    - name: pushing to the server
+      working-directory: ./frontend
+      run: |
+        echo "${{ secrets.SSH_KEY }}" > key
+        chmod 0600 key
+        scp -o "StrictHostKeyChecking=no" -o "LogLevel=ERROR" -i key -r dist/ ${{ secrets.SSH_USER }}@${{ secrets.SSH_HOST }}:
+    - run: echo "The website has been deployed. visit https://clyde.herisson.ovh/"
+
+  deploy-backend:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: pushing to the server
+      run: |
+        echo "${{ secrets.SSH_KEY }}" > key
+        chmod 0600 key
+        scp -o "StrictHostKeyChecking=no" -o "LogLevel=ERROR" -i key -r * ${{ secrets.SSH_USER }}@${{ secrets.SSH_HOST }}:api/
+    - name: restarting the backend 
+      run: |
+        ssh -o "StrictHostKeyChecking=no" -o "LogLevel=ERROR" -i key ${{ secrets.SSH_USER }}@${{ secrets.SSH_HOST }} 'cd api/ && sed -i compose.yaml -e "s/8080:8080/4001:8080/" -e "s/8000:8080/4000:8080/" && docker-compose up --force-recreate --build -d'
+    - run: echo "The backend has been deployed. running at https://clyde.herisson.ovh/api"

.gitea/workflows/frontend.yaml

@@ -0,0 +1,22 @@
+name: Build and test FrontEnd 
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  Build-frontend:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      working-directory: ./frontend
+    - run: npm ci 
+      name: clean install
+      working-directory: ./frontend
+    - run: npm run build --if-present
+      name: build
+      working-directory: ./frontend

.gitignore

@@ -0,0 +1,9 @@
+# Ignore Gradle project-specific cache directory
+.gradle
+
+# Ignore Gradle build output directory
+build
+
+.project
+.settings
+.idea/

Documents/JournalDeBord/29-02.md

@@ -0,0 +1,48 @@
+# Journal de bord du 29 février
+
+Ce premier journal de bord permet d'initier une tendance a garder une trace des choix fait lors du dévelopement du
+projet de génie logiciel. Ces journaux pourront alors être consultés par la suite, pour la rédaction du rapport.
+
+## Choix des technologies utilisées
+
+### Backend: spring.io
+
+Le backend est imposé, nous devons utiliser spring boots. La courbe d'aprentisage nous semble difficile mais après de
+longues documentations nous commençons à comprendre son fonctionnement.
+
+### Frontend: Vue.js
+
+Le frontend n'est pas imposé, nous devons utiliser javascript mais le choix du framework (si utilisé) est libre. Nous
+avons pris la recomendation du cours: vue.js qui est un framework simple d'aprentisage et très performant.
+
+#### Librairies
+
+- **Vue3-toastify:** Nous avons opté pour l'utilisation d'une librarie de "notification". cette librairie permet 
+d'afficher des notifications sur la page. Elle nous est utile autant pour l'application finale que pour le
+dévelopement.
+
+### Database: postgresql
+
+C'est une base de données très efficace qui est déjà installé
+
+### VCS: Gitea
+
+C'est une alternative a github mais self-hosted. Nous avons accés à un serveur sur lequel gitea est installé
+(https://git.herisson.ovh/).
+
+### CI/CD: Gitea Actions
+
+Gitea a récement implémenter l'équivalent de github actions dans gitea et qui est complètement compatible avec github
+actions. Nous avons donc implémentés les test et build en continu lors des pr et merge. Lorsqu'un merge est fait avec la
+branche master, le site est instentanément mis à jours (après une dernière verification du build et test) sur l'adresse
+http://clyde.herisson.ovh pour le frontent et http://clyde.herisson.ovh/api pour le backend.
+
+
+## Répartition des taches
+
+Nous nous répartisons les taches par familiarité et préférences avec les différentes partie du projet.
+
+- Wiliam: Frontend visuel
+- Anthony: Frontend technique
+- Max: Backend Endpoints
+- Léo: Backend Data

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.

Documents/JournalDeBord/i18n.md

@@ -0,0 +1,45 @@
+# Internationalization (i18n)
+
+L'un des critère du projet est de donner la possibilité aux utilisateur de choisir entre différentes
+langues. Minimum 2 sont a implémenter, le français et l'anglais.
+
+## Intention 
+
+La gestion des langue au niveau backend peut sembler être une bonne idée aux premier abord car celà
+permeterais de laisser la possibilité a différents frontend utilisant la meme api de traduction.
+cependant, peu d'éléments venant de la base de données sont traduisible. Nous alons alors opter pour
+une internationalization au niveau du frontend. Dans le cas ou un éléments venant du frontend
+devrait être traduit, Il suffirait alors de le faire traduire par le frontend directement
+
+## Implémentation
+
+Le frontend va se voir équiper d'une collection de fonctions permettant la traduction. notament
+`i18n(key: str) -> str` qui prendrait en entrée une "clé" identifiant la traduction à aller
+chercher. Cette clé serait sous la forme : `<context>.<element>`. La fonctions retournera alors la
+traduction du texte dans la langue choisie par l'utilisateur. cette langue sera stockée dans les
+cookies pour qu'un utilisateur non enregistré puisse naviguer sur le site sans problèmes. Si
+l'utilisateur est enregistré elle pourra également être ajouter à son profil pour que la langue soit
+mise à jours lors de son prochain passage.
+
+### Base de données de traduction
+
+Les traductions seront rassembler dans fichier txt. Une langue sera présente par fichier et une
+traduction par ligne. (Ce format semble être utilisé par certaines librairies de spring. Malgré le
+fait que nous ne l'utiliserons finalement pas, ce format semble efficace est facile à utilsier).
+
+Chaque ligne commence par la clé. suivi immédiatement d'un "=". le contenu après ce égale est la
+traduction jusqu'au égale.
+
+## Considérations
+
+- Il existe certainemnt des librairies prète à l'emploi de traduction mais celà semble être
+  relativement simple à implémenter manuellement.
+
+- Dans l'éventualité où nous voudrions implémenter des éléments au milieu d'une traduction (example:
+  Veuillez vérifier votre addresse mail: `tonitch@herisson.ovh` puis revenir sur le site!). Dans ce
+  cas nous pouvons utiliser le regex et simplement renseigner ces éléments par \1, \2, \3, ... puis
+  créer une fonction qui s'occuperais de remplacer ces éléments dans le texte avant de le mettre en
+  avant.
+
+- Il ne devrait pas etre trop compliqué d'écrire un script qui vérifie que toutes les traductions
+  sont présente dans tout les fichiers en vérifiant que toutes les clés d'un fichiers sont présente.

Documents/proto/messaging_extension/ERD.md

@@ -0,0 +1,87 @@
+# Entity relational diagram
+
+## Messaging extension 
+
+```mermaid
+%%{init: {  "er": {"fontSize": 25, "stroke": "black" }}}%%
+erDiagram
+
+%% General
+Users
+
+%% Messages
+Discussions{
+    Integer id PK
+    String name
+}
+
+Messages{
+    Integer id PK
+    Integer response FK "Messages"
+    String content
+}
+
+Discussions ||--o{ Messages: "" 
+Discussions ||--o{ Users: ""
+
+Messages o|--o{ Messages: "answers"
+
+%% Forums
+Forums{
+    Integer id PK
+    String name
+    Integer course FK "Course"
+}
+
+Topics{
+    Integer id PK
+    String subject
+    String content
+    Boolean locked
+}
+Answers{
+    Integer id PK
+    String content
+    Boolean anonymous
+    TimeStamp creation_time 
+}
+
+Polls{
+    Integer id PK
+    enum PollType
+}
+Options{
+    Integer id PK
+    String name
+}
+
+Forums ||--o{ Users: "Registered"
+Forums ||--|| Teacher: "Owner"
+Forums ||--o{ Topics: ""
+Forums ||--o{ Polls: ""
+
+Topics ||--|| Teacher: "Author"
+Topics ||--|| Users: "Author"
+Topics ||--o{ Answers: ""
+
+Polls ||--o{ Options: ""
+
+Options ||--o{ Votes : ""
+
+Votes }o--|| Users: "Voter"
+
+
+%% Appointments
+Teacher
+Appointments{
+    Integer id PK
+    Integer teacher FK "Teacher"
+    TIME sent_time
+    enum Status
+}
+
+Appointments ||--|| Users: ""
+
+```
+
+Debucquoy Anthony

Documents/proto/messaging_extension/Makefile

@@ -11,8 +11,9 @@ extension_messagerie.pdf:use_case_messagerie.tex extension_messagerie.bbl extens
 use_case_messagerie.tex: use_case_messagerie.uml
 	plantuml -tlatex:nopreamble use_case_messagerie.uml
 
-image: use_case_messagerie.uml interaction_diagram.uml
+image: use_case_messagerie.uml interaction_diagram.uml class.uml 
 	plantuml $^ 
+	mmdc -i ERD.md -o ERD.png
 
 extension_messagerie.bbl: extension_messagerie.bcf
 	biber extension_messagerie
@@ -24,6 +25,7 @@ clean:
 	latexmk -C
 	rm -f use_case_messagerie.tex
 	rm -f extension_messagerie.{bbl,run.xml}
+	rm -f class.tex
 
 run: extension_messagerie.pdf
 	xdg-open $<

Documents/proto/messaging_extension/class.uml

@@ -0,0 +1,86 @@
+@startuml
+title Class diagram for Messaging extension
+
+package Messages {
+	class Message{
+		content: String
+		response: Message
+		respond(User, String)
+	}
+	class Discussion{
+		name: String
+		users: ArrayList<User>
+		invite(User)
+		sendMessage(User, String)
+	}
+	Discussion *-- Message
+}
+
+package Forums {
+	class Forum{
+		name: String
+		Owner: Teacher
+		Registered: ArrayList<User>
+		{static} createForum(Course): Forum
+		createTopic(String): Topic
+		createPoll(String, PollType, ArrayList<Option>): Poll
+	}
+	class Topic{
+		subject: String
+		author: Teacher 
+		content: String
+		answer(User, String): Answer
+		lock(Boolean)
+	}
+	class Answer{
+		author: User
+		content: String
+		anonymous: Boolean 
+		remove()
+	}
+	class Poll{
+		options: ArrayList<Option>
+		type: PollType
+		answer(User, Option): Vote
+		addOption(Option)
+	}
+	class Option{
+		name: String
+	}
+	class Vote{
+		voter: User
+	}
+	enum PollType {
+		ALLOW_NEW_OPTIONS
+		ALLOW_MULTIPLE_CHOICE
+	}
+	note "Change the behaviour of poll" as N
+
+	Forum *-l- Topic
+	Topic *-l- Answer
+
+	Topic <|-d- Poll
+	Poll *-l- Option
+	Option "1..*" -d-x Vote
+	Poll *-- Vote
+
+	Poll -- PollType
+	PollType .r. N
+
+}
+
+package Appointments{
+	class Appointment{
+		date: Date
+		teacher: Teacher
+		student: Student
+		{static} Appointment(Student, Teacher, Date)
+		accept()
+		refuse()
+		propose(Date)
+		export(): File
+	}
+}
+
+Appointments -[hidden]d- Messages
+@enduml

Documents/proto/messaging_extension/extension_messagerie.tex

@@ -3,6 +3,7 @@
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}
 \usepackage{amsmath, amsfonts, amssymb, amsthm}
+\usepackage{dirtytalk}
 \usepackage{tikz}
 \usepackage{biblatex}
 
@@ -20,77 +21,74 @@
 \resizebox{345pt}{!}{
 	\input{./use_case_messagerie.tex}
 }
-\caption{Use Case Diagram of the messaging extension}
+\caption{Use Case Diagram pour l'extension de messagerie}
 \label{fig:useCase:msg_ext} 
 \end{figure}
 
-In the diagram Figure~\ref{fig:useCase:msg_ext},
-the <<extend>> definition is not pulled from the "Genie logiciel" course
-of the University of Mons (UMONS). It is in fact the definition from
-the Dan Pilone's pocket reference \cite{Pilone2006-fn}.
+Dans le diagramme \ref{fig:useCase:msg_ext}, la définition du <<extend>> est tirée du livre:
+"uml Pocket reference" de Dan Pilone \cite{Pilone2006-fn}. 
+
+\say{Use case extension encapsulates a distinct flow of events
+	that are not considered part of the normal or basic flow.
+	They are not necessarily exceptional conditions.}
 
 \subsection{Answer topic}
 
-The user should be able to answer to a topic created by a teacher.
-This answer will depend on the type of topic. The answer could be a selection on a poll,
-a private answer (which mean that the answer is not visible to the other users except to the professor).
-The answer could finally be a basic answer to the topic and be visible to other users browsing the topic.
+L'utilisateur doit être capable de répondre à un topic crée par l'enseignant.
+Cette réponse va dépendre du type de topic. Elle peut être une réponse à un questionnaire,
+un message privé (qui ne serait pas visible par les autres utilisateur excepté l'enseignant) ou 
+une simple réponse qui serait visible par tous.
 
 \subsection{Create discutions}
 
-The user can select multiple users and group them into a discussion.
-In this discussion, users will be able to exchange messages readable by
-every other members of the discussion
+L'utilisateur peut séléctionner plusieurs utilisateurs et les include dans un groupe de discussion.
+Dans cette discussion, les utilisateurs peuvent échanger des messages lisible par les autres membres du
+groupe
 
 \subsubsection{Send messages}
 
-Allow the creation of a message in a discussion.
-The text sent to others shall be received by other users
-and these users shall be notified of this message by the notification
-system.
+Permet la création d'un message dans une discusison.
+Ce message va être reçu par les autres utilisateur et ceux-ci vont être notifié
+du message par le système de notification
 
 \subsection{Ask appointment}
 
-A student can ask for an appointment to a teacher.
-In this request, the student will have to give a date, a time
-and a subject he want to propose to the teacher.
+Un étudiant peut demander un rendes-vous à un enseignant.
+Dans cette demande, l'étudiant doit donner une date qui lui convient pour ce rendez-vous
+ainsi qu'une raison à ce rendez-vous.
 
 \subsubsection{Export to calendar}
 
-When an appointment is made. The program can export the event
-to an open format that can be read by calendar software to add
-the event to the user's calendar.
+Quand un rendez-vous est crée, Le programme peut exporter l'événement dans un 
+format libre qui pourra être lu par les programme de gestions de planning.
 
 \subsection{Manage appointment}
 
-When a teacher received an appointment, he is able to
-validate, deny or propose a new appointment schedule to the
-student.
+Quand un enseignant reçois une demande de rendez-vous,
+il a la possibilité de valider/refuser ou de proposer un nouveau rendez-vous
+à l'étudiant
 
 \subsubsection{Propose new appointment}
 
-If the teacher can't attend to an appointment because of his
-schedule, he can make a new time proposal and send it to
-the student. The student then receive a notification of
-the proposed modifications.
+Si l'enseignant n'est pas disponible pour le rendez-vous proposé,
+il peut alors proposer un nouveau créneau horaire et l'envoyer à l'étudiant.
+L'étudiant reçois alors une notification du nouveau créneau horaire.
 
 \subsection{Create forum}
 
-The teacher can create a new forum under a specific course
-The new forum will then make every student of this course
-follow the forum and its topic.
+L'enseignant peut créer un nouveau forum lié à un cours.
+Ce nouveau forum enregistrera les étudiant du cours automatiquement.
 
 \subsubsection{Post topics}
 
-The teacher can post a new topic inside a forum to let 
-the student know of something specific or to ask a question to
-them.
+L'enseignant peut envoyer un topic dans un forum pour préciser quelque chose aux étudiants
+ou pour poser une questions
 
 \subsubsection{Post poll}
 
-When posting a topic to a forum, the teacher can choose to
-make the post as a poll. In that case, student will have to vote
-for one of the options or if allowed by the teacher, create a new option.
+Lors d'un post, il est possible de choisir de créer un questionnaire à choix multiples ou non.
+Dans ce cas, les étudiants vont devoir voter pour l'une des options proposée ou potentiellement
+crée une nouvelle option.
 
 \printbibliography
 

Documents/proto/messaging_extension/interaction_diagram.uml

@@ -1,23 +1,19 @@
 @startuml
-note
-	Appointment
-endnote
+mainframe Appointment
 start
-:Asking Apointment]
+:Asking Appointment]
 repeat
 if (accepted) is (yes) then
 	:Export to calendar]
 	stop
 else (no)
-	:Propose new apointment]
+	:Propose new appointment]
 endif
 	
 @enduml
 
 @startuml
-note
-	Messaging
-endnote
+mainframe Messaging
 start
 split 
 	:Create Discution]
@@ -31,10 +27,7 @@ stop
 @enduml
 
 @startuml
-note 
-	Forum
-endnote
-
+mainframe Forum
 start
 :Forum Creation]
 

Documents/proto/messaging_extension/use_case_messagerie.uml

@@ -5,14 +5,13 @@ left to right direction
 :Student: as s
 :Teacher: as t
 
-
 package "Messagerie"{
 
 (Answer topics) as at
-(Ask appointement) as aa
-(Create Discution) as cd
+(Ask appointment) as aa
+(Create Discussion) as cd
 (Create Forum) as cf
-(Manage appointement) as ma
+(Manage appointment) as ma
 
 s -- at
 s -- aa
@@ -32,7 +31,7 @@ cf <-- pt : << include >>
 pt <|-- (Post poll)
 cd <-- (Send messages) : << include >>
 
-ma <-- (Propose new appointment) : << exlude>> \n [refuse]
+ma <-- (Propose new appointment) : << extends >> \n [refuse]
 
 }
 

README.md

@@ -0,0 +1,41 @@
+# Clyde project
+
+## Signature
+
+Projet du groupe 01:
+
+- Debucquoy Anthony: Extension messagerie
+- Maxime Bartha: Extension publication scientifique
+- William Karpinski: Extension gestion des horaires
+- Léo Moulin: Extension inscription des étudiants
+
+## Running
+
+Le projet peut être lancé grace à docker compose.
+
+```sh
+$ docker compose up 
+```
+
+Dans le cas ou vous modifiers des fichiers, pour éviter que les images de docker soient recrées avec les changement
+
+```sh
+$ docker compose up --force-recreate --build
+```
+
+## Dévelopement
+
+Dans le cas ou vous êtes dans une phase de développement, il est plus simple d'utiliser gradle pour lancer le backend et frontend dans un mode de développement.
+**Attention**: Ce mode n'est pas fait pour être utilisé en production!
+
+```sh
+$ ./gradlew run --parallel
+```
+permet de lancer le frontend sur [http://localhost:5173](http://localhost:5173) ansi que le frontend sur [http://localhost:8080](http://localhost:8080) 
+
+Ceci requière également docker pour lancer une instance de postgresql pris en charge par spring.
+
+Il est possible de se passer entièrement de docker en supprimant la dépendance dans le fichier `backend/build.gradle.kts`: ~~`developmentOnly("org.springframework.boot:spring-boot-docker-compose")`~~
+Il est alors nécéssaire d'avoir une instance de postgresql tournant sur `localhost:5432` avec une table `clyde`, utilisateur: `devel` et password: `devel`
+(cette configuration peut également être changée dans le fichier resources/application.properties de spring)
+

backend/.gitignore

@@ -0,0 +1,39 @@
+HELP.md
+.gradle
+build/
+!gradle/wrapper/gradle-wrapper.jar
+!**/src/main/**/build/
+!**/src/test/**/build/
+
+### STS ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### IntelliJ IDEA ###
+.idea
+*.iws
+*.iml
+*.ipr
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+/cdn

backend/Dockerfile

@@ -0,0 +1,15 @@
+## Building phase
+FROM gradle:jdk21-alpine AS BUILD
+WORKDIR /backend
+  
+COPY . .
+RUN gradle build -x test
+
+## Running Phase
+FROM eclipse-temurin:21-jdk-alpine
+WORKDIR /backend
+VOLUME /cdn
+# ENV SPRING_PROFILES_ACTIVE=prod
+COPY --from=BUILD /backend/build/libs/Clyde-0.0.1-SNAPSHOT.jar /backend/app.jar
+EXPOSE 8080
+ENTRYPOINT ["java", "-jar", "/backend/app.jar"]

backend/build.gradle.kts

@@ -0,0 +1,49 @@
+plugins {
+	java
+	id("org.springframework.boot") version "3.2.2"
+	id("io.spring.dependency-management") version "1.1.4"
+}
+
+group = "ovh.herisson"
+version = "0.0.1-SNAPSHOT"
+
+java {
+	sourceCompatibility = JavaVersion.VERSION_21
+}
+
+repositories {
+	mavenCentral()
+}
+
+dependencies {
+	compileOnly("org.projectlombok:lombok")
+	annotationProcessor("org.projectlombok:lombok")
+	implementation("org.springframework.boot:spring-boot-starter-jdbc")
+	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+	implementation("org.springframework.boot:spring-boot-starter-mail")
+	implementation("org.springframework.boot:spring-boot-starter-web")
+	implementation("org.springframework.boot:spring-boot-starter-data-jpa")
+	implementation("org.springframework.boot:spring-boot-starter-security")
+	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)
+}
+
+
+tasks.withType<Test> {
+	useJUnitPlatform()
+}
+

backend/compose.yaml

@@ -0,0 +1,9 @@
+services:
+  postgres:
+    image: 'postgres:latest'
+    environment:
+      - 'POSTGRES_DB=clyde'
+      - 'POSTGRES_USER=devel'
+      - 'POSTGRES_PASSWORD=devel'
+    ports:
+      - '5442:5432'

backend/settings.gradle.kts

@@ -0,0 +1,13 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ *
+ * The settings file is used to specify which projects to include in your build.
+ * For more detailed information on multi-project builds, please refer to https://docs.gradle.org/8.6/userguide/multi_project_builds.html in the Gradle documentation.
+ */
+
+plugins {
+    // Apply the foojay-resolver plugin to allow automatic download of JDKs
+    id("org.gradle.toolchains.foojay-resolver-convention") version "0.7.0"
+}
+
+rootProject.name = "Clyde"

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

@@ -0,0 +1,13 @@
+package ovh.herisson.Clyde;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;
+
+@SpringBootApplication(exclude = { SecurityAutoConfiguration.class })
+public class ClydeApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(ClydeApplication.class, args);
+	}
+}

backend/src/main/java/ovh/herisson/Clyde/DTO/Msg/DiscussionDTO.java

@@ -0,0 +1,34 @@
+package ovh.herisson.Clyde.DTO.Msg;
+
+/******************************************************
+ * @file DiscussionDTO.java
+ * @author Anthony Debucquoy
+ * @scope Extension messagerie
+ *
+ * File to format a discussion using messageDTO 
+ ******************************************************/
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Msg.Discussion;
+import ovh.herisson.Clyde.DTO.Msg.MessagesDTO;
+
+@Data
+@AllArgsConstructor
+public class DiscussionDTO {
+	private long id;
+	private String name;
+	private List<User> members;
+	private List<MessagesDTO> msgs;
+
+	public static DiscussionDTO construct(Discussion d, User u){
+		List<MessagesDTO> msgsdto = new ArrayList<>();
+		d.getMsgs().forEach(x -> msgsdto.add(MessagesDTO.construct(x, u)));
+		return new DiscussionDTO(d.getId(), d.getName(), d.getMembers(), msgsdto);
+	} 
+}

backend/src/main/java/ovh/herisson/Clyde/DTO/Msg/MessagesDTO.java

@@ -0,0 +1,33 @@
+package ovh.herisson.Clyde.DTO.Msg;
+
+/******************************************************
+ * @file MessagesDTO.java
+ * @author Anthony Debucquoy
+ * @scope Extension messagerie
+ *
+ * File to Format the response adding the sender field
+ ******************************************************/
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Msg.Message;
+import java.util.Date;
+
+@Data
+@AllArgsConstructor
+public class MessagesDTO {
+	private long id;
+	private String content; 
+	private User author;
+	private boolean sender;
+	private Date created;
+	//TODO: Attachment
+
+	public static MessagesDTO construct(Message m, User user){
+		boolean sender = false;
+		if(m.getAuthor().equals(user))
+			sender = true;
+		return new MessagesDTO(m.getId(), m.getContent(), m.getAuthor(), sender, m.getCreated());
+	}
+}

backend/src/main/java/ovh/herisson/Clyde/DTO/ScientificPublications/ResearchDTO.java

@@ -0,0 +1,63 @@
+package ovh.herisson.Clyde.DTO.ScientificPublications;
+
+/******************************************************
+ * @file ResearchDTO.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Research format to return to front (without author's password)
+ ******************************************************/
+
+import lombok.Data;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Access;
+import ovh.herisson.Clyde.Tables.ScientificPublications.PaperType;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.Date;
+import java.util.HashSet;
+import java.util.Set;
+
+@Data
+public class ResearchDTO {
+
+    private long id;
+    private String title;
+    private ResearcherDTO researcher;
+    private final Set<ResearcherDTO> coAuthors;
+    private Date releaseDate;
+    private PaperType paperType;
+    private String pdfLocation;
+    private String bibTexLocation;
+    private String language;
+    private Access access;
+    private String domain;
+    private String summary;
+    private long views;
+
+    private ResearchDTO(String title, ResearcherDTO researcherDTO, Date releaseDate, PaperType paperType, String pdfLocation, String language, Access access, String domain, String bibTexLocation, String summary, Set<Researcher> coAuthors, long id, long views) {
+        this.title = title;
+        this.researcher = researcherDTO;
+        this.releaseDate = releaseDate;
+        this.paperType = paperType;
+        this.pdfLocation = pdfLocation;
+        this.language = language;
+        this.access = access;
+        this.domain = domain;
+        this.summary = summary;
+        this.id = id;
+        this.bibTexLocation = bibTexLocation;
+        this.coAuthors = new HashSet<>();
+        for (Researcher coAuthor: coAuthors) {
+            this.coAuthors.add(ResearcherDTO.construct(coAuthor));
+        }
+        this.views = views;
+    }
+
+
+    public static ResearchDTO construct(Research research){
+        return new ResearchDTO(research.getTitle(), ResearcherDTO.construct(research.getAuthor()), research.getReleaseDate(),
+                research.getPaperType(),research.getPdfLocation(),research.getLanguage(),research.getAccess(),
+                research.getDomain(),research.getBibTexLocation(), research.getSummary(), research.getCoAuthors(),research.getId(), research.getViews());
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/DTO/ScientificPublications/ResearcherDTO.java

@@ -0,0 +1,38 @@
+package ovh.herisson.Clyde.DTO.ScientificPublications;
+
+/******************************************************
+ * @file ResearcherDTO.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Researcher Format to return to front (without user password)
+ ******************************************************/
+import lombok.Data;
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.Map;
+
+@Data
+public class ResearcherDTO {
+
+    private long id;
+    private Map<String,Object> user;
+    private String site;
+    private String domain;
+    private String orcidId;
+
+
+    private ResearcherDTO(long id, Map<String ,Object> user, String site,String domain,String orcidId){
+        this.domain = domain;
+        this.orcidId = orcidId;
+        this.site = site;
+        this.user = user;
+        this.id = id;
+    }
+
+    public static ResearcherDTO construct(Researcher researcher){
+        return new ResearcherDTO(researcher.getId(), ProtectionService.userWithoutPassword(researcher.getUser()),researcher.getSite(),
+                researcher.getDomain(),researcher.getOrcidId());
+    }
+}

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

@@ -0,0 +1,93 @@
+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.Services.ScientificPublications.ResearchesService;
+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;
+
+    ResearchesService researchesServ;
+
+    public ApplicationsController(AuthenticatorService authServ, ResearchesService researchesServ){
+        this.researchesServ = researchesServ;
+    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.ListResearches);
+        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(!authServ.isNotIn(new Role[]{Role.Teacher,Role.Admin},token))
+            authorizedApps.add(Applications.ManageOwnedLessons);
+        //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, Role.Teacher},token)){
+            authorizedApps.add(Applications.Requests);
+            authorizedApps.add(Applications.StudentsList);}
+
+        if (researchesServ.getResearcherByUser(user) != null)
+            authorizedApps.add(Applications.ManageResearcherProfile);
+
+        if (!authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token)){ 
+          authorizedApps.add(Applications.UsersList);
+          authorizedApps.add(Applications.ManageSchedules);
+          authorizedApps.add(Applications.LessonRequests);
+           authorizedApps.add(Applications.CreateUser);
+		}
+
+        if (!authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin, Role.InscriptionService},token)){
+            authorizedApps.add(Applications.Payments);}
+        return authorizedApps;
+    }
+}

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

@@ -0,0 +1,174 @@
+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.Repositories.CurriculumCourseRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.*;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class CourseController {
+
+    private final CourseService courseServ;
+
+    private final TeacherCourseService teacherCourseServ;
+
+    private final AuthenticatorService authServ;
+
+    private final UserService userService;
+
+    private final CurriculumService curriculumService;
+
+    private final UserCurriculumService userCurriculumService;
+
+    private final CurriculumCourseRepository curriculumCourseRepository;
+    private final CurriculumCourseService curriculumCourseService;
+    public CourseController(CourseService courseServ, TeacherCourseService teacherCourseServ, AuthenticatorService authServ, UserService userService, CurriculumService curriculumService, UserCurriculumService userCurriculumService, CurriculumCourseRepository curriculumCourseRepository, CurriculumCourseService curriculumCourseService) {
+        this.courseServ = courseServ;
+        this.teacherCourseServ = teacherCourseServ;
+        this.authServ = authServ;
+        this.userService = userService;
+        this.curriculumService = curriculumService;
+        this.userCurriculumService = userCurriculumService;
+        this.curriculumCourseRepository = curriculumCourseRepository;
+        this.curriculumCourseService = curriculumCourseService;
+    }
+
+    @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/curriculum/{id}")
+    public ResponseEntity<Map<String ,Object>> postCourse(@RequestHeader("Authorization") String token,
+                                             @RequestBody Course course,@PathVariable long id)
+    {
+        if (authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+        Course createdCourse = courseServ.save(course);
+        Curriculum curriculum = curriculumService.findById(id);
+        if (createdCourse == null || curriculum == null)
+            return new ResponseEntity<>(null,HttpStatus.BAD_REQUEST);
+        CurriculumCourse curriculumCourse = new CurriculumCourse(curriculum,course);
+        curriculumCourseService.save(curriculumCourse);
+        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);
+    }
+
+
+    //Get all the courses followed by an user
+    @GetMapping("/usercourses")
+    public ResponseEntity<List<Course>> getAllUserCourses(@RequestHeader("Authorization") String token){
+        User u = authServ.getUserFromToken(token);
+
+        //We get all the actual curriculums of the user
+        List<UserCurriculum> userCurricula = userCurriculumService.findByStudentAndActual(u, true);
+        List<Course> toReturn = new ArrayList<>();
+
+        //We iterate through all the curriculums and we extract the courses
+        for (int i = 0; i < userCurricula.size(); i++){
+            curriculumCourseRepository.findCoursesByCurriculum(userCurricula.get(i).getCurriculum()).forEach((item) -> {
+                //We need this to eliminate clones because a course can belong to several curriculums
+                if(!toReturn.contains(item)){
+                    toReturn.add(item);
+                }
+            });
+        }
+
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+
+}

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

@@ -0,0 +1,139 @@
+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.Repositories.Inscription.ExternalCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.InscriptionRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.*;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class CurriculumController {
+
+
+    private final CurriculumService curriculumServ;
+    private final CourseService courseServ;
+    private final AuthenticatorService authServ;
+
+    private final UserCurriculumService userCurriculumServ;
+    private final CurriculumCourseService curriculumCourseServ;
+    private final InscriptionRepository ir;
+    private final UserService userServ;
+
+    private final ExternalCurriculumRepository ecr;
+    public CurriculumController(CurriculumService curriculumServ, CourseService courseServ, AuthenticatorService authServ, UserCurriculumService userCurriculumServ, CurriculumCourseService curriculumCourseServ, InscriptionRepository ir, UserService userServ, ExternalCurriculumRepository ecr){
+        this.curriculumServ = curriculumServ;
+        this.courseServ = courseServ;
+        this.authServ = authServ;
+        this.userCurriculumServ = userCurriculumServ;
+        this.curriculumCourseServ = curriculumCourseServ;
+        this.ir = ir;
+        this.userServ = userServ;
+        this.ecr = ecr;
+    }
+
+    @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("/course/curriculum/{id}")
+    public ResponseEntity<Iterable<Curriculum>> getCurriculumsByCourse(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if(authServ.isNotIn(new Role[]{Role.Admin, Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+        Course course = courseServ.findById(id);
+        if(course == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+        Iterable<Curriculum> curriculum = curriculumCourseServ.findCurriculumByCourses(course);
+        return new ResponseEntity<>(curriculum, HttpStatus.OK);
+    }
+
+
+
+    //Return the list of all curicullums of an user
+    @GetMapping("/onescurriculum/{userId}")
+    public ResponseEntity<Map<String ,Object>> findOnesCurriculum(@RequestHeader("Authorization") String token, @PathVariable String userId){
+        if (authServ.getUserFromToken(token) == null)
+            return new UnauthorizedResponse<>(null);
+
+        User u = userServ.getUserById(Long.parseLong(userId));
+        HashMap<String,Object> toReturn = userCurriculumServ.findAllCurriculumByStudent(u);
+
+        if (toReturn == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(toReturn,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> postCourseToCurriculum(@RequestHeader("Authorization") String token,
+                                                          @RequestBody long coursesId,
+                                                          @PathVariable long id){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        CurriculumCourse curriculumCourse = new CurriculumCourse(curriculumServ.findById(id), courseServ.findById(coursesId));
+        if(curriculumCourse.getCourse() == null || curriculumCourse.getCurriculum() == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+
+        curriculumCourseServ.save(curriculumCourse);
+
+        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/Inscription/ExternalCurriculumController.java

@@ -0,0 +1,62 @@
+package ovh.herisson.Clyde.EndPoints.Inscription;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Repositories.Inscription.ExternalCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.InscriptionRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Tables.Inscription.ExternalCurriculum;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class ExternalCurriculumController {
+
+    public final ExternalCurriculumRepository ecr;
+    public final InscriptionRepository inscriptionRepository;
+    public final UserRepository userRepository;
+
+    public ExternalCurriculumController(ExternalCurriculumRepository ecr, InscriptionRepository inscriptionRepository, UserRepository userRepository) {
+        this.ecr = ecr;
+        this.inscriptionRepository = inscriptionRepository;
+        this.userRepository = userRepository;
+    }
+
+    //everyone can post some externalcurriculums (the validity of the elements is assured by the inscription service)
+    @PostMapping("/externalcurriculum")
+    public ResponseEntity<ExternalCurriculum> postExternalCurriculum(@RequestBody Map<String, Object> externalCurrInfos){
+        //An external curriculum can either be linked to an User or to an InscriptionRequest
+        InscriptionRequest ir = null;
+        User user = null;
+        if (externalCurrInfos.get("inscriptionRequestId") != null){
+            ir = inscriptionRepository.findById((Integer) externalCurrInfos.get("inscriptionRequestId"));
+        }else{
+            user = userRepository.findById((Integer) externalCurrInfos.get("userRegNo"));
+        }
+
+        ExternalCurriculum toSave = new ExternalCurriculum(ir, (String) externalCurrInfos.get("school"),(String) externalCurrInfos.get("formation"),(String) externalCurrInfos.get("completion"), (Integer)externalCurrInfos.get("startYear"), (Integer)externalCurrInfos.get("endYear"), (String)externalCurrInfos.get("justifdocUrl"), user);
+
+        return new ResponseEntity<>(ecr.save(toSave), HttpStatus.OK);
+    }
+
+    @GetMapping("/externalcurriculum/{inscReqId}")
+    public ResponseEntity<ArrayList<ExternalCurriculum>> getExternalCurrListByInscrReq(@PathVariable long inscReqId){
+        InscriptionRequest ir = inscriptionRepository.findById(inscReqId);
+
+        ArrayList<ExternalCurriculum> toReturn = ecr.getExternalCurriculumByInscriptionRequest(ir);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @GetMapping("/externalcurriculumbyuser/{userId}")
+    public ResponseEntity<ArrayList<ExternalCurriculum>> getExternalCurrByUser(@PathVariable long userId){
+        User user = userRepository.findById(userId);
+
+        ArrayList<ExternalCurriculum> toReturn = ecr.getExternalCurriculumByUser(user);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+}

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

@@ -0,0 +1,136 @@
+package ovh.herisson.Clyde.EndPoints.Inscription;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.Inscription.InscriptionService;
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.Inscription.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;
+    private final CurriculumRepository curriculumRepository;
+    public InscriptionController(InscriptionService inscriptionServ, AuthenticatorService authServ, CurriculumRepository curriculumRepository){
+        this.inscriptionServ = inscriptionServ;
+        this.authServ = authServ;
+        this.curriculumRepository = curriculumRepository;
+    }
+
+
+    @GetMapping("/requests/register")
+    public ResponseEntity<Iterable<Map<String,Object>>> getAllRequests(@RequestHeader("Authorization") String token){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService, Role.Teacher},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, Role.Teacher},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);
+    }
+
+
+    //Allow teacher or admin to accept or refuse the equivalence
+    @PatchMapping("/request/registerequiv/{id}/{newstate}")
+    public ResponseEntity<Object> editRegisterEquiv(@RequestHeader("Authorization") String token, @PathVariable long id, @PathVariable RequestState newstate){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher}, token))
+            return new UnauthorizedResponse<>(null);
+
+        InscriptionRequest toEdit = inscriptionServ.getById(id);
+
+        //If the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (toEdit.getEquivalenceState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        toEdit.setEquivalenceState(newstate);
+
+        inscriptionServ.save(toEdit);
+
+        if (toEdit.getState() == RequestState.Accepted && (toEdit.getEquivalenceState() == RequestState.Accepted || toEdit.getEquivalenceState() == RequestState.Unrequired))
+        {
+            inscriptionServ.createUser(toEdit);
+        }
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @PatchMapping("/request/registerequivimpose/{id}/{cursusid}")
+    public ResponseEntity<Object> editRegisterEquiv(@RequestHeader("Authorization") String token, @PathVariable long id, @PathVariable long cursusid){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher}, token))
+            return new UnauthorizedResponse<>(null);
+
+        InscriptionRequest toEdit = inscriptionServ.getById(id);
+
+        //If the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (toEdit.getEquivalenceState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        //We impose a curriculum
+        Curriculum curriculum = curriculumRepository.findById(cursusid);
+
+        toEdit.setCurriculumId(curriculum.getCurriculumId());
+        toEdit.setEquivalenceState(RequestState.Accepted);
+
+        inscriptionServ.save(toEdit);
+
+        if (toEdit.getState() == RequestState.Accepted && (toEdit.getEquivalenceState() == RequestState.Accepted || toEdit.getEquivalenceState() == RequestState.Unrequired))
+        {
+            inscriptionServ.createUser(toEdit);
+        }
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/Inscription/MinervalController.java

@@ -0,0 +1,55 @@
+package ovh.herisson.Clyde.EndPoints.Inscription;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Repositories.Inscription.MinervalRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Tables.Inscription.Minerval;
+import ovh.herisson.Clyde.Tables.Role;
+
+import java.util.*;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class MinervalController {
+    private final AuthenticatorService authServ;
+    private final MinervalRepository mr;
+
+    public MinervalController(AuthenticatorService authServ, MinervalRepository mr) {
+        this.authServ = authServ;
+        this.mr = mr;
+    }
+
+    //A new minerval entry is posted when the inscription service accept a registration request
+    @PostMapping("/minerval/{studentRegNo}")
+    public ResponseEntity<Object> postMinerval(@RequestHeader("Authorization") String token, @PathVariable long studentRegNo){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        Calendar c = new GregorianCalendar();
+
+        mr.save(new Minerval(studentRegNo, 0, 835, c.get(Calendar.YEAR)));
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @GetMapping("/minerval/{studentRegNo}")
+    public ResponseEntity<Minerval> getCurrentMinervalbyRegNo(@PathVariable long studentRegNo){
+        ArrayList<Minerval> mlist = mr.getMinervalsByStudentRegNoOrderByYearDesc(studentRegNo);
+
+        //The list is ordered by year in descending order then the index 0 contains the actual minerval (for this year)
+        Minerval m = mlist.get(0);
+        return new ResponseEntity<>(m, HttpStatus.OK);
+    }
+
+    @PatchMapping("/minerval")
+    public ResponseEntity<Object> updateMinerval(@RequestBody Minerval updatedMinerval){
+        Minerval minerval = mr.findById(updatedMinerval.getId());
+
+        minerval.setPaidAmount(updatedMinerval.getPaidAmount());
+        minerval.setToPay(updatedMinerval.getToPay());
+        mr.save(minerval);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/Inscription/PaymentController.java

@@ -0,0 +1,45 @@
+package ovh.herisson.Clyde.EndPoints.Inscription;
+
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Repositories.Inscription.PaymentRepository;
+import ovh.herisson.Clyde.Tables.Inscription.Payment;
+
+import java.util.ArrayList;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class PaymentController {
+
+    private final PaymentRepository paymentRepository;
+
+    public PaymentController(PaymentRepository paymentRepository){
+        this.paymentRepository = paymentRepository;
+    }
+
+    //Post a payment record
+    @PostMapping("/payment")
+    public ResponseEntity<Object> postPayment(@RequestBody Payment payment){
+        paymentRepository.save(payment);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+
+    //Get all payment records of a student
+    @GetMapping("/payment/{studentRegNo}")
+    public ResponseEntity<ArrayList<Payment>> getPaymentsByUser(@PathVariable long studentRegNo){
+        ArrayList<Payment> toReturn = paymentRepository.getPaymentsByStudentRegNo(studentRegNo);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @GetMapping("/payment")
+    public ResponseEntity<ArrayList<Payment>> getAllPayments(){
+        ArrayList<Payment> toReturn = new ArrayList<Payment>();
+
+
+        paymentRepository.findAll().forEach(toReturn::add);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/Inscription/RequestsController.java

@@ -0,0 +1,373 @@
+package ovh.herisson.Clyde.EndPoints.Inscription;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Repositories.CourseRepository;
+import ovh.herisson.Clyde.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.*;
+import ovh.herisson.Clyde.Repositories.UserCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.TokenService;
+import ovh.herisson.Clyde.Services.UserService;
+import ovh.herisson.Clyde.Tables.*;
+import ovh.herisson.Clyde.Tables.Inscription.ExemptionsRequest;
+import ovh.herisson.Clyde.Tables.Inscription.Minerval;
+import ovh.herisson.Clyde.Tables.Inscription.ScholarshipRequest;
+import ovh.herisson.Clyde.Tables.Inscription.UnregisterRequest;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class RequestsController {
+
+    public final TokenService tokenService;
+    public final ExemptionsRequestRepository err;
+    public final ScholarshipRequestRepository srr;
+    public final UserRepository userRepository;
+    public final AuthenticatorService authServ;
+    public final UnregisterRequestRepository unregisterRequestRepository;
+    public final CourseRepository courseRepository;
+    public final UserService userService;
+    public final UserCurriculumRepository userCurriculumRepository;
+    public final CurriculumRepository curriculumRepository;
+    public final MinervalRepository minervalRepository;
+    public final ChangeCurriculumRequestRepository changeCurriculumRequestRepository;
+
+    public RequestsController(TokenService tokenService, ExemptionsRequestRepository err, ScholarshipRequestRepository srr, UserRepository userRepository, AuthenticatorService authServ, UnregisterRequestRepository unregisterRequestRepository, CourseRepository courseRepository, UserService userService, UserCurriculumRepository userCurriculumRepository, CurriculumRepository curriculumRepository, MinervalRepository minervalRepository, ChangeCurriculumRequestRepository changeCurriculumRequestRepository) {
+        this.tokenService = tokenService;
+        this.err = err;
+        this.srr = srr;
+        this.userRepository = userRepository;
+        this.authServ = authServ;
+        this.unregisterRequestRepository = unregisterRequestRepository;
+        this.courseRepository = courseRepository;
+        this.userService = userService;
+        this.userCurriculumRepository = userCurriculumRepository;
+        this.curriculumRepository = curriculumRepository;
+        this.minervalRepository = minervalRepository;
+        this.changeCurriculumRequestRepository = changeCurriculumRequestRepository;
+    }
+
+    @PostMapping(value="/exemptionreq")
+    public ResponseEntity<String> createExemptionReq(@RequestBody Map<String, Object> exemptionsRequestInfo){
+        User user = userRepository.findById((Integer) exemptionsRequestInfo.get("userRegNo"));
+        Course course = courseRepository.findById((Integer) exemptionsRequestInfo.get("courseId"));
+
+        ExemptionsRequest exemptionsRequest = new ExemptionsRequest(user, course, (String) exemptionsRequestInfo.get("justifDocument"), RequestState.Pending, new Date());
+
+        err.save(exemptionsRequest);
+
+        return new ResponseEntity<>(HttpStatus.CREATED);
+    }
+
+    @PostMapping(value="/scholarshipreq")
+    public ResponseEntity<String> createScholarshipReq(@RequestBody Map<String, Object> scholarshipRequestInfo){
+        User user = userRepository.findById((Integer)scholarshipRequestInfo.get("userId"));
+        ScholarshipRequest toCreate = new ScholarshipRequest(user, RequestState.Pending, 0, new Date(), (String) scholarshipRequestInfo.get("taxDocUrl"), (String) scholarshipRequestInfo.get("residencyDocUrl"));
+
+        srr.save(toCreate);
+
+        return new ResponseEntity<>(HttpStatus.CREATED);
+    }
+
+    //Get all the exemptions Request
+    @GetMapping(value = "/exemptionsreq")
+    public ResponseEntity<ArrayList<ExemptionsRequest>> getAllExemptionsRequests(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService, Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+
+        ArrayList<ExemptionsRequest> toReturn = new ArrayList<>();
+
+        err.findAll().forEach(toReturn::add);
+
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/exemptionsreq/{id}")
+    public ResponseEntity<ExemptionsRequest> getExemptionRequestbyId(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ExemptionsRequest exemptionsRequest = err.findById(id);
+
+        return new ResponseEntity<>(exemptionsRequest, HttpStatus.OK);
+    }
+
+    @PatchMapping(value = "/exemptionsreq/{id}/{newstate}")
+    public ResponseEntity<String> changeExemptionReqState(@RequestHeader("Authorization") String token, @PathVariable long id, @PathVariable RequestState newstate){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+
+        ExemptionsRequest exemptionsRequest = err.findById(id);
+
+        if (exemptionsRequest.getState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        exemptionsRequest.setState(newstate);
+        err.save(exemptionsRequest);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    //Get all the scholarships requests
+    @GetMapping(value = "/scholarshipreq")
+    public ResponseEntity<ArrayList<ScholarshipRequest>> getAllScholarshipRequests(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ArrayList<ScholarshipRequest> toReturn = new ArrayList<>();
+
+        srr.findAll().forEach(toReturn::add);
+
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @PostMapping(value = "/unregister")
+    public ResponseEntity<String> postUnregReq(@RequestBody Map<String,Object> uninscr){
+        User u = userRepository.findById((int) uninscr.get("userId"));
+        Curriculum c;
+
+        if (uninscr.get("curriculumId") == null){
+            c = null;
+        }else{
+            c = curriculumRepository.findById((Integer) uninscr.get("curriculumId"));
+        }
+
+        UnregisterRequest ur = new UnregisterRequest(RequestState.Pending, (String) uninscr.get("reason"), new Date(), u.getRegNo(), u.getFirstName(), u.getLastName(), u.getEmail(), c);
+        unregisterRequestRepository.save(ur);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @PatchMapping(value = "/scholarshipreq/")
+    public ResponseEntity<String> editScholReq(@RequestHeader("Authorization") String token, @RequestBody Map<String,Object> infos){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ScholarshipRequest scholarshipRequest = srr.findById((Integer) infos.get("id"));
+
+        User u = scholarshipRequest.getUser();
+
+        //If the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (scholarshipRequest.getState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        if (infos.get("state").equals("Accepted")){
+            scholarshipRequest.setState(RequestState.Accepted);
+            scholarshipRequest.setAmount((int) infos.get("amount"));
+
+            //We then deduce then amount from the minerval
+            ArrayList<Minerval> minerval = minervalRepository.getMinervalsByStudentRegNoOrderByYearDesc(u.getRegNo());
+            minerval.get(0).setPaidAmount(minerval.get(0).getPaidAmount() + scholarshipRequest.getAmount());
+            minerval.get(0).setToPay(minerval.get(0).getToPay() - scholarshipRequest.getAmount());
+            minervalRepository.save(minerval.get(0));
+        }else{
+            scholarshipRequest.setState(RequestState.Refused);
+        }
+
+        srr.save(scholarshipRequest);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/scholarshipreq/{id}")
+    public ResponseEntity<ScholarshipRequest> getScholReqbyId(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin, Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ScholarshipRequest toReturn = srr.findById(id);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/unregister")
+    public ResponseEntity<ArrayList<UnregisterRequest>> getAllUnregReq(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ArrayList<UnregisterRequest> toReturn = new ArrayList<>();
+        unregisterRequestRepository.findAll().forEach(toReturn::add);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @GetMapping(value = "/unregister/{id}")
+    public ResponseEntity<UnregisterRequest> getUnregbyId(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        UnregisterRequest unregisterRequest = unregisterRequestRepository.findById(id);
+        return new ResponseEntity<>(unregisterRequest, HttpStatus.OK);
+    }
+
+    @PatchMapping(value = "/unregister/{id}/{newstate}")
+    public ResponseEntity<String> pathUnregReq(@RequestHeader("Authorization") String token, @PathVariable long id, @PathVariable RequestState newstate){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        UnregisterRequest unregisterRequest = unregisterRequestRepository.findById(id);
+        User u = userRepository.findById(unregisterRequest.getRegNo());
+
+        //If the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (unregisterRequest.getState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        unregisterRequest.setState(newstate);
+        unregisterRequestRepository.save(unregisterRequest);
+        if (newstate == RequestState.Accepted){
+            if (unregisterRequest.getCurriculum() == null){
+                ArrayList<UserCurriculum> userCurricula = userCurriculumRepository.findByUserOrderByCurriculum(u);
+                for (int i = 0; i < userCurricula.size(); i++){
+                    userCurricula.get(i).setActual(false);
+                }
+                userCurriculumRepository.saveAll(userCurricula);
+            }else{
+                //This usercurriculum will contain the usercurriculum to set false
+                UserCurriculum userCurriculum = userCurriculumRepository.findByUserAndCurriculumAndActual(u, unregisterRequest.getCurriculum(), true);
+                userCurriculum.setActual(false);
+                userCurriculumRepository.save(userCurriculum);
+            }
+        }
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    //We look in the usercursus table if the student has already the previous year of a curriculum
+    public boolean studentHasPrevYear(Curriculum curriculum, User user){
+        ArrayList<UserCurriculum> userCurrList = userCurriculumRepository.findByUserOrderByCurriculum(user);
+        for (int i = 0; i < userCurrList.size(); i++){
+            if (userCurrList.get(i).getCurriculum().getOption().equals(curriculum.getOption()) && userCurrList.get(i).getCurriculum().getYear() == curriculum.getYear()-1){
+                return true;
+            }
+        }
+        return false;
+    }
+    @PostMapping("/changecurriculumreq")
+    public ResponseEntity<String> addChangeCurrReq(@RequestBody Map<String,Object> reqInfos){
+        User user = userRepository.findById((Integer) reqInfos.get("userId"));
+
+        Curriculum actualCurriculum;
+
+        //If null then it means we are in a supplementary cursus case
+        if (reqInfos.get("actualcursus") == null){
+            actualCurriculum = null;
+        }else{
+            actualCurriculum = curriculumRepository.findById((Integer) reqInfos.get("actualcursus"));
+        }
+
+        Curriculum destinationCurriculum = curriculumRepository.findById((Integer) reqInfos.get("newcursus"));
+
+        ChangeCurriculumRequest changeCurriculumRequest = new ChangeCurriculumRequest(user, actualCurriculum, destinationCurriculum, new Date(), RequestState.Pending, RequestState.Unrequired);
+
+        //Si l'année du cursus est plus grande que 1 et que l'étudiant n'a pas dans sa liste de cursus l'année d'en dessous alors on demande l'accord du prof
+        if (destinationCurriculum.getYear() > 1 && !studentHasPrevYear(destinationCurriculum, user)){
+            changeCurriculumRequest.setTeacherApprovalState(RequestState.Pending);
+        }
+        changeCurriculumRequestRepository.save(changeCurriculumRequest);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @GetMapping("/changecurriculumreq")
+    public  ResponseEntity<ArrayList <ChangeCurriculumRequest>> getAllChangeCurrReq(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService, Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+
+        ArrayList<ChangeCurriculumRequest> toReturn = new ArrayList<>();
+
+        changeCurriculumRequestRepository.findAll().forEach(toReturn::add);
+
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @GetMapping("/changecurriculumreq/{id}")
+    public ResponseEntity<ChangeCurriculumRequest> getCCrbyId(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ChangeCurriculumRequest toReturn = changeCurriculumRequestRepository.findById(id);
+        return new ResponseEntity<>(toReturn, HttpStatus.OK);
+    }
+
+    @PatchMapping("/changecurriculumreq/{id}/{newState}")
+    public ResponseEntity<String> editCCReq(@RequestHeader("Authorization") String token, @PathVariable long id, @PathVariable RequestState newState){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.InscriptionService},token))
+            return new UnauthorizedResponse<>(null);
+
+        ChangeCurriculumRequest toEdit = changeCurriculumRequestRepository.findById(id);
+
+        //If the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (toEdit.getState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        toEdit.setState(newState);
+        changeCurriculumRequestRepository.save(toEdit);
+        if (newState == RequestState.Accepted && (toEdit.getTeacherApprovalState() == RequestState.Accepted || toEdit.getTeacherApprovalState() == RequestState.Unrequired)){
+            //If actual curriculum is not null then we need to set that the user doesn't follow it anymore
+            acceptProcedure(toEdit);
+        }
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @PatchMapping("/changecurriculumreqteacher/{id}/{newteacherstate}")
+    public ResponseEntity<String> editCCReqTeacherState(@RequestHeader("Authorization") String token, @PathVariable long id, @PathVariable RequestState newteacherstate){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+
+        ChangeCurriculumRequest toEdit = changeCurriculumRequestRepository.findById(id);
+
+        //If the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (toEdit.getTeacherApprovalState() == RequestState.Accepted){
+            return new ResponseEntity<>(HttpStatus.OK);
+        }
+
+        toEdit.setState(newteacherstate);
+        changeCurriculumRequestRepository.save(toEdit);
+
+        if (newteacherstate == RequestState.Accepted && toEdit.getState() == RequestState.Accepted){
+            //If actual curriculum is not null then we need to set that the user doesn't follow it anymore
+            acceptProcedure(toEdit);
+        }
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    private void acceptProcedure(ChangeCurriculumRequest toEdit) {
+        User u = toEdit.getUser();
+        if (toEdit.getActualCurriculum() != null){
+            ArrayList<UserCurriculum> listcurr = userCurriculumRepository.findByUserOrderByCurriculum(u);
+
+            for (int i = 0; i < listcurr.size(); i++){
+                if (listcurr.get(i).getCurriculum() == toEdit.getActualCurriculum()){
+                    listcurr.get(i).setActual(false);
+                }
+            }
+
+            userCurriculumRepository.saveAll(listcurr);
+        }
+
+        Calendar c = Calendar.getInstance();
+        UserCurriculum userCurriculum = new UserCurriculum(u, toEdit.getDestinationCurriculum(), c.get(Calendar.YEAR), true);
+        userCurriculumRepository.save(userCurriculum);
+    }
+
+    @GetMapping("/exemptionreq/{userId}")
+    public ResponseEntity<ArrayList<ExemptionsRequest>> getExReqByuser(@RequestHeader("Authorization") String token, @PathVariable long userId){
+        User currentUser = tokenService.getUserFromToken(token);
+
+        //Only admin, teacher, secretary and the student himself can access a student's data here
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher, Role.Secretary},token) && currentUser.getRegNo() != userId)
+            return new UnauthorizedResponse<>(null);
+
+        User u = userRepository.findById(userId);
+
+        ArrayList<ExemptionsRequest> exList = err.findByUser(u);
+        return new ResponseEntity<>(exList, HttpStatus.OK);
+    }
+}

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

@@ -0,0 +1,129 @@
+package ovh.herisson.Clyde.EndPoints;
+
+/******************************************************
+ * @file LessonController.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ *
+ * Controller of Lessons API
+ ******************************************************/
+
+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.LessonService;
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Services.ScheduleLessonService;
+import ovh.herisson.Clyde.Tables.Lesson;
+import ovh.herisson.Clyde.Tables.Role;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class LessonController {
+    private final LessonService lessonServ;
+
+    private final ScheduleLessonService scheduleLessonServ;
+    private final AuthenticatorService authServ;
+
+    public LessonController(LessonService lessonServ, ScheduleLessonService scheduleLessonService, AuthenticatorService authServ) {
+        this.lessonServ = lessonServ;
+        this.scheduleLessonServ = scheduleLessonService;
+        this.authServ = authServ;
+    }
+
+    /**
+     * Return a lesson via its id
+     */
+    @GetMapping("/lesson/{id}")
+    public ResponseEntity<HashMap<String,Object>> getLesson(@PathVariable long id){
+        Lesson lesson = lessonServ.findById(id);
+
+        if(lesson == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ProtectionService.lessonWithoutPassword(lesson),HttpStatus.OK);
+    }
+
+    /**
+     * Return all the lessons
+     */
+    @GetMapping("/lessons")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllLessons(@RequestHeader("Authorization") String token){
+        if(authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+        return new ResponseEntity<>(ProtectionService.lessonsWithoutPassword(lessonServ.findAll()),HttpStatus.OK);
+    }
+
+    /**
+     * Return all the lessons of a teacher's courses
+     */
+    @GetMapping("/lessons/owned")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getOwnedLessons(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token)){
+            return new UnauthorizedResponse<>(null);}
+        return new ResponseEntity<>(ProtectionService.lessonsWithoutPassword(lessonServ.findAllOwnedLesson(authServ.getUserFromToken(token))),HttpStatus.OK);
+    }
+
+    /**
+     ⋅* Return all the lessons of a student
+     */
+    @GetMapping("/lessons/OwnCurriculum")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getOnesLessons(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Student},token)){
+            return new UnauthorizedResponse<>(null);}
+        return new ResponseEntity<>(ProtectionService.lessonsWithoutPassword(lessonServ.findOnesLessons(authServ.getUserFromToken(token))),HttpStatus.OK);
+    }
+
+    /**
+     * Post a new lesson
+     */
+    @PostMapping("/lesson")
+    public ResponseEntity<HashMap<String, Object>> postLesson(@RequestHeader("Authorization") String token,
+                                                              @RequestBody Map<String, Object> lessonInfos){
+        if(authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+
+
+          Lesson lesson = lessonServ.createLesson(lessonInfos);
+          Lesson createdLesson = lessonServ.save(lesson);
+          scheduleLessonServ.saveToAllSchedule(lesson);
+
+        if(createdLesson==null)
+            return new ResponseEntity<>(null,HttpStatus.BAD_REQUEST);
+        return new ResponseEntity<>(ProtectionService.lessonWithoutPassword(createdLesson), HttpStatus.OK);
+    }
+    /**
+     * Modify a lesson
+     */
+    @PatchMapping("/lesson/{id}")
+    public ResponseEntity<Lesson> patchLesson(@RequestHeader("Authorization") String token,
+                                              @RequestBody Map<String, Object> updates,
+                                              @PathVariable long id){
+        if(authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+        if(!lessonServ.modifyData(id, updates)){
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+          }
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+    /**
+     * Delete a lesson
+     */
+    @DeleteMapping("lesson/{id}")
+    public ResponseEntity<String> deleteLesson(@RequestHeader("Authorization") String token,
+                                               @PathVariable Long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+        Lesson toDelete = lessonServ.findById(id);
+        if(toDelete == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+        lessonServ.delete(toDelete);
+        return new ResponseEntity<>(HttpStatus.OK);
+
+    }
+}

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

@@ -0,0 +1,149 @@
+package ovh.herisson.Clyde.EndPoints;
+
+/******************************************************
+ * @file LessonRequestsController.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ *
+ * Controller of lesson requests API
+ ******************************************************/
+
+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.*;
+
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class LessonRequestsController {
+    private final LessonRequestService lessonRequestServ;
+    private final AuthenticatorService authServ;
+    private final UserService userServ;
+
+    private final LessonService lessonServ;
+    public LessonRequestsController(LessonRequestService lessonRequestServer, AuthenticatorService authServ, UserService userServ, LessonService lessonServ) {
+        this.lessonRequestServ = lessonRequestServer;
+        this.authServ = authServ;
+        this.userServ = userServ;
+        this.lessonServ = lessonServ;
+    }
+    /**
+     * Return a lesson request via its id
+     */
+    @GetMapping("/requests/lessonRequest/{id}")
+    public ResponseEntity<Map<String,Object>> getById(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        LessonChangesRequest lessonRequest= lessonRequestServ.findById(id);
+
+        return new ResponseEntity<>(ProtectionService.lessonRequestWithoutPassword(lessonRequest), HttpStatus.OK);
+    }
+    /**
+     * return all the requests made by a user
+     */
+    @GetMapping("/requests/lessonRequests/owned")
+    public ResponseEntity<Iterable<Map<String, Object>>> getOwnedRequests(@RequestHeader("Authorization") String token){
+        if(authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+        User user = authServ.getUserFromToken(token);
+        Iterable<LessonChangesRequest> lessonChangesRequests = lessonRequestServ.findOwnRequests(user);
+        return new ResponseEntity<>(ProtectionService.lessonRequestsWithoutPassword(lessonChangesRequests),HttpStatus.OK);
+
+    }
+    /**
+     *  Return all the lesson requests
+     */
+    @GetMapping("/requests/lessonRequests")
+    public ResponseEntity<Iterable<Map<String,Object>>> getAllRequests(@RequestHeader("Authorization") String token){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        Iterable<LessonChangesRequest> lessonRequests= lessonRequestServ.getAll();
+
+        return new ResponseEntity<>(ProtectionService.lessonRequestsWithoutPassword(lessonRequests), HttpStatus.OK);
+    }
+    /**
+     * Post a lesson request
+     */
+    @PostMapping("/requests/lessonRequest")
+    public ResponseEntity<Map<String, Object>> makeRequest(@RequestHeader("Authorization") String token, @RequestBody Map<String,Object> lessonRequestInfos){
+        if(authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+        LessonChangesRequest lessonChangesRequest = lessonRequestServ.createLessonRequest(lessonRequestInfos);
+        LessonChangesRequest createdRequest = lessonRequestServ.save(lessonChangesRequest);
+        if(createdRequest == null)
+            return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
+        return new ResponseEntity<>(ProtectionService.lessonRequestWithoutPassword(lessonChangesRequest),HttpStatus.OK);
+    }
+    /**
+     * Modify a lesson Request
+     */
+    @PatchMapping("/requests/lessonRequest/{id}")
+    public ResponseEntity<LessonChangesRequest> changeRequestState(@PathVariable long id,
+                                                                   @RequestHeader("Authorization") String token,
+                                                                   @RequestBody Map<String , Object> infos){
+        if(authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token))
+            return new UnauthorizedResponse<>(null);
+
+        LessonChangesRequest lessonRequest = lessonRequestServ.findById(id);
+            String local = "";
+            RequestState state = null;
+            for (Map.Entry<String, Object> entry : infos.entrySet()) {
+                switch (entry.getKey()) {
+                    case "local":
+                        local = (String) entry.getValue();
+                        break;
+                    case "state":
+                        state = RequestState.valueOf((String)entry.getValue());
+                }
+            }
+
+            if (state == null)
+                return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        if(lessonRequest.getRequestType() == 0 ) {
+            if (!lessonRequestServ.modifyCreateRequestState(lessonRequest, state, local))
+                return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+            userServ.Notify(lessonRequest.getUser(), new Notification("Request took in charge","Request"+ state + ":" + lessonRequest.getCourse().getTitle(), "#/manage-owned-lessons"));
+        }
+
+        else if(lessonRequest.getRequestType() == 1){
+            infos.put("lessonStart", lessonRequest.getLessonStart());
+            infos.put("lessonEnd", lessonRequest.getLessonEnd());
+            infos.put("lessonType",lessonRequest.getLessonType());
+            if(!lessonRequestServ.modifyChangeRequestState(infos,lessonRequest.getLessonId(),state))
+                return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+            lessonRequest.setState(state);
+            userServ.Notify(lessonRequest.getUser(), new Notification("Request took in charge","Request"+ state + ":" + lessonServ.findById(lessonRequest.getLessonId()).getCourse().getTitle(), "#/manage-owned-lessons"));
+
+        }
+
+        else{
+            userServ.Notify(lessonRequest.getUser(), new Notification("Request took in charge","Request"+ state + ":" + lessonServ.findById(lessonRequest.getLessonId()).getCourse().getTitle(), "#/manage-owned-lessons"));
+            lessonRequestServ.modifyDeleteRequest(lessonRequest, state);
+            lessonRequest.setState(state);
+        }
+        lessonRequestServ.save(lessonRequest);
+        return new ResponseEntity<>(HttpStatus.OK);
+
+    }
+
+    /**
+     * Delete a lesson request
+     */
+    @DeleteMapping("/requests/lessonRequest/{id}")
+    public ResponseEntity<String> deleteRequest(@RequestHeader("Authorization") String token, @PathVariable long id){
+        if(authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary,Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+        LessonChangesRequest lessonChangesRequest = lessonRequestServ.findById(id);
+        if (lessonChangesRequest == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+        lessonRequestServ.delete(lessonChangesRequest);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

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

@@ -0,0 +1,70 @@
+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.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.ProtectionService;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.RequestState;
+
+import java.util.Date;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class LoginController {
+    private final AuthenticatorService authServ;
+    private final CurriculumRepository curriculumRepository;
+    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, CurriculumRepository curriculumRepository){
+        this.authServ = authServ;
+        this.curriculumRepository = curriculumRepository;
+    }
+
+    @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");
+        }
+
+        HttpHeaders responseHeaders = new HttpHeaders();
+        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){
+        //We ensure here that if the targeted cursus year is more than first grade then we need the teacher equivalence approval
+        Curriculum curr = curriculumRepository.findById(inscriptionRequest.getCurriculumId());
+
+        if (curr.getYear() > 1){
+            inscriptionRequest.setEquivalenceState(RequestState.Pending);
+        }else{
+            inscriptionRequest.setEquivalenceState(RequestState.Unrequired);
+        }
+
+        InscriptionRequest returnedInscriptionRequest = authServ.register(inscriptionRequest);
+
+
+        return new ResponseEntity<>(ProtectionService.requestWithoutPassword(returnedInscriptionRequest), HttpStatus.CREATED);
+    }
+}

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

@@ -0,0 +1,235 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Repositories.*;
+import ovh.herisson.Clyde.Repositories.Inscription.ExternalCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.MinervalRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.ScholarshipRequestRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.UnregisterRequestRepository;
+import ovh.herisson.Clyde.Services.*;
+import ovh.herisson.Clyde.Services.ScientificPublications.ResearchesService;
+import ovh.herisson.Clyde.Tables.*;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Access;
+import ovh.herisson.Clyde.Tables.ScientificPublications.PaperType;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+import ovh.herisson.Clyde.Services.Inscription.InscriptionService;
+import ovh.herisson.Clyde.Tables.Inscription.ExternalCurriculum;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.Inscription.Minerval;
+import ovh.herisson.Clyde.Tables.Inscription.ScholarshipRequest;
+import ovh.herisson.Clyde.Tables.Inscription.*;
+
+import java.util.*;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class MockController {
+    public final UserService userService;
+    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 ExternalCurriculumRepository externalCurriculumRepository;
+    public final InscriptionService inscriptionService;
+
+    public final LessonService lessonService;
+    public final ScheduleService scheduleService;
+    public final ScheduleLessonService scheduleLessonService;
+
+    public final LessonRequestService lessonRequestService;
+    ArrayList<User> mockUsers;
+
+    public final ResearchesService researchesService;
+    public final UserCurriculumRepository ucr;
+    public final MinervalRepository minervalRepository;
+    public final ScholarshipRequestRepository scholarshipRequestRepository;
+    
+    public final UnregisterRequestRepository uninscriptionRequestRepository;
+    public MockController(UserService userService, UserRepository userRepo, TokenRepository tokenRepo, TokenService tokenService, CurriculumCourseService CurriculumCourseService, CurriculumService curriculumService, CourseService courseService, ExternalCurriculumRepository externalCurriculumRepository, ResearchesService researchesService, InscriptionService inscriptionService, UserCurriculumRepository ucr, MinervalRepository minervalRepository, ScholarshipRequestRepository scholarshipRequestRepository, UnregisterRequestRepository unregisterRequestRepository, LessonService lessonService, ScheduleService scheduleService, ScheduleLessonService scheduleLessonService, LessonRequestService lessonRequestService){
+        this.userService = userService;
+        this.tokenRepo = tokenRepo;
+        this.userRepo = userRepo;
+        this.tokenService = tokenService;
+        this.CurriculumCourseService = CurriculumCourseService;
+        this.curriculumService = curriculumService;
+        this.courseService = courseService;
+        this.externalCurriculumRepository = externalCurriculumRepository;
+        this.inscriptionService = inscriptionService;
+        this.researchesService = researchesService;
+        this.lessonService = lessonService;
+        this.scheduleService = scheduleService;
+        this.scheduleLessonService = scheduleLessonService;
+        this.lessonRequestService = lessonRequestService;
+        this.ucr = ucr;
+        this.minervalRepository = minervalRepository;
+        this.scholarshipRequestRepository = scholarshipRequestRepository;
+        this.uninscriptionRequestRepository = unregisterRequestRepository;
+    }
+
+    /** Saves an example of each user type by :
+     * email : FooRole@FooRole.com, password : FooRole and token : FooRole
+     * For example the admin as "admin@admin.com" as email and "admin" as both password and token
+     * They all have silly names
+     */
+
+    @PostMapping("/mock")
+    public void postMock() {
+
+
+        // user part
+        User herobrine = new User("brine","hero","admin@admin.com","behind","ShadowsLand",new Date(0), null,Role.Admin,"admin");
+        User joe = new User("Piplo","Joe","student@student.com","roundabout","England",new Date(0), null,Role.Student,"student");
+        User meh = new User("Polo","Marco","secretary@secretary.com","a Box","Monaco",new Date(0), null,Role.Secretary,"secretary");
+        User joke = new User("Gaillard","Corentin","teacher@teacher.com","lab","faculty",new Date(0), null,Role.Teacher,"teacher");
+        User jojo = new User("Bridoux","Justin","teacher2@teacher2.com","lab","faculty",new Date(0), null,Role.Teacher,"teacher");
+        User lena = new User("Louille","Lena","inscriptionService@InscriptionService.com","no","yes",new Date(0), null,Role.InscriptionService,"inscriptionService");
+        User popo = new User("Smith", "Paul", "paulsmith@gmail.com", "306 rue du poulet", "belgique", new Date(0), null, Role.Student, "jesuispaulleroi");
+        mockUsers = new ArrayList<>(Arrays.asList(herobrine,joe,meh,joke,lena,jojo, popo));
+
+        userService.saveAll(mockUsers);
+
+        ExternalCurriculum externalCurriculum = new ExternalCurriculum(null, "HEH", "Bachelier en ingénieur", "completed", 2015, 2017, null, joe);
+        externalCurriculumRepository.save(externalCurriculum);
+
+            Minerval minerval = new Minerval(joe.getRegNo(), 0, 852, 2023);
+            minervalRepository.save(minerval);
+            // Course / Curriculum part
+
+        Curriculum infoBab1 = new Curriculum(1,"info", false);
+        Curriculum chemistryBab1 = new Curriculum(1,"chemistry", false);
+        Curriculum psychologyBab1 = new Curriculum(1,"psychology", false);
+        Curriculum infoBab2 = new Curriculum(2,"info", false);
+        Curriculum masterinfo1 = new Curriculum(4, "info", false);
+        Curriculum masterinfo2 = new Curriculum(5, "info", false);
+        Curriculum chemistryBab2 = new Curriculum(2, "chemistry", false);
+        Curriculum ingebab1 = new Curriculum(1, "ingénieur", true);
+
+        curriculumService.save(infoBab1);
+        curriculumService.save(chemistryBab1);
+        curriculumService.save(psychologyBab1);
+        curriculumService.save(infoBab2);
+        curriculumService.save(masterinfo1);
+        curriculumService.save(masterinfo2);
+        curriculumService.save(chemistryBab2);
+        curriculumService.save(ingebab1);
+
+        ucr.save(new UserCurriculum(joe, infoBab1, 2022, false));
+        ucr.save(new UserCurriculum(joe, chemistryBab1, 2023, true));
+        ucr.save(new UserCurriculum(joe, infoBab1, 2023, true));
+        ucr.save(new UserCurriculum(joe, psychologyBab1, 2020, false));
+        ucr.save(new UserCurriculum(popo, infoBab1, 2022, false));
+        ucr.save(new UserCurriculum(popo, infoBab2, 2023, true));
+
+        Course progra1 = new Course(5,"Programmation et algorithmique 1",joke);
+        Course chemistry1 = new Course(12, "Thermochimie",jojo);
+        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);
+
+            ScholarshipRequest ssr1 = new ScholarshipRequest(joe, RequestState.Pending, 0, new Date(), "test", "test");
+            scholarshipRequestRepository.save(ssr1);
+
+
+        CurriculumCourseService.save(new CurriculumCourse(infoBab1,progra1));
+        CurriculumCourseService.save(new CurriculumCourse(infoBab1,commun));
+        CurriculumCourseService.save(new CurriculumCourse(infoBab1, psycho1));
+        CurriculumCourseService.save(new CurriculumCourse(psychologyBab1,psycho1));
+        CurriculumCourseService.save(new CurriculumCourse(psychologyBab1,commun));
+        CurriculumCourseService.save(new CurriculumCourse(chemistryBab1, chemistry1));
+
+            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) 4,RequestState.Pending,"yes.png","password", null, new Date(), RequestState.Pending, null);
+
+            inscriptionService.save(inscriptionRequest);
+
+            ///////////////////////////
+            // extension Publications Scientifiques
+            Researcher jojoResearcherAccount = new Researcher(jojo, "3363-22555-AB33-T", null, "IT");
+
+            Researcher joResearchAccount = new Researcher(joe,"N555-321213-BED-DD",null, "Physics");
+
+
+            Researcher output = researchesService.saveResearcher(jojoResearcherAccount);
+            Researcher joOutput = researchesService.saveResearcher(joResearchAccount);
+
+            Set<Researcher> coAuthor = new HashSet<>();
+            coAuthor.add(joOutput);
+
+            Research jojoResearch = new Research("Graphs : Advanced Search Algorithms", output, new Date(0),
+                    PaperType.Article, "test.pdf", null, "english",
+                    Access.OpenSource, "IT", "This Article's title speaks for itself \n We'll discuss about advanced Graph search Algorithms",coAuthor);
+            Research restrictedResearch = new Research("the great Constantinople war", output, new Date(1111111111),
+                    PaperType.Article, "restricted", null, "Portuguese",
+                    Access.Restricted, "history", "this is a summary", new HashSet<>());
+
+            Research privateResearch = new Research("the great Potato War", output, new Date(),
+                    PaperType.Article, "private", null, "english",
+                    Access.Private, "agriculture", "my life is potato",null);
+
+
+            researchesService.saveResearch(restrictedResearch);
+            researchesService.saveResearch(privateResearch);
+            researchesService.saveResearch(jojoResearch);
+
+
+        //Schedule part
+
+        Lesson lesson_0_progra1 = new Lesson(progra1, "Mon Apr 22 2024 08:15", "Mon Apr 22 2024 10:15","rgb(0,50,100)","A0B2","Course");
+        Lesson lesson_0_chemistry1 = new Lesson(chemistry1, "Wed Mar 27 2024 08:15", "Wed Mar 27 2024 09:15","rgb(100,50,0)","A0B2","TP");
+        Lesson lesson_0_psycho1 = new Lesson(psycho1, "Sun Mar 24 2024 10:30 ","Sun Mar 24 2024 12:30 ","rgb(100,50,100)", "A0B2","TD");
+        Lesson lesson_1_progra1 = new Lesson(progra1, "Mon Apr 02 2024 13:30", "Mon Apr 02 2024 15:30","rgb(0,50,100)","A0B2","TP");
+        Lesson lesson_0_commun = new Lesson(commun, "Mon Apr 01 2024 10:30", "Mon Apr 01 2024 12:30","rgb(0,50,100)","A0B2","Course");
+
+        LessonChangesRequest request1 = new LessonChangesRequest(joke,RequestState.Pending,null,null,null,null,2,null,1);
+        LessonChangesRequest request2 = new LessonChangesRequest(joke,RequestState.Pending,"Fri Apr 19 2024 10:30 ","Fri Apr 19 2024 12:30 ",null,null,1,null,2);
+        LessonChangesRequest request3 = new LessonChangesRequest(joke,RequestState.Pending,"Fri Apr 19 2024 13:30 ","Fri Apr 19 2024 15:30 ","Course",progra1,0,"rgb(27,49,100)",4);
+
+
+        Schedule infoBab1Schedule = new Schedule(infoBab1);
+        Schedule chemistryBab1Schedule = new Schedule(chemistryBab1);
+        Schedule psychoBab1Schedule = new Schedule(psychologyBab1);
+
+
+        scheduleService.save(infoBab1Schedule);
+        scheduleService.save(chemistryBab1Schedule);
+        scheduleService.save(psychoBab1Schedule);
+
+        lessonService.save(lesson_0_progra1);
+        lessonService.save(lesson_0_chemistry1);
+        lessonService.save(lesson_0_commun);
+        lessonService.save(lesson_0_psycho1);
+        lessonService.save(lesson_1_progra1);
+
+        scheduleLessonService.save(new ScheduleLesson(infoBab1Schedule,lesson_0_progra1));
+        scheduleLessonService.save(new ScheduleLesson(infoBab1Schedule,lesson_1_progra1));
+        scheduleLessonService.save(new ScheduleLesson(infoBab1Schedule,lesson_0_commun));
+
+        scheduleLessonService.save(new ScheduleLesson(chemistryBab1Schedule,lesson_0_chemistry1));
+        scheduleLessonService.save(new ScheduleLesson(chemistryBab1Schedule,lesson_0_commun));
+
+        scheduleLessonService.save(new ScheduleLesson(psychoBab1Schedule,lesson_0_psycho1));
+        scheduleLessonService.save(new ScheduleLesson(psychoBab1Schedule,lesson_0_commun));
+
+
+        lessonRequestService.save(request1);
+        lessonRequestService.save(request2);
+        lessonRequestService.save(request3);
+
+        UnregisterRequest unregisterRequest = new UnregisterRequest(RequestState.Pending, "je veux partir", new Date(), joe.getRegNo(), joe.getFirstName(), joe.getLastName(), joe.getEmail(), null);
+        uninscriptionRequestRepository.save(unregisterRequest);
+
+        externalCurriculum = new ExternalCurriculum(inscriptionRequest, "HEH", "Bachelier en informatique", "Completed", 2015, 2018, null, null);
+        externalCurriculumRepository.save(externalCurriculum);
+    }
+}
+

backend/src/main/java/ovh/herisson/Clyde/EndPoints/Msg/ForumController.java

@@ -0,0 +1,113 @@
+package ovh.herisson.Clyde.EndPoints.Msg;
+
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.HttpStatusCode;
+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.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RestController;
+
+import jakarta.websocket.server.PathParam;
+import lombok.AllArgsConstructor;
+import ovh.herisson.Clyde.Repositories.CourseRepository;
+import ovh.herisson.Clyde.Repositories.Msg.AnswerRepository;
+import ovh.herisson.Clyde.Repositories.Msg.ForumRepository;
+import ovh.herisson.Clyde.Repositories.Msg.TopicRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.CourseService;
+import ovh.herisson.Clyde.Services.Msg.ForumService;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.Token;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Msg.Answer;
+import ovh.herisson.Clyde.Tables.Msg.Forum;
+import ovh.herisson.Clyde.Tables.Msg.Topic;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+@AllArgsConstructor
+public class ForumController {
+
+	private CourseRepository courseRepo;
+	private AuthenticatorService authServ;
+	private ForumService forumServ;
+	private ForumRepository forumRepo;
+	private TopicRepository topicRepo;
+
+	//// Endpoints to get and create new forums
+
+	@GetMapping("/forums/{id}")
+	public ResponseEntity<List<Forum>> getForumFromCourseId(@RequestHeader("Authorization") String token, @PathVariable long id){
+		User u = authServ.getUserFromToken(token);
+		if(u == null){
+			return new UnauthorizedResponse<>(null);
+		}
+		return new ResponseEntity<>(courseRepo.findById(id).getForums(), HttpStatus.OK);
+	}
+
+	@PostMapping("/forums/{id}")
+	public ResponseEntity<Forum> createForumOfCourse(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody Forum data){
+		User u = authServ.getUserFromToken(token);
+		Course c = courseRepo.findById(id);
+		if(!(c.getOwner().equals(u) || u.getRole() == Role.Admin)){
+			return new UnauthorizedResponse<>(null);
+		}
+		forumServ.createForum(c, data);
+		return new ResponseEntity<>(HttpStatus.ACCEPTED);
+	}
+
+	//// Endpoints to get and create forum's topic
+
+	@GetMapping("/forum/{id}")
+	public ResponseEntity<List<Topic>> getTopicsFromForumId(@RequestHeader("Authorization") String token, @PathVariable long id){
+		User u = authServ.getUserFromToken(token);
+		if(u == null){
+			return new UnauthorizedResponse<>(null);
+		}
+		return new ResponseEntity<>(forumRepo.findById(id).orElse(null).getTopics(), HttpStatus.OK);
+	}
+
+	@PostMapping("/forum/{id}")
+	public ResponseEntity<Topic> postTopicToForum(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody Topic data){
+		User u = authServ.getUserFromToken(token);
+		Forum f = forumRepo.findById(id).orElse(null);
+		if(!(f.getWriters().contains(u) || f.getCourse().getOwner().equals(u) || u.getRole() == Role.Admin)){
+			return new UnauthorizedResponse<>(null);
+		}
+		forumServ.createTopic(f, data);
+		return new ResponseEntity<>(HttpStatus.ACCEPTED);
+	}
+
+	//// Endpoints related to topics and messages
+	
+	@GetMapping("/forum/post/{id}")
+	public ResponseEntity<Topic> getPost(@RequestHeader("Authorization") String token, @PathVariable long id){
+		User u = authServ.getUserFromToken(token);
+		if(u == null){
+			return new UnauthorizedResponse<>(null);
+		}
+		Topic t = topicRepo.findById(id).orElse(null);
+		return new ResponseEntity<>(t, HttpStatus.OK);
+	}
+
+	@PostMapping("/forum/post/{id}")
+	public ResponseEntity<Topic> postTopicToForum(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody Answer data){
+		User u = authServ.getUserFromToken(token);
+		Topic t = topicRepo.findById(id).orElse(null);
+		if(t.isLocked() && u.getRole() != Role.Admin){
+			return new UnauthorizedResponse<>(null);
+		}
+		System.out.println(data);
+		forumServ.answerTopic(t, data, u);
+		return new ResponseEntity<>(HttpStatus.ACCEPTED);
+	}
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/Msg/MessagesController.java

@@ -0,0 +1,126 @@
+package ovh.herisson.Clyde.EndPoints.Msg;
+
+/******************************************************
+ * @file MessagesController.java
+ * @author Anthony Debucquoy
+ * @scope Extension messagerie
+ *
+ * Entry point for the messages application
+ ******************************************************/
+
+import org.springframework.beans.factory.annotation.Autowired;
+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.PatchMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RestController;
+
+import lombok.AllArgsConstructor;
+import ovh.herisson.Clyde.DTO.Msg.DiscussionDTO;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Repositories.Msg.DiscussionRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.UserService;
+import ovh.herisson.Clyde.Services.Msg.DiscussionService;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Msg.Discussion;
+import ovh.herisson.Clyde.Tables.Msg.Message;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+@AllArgsConstructor
+public class MessagesController {
+
+	private AuthenticatorService authServ;
+	private DiscussionService discServ;
+	private DiscussionRepository discRepo;
+	private UserService userServ;
+
+	@GetMapping("/discussions")
+	public ResponseEntity<Iterable<Discussion>> getDiscussions(@RequestHeader("Authorization") String token ){
+		User user = authServ.getUserFromToken(token);
+		if(user == null){
+			return new UnauthorizedResponse<>(null);
+		}
+
+		Iterable<Discussion> mock = discServ.getOwned(authServ.getUserFromToken(token));
+
+		return new ResponseEntity<>(mock, HttpStatus.OK); 
+	} 
+
+	@GetMapping("/discussion/{id}")
+	public ResponseEntity<DiscussionDTO> getDiscussion(@RequestHeader("Authorization") String token, @PathVariable long id){
+		User user = authServ.getUserFromToken(token);
+		if(user == null || !discServ.hasDiscussion(user, id) ){
+			return new UnauthorizedResponse<>(null);
+		}
+		return new ResponseEntity<>(DiscussionDTO.construct(discRepo.findById(id).orElse(null), authServ.getUserFromToken(token)), HttpStatus.OK);
+	} 
+
+	@PatchMapping("/discussion/{id}")
+	public ResponseEntity<Discussion> AlterDiscussion(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody Discussion data){
+		User user = authServ.getUserFromToken(token);
+		if(user == null){
+			return new UnauthorizedResponse<>(null);
+		}
+
+		Discussion disc = discRepo.findById(id).orElse(null);
+		disc.setName(data.getName());
+		discRepo.save(disc);
+		return new ResponseEntity<>(disc, HttpStatus.OK);
+	}
+
+	@PatchMapping("/discussion/{id}/add")
+	public ResponseEntity<Discussion> invite(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody User data){
+		User user = authServ.getUserFromToken(token);
+		if(user == null){
+			return new UnauthorizedResponse<>(null);
+		}
+
+		Discussion disc = discRepo.findById(id).orElse(null);
+		User invited = userServ.getUserById(data.getRegNo());
+		disc.addMember(invited);
+		discRepo.save(disc);
+		return new ResponseEntity<>(disc, HttpStatus.OK);
+	}
+
+	@PatchMapping("/discussion/{id}/remove")
+	public ResponseEntity<Discussion> removeMember(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody User data){
+		User user = authServ.getUserFromToken(token);
+		if(user == null){
+			return new UnauthorizedResponse<>(null);
+		}
+
+		Discussion disc = discRepo.findById(id).orElse(null);
+		User member = userServ.getUserById(data.getRegNo());
+		disc.delMember(member);
+		discRepo.save(disc);
+		return new ResponseEntity<>(disc, HttpStatus.OK);
+	}
+
+	@PostMapping("/discussion/{id}")
+	public ResponseEntity<Discussion> sendMessage(@RequestHeader("Authorization") String token, @PathVariable long id, @RequestBody Message msg){
+		User user = authServ.getUserFromToken(token);
+		if(user == null){
+			return new UnauthorizedResponse<>(null);
+		}
+
+		Discussion disc = discRepo.findById(id).orElse(null);
+		msg.setAuthor(user);
+		if(disc != null)
+			discServ.CreateMessage(disc, msg);
+		return new ResponseEntity<>(disc, HttpStatus.OK);
+	}
+
+
+	@PostMapping("/discussion")
+	public ResponseEntity<Discussion> createDiscussion(@RequestHeader("Authorization") String token, @RequestBody Discussion data){
+		return new ResponseEntity<>(discServ.create(data.getName(), authServ.getUserFromToken(token)), HttpStatus.OK);
+	}
+}

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

@@ -0,0 +1,61 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+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.PostMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+import lombok.AllArgsConstructor;
+import ovh.herisson.Clyde.Repositories.NotificationRepository;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Tables.Notification;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Notification.Status;
+
+@RestController
+@AllArgsConstructor
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class NotificationController {
+
+	private AuthenticatorService authServ;
+	private NotificationRepository notifRepo;
+
+	@GetMapping("/notifications")
+	public ResponseEntity<List<Notification>> getNotifications(@RequestHeader("Authorization") String token){
+		User u = authServ.getUserFromToken(token);
+		if(u == null){
+            return new UnauthorizedResponse<>(null);
+		}
+		ArrayList<Notification> ret = new ArrayList<>();
+		for (Notification n : u.getNotifications()) {
+			if(!n.getStatus().equals(Status.Archived)){
+				ret.add(n);
+			}
+		}
+		return new ResponseEntity<>(ret, HttpStatus.OK);
+
+	}
+
+	@PostMapping("/notifications/{id}")
+	public ResponseEntity<Notification> archiveNotification(@RequestHeader("Authorization") String token, @PathVariable long id){
+		User u = authServ.getUserFromToken(token);
+		Notification n = notifRepo.findById(id).orElse(null);
+		if(u == null || n.getUser() != u){
+            return new UnauthorizedResponse<>(null);
+		}
+
+		n.setStatus(Status.Archived);
+		notifRepo.save(n);
+		return new ResponseEntity<>(HttpStatus.OK);
+	}
+}

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

@@ -0,0 +1,20 @@
+package ovh.herisson.Clyde.EndPoints;
+
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.RestController;
+
+import ovh.herisson.Clyde.Responses.PingResponse;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class PingController {
+
+	@GetMapping("/ping")
+	public PingResponse ping(){
+		return new PingResponse(1, "pong");
+	}
+	
+}
+
+

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

@@ -0,0 +1,116 @@
+package ovh.herisson.Clyde.EndPoints;
+
+/******************************************************
+ * @file ScheduleController.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ *
+ * Controller of Schedule API
+ ******************************************************/
+
+
+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.ScheduleLessonService;
+import ovh.herisson.Clyde.Services.ScheduleService;
+import ovh.herisson.Clyde.Services.UserCurriculumService;
+import ovh.herisson.Clyde.Services.CurriculumService;
+import ovh.herisson.Clyde.Tables.*;
+import ovh.herisson.Clyde.Services.LessonService;
+
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+public class ScheduleController {
+
+    private final ScheduleService scheduleServ;
+    private final LessonService lessonServ;
+
+    private final CurriculumService curriculumServ;
+    private final AuthenticatorService authServ;
+
+    private final ScheduleLessonService scheduleLessonServ;
+
+    public ScheduleController(ScheduleService scheduleServ, AuthenticatorService authServ, ScheduleLessonService scheduleLessonServ, CurriculumService curriculumServ,LessonService lessonServ) {
+        this.scheduleServ = scheduleServ;
+        this.authServ = authServ;
+        this.scheduleLessonServ = scheduleLessonServ;
+        this.curriculumServ = curriculumServ;
+        this.lessonServ  = lessonServ;
+    }
+    /**
+     * Return schedule via its id
+     */
+    @GetMapping("/schedule/{id}")
+    public ResponseEntity<Map<String,Object>> findById(@PathVariable long id){
+        Schedule schedule = scheduleServ.findById(id);
+
+        if(schedule == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+        return new ResponseEntity<>(scheduleLessonServ.getDepthScheduleBySchedule(schedule),HttpStatus.OK);
+    }
+
+    /**
+     *  Return a schedule via its curriculum id
+     */
+    @GetMapping("/schedule/curriculum/{id}")
+    public ResponseEntity<Map<String, Object>> findCurriculumSchedule(@PathVariable Long id){
+      Schedule schedule = scheduleLessonServ.getScheduleByCurriculum(curriculumServ.findById(id));
+      if(schedule == null)
+        return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+      return new ResponseEntity<>(scheduleLessonServ.getDepthScheduleBySchedule(schedule),HttpStatus.OK);
+  }
+    /**
+     * Return all schedules
+     */
+    @GetMapping("/schedules")
+    public ResponseEntity<Iterable<Map<String , Object>>> findAllSchedule(){
+        return new ResponseEntity<>(scheduleLessonServ.getAllSchedule(),HttpStatus.OK);
+    }
+    /**
+     *  Post a new schedule
+     */
+    @PostMapping("/schedule")
+    public ResponseEntity<Schedule> postSchedule(@RequestHeader("Authorization") String token,
+                                                 @RequestBody Schedule schedule){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+        return new ResponseEntity<>(scheduleServ.save(schedule),HttpStatus.OK);
+    }
+    /**
+     *  Post a lesson to a schedule
+     */
+    @PostMapping("/schedule/{id}")
+    public ResponseEntity<String> postLessonToSchedule(@RequestHeader("Authorization") String token,
+                                                          @RequestBody Long lessonId,
+                                                          @PathVariable long id)
+    {
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+
+        if (!scheduleLessonServ.save(new ScheduleLesson( scheduleServ.findById(id), lessonServ.findById(lessonId))))
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+    /**
+     * Delete a lesson from a schedule
+     */
+    @DeleteMapping("/schedule/lesson/{id}")
+    public ResponseEntity<String> deleteLessonFromSchedule(@RequestHeader("Authorization") String token,
+                                                          @RequestBody Long lessonId,
+                                                          @PathVariable Long id)
+    {
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+            return new UnauthorizedResponse<>(null);
+        if (!scheduleLessonServ.delete(lessonId))
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/ScientificPublications/ResearchController.java

@@ -0,0 +1,167 @@
+package ovh.herisson.Clyde.EndPoints.ScientificPublications;
+
+/******************************************************
+ * @file ResearchController.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * API class for the researches
+ ******************************************************/
+
+import lombok.AllArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.DTO.ScientificPublications.ResearchDTO;
+import ovh.herisson.Clyde.DTO.ScientificPublications.ResearcherDTO;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.ScientificPublications.ResearchesService;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+@AllArgsConstructor
+public class ResearchController {
+
+
+
+   private final ResearchesService researchesServ;
+
+   private final AuthenticatorService authServ;
+
+    /** Is accessible by anyone
+     * but if the user doesn't have the permission to download the research
+     * the return Research Download URL will be null
+     */
+    @GetMapping("/research/{id}")
+    public ResponseEntity<ResearchDTO> getResearch(@RequestHeader(value = "Authorization", required = false) String token, @PathVariable long id){
+
+        Research research = researchesServ.getResearchById(id);
+
+        if (research == null)
+            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+
+        if (researchesServ.hasNoAccessTo(research,authServ.getUserFromToken(token))){
+           research.setPdfLocation(null);
+        }// If the user doesn't have access to the document he can't download the pdf
+
+        return new ResponseEntity<>(ResearchDTO.construct(research), HttpStatus.OK);
+    }
+
+    /**
+     * @param token  used to know if the user can download or not the research pdf
+     * @return every research
+     */
+    @GetMapping("/researches")
+    public ResponseEntity<Iterable<ResearchDTO>> getResearches(@RequestHeader(value = "Authorization",required = false) String token){
+        Iterable<Research> researches = researchesServ.getAllResearches();
+
+        ArrayList<ResearchDTO> toReturnResearches = new ArrayList<>();
+
+        for (Research research: researches){
+            if (researchesServ.hasNoAccessTo(research,authServ.getUserFromToken(token))){
+                research.setPdfLocation(null);
+            }
+            toReturnResearches.add(ResearchDTO.construct(research));
+        }
+        return new ResponseEntity<>(toReturnResearches,HttpStatus.OK);
+    }
+
+
+    @GetMapping("/researches/{id}")
+    public ResponseEntity<Iterable<ResearchDTO>> getResearchesFromResearcher(@RequestHeader(value = "Authorization",required = false) String token,
+                                                                             @PathVariable Long id
+    ){
+        Iterable<Research> researches = researchesServ.getResearchesByAuthor(id);
+        if (researches == null) return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+
+        ArrayList<ResearchDTO> toReturnResearches = new ArrayList<>();
+
+        for (Research research: researches){
+            if (researchesServ.hasNoAccessTo(research,authServ.getUserFromToken(token))){
+                research.setPdfLocation(null);
+            }
+            toReturnResearches.add(ResearchDTO.construct(research));
+        }
+        return new ResponseEntity<>(toReturnResearches,HttpStatus.OK);
+    }
+
+    /** post a new research
+     *
+     * @return the research saved
+     */
+    @PostMapping("/research")
+    public ResponseEntity<Research> postResearch(@RequestHeader("Authorization") String token, @RequestBody Research research){
+
+        if (authServ.isNotIn(new Role[]{Role.Admin},token) &&
+                researchesServ.getResearcherByUser(authServ.getUserFromToken(token)) == null){
+            return new UnauthorizedResponse<>(null);
+        } // if the poster isn't a researcher
+
+        return new ResponseEntity<>(researchesServ.saveResearch(research), HttpStatus.OK);
+    }
+
+    /** post updates to the research
+     * in the updates, the coAuthors have to be referenced by their ids
+     *
+     */
+    @PatchMapping("/research/{id}")
+    public ResponseEntity<String> patchResearch(@RequestHeader("Authorization") String token,
+                                          @RequestBody Map<String,Object> updates,
+                                          @PathVariable long id
+                                          )
+    {
+        Research research = researchesServ.getResearchById(id);
+        Researcher researcher = researchesServ.getResearcherByUser(authServ.getUserFromToken(token));
+
+        if (research == null)
+            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
+
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token) &&
+                researcher != research.getAuthor()) {
+            return new UnauthorizedResponse<>(null);
+        }
+
+      researchesServ.modifyResearchData(research, updates);
+      return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    /** Only Admin, Secretary and author can delete a research
+     *
+     */
+    @DeleteMapping("/research/{id}")
+    public ResponseEntity<String> deleteResearch(@RequestHeader("Authorization") String token, @PathVariable long id){
+
+        Research research = researchesServ.getResearchById(id);
+        Researcher researcher = researchesServ.getResearcherByUser(authServ.getUserFromToken(token));
+
+        if (research == null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        if (authServ.isNotIn(new Role[]{Role.Admin, Role.Secretary},token) &&
+                researcher != research.getAuthor()){
+            return new UnauthorizedResponse<>(null);
+        }
+
+        researchesServ.deleteResearch(research);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    ///////
+    //views part
+    @PostMapping("/addview/cdn/{url}")
+    public ResponseEntity<ResearchDTO> addView(@PathVariable String url){
+        System.out.println(url);
+        Research research = researchesServ.getResearchByUrl("cdn/" + url);
+        if (research ==null) return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ResearchDTO.construct(researchesServ.addView(research)), HttpStatus.OK);
+    }
+
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/ScientificPublications/ResearcherController.java

@@ -0,0 +1,102 @@
+package ovh.herisson.Clyde.EndPoints.ScientificPublications;
+
+/******************************************************
+ * @file ResearcherController.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * API class for the researchers
+ ******************************************************/
+import lombok.AllArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.DTO.ScientificPublications.ResearcherDTO;
+import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
+import ovh.herisson.Clyde.Services.AuthenticatorService;
+import ovh.herisson.Clyde.Services.ScientificPublications.ResearchesService;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+@AllArgsConstructor
+public class ResearcherController {
+
+    ResearchesService researchesServ;
+    AuthenticatorService authServ;
+
+
+    @GetMapping("/researcher/{id}")
+    public ResponseEntity<ResearcherDTO> getResearcher(@PathVariable long id){
+        Researcher researcher = researchesServ.getResearcherById(id);
+        return new ResponseEntity<>(ResearcherDTO.construct(researcher),HttpStatus.OK);
+    }
+
+    /**
+     * Everyone can access every researcher Account
+     * @return all the researchers accounts
+     */
+    @GetMapping("/researchers")
+    public ResponseEntity<Iterable<ResearcherDTO>> getAllResearchers(){
+        Iterable<Researcher> researchers = researchesServ.getAllResearchers();
+        ArrayList<ResearcherDTO> toReturnResearchersDTO = new ArrayList<>();
+        for (Researcher researcher: researchers){
+            toReturnResearchersDTO.add(ResearcherDTO.construct(researcher));
+        }
+        return new ResponseEntity<>(toReturnResearchersDTO, HttpStatus.OK);
+    }
+
+    @GetMapping("/researcher")
+    public ResponseEntity<ResearcherDTO> getSelf(@RequestHeader("Authorization") String token){
+
+        Researcher self = researchesServ.getResearcherByUser(authServ.getUserFromToken(token));
+
+        if (self ==null) return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ResearcherDTO.construct(self), HttpStatus.OK);
+    }
+
+    @PostMapping("/researcher")
+    public ResponseEntity<ResearcherDTO> postResearcher(@RequestHeader("Authorization") String token, @RequestBody Researcher researcher){
+        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary}, token)){
+            return new UnauthorizedResponse<>(null);
+        }
+
+        Researcher posted = researchesServ.saveResearcher(researcher);
+
+        if (posted == null) return new ResponseEntity<>(null, HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ResearcherDTO.construct(posted), HttpStatus.CREATED);
+    }
+
+    @PatchMapping("/researcher/{id}")
+    public ResponseEntity<ResearcherDTO> patchResearcher(@RequestHeader("Authorization") String token,
+                                                         @PathVariable long id,
+                                                         @RequestBody Map<String ,Object> updates){
+
+        Researcher researcher = researchesServ.getResearcherById(id);
+        if (authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin}, token)
+                && researcher.getId() != researchesServ.getResearcherByUser(authServ.getUserFromToken(token)).getId())
+            return new UnauthorizedResponse<>(null);
+
+
+        if (researcher == null) return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        researchesServ.modifyResearcherData(researcher,updates);
+
+        return new ResponseEntity<>(ResearcherDTO.construct(researcher),HttpStatus.OK);
+    }
+
+    @DeleteMapping("/researcher/{id}")
+    public ResponseEntity<String> deleteResearcher(@RequestHeader ("Authorization") String token, @PathVariable long id){
+       if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
+           return new UnauthorizedResponse<>(null);
+
+       researchesServ.deleteResearcher(researchesServ.getResearcherById(id));
+       return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/EndPoints/ScientificPublications/StatController.java

@@ -0,0 +1,47 @@
+package ovh.herisson.Clyde.EndPoints.ScientificPublications;
+
+/******************************************************
+ * @file StatController.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Api class for handling statistics
+ ******************************************************/
+import lombok.AllArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+import ovh.herisson.Clyde.Services.ScientificPublications.ResearchesService;
+import ovh.herisson.Clyde.Services.ScientificPublications.StatisticsService;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.Map;
+
+@RestController
+@CrossOrigin(originPatterns = "*", allowCredentials = "true")
+@AllArgsConstructor
+public class StatController {
+
+
+    private StatisticsService statServ;
+    private ResearchesService researchesServ;
+
+    /** returns all the statistics in a 2D array
+     *
+     * @param id the researcher's id
+     * @return all the stats in a 2D array
+     */
+    @GetMapping("/stats/{id}")
+    public ResponseEntity<Iterable<Iterable<Map<String, Integer>>>> getStat(@PathVariable Long id){
+
+        Researcher researcher = researchesServ.getResearcherById(id);
+        if (researcher == null) return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        Iterable<Iterable<Map<String,Integer>>> stats = statServ.generateStats(researcher);
+
+        if (stats == null) return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(stats,HttpStatus.OK);
+
+    }
+}

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

@@ -0,0 +1,137 @@
+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(originPatterns = "*", allowCredentials = "true")
+public class UserController {
+
+    private final UserService userService;
+    private final AuthenticatorService authServ;
+    public UserController(UserService userService, AuthenticatorService authServ){
+        this.userService = userService;
+        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<HashMap<String,Object>> getUser(@RequestHeader("Authorization") String token){
+
+        User user = authServ.getUserFromToken(token);
+            if (user == null) return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.userWithoutPassword(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, Role.Teacher},token))
+            return new UnauthorizedResponse<>(null);
+
+        return new ResponseEntity<>(ProtectionService.userWithoutPassword(userService.getUserById(id)), HttpStatus.OK);
+    }
+
+    @PostMapping("/user")
+    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 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<Map<String,Object>> 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<>(null);}
+
+        User modified = userService.modifyData(id,updates,poster);
+        if (modified ==null)
+            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+
+        return new ResponseEntity<>(ProtectionService.userWithoutPassword(modified), HttpStatus.OK);
+    }
+
+    @GetMapping("/teachers")
+    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllTeachers(@RequestHeader("Authorization") String token){
+        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/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,27 @@
+package ovh.herisson.Clyde.Repositories;
+
+import jakarta.transaction.Transactional;
+import org.springframework.data.jpa.repository.Modifying;
+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 where cc.course = ?1")
+    Iterable<Curriculum> findCurriculumByCourses(Course course);
+
+    @Query("select distinct cc.curriculum from  CurriculumCourse cc")
+    Iterable<Curriculum> findDistinctCurriculums();
+
+    @Modifying
+    @Transactional
+    @Query("delete from CurriculumCourse cc where cc.course =?1")
+    void delete(Course course);
+
+}

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/Inscription/ChangeCurriculumRequestRepository.java

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

backend/src/main/java/ovh/herisson/Clyde/Repositories/Inscription/ExemptionsRequestRepository.java

@@ -0,0 +1,13 @@
+package ovh.herisson.Clyde.Repositories.Inscription;
+
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Inscription.ExemptionsRequest;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+
+public interface ExemptionsRequestRepository extends CrudRepository<ExemptionsRequest, Long> {
+    ExemptionsRequest findById(long id);
+
+    ArrayList<ExemptionsRequest> findByUser(User user);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Inscription/ExternalCurriculumRepository.java

@@ -0,0 +1,15 @@
+package ovh.herisson.Clyde.Repositories.Inscription;
+
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Inscription.ExternalCurriculum;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.ArrayList;
+
+public interface ExternalCurriculumRepository extends CrudRepository<ExternalCurriculum, Long> {
+    ArrayList<ExternalCurriculum> getExternalCurriculumByInscriptionRequest(InscriptionRequest ir);
+
+    ArrayList<ExternalCurriculum> getExternalCurriculumByUser(User user);
+    ExternalCurriculum getExternalCurriculumById(long id);
+}

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

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

backend/src/main/java/ovh/herisson/Clyde/Repositories/Inscription/MinervalRepository.java

@@ -0,0 +1,12 @@
+package ovh.herisson.Clyde.Repositories.Inscription;
+
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Inscription.Minerval;
+
+import java.util.ArrayList;
+
+public interface MinervalRepository extends CrudRepository<Minerval, Long> {
+    public ArrayList<Minerval> getMinervalsByStudentRegNoOrderByYearDesc(Long studentRegNo);
+
+    public Minerval findById(long id);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Inscription/PaymentRepository.java

@@ -0,0 +1,10 @@
+package ovh.herisson.Clyde.Repositories.Inscription;
+
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Inscription.Payment;
+
+import java.util.ArrayList;
+
+public interface PaymentRepository extends CrudRepository<Payment, Long> {
+    public ArrayList<Payment> getPaymentsByStudentRegNo(long regNo);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Inscription/ScholarshipRequestRepository.java

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

backend/src/main/java/ovh/herisson/Clyde/Repositories/Inscription/UnregisterRequestRepository.java

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

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

@@ -0,0 +1,23 @@
+package ovh.herisson.Clyde.Repositories;
+
+/******************************************************
+ * @file LessonChangesRequestRepository.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.LessonChangesRequest;
+import ovh.herisson.Clyde.Tables.User;
+
+public interface LessonChangesRequestRepository extends CrudRepository<LessonChangesRequest, Long> {
+    LessonChangesRequest findById(long id);
+    
+
+    @Query("select lr from LessonChangesRequest lr where lr.user = ?1")
+    Iterable<LessonChangesRequest> findOwnRequests(User user);
+
+    @Query("select lr from LessonChangesRequest lr where lr.lessonId = ?1")
+    Iterable<LessonChangesRequest> findRequestByLessonId(long id);
+}

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

@@ -0,0 +1,20 @@
+package ovh.herisson.Clyde.Repositories;
+
+/******************************************************
+ * @file LessonRepository.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Lesson;
+
+public interface LessonRepository extends CrudRepository<Lesson, Long> {
+
+    Lesson findById(long id);
+
+    @Query("select l from Lesson l where l.course = ?1")
+    Iterable<Lesson> findLessonByCourse(Course course);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Msg/AnswerRepository.java

@@ -0,0 +1,10 @@
+package ovh.herisson.Clyde.Repositories.Msg;
+
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.Msg.Answer;
+
+public interface AnswerRepository extends CrudRepository<Answer, Long> {
+
+}
+

backend/src/main/java/ovh/herisson/Clyde/Repositories/Msg/DiscussionRepository.java

@@ -0,0 +1,23 @@
+package ovh.herisson.Clyde.Repositories.Msg;
+
+/******************************************************
+ * @file DiscussionRepository.java
+ * @author Anthony Debucquoy
+ * @scope Extension messagerie
+ *
+ * Repository of Discussion allowing to fetch discussion by user 
+ ******************************************************/
+
+
+import java.util.List;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.Msg.Discussion;
+
+public interface DiscussionRepository extends CrudRepository<Discussion, Long>{
+
+	@Query("SELECT d FROM Discussion d INNER JOIN FETCH d.members dm WHERE dm.id = ?1")
+	List<Discussion> findByMembership(long userid);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Msg/ForumRepository.java

@@ -0,0 +1,9 @@
+package ovh.herisson.Clyde.Repositories.Msg;
+
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.Msg.Forum;
+
+public interface ForumRepository extends CrudRepository<Forum, Long> {
+	
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Msg/MessageRepository.java

@@ -0,0 +1,14 @@
+package ovh.herisson.Clyde.Repositories.Msg;
+
+/******************************************************
+ * @file MessageRepository.java
+ * @author Anthony Debucquoy
+ * @scope Extension messagerie
+ ******************************************************/
+
+
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.Msg.Message;
+
+public interface MessageRepository extends CrudRepository<Message, Long> {}

backend/src/main/java/ovh/herisson/Clyde/Repositories/Msg/TopicRepository.java

@@ -0,0 +1,10 @@
+package ovh.herisson.Clyde.Repositories.Msg;
+
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.Msg.Topic;
+
+public interface TopicRepository extends CrudRepository<Topic, Long> {
+
+}
+

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

@@ -0,0 +1,8 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.repository.CrudRepository;
+
+import ovh.herisson.Clyde.Tables.Notification;
+
+public interface NotificationRepository extends CrudRepository<Notification, Long> {}
+

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

@@ -0,0 +1,33 @@
+package ovh.herisson.Clyde.Repositories;
+
+/******************************************************
+ * @file ScheduleLessonRepository.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+import jakarta.transaction.Transactional;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Curriculum;
+import ovh.herisson.Clyde.Tables.Lesson;
+import ovh.herisson.Clyde.Tables.Schedule;
+import ovh.herisson.Clyde.Tables.ScheduleLesson;
+
+public interface ScheduleLessonRepository extends CrudRepository<ScheduleLesson,Long> {
+
+    @Query("select distinct sl.lesson from ScheduleLesson sl where sl.schedule.curriculum = ?1")
+    Iterable<Lesson> findLessonByCurriculum(Curriculum curriculum);
+
+    @Query("select distinct sl.schedule from ScheduleLesson sl where sl.schedule.curriculum = ?1")
+    Schedule findScheduleByCurriculum(Curriculum curriculum);
+
+    @Query("select distinct sl from ScheduleLesson sl where sl.lesson = ?1")
+    ScheduleLesson findByLesson(Lesson lesson);
+
+    @Modifying
+    @Transactional
+    @Query("delete from ScheduleLesson sl where sl.lesson =?1")
+    void delete(Lesson lesson);
+
+}

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

@@ -0,0 +1,22 @@
+package ovh.herisson.Clyde.Repositories;
+
+/******************************************************
+ * @file ScheduleRepository.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Lesson;
+import ovh.herisson.Clyde.Tables.Schedule;
+
+public interface ScheduleRepository extends CrudRepository<Schedule,Long> {
+
+    Schedule getById(long id);
+
+
+    @Query("select distinct sl from Schedule sl where EXISTS (select c.curriculum from CurriculumCourse c where (sl.curriculum = c.curriculum) AND (c.course = ?1))")
+    Iterable<Schedule> findAllLessonSchedule(Course course);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/ScientificPublications/ResearchRepository.java

@@ -0,0 +1,26 @@
+package ovh.herisson.Clyde.Repositories.ScientificPublications;
+
+/******************************************************
+ * @file ResearchRepository.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Repository handling communication with Reseach table
+ ******************************************************/
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.Map;
+
+public interface ResearchRepository extends CrudRepository<Research,Long> {
+
+    Research findById(long id);
+
+    Iterable<Research> findByAuthor(Researcher author);
+
+    @Query("select r from Research r where r.pdfLocation = ?1")
+    Research findByPdfLocation(String url);
+
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/ScientificPublications/ResearcherRepository.java

@@ -0,0 +1,23 @@
+package ovh.herisson.Clyde.Repositories.ScientificPublications;
+
+/******************************************************
+ * @file ResearcherRepository.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Repository handling communication with Reseacher table
+ ******************************************************/
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+import ovh.herisson.Clyde.Tables.User;
+
+public interface ResearcherRepository extends CrudRepository<Researcher,Long> {
+    Researcher findByUser(User user);
+
+    Researcher findById(long id);
+
+    @Query("select r from Research r where r.author = ?1")
+    Iterable<Research> findAllByAuthorId(Researcher author);
+}

backend/src/main/java/ovh/herisson/Clyde/Repositories/ScientificPublications/StatsRepository.java

@@ -0,0 +1,47 @@
+package ovh.herisson.Clyde.Repositories.ScientificPublications;
+
+/******************************************************
+ * @file StatsRepository.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Repository handling communication with Reseach table for making statistics
+ ******************************************************/
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+
+import java.util.Map;
+
+public interface StatsRepository extends CrudRepository<Research,Long> {
+
+    @Query("select new map(to_char(r.releaseDate, 'month') as label, sum(r.views) as y) from Research r group by to_char(r.releaseDate, 'month')")
+    Iterable<Map<String ,Integer>> viewsByMonths();
+
+    @Query("select new map(to_char(r.releaseDate,'YYYY') as label, sum  (r.views) as y) from Research r group by to_char(r.releaseDate,'YYYY')")
+    Iterable<Map<String ,Integer>> viewsByYears();
+
+
+    @Query("select new map(r.domain as label, sum(r.views) as y) from Research r group by r.domain")
+    Iterable<Map<String ,Integer>> viewsByTopics();
+
+
+    @Query("select new map(r.domain as label, count(distinct r.language) as y) from Research r group by r.domain")
+    Iterable<Map<String ,Integer>> languageByTopics();
+
+    @Query("select new map(to_char(r.releaseDate,'YYYY') as label,  count(distinct r.language) as y) from Research r group by to_char(r.releaseDate,'YYYY')")
+    Iterable<Map<String ,Integer>> languageByYears();
+
+    @Query("select new map(to_char(r.releaseDate, 'month') as label, count(distinct r.language) as y) from Research r group by to_char(r.releaseDate, 'month')")
+    Iterable<Map<String ,Integer>> languageByMonths();
+
+    @Query("select new map(to_char(r.releaseDate,'YYYY') as label, count(distinct r) as y) from Research r group by to_char(r.releaseDate,'YYYY')")
+    Iterable<Map<String ,Integer>> researchesByYears();
+
+    @Query("select new map(r.domain as label, count(distinct r) as y) from Research r group by r.domain")
+    Iterable<Map<String ,Integer>> researchesByTopics();
+
+    @Query("select new map(to_char(r.releaseDate, 'month') as label, count(distinct r) as y) from Research r group by to_char(r.releaseDate, 'month')")
+    Iterable<Map<String ,Integer>> researchesByMonth();
+
+}

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

@@ -0,0 +1,14 @@
+package ovh.herisson.Clyde.Repositories;
+
+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);
+
+    ArrayList <Token> getByUserOrderByExpirationDate(User user);
+}

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

@@ -0,0 +1,23 @@
+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;
+
+import java.util.ArrayList;
+
+public interface UserCurriculumRepository extends CrudRepository<UserCurriculum, Long> {
+
+    @Query("select uc.curriculum from UserCurriculum uc where uc.user = ?1")
+    Curriculum findByUser(User student);
+
+    @Query("select distinct uc.user from UserCurriculum uc where uc.curriculum = ?1")
+   Iterable<User> findUsersByCurriculum(Curriculum curriculum);
+
+    ArrayList<UserCurriculum> findByUserOrderByCurriculum(User student);
+    UserCurriculum findByUserAndCurriculumAndActual(User user, Curriculum curriculum, boolean actual);
+
+    ArrayList<UserCurriculum> findByUserAndActual(User user, boolean actual);
+}

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

@@ -0,0 +1,23 @@
+package ovh.herisson.Clyde.Repositories;
+
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import ovh.herisson.Clyde.Tables.User;
+
+public interface UserRepository extends CrudRepository<User, Long> {
+
+    User findById(long id);
+
+    User findByEmail(String email);
+
+
+
+    @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/Responses/PingResponse.java

@@ -0,0 +1,3 @@
+package ovh.herisson.Clyde.Responses;
+
+public record PingResponse(int id, String txt){};

backend/src/main/java/ovh/herisson/Clyde/Responses/UnauthorizedResponse.java

@@ -0,0 +1,12 @@
+package ovh.herisson.Clyde.Responses;
+
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+
+public class UnauthorizedResponse<T> extends ResponseEntity<T> {
+    public UnauthorizedResponse(T message) {
+        super(message,HttpStatus.UNAUTHORIZED);
+    }
+}

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

@@ -0,0 +1,55 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Services.Inscription.InscriptionService;
+import ovh.herisson.Clyde.Tables.*;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+
+import java.util.Date;
+
+@Service
+public class AuthenticatorService {
+
+    private final TokenService tokenService;
+    private final UserService userService;
+    private final InscriptionService inscriptionService;
+
+    public AuthenticatorService(TokenService tokenService, UserService userService, InscriptionService inscriptionService){
+        this.tokenService = tokenService;
+        this.userService = userService;
+        this.inscriptionService = inscriptionService;
+    }
+
+    public User getUserFromToken(String token){
+        return tokenService.getUserFromToken(token);
+    }
+
+    public String login(String identifier, String password, Date expirationDate){
+        User user = userService.getUser(identifier);
+        if (user == null){return null;}
+        if (!userService.checkPassword(user,password)){return null;}
+        String token = tokenService.generateNewToken();
+        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,97 @@
+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());
+        toReturn.put("requireCertificate", curriculum.isRequireCertificate());
+
+        return  toReturn;
+    }
+
+    public Iterable<Curriculum> findCurriculumByCourses(Course course){
+        return curriculumCourseRepo.findCurriculumByCourses(course);
+    }
+
+    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,24 @@
+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/Inscription/InscriptionService.java

@@ -0,0 +1,113 @@
+package ovh.herisson.Clyde.Services.Inscription;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.*;
+import ovh.herisson.Clyde.Repositories.Inscription.ExternalCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.InscriptionRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.MinervalRepository;
+import ovh.herisson.Clyde.Services.UserService;
+import ovh.herisson.Clyde.Tables.*;
+import ovh.herisson.Clyde.Tables.Inscription.ExternalCurriculum;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+import ovh.herisson.Clyde.Tables.Inscription.Minerval;
+
+import java.util.ArrayList;
+import java.util.Calendar;
+
+@Service
+public class InscriptionService {
+
+    private final InscriptionRepository inscriptionRepo;
+
+    private final UserRepository userRepo;
+
+    private final UserCurriculumRepository userCurriculumRepo;
+
+    private final CurriculumRepository curriculumRepo;
+
+    private final MinervalRepository minervalRepository;
+    private final ExternalCurriculumRepository externalCurriculumRepository;
+    private final UserService userService;
+
+    public InscriptionService(InscriptionRepository inscriptionRepo, UserRepository userRepo, UserCurriculumRepository userCurriculumRepo, CurriculumRepository curriculumRepo, MinervalRepository minervalRepository, ExternalCurriculumRepository externalCurriculumRepository, UserService userService){
+        this.inscriptionRepo = inscriptionRepo;
+        this.userRepo = userRepo;
+        this.userCurriculumRepo = userCurriculumRepo;
+        this.curriculumRepo = curriculumRepo;
+        this.minervalRepository = minervalRepository;
+        this.externalCurriculumRepository = externalCurriculumRepository;
+        this.userService = userService;
+    }
+
+    public InscriptionRequest save(InscriptionRequest inscriptionRequest){
+        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 the request is already accepted we just return ok (otherwise we would duplicate the procedure below)
+        if (inscrRequest.getState() == RequestState.Accepted){
+            return true;
+        }
+
+        inscrRequest.setState(requestState);
+        save(inscrRequest);
+
+        //saves the user from the request if accepted from teacher and inscription services
+        if (requestState == RequestState.Accepted && (inscrRequest.getEquivalenceState() == RequestState.Accepted || inscrRequest.getEquivalenceState() == RequestState.Unrequired))
+        {
+            return createUser(inscrRequest);
+        }
+        return true;
+    }
+
+    public boolean createUser(InscriptionRequest inscrRequest){
+        //We must send an email here
+
+        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(),
+                inscrRequest.getIdentityCard()
+        );
+
+        userService.save(userFromRequest);
+        Calendar c = Calendar.getInstance();
+        userCurriculumRepo.save(new UserCurriculum(userFromRequest, curriculumRepo.findById(inscrRequest.getCurriculumId()),c.get(Calendar.YEAR), true));
+
+        //Create a minerval for the new student
+        Minerval minerval = new Minerval(userFromRequest.getRegNo(), 0, 852, 2023);
+        minervalRepository.save(minerval);
+
+        //Assign the externals curriculums from the inscription request to newly created student
+        ArrayList<ExternalCurriculum> extCurrList = externalCurriculumRepository.getExternalCurriculumByInscriptionRequest(inscrRequest);
+        for (int i = 0; i < extCurrList.size(); i++){
+            extCurrList.get(i).setUser(userFromRequest);
+            externalCurriculumRepository.save(extCurrList.get(i));
+        }
+        return true;
+    }
+    public void delete(InscriptionRequest toDelete) {
+        inscriptionRepo.delete(toDelete);
+    }
+}

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

@@ -0,0 +1,177 @@
+package ovh.herisson.Clyde.Services;
+
+/******************************************************
+ * @file LeessonRequestService.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.*;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.Map;
+
+@Service
+public class LessonRequestService {
+    private final LessonChangesRequestRepository lessonChangesRepo;
+
+    private final UserRepository userRepo;
+
+    private final LessonRepository lessonRepo;
+
+    private final LessonService lessonServ;
+
+    private final ScheduleLessonRepository scheduleLessonRepo;
+
+    private final ScheduleRepository scheduleRepository;
+
+    private final ScheduleLessonService scheduleLessonService;
+
+    private final UserService userServ;
+
+    private final CourseRepository courseRepository;
+    public LessonRequestService(LessonChangesRequestRepository lessonChangesRepo,
+                                UserRepository userRepo, LessonRepository lessonRepo,
+                                LessonService lessonServ, ScheduleLessonRepository scheduleLessonRepo,
+                                ScheduleRepository scheduleRepository, ScheduleLessonService scheduleLessonService,
+                                UserService userServ, CourseRepository courseRepository) {
+        this.lessonChangesRepo = lessonChangesRepo;
+        this.userRepo = userRepo;
+        this.lessonRepo = lessonRepo;
+        this.lessonServ = lessonServ;
+        this.scheduleLessonRepo = scheduleLessonRepo;
+        this.scheduleRepository = scheduleRepository;
+        this.scheduleLessonService = scheduleLessonService;
+        this.userServ = userServ;
+        this.courseRepository = courseRepository;
+    }
+
+    /**
+     * Create a new lesson request
+     */
+    public LessonChangesRequest save(LessonChangesRequest lessonRequest){
+        return lessonChangesRepo.save(lessonRequest);
+    }
+
+    /**
+     * Find all the requests made by a user
+     */
+    public Iterable<LessonChangesRequest> findOwnRequests(User user){
+        return lessonChangesRepo.findOwnRequests(user);
+    }
+    public LessonChangesRequest findById(long id){
+        return lessonChangesRepo.findById(id);
+    }
+    /**
+     *  Return all the requests
+     */
+    public Iterable<LessonChangesRequest> getAll(){return lessonChangesRepo.findAll();}
+
+    /**
+     * Create a lesson if a request is accepted
+     */
+    public boolean modifyCreateRequestState(LessonChangesRequest lessonRequest, RequestState state, String local ){
+        if(lessonRequest == null || state == lessonRequest.getState()  || state == null){
+            return false;}
+        if (state == RequestState.Accepted){
+            Course course = courseRepository.findById(lessonRequest.getCourse().getCourseID());
+            if(courseRepository.findById(lessonRequest.getCourse().getCourseID())==null|| local == null){
+                return false;}
+            Lesson lesson = new Lesson();
+            lesson.setCourse(course);
+            lesson.setLessonStart(lessonRequest.getLessonStart());
+            lesson.setLessonEnd(lessonRequest.getLessonEnd());
+            lesson.setColor(lessonRequest.getColor());
+            lesson.setLocal(local);
+            lesson.setLessonType(lessonRequest.getLessonType());
+
+            lesson = lessonRepo.save(lesson);
+            scheduleLessonService.saveToAllSchedule(lesson);
+            }
+        lessonRequest.setState(state);
+        save(lessonRequest);
+        return true;
+    }
+
+    public Iterable<LessonChangesRequest> findRequestByLessonId(long id){
+      return lessonChangesRepo.findRequestByLessonId(id);
+    }
+
+    /**
+     *  Refuse all the lesson request that depends on a certain lesson
+     *  Used after the deletion of the lesson
+     */
+    public void refuseAllByLessonId(long id){
+      Iterable<LessonChangesRequest> toRefuse = findRequestByLessonId(id);
+      for(LessonChangesRequest element : toRefuse)
+        element.setState(RequestState.Refused);
+        
+  }
+
+    /**
+     *  Modify a lesson if a request is accepted
+     */
+    public boolean modifyChangeRequestState(Map<String, Object> updates, long lessonId,RequestState state){
+        if(state == RequestState.Accepted){
+            Lesson lesson = lessonServ.findById(lessonId);
+            return lessonServ.modifyData(lesson.getLessonID(),updates);
+        }
+        return true;
+    }
+
+    /**
+     *  Delete a lesson if a request is accepted
+     */
+    public void modifyDeleteRequest(LessonChangesRequest lessonChangesRequest, RequestState state){
+        if(state == RequestState.Accepted){
+            lessonServ.delete(lessonServ.findById(lessonChangesRequest.getLessonId()));
+            refuseAllByLessonId(lessonChangesRequest.getLessonId());
+            }
+    }
+
+    /**
+     * Construct a lesson request
+     */
+    public LessonChangesRequest createLessonRequest(Map<String,Object> lessonInfos) {
+        LessonChangesRequest target = new LessonChangesRequest();
+
+        for (Map.Entry<String, Object> entry : lessonInfos.entrySet()) {
+            System.out.println(entry.toString());
+            if(entry.getValue() != null){
+                switch (entry.getKey()) {
+                    case "requestType":
+                    target.setRequestType((int) entry.getValue());
+                    break;
+                    case "lessonStart":
+                        target.setLessonStart((String) entry.getValue());
+                        break;
+                    case "lessonEnd":
+                        target.setLessonEnd((String) entry.getValue());
+                        break;
+                    case "color":
+                        target.setColor((String) entry.getValue());
+                        break;
+                    case "user":
+                        target.setUser(userServ.getUserById((int) entry.getValue()));
+                        break;
+                    case "lessonType":
+                        target.setLessonType((String) entry.getValue());
+                        break;
+                    case "course":
+                        target.setCourse(courseRepository.findById((int) entry.getValue()));
+                        break;
+                    case "lessonId":
+                        target.setLessonId((int) entry.getValue());
+                        break;
+
+                }
+            }
+        }
+        target.setState(RequestState.Pending);
+        return target;
+    }
+
+    public void delete (LessonChangesRequest toDelete) {
+        lessonChangesRepo.delete(toDelete);
+    }
+}

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

@@ -0,0 +1,157 @@
+package ovh.herisson.Clyde.Services;
+
+
+/******************************************************
+ * @file LessonService.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.*;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+@Service
+public class LessonService {
+    private final LessonRepository lessonRepo;
+
+    private final ScheduleLessonRepository scheduleLessonRepo;
+    private final UserCurriculumRepository userCurriculumRepo;
+    private final UserService userServ;
+    private final CourseRepository courseRepo;
+    private final CurriculumCourseRepository curriculumCourseRepo;
+    public LessonService(LessonRepository lessonRepo, ScheduleLessonRepository scheduleLessonRepo, UserCurriculumRepository userCurriculumRepo, UserService userServ, CourseRepository courseRepo, CurriculumCourseRepository curriculumCourseRepo){
+        this.lessonRepo = lessonRepo;
+        this.scheduleLessonRepo = scheduleLessonRepo;
+        this.userCurriculumRepo = userCurriculumRepo;
+        this.userServ = userServ;
+        this.courseRepo = courseRepo;
+        this.curriculumCourseRepo = curriculumCourseRepo;
+    }
+
+    /**
+     * Create a lesson
+     */
+    public Lesson save(Lesson lesson){
+        return lessonRepo.save(lesson);
+    }
+    /**
+     * Find a lesson by its id
+     */
+    public Lesson findById(long id){
+        return lessonRepo.findById(id);
+    }
+    /**
+     * Return all the lessons
+     */
+    public Iterable<Lesson> findAll(){return lessonRepo.findAll();}
+    /**
+     * Return all a teacher's lessons
+     */
+    public Iterable<Lesson> findAllOwnedLesson(User teacher){
+        ArrayList<Lesson> toReturn = new ArrayList<>();
+        ArrayList<Course> coursesOwned = (ArrayList<Course>) courseRepo.findAllOwnedCoures(teacher);
+        for (Course element : coursesOwned) {
+            for(Lesson lesson : lessonRepo.findLessonByCourse(element))
+                toReturn.add(lesson);
+        }
+        return toReturn;
+    }
+    /**
+     * Return all a student's lessons
+     */
+    
+  public Iterable<Lesson> findOnesLessons(User student){
+    ArrayList<Lesson> toReturn = new ArrayList<>();
+    ArrayList<Course> courses = new ArrayList<>();
+    ArrayList<UserCurriculum> userCurricula = userCurriculumRepo.findByUserAndActual(student, true);
+      for (UserCurriculum userCurriculum : userCurricula) {
+          curriculumCourseRepo.findCoursesByCurriculum(userCurriculum.getCurriculum()).forEach((item) -> {
+              //We need this to eliminate clones because a course can belong to several curriculums
+              if (!courses.contains(item)) {
+                  System.out.println(item.getTitle());
+                  courses.add(item);
+              }
+          });
+      }
+    for (Course element : courses) {
+          for(Lesson lesson : lessonRepo.findLessonByCourse(element))
+              toReturn.add(lesson);
+      }
+
+    return toReturn;
+    }
+    /**
+     *  Construct a new lesson
+     */
+    public Lesson createLesson(Map<String,Object> lessonInfos) {
+        Lesson target = new Lesson();
+
+        for (Map.Entry<String, Object> entry : lessonInfos.entrySet()) {
+            switch (entry.getKey()) {
+                case "lessonStart":
+                    target.setLessonStart((String) entry.getValue());
+                    break;
+                case "lessonEnd":
+                    target.setLessonEnd((String) entry.getValue());
+                case "color":
+                    target.setColor((String) entry.getValue());
+                    break;
+                case "local":
+                    target.setLocal((String) entry.getValue());
+                    break;
+                case "lessonType":
+                    target.setLessonType((String) entry.getValue());
+                    break;
+                case "courseID":
+                    target.setCourse(courseRepo.findById((int) entry.getValue()));
+                    break;
+            }
+
+        }
+        return target;
+    }
+    /**
+     * Modify a lesson
+     */
+    public boolean modifyData(long id, Map<String ,Object> updates){
+        Lesson target = lessonRepo.findById(id);
+
+        if(target == null)
+            return false;
+
+        for (Map.Entry<String , Object> entry: updates.entrySet()){
+            switch (entry.getKey()){
+                case "lessonStart":
+                    target.setLessonStart((String) entry.getValue());
+                    break;
+                case "lessonEnd":
+                    target.setLessonEnd((String) entry.getValue());
+                    break;            
+                case "local":
+                    target.setLocal((String) entry.getValue());
+                    break;
+                case "lessonType":
+                    target.setLessonType((String) entry.getValue());
+                    break;
+            }
+        }
+        Lesson lesson = lessonRepo.save(target);
+        ScheduleLesson scheduleLesson = scheduleLessonRepo.findByLesson(lesson);
+        Iterable<User> users = userCurriculumRepo.findUsersByCurriculum(scheduleLesson.getSchedule().getCurriculum());
+        for(User user: users){
+            userServ.Notify(user, new Notification("Course modified in the schedule", "Course Modified " + lesson.getCourse().getTitle() , "/#/schedule"));
+        }
+        return true;
+    }
+    /**
+     * Delete a lesson
+     */
+    public void delete(Lesson lesson){
+        lessonRepo.delete(lesson);
+    }
+
+
+}

backend/src/main/java/ovh/herisson/Clyde/Services/Msg/DiscussionService.java

@@ -0,0 +1,64 @@
+package ovh.herisson.Clyde.Services.Msg;
+
+import java.util.List;
+
+/******************************************************
+ * @file DiscussionService.java
+ * @author Anthony Debucquoy
+ * @scope Extension messagerie
+ *
+ * Various function utilised by the messages application
+ ******************************************************/
+
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.fasterxml.jackson.databind.util.JSONPObject;
+
+import ovh.herisson.Clyde.Repositories.Msg.DiscussionRepository;
+import ovh.herisson.Clyde.Services.UserService;
+import ovh.herisson.Clyde.Tables.Notification;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Msg.Discussion;
+import ovh.herisson.Clyde.Tables.Msg.Message;
+
+@Service
+public class DiscussionService {
+
+	@Autowired
+	private DiscussionRepository discRepo;
+	@Autowired
+	private UserService userServ;
+
+	public Discussion create(String name, User author){
+		return discRepo.save(new Discussion(name, author));
+	}
+
+	/**
+	 * list discussions owned by a certain user
+	 */
+	public Iterable<Discussion> getOwned(User author){
+		return discRepo.findByMembership(author.getRegNo());
+	}
+
+	/**
+	 * Create a message and link it to it's discussion
+	 */
+	public Discussion CreateMessage(Discussion disc, Message msg){
+		for(User u: disc.getMembers()){
+			userServ.Notify(u, new Notification("msg.notification.new", msg.getContent(), "/#/msg"));
+		}
+		disc.addMessage(msg);
+		return discRepo.save(disc);
+	}
+
+	/**
+	 * Check if a user is in a discussion
+	 */
+    public boolean hasDiscussion(User user, long id) {
+		Discussion disc = discRepo.findById(id).orElse(null);
+		List<User> members = disc.getMembers();
+		return members.contains(user);
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/Msg/ForumService.java

@@ -0,0 +1,47 @@
+package ovh.herisson.Clyde.Services.Msg;
+
+import org.springframework.stereotype.Service;
+
+import lombok.AllArgsConstructor;
+import ovh.herisson.Clyde.Repositories.CourseRepository;
+import ovh.herisson.Clyde.Repositories.Msg.ForumRepository;
+import ovh.herisson.Clyde.Repositories.Msg.TopicRepository;
+import ovh.herisson.Clyde.Services.UserService;
+import ovh.herisson.Clyde.Tables.Course;
+import ovh.herisson.Clyde.Tables.Notification;
+import ovh.herisson.Clyde.Tables.User;
+import ovh.herisson.Clyde.Tables.Msg.Answer;
+import ovh.herisson.Clyde.Tables.Msg.Forum;
+import ovh.herisson.Clyde.Tables.Msg.Topic;
+
+@Service
+@AllArgsConstructor
+public class ForumService {
+
+	private UserService userServ;
+	private CourseRepository courseRepo;
+	private ForumRepository forumRepo;
+	private TopicRepository topicRepo;
+
+	public void createForum(Course c, Forum f){
+		c.addForum(f);
+		for (User u: f.getRegister()) {
+			userServ.Notify(u, new Notification("forum.notification.forum.new", f.getName(), "/#/Forum"));
+		}
+		courseRepo.save(c);
+	}
+
+    public void createTopic(Forum f, Topic data) {
+		f.addTopic(data);
+		for (User u: f.getRegister()) {
+			userServ.Notify(u, new Notification("forum.notification.topic.new", data.getSubject(), "/#/Forum"));
+		}
+		forumRepo.save(f);
+    }
+
+    public void answerTopic(Topic t, Answer data, User	u) {
+		data.setAuthor(u);
+		t.addAnswer(data);
+		topicRepo.save(t);
+    }
+}

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

@@ -0,0 +1,9 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+@Service
+public class NotificationService {
+
+}

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

@@ -0,0 +1,161 @@
+package ovh.herisson.Clyde.Services;
+
+import ovh.herisson.Clyde.Tables.*;
+import ovh.herisson.Clyde.Tables.Inscription.InscriptionRequest;
+
+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());
+        toReturn.put("identityCard", user.getIdentityCardUrl());
+        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 HashMap<String , Object> lessonWithoutPassword(Lesson lesson){
+        if(lesson == null)
+            return null;
+
+        HashMap<String, Object> toReturn = new HashMap<>();
+
+        toReturn.put("lessonID", lesson.getLessonID());
+        toReturn.put("lessonStart", lesson.getLessonStart());
+        toReturn.put("lessonEnd", lesson.getLessonEnd());
+        toReturn.put("course",courseWithoutPassword(lesson.getCourse()));
+        toReturn.put("local",lesson.getLocal());
+        toReturn.put("color", lesson.getColor());
+        toReturn.put("lessonType",lesson.getLessonType());
+        return toReturn;
+    }
+
+    public static Iterable<HashMap<String ,Object>> lessonsWithoutPassword(Iterable<Lesson> lessons){
+        ArrayList<HashMap<String,Object>> toReturn = new ArrayList<>();
+
+        for (Lesson l: lessons){
+            toReturn.add(ProtectionService.lessonWithoutPassword(l));
+        }
+
+        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());
+        toReturn.put("identityCard", inscriptionRequest.getIdentityCard());
+        toReturn.put("submissionDate", inscriptionRequest.getSubmissionDate());
+        toReturn.put("equivalenceState", inscriptionRequest.getEquivalenceState());
+        toReturn.put("admissionDocUrl", inscriptionRequest.getAdmissionDocUrl());
+        return toReturn;
+    }
+
+    public static Map<String, Object> lessonRequestWithoutPassword(LessonChangesRequest lessonRequest){
+        if (lessonRequest == null)
+            return null;
+        Map<String, Object> toReturn = new HashMap<>();
+        toReturn.put("id", lessonRequest.getId());
+        toReturn.put("lessonStart", lessonRequest.getLessonStart());
+        toReturn.put("lessonEnd", lessonRequest.getLessonEnd());
+        toReturn.put("lessonType",lessonRequest.getLessonType());
+        toReturn.put("course", courseWithoutPassword(lessonRequest.getCourse()));
+        toReturn.put("user", userWithoutPassword(lessonRequest.getUser()));
+        toReturn.put("requestType", lessonRequest.getRequestType());
+        toReturn.put("state", lessonRequest.getState());
+        toReturn.put("lessonId",lessonRequest.getLessonId());
+
+        return toReturn;
+    }
+
+    public static Iterable<Map<String, Object>> lessonRequestsWithoutPassword(Iterable<LessonChangesRequest> lessonChangesRequests){
+       ArrayList<Map<String,Object>> toReturn = new ArrayList<>();
+
+       for(LessonChangesRequest lessonChangeRequest: lessonChangesRequests){
+           toReturn.add(lessonRequestWithoutPassword(lessonChangeRequest));
+       }
+       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/ScheduleLessonService.java

@@ -0,0 +1,105 @@
+package ovh.herisson.Clyde.Services;
+
+/******************************************************
+ * @file ScheduleLessonService.java
+ * @author William Karpinski
+ * @scope Extension Horaire
+ ******************************************************/
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.LessonRepository;
+import ovh.herisson.Clyde.Repositories.ScheduleLessonRepository;
+import ovh.herisson.Clyde.Repositories.ScheduleRepository;
+import ovh.herisson.Clyde.Repositories.UserCurriculumRepository;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+
+@Service
+public class ScheduleLessonService {
+
+    private final ScheduleLessonRepository scheduleLessonRepo;
+
+    private final UserCurriculumRepository userCurriculumRepo;
+    private final UserService userServ;
+    private final LessonRepository lessonRepo;
+    private final ScheduleRepository scheduleRepo;
+    public ScheduleLessonService(ScheduleLessonRepository scheduleLessonRepo, UserCurriculumRepository userCurriculumRepo, UserService userServ, LessonRepository lessonRepo, ScheduleRepository scheduleRepo) {
+        this.scheduleLessonRepo = scheduleLessonRepo;
+        this.userCurriculumRepo = userCurriculumRepo;
+        this.userServ = userServ;
+        this.lessonRepo = lessonRepo;
+        this.scheduleRepo = scheduleRepo;
+    }
+    public boolean save(ScheduleLesson scheduleLesson){
+        if(scheduleLesson == null)
+          return false;
+        scheduleLessonRepo.save(scheduleLesson);
+        Iterable<User> users = userCurriculumRepo.findUsersByCurriculum(scheduleLesson.getSchedule().getCurriculum());
+        for(User user: users){
+            userServ.Notify(user, new Notification("New course in the schedule", "Course added " + scheduleLesson.getLesson().getCourse().getTitle(), "/#/schedule"));
+        }
+        return true;
+    }
+    /**
+     * Save a lesson to all the schedule it is linked
+     */
+    public void saveToAllSchedule(Lesson lesson){
+        Iterable<Schedule> schedules = scheduleRepo.findAllLessonSchedule(lesson.getCourse());
+        if(schedules == null)
+            return;
+        for (Schedule schedule : schedules){
+            save(new ScheduleLesson(schedule, lesson));
+        }
+    }
+    /**
+     * Delete a scheduleLesson via its lesson
+     */
+    public boolean delete(long lessonId){
+        if(lessonId == 0)
+            return false;
+        ScheduleLesson scheduleLesson = scheduleLessonRepo.findByLesson(lessonRepo.findById(lessonId));
+        Iterable<User> users = userCurriculumRepo.findUsersByCurriculum(scheduleLesson.getSchedule().getCurriculum());
+        for(User user: users){
+            userServ.Notify(user, new Notification("Course deleted in the schedule","Course deleted " +  scheduleLesson.getLesson().getCourse().getTitle(), "/#/schedule"));
+        }
+        scheduleLessonRepo.delete(lessonRepo.findById(lessonId));
+        return true;
+    }
+
+    public Schedule getScheduleByCurriculum(Curriculum curriculum){
+        return scheduleLessonRepo.findScheduleByCurriculum(curriculum);
+    }
+    /**
+     *  Return a schedule and the list of lessons that corresponds
+     */
+    public Map<String , Object> getDepthScheduleBySchedule(Schedule schedule){
+        if(schedule == null)
+            return null;
+
+        HashMap<String , Object> toReturn = new HashMap<>();
+        ArrayList<Map<String, Object>> lessons = new ArrayList<>();
+        Iterable<Lesson> foundLessons = scheduleLessonRepo.findLessonByCurriculum(schedule.getCurriculum());
+
+        for (Lesson l: foundLessons){
+            lessons.add(ProtectionService.lessonWithoutPassword(l));
+        }
+        toReturn.put("lessons",lessons);
+        toReturn.put("scheduleId" , schedule.getScheduleID());
+        toReturn.put("curriculum", schedule.getCurriculum());
+        return toReturn;
+    }
+    /**
+     * Return all the schedules
+     */
+    public Iterable<Map<String,Object>> getAllSchedule(){
+        ArrayList<Map<String,Object>> toReturn = new ArrayList<>();
+
+        for (Schedule schedule: scheduleRepo.findAll()){
+            toReturn.add(getDepthScheduleBySchedule(schedule));
+        }
+        return toReturn;
+    }
+
+}

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

@@ -0,0 +1,24 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.ScheduleRepository;
+import ovh.herisson.Clyde.Tables.Schedule;
+
+@Service
+public class ScheduleService {
+    private final ScheduleRepository scheduleRepo;
+    public ScheduleService(ScheduleRepository scheduleRepo) {
+        this.scheduleRepo = scheduleRepo;
+    }
+    public Schedule save(Schedule schedule){
+        return scheduleRepo.save(schedule);
+    }
+    public Schedule findById(long id){
+        return scheduleRepo.getById(id);
+    }
+    public void delete(Schedule schedule){
+        scheduleRepo.delete(schedule);
+    }
+
+}
+

backend/src/main/java/ovh/herisson/Clyde/Services/ScientificPublications/ResearchesService.java

@@ -0,0 +1,178 @@
+package ovh.herisson.Clyde.Services.ScientificPublications;
+
+/******************************************************
+ * @file ResearchesService.java
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Service for managing researcher and researches
+ ******************************************************/
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.ScientificPublications.ResearchRepository;
+import ovh.herisson.Clyde.Repositories.ScientificPublications.ResearcherRepository;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.ScientificPublications.*;
+import ovh.herisson.Clyde.Tables.User;
+
+import java.util.*;
+
+@Service
+@AllArgsConstructor
+@SuppressWarnings("unchecked")
+public class ResearchesService {
+
+    private final ResearcherRepository researcherRepo;
+    private final ResearchRepository articleRepo;
+
+
+    // researches Part
+    public Research getResearchById(long id) {
+        return articleRepo.findById(id);
+    }
+
+    public Research getResearchByUrl(String url) {
+        return articleRepo.findByPdfLocation(url);
+    }
+
+
+    public Iterable<Research> getResearchesByAuthor(long authorId){
+        Researcher researcher = researcherRepo.findById(authorId);
+        if (researcher == null) return null;
+
+        return researcherRepo.findAllByAuthorId(researcher);
+    }
+
+    public Research saveResearch(Research research) {
+        return articleRepo.save(research);
+    }
+
+    public void modifyResearchData(Research research, Map<String, Object> updates) {
+        for (Map.Entry<String, Object> entry : updates.entrySet()){
+            switch (entry.getKey()){
+                case "title":
+                    research.setTitle((String) entry.getValue());
+                    break;
+                case "paperType":
+                    research.setPaperType((PaperType) entry.getValue());
+                    break;
+                case "language":
+                    research.setLanguage((String) entry.getValue());
+                    break;
+                case "domain":
+                    research.setDomain((String) entry.getValue());
+                    break;
+                case "summary":
+                    research.setSummary((String) entry.getValue());
+                    break;
+                case "access":
+                    research.setAccess(Access.valueOf((String) entry.getValue()));
+                    break;
+                case "coAuthors":
+                    Set<Researcher> set = new HashSet<>();
+
+                    for (int id : (List<Integer>) entry.getValue()) {
+
+                        Researcher r = researcherRepo.findById(id);
+                        if (r != null){
+                            set.add(r);
+                        }
+                    }
+                    research.setCoAuthors(set);
+                    break;
+            }
+        }
+        articleRepo.save(research);
+    }
+
+    public void deleteResearch(Research research) {
+        articleRepo.delete(research);
+    }
+
+
+    // Researchers Part
+    public Researcher getResearcherByUser(User user){
+        return researcherRepo.findByUser(user);
+    }
+
+    public Iterable<Research> getAllResearches() {
+        return articleRepo.findAll();
+    }
+
+    public Researcher saveResearcher(Researcher researcher) {
+
+        if (researcherRepo.findByUser(researcher.getUser()) != null) return null;
+       return researcherRepo.save(researcher);
+    }
+
+    public Iterable<Researcher> getAllResearchers() {
+        return researcherRepo.findAll();
+    }
+
+    public Researcher getResearcherById(long id) {
+        return  researcherRepo.findById(id);
+    }
+
+    public void deleteResearcher(Researcher researcher) {
+        articleRepo.findAll();
+        for (Research r: articleRepo.findAll())
+        {
+            if (r.getCoAuthors().contains(researcher)){
+                r.getCoAuthors().remove(researcher);
+                articleRepo.save(r);
+            }
+        }
+       researcherRepo.delete(researcher);
+    }
+
+    public void modifyResearcherData(Researcher researcher, Map<String, Object> updates) {
+
+        for (Map.Entry<String, Object> entry : updates.entrySet()){
+            switch (entry.getKey()){
+                case "orcidId":
+                    if (entry.getValue() != null)
+                        researcher.setOrcidId((String) entry.getValue());
+                    break;
+                case "domain":
+                    if (entry.getValue() != null)
+                        researcher.setDomain((String) entry.getValue());
+                    break;
+                case "site":
+                    if (entry.getValue() != null)
+                        researcher.setSite((String) entry.getValue());
+                    break;
+           }
+        }
+        researcherRepo.save(researcher);
+    }
+    // Other stuff
+
+    public Research addView(Research research) {
+        research.setViews(research.getViews()+1);
+        return articleRepo.save(research);
+    }
+
+    public boolean hasNoAccessTo(Research research, User user){
+        if (research.getAccess() == Access.OpenSource) return false; // if the access is open source even non-users can see it
+        if (user == null) return true; // else you need at least to be a user
+
+        if (user.getRole() == Role.Admin) return false;
+
+
+        Researcher researcher = getResearcherByUser(user);
+        if (researcher !=null ){
+            if (research.getAuthor().getId() == researcher.getId())
+                return false;
+
+            for (Researcher coAuthor: research.getCoAuthors()){
+                if (coAuthor.getId() == researcher.getId())
+                    return false;
+            }
+        }
+
+        return research.getAccess() != Access.Restricted || (user.getRole() != Role.Secretary &&
+                user.getRole() != Role.Teacher && user.getRole() != Role.InscriptionService);
+        // if the access is restricted only the staff member (above) can access the research
+
+    }
+}

backend/src/main/java/ovh/herisson/Clyde/Services/ScientificPublications/StatisticsService.java

@@ -0,0 +1,50 @@
+package ovh.herisson.Clyde.Services.ScientificPublications;
+
+/******************************************************
+ * @file StatisticsService
+ * @author Bartha Maxime
+ * @scope Publications Scientifiques
+ *
+ * Service for managing statistics
+ ******************************************************/
+import lombok.AllArgsConstructor;
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.ScientificPublications.ResearchRepository;
+import ovh.herisson.Clyde.Repositories.ScientificPublications.StatsRepository;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Research;
+import ovh.herisson.Clyde.Tables.ScientificPublications.Researcher;
+
+import java.util.*;
+
+@Service
+@AllArgsConstructor
+public class StatisticsService {
+
+
+    private ResearchRepository articleRepo;
+    private StatsRepository statsRepo;
+
+
+    public Iterable<Iterable<Map<String, Integer>>> generateStats(Researcher researcher){
+
+        Iterable<Research> researches = articleRepo.findByAuthor(researcher);
+
+        if (researches == null) return null;
+
+
+        ArrayList<Iterable<Map<String,Integer>>> toReturn = new ArrayList<>();
+
+        toReturn.add(statsRepo.viewsByYears());
+        toReturn.add(statsRepo.viewsByMonths());
+        toReturn.add(statsRepo.viewsByTopics());
+
+        toReturn.add(statsRepo.researchesByYears());
+        toReturn.add(statsRepo.researchesByMonth());
+        toReturn.add(statsRepo.researchesByTopics());
+
+        toReturn.add(statsRepo.languageByYears());
+        toReturn.add(statsRepo.languageByMonths());
+        toReturn.add(statsRepo.languageByTopics());
+        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

@@ -0,0 +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.io.UnsupportedEncodingException;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Calendar;
+
+@Service
+public class TokenService {
+    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);
+        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) {
+        Token tokenRep = tokenRepo.getByToken(token);
+        if (tokenRep == null)
+            return null;
+
+        return tokenRep.getUser();
+    }
+
+    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,55 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Repositories.CurriculumRepository;
+import ovh.herisson.Clyde.Repositories.Inscription.ExternalCurriculumRepository;
+import ovh.herisson.Clyde.Repositories.UserCurriculumRepository;
+import ovh.herisson.Clyde.Tables.*;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+@Service
+public class UserCurriculumService {
+
+    private final UserCurriculumRepository userCurriculumRepository;
+    private final CurriculumRepository curriculumRepo;
+
+    private final ExternalCurriculumRepository externalCurriculumRepo;
+    public UserCurriculumService(UserCurriculumRepository userCurriculumRepository, CurriculumRepository curriculumRepo, ExternalCurriculumRepository externalCurriculumRepo) {
+        this.userCurriculumRepository = userCurriculumRepository;
+        this.curriculumRepo = curriculumRepo;
+        this.externalCurriculumRepo = externalCurriculumRepo;
+    }
+
+    public Curriculum findByUser(User student){
+        return userCurriculumRepository.findByUser(student);
+    }
+
+    public HashMap<String,Object> findAllCurriculumByStudent(User student) {
+        ArrayList<UserCurriculum> list = userCurriculumRepository.findByUserOrderByCurriculum(student);
+
+        ArrayList<HashMap<String, Object>> curriculumlist = new ArrayList<HashMap<String, Object>>();
+
+        for (int i = 0; i < list.size(); i++) {
+            HashMap<String, Object> element = new HashMap<>();
+            Curriculum c = list.get(i).getCurriculum();
+
+            element.put("curriculumId", c.getCurriculumId());
+            element.put("year", c.getYear());
+            element.put("option", c.getOption());
+            element.put("dateyear", list.get(i).getYear());
+            element.put("actual", list.get(i).isActual());
+
+            curriculumlist.add(element);
+        }
+
+        HashMap<String, Object> toReturn = new HashMap<String, Object>();
+        toReturn.put("curriculumList", curriculumlist);
+        return toReturn;
+    }
+
+    public ArrayList<UserCurriculum> findByStudentAndActual(User u, boolean actual){
+        return userCurriculumRepository.findByUserAndActual(u, actual);
+    }
+}

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

@@ -0,0 +1,142 @@
+package ovh.herisson.Clyde.Services;
+
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Service;
+import ovh.herisson.Clyde.Tables.RegNoGenerator;
+import ovh.herisson.Clyde.Repositories.UserRepository;
+import ovh.herisson.Clyde.Tables.Notification;
+import ovh.herisson.Clyde.Tables.Role;
+import ovh.herisson.Clyde.Tables.User;
+import java.util.*;
+
+@Service
+public class UserService {
+    private final UserRepository userRepo;
+    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
+
+    public UserService(UserRepository userRepo){
+        this.userRepo = userRepo;
+    }
+
+
+    /** 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;
+
+        try {
+            int id = Integer.parseInt(identifier);
+            return userRepo.findById(id);
+        }
+        catch (NumberFormatException nfe){
+            return userRepo.findByEmail(identifier);
+        }
+    }
+
+    /** 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 User modifyData(long targetId, Map<String ,Object> updates, User poster){
+
+        User target = userRepo.findById(targetId);
+        if (target == null)
+            return null;
+
+        if (!target.getRegNo().equals(poster.getRegNo()) && !(poster.getRole() == Role.Secretary) &&
+            !(poster.getRole() == Role.Admin))
+            return null;
+
+        for (Map.Entry<String, Object> entry : updates.entrySet()){
+            System.out.println(entry.getValue());
+            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((String) entry.getValue());
+                    break;
+                case "role":
+                    //a user can't change his own role
+                    if (poster.getRole()==Role.Secretary || poster.getRole() == Role.Admin){
+                        Role wanted = Role.valueOf((String) entry.getValue());
+                        if (wanted == Role.Admin && poster.getRole() != Role.Admin)
+                            return null;
+                        target.setRole(wanted);
+                    }
+            }
+        }
+        userRepo.save(target);
+        return target;
+    }
+
+
+    public boolean checkPassword(User user, String tryingPassword){
+        return passwordEncoder.matches(tryingPassword,  user.getPassword());
+    }
+
+    public User save(User  user){
+        RegNoGenerator.resetCount();
+        return userRepo.save(user);
+    }
+
+    public void saveAll(ArrayList<User> list){
+        //S'assure que le compteur est bien a 0
+        RegNoGenerator.resetCount();
+        userRepo.saveAll(list);
+    }
+
+    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);
+    }
+
+	public void Notify(User u, Notification n){
+		n.setUser(u);
+		u.getNotifications().add(n);
+		userRepo.save(u);
+	}
+}