setup ffsaf server

src/main/java/fr/titionfire/ExampleResource.java

@@ -0,0 +1,16 @@
+package fr.titionfire;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+@Path("/hello")
+public class ExampleResource {
+
+    @GET
+    @Produces(MediaType.TEXT_PLAIN)
+    public String hello() {
+        return "Hello from RESTEasy Reactive";
+    }
+}

src/main/java/fr/titionfire/SomePage.java

@@ -0,0 +1,29 @@
+package fr.titionfire;
+
+import io.quarkus.qute.Template;
+import io.quarkus.qute.TemplateInstance;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.MediaType;
+
+import static java.util.Objects.requireNonNull;
+
+@Path("/some-page")
+public class SomePage {
+
+    private final Template page;
+
+    public SomePage(Template page) {
+        this.page = requireNonNull(page, "page is required");
+    }
+
+    @GET
+    @Produces(MediaType.TEXT_HTML)
+    public TemplateInstance get(@QueryParam("name") String name) {
+        return page.data("name", name);
+    }
+
+}

src/main/java/fr/titionfire/ffsaf/data/SafcaNamingStrategy.java

@@ -0,0 +1,37 @@
+package fr.titionfire.ffsaf.data;
+
+import org.hibernate.boot.model.naming.Identifier;
+import org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl;
+import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
+
+public class SafcaNamingStrategy extends PhysicalNamingStrategyStandardImpl {
+
+    private final static String PREFIX = "ffsaf__";
+
+    @Override
+    public Identifier toPhysicalTableName(Identifier name, JdbcEnvironment context) {
+        return new Identifier(convertToSnakeCasePrefixed(name.getText()), name.isQuoted());
+    }
+
+    @Override
+    public Identifier toPhysicalColumnName(Identifier name, JdbcEnvironment context) {
+        return new Identifier(convertToSnakeCase(name.getText()), name.isQuoted());
+    }
+
+    private String convertToSnakeCase(final String identifier) {
+        final String regex = "([a-z])([A-Z])";
+        final String replacement = "$1_$2";
+        return identifier
+                .replaceAll(regex, replacement)
+                .toLowerCase();
+    }
+
+    private String convertToSnakeCasePrefixed(final String identifier) {
+        final String regex = "([a-z])([A-Z])";
+        final String replacement = "$1_$2";
+        final String newName = identifier
+                .replaceAll(regex, replacement)
+                .toLowerCase();
+        return PREFIX + newName;
+    }
+}

src/main/java/fr/titionfire/ffsaf/data/model/ClubModel.java

@@ -0,0 +1,28 @@
+package fr.titionfire.ffsaf.data.model;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@RegisterForReflection
+
+@Entity
+@Table(name = "club")
+public class ClubModel {
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    Long id;
+
+    String name;
+
+    String country;
+
+    String shieldURL;
+}

src/main/java/fr/titionfire/ffsaf/data/model/CombModel.java

@@ -0,0 +1,40 @@
+package fr.titionfire.ffsaf.data.model;
+
+import fr.titionfire.ffsaf.utils.Categorie;
+import fr.titionfire.ffsaf.utils.Genre;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@RegisterForReflection
+
+@Entity
+@Table(name = "comb")
+public class CombModel {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    Long id;
+
+    String lname = "";
+    String fname = "";
+
+    Categorie categorie;
+
+    @ManyToOne(fetch = FetchType.EAGER)
+    @JoinColumn(name = "club", referencedColumnName = "id")
+    ClubModel club;
+
+    Genre genre;
+
+    int licence = 0;
+
+    String country = "fr";
+}

src/main/java/fr/titionfire/ffsaf/domain/entity/ClubEntity.java

@@ -0,0 +1,24 @@
+package fr.titionfire.ffsaf.domain.entity;
+
+import fr.titionfire.ffsaf.data.model.ClubModel;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+@RegisterForReflection
+public class ClubEntity {
+    private long id;
+    private String name;
+    private String country;
+    private String shieldURL;
+
+    public static ClubEntity fromModel (ClubModel model) {
+        return new ClubEntity(model.getId(), model.getName(), model.getCountry(), model.getShieldURL());
+    }
+
+    public ClubModel toModel () {
+        return new ClubModel(this.id, this.name, this.country, this.shieldURL);
+    }
+}

src/main/java/fr/titionfire/ffsaf/domain/entity/CombEntity.java

@@ -0,0 +1,38 @@
+package fr.titionfire.ffsaf.domain.entity;
+
+import fr.titionfire.ffsaf.data.model.CombModel;
+import fr.titionfire.ffsaf.utils.Categorie;
+import fr.titionfire.ffsaf.utils.Genre;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+@Data
+@AllArgsConstructor
+@RegisterForReflection
+public class CombEntity {
+    private long id;
+    private String lname = "";
+    private String fname = "";
+    private Categorie categorie;
+    private ClubEntity club;
+    private Genre genre;
+    private int licence;
+    private String country;
+
+    public static CombEntity fromModel(CombModel model) {
+        if (model == null)
+            return null;
+
+        return new CombEntity(model.getId(), model.getLname(), model.getFname(), model.getCategorie(),
+                (model.getClub() == null) ? null : ClubEntity.fromModel(model.getClub()),
+                model.getGenre(), model.getLicence(), model.getCountry());
+    }
+
+    public static String getFullName(CombModel model) {
+        return model.getFname() + " " + model.getLname();
+    }
+    public String getFullName() {
+        return this.fname + " " + this.lname;
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/Client_Thread.java

@@ -0,0 +1,229 @@
+package fr.titionfire.ffsaf.net2;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import fr.titionfire.ffsaf.utils.JsonConsumer;
+import fr.titionfire.ffsaf.utils.Pair;
+import jakarta.inject.Inject;
+import jakarta.transaction.Transactional;
+import org.jboss.logging.Logger;
+import org.quartz.*;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PublicKey;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.UUID;
+
+public class Client_Thread extends Thread {
+    private static final Logger LOGGER = Logger.getLogger(Client_Thread.class);
+
+    public static final ObjectMapper MAPPER = new ObjectMapper();
+
+    private final Socket s;
+    private final OutputStreamWriter dos;
+    private final BufferedReader br;
+
+    public final ServerCustom serv;
+
+    private boolean isAuth;
+
+    private final HashMap<UUID, JsonConsumer<Object>> waitResult = new HashMap<>();
+
+    public Client_Thread(ServerCustom serv, Socket s, PublicKey publicKey) throws IOException {
+        this.serv = serv;
+        this.s = s;
+        this.isAuth = false;
+
+        dos = new OutputStreamWriter(s.getOutputStream(), StandardCharsets.UTF_8); // to send data to the client
+        br = new BufferedReader(new InputStreamReader(s.getInputStream(), StandardCharsets.UTF_8)); // to read data
+        // coming from the client
+        LOGGER.infof("Connection established to %s", s.getInetAddress().getHostAddress());
+
+        String auth_code = UUID.randomUUID() + "-" + UUID.randomUUID();
+        JsonConsumer<Object> consumer = new JsonConsumer<>(Object.class, t -> {
+            if (t.equals(auth_code)) {
+                isAuth = true;
+                LOGGER.infof("Client %s is auth", s.getInetAddress().getHostAddress());
+            } else {
+                LOGGER.warnf("Client %s is not auth", s.getInetAddress().getHostAddress());
+                stopSoket();
+            }
+        });
+
+        try {
+            Cipher cipher = Cipher.getInstance("RSA");
+            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
+
+            byte[] bytes = cipher.doFinal(auth_code.getBytes(StandardCharsets.UTF_8));
+            sendReq(new String(Base64.getEncoder().encode(bytes)), "auth", consumer);
+        } catch (NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException | InvalidKeyException e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    @Override
+    public void run() {
+        while (!s.isClosed()) {
+            String jsonmessage;
+            // read from client
+            try {
+                if ((jsonmessage = br.readLine()) != null) {
+                    jsonmessage = jsonmessage.replace('¤', '\n');
+                    process_message(jsonmessage);
+                } else {
+                    s.close();
+                }
+            } catch (IOException e) {
+                if (e.getMessage().equals("Stream closed") || e.getMessage().equals("Connection reset")) {
+                    break;
+                }
+                LOGGER.error(e.getMessage(), e);
+            }
+        }
+
+        serv.onCloseClient(this);
+
+        // close connection
+        try {
+            dos.close();
+            br.close();
+            LOGGER.infof("Connection closed for %s", s.getInetAddress().getHostAddress());
+        } catch (IOException e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    private void process_message(String jsonmessage) {
+        try {
+            JsonNode node = MAPPER.readTree(jsonmessage);
+            if (node.has("uuid") && node.has("code") && node.has("type")) {
+                Message<JsonNode> message = new Message<>(UUID.fromString(node.get("uuid").asText()),
+                        node.get("code").asText(), MessageType.valueOf(node.get("type").asText()),
+                        (node.has("data")) ? node.get("data") : null);
+
+                LOGGER.debugf("Message Received of %s: %s", s.getInetAddress().getHostAddress(), message);
+
+                if (message.type() == MessageType.REQUEST || message.type() == MessageType.NOTIFY) {
+                    if (serv.iMap.containsKey(message.code())) {
+                        if (isAuth) {
+                            UUID uuid = UUID.randomUUID();
+                            serv.jobData.put(uuid, new Pair<>(this, message));
+
+                            JobKey jobKey = JobKey.jobKey(uuid.toString(), "client-request");
+                            JobDetail job = JobBuilder.newJob(CallSyncJob.class)
+                                    .usingJobData("uuid", uuid.toString())
+                                    .storeDurably(true)
+                                    .withIdentity(jobKey)
+                                    .build();
+                            serv.quartz.addJob(job, true);
+                            serv.quartz.triggerJob(jobKey);
+                        }
+                    } else {
+                        this.sendErr("No receiver found", message.code(), message.uuid());
+                        LOGGER.warnf("No receiver found for %s", message.code());
+                    }
+                } else {
+                    if (waitResult.containsKey(message.uuid())) {
+                        if (waitResult.get(message.uuid()) != null)
+                            waitResult.get(message.uuid()).castAndAccept(message.data());
+
+                        waitResult.remove(message.uuid());
+                    } else {
+                        LOGGER.warnf("No waiting message found for %s", message.uuid());
+                    }
+                }
+            } else {
+                LOGGER.debugf("Message format incorrect: %s", jsonmessage);
+            }
+        } catch (Exception e) {
+            LOGGER.debug(jsonmessage);
+            LOGGER.error(e.getMessage(), e);
+        }
+    }
+
+    public void sendNotify(Object object, String type) {
+        sendMessage(new Message<>(UUID.randomUUID(), type, MessageType.NOTIFY, object));
+    }
+
+    public void sendReq(Object object, String type) {
+        sendReq(object, type, null);
+    }
+
+    public void sendReq(Object object, String code, JsonConsumer<Object> consumer) {
+        UUID uuid;
+        do {
+            uuid = UUID.randomUUID();
+        } while (waitResult.containsKey(uuid));
+        waitResult.put(uuid, consumer);
+
+        sendMessage(new Message<>(uuid, code, MessageType.REQUEST, object));
+    }
+
+    public void sendRepTo(Object object, Message<?> in) {
+        sendMessage(new Message<>(in.uuid(), in.code(), MessageType.REPLY, object));
+    }
+
+    public void sendErr(String msg, String type, UUID uuid) {
+        sendMessage(new Message<>(uuid, type, MessageType.ERROR, msg));
+    }
+
+    public void sendErrTo(String msg, Message<?> in) {
+        sendMessage(new Message<>(in.uuid(), in.code(), MessageType.ERROR, msg));
+    }
+
+    public void sendMessage(Message<?> message) {
+        try {
+            synchronized (dos) {
+                dos.write(MAPPER.writeValueAsString(message).replace('¤', ' ').replace('\n', '¤') + '\n');
+                dos.flush();
+            }
+        } catch (IOException e) {
+            LOGGER.error(e.getMessage(), e);
+        }
+        LOGGER.tracef("Send message type: %s, code: %s, uuid: %s, to: %s", message.type(), message.code(),
+                message.uuid(), s.getInetAddress().getHostAddress());
+    }
+
+    public void stopSoket() {
+        try {
+            s.close();
+        } catch (IOException ignored) {
+        }
+    }
+
+    public static class CallSyncJob implements Job {
+        @Inject
+        ServerCustom socket;
+
+        @Transactional
+        public void execute(JobExecutionContext context) {
+            UUID uuid = UUID.fromString(context.getMergedJobDataMap().getString("uuid"));
+            Pair<Client_Thread, Message<JsonNode>> pair = socket.jobData.get(uuid);
+
+            if (pair != null) {
+                try {
+                    socket.iMap.get(pair.getValue().code()).castAndCall(pair.getKey(), pair.getValue());
+                } catch (JsonProcessingException e) {
+                    LOGGER.error(e.getMessage(), e);
+                }
+
+                socket.jobData.remove(uuid);
+            } else {
+                LOGGER.errorf("no get found %d", socket.jobData.size());
+            }
+        }
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/Message.java

@@ -0,0 +1,19 @@
+package fr.titionfire.ffsaf.net2;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.UUID;
+
+@RegisterForReflection
+public record Message<T> (UUID uuid, String code, MessageType type, T data){
+
+    @Override
+    public String toString() {
+        return "Message{" +
+                "uuid=" + uuid +
+                ", code='" + code + '\'' +
+                ", type=" + type +
+                ", data=" + data +
+                '}';
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/MessageType.java

@@ -0,0 +1,5 @@
+package fr.titionfire.ffsaf.net2;
+
+public enum MessageType {
+    REQUEST, REPLY, ERROR, NOTIFY
+}

src/main/java/fr/titionfire/ffsaf/net2/ServerCustom.java

@@ -0,0 +1,148 @@
+package fr.titionfire.ffsaf.net2;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import fr.titionfire.ffsaf.net2.packet.IAction;
+import fr.titionfire.ffsaf.net2.packet.RegisterAction;
+import fr.titionfire.ffsaf.utils.Pair;
+import io.quarkus.runtime.ShutdownEvent;
+import io.quarkus.runtime.StartupEvent;
+import jakarta.enterprise.event.Observes;
+import jakarta.inject.Singleton;
+import org.eclipse.microprofile.config.inject.ConfigProperty;
+import org.jboss.logging.Logger;
+import org.quartz.Scheduler;
+
+import javax.net.ssl.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.Socket;
+import java.security.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Stream;
+
+import jakarta.inject.Inject;
+
+@Singleton
+public class ServerCustom extends Thread {
+    private static final Logger LOGGER = Logger.getLogger("SocketServer");
+
+    protected ConcurrentHashMap<UUID, Pair<Client_Thread, Message<JsonNode>>> jobData = new ConcurrentHashMap<>();
+    protected HashMap<String, IAction> iMap = new HashMap<>();
+    public final ArrayList<Client_Thread> clients = new ArrayList<>();
+
+    private SSLServerSocket server;
+    private boolean run;
+
+    @ConfigProperty(name = "internal-port")
+    int port;
+
+    @ConfigProperty(name = "certificate_password")
+    String certificate_password;
+
+    @ConfigProperty(name = "certificate_file")
+    String certificate_file;
+
+    @Inject
+    protected Scheduler quartz;
+
+    private PublicKey publicKey;
+
+    private X509TrustManager tm(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException {
+        TrustManagerFactory trustMgrFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        trustMgrFactory.init(keystore);
+        TrustManager[] trustManagers = trustMgrFactory.getTrustManagers();
+        for (TrustManager trustManager : trustManagers) {
+            if (trustManager instanceof X509TrustManager) {
+                return (X509TrustManager) trustManager;
+            }
+        }
+        return null;
+    }
+
+    private X509KeyManager km(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException, UnrecoverableKeyException {
+        KeyManagerFactory keyMgrFactory = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm());
+        keyMgrFactory.init(keystore, certificate_password.toCharArray());
+        KeyManager[] keyManagers = keyMgrFactory.getKeyManagers();
+        for (KeyManager keyManager : keyManagers) {
+            if (keyManager instanceof X509KeyManager) {
+                return (X509KeyManager) keyManager;
+            }
+        }
+        return null;
+    }
+
+    private SSLServerSocket getServerSocketWithCert(int port, InputStream pathToCert) throws Exception {
+        TrustManager[] tmm = new TrustManager[1];
+        KeyManager[] kmm = new KeyManager[1];
+
+        KeyStore ks = KeyStore.getInstance("JKS");
+        ks.load(pathToCert, certificate_password.toCharArray());
+        tmm[0] = tm(ks);
+        kmm[0] = km(ks);
+
+        SSLContext ctx = SSLContext.getInstance("TLSv1.2");
+        ctx.init(kmm, tmm, null);
+
+        publicKey = ks.getCertificate("ffsaf").getPublicKey();
+
+        SSLServerSocketFactory socketFactory = ctx.getServerSocketFactory();
+        return (SSLServerSocket) socketFactory.createServerSocket(port);
+    }
+
+    @Override
+    public void run() {
+        try {
+            this.run = true;
+            this.server = getServerSocketWithCert(this.port, new FileInputStream(new File(this.certificate_file)));
+            RegisterAction.register(iMap);
+            LOGGER.info("Starting socket server!!");
+            while (this.run) {
+                Socket socket = this.server.accept();
+                Client_Thread cThread = new Client_Thread(this, socket, publicKey);
+                synchronized (clients) {
+                    this.clients.add(cThread);
+                }
+                cThread.start();
+            }
+            LOGGER.info("Shutting down Socket server!!");
+        } catch (Exception e) {
+            LOGGER.info("Server start failed! (" + e.getMessage() + ")");
+            this.interrupt();
+        }
+    }
+
+    public void onCloseClient(Client_Thread cThread) {
+        synchronized (clients) {
+            clients.remove(cThread);
+        }
+    }
+
+    public void stop2() {
+        this.run = false;
+
+        try {
+            this.server.close();
+            clients.forEach(Client_Thread::stopSoket);
+        } catch (IOException ignored) {
+        }
+    }
+
+    void onStart(@Observes StartupEvent ev) {
+        LOGGER.info("The server is starting...");
+        this.start();
+    }
+
+    void onStop(@Observes ShutdownEvent ev) {
+        LOGGER.info("The server is stopping...");
+        this.stop2();
+    }
+
+    public Stream<Client_Thread> get_clients() {
+        return clients.stream();
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/packet/CIA.java

@@ -0,0 +1,25 @@
+package fr.titionfire.ffsaf.net2.packet;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import fr.titionfire.ffsaf.net2.Client_Thread;
+import fr.titionfire.ffsaf.net2.Message;
+
+import java.util.function.BiConsumer;
+
+import static fr.titionfire.ffsaf.net2.Client_Thread.MAPPER;
+
+public class CIA<T> implements IAction{
+    private final Class<T> clazz;
+    private final BiConsumer<Client_Thread, Message<T>> iAction;
+
+    public CIA(Class<T> clazz, BiConsumer<Client_Thread, Message<T>> iAction){
+        this.clazz = clazz;
+        this.iAction = iAction;
+    }
+
+    @Override
+    public void dataIn(Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException {
+        iAction.accept(client_Thread, new Message<>(message.uuid(), message.code(), message.type(), MAPPER.treeToValue(message.data(), clazz)));
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/packet/IAction.java

@@ -0,0 +1,14 @@
+package fr.titionfire.ffsaf.net2.packet;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.JsonNode;
+import fr.titionfire.ffsaf.net2.Client_Thread;
+import fr.titionfire.ffsaf.net2.Message;
+
+public interface IAction {
+    void dataIn(Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException;
+
+    default void castAndCall (Client_Thread client_Thread, Message<JsonNode> message) throws JsonProcessingException {
+        this.dataIn(client_Thread, message);
+    }
+}

src/main/java/fr/titionfire/ffsaf/net2/packet/RegisterAction.java

@@ -0,0 +1,11 @@
+package fr.titionfire.ffsaf.net2.packet;
+
+import java.util.HashMap;
+
+public class RegisterAction {
+
+	public static void register(HashMap<String, IAction> iMap) {
+		iMap.clear();
+
+	}
+}

src/main/java/fr/titionfire/ffsaf/utils/Categorie.java

@@ -0,0 +1,33 @@
+package fr.titionfire.ffsaf.utils;
+
+import java.util.ResourceBundle;
+
+public enum Categorie {
+    SUPER_MINI,
+    MINI_POUSSIN,
+    POUSSIN,
+    BENJAMIN,
+    MINIME,
+    CADET,
+    JUNIOR,
+    SENIOR1,
+    SENIOR2,
+    VETERAN1,
+    VETERAN2;
+
+    public String getName(ResourceBundle BUNDLE) {
+        return switch (this){
+            case SUPER_MINI -> BUNDLE.getString("Cat.SUPER_MINI");
+            case MINI_POUSSIN -> BUNDLE.getString("Cat.MINI_POUSSIN");
+            case POUSSIN -> BUNDLE.getString("Cat.POUSSIN");
+            case BENJAMIN -> BUNDLE.getString("Cat.BENJAMIN");
+            case MINIME -> BUNDLE.getString("Cat.MINIME");
+            case CADET -> BUNDLE.getString("Cat.CADET");
+            case JUNIOR -> BUNDLE.getString("Cat.JUNIOR");
+            case SENIOR1 -> BUNDLE.getString("Cat.SENIOR1");
+            case SENIOR2 -> BUNDLE.getString("Cat.SENIOR2");
+            case VETERAN1 -> BUNDLE.getString("Cat.VETERAN1");
+            case VETERAN2 -> BUNDLE.getString("Cat.VETERAN2");
+        };
+    }
+}

src/main/java/fr/titionfire/ffsaf/utils/Genre.java

@@ -0,0 +1,5 @@
+package fr.titionfire.ffsaf.utils;
+
+public enum Genre {
+    H, F
+}

src/main/java/fr/titionfire/ffsaf/utils/JsonConsumer.java

@@ -0,0 +1,28 @@
+package fr.titionfire.ffsaf.utils;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.TreeNode;
+
+import java.util.function.Consumer;
+
+import static fr.titionfire.ffsaf.net2.Client_Thread.MAPPER;
+
+public class JsonConsumer<T> implements Consumer<T> {
+
+    private final Class<T> clazz;
+    private final Consumer<T> consumer;
+
+    public JsonConsumer(Class<T> clazz, Consumer<T> consumer){
+        this.clazz = clazz;
+        this.consumer = consumer;
+    }
+
+    public void castAndAccept (TreeNode message) throws JsonProcessingException {
+        this.accept(MAPPER.treeToValue(message, clazz));
+    }
+
+    @Override
+    public void accept(T t) {
+        consumer.accept(t);
+    }
+}

src/main/java/fr/titionfire/ffsaf/utils/Pair.java

@@ -0,0 +1,15 @@
+package fr.titionfire.ffsaf.utils;
+
+import io.quarkus.runtime.annotations.RegisterForReflection;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@RegisterForReflection
+public class Pair<K, V> {
+    private K key;
+    private V value;
+}