jsp

src/dev/peerat/backend/Configuration.java

@@ -33,6 +33,7 @@ public class Configuration {
 	
 	private int groupJoinMinutes;
 	private String groupQuitMinutes;
+	private int groupMaxPlayers;
 	
 	private String mailUsername;
 	private String mailPassword;
@@ -43,6 +44,10 @@ public class Configuration {
 	private String git_token;
 	
 	private String jwt_key;
+	
+	private String sql_folder;
+	
+	private int event_chapter;
 
 	private File _file;
 
@@ -197,6 +202,10 @@ public class Configuration {
 		return this.groupQuitMinutes;
 	}
 	
+	public int getGroupMaxPlayers(){
+		return this.groupMaxPlayers;
+	}
+	
 	public Mail getMail(){
 		return new Mail(
 				this.mailUsername,
@@ -217,4 +226,12 @@ public class Configuration {
 	public void setJwtKey(String key){
 		this.jwt_key = key;
 	}
+	
+	public String getSqlFolder(){
+		return this.sql_folder;
+	}
+	
+	public int getEventChapter(){
+		return this.event_chapter;
+	}
 }

src/dev/peerat/backend/Main.java

@@ -9,47 +9,11 @@ import java.util.Map.Entry;
 import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteExtracter;
-import dev.peerat.backend.model.Completion;
 import dev.peerat.backend.model.Group;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.ConnectionManager;
+import dev.peerat.backend.repository.DatabaseBadgeRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.backend.routes.BadgeDetails;
-import dev.peerat.backend.routes.ChapterElement;
-import dev.peerat.backend.routes.ChapterList;
-import dev.peerat.backend.routes.DynamicLeaderboard;
-import dev.peerat.backend.routes.Leaderboard;
-import dev.peerat.backend.routes.PlayerDetails;
-import dev.peerat.backend.routes.PuzzleElement;
-import dev.peerat.backend.routes.PuzzleResponse;
-import dev.peerat.backend.routes.Result;
-import dev.peerat.backend.routes.Swagger;
-import dev.peerat.backend.routes.admins.DynamicLogs;
-import dev.peerat.backend.routes.admins.ExceptionLogs;
-import dev.peerat.backend.routes.admins.WebHookLeaderboard;
-import dev.peerat.backend.routes.admins.chapter.AddChapter;
-import dev.peerat.backend.routes.admins.chapter.DeleteChapter;
-import dev.peerat.backend.routes.admins.chapter.EditChapter;
-import dev.peerat.backend.routes.admins.chapter.GetChapter;
-import dev.peerat.backend.routes.admins.puzzle.AddPuzzle;
-import dev.peerat.backend.routes.admins.puzzle.DeletePuzzle;
-import dev.peerat.backend.routes.admins.puzzle.EditPuzzle;
-import dev.peerat.backend.routes.admins.puzzle.GetPuzzle;
-import dev.peerat.backend.routes.admins.puzzle.GetPuzzles;
-import dev.peerat.backend.routes.admins.tag.AddTag;
-import dev.peerat.backend.routes.admins.tag.DeleteTag;
-import dev.peerat.backend.routes.admins.tag.EditTag;
-import dev.peerat.backend.routes.admins.tag.GetTags;
-import dev.peerat.backend.routes.groups.GroupCreate;
-import dev.peerat.backend.routes.groups.GroupJoin;
-import dev.peerat.backend.routes.groups.GroupList;
-import dev.peerat.backend.routes.groups.GroupQuit;
-import dev.peerat.backend.routes.users.ChangePassword;
-import dev.peerat.backend.routes.users.ForgotPassword;
-import dev.peerat.backend.routes.users.Login;
-import dev.peerat.backend.routes.users.MailConfirmation;
-import dev.peerat.backend.routes.users.ProfileSettings;
-import dev.peerat.backend.routes.users.Register;
-import dev.peerat.backend.utils.Mail;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.DependencyInjector;
 import dev.peerat.framework.HttpReader;
@@ -61,6 +25,8 @@ import dev.peerat.framework.Response;
 import dev.peerat.framework.Route;
 import dev.peerat.framework.RouteInterceptor;
 import dev.peerat.framework.Router;
+import dev.peerat.framework.auth.Authenticator;
+import dev.peerat.framework.auth.JwtAuthenticator;
 import dev.peerat.framework.utils.json.JsonMap;
 import dev.peerat.framework.utils.json.JsonParser;
 
@@ -74,8 +40,8 @@ public class Main{
 		config.load();
 
 		Class.forName("com.mysql.cj.jdbc.Driver");
-
+		
-		DatabaseRepository repo = new DatabaseRepository(config);
+		DatabaseRepository repo = new DatabaseRepository(new ConnectionManager(config), config);
 		Router<PeerAtUser> router = new Router<PeerAtUser>()
 				.activeReOrdering().
 				addDefaultHeaders(RequestType.GET, "Access-Control-Allow-Origin: *").
@@ -86,12 +52,13 @@ public class Main{
 						"Access-Control-Allow-Headers: *");
 		ACCESS_ROUTER = router;
 		
+		Authenticator<PeerAtUser> auth;
 		if(config.getJwtKey() != null){
 			JsonParser parser = new JsonParser();
 			JsonMap json = parser.parse(config.getJwtKey());
 			Map<String, Object> params = new HashMap<>();
 			for(Entry<String, Object> entry : json.entries()) params.put(entry.getKey(), entry.getValue());
-			router.configureJwt(
+			auth = new JwtAuthenticator<PeerAtUser>().configure(
 					(builder) -> builder.setExpectedIssuer(config.getTokenIssuer()),
 					(claims) -> {
 						claims.setIssuer(config.getTokenIssuer());
@@ -100,7 +67,7 @@ public class Main{
 					(claims) -> new PeerAtUser(claims),
 					params);
 		}else{
-			router.configureJwt(
+			auth = new JwtAuthenticator<PeerAtUser>().configure(
 					(builder) -> builder.setExpectedIssuer(config.getTokenIssuer()),
 					(claims) -> {
 						claims.setIssuer(config.getTokenIssuer());
@@ -108,12 +75,13 @@ public class Main{
 					}, 
 					(claims) -> new PeerAtUser(claims));
 			JsonMap json = new JsonMap();
-			for(Entry<String, Object> entry : router.exportJwtKey().entrySet()){
+			for(Entry<String, Object> entry : ((JwtAuthenticator<PeerAtUser>)auth).exportKey().entrySet()){
 				json.set(entry.getKey(), entry.getValue());
 			}
 			config.setJwtKey(json.toString());
 			config.save();
 		}
+		router.setAuthenticator(auth);
 
 		router.setDefault((matcher, context, reader, writer) -> {
 			context.response(404);
@@ -125,7 +93,6 @@ public class Main{
 			public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception {
 				context.response(200);
 			}
-
 		});
 		
 		initRoutes(router, repo, config);
@@ -135,7 +102,7 @@ public class Main{
 			public boolean intercept(Matcher matcher, Context context, HttpReader reader, HttpWriter writer, Method method){
 				if(method.getDeclaringClass().getPackage().getName().contains(".admins")){
 					try {
-						Group group = repo.getPlayerGroup(context.<PeerAtUser>getUser().getId(), 1);
+						Group group = repo.getGroupRepository().getPlayerGroup(context.<PeerAtUser>getUser().getId(), 1);
 						if(!group.getName().equalsIgnoreCase("Quarter-Master - Battles PAC x CEI")){
 							context.response(401);
 							return false;
@@ -164,7 +131,26 @@ public class Main{
 						locker.lock(key);
 						Context instance = locker.getValue(key);
 						if(instance == null) continue;
-						System.out.println("["+((instance.isLogged()) ? repo.getPlayer(instance.<PeerAtUser>getUser().getId()).getPseudo() : "?")+"] "+instance.getType()+" "+instance.getPath()+" -> "+instance.getResponseCode());
+						System.out.println("["+((instance.isLogged()) ? repo.getPlayerRepository().getPlayer(instance.<PeerAtUser>getUser().getId()).getPseudo() : "?")+"] "+instance.getType()+" "+instance.getPath()+" -> "+instance.getResponseCode());
+					}
+				}catch(Exception e){
+					e.printStackTrace();
+				}
+				locker.remove(key);
+			}
+		}).start();
+		
+		new Thread(new Runnable(){
+			public void run(){
+				Key key = new Key();
+				
+				Locker<Throwable> locker = router.getExceptionLogger();
+				
+				locker.init(key);
+				try {
+					while(true){
+						locker.lock(key);
+						locker.getValue(key).printStackTrace();
 					}
 				}catch(Exception e){
 					e.printStackTrace();
@@ -178,18 +164,12 @@ public class Main{
 	}
 
 	private static void initRoutes(Router<PeerAtUser> router, DatabaseRepository repo, Configuration config) throws Exception{
-		router.registerPackages(new DependencyInjector()
+		router.registerPackages("dev.peerat.backend.routes",new DependencyInjector()
-				.of(repo, router, config.getMail(), new RouteExtracter(router))
+				.of(repo, router, config, new RouteExtracter(router), config.getMail())
 				.of("waitting", new HashMap<>())
 				.of("leaderboard", new Locker<>())
-				.of("log", router.getLogger())
-				.of("exception", router.getExceptionLogger())
 				.of("groups", new Locker<>())
-				.of("groupDelay", config.getGroupJoinMinutes())
+				.of("groupMessages", new Locker<>()));
-				.of("waitTime", config.getGroupQuitMinutes())
-				.of("usersFiles", config.getUsersFiles())
-				.of("gitToken", config.getGitToken())
-				.of("issuer", config.getTokenIssuer()));
 		
 //		Bot bot = new Bot(config, repo, groupLock);
 //		bot.start();

src/dev/peerat/backend/bonus/discord/Bot.java

@@ -38,7 +38,7 @@ public class Bot extends Thread{
 			
 			locker.init(key);
 			
-			List<Group> groups = this.repo.getAllGroups();
+			List<Group> groups = this.repo.getGroupRepository().getAllGroups();
 			for(Group group : groups){
 				Integer chapter = group.getLinkToChapter();
 //				Integer puzzle = group.getLinkToPuzzle();

src/dev/peerat/backend/repository/BaseDatabaseQuery.java

@@ -0,0 +1,114 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Badge;
+import dev.peerat.backend.model.Chapter;
+import dev.peerat.backend.model.Completion;
+import dev.peerat.backend.model.Group;
+import dev.peerat.backend.model.Player;
+import dev.peerat.backend.model.Puzzle;
+
+public class BaseDatabaseQuery{
+	
+	private ConnectionManager con;
+	private Configuration config;
+	
+	public BaseDatabaseQuery(ConnectionManager con){
+		this.con = con;
+	}
+	
+	public Connection ensureConnection() throws SQLException{
+		return this.con.ensureConnection();
+	}
+	
+	public PreparedStatement prepare(String request) throws SQLException{
+		return this.con.ensureConnection().prepareStatement(request);
+	}
+	
+	public Puzzle makePuzzle(ResultSet puzzleResult) throws SQLException {
+		return new Puzzle(puzzleResult.getInt("id_puzzle"), puzzleResult.getString("name"),
+				puzzleResult.getString("content"), puzzleResult.getBytes("soluce"), puzzleResult.getString("verify"),
+				puzzleResult.getInt("score_max"), puzzleResult.getString("tags"),
+				hasColumn(puzzleResult, "origin") ? puzzleResult.getInt("origin") : -1,
+				puzzleResult.getTimestamp("start_date"));
+	}
+	
+	public Chapter makeChapter(ResultSet chapterResult) throws SQLException {
+		return new Chapter(chapterResult.getInt("id_chapter"), chapterResult.getString("name"),
+				chapterResult.getTimestamp("start_date"), chapterResult.getTimestamp("end_date"));
+	}
+
+	public Completion makeCompletion(ResultSet completionResult) throws SQLException {
+		String fileName = null;
+		if (hasColumn(completionResult, "fileName"))
+			fileName = completionResult.getString("fileName");
+		String puzzleName = null;
+		if (hasColumn(completionResult, "name"))
+			puzzleName = completionResult.getString("name");
+		
+		return new Completion(completionResult.getInt("fk_player"), completionResult.getInt("fk_puzzle"), completionResult.getInt("tries"),
+				fileName, completionResult.getInt("score"), puzzleName);
+	}
+
+	public Player makePlayer(ResultSet playerResult, int id) throws SQLException {
+		Player p = new Player(playerResult.getString("pseudo"), playerResult.getString("email"),
+				playerResult.getString("firstName"), playerResult.getString("lastName"));
+		if (hasColumn(playerResult, "avatar")) {
+			p.setAvatar(playerResult.getBytes("avatar"));
+		}
+		if (hasColumn(playerResult, "score")) {
+			p.addCompletion(new Completion(playerResult.getInt("tries"), playerResult.getInt("score")));
+			for (int ct = 1; ct < playerResult.getInt("completions"); ct++)
+			{	// TODO refactor for V3
+				p.addCompletion(new Completion(0, 0));
+			}
+		}
+		if (hasColumn(playerResult, "name")) {
+			// Manage groups
+			String groupName = playerResult.getString("name");
+			if (groupName != null) {
+				p.addGroup(makeGroup(playerResult));
+			}
+		}
+
+		// ADD rank
+		PreparedStatement completionsStmt = con.ensureConnection().prepareStatement(DatabasePlayerRepository.GET_PLAYER_RANK());
+		completionsStmt.setInt(1, id);
+		ResultSet result = completionsStmt.executeQuery();
+		while (result.next()) {
+			p.setRank(result.getInt("rank"));
+		}
+		return p;
+	}
+
+	public Group makeGroup(ResultSet result) throws SQLException {
+		return new Group(result.getString("name"), result.getInt("fk_chapter"), result.getInt("fk_puzzle"), ((hasColumn(result, "countPlayer")) ? result.getInt("countPlayer") : 0));
+	}
+
+	public Player makeGroupPlayer(ResultSet result) throws SQLException {
+		return new Player(result.getString("pseudo"), result.getInt("score"), result.getInt("tries"));
+	}
+
+	public Badge makeBadge(ResultSet rs) throws SQLException {
+		return new Badge(rs.getString("name"), rs.getBytes("logo"), rs.getInt("level"));
+	}
+
+	public boolean hasColumn(ResultSet rs, String columnName) throws SQLException {
+		// Found on StackOverflow
+		ResultSetMetaData rsmd = rs.getMetaData();
+		int columns = rsmd.getColumnCount();
+		for (int x = 1; x <= columns; x++) {
+			if (columnName.equals(rsmd.getColumnName(x)))
+				return true;
+		}
+		return false;
+	}
+
+
+}

src/dev/peerat/backend/repository/ConnectionManager.java

@@ -0,0 +1,26 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+import dev.peerat.backend.Configuration;
+
+public class ConnectionManager {
+	
+	private Connection con;
+	private Configuration config;
+	
+	public ConnectionManager(Configuration config){
+		this.config = config;
+	}
+
+	public Connection ensureConnection() throws SQLException {
+		if (con == null || (!con.isValid(5))) {
+			this.con = DriverManager.getConnection(
+					"jdbc:mysql://" + config.getDbHost() + ":" + config.getDbPort() + "/" + config.getDbDatabase() + "",
+					config.getDbUser(), config.getDbPassword());
+		}
+		return this.con;
+	}
+}

src/dev/peerat/backend/repository/DatabaseAdminRepository.java

@@ -0,0 +1,194 @@
+package dev.peerat.backend.repository;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Chapter;
+import dev.peerat.backend.model.Puzzle;
+import dev.peerat.backend.model.Tag;
+
+public class DatabaseAdminRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+		
+		//ADMIN
+		ADD_CHAPTER("INSERT INTO chapters (name, start_date, end_date) VALUES (?,?,?)"),
+		DELETE_CHAPTER("DELETE FROM chapters WHERE id_chapter = ?"),
+		EDIT_CHAPTER("UPDATE chapters SET name = ?, start_date = ?, end_date = ? WHERE id_chapter = ?"),
+		GET_CHAPTER("SELECT * FROM chapters WHERE id_chapter = ?"),
+		
+		ADD_PUZZLE("INSERT INTO puzzles (name, content, soluce, verify, score_max, fk_chapter) VALUES (?,?,?,?,?,?)"),
+		DELETE_PUZZLE("DELETE FROM puzzles WHERE id_puzzle = ?"),
+		EDIT_PUZZLE("UPDATE puzzles SET name = ?, content = ?, soluce = ?, verify = ?, score_max = ?, fk_chapter = ? WHERE id_puzzle = ?"),
+		GET_PUZZLE("SELECT p.*, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag WHERE p.id_puzzle = ? GROUP BY p.id_puzzle"),
+		GET_PUZZLES("SELECT p.*, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag GROUP BY p.id_puzzle"),
+		
+		ADD_TAG("INSERT INTO tags (name) VALUES (?)"),
+		DELETE_TAG("DELETE FROM tags WHERE id_tag = ?"),
+		EDIT_TAG("UPDATE tags SET name = ? WHERE id_tag = ?"),
+		GET_TAGS("SELECT * FROM tags");
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	
+	private Configuration config;
+	
+	public DatabaseAdminRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+	
+	//ADMIN
+		public Chapter getAdminChapter(int id){
+			try {
+				PreparedStatement chapterStmt = Query.GET_CHAPTER.prepare(this);
+				chapterStmt.setInt(1, id);
+				ResultSet chapterResult = chapterStmt.executeQuery();
+				if (chapterResult.next()) {
+					Chapter chapter = makeChapter(chapterResult);
+					return chapter;
+				}
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+			return null;
+		}
+		
+		public Puzzle getAdminPuzzle(int id){
+			try {
+				PreparedStatement chapterStmt = Query.GET_PUZZLE.prepare(this);
+				chapterStmt.setInt(1, id);
+				ResultSet chapterResult = chapterStmt.executeQuery();
+				if (chapterResult.next()) {
+					return makePuzzle(chapterResult);
+				}
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+			return null;
+		}
+		
+		public List<Puzzle> getAdminPuzzles(){
+			try {
+				PreparedStatement chapterStmt = Query.GET_PUZZLES.prepare(this);
+				ResultSet chapterResult = chapterStmt.executeQuery();
+				List<Puzzle> list = new ArrayList<>();
+				while(chapterResult.next()){
+					list.add(makePuzzle(chapterResult));
+				}
+				return list;
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+			return null;
+		}
+		
+		public List<Tag> getAdminTags(){
+			try {
+				PreparedStatement chapterStmt = Query.GET_TAGS.prepare(this);
+				ResultSet chapterResult = chapterStmt.executeQuery();
+				List<Tag> list = new ArrayList<>();
+				while(chapterResult.next()){
+					list.add(new Tag(chapterResult.getInt("id_tag"), chapterResult.getString("name")));
+				}
+				return list;
+			} catch (SQLException e) {
+				e.printStackTrace();
+			}
+			return null;
+		}
+		
+		public boolean adminAddChapter(Chapter chapter) throws SQLException {
+			PreparedStatement statement = Query.ADD_CHAPTER.prepare(this);
+			statement.setString(1, chapter.getName());
+			statement.setTimestamp(2, chapter.getStartDate());
+			statement.setTimestamp(3, chapter.getEndDate());
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminAddPuzzle(Puzzle puzzle, int chapter) throws SQLException {
+			PreparedStatement statement = Query.ADD_PUZZLE.prepare(this);
+			statement.setString(1, puzzle.getName());
+			statement.setString(2, puzzle.getContent());
+			statement.setBytes(3, puzzle.getSoluce());
+			statement.setString(4, "");
+			statement.setInt(5, puzzle.getScoreMax());
+			statement.setInt(6, chapter);
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminAddTag(String name) throws SQLException {
+			PreparedStatement statement = Query.ADD_TAG.prepare(this);
+			statement.setString(1, name);
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminUpdateChapter(int id, Chapter chapter) throws SQLException {
+			PreparedStatement statement = Query.EDIT_CHAPTER.prepare(this);
+			statement.setString(1, chapter.getName());
+			statement.setTimestamp(2, chapter.getStartDate());
+			statement.setTimestamp(3, chapter.getEndDate());
+			statement.setInt(4, id);
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminUpdatePuzzle(int id, Puzzle puzzle, int chapter) throws SQLException {
+			PreparedStatement statement = Query.EDIT_PUZZLE.prepare(this);
+			statement.setString(1, puzzle.getName());
+			statement.setString(2, puzzle.getContent());
+			statement.setBytes(3, puzzle.getSoluce());
+			statement.setString(4, "");
+			statement.setInt(5, puzzle.getScoreMax());
+			statement.setInt(6, chapter);
+			statement.setInt(7, id);
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminUpdateTag(Tag tag) throws SQLException {
+			PreparedStatement statement = Query.EDIT_TAG.prepare(this);
+			statement.setString(1, tag.getName());
+			statement.setInt(2, tag.getId());
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminDeleteChapter(int id) throws SQLException {
+			PreparedStatement statement = Query.DELETE_CHAPTER.prepare(this);
+			statement.setInt(1, id);
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminDeletePuzzle(int id) throws SQLException {
+			PreparedStatement statement = Query.DELETE_PUZZLE.prepare(this);
+			statement.setInt(1, id);
+			return (statement.executeUpdate() >= 0);
+		}
+		
+		public boolean adminDeleteTag(int id) throws SQLException {
+			PreparedStatement statement = Query.DELETE_TAG.prepare(this);
+			statement.setInt(1, id);
+			return (statement.executeUpdate() >= 0);
+		}
+
+}

src/dev/peerat/backend/repository/DatabaseAuthRepository.java

@@ -0,0 +1,167 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import com.password4j.Password;
+
+import dev.peerat.backend.Configuration;
+
+public class DatabaseAuthRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+		
+		// REGISTER
+		CHECK_PSEUDO_AVAILABLE_QUERY("SELECT * FROM players WHERE pseudo = ?"),
+		CHECK_EMAIL_AVAILABLE_QUERY("SELECT * FROM players WHERE email = ?"),
+		REGISTER_QUERY(
+				"INSERT INTO players (pseudo, email, passwd, firstname, lastname, description, avatar) VALUES (?, ?, ?, ?, ?, ?, ?)"),
+		REGISTER_PLAYER_IN_EXISTING_GROUP(
+				"INSERT INTO containsGroups (fk_player, fk_group) VALUES (?, (SELECT id_group FROM groups WHERE name = ?));"),
+
+		// LOGIN
+		CHECK_PASSWORD("SELECT id_player, passwd FROM players WHERE pseudo=?");
+		
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	private Configuration config;
+	
+	public DatabaseAuthRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+	
+	/**
+	 * Check if a pseudo is available
+	 *
+	 * @param pseudo The pseudo to check
+	 * @return True if the pseudo is available, false if it's already taken
+	 */
+	public boolean checkPseudoAvailability(String pseudo) {
+		return checkAvailability(pseudo, Query.CHECK_PSEUDO_AVAILABLE_QUERY.toString());
+	}
+
+	/**
+	 * Check if an email is available
+	 *
+	 * @param email The email to check
+	 * @return True if the email is available, false if it's already taken
+	 */
+	public boolean checkEmailAvailability(String email) {
+		return checkAvailability(email, Query.CHECK_EMAIL_AVAILABLE_QUERY.toString());
+	}
+
+	private boolean checkAvailability(String queriedString, String correspondingQuery) {
+		try {
+			PreparedStatement statement = prepare(correspondingQuery);
+			statement.setString(1, queriedString);
+			ResultSet result = statement.executeQuery();
+			return !result.next();
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	/**
+	 * Register a new user
+	 *
+	 * @param pseudo      The pseudo of the user
+	 * @param email       The email of the user
+	 * @param password    The password of the user
+	 * @param firstname   The firstname of the user
+	 * @param lastname    The lastname of the user
+	 * @param description The description of the user
+	 * @param sgroup      The group of the user
+	 * @param avatar      The avatar of the user
+	 * @return True if the user was registered, false if an error occurred
+	 */
+	public int register(String pseudo, String email, String password, String firstname, String lastname,
+			String description, String sgroup, String avatar) {
+		try {
+			String pass = Password.hash(password).withArgon2().getResult();
+			System.out.println("pass("+pass.length()+") "+pass);
+			Connection con = ensureConnection();
+			con.setAutoCommit(false);
+			try (PreparedStatement playerStatement = con.prepareStatement(Query.REGISTER_QUERY.toString(),
+					Statement.RETURN_GENERATED_KEYS)) {
+				playerStatement.setString(1, pseudo);
+				playerStatement.setString(2, email);
+				playerStatement.setString(3, Password.hash(password).withArgon2().getResult());
+				playerStatement.setString(4, firstname);
+				playerStatement.setString(5, lastname);
+				playerStatement.setString(6, description);
+				playerStatement.setString(7, avatar);
+				if (playerStatement.executeUpdate() == 1) {
+					ResultSet inserted = playerStatement.getGeneratedKeys();
+					if (inserted.next()) {
+						int newPlayerId = inserted.getInt(1);
+						if (!sgroup.isEmpty()) {
+							try (PreparedStatement containsGroupsStatement = con
+									.prepareStatement(Query.REGISTER_PLAYER_IN_EXISTING_GROUP.toString())) {
+								containsGroupsStatement.setInt(1, newPlayerId);
+								containsGroupsStatement.setString(2, sgroup);
+								containsGroupsStatement.executeUpdate();
+							}
+						}
+						con.commit();
+						con.setAutoCommit(true);
+						return newPlayerId;
+					}
+				}
+			} catch (SQLException e) {
+				con.rollback();
+				con.setAutoCommit(true);
+				e.printStackTrace();
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return -1;
+	}
+
+	/**
+	 * Login a user
+	 *
+	 * @param username The username of the user
+	 * @param password The password of the user
+	 * @return id the id of the user, -1 if not login successefuly
+	 */
+	public int login(String username, String password) {
+		try {
+			ensureConnection();
+			PreparedStatement statement = prepare(Query.CHECK_PASSWORD.toString());
+			statement.setString(1, username);
+			ResultSet result = statement.executeQuery();
+			if (result.next()) {
+				String hashedPassword = result.getString("passwd");
+				if (Password.check(password, hashedPassword).withArgon2())
+					return result.getInt("id_player");
+			}
+		} catch (SQLException e) {
+		}
+		return -1;
+	}
+
+}

src/dev/peerat/backend/repository/DatabaseBadgeRepository.java

@@ -0,0 +1,69 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Badge;
+import dev.peerat.backend.model.Puzzle;
+
+public class DatabaseBadgeRepository extends BaseDatabaseQuery{
+	
+	public static String GET_BADGES_OF_PLAYER(){
+		return Query.GET_BADGES_OF_PLAYER.request;
+	}
+	
+	private static enum Query{
+		
+		// BADGES
+		GET_BADGE("SELECT * FROM badges WHERE id_badge = ?"),
+		GET_BADGES_OF_PLAYER(
+				"SELECT * FROM badges b LEFT JOIN containsBadges cb ON cb.fk_badge = b.id_badge WHERE cb.fk_player = ?");
+		
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	private Configuration config;
+	
+	public DatabaseBadgeRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+	
+	public Badge getBadge(int badgeId) {
+		try {
+			ensureConnection();
+			PreparedStatement completionsStmt = Query.GET_BADGE.prepare(this);
+			completionsStmt.setInt(1, badgeId);
+			ResultSet result = completionsStmt.executeQuery();
+			if (result.next()) {
+				return makeBadge(result);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+}

src/dev/peerat/backend/repository/DatabaseChapterRepository.java

@@ -0,0 +1,122 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Chapter;
+import dev.peerat.backend.model.Puzzle;
+
+public class DatabaseChapterRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+
+		// CHAPTERS
+		SPECIFIC_CHAPTER_QUERY("SELECT * FROM chapters WHERE id_chapter = ?"),
+		CHAPTER_FROM_PUZZLE("SELECT c.*\r\n"
+				+ "FROM chapters c\r\n"
+				+ "JOIN puzzles p ON p.fk_chapter = c.id_chapter\r\n"
+				+ "WHERE p.id_puzzle = ?"),
+		ALL_CHAPTERS_QUERY("SELECT * FROM chapters WHERE id_chapter > 0");
+
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	
+	private Configuration config;
+	private DatabasePuzzleRepository puzzleRepo;
+	
+	public DatabaseChapterRepository(ConnectionManager con, Configuration config, DatabasePuzzleRepository puzzleRepo){
+		super(con);
+		this.config = config;
+		this.puzzleRepo = puzzleRepo;
+	}
+	
+	/**
+	 * Get a specific chapter
+	 *
+	 * @param id The id of the chapter
+	 * @return The chapter or null if an error occurred
+	 */
+	public Chapter getChapter(int id) {
+		try {
+			ensureConnection();
+			PreparedStatement chapterStmt = Query.SPECIFIC_CHAPTER_QUERY.prepare(this);
+			chapterStmt.setInt(1, id);
+			ResultSet chapterResult = chapterStmt.executeQuery();
+			if (chapterResult.next()) {
+				Chapter chapter = makeChapter(chapterResult);
+				List<Puzzle> puzzles = puzzleRepo.getPuzzlesInChapter(id);
+				chapter.setPuzzles(puzzles);
+				return chapter;
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public Chapter getChapter(Puzzle puzzle){
+		try {
+			ensureConnection();
+			PreparedStatement chapterStmt = Query.CHAPTER_FROM_PUZZLE.prepare(this);
+			chapterStmt.setInt(1, puzzle.getId());
+			ResultSet chapterResult = chapterStmt.executeQuery();
+			if (chapterResult.next()) {
+				Chapter chapter = makeChapter(chapterResult);
+				List<Puzzle> puzzles = puzzleRepo.getPuzzlesInChapter(chapter.getId());
+				chapter.setPuzzles(puzzles);
+				return chapter;
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	/**
+	 * Get all chapters in the database
+	 *
+	 * @return List of all chapters or null if an error occurred
+	 */
+	public List<Chapter> getAllChapters() {
+		try {
+			List<Chapter> chapterList = new ArrayList<>();
+			ensureConnection();
+			PreparedStatement chapterStmt = Query.ALL_CHAPTERS_QUERY.prepare(this);
+			ResultSet chapterResult = chapterStmt.executeQuery();
+			while (chapterResult.next()) {
+				Chapter chapter = makeChapter(chapterResult);
+				chapter.setPuzzles(puzzleRepo.getPuzzlesInChapter(chapter.getId()));
+				chapterList.add(chapter);
+			}
+			return chapterList;
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+}

src/dev/peerat/backend/repository/DatabaseCompletionRepository.java

@@ -0,0 +1,162 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Completion;
+import dev.peerat.backend.model.Puzzle;
+
+public class DatabaseCompletionRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+		
+		// COMPLETIONS
+		GET_COMPLETION(
+				"SELECT * FROM completions WHERE fk_puzzle = ? AND fk_player = ?"),
+		GET_COMPLETION_GROUP("SELECT c.*\r\n"
+				+ "FROM completions c\r\n"
+				+ "WHERE c.fk_puzzle = ? AND c.fk_player IN\r\n"
+				+ "(select f.fk_player FROM containsGroups cgs JOIN containsGroups f ON f.fk_group = cgs.fk_group JOIN groups g ON g.id_group = cgs.fk_group WHERE g.fk_chapter = 12 AND cgs.fk_player = ?)"),
+		INSERT_COMPLETION(
+				"INSERT INTO completions (fk_puzzle, fk_player, tries, code, fileName, score) values (?, ?, ?, ?, ?, ?)"),
+		UPDATE_COMPLETION(
+				"UPDATE completions SET tries = ?, score = ?, fk_player = ? WHERE fk_puzzle = ? AND fk_player = ?"),
+		SCORE("SELECT score FROM completions WHERE fk_player = ? AND fk_puzzle = ?"),
+		SCORE_GROUP("SELECT c.score\r\n"
+				+ "FROM completions c\r\n"
+				+ "WHERE c.fk_puzzle = ? AND c.fk_player IN\r\n"
+				+ "(select f.fk_player FROM containsGroups cgs JOIN containsGroups f ON f.fk_group = cgs.fk_group JOIN groups g ON g.id_group = cgs.fk_group WHERE g.fk_chapter = 12 AND cgs.fk_player = ?)");
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	
+	private Configuration config;
+	private DatabaseChapterRepository chapterRepo;
+	
+	public DatabaseCompletionRepository(ConnectionManager con, Configuration config, DatabaseChapterRepository chapterRepo){
+		super(con);
+		this.config = config;
+		this.chapterRepo = chapterRepo;
+	}
+	
+	public Completion getCompletionGroup(int user, int puzzle) {
+		try {
+			PreparedStatement stmt = Query.GET_COMPLETION_GROUP.prepare(this);
+			stmt.setInt(1, puzzle);
+			stmt.setInt(2, user);
+			ResultSet result = stmt.executeQuery();
+			if (result.next())
+				return makeCompletion(result);
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return getCompletion(user, puzzle);
+	}
+
+	public Completion getCompletion(int playerId, int puzzleId) {
+		try {
+			PreparedStatement completionsStmt = Query.GET_COMPLETION.prepare(this);
+			completionsStmt.setInt(1, puzzleId);
+			completionsStmt.setInt(2, playerId);
+			ResultSet result = completionsStmt.executeQuery();
+			if (result.next()) {
+				return makeCompletion(result);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public Completion insertOrUpdatePuzzleResponse(int puzzleId, int userId, String fileName, byte[] code,
+			byte[] response, Puzzle currentPuzzle){
+		try {
+			ensureConnection();
+			Completion completion = getCompletionGroup(userId, puzzleId);
+			if (completion == null){
+				System.out.println("Completion is null");
+				completion = new Completion(userId, puzzleId, fileName, code, response, currentPuzzle);
+				insertCompletion(completion);
+			} else {
+				System.out.println(completion);
+				completion.addTry(currentPuzzle, response, chapterRepo.getChapter(currentPuzzle).getId());
+				int lastUserId = completion.getPlayerId();
+				completion.updatePlayer(userId);
+				updateCompletion(completion, lastUserId);
+			}
+			return completion;
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	private void insertCompletion(Completion newCompletion) throws SQLException {
+		PreparedStatement statement = Query.INSERT_COMPLETION.prepare(this);
+		statement.setInt(1, newCompletion.getPuzzleId());
+		statement.setInt(2, newCompletion.getPlayerId());
+		statement.setInt(3, newCompletion.getTries());
+		statement.setBytes(4, newCompletion.getCode());
+		statement.setString(5, newCompletion.getFileName());
+		statement.setInt(6, newCompletion.getScore());
+		statement.executeUpdate();
+	}
+
+
+	private void updateCompletion(Completion completionToUpdate, int user) throws SQLException{
+		System.out.println("update "+completionToUpdate);
+		PreparedStatement statement = Query.UPDATE_COMPLETION.prepare(this);
+		statement.setInt(1, completionToUpdate.getTries());
+		statement.setInt(2, completionToUpdate.getScore());
+		statement.setInt(3, completionToUpdate.getPlayerId());
+		statement.setInt(4, completionToUpdate.getPuzzleId());
+		statement.setInt(5, user);
+		statement.executeUpdate();
+	}
+	
+	public int getScore(int user, int puzzle) {
+		try {
+			ensureConnection();
+			PreparedStatement stmt = Query.SCORE_GROUP.prepare(this);
+			stmt.setInt(1, puzzle);
+			stmt.setInt(2, user);
+			ResultSet result = stmt.executeQuery();
+			if (result.next())
+				return result.getInt("score");
+
+			stmt = Query.SCORE.prepare(this);
+			stmt.setInt(1, user);
+			stmt.setInt(2, puzzle);
+
+			result = stmt.executeQuery();
+			if (result.next())
+				return result.getInt("score");
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return -1;
+	}
+}

src/dev/peerat/backend/repository/DatabaseGroupRepository.java

@@ -0,0 +1,166 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Group;
+import dev.peerat.backend.model.PeerAtUser;
+
+public class DatabaseGroupRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+		
+		// GROUPS
+		ALL_GROUPS("SELECT * FROM groups"),
+		ALL_GROUPS_BY_CHAPTER("select g.*, count(cg.fk_player) as countPlayer from groups g left join containsGroups cg on cg.fk_group = g.id_group where g.fk_chapter = ? group by g.id_group"),
+		GET_GROUP_FOR_PLAYER("SELECT g.* FROM groups g JOIN containsGroups cg ON cg.fk_group = g.id_group WHERE cg.fk_player = ? AND g.fk_chapter = ?"), // AND g.fk_puzzle = ?
+		GET_GROUP_ID_BY_DATA("SELECT id_group FROM groups WHERE name = ? AND (fk_chapter = ?)"), // OR fk_puzzle = ?
+		GET_GROUP_USERS_COUNT("SELECT count(*) as howmany FROM containsGroups WHERE fk_group = ?"),
+		INSERT_GROUP("INSERT INTO groups (name, fk_chapter) VALUES (?,?)"),
+		INSERT_PLAYER_IN_GROUP("INSERT INTO containsGroups (fk_player, fk_group) VALUES (?,?)"),
+		LEAVE_GROUP("DELETE FROM containsGroups WHERE fk_player = ? AND fk_group = ?");
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	private Configuration config;
+	
+	public DatabaseGroupRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+	
+	public List<Group> getAllGroups() {
+		try {
+			ensureConnection();
+			List<Group> list = new ArrayList<>();
+			PreparedStatement stmt = Query.ALL_GROUPS.prepare(this);
+			ResultSet groupResult = stmt.executeQuery();
+			while (groupResult.next())
+				list.add(makeGroup(groupResult));
+			return list;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public List<Group> getAllGroupsByChapter(int chapter){
+		try {
+			ensureConnection();
+			List<Group> list = new ArrayList<>();
+			PreparedStatement stmt = Query.ALL_GROUPS_BY_CHAPTER.prepare(this);
+			stmt.setInt(1, chapter);
+			ResultSet groupResult = stmt.executeQuery();
+			while (groupResult.next())
+				list.add(makeGroup(groupResult));
+			return list;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public boolean insertGroup(Group group, PeerAtUser creator) throws SQLException {
+		Integer groupId = getGroupId(group);
+		if (groupId == null)
+			ensureConnection();
+			PreparedStatement statement = Query.INSERT_GROUP.prepare(this);
+			statement.setString(1, group.getName());
+			statement.setObject(2, group.getLinkToChapter());
+//			statement.setObject(3, group.getLinkToPuzzle());
+			if (statement.executeUpdate() >= 0)
+				return insertUserInGroup(group, creator);
+		return false;
+	}
+
+	public Group getPlayerGroup(int user, Integer chapter) throws SQLException {
+		ensureConnection();
+		PreparedStatement stmt = Query.GET_GROUP_FOR_PLAYER.prepare(this);
+		stmt.setInt(1, user);
+		stmt.setObject(2, chapter);
+//		stmt.setObject(3, puzzle);
+
+		ResultSet result = stmt.executeQuery();
+		if (result.next())
+			return makeGroup(result);
+		return null;
+	}
+
+	public Integer getGroupId(Group group) throws SQLException {
+		ensureConnection();
+		PreparedStatement stmt = Query.GET_GROUP_ID_BY_DATA.prepare(this);
+		stmt.setString(1, group.getName());
+		stmt.setObject(2, group.getLinkToChapter());
+//		stmt.setObject(3, group.getLinkToPuzzle());
+
+		ResultSet result = stmt.executeQuery();
+		if (result.next())
+			return result.getInt("id_group");
+		return null;
+	}
+
+	public boolean insertUserInGroup(Group group, PeerAtUser user) throws SQLException{
+		Integer id = getGroupId(group);
+		if(id != null){
+			int howmany = numberInGroup(id);
+			System.out.println("join group, already have "+howmany);
+			if(howmany > config.getGroupMaxPlayers()) return false;
+		}
+		Group alreadyInGroup = getPlayerGroup(user.getId(), group.getLinkToChapter());
+		if (id != null && alreadyInGroup == null) {
+			PreparedStatement stmt = Query.INSERT_PLAYER_IN_GROUP.prepare(this);
+
+			stmt.setInt(1, user.getId());
+			stmt.setInt(2, id);
+
+			return stmt.executeUpdate() >= 0;
+		}
+		return false;
+	}
+	
+	public int numberInGroup(int group) throws SQLException{
+		PreparedStatement stmt = Query.GET_GROUP_USERS_COUNT.prepare(this);
+		stmt.setInt(1, group);
+
+		ResultSet result = stmt.executeQuery();
+		if(result.next()) return result.getInt("howmany");
+		return 0;
+	}
+
+	public boolean leaveGroup(Group group, PeerAtUser user) throws SQLException {
+		Integer id = getGroupId(group);
+		if (id != null) {
+			PreparedStatement stmt = Query.LEAVE_GROUP.prepare(this);
+
+			stmt.setInt(1, user.getId());
+			stmt.setInt(2, id);
+
+			return stmt.executeUpdate() >= 0;
+		}
+		return false;
+	}
+
+}

src/dev/peerat/backend/repository/DatabaseLeaderboardRepository.java

@@ -0,0 +1,102 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Group;
+import dev.peerat.backend.model.Player;
+
+public class DatabaseLeaderboardRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+		
+		// LEADERBOARD
+		ALL_PLAYERS_FOR_LEADERBOARD(
+				"select p.*, scores.*, g.* from players p ,(SELECT fk_player, SUM(c.score) AS score, COUNT(c.id_completion) AS completions, SUM(c.tries) AS tries, rank() over(ORDER BY score DESC) AS rank FROM completions c LEFT JOIN puzzles puzz on puzz.id_puzzle = c.fk_puzzle LEFT JOIN chapters chap on chap.id_chapter = puzz.fk_chapter WHERE chap.id_chapter > 1 GROUP BY c.fk_player) AS scores LEFT JOIN containsGroups cg ON scores.fk_player = cg.fk_player LEFT JOIN groups g ON cg.fk_group = g.id_group  WHERE p.id_player = scores.fk_player ORDER BY g.fk_chapter"),
+		ALL_GROUP_FOR_CHAPTER_LEADERBOARD(
+				"SELECT g.*, pl.pseudo, co.score, co.tries FROM groups g LEFT JOIN containsGroups cg ON g.id_group = cg.fk_group LEFT JOIN players pl ON cg.fk_player = pl.id_player LEFT JOIN completions co ON pl.id_player = co.fk_player WHERE cg.fk_player IS NOT NULL AND fk_chapter = ? AND (co.fk_puzzle IN (SELECT id_puzzle FROM puzzles puz WHERE puz.fk_chapter = g.fk_chapter) OR co.score IS NULL);");
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	private Configuration config;
+	
+	public DatabaseLeaderboardRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+
+	public SortedSet<Player> getAllPlayerForLeaderboard() {
+		try {
+			ensureConnection();
+			PreparedStatement playersStmt = Query.ALL_PLAYERS_FOR_LEADERBOARD.prepare(this);
+			ResultSet result = playersStmt.executeQuery();
+			ArrayList<Player> players = new ArrayList<Player>();
+			Player tmpPlayer;
+			while (result.next()) {
+				tmpPlayer = makePlayer(result, result.getInt("id_player"));
+				if (!players.contains(tmpPlayer)) {
+					players.add(tmpPlayer);
+				} else {
+					players.get(players.indexOf(tmpPlayer)).addGroup(makeGroup(result));
+				}
+			}
+			return new TreeSet<Player>(players);
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	public SortedSet<Group> getAllGroupForChapterLeaderboard(int chapterId){
+		try{
+			ensureConnection();
+			PreparedStatement groupsStmt = Query.ALL_GROUP_FOR_CHAPTER_LEADERBOARD.prepare(this);
+			groupsStmt.setInt(1, chapterId);
+			ResultSet result = groupsStmt.executeQuery();
+			List<Group> groups = new ArrayList<Group>();
+			Group tmpGroup;
+			while (result.next()) {
+				tmpGroup = makeGroup(result);
+				if (tmpGroup != null) {
+					int gPosition = groups.indexOf(tmpGroup);
+					if (gPosition < 0) {
+						tmpGroup.addPlayer(makeGroupPlayer(result));
+						groups.add(tmpGroup);
+					} else {
+						groups.get(gPosition).addPlayer(makeGroupPlayer(result));
+					}
+				}
+			}
+			return new TreeSet<Group>(groups);
+		}catch(SQLException e){
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+}

src/dev/peerat/backend/repository/DatabasePlayerRepository.java

@@ -0,0 +1,191 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.password4j.Password;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Player;
+import dev.peerat.backend.model.Puzzle;
+
+public class DatabasePlayerRepository extends BaseDatabaseQuery{
+	
+	public static String GET_PLAYER_RANK(){
+		return Query.GET_PLAYER_RANK.request;
+	}
+	
+	private static enum Query{
+		
+		// PLAYERS
+		GET_PLAYER_SIMPLE("SELECT pseudo, email, firstname, lastname, description FROM players WHERE id_player = ?"),
+		GET_PLAYER_EMAIL("SELECT id_player FROM players WHERE email = ?"),
+		GET_PLAYER_PSEUDO("SELECT * FROM players WHERE pseudo = ?"),
+		GET_PLAYER_DETAILS("SELECT p.*, g.*\r\n"
+				+ "FROM players p\r\n"
+				+ "LEFT OUTER JOIN containsGroups cg ON p.id_player = cg.fk_player\r\n"
+				+ "LEFT OUTER JOIN groups g ON cg.fk_group = g.id_group\r\n"
+				+ "LEFT OUTER JOIN completions c on p.id_player = c.fk_player\r\n"
+				+ "WHERE "),
+		GET_PLAYER_DETAILS_BY_ID(GET_PLAYER_DETAILS, " p.id_player = ? GROUP BY g.name ORDER BY g.fk_chapter, g.fk_puzzle;"),
+		GET_PLAYER_DETAILS_BY_PSEUDO(GET_PLAYER_DETAILS, "p.pseudo = ? GROUP BY g.name ORDER BY g.fk_chapter, g.fk_puzzle;"),
+		GET_PLAYER_COMPLETIONS("select c.*, p.name from completions c left join puzzles p on c.fk_puzzle = p.id_puzzle where fk_player = ?;"),
+		GET_PLAYER_RANK("SELECT * FROM (SELECT fk_player, RANK() OVER(ORDER BY SUM(score) DESC) rank FROM completions c LEFT JOIN puzzles puzz on puzz.id_puzzle = c.fk_puzzle LEFT JOIN chapters chap on chap.id_chapter = puzz.fk_chapter LEFT JOIN players p ON p.id_player = c.fk_player WHERE chap.id_chapter > 1 GROUP BY fk_player ORDER BY rank) AS ranks WHERE ranks.fk_player = ?;"),
+		UPDATE_PLAYER_INFO("UPDATE players SET pseudo = ?, email = ?, firstname = ?, lastname = ? WHERE id_player = ?"),
+		UPDATE_PLAYER_PASSWORD("UPDATE players SET passwd = ? WHERE id_player = ?");		
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	
+	private Configuration config;
+	
+	public DatabasePlayerRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+	
+	public Player getPlayer(int idPlayer) {
+		try {
+			PreparedStatement completionsStmt = Query.GET_PLAYER_SIMPLE.prepare(this);
+			completionsStmt.setInt(1, idPlayer);
+			ResultSet result = completionsStmt.executeQuery();
+			if (result.next()) {
+				return makePlayer(result, idPlayer);
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public int getPlayerId(String email){
+		try {
+			ensureConnection();
+			PreparedStatement completionsStmt = Query.GET_PLAYER_EMAIL.prepare(this);
+			completionsStmt.setString(1, email);
+			ResultSet result = completionsStmt.executeQuery();
+			if (result.next()) {
+				return result.getInt("id_player");
+			}
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return -1;
+	}
+	
+	public boolean updatePseudo(int id, Player player, String pseudo){
+		try{
+			PreparedStatement statment = Query.GET_PLAYER_PSEUDO.prepare(this);
+			statment.setString(1, pseudo);
+			ResultSet result = statment.executeQuery();
+			if(result.next()) return false;
+			statment = Query.UPDATE_PLAYER_INFO.prepare(this);
+			statment.setString(1, pseudo);
+			statment.setString(2, player.getEmail());
+			statment.setString(3, player.getFirstname());
+			statment.setString(4, player.getLastname());
+			statment.setInt(5, id);
+			return statment.executeUpdate() > 0;
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+		return false;
+	}
+	
+	public void updateProfile(int id, Player player, String lastname, String firstname){
+		try{
+			PreparedStatement statment = Query.UPDATE_PLAYER_INFO.prepare(this);
+			statment.setString(1, player.getPseudo());
+			statment.setString(2, player.getEmail());
+			statment.setString(3, firstname);
+			statment.setString(4, lastname);
+			statment.setInt(5, id);
+			statment.executeUpdate();
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+	}
+	
+	public void updatePassword(int id, String password){
+		try{
+			PreparedStatement statment = Query.UPDATE_PLAYER_PASSWORD.prepare(this);
+			statment.setString(1, Password.hash(password).withArgon2().getResult());
+			statment.setInt(2, id);
+			statment.executeUpdate();
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+	}
+
+	public Player getPlayerDetails(int idPlayer) {
+		return getPlayerDetails(idPlayer, null);
+	}
+
+	public Player getPlayerDetails(String pseudoPlayer) {
+		return getPlayerDetails(-1, pseudoPlayer);
+	}
+
+	private Player getPlayerDetails(int id, String pseudo) {
+		try {
+			ensureConnection();
+			PreparedStatement completionsStmt;
+			if (pseudo != null) {
+				completionsStmt = Query.GET_PLAYER_DETAILS_BY_PSEUDO.prepare(this);
+				completionsStmt.setString(1, pseudo);
+			} else {
+				completionsStmt = Query.GET_PLAYER_DETAILS_BY_ID.prepare(this);
+				completionsStmt.setInt(1, id);
+			}
+			ResultSet result = completionsStmt.executeQuery();
+			Player player = null;
+			while (result.next()) {
+				if (player == null) {
+					id = result.getInt("id_player");
+					player = makePlayer(result, id);
+					completionsStmt = prepare(DatabaseBadgeRepository.GET_BADGES_OF_PLAYER());
+					completionsStmt.setInt(1, id);
+					ResultSet resultBadges = completionsStmt.executeQuery();
+					while (resultBadges.next()) {
+						player.addBadge(makeBadge(resultBadges));
+					}
+				} else {
+					player.addGroup(makeGroup(result));
+				}
+			}
+			// ADD completions
+			completionsStmt = Query.GET_PLAYER_COMPLETIONS.prepare(this);
+			completionsStmt.setInt(1, id);
+			result = completionsStmt.executeQuery();
+			while (result.next()) {
+				player.addCompletion(makeCompletion(result));
+			}
+			
+			return player;
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+}

src/dev/peerat/backend/repository/DatabasePuzzleRepository.java

@@ -0,0 +1,78 @@
+package dev.peerat.backend.repository;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.List;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Puzzle;
+
+public class DatabasePuzzleRepository extends BaseDatabaseQuery{
+	
+	private static enum Query{
+		
+		SPECIFIC_PUZZLE_QUERY(
+				"SELECT p.*, np.origin, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN nextPart np ON p.id_puzzle = np.next LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag WHERE p.id_puzzle = ? GROUP BY p.id_puzzle"),
+		PUZZLES_IN_CHAPTER_QUERY(
+				"SELECT p.*, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag WHERE fk_chapter = ? GROUP BY p.id_puzzle");
+
+		private String request;
+
+		Query(Query parent, String request) {
+			this.request = parent.request + request;
+		}
+
+		Query(String request) {
+			this.request = request;
+		}
+
+		public PreparedStatement prepare(BaseDatabaseQuery base) throws SQLException {
+			return base.prepare(this.request);
+		}
+
+		@Override
+		public String toString() {
+			return this.request;
+		}
+	}
+	
+	private Configuration config;
+	
+	public DatabasePuzzleRepository(ConnectionManager con, Configuration config){
+		super(con);
+		this.config = config;
+	}
+	
+	public List<Puzzle> getPuzzlesInChapter(int id) throws SQLException {
+		List<Puzzle> puzzles = new ArrayList<>();
+		ensureConnection();
+		PreparedStatement puzzleStmt = Query.PUZZLES_IN_CHAPTER_QUERY.prepare(this);
+		puzzleStmt.setInt(1, id);
+		ResultSet puzzleResult = puzzleStmt.executeQuery();
+		while (puzzleResult.next()) {
+			puzzles.add(makePuzzle(puzzleResult));
+		}
+		return puzzles;
+	}
+
+	/**
+	 * Get a specific puzzle
+	 *
+	 * @param id The id of the puzzle
+	 * @return The puzzle or null if an error occurred
+	 */
+	public Puzzle getPuzzle(int id) throws SQLException {
+		ensureConnection();
+		PreparedStatement puzzleStmt = Query.SPECIFIC_PUZZLE_QUERY.prepare(this);
+		puzzleStmt.setInt(1, id);
+		ResultSet puzzleResult = puzzleStmt.executeQuery();
+		if (puzzleResult.next()) {
+			return makePuzzle(puzzleResult);
+		}
+		return null;
+	}
+
+}

src/dev/peerat/backend/repository/DatabaseQuery.java

@@ -5,101 +5,6 @@ import java.sql.PreparedStatement;
 import java.sql.SQLException;
 
 public enum DatabaseQuery {
-	// PUZZLES
-	SPECIFIC_PUZZLE_QUERY(
-			"SELECT p.*, np.origin, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN nextPart np ON p.id_puzzle = np.next LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag WHERE p.id_puzzle = ? GROUP BY p.id_puzzle"),
-	PUZZLES_IN_CHAPTER_QUERY(
-			"SELECT p.*, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag WHERE fk_chapter = ? GROUP BY p.id_puzzle"),
-
-	// CHAPTERS
-	SPECIFIC_CHAPTER_QUERY("SELECT * FROM chapters WHERE id_chapter = ?"),
-	CHAPTER_FROM_PUZZLE("SELECT c.*\r\n"
-			+ "FROM chapters c\r\n"
-			+ "JOIN puzzles p ON p.fk_chapter = c.id_chapter\r\n"
-			+ "WHERE p.id_puzzle = ?"),
-	ALL_CHAPTERS_QUERY("SELECT * FROM chapters WHERE id_chapter > 0"),
-
-	// GROUPS
-	ALL_GROUPS("SELECT * FROM groups"),
-	ALL_GROUPS_BY_CHAPTER("select g.*, count(cg.fk_player) as countPlayer from groups g left join containsGroups cg on cg.fk_group = g.id_group where g.fk_chapter = ? group by g.id_group"),
-	GET_GROUP_FOR_PLAYER("SELECT g.* FROM groups g JOIN containsGroups cg ON cg.fk_group = g.id_group WHERE cg.fk_player = ? AND g.fk_chapter = ?"), // AND g.fk_puzzle = ?
-	GET_GROUP_ID_BY_DATA("SELECT id_group FROM groups WHERE name = ? AND (fk_chapter = ?)"), // OR fk_puzzle = ?
-	GET_GROUP_USERS_COUNT("SELECT count(*) as howmany FROM containsGroups WHERE fk_group = ?"),
-	INSERT_GROUP("INSERT INTO groups (name, fk_chapter) VALUES (?,?)"),
-	INSERT_PLAYER_IN_GROUP("INSERT INTO containsGroups (fk_player, fk_group) VALUES (?,?)"),
-	LEAVE_GROUP("DELETE FROM containsGroups WHERE fk_player = ? AND fk_group = ?"),
-	
-	// LEADERBOARD
-	ALL_PLAYERS_FOR_LEADERBOARD(
-			"select p.*, scores.*, g.* from players p ,(SELECT fk_player, SUM(c.score) AS score, COUNT(c.id_completion) AS completions, SUM(c.tries) AS tries, rank() over(ORDER BY score DESC) AS rank FROM completions c LEFT JOIN puzzles puzz on puzz.id_puzzle = c.fk_puzzle LEFT JOIN chapters chap on chap.id_chapter = puzz.fk_chapter WHERE chap.id_chapter > 1 GROUP BY c.fk_player) AS scores LEFT JOIN containsGroups cg ON scores.fk_player = cg.fk_player LEFT JOIN groups g ON cg.fk_group = g.id_group  WHERE p.id_player = scores.fk_player ORDER BY g.fk_chapter"),
-	ALL_GROUP_FOR_CHAPTER_LEADERBOARD(
-			"SELECT g.*, pl.pseudo, co.score, co.tries FROM groups g LEFT JOIN containsGroups cg ON g.id_group = cg.fk_group LEFT JOIN players pl ON cg.fk_player = pl.id_player LEFT JOIN completions co ON pl.id_player = co.fk_player WHERE cg.fk_player IS NOT NULL AND fk_chapter = ? AND (co.fk_puzzle IN (SELECT id_puzzle FROM puzzles puz WHERE puz.fk_chapter = g.fk_chapter) OR co.score IS NULL);"),
-
-	// REGISTER
-	CHECK_PSEUDO_AVAILABLE_QUERY("SELECT * FROM players WHERE pseudo = ?"),
-	CHECK_EMAIL_AVAILABLE_QUERY("SELECT * FROM players WHERE email = ?"),
-	REGISTER_QUERY(
-			"INSERT INTO players (pseudo, email, passwd, firstname, lastname, description, avatar) VALUES (?, ?, ?, ?, ?, ?, ?)"),
-	REGISTER_PLAYER_IN_EXISTING_GROUP(
-			"INSERT INTO containsGroups (fk_player, fk_group) VALUES (?, (SELECT id_group FROM groups WHERE name = ?));"),
-
-	// LOGIN
-	CHECK_PASSWORD("SELECT id_player, passwd FROM players WHERE pseudo=?"),
-
-	// COMPLETIONS
-	GET_COMPLETION(
-			"SELECT * FROM completions WHERE fk_puzzle = ? AND fk_player = ?"),
-	GET_COMPLETION_GROUP("SELECT c.*\r\n"
-			+ "FROM completions c\r\n"
-			+ "WHERE c.fk_puzzle = ? AND c.fk_player IN\r\n"
-			+ "(select f.fk_player FROM containsGroups cgs JOIN containsGroups f ON f.fk_group = cgs.fk_group JOIN groups g ON g.id_group = cgs.fk_group WHERE g.fk_chapter = 12 AND cgs.fk_player = ?)"),
-	INSERT_COMPLETION(
-			"INSERT INTO completions (fk_puzzle, fk_player, tries, code, fileName, score) values (?, ?, ?, ?, ?, ?)"),
-	UPDATE_COMPLETION(
-			"UPDATE completions SET tries = ?, score = ?, fk_player = ? WHERE fk_puzzle = ? AND fk_player = ?"),
-	SCORE("SELECT score FROM completions WHERE fk_player = ? AND fk_puzzle = ?"),
-	SCORE_GROUP("SELECT c.score\r\n"
-			+ "FROM completions c\r\n"
-			+ "WHERE c.fk_puzzle = ? AND c.fk_player IN\r\n"
-			+ "(select f.fk_player FROM containsGroups cgs JOIN containsGroups f ON f.fk_group = cgs.fk_group JOIN groups g ON g.id_group = cgs.fk_group WHERE g.fk_chapter = 12 AND cgs.fk_player = ?)"),
-	
-	// PLAYERS
-	GET_PLAYER_SIMPLE("SELECT pseudo, email, firstname, lastname, description FROM players WHERE id_player = ?"),
-	GET_PLAYER_EMAIL("SELECT id_player FROM players WHERE email = ?"),
-	GET_PLAYER_PSEUDO("SELECT * FROM players WHERE pseudo = ?"),
-	GET_PLAYER_DETAILS("SELECT p.*, g.*\r\n"
-			+ "FROM players p\r\n"
-			+ "LEFT OUTER JOIN containsGroups cg ON p.id_player = cg.fk_player\r\n"
-			+ "LEFT OUTER JOIN groups g ON cg.fk_group = g.id_group\r\n"
-			+ "LEFT OUTER JOIN completions c on p.id_player = c.fk_player\r\n"
-			+ "WHERE "),
-	GET_PLAYER_DETAILS_BY_ID(GET_PLAYER_DETAILS, " p.id_player = ? GROUP BY g.name ORDER BY g.fk_chapter, g.fk_puzzle;"),
-	GET_PLAYER_DETAILS_BY_PSEUDO(GET_PLAYER_DETAILS, "p.pseudo = ? GROUP BY g.name ORDER BY g.fk_chapter, g.fk_puzzle;"),
-	GET_PLAYER_COMPLETIONS("select c.*, p.name from completions c left join puzzles p on c.fk_puzzle = p.id_puzzle where fk_player = ?;"),
-	GET_PLAYER_RANK("SELECT * FROM (SELECT fk_player, RANK() OVER(ORDER BY SUM(score) DESC) rank FROM completions c LEFT JOIN puzzles puzz on puzz.id_puzzle = c.fk_puzzle LEFT JOIN chapters chap on chap.id_chapter = puzz.fk_chapter LEFT JOIN players p ON p.id_player = c.fk_player WHERE chap.id_chapter > 1 GROUP BY fk_player ORDER BY rank) AS ranks WHERE ranks.fk_player = ?;"),
-	UPDATE_PLAYER_INFO("UPDATE players SET pseudo = ?, email = ?, firstname = ?, lastname = ? WHERE id_player = ?"),
-	UPDATE_PLAYER_PASSWORD("UPDATE players SET passwd = ? WHERE id_player = ?"),
-	
-	// BADGES
-	GET_BADGE("SELECT * FROM badges WHERE id_badge = ?"), GET_BADGES_OF_PLAYER(
-			"SELECT * FROM badges b LEFT JOIN containsBadges cb ON cb.fk_badge = b.id_badge WHERE cb.fk_player = ?"),
-	
-	//ADMIN
-	ADD_CHAPTER("INSERT INTO chapters (name, start_date, end_date) VALUES (?,?,?)"),
-	DELETE_CHAPTER("DELETE FROM chapters WHERE id_chapter = ?"),
-	EDIT_CHAPTER("UPDATE chapters SET name = ?, start_date = ?, end_date = ? WHERE id_chapter = ?"),
-	GET_CHAPTER("SELECT * FROM chapters WHERE id_chapter = ?"),
-	
-	ADD_PUZZLE("INSERT INTO puzzles (name, content, soluce, verify, score_max, fk_chapter) VALUES (?,?,?,?,?,?)"),
-	DELETE_PUZZLE("DELETE FROM puzzles WHERE id_puzzle = ?"),
-	EDIT_PUZZLE("UPDATE puzzles SET name = ?, content = ?, soluce = ?, verify = ?, score_max = ?, fk_chapter = ? WHERE id_puzzle = ?"),
-	GET_PUZZLE("SELECT p.*, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag WHERE p.id_puzzle = ? GROUP BY p.id_puzzle"),
-	GET_PUZZLES("SELECT p.*, GROUP_CONCAT(t.name) AS tags FROM puzzles p LEFT JOIN containsTags ct ON ct.fk_puzzle = p.id_puzzle LEFT JOIN tags t ON t.id_tag = ct.fk_tag GROUP BY p.id_puzzle"),
-	
-	ADD_TAG("INSERT INTO tags (name) VALUES (?)"),
-	DELETE_TAG("DELETE FROM tags WHERE id_tag = ?"),
-	EDIT_TAG("UPDATE tags SET name = ? WHERE id_tag = ?"),
-	GET_TAGS("SELECT * FROM tags"),
 	
 	//TRIGGER
 	FIRST_TRY("CREATE OR REPLACE TRIGGER FirstTry\r\n"

src/dev/peerat/backend/routes/BadgeDetails.java

@@ -5,6 +5,7 @@ import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Badge;
+import dev.peerat.backend.repository.DatabaseBadgeRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -15,10 +16,10 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class BadgeDetails implements Response {
 
-	private final DatabaseRepository databaseRepo;
+	private final DatabaseBadgeRepository databaseRepo;
 
 	public BadgeDetails(DatabaseRepository databaseRepo) {
-		this.databaseRepo = databaseRepo;
+		this.databaseRepo = databaseRepo.getBadgeRepository();
 	}
 	
 	@RouteDoc(path = "/badge/<id>", responseCode = 200, responseDescription = "JSON contenant les informations du badge")

src/dev/peerat/backend/routes/ChapterElement.java

@@ -6,6 +6,9 @@ import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Chapter;
 import dev.peerat.backend.model.PeerAtUser;
 import dev.peerat.backend.model.Puzzle;
+import dev.peerat.backend.repository.DatabaseChapterRepository;
+import dev.peerat.backend.repository.DatabaseCompletionRepository;
+import dev.peerat.backend.repository.DatabaseGroupRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -17,10 +20,12 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class ChapterElement implements Response {
 
-	private final DatabaseRepository databaseRepo;
+	private final DatabaseChapterRepository chapterRepo;
+	private final DatabaseCompletionRepository completionRepo;
 
-	public ChapterElement(DatabaseRepository databaseRepo) {
+	public ChapterElement(DatabaseRepository repo) {
-		this.databaseRepo = databaseRepo;
+		this.chapterRepo = repo.getChapterRepository();
+		this.completionRepo = repo.getCompletionRepository();
 	}
 
 	@RouteDoc(path = "/chapter/<id>", responseCode = 200, responseDescription = "JSON contenant les informations du chapitre demander")
@@ -28,7 +33,7 @@ public class ChapterElement implements Response {
 	
 	@Route(path = "^\\/chapter\\/([0-9]+)$", needLogin = true)
 	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		Chapter chapter = databaseRepo.getChapter(Integer.parseInt(matcher.group(1)));
+		Chapter chapter = chapterRepo.getChapter(Integer.parseInt(matcher.group(1)));
 		if (chapter != null){
 			JsonMap chapterJSON = new JsonMap();
 			chapterJSON.set("id", chapter.getId());
@@ -46,7 +51,7 @@ public class ChapterElement implements Response {
 					puzzleJSON.set("name", puzzle.getName());
 					puzzleJSON.set("scoreMax", puzzle.getScoreMax());
 					if (puzzle.getTags() != null) puzzleJSON.set("tags", puzzle.getJsonTags());
-					int score = this.databaseRepo.getScore(user.getId(), puzzle.getId());
+					int score = this.completionRepo.getScore(user.getId(), puzzle.getId());
 					if(score >= 0) puzzleJSON.set("score", score);
 					puzzleJSON.set("show", puzzle.hasStarted());
 					puzzles.add(puzzleJSON);

src/dev/peerat/backend/routes/ChapterList.java

@@ -5,6 +5,7 @@ import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Chapter;
+import dev.peerat.backend.repository.DatabaseChapterRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -16,10 +17,10 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class ChapterList implements Response {
 
-	private final DatabaseRepository databaseRepo;
+	private final DatabaseChapterRepository databaseRepo;
 
 	public ChapterList(DatabaseRepository databaseRepo) {
-		this.databaseRepo = databaseRepo;
+		this.databaseRepo = databaseRepo.getChapterRepository();
 	}
 	
 	@RouteDoc(path = "/chapters", responseCode = 200, responseDescription = "JSON contenant les informations des chapitres")

src/dev/peerat/backend/routes/EventSSE.java

@@ -0,0 +1,73 @@
+package dev.peerat.backend.routes;
+
+import dev.peerat.backend.Configuration;
+import dev.peerat.backend.model.Group;
+import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseGroupRepository;
+import dev.peerat.backend.repository.DatabaseRepository;
+import dev.peerat.framework.Context;
+import dev.peerat.framework.HttpWriter;
+import dev.peerat.framework.Injection;
+import dev.peerat.framework.Locker;
+import dev.peerat.framework.Locker.Key;
+import dev.peerat.framework.Route;
+
+public class EventSSE{
+	
+	private Locker<GroupMessage> locker;
+	private DatabaseGroupRepository repo;
+	private int eventChapter;
+	
+	public EventSSE(@Injection("groupMessages") Locker<GroupMessage> locker, DatabaseRepository repo, Configuration config){
+		this.locker = locker;
+		this.repo = repo.getGroupRepository();
+		this.eventChapter = config.getEventChapter();
+	}
+	
+	@Route(path = "^/group/event/$", needLogin = true)
+	public void connect(Context context, HttpWriter writer) throws Exception {
+		Group group = repo.getPlayerGroup(context.<PeerAtUser>getUser().getId(), this.eventChapter);
+		if(group == null){
+			context.response(401);
+			return;
+		}
+		context.response(200, "Content-Type: text/event-stream");
+		
+		Key key = new Key();
+		
+		locker.init(key);
+		try {
+			while(true){
+				GroupMessage message = locker.getValue(key);
+				if(message.getGroup() == null || message.getGroup().equals(group.getName())){
+					writer.write("data: "+message.getMessage()+"\n\n");
+					writer.flush();
+				}
+				locker.lock(key);
+			}
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+		locker.remove(key);
+	}
+
+	public static class GroupMessage{
+		
+		private String group;
+		private String message;
+		
+		public GroupMessage(String group, String message){
+			this.group = group;
+			this.message = message;
+		}
+		
+		public String getGroup(){
+			return this.group;
+		}
+		
+		public String getMessage(){
+			return this.message;
+		}
+		
+	}
+}

src/dev/peerat/backend/routes/Leaderboard.java

@@ -38,9 +38,9 @@ public class Leaderboard implements Response {
 	}
 
 	public final void groupsLeaderboard(int chapterId, HttpWriter writer) throws IOException {
-		Chapter chInfo = databaseRepo.getChapter(chapterId);
+		Chapter chInfo = databaseRepo.getChapterRepository().getChapter(chapterId);
 
-		SortedSet<Group> allGroupsForChapter = databaseRepo.getAllGroupForChapterLeaderboard(chapterId);
+		SortedSet<Group> allGroupsForChapter = databaseRepo.getLeaderboardRepository().getAllGroupForChapterLeaderboard(chapterId);
 		JsonMap leaderboardJSON = new JsonMap();
 		if (chInfo.getStartDate() != null)
 			leaderboardJSON.set("start_date", chInfo.getStartDate().toString());
@@ -69,7 +69,7 @@ public class Leaderboard implements Response {
 	}
 
 	public final void playersLeaderboard(HttpWriter writer) throws IOException {
-		SortedSet<Player> allPlayers = databaseRepo.getAllPlayerForLeaderboard();
+		SortedSet<Player> allPlayers = databaseRepo.getLeaderboardRepository().getAllPlayerForLeaderboard();
 		JsonArray playersJSON = new JsonArray();
 		if (allPlayers != null) {
 			for (Player player : allPlayers) {

src/dev/peerat/backend/routes/PlayerDetails.java

@@ -5,6 +5,7 @@ import java.util.regex.Matcher;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.PeerAtUser;
 import dev.peerat.backend.model.Player;
+import dev.peerat.backend.repository.DatabasePlayerRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -15,10 +16,10 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class PlayerDetails implements Response {
 
-	private final DatabaseRepository databaseRepo;
+	private final DatabasePlayerRepository databaseRepo;
 
 	public PlayerDetails(DatabaseRepository databaseRepo) {
-		this.databaseRepo = databaseRepo;
+		this.databaseRepo = databaseRepo.getPlayerRepository();
 	}
 	
 	@RouteDoc(path = "/player/{id}", responseCode = 200, responseDescription = "JSON contenant les informations de l'utilisateur")

src/dev/peerat/backend/routes/PuzzleElement.java

@@ -30,9 +30,9 @@ public class PuzzleElement implements Response {
 
 	@Route(path = "^\\/puzzle\\/([0-9]+)$", needLogin = true)
 	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception {
-		Puzzle puzzle = databaseRepo.getPuzzle(extractId(matcher));
+		Puzzle puzzle = databaseRepo.getPuzzleRepository().getPuzzle(extractId(matcher));
 		if (puzzle != null){
-			Chapter chapter = this.databaseRepo.getChapter(puzzle);
+			Chapter chapter = this.databaseRepo.getChapterRepository().getChapter(puzzle);
 			if(chapter.getStartDate() != null){
 				if(LocalDateTime.now().isBefore(chapter.getStartDate().toLocalDateTime())){
 					context.response(423);
@@ -54,7 +54,7 @@ public class PuzzleElement implements Response {
 			puzzleJSON.set("content", puzzle.getContent());
 			puzzleJSON.set("scoreMax", puzzle.getScoreMax());
 			if(puzzle.getTags() != null) puzzleJSON.set("tags", puzzle.getJsonTags());
-			Completion completion = this.databaseRepo.getCompletionGroup(user.getId(), puzzle.getId());
+			Completion completion = this.databaseRepo.getCompletionRepository().getCompletionGroup(user.getId(), puzzle.getId());
 			if(completion != null && completion.getScore() >= 0){
 				puzzleJSON.set("score", completion.getScore());
 				puzzleJSON.set("tries", completion.getTries());

src/dev/peerat/backend/routes/PuzzleResponse.java

@@ -11,6 +11,7 @@ import java.util.Arrays;
 import java.util.List;
 import java.util.regex.Matcher;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Chapter;
 import dev.peerat.backend.model.Completion;
@@ -34,9 +35,9 @@ public class PuzzleResponse implements Response {
 	
 	private final Locker<Completion> leaderboard;
 	
-	public PuzzleResponse(DatabaseRepository databaseRepo, @Injection("usersFiles") String initUsersFilesPath, @Injection("leaderboard") Locker<Completion> locker){
+	public PuzzleResponse(DatabaseRepository databaseRepo, Configuration config, @Injection("leaderboard") Locker<Completion> locker){
 		this.databaseRepo = databaseRepo;
-		usersFilesPath = initUsersFilesPath;
+		usersFilesPath = config.getUsersFiles();
 		this.leaderboard = locker;
 	}
 	
@@ -57,18 +58,18 @@ public class PuzzleResponse implements Response {
 		
 		//saveSourceCode(received, databaseRepo.getPlayer(user.getId()));
 		JsonMap responseJSON = new JsonMap();
-		if(this.databaseRepo.getScore(user.getId(), received.getPuzzleId()) > 0){
+		if(this.databaseRepo.getCompletionRepository().getScore(user.getId(), received.getPuzzleId()) > 0){
 			context.response(403);
 			return;
 		}
 
-		Puzzle currentPuzzle = databaseRepo.getPuzzle(received.getPuzzleId());
+		Puzzle currentPuzzle = databaseRepo.getPuzzleRepository().getPuzzle(received.getPuzzleId());
 		if(!currentPuzzle.hasStarted()){
 			context.response(423);
 			return;
 		}
 		
-		Chapter chapter = this.databaseRepo.getChapter(currentPuzzle);
+		Chapter chapter = this.databaseRepo.getChapterRepository().getChapter(currentPuzzle);
 		if(!chapter.hasStarted()){
 			context.response(423);
 			return;
@@ -85,7 +86,7 @@ public class PuzzleResponse implements Response {
 				context.response(423);
 				return;
 			}
-			Group group = this.databaseRepo.getPlayerGroup(user.getId(), chapter.getId());
+			Group group = this.databaseRepo.getGroupRepository().getPlayerGroup(user.getId(), chapter.getId());
 			if(group == null){
 				context.response(423);
 				return;
@@ -93,7 +94,7 @@ public class PuzzleResponse implements Response {
 		}
 		
 		
-		Completion completion = databaseRepo.insertOrUpdatePuzzleResponse(received.getPuzzleId(), user.getId(),
+		Completion completion = databaseRepo.getCompletionRepository().insertOrUpdatePuzzleResponse(received.getPuzzleId(), user.getId(),
 				received.getFileName(), received.getSourceCode(), received.getResponse(), currentPuzzle);
 		if(completion == null){
 			context.response(400);

src/dev/peerat/backend/routes/Result.java

@@ -4,6 +4,7 @@ import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseCompletionRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -13,10 +14,10 @@ import dev.peerat.framework.Route;
 
 public class Result implements Response {
 
-	private DatabaseRepository repo;
+	private DatabaseCompletionRepository repo;
 
 	public Result(DatabaseRepository repo) {
-		this.repo = repo;
+		this.repo = repo.getCompletionRepository();
 	}
 	
 	@RouteDoc(path = "/result/<id>", responseCode = 200, responseDescription = "Le score")

src/dev/peerat/backend/routes/Swagger.java

@@ -2,6 +2,7 @@ package dev.peerat.backend.routes;
 
 import java.util.regex.Matcher;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteExtracter;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -14,9 +15,9 @@ public class Swagger implements Response{
 	
 	private String json;
 	
-	public Swagger(RouteExtracter extracter, @Injection("issuer") String host){
+	public Swagger(RouteExtracter extracter, Configuration config){
 		try{
-			this.json = extracter.swagger(host).toString();
+//			this.json = extracter.swagger(config.getTokenIssuer()).toString();
 		}catch(Exception e){
 			e.printStackTrace();
 			json = "{}";

src/dev/peerat/backend/routes/admins/ChapterController.java

@@ -0,0 +1,70 @@
+package dev.peerat.backend.routes.admins;
+
+import static dev.peerat.framework.RequestType.DELETE;
+import static dev.peerat.framework.RequestType.POST;
+import static dev.peerat.framework.RequestType.PUT;
+
+import java.sql.Timestamp;
+import java.util.regex.Matcher;
+
+import dev.peerat.backend.model.Chapter;
+import dev.peerat.backend.repository.DatabaseAdminRepository;
+import dev.peerat.backend.repository.DatabaseRepository;
+import dev.peerat.framework.Context;
+import dev.peerat.framework.HttpReader;
+import dev.peerat.framework.HttpWriter;
+import dev.peerat.framework.Route;
+import dev.peerat.framework.utils.json.JsonMap;
+
+public class ChapterController{
+	
+	private DatabaseAdminRepository repo;
+	
+	public ChapterController(DatabaseRepository repo){
+		this.repo = repo.getAdminRepository();
+	}
+	
+	@Route(path = "^/admin/chapter/$", type = POST, needLogin = true)
+	public void add(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		JsonMap json = reader.readJson();
+		Chapter chapter = new Chapter(-1, json.get("name"), Timestamp.valueOf(json.<String>get("start")), Timestamp.valueOf(json.<String>get("end")));
+		if(repo.adminAddChapter(chapter)){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/chapter/(\\d+)$", type = DELETE, needLogin = true)
+	public void delte(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		if(this.repo.adminDeleteChapter(Integer.parseInt(matcher.group(1)))){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/chapter/(\\d+)$", type = PUT, needLogin = true)
+	public void edit(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		JsonMap json = reader.readJson();
+		Chapter chapter = new Chapter(-1, json.get("name"), Timestamp.valueOf(json.<String>get("start")), Timestamp.valueOf(json.<String>get("end")));
+		if(repo.adminUpdateChapter(Integer.parseInt(matcher.group(1)), chapter)){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/chapter/(\\d+)$", needLogin = true)
+	public void get(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		Chapter chapter = this.repo.getAdminChapter(Integer.parseInt(matcher.group(1)));
+		JsonMap json = new JsonMap();
+		json.set("name", chapter.getName());
+		json.set("start", chapter.getStartDate());
+		json.set("end", chapter.getEndDate());
+		
+		context.response(200);
+		writer.write(json.toString()+"\n");
+	}
+
+}

src/dev/peerat/backend/routes/admins/DynamicLogs.java

@@ -1,57 +0,0 @@
-package dev.peerat.backend.routes.admins;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.bonus.extract.RouteDoc;
-import dev.peerat.backend.model.Group;
-import dev.peerat.backend.model.PeerAtUser;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Injection;
-import dev.peerat.framework.Locker;
-import dev.peerat.framework.Locker.Key;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class DynamicLogs implements Response{
-	
-	private Locker<Context> locker; //Context
-	private DatabaseRepository repo;
-	
-	public DynamicLogs(@Injection("log") Locker<Context> locker,  DatabaseRepository repo){
-		this.locker = locker;
-		this.repo = repo;
-	}
-	
-	@RouteDoc(path = "/admin/logs", responseCode = 200, responseDescription = "L'utilisateur peux voir les logs en directe")
-	@RouteDoc(responseCode = 401, responseDescription = "L'utilisateur n'a pas accès à cette ressource")
-
-	@Route(path = "^/admin/logs$", needLogin = true, websocket = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		Key key = new Key();
-		
-		locker.init(key);
-		try {
-			while(!reader.isClosed()){
-				locker.lock(key);
-				Context instance = locker.getValue(key);
-				JsonMap json = new JsonMap();
-				json.set("logged", instance.isLogged());
-				if(instance.isLogged()) json.set("pseudo", repo.getPlayer(instance.<PeerAtUser>getUser().getId()).getPseudo());
-				json.set("path", instance.getPath());
-				json.set("type", instance.getType().toString());
-				json.set("code", instance.getResponseCode());
-				
-				writer.write(json.toString());
-				writer.flush();
-			}
-		}catch(Exception e){}
-		locker.remove(key);
-	}
-
-	
-	
-}

src/dev/peerat/backend/routes/admins/ExceptionLogs.java

@@ -1,49 +0,0 @@
-package dev.peerat.backend.routes.admins;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Injection;
-import dev.peerat.framework.Locker;
-import dev.peerat.framework.Locker.Key;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonArray;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class ExceptionLogs implements Response{
-	
-	private Locker<Exception> locker;
-	
-	public ExceptionLogs(@Injection("exception") Locker<Exception> locker){
-		this.locker = locker;
-	}
-	
-	@Route(path = "^/admin/exceptions$", needLogin = true, websocket = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		Key key = new Key();
-		
-		locker.init(key);
-		try {
-			while(!reader.isClosed()){
-				locker.lock(key);
-				Exception exception = locker.getValue(key);
-				JsonMap json = new JsonMap();
-				json.set("type", exception.getClass().getSimpleName());
-				json.set("message", exception.getMessage());
-				JsonArray trace = new JsonArray();
-				for(StackTraceElement element : exception.getStackTrace()) trace.add(element.toString());
-				json.set("trace", trace);
-				
-				writer.write(json.toString());
-				writer.flush();
-			}
-		}catch(Exception e){}
-		locker.remove(key);
-	}
-
-	
-	
-}

src/dev/peerat/backend/routes/admins/GroupController.java

@@ -0,0 +1,31 @@
+package dev.peerat.backend.routes.admins;
+
+import dev.peerat.backend.routes.EventSSE.GroupMessage;
+import dev.peerat.framework.Context;
+import dev.peerat.framework.HttpReader;
+import dev.peerat.framework.Injection;
+import dev.peerat.framework.Locker;
+import dev.peerat.framework.Route;
+import dev.peerat.framework.utils.json.JsonMap;
+
+public class GroupController {
+	
+	private Locker<GroupMessage> locker;
+	
+	public GroupController(@Injection("groupMessages") Locker<GroupMessage> locker){
+		this.locker = locker;
+	}
+	
+	@Route(path = "^/admin/event/$", needLogin = true)
+	public void send(Context context, HttpReader reader) throws Exception{
+		JsonMap json = reader.readJson();
+		if(!json.has("message")){
+			context.response(400);
+			return;
+		}
+		
+		locker.setValue(new GroupMessage(json.get("group"), json.get("message")));
+		context.response(200);
+	}
+
+}

src/dev/peerat/backend/routes/admins/LogController.java

@@ -0,0 +1,78 @@
+package dev.peerat.backend.routes.admins;
+
+import java.util.function.BiConsumer;
+import java.util.regex.Matcher;
+
+import dev.peerat.backend.bonus.extract.RouteDoc;
+import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseAdminRepository;
+import dev.peerat.backend.repository.DatabasePlayerRepository;
+import dev.peerat.backend.repository.DatabaseRepository;
+import dev.peerat.framework.Context;
+import dev.peerat.framework.HttpReader;
+import dev.peerat.framework.HttpWriter;
+import dev.peerat.framework.Locker;
+import dev.peerat.framework.Locker.Key;
+import dev.peerat.framework.Route;
+import dev.peerat.framework.Router;
+import dev.peerat.framework.utils.json.JsonArray;
+import dev.peerat.framework.utils.json.JsonMap;
+
+public class LogController {
+	
+	private Locker<Context> contextLocker;
+	private Locker<Throwable> exceptionLocker;
+	private DatabaseAdminRepository repo;
+	private DatabasePlayerRepository playerRepo;
+	
+	public LogController(Router<PeerAtUser> router, DatabaseRepository repo){
+		this.contextLocker = router.getLogger();
+		this.exceptionLocker = router.getExceptionLogger();
+		this.repo = repo.getAdminRepository();
+		this.playerRepo = repo.getPlayerRepository();
+	}
+	
+	@RouteDoc(path = "/admin/logs", responseCode = 200, responseDescription = "L'utilisateur peux voir les logs en directe")
+	@RouteDoc(responseCode = 401, responseDescription = "L'utilisateur n'a pas accès à cette ressource")
+
+	@Route(path = "^/admin/logs$", needLogin = true, websocket = true)
+	public void logs(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		log(reader, writer, this.contextLocker, (json, instance) -> {
+			json.set("logged", instance.isLogged());
+			if(instance.isLogged()) json.set("pseudo", playerRepo.getPlayer(instance.<PeerAtUser>getUser().getId()).getPseudo());
+			json.set("path", instance.getPath());
+			json.set("type", instance.getType().toString());
+			json.set("code", instance.getResponseCode());
+		});
+	}
+	
+	@Route(path = "^/admin/exceptions$", needLogin = true, websocket = true)
+	public void exceptions(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		log(reader, writer, this.exceptionLocker, (json, exception) -> {
+			json.set("type", exception.getClass().getSimpleName());
+			json.set("message", exception.getMessage());
+			JsonArray trace = new JsonArray();
+			for(StackTraceElement element : exception.getStackTrace()) trace.add(element.toString());
+			json.set("trace", trace);
+		});
+	}
+	
+	public <T> void log(HttpReader reader, HttpWriter writer, Locker<T> locker, BiConsumer<JsonMap, T> consumer){
+		Key key = new Key();
+		
+		locker.init(key);
+		try {
+			while(!reader.isClosed()){
+				locker.lock(key);
+				T instance  = locker.getValue(key);
+				JsonMap json = new JsonMap();
+				consumer.accept(json, instance);
+				
+				writer.write(json.toString());
+				writer.flush();
+			}
+		}catch(Exception e){}
+		locker.remove(key);
+	}
+
+}

src/dev/peerat/backend/routes/admins/PuzzleController.java

@@ -0,0 +1,89 @@
+package dev.peerat.backend.routes.admins;
+
+import static dev.peerat.framework.RequestType.DELETE;
+import static dev.peerat.framework.RequestType.POST;
+import static dev.peerat.framework.RequestType.PUT;
+
+import java.util.List;
+import java.util.regex.Matcher;
+
+import dev.peerat.backend.model.Puzzle;
+import dev.peerat.backend.repository.DatabaseAdminRepository;
+import dev.peerat.backend.repository.DatabaseRepository;
+import dev.peerat.framework.Context;
+import dev.peerat.framework.HttpReader;
+import dev.peerat.framework.HttpWriter;
+import dev.peerat.framework.Route;
+import dev.peerat.framework.utils.json.JsonArray;
+import dev.peerat.framework.utils.json.JsonMap;
+
+public class PuzzleController {
+
+	private DatabaseAdminRepository repo;
+	
+	public PuzzleController(DatabaseRepository repo){
+		this.repo = repo.getAdminRepository();
+	}
+	
+	@Route(path = "^/admin/puzzle/$", type = POST, needLogin = true)
+	public void add(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		JsonMap json = reader.readJson();
+		Puzzle puzzle = new Puzzle(-1, json.get("name"), json.get("content"), json.<String>get("soluce").getBytes(), null, json.<Long>get("scoreMax").intValue(), null, -1, null);
+		if(repo.adminAddPuzzle(puzzle, json.<Long>get("chapter").intValue())){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/puzzle/(\\d+)$", type = DELETE, needLogin = true)
+	public void delete(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		if(this.repo.adminDeletePuzzle(Integer.parseInt(matcher.group(1)))){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	
+	@Route(path = "^/admin/puzzle/(\\d+)$", type = PUT, needLogin = true)
+	public void edit(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		JsonMap json = reader.readJson();
+		Puzzle puzzle = new Puzzle(-1, json.get("name"), json.get("content"), json.<String>get("soluce").getBytes(), null, json.<Long>get("scoreMax").intValue(), null, -1, null);
+		if(repo.adminUpdatePuzzle(Integer.parseInt(matcher.group(1)), puzzle, json.<Long>get("chapter").intValue())){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/puzzle/(\\d+)$", needLogin = true)
+	public void get(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		Puzzle puzzle = this.repo.getAdminPuzzle(Integer.parseInt(matcher.group(1)));
+		JsonMap json = new JsonMap();
+		json.set("name", puzzle.getName());
+		json.set("content", puzzle.getContent());
+		json.set("soluce", new String(puzzle.getSoluce()));
+		json.set("score_max", puzzle.getScoreMax());
+		
+		context.response(200);
+		writer.write(json.toString()+"\n");
+	}
+	
+	@Route(path = "^/admin/puzzles/$", needLogin = true)
+	public void getAll(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		List<Puzzle> puzzles = repo.getAdminPuzzles();
+		JsonArray array = new JsonArray();
+		for (Puzzle puzzle : puzzles){
+			JsonMap puzzleJSON = new JsonMap();
+			puzzleJSON.set("id", puzzle.getId());
+			puzzleJSON.set("name", puzzle.getName());
+			puzzleJSON.set("scoreMax", puzzle.getScoreMax());
+			if(puzzle.getTags() != null) puzzleJSON.set("tags", puzzle.getJsonTags());
+			puzzleJSON.set("show", puzzle.hasStarted());
+			array.add(puzzleJSON);
+		}
+		context.response(200);
+		writer.write(array.toString());
+	}
+}

src/dev/peerat/backend/routes/admins/TagController.java

@@ -0,0 +1,68 @@
+package dev.peerat.backend.routes.admins;
+
+import static dev.peerat.framework.RequestType.DELETE;
+import static dev.peerat.framework.RequestType.POST;
+import static dev.peerat.framework.RequestType.PUT;
+
+import java.util.List;
+import java.util.regex.Matcher;
+
+import dev.peerat.backend.model.Tag;
+import dev.peerat.backend.repository.DatabaseAdminRepository;
+import dev.peerat.backend.repository.DatabaseRepository;
+import dev.peerat.framework.Context;
+import dev.peerat.framework.HttpReader;
+import dev.peerat.framework.HttpWriter;
+import dev.peerat.framework.Route;
+import dev.peerat.framework.utils.json.JsonArray;
+import dev.peerat.framework.utils.json.JsonMap;
+
+public class TagController {
+	
+	private DatabaseAdminRepository repo;
+	
+	public TagController(DatabaseRepository repo){
+		this.repo = repo.getAdminRepository();
+	}
+	
+	@Route(path = "^/admin/tag/$", type = POST, needLogin = true)
+	public void add(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		JsonMap json = reader.readJson();
+		if(repo.adminAddTag(json.get("name"))){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/tag/(\\d+)$", type = DELETE, needLogin = true)
+	public void delete(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		if(this.repo.adminDeleteTag(Integer.parseInt(matcher.group(1)))){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/tag/(\\d+)$", type = PUT, needLogin = true)
+	public void edit(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		JsonMap json = reader.readJson();
+		if(repo.adminUpdateTag(new Tag(Integer.parseInt(matcher.group(1)), json.get("name")))){
+			context.response(200);
+		}else{
+			context.response(501);
+		}
+	}
+	
+	@Route(path = "^/admin/tag/$", needLogin = true)
+	public void get(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
+		List<Tag> list = repo.getAdminTags();
+		JsonArray json = new JsonArray();
+		for(Tag tag : list) json.add(tag.toJson());
+		context.response(200);
+		writer.write(json.toString());
+		writer.flush();
+	}
+	
+
+}

src/dev/peerat/backend/routes/admins/chapter/AddChapter.java

@@ -1,36 +0,0 @@
-package dev.peerat.backend.routes.admins.chapter;
-
-import static dev.peerat.framework.RequestType.POST;
-
-import java.sql.Timestamp;
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Chapter;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class AddChapter implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public AddChapter(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/chapter/$", type = POST, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		JsonMap json = reader.readJson();
-		Chapter chapter = new Chapter(-1, json.get("name"), Timestamp.valueOf(json.<String>get("start")), Timestamp.valueOf(json.<String>get("end")));
-		if(repo.adminAddChapter(chapter)){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/chapter/DeleteChapter.java

@@ -1,31 +0,0 @@
-package dev.peerat.backend.routes.admins.chapter;
-
-import static dev.peerat.framework.RequestType.DELETE;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-
-public class DeleteChapter implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public DeleteChapter(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/chapter/(\\d+)$", type = DELETE, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		if(this.repo.adminDeleteChapter(Integer.parseInt(matcher.group(1)))){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/chapter/EditChapter.java

@@ -1,37 +0,0 @@
-package dev.peerat.backend.routes.admins.chapter;
-
-import static dev.peerat.framework.RequestType.PUT;
-
-import java.sql.Timestamp;
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Chapter;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class EditChapter implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public EditChapter(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/chapter/(\\d+)$", type = PUT, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		JsonMap json = reader.readJson();
-		Chapter chapter = new Chapter(-1, json.get("name"), Timestamp.valueOf(json.<String>get("start")), Timestamp.valueOf(json.<String>get("end")));
-		if(repo.adminUpdateChapter(Integer.parseInt(matcher.group(1)), chapter)){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-		
-	}
-
-}

src/dev/peerat/backend/routes/admins/chapter/GetChapter.java

@@ -1,34 +0,0 @@
-package dev.peerat.backend.routes.admins.chapter;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Chapter;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class GetChapter implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public GetChapter(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/chapter/(\\d+)$", needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		Chapter chapter = this.repo.getAdminChapter(Integer.parseInt(matcher.group(1)));
-		JsonMap json = new JsonMap();
-		json.set("name", chapter.getName());
-		json.set("start", chapter.getStartDate());
-		json.set("end", chapter.getEndDate());
-		
-		context.response(200);
-		writer.write(json.toString()+"\n");
-	}
-
-}

src/dev/peerat/backend/routes/admins/puzzle/AddPuzzle.java

@@ -1,35 +0,0 @@
-package dev.peerat.backend.routes.admins.puzzle;
-
-import static dev.peerat.framework.RequestType.POST;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Puzzle;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class AddPuzzle implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public AddPuzzle(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/puzzle/$", type = POST, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		JsonMap json = reader.readJson();
-		Puzzle puzzle = new Puzzle(-1, json.get("name"), json.get("content"), json.<String>get("soluce").getBytes(), null, json.<Long>get("scoreMax").intValue(), null, -1, null);
-		if(repo.adminAddPuzzle(puzzle, json.<Long>get("chapter").intValue())){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/puzzle/DeletePuzzle.java

@@ -1,32 +0,0 @@
-package dev.peerat.backend.routes.admins.puzzle;
-
-import static dev.peerat.framework.RequestType.DELETE;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class DeletePuzzle implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public DeletePuzzle(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/puzzle/(\\d+)$", type = DELETE, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		if(this.repo.adminDeletePuzzle(Integer.parseInt(matcher.group(1)))){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/puzzle/EditPuzzle.java

@@ -1,35 +0,0 @@
-package dev.peerat.backend.routes.admins.puzzle;
-
-import static dev.peerat.framework.RequestType.PUT;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Puzzle;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class EditPuzzle implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public EditPuzzle(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/puzzle/(\\d+)$", type = PUT, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		JsonMap json = reader.readJson();
-		Puzzle puzzle = new Puzzle(-1, json.get("name"), json.get("content"), json.<String>get("soluce").getBytes(), null, json.<Long>get("scoreMax").intValue(), null, -1, null);
-		if(repo.adminUpdatePuzzle(Integer.parseInt(matcher.group(1)), puzzle, json.<Long>get("chapter").intValue())){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/puzzle/GetPuzzle.java

@@ -1,35 +0,0 @@
-package dev.peerat.backend.routes.admins.puzzle;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Puzzle;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class GetPuzzle implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public GetPuzzle(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/puzzle/(\\d+)$", needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		Puzzle puzzle = this.repo.getAdminPuzzle(Integer.parseInt(matcher.group(1)));
-		JsonMap json = new JsonMap();
-		json.set("name", puzzle.getName());
-		json.set("content", puzzle.getContent());
-		json.set("soluce", new String(puzzle.getSoluce()));
-		json.set("score_max", puzzle.getScoreMax());
-		
-		context.response(200);
-		writer.write(json.toString()+"\n");
-	}
-
-}

src/dev/peerat/backend/routes/admins/puzzle/GetPuzzles.java

@@ -1,41 +0,0 @@
-package dev.peerat.backend.routes.admins.puzzle;
-
-import java.util.List;
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Puzzle;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonArray;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class GetPuzzles implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public GetPuzzles(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/puzzles/$", needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		List<Puzzle> puzzles = repo.getAdminPuzzles();
-		JsonArray array = new JsonArray();
-		for (Puzzle puzzle : puzzles){
-			JsonMap puzzleJSON = new JsonMap();
-			puzzleJSON.set("id", puzzle.getId());
-			puzzleJSON.set("name", puzzle.getName());
-			puzzleJSON.set("scoreMax", puzzle.getScoreMax());
-			if(puzzle.getTags() != null) puzzleJSON.set("tags", puzzle.getJsonTags());
-			puzzleJSON.set("show", puzzle.hasStarted());
-			array.add(puzzleJSON);
-		}
-		context.response(200);
-		writer.write(array.toString());
-	}
-
-}

src/dev/peerat/backend/routes/admins/tag/AddTag.java

@@ -1,33 +0,0 @@
-package dev.peerat.backend.routes.admins.tag;
-
-import static dev.peerat.framework.RequestType.POST;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class AddTag implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public AddTag(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/tag/$", type = POST, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		JsonMap json = reader.readJson();
-		if(repo.adminAddTag(json.get("name"))){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/tag/DeleteTag.java

@@ -1,31 +0,0 @@
-package dev.peerat.backend.routes.admins.tag;
-
-import static dev.peerat.framework.RequestType.DELETE;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-
-public class DeleteTag implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public DeleteTag(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/tag/(\\d+)$", type = DELETE, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		if(this.repo.adminDeleteTag(Integer.parseInt(matcher.group(1)))){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/tag/EditTag.java

@@ -1,34 +0,0 @@
-package dev.peerat.backend.routes.admins.tag;
-
-import static dev.peerat.framework.RequestType.PUT;
-
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Tag;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonMap;
-
-public class EditTag implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public EditTag(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/tag/(\\d+)$", type = PUT, needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		JsonMap json = reader.readJson();
-		if(repo.adminUpdateTag(new Tag(Integer.parseInt(matcher.group(1)), json.get("name")))){
-			context.response(200);
-		}else{
-			context.response(501);
-		}
-	}
-
-}

src/dev/peerat/backend/routes/admins/tag/GetTags.java

@@ -1,33 +0,0 @@
-package dev.peerat.backend.routes.admins.tag;
-
-import java.util.List;
-import java.util.regex.Matcher;
-
-import dev.peerat.backend.model.Tag;
-import dev.peerat.backend.repository.DatabaseRepository;
-import dev.peerat.framework.Context;
-import dev.peerat.framework.HttpReader;
-import dev.peerat.framework.HttpWriter;
-import dev.peerat.framework.Response;
-import dev.peerat.framework.Route;
-import dev.peerat.framework.utils.json.JsonArray;
-
-public class GetTags implements Response{
-	
-	private DatabaseRepository repo;
-	
-	public GetTags(DatabaseRepository repo){
-		this.repo = repo;
-	}
-	
-	@Route(path = "^/admin/tag/$", needLogin = true)
-	public void exec(Matcher matcher, Context context, HttpReader reader, HttpWriter writer) throws Exception{
-		List<Tag> list = repo.getAdminTags();
-		JsonArray json = new JsonArray();
-		for(Tag tag : list) json.add(tag.toJson());
-		context.response(200);
-		writer.write(json.toString());
-		writer.flush();
-	}
-
-}

src/dev/peerat/backend/routes/groups/GroupCreate.java

@@ -5,10 +5,13 @@ import static dev.peerat.framework.RequestType.POST;
 import java.time.LocalDateTime;
 import java.util.regex.Matcher;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Chapter;
 import dev.peerat.backend.model.Group;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseChapterRepository;
+import dev.peerat.backend.repository.DatabaseGroupRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.backend.utils.FormResponse;
 import dev.peerat.framework.Context;
@@ -16,20 +19,21 @@ import dev.peerat.framework.HttpReader;
 import dev.peerat.framework.HttpWriter;
 import dev.peerat.framework.Injection;
 import dev.peerat.framework.Locker;
-import dev.peerat.framework.Response;
 import dev.peerat.framework.Route;
 import dev.peerat.framework.utils.json.JsonMap;
 
 public class GroupCreate extends FormResponse {
 
 	private Locker<Group> locker;
-	private DatabaseRepository repo;
+	private DatabaseGroupRepository repo;
+	private DatabaseChapterRepository chapterRepo;
 	private int groupDelay;
 
-	public GroupCreate(DatabaseRepository repo, @Injection("groups") Locker<Group> locker, @Injection("groupDelay") int groupDelay){
+	public GroupCreate(DatabaseRepository repo, @Injection("groups") Locker<Group> locker, Configuration config){
-		this.repo = repo;
+		this.repo = repo.getGroupRepository();
+		this.chapterRepo = repo.getChapterRepository();
 		this.locker = locker;
-		this.groupDelay = groupDelay;
+		this.groupDelay = config.getGroupJoinMinutes();
 		
 		validator("name", "[a-zA-Z0-9&|!?{}\\[\\]%/*\\-+=:;,_#@ ]{3,100}");
 	}
@@ -55,7 +59,7 @@ public class GroupCreate extends FormResponse {
 				return;
 			}catch(NullPointerException e){
 				if(newGroup.getLinkToChapter() != null){
-					Chapter chapter = this.repo.getChapter(newGroup.getLinkToChapter());
+					Chapter chapter = this.chapterRepo.getChapter(newGroup.getLinkToChapter());
 					if(chapter.getStartDate() != null){
 						LocalDateTime start = chapter.getStartDate().toLocalDateTime().plusMinutes(this.groupDelay);
 						if(LocalDateTime.now().isAfter(start)){

src/dev/peerat/backend/routes/groups/GroupJoin.java

@@ -5,11 +5,14 @@ import static dev.peerat.framework.RequestType.POST;
 import java.time.LocalDateTime;
 import java.util.regex.Matcher;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Chapter;
 import dev.peerat.backend.model.Completion;
 import dev.peerat.backend.model.Group;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseChapterRepository;
+import dev.peerat.backend.repository.DatabaseGroupRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -21,16 +24,18 @@ import dev.peerat.framework.Route;
 
 public class GroupJoin implements Response{
 	
-	private DatabaseRepository repo;
+	private DatabaseChapterRepository chapterRepo;
+	private DatabaseGroupRepository groupRepo;
 	private int groupDelay;
 	private String waitTime;
 	
 	private final Locker<Completion> leaderboard;
 
-	public GroupJoin(DatabaseRepository repo, @Injection("groupDelay") int groupDelay, @Injection("waitTime") String waitTime, @Injection("leaderboard") Locker<Completion> locker){
+	public GroupJoin(DatabaseRepository repo, Configuration config, @Injection("leaderboard") Locker<Completion> locker){
-		this.repo = repo;
+		this.chapterRepo = repo.getChapterRepository();
-		this.groupDelay = groupDelay;
+		this.groupRepo = repo.getGroupRepository();
-		this.waitTime = waitTime;
+		this.groupDelay = config.getGroupJoinMinutes();
+		this.waitTime = config.getGroupQuitMinutes();
 		this.leaderboard = locker;
 	}
 
@@ -44,7 +49,7 @@ public class GroupJoin implements Response{
 		Group group = new Group(reader.readJson());
 		PeerAtUser user = context.getUser();
 		
-		Group userGroup = this.repo.getPlayerGroup(user.getId(), group.getLinkToChapter());
+		Group userGroup = this.groupRepo.getPlayerGroup(user.getId(), group.getLinkToChapter());
 		if(group.equals(userGroup)){
 			context.response(403);
 			return;
@@ -57,7 +62,7 @@ public class GroupJoin implements Response{
 		}
 		
 		if(group.getLinkToChapter() != null){
-			Chapter chapter = this.repo.getChapter(group.getLinkToChapter());
+			Chapter chapter = this.chapterRepo.getChapter(group.getLinkToChapter());
 			if(chapter.getStartDate() != null){
 				LocalDateTime start = chapter.getStartDate().toLocalDateTime().plusMinutes(this.groupDelay);
 				if(LocalDateTime.now().isAfter(start)){
@@ -67,7 +72,7 @@ public class GroupJoin implements Response{
 			}
 		}
 		
-		if (this.repo.insertUserInGroup(group, user)) {
+		if (this.groupRepo.insertUserInGroup(group, user)) {
 			context.response(200);
 			
 			leaderboard.setValue(new Completion(0, 0, 0, null, 0));

src/dev/peerat/backend/routes/groups/GroupList.java

@@ -4,6 +4,7 @@ import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Group;
+import dev.peerat.backend.repository.DatabaseGroupRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -14,10 +15,10 @@ import dev.peerat.framework.utils.json.JsonArray;
 
 public class GroupList implements Response {
 
-	private DatabaseRepository repo;
+	private DatabaseGroupRepository repo;
 
-	public GroupList(DatabaseRepository repo) {
+	public GroupList(DatabaseRepository repo){
-		this.repo = repo;
+		this.repo = repo.getGroupRepository();
 	}
 	
 	@RouteDoc(path = "/groups", responseCode = 200, responseDescription = "JSON avec la liste des groups")

src/dev/peerat/backend/routes/groups/GroupQuit.java

@@ -5,11 +5,14 @@ import static dev.peerat.framework.RequestType.POST;
 import java.time.LocalDateTime;
 import java.util.regex.Matcher;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.Chapter;
 import dev.peerat.backend.model.Completion;
 import dev.peerat.backend.model.Group;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseChapterRepository;
+import dev.peerat.backend.repository.DatabaseGroupRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -21,14 +24,16 @@ import dev.peerat.framework.Route;
 
 public class GroupQuit implements Response{
 	
-	private DatabaseRepository repo;
+	private DatabaseChapterRepository chapterRepo;
+	private DatabaseGroupRepository groupRepo;
 	private int groupDelay;
 	
 	private final Locker<Completion> leaderboard;
 
-	public GroupQuit(DatabaseRepository repo, @Injection("groupDelay") int groupDelay, @Injection("leaderboard") Locker<Completion> locker){
+	public GroupQuit(DatabaseRepository repo, Configuration config, @Injection("leaderboard") Locker<Completion> locker){
-		this.repo = repo;
+		this.chapterRepo = repo.getChapterRepository();
-		this.groupDelay = groupDelay;
+		this.groupRepo = repo.getGroupRepository();
+		this.groupDelay = config.getGroupJoinMinutes();
 		
 		this.leaderboard = locker;
 	}
@@ -42,14 +47,14 @@ public class GroupQuit implements Response{
 		Group group = new Group(reader.readJson());
 		PeerAtUser user = context.getUser();
 		
-		Group userGroup = this.repo.getPlayerGroup(user.getId(), group.getLinkToChapter());
+		Group userGroup = this.groupRepo.getPlayerGroup(user.getId(), group.getLinkToChapter());
 		if(!group.equals(userGroup)){
 			context.response(403);
 			return;
 		}
 		
 		if(group.getLinkToChapter() != null){
-			Chapter chapter = this.repo.getChapter(group.getLinkToChapter());
+			Chapter chapter = this.chapterRepo.getChapter(group.getLinkToChapter());
 			if(chapter.getStartDate() != null){
 				LocalDateTime start = chapter.getStartDate().toLocalDateTime().plusMinutes(this.groupDelay);
 				if(LocalDateTime.now().isAfter(start)){
@@ -59,7 +64,7 @@ public class GroupQuit implements Response{
 			}
 		}
 		
-		if (this.repo.leaveGroup(group, user)) {
+		if (this.groupRepo.leaveGroup(group, user)) {
 			context.response(200);
 			
 			leaderboard.setValue(new Completion(0, 0, 0, null, 0));

src/dev/peerat/backend/routes/users/ChangePassword.java

@@ -4,6 +4,7 @@ import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabasePlayerRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.framework.Context;
 import dev.peerat.framework.HttpReader;
@@ -15,10 +16,10 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class ChangePassword implements Response{
 	
-	private DatabaseRepository repo;
+	private DatabasePlayerRepository repo;
 	
 	public ChangePassword(DatabaseRepository repo){
-		this.repo = repo;
+		this.repo = repo.getPlayerRepository();
 	}
 	
 	@RouteDoc(path = "/user/cpw", responseCode = 200, responseDescription = "L'utilisateur a mis à jours sont mots de passe")

src/dev/peerat/backend/routes/users/ForgotPassword.java

@@ -13,6 +13,7 @@ import java.util.UUID;
 import java.util.regex.Matcher;
 
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabasePlayerRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.backend.utils.FormResponse;
 import dev.peerat.backend.utils.Mail;
@@ -26,14 +27,14 @@ import dev.peerat.framework.utils.json.JsonMap;
 public class ForgotPassword extends FormResponse{
 
 	private Router<PeerAtUser> router;
-	private DatabaseRepository repo;
+	private DatabasePlayerRepository repo;
 	private Mail mail;
 	private Map<String, String> codes;
 	private List<Random> randoms;
 	
 	public ForgotPassword(Router<PeerAtUser> router, DatabaseRepository repo, Mail mail){
 		this.router = router;
-		this.repo = repo;
+		this.repo = repo.getPlayerRepository();
 		this.mail = mail;
 		this.codes = new HashMap<>();
 		

src/dev/peerat/backend/routes/users/Login.java

@@ -6,6 +6,7 @@ import java.util.regex.Matcher;
 
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseAuthRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.backend.utils.FormResponse;
 import dev.peerat.framework.Context;
@@ -17,11 +18,11 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class Login extends FormResponse{
 
-	private DatabaseRepository databaseRepo;
+	private DatabaseAuthRepository repo;
 	private Router<PeerAtUser> router;
 
 	public Login(DatabaseRepository databaseRepo, Router<PeerAtUser> router){
-		this.databaseRepo = databaseRepo;
+		this.repo = databaseRepo.getAuthRepository();
 		this.router = router;
 	}
 	
@@ -41,7 +42,7 @@ public class Login extends FormResponse{
 			return;
 		}
 		int id;
-		if((id = databaseRepo.login(json.get("pseudo"), json.get("passwd"))) >= 0){
+		if((id = repo.login(json.get("pseudo"), json.get("passwd"))) >= 0){
 			context.response(200,
 					"Access-Control-Expose-Headers: Authorization",
 					"Authorization: Bearer " + this.router.createAuthUser(new PeerAtUser(id)));

src/dev/peerat/backend/routes/users/MailConfirmation.java

@@ -29,8 +29,10 @@ import javax.net.ssl.HttpsURLConnection;
 import org.jose4j.json.internal.json_simple.JSONAware;
 import org.jose4j.json.internal.json_simple.JSONObject;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.PeerAtUser;
+import dev.peerat.backend.repository.DatabaseAuthRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.backend.utils.FormResponse;
 import dev.peerat.backend.utils.Mail;
@@ -44,7 +46,7 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class MailConfirmation extends FormResponse{
 
-	private DatabaseRepository databaseRepo;
+	private DatabaseAuthRepository databaseRepo;
 	private Router<PeerAtUser> router;
 	private String usersFilesPath;
 	private KeyPairGenerator generator;
@@ -57,15 +59,14 @@ public class MailConfirmation extends FormResponse{
 	public MailConfirmation(
 			DatabaseRepository databaseRepo,
 			Router<PeerAtUser> router,
-			@Injection("usersFiles") String initUsersFilesPath,
+			Configuration config,
-			@Injection("gitToken") String gitToken,
 			@Injection("waitting") Map<String, String> playersWaiting,
 			Mail mail) throws NoSuchAlgorithmException{
 		
-		this.databaseRepo = databaseRepo;
+		this.databaseRepo = databaseRepo.getAuthRepository();
 		this.router = router;
-		this.usersFilesPath = initUsersFilesPath;
+		this.usersFilesPath = config.getUsersFiles();
-		this.gitToken = gitToken;
+		this.gitToken = config.getGitToken();
 		this.playersWaiting = playersWaiting;
 		this.mail = mail;
 		

src/dev/peerat/backend/routes/users/ProfileSettings.java

@@ -5,6 +5,7 @@ import java.util.regex.Matcher;
 import dev.peerat.backend.bonus.extract.RouteDoc;
 import dev.peerat.backend.model.PeerAtUser;
 import dev.peerat.backend.model.Player;
+import dev.peerat.backend.repository.DatabasePlayerRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.backend.utils.FormResponse;
 import dev.peerat.framework.Context;
@@ -16,10 +17,10 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class ProfileSettings extends FormResponse{
 	
-	private DatabaseRepository repo;
+	private DatabasePlayerRepository repo;
 	
 	public ProfileSettings(DatabaseRepository repo){
-		this.repo = repo;
+		this.repo = repo.getPlayerRepository();
 		
 		validator("pseudo", "[a-zA-Z0-9&|!?{}\\[\\]%/*\\-+=:;,_#@ ]{3,100}");
 	}

src/dev/peerat/backend/routes/users/Register.java

@@ -11,7 +11,9 @@ import java.util.Random;
 import java.util.UUID;
 import java.util.regex.Matcher;
 
+import dev.peerat.backend.Configuration;
 import dev.peerat.backend.bonus.extract.RouteDoc;
+import dev.peerat.backend.repository.DatabaseAuthRepository;
 import dev.peerat.backend.repository.DatabaseRepository;
 import dev.peerat.backend.utils.FormResponse;
 import dev.peerat.backend.utils.Mail;
@@ -24,17 +26,17 @@ import dev.peerat.framework.utils.json.JsonMap;
 
 public class Register extends FormResponse{
 
-	private DatabaseRepository databaseRepo;
+	private DatabaseAuthRepository databaseRepo;
 	private Map<String, String> playersWaiting;
 	private Mail mail;
 	private String host;
 	private List<Random> randoms;
 
-	public Register(DatabaseRepository databaseRepo, @Injection("waitting") Map<String, String> playersWaiting, Mail mail, @Injection("issuer") String host){
+	public Register(DatabaseRepository databaseRepo, @Injection("waitting") Map<String, String> playersWaiting, Mail mail, Configuration config){
-		this.databaseRepo = databaseRepo;
+		this.databaseRepo = databaseRepo.getAuthRepository();
 		this.playersWaiting = playersWaiting;
 		this.mail = mail;
-		this.host = host;
+		this.host = config.getTokenIssuer();
 		this.randoms = new ArrayList<>();
 		
 		Random random = new Random();