feat: external website result connector

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

@@ -66,4 +66,13 @@ public class RegisterModel {
             return membre.club;
         return club;
     }
+
+    public Categorie getCategorie2() {
+        Categorie tmp = this.categorie;
+        if (tmp == null)
+            tmp = membre.getCategorie();
+        if (tmp == null)
+            return null;
+        return Categorie.values()[Math.min(tmp.ordinal() + this.overCategory, Categorie.values().length - 1)];
+    }
 }

src/main/java/fr/titionfire/ffsaf/domain/service/ResultService.java

@@ -1,10 +1,7 @@
 package fr.titionfire.ffsaf.domain.service;
 
 import fr.titionfire.ffsaf.data.model.*;
-import fr.titionfire.ffsaf.data.repository.CategoryRepository;
-import fr.titionfire.ffsaf.data.repository.CompetitionRepository;
-import fr.titionfire.ffsaf.data.repository.MatchRepository;
-import fr.titionfire.ffsaf.data.repository.RegisterRepository;
+import fr.titionfire.ffsaf.data.repository.*;
 import fr.titionfire.ffsaf.rest.data.ResultCategoryData;
 import fr.titionfire.ffsaf.rest.exception.DForbiddenException;
 import fr.titionfire.ffsaf.utils.*;
@@ -19,7 +16,9 @@ import lombok.Builder;
 import org.hibernate.reactive.mutiny.Mutiny;
 
 import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 import java.util.stream.Stream;
 
 @WithSession
@@ -35,6 +34,12 @@ public class ResultService {
     @Inject
     MembreService membreService;
 
+    @Inject
+    ClubRepository clubRepository;
+
+    @Inject
+    CompetitionGuestRepository competitionGuestRepository;
+
     @Inject
     CategoryRepository categoryRepository;
 
@@ -53,10 +58,22 @@ public class ResultService {
                 .collect().asList();
     }
 
+    public Uni<HashMap<String, Long>> getCategoryList(String uuid) {
+        return categoryRepository.list("compet.uuid = ?1", uuid)
+                .map(categoryModels -> {
+                    HashMap<String, Long> map = new HashMap<>();
+                    categoryModels.stream()
+                            .sorted(Comparator.comparing(CategoryModel::getName))
+                            .forEachOrdered(categoryModel -> map.put(categoryModel.getName(), categoryModel.getId()));
+                    return map;
+                });
+    }
+
     public Uni<List<ResultCategoryData>> getCategory(String uuid, SecurityCtx securityCtx) {
         return hasAccess(uuid, securityCtx)
                 .chain(m -> categoryRepository.list("compet.uuid = ?1", uuid)
-                        .chain(cats -> matchRepository.list("(c1_id = ?1 OR c2_id = ?1 OR True) AND category IN ?2", //TODO rm OR True
+                        .chain(cats -> matchRepository.list(
+                                "(c1_id = ?1 OR c2_id = ?1 OR True) AND category IN ?2", //TODO rm OR True
                                 m.getMembre(), cats)))
                 .map(matchModels -> {
                     HashMap<Long, List<MatchModel>> map = new HashMap<>();
@@ -82,6 +99,8 @@ public class ResultService {
         CategoryModel categoryModel = matchModels.get(0).getCategory();
         out.setName(categoryModel.getName());
         out.setType(categoryModel.getType());
+        out.setLiceName(categoryModel.getLiceName() == null ? new String[]{} : categoryModel.getLiceName().split(";"));
+        out.setGenTime(System.currentTimeMillis());
 
         getArray2(matchModels, out);
         getTree(categoryModel.getTree(), out);
@@ -173,6 +192,12 @@ public class ResultService {
         }
     }
 
+    public Uni<ResultCategoryData> getCategoryPublic(String uuid, long poule) {
+        return matchRepository.list("category.compet.uuid = ?1 AND category.id = ?2", uuid, poule)
+                .call(list -> Mutiny.fetch(list.get(0).getCategory().getTree()))
+                .map(this::getData);
+    }
+
     private void getTree(List<TreeModel> treeModels, ResultCategoryData out) {
         ArrayList<TreeNode<ResultCategoryData.TreeData>> trees = new ArrayList<>();
         treeModels.stream().filter(t -> t.getLevel() != 0).forEach(treeModel -> {
@@ -185,87 +210,230 @@ public class ResultService {
 
     public Uni<CombsArrayData> getAllCombArray(String uuid, SecurityCtx securityCtx) {
         return hasAccess(uuid, securityCtx)
-                .chain(cm_register -> registerRepository.list("competition.uuid = ?1", uuid)
-                        .chain(registers -> matchRepository.list("category.compet.uuid = ?1", uuid)
-                                .map(matchModels -> new Pair<>(registers, matchModels)))
-                        .map(pair -> {
-                            List<RegisterModel> registers = pair.getKey();
-                            List<MatchModel> matchModels = pair.getValue();
+                .chain(__ -> getAllCombArray(uuid));
+    }
 
-                            CombsArrayData.CombsArrayDataBuilder builder = CombsArrayData.builder();
+    public Uni<CombsArrayData> getAllCombArrayPublic(String uuid) {
+        return getAllCombArray(uuid);
+    }
 
-                            List<CombsArrayData.CombsData> combs = matchModels.stream()
-                                    .flatMap(m -> Stream.of(m.getC1Name(), m.getC2Name()))
-                                    .filter(Objects::nonNull)
-                                    .distinct()
-                                    .map(combName -> {
-                                        var builder2 = CombsArrayData.CombsData.builder();
-                                        AtomicInteger w = new AtomicInteger(0);
-                                        AtomicInteger l = new AtomicInteger(0);
-                                        AtomicInteger pointMake = new AtomicInteger();
-                                        AtomicInteger pointTake = new AtomicInteger();
+    public Uni<CombsArrayData> getAllCombArray(String uuid) {
+        return registerRepository.list("competition.uuid = ?1", uuid)
+                .chain(registers -> matchRepository.list("category.compet.uuid = ?1", uuid)
+                        .map(matchModels -> new Pair<>(registers, matchModels)))
+                .map(pair -> {
+                    List<RegisterModel> registers = pair.getKey();
+                    List<MatchModel> matchModels = pair.getValue();
 
-                                        matchModels.stream()
-                                                .filter(m -> m.isEnd() && (m.getC1Name().equals(combName)
-                                                        || m.getC2Name().equals(combName)))
-                                                .forEach(matchModel -> {
-                                                    int win = matchModel.win();
-                                                    if ((combName.equals(matchModel.getC1Name()) && win > 0) ||
-                                                            combName.equals(matchModel.getC2Name()) && win < 0) {
-                                                        w.getAndIncrement();
-                                                    } else {
-                                                        l.getAndIncrement();
-                                                    }
+                    CombsArrayData.CombsArrayDataBuilder builder = CombsArrayData.builder();
 
-                                                    matchModel.getScores().stream()
-                                                            .filter(s -> s.getS1() > -900 && s.getS2() > -900)
-                                                            .forEach(score -> {
-                                                                if (combName.equals(matchModel.getC1Name())) {
-                                                                    pointMake.addAndGet(score.getS1());
-                                                                    pointTake.addAndGet(score.getS2());
-                                                                } else {
-                                                                    pointMake.addAndGet(score.getS2());
-                                                                    pointTake.addAndGet(score.getS1());
-                                                                }
-                                                            });
-                                                });
+                    List<CombsArrayData.CombsData> combs = matchModels.stream()
+                            .flatMap(m -> Stream.of(m.getC1Name(), m.getC2Name()))
+                            .filter(Objects::nonNull)
+                            .distinct()
+                            .map(combName -> {
+                                var builder2 = CombsArrayData.CombsData.builder();
+                                AtomicInteger w = new AtomicInteger(0);
+                                AtomicInteger l = new AtomicInteger(0);
+                                AtomicInteger pointMake = new AtomicInteger();
+                                AtomicInteger pointTake = new AtomicInteger();
 
-                                        Categorie categorie = null;
-                                        ClubModel club = null;
+                                matchModels.stream()
+                                        .filter(m -> m.isEnd() && (m.getC1Name().equals(combName)
+                                                || m.getC2Name().equals(combName)))
+                                        .forEach(matchModel -> {
+                                            int win = matchModel.win();
+                                            if ((combName.equals(matchModel.getC1Name()) && win > 0) ||
+                                                    combName.equals(matchModel.getC2Name()) && win < 0) {
+                                                w.getAndIncrement();
+                                            } else {
+                                                l.getAndIncrement();
+                                            }
 
-                                        Optional<RegisterModel> register = registers.stream()
-                                                .filter(r -> r.getName().equals(combName)).findFirst();
-                                        if (register.isPresent()) {
-                                            categorie = register.get().getCategorie();
-                                            club = register.get().getClub2();
-                                        }
+                                            matchModel.getScores().stream()
+                                                    .filter(s -> s.getS1() > -900 && s.getS2() > -900)
+                                                    .forEach(score -> {
+                                                        if (combName.equals(matchModel.getC1Name())) {
+                                                            pointMake.addAndGet(score.getS1());
+                                                            pointTake.addAndGet(score.getS2());
+                                                        } else {
+                                                            pointMake.addAndGet(score.getS2());
+                                                            pointTake.addAndGet(score.getS1());
+                                                        }
+                                                    });
+                                        });
 
-                                        builder2.cat((categorie == null) ? "---" : categorie.getName(BUNDLE));
-                                        builder2.name(combName);
-                                        builder2.w(w.get());
-                                        builder2.l(l.get());
-                                        builder2.ratioVictoire((l.get() == 0) ? w.get() : (float) w.get() / l.get());
-                                        builder2.club((club == null) ? BUNDLE.getString("no.licence") : club.getName());
-                                        builder2.pointMake(pointMake.get());
-                                        builder2.pointTake(pointTake.get());
-                                        builder2.ratioPoint(
-                                                (pointTake.get() == 0) ? pointMake.get() : (float) pointMake.get() / pointTake.get());
+                                Categorie categorie = null;
+                                ClubModel club = null;
 
-                                        return builder2.build();
-                                    })
-                                    .sorted(Comparator.comparing(CombsArrayData.CombsData::name))
-                                    .toList();
+                                Optional<RegisterModel> register = registers.stream()
+                                        .filter(r -> r.getName().equals(combName)).findFirst();
+                                if (register.isPresent()) {
+                                    categorie = register.get().getCategorie();
+                                    club = register.get().getClub2();
+                                }
 
-                            builder.nb_insc(combs.size());
-                            builder.tt_match((int) matchModels.stream().filter(MatchModel::isEnd).count());
-                            builder.point(combs.stream().mapToInt(CombsArrayData.CombsData::pointMake).sum());
-                            builder.combs(combs);
+                                builder2.cat((categorie == null) ? "---" : categorie.getName(BUNDLE));
+                                builder2.name(combName);
+                                builder2.w(w.get());
+                                builder2.l(l.get());
+                                builder2.ratioVictoire((l.get() == 0) ? w.get() : (float) w.get() / l.get());
+                                builder2.club((club == null) ? BUNDLE.getString("no.licence") : club.getName());
+                                builder2.pointMake(pointMake.get());
+                                builder2.pointTake(pointTake.get());
+                                builder2.ratioPoint(
+                                        (pointTake.get() == 0) ? pointMake.get() : (float) pointMake.get() / pointTake.get());
 
-                            return builder.build();
+                                return builder2.build();
+                            })
+                            .sorted(Comparator.comparing(CombsArrayData.CombsData::name))
+                            .toList();
+
+                    builder.nb_insc(combs.size());
+                    builder.tt_match((int) matchModels.stream().filter(MatchModel::isEnd).count());
+                    builder.point(combs.stream().mapToInt(CombsArrayData.CombsData::pointMake).sum());
+                    builder.combs(combs);
+
+                    return builder.build();
+                });
+    }
+
+    public Uni<HashMap<String, String>> getCombList(String uuid) {
+        return registerRepository.list("competition.uuid = ?1", uuid)
+                .map(models -> {
+                    HashMap<String, String> map = new HashMap<>();
+                    models.forEach(registerEmbeddable -> {
+                        map.put(Utils.getFullName(registerEmbeddable.getMembre()),
+                                registerEmbeddable.getMembre().getFname() + "¤" + registerEmbeddable.getMembre()
+                                        .getLname());
+                    });
+                    return map;
+                })
+                .chain(map -> competitionGuestRepository.list("competition.uuid = ?1", uuid)
+                        .map(models -> {
+                            models.forEach(guestModel -> map.put(Utils.getFullName(guestModel),
+                                    guestModel.getFname() + "¤" + guestModel.getLname()));
+                            return map;
                         })
                 );
     }
 
+    public Uni<?> getCombArrayPublic(String uuid, String fname, String lname) {
+        CombArrayData.CombArrayDataBuilder builder = CombArrayData.builder();
+        AtomicBoolean guest = new AtomicBoolean(false);
+        AtomicLong id = new AtomicLong(0);
+
+
+        return registerRepository.find("membre.fname = ?1 AND membre.lname = ?2 AND competition.uuid = ?3", fname,
+                        lname, uuid).firstResult()
+                .chain(registerModel -> {
+                    if (registerModel == null) {
+                        return competitionGuestRepository.find("fname = ?1 AND lname = ?2 AND competition.uuid = ?3",
+                                        fname, lname, uuid).firstResult()
+                                .chain(guestModel -> {
+                                    builder.name(Utils.getFullName(guestModel));
+                                    builder.club(guestModel.getClub());
+                                    guest.set(true);
+                                    id.set(guestModel.getId());
+                                    builder.cat((guestModel.getCategorie() == null) ? "---" : guestModel.getCategorie()
+                                            .getName(BUNDLE));
+
+                                    return matchRepository.list(
+                                            "category.compet.uuid = ?1 AND (c1_guest = ?2 OR c2_guest = ?2)", uuid,
+                                            guestModel);
+                                });
+                    }
+                    builder.name(Utils.getFullName(registerModel.getMembre()));
+                    builder.club((registerModel.getClub2() == null) ? BUNDLE.getString(
+                            "no.licence") : registerModel.getClub2().getName());
+                    id.set(registerModel.getMembre().getId());
+                    builder.cat((registerModel.getCategorie2() == null) ? "---" : registerModel.getCategorie2()
+                            .getName(BUNDLE));
+
+                    return matchRepository.list("category.compet.uuid = ?1 AND (c1_id = ?2 OR c2_id = ?2)", uuid,
+                            registerModel.getMembre());
+                })
+                .invoke(matchModels -> {
+                    List<CategoryModel> pouleModels = matchModels.stream().map(MatchModel::getCategory).distinct()
+                            .toList();
+                    List<CombArrayData.MatchsData> matchs = new ArrayList<>();
+
+                    AtomicInteger sumW = new AtomicInteger();
+                    AtomicInteger sumPointMake = new AtomicInteger(0);
+                    AtomicInteger sumPointTake = new AtomicInteger(0);
+
+                    for (MatchModel matchModel : matchModels) {
+                        if ((matchModel.getC1_id() == null && matchModel.getC1_guest() == null) ||
+                                (matchModel.getC2_id() == null && matchModel.getC2_guest() == null))
+                            continue;
+
+                        var builder2 = CombArrayData.MatchsData.builder();
+                        builder2.date(matchModel.getDate());
+                        builder2.poule(pouleModels.stream().filter(p -> p.equals(matchModel.getCategory()))
+                                .map(CategoryModel::getName).findFirst().orElse(""));
+
+                        AtomicInteger pointMake = new AtomicInteger();
+                        AtomicInteger pointTake = new AtomicInteger();
+
+                        if ((!guest.get() && matchModel.getC1_id() != null && matchModel.getC1_id().getId() == id.get())
+                                || (guest.get() && matchModel.getC1_guest() != null && matchModel.getC1_guest()
+                                .getId() == id.get())) {
+                            builder2.adv(Utils.getFullName(matchModel.getC2_id(), matchModel.getC2_guest()));
+                            if (matchModel.isEnd()) {
+                                matchModel.getScores().stream()
+                                        .filter(s -> s.getS1() > -900 && s.getS2() > -900)
+                                        .forEach(scoreEntity -> {
+                                            pointMake.addAndGet(scoreEntity.getS1());
+                                            pointTake.addAndGet(scoreEntity.getS2());
+                                        });
+                                builder2.score(matchModel.getScores().stream()
+                                        .map(s -> new Integer[]{s.getS1(), s.getS2()}).toList());
+                            } else {
+                                builder2.score(new ArrayList<>());
+                            }
+                            builder2.win(matchModel.win() > 0);
+                        } else {
+                            builder2.adv(Utils.getFullName(matchModel.getC1_id(), matchModel.getC1_guest()));
+                            if (matchModel.isEnd()) {
+                                matchModel.getScores().stream()
+                                        .filter(s -> s.getS1() > -900 && s.getS2() > -900)
+                                        .forEach(scoreEntity -> {
+                                            pointMake.addAndGet(scoreEntity.getS2());
+                                            pointTake.addAndGet(scoreEntity.getS1());
+                                        });
+                                builder2.score(matchModel.getScores().stream()
+                                        .map(s -> new Integer[]{s.getS2(), s.getS1()}).toList());
+                            } else {
+                                builder2.score(new ArrayList<>());
+                            }
+                            builder2.win(matchModel.win() < 0);
+                        }
+
+                        builder2.ratio(
+                                (pointTake.get() == 0) ? pointMake.get() : (float) pointMake.get() / pointTake.get());
+
+                        sumPointMake.addAndGet(pointMake.get());
+                        sumPointTake.addAndGet(pointTake.get());
+
+                        matchs.add(builder2.build());
+                        if (builder2.win)
+                            sumW.getAndIncrement();
+                    }
+
+                    builder.totalWin(sumW.get());
+                    builder.pointRatio(
+                            (sumPointTake.get() == 0) ? sumPointMake.get() : (float) sumPointMake.get() / sumPointTake.get());
+                    builder.pointMake(sumPointMake.get());
+                    builder.pointTake(sumPointTake.get());
+
+                    matchs.sort(Comparator.comparing(CombArrayData.MatchsData::poule)
+                            .thenComparing(CombArrayData.MatchsData::adv));
+
+                    builder.matchs(matchs);
+                })
+                .map(__ -> builder.build());
+    }
+
 
     @Builder
     @RegisterForReflection
@@ -277,96 +445,117 @@ public class ResultService {
         }
     }
 
+    @Builder
+    @RegisterForReflection
+    public static record CombArrayData(String name, String club, String cat, int totalWin,
+                                       float pointRatio, int pointMake, int pointTake, List<MatchsData> matchs) {
+        @Builder
+        @RegisterForReflection
+        public static record MatchsData(Date date, String poule, String adv, List<Integer[]> score, float ratio,
+                                        boolean win) {
+        }
+    }
+
+    public Uni<HashMap<String, Long>> getClubList(String uuid) { // TODO add guest club
+        return registerRepository.list("competition.uuid = ?1", uuid)
+                .map(registers -> {
+                    HashMap<String, Long> registerMap = new HashMap<>();
+                    registers.stream().map(RegisterModel::getClub2).distinct().filter(Objects::nonNull)
+                            .forEach(registerClub -> registerMap.put(registerClub.getName(), registerClub.getId()));
+                    return registerMap;
+                });
+    }
+
     public Uni<ClubArrayData> getClubArray(String uuid, SecurityCtx securityCtx) {
+        return hasAccess(uuid, securityCtx).chain(cm_register -> getClubArray(uuid, cm_register.getClub2()));
+    }
+
+    public Uni<ClubArrayData> getClubArrayPublic(String uuid, Long id) {
+        return clubRepository.findById(id).chain(clubModel -> getClubArray(uuid, clubModel));
+    }
+
+    public Uni<ClubArrayData> getClubArray(String uuid, ClubModel clubModel) {
         ClubArrayData.ClubArrayDataBuilder builder = ClubArrayData.builder();
+        builder.name(clubModel.getName());
 
-        return hasAccess(uuid, securityCtx)
-                .invoke(cm_register -> builder.name(cm_register.getClub2().getName()))
-                .chain(cm_register -> registerRepository.list("competition.uuid = ?1 AND membre.club = ?2", uuid,
-                                cm_register.getClub2())
-                        .chain(registers -> matchRepository.list("category.compet.uuid = ?1", uuid)
-                                .map(matchModels -> new Pair<>(registers, matchModels)))
-                        .map(pair -> {
-                            List<RegisterModel> registers = pair.getKey();
-                            List<MatchModel> matchModels = pair.getValue();
+        return registerRepository.list("competition.uuid = ?1 AND membre.club = ?2", uuid, clubModel)
+                .chain(registers -> matchRepository.list("category.compet.uuid = ?1", uuid)
+                        .map(matchModels -> new Pair<>(registers, matchModels)))
+                .map(pair -> {
+                    List<RegisterModel> registers = pair.getKey();
+                    List<MatchModel> matchModels = pair.getValue();
 
-                            builder.nb_insc(registers.size());
+                    builder.nb_insc(registers.size());
 
-                            AtomicInteger tt_win = new AtomicInteger(0);
-                            AtomicInteger tt_match = new AtomicInteger(0);
+                    AtomicInteger tt_win = new AtomicInteger(0);
+                    AtomicInteger tt_match = new AtomicInteger(0);
 
-                            List<ClubArrayData.CombData> combData = registers.stream()
-                                    .map(register -> {
+                    List<ClubArrayData.CombData> combData = registers.stream().map(register -> {
+                                var builder2 = ClubArrayData.CombData.builder();
+                                AtomicInteger w = new AtomicInteger(0);
+                                AtomicInteger l = new AtomicInteger(0);
+                                AtomicInteger pointMake = new AtomicInteger();
+                                AtomicInteger pointTake = new AtomicInteger();
 
-                                        var builder2 = ClubArrayData.CombData.builder();
-                                        AtomicInteger w = new AtomicInteger(0);
-                                        AtomicInteger l = new AtomicInteger(0);
-                                        AtomicInteger pointMake = new AtomicInteger();
-                                        AtomicInteger pointTake = new AtomicInteger();
+                                matchModels.stream()
+                                        .filter(m -> m.isEnd() && (register.getMembre().equals(m.getC1_id())
+                                                || register.getMembre().equals(m.getC2_id())))
+                                        .forEach(matchModel -> {
+                                            int win = matchModel.win();
+                                            if ((register.getMembre().equals(matchModel.getC1_id()) && win > 0) ||
+                                                    register.getMembre().equals(matchModel.getC2_id()) && win < 0) {
+                                                w.getAndIncrement();
+                                            } else {
+                                                l.getAndIncrement();
+                                            }
 
-                                        matchModels.stream()
-                                                .filter(m -> m.isEnd() && (register.getMembre().equals(m.getC1_id())
-                                                        || register.getMembre().equals(m.getC2_id())))
-                                                .forEach(matchModel -> {
-                                                    int win = matchModel.win();
-                                                    if ((register.getMembre()
-                                                            .equals(matchModel.getC1_id()) && win > 0) ||
-                                                            register.getMembre()
-                                                                    .equals(matchModel.getC2_id()) && win < 0) {
-                                                        w.getAndIncrement();
-                                                    } else {
-                                                        l.getAndIncrement();
-                                                    }
+                                            matchModel.getScores().stream()
+                                                    .filter(s -> s.getS1() > -900 && s.getS2() > -900)
+                                                    .forEach(score -> {
+                                                        if (register.getMembre().equals(matchModel.getC1_id())) {
+                                                            pointMake.addAndGet(score.getS1());
+                                                            pointTake.addAndGet(score.getS2());
+                                                        } else {
+                                                            pointMake.addAndGet(score.getS2());
+                                                            pointTake.addAndGet(score.getS1());
+                                                        }
+                                                    });
+                                        });
 
-                                                    matchModel.getScores().stream()
-                                                            .filter(s -> s.getS1() > -900 && s.getS2() > -900)
-                                                            .forEach(score -> {
-                                                                if (register.getMembre()
-                                                                        .equals(matchModel.getC1_id())) {
-                                                                    pointMake.addAndGet(score.getS1());
-                                                                    pointTake.addAndGet(score.getS2());
-                                                                } else {
-                                                                    pointMake.addAndGet(score.getS2());
-                                                                    pointTake.addAndGet(score.getS1());
-                                                                }
-                                                            });
-                                                });
+                                Categorie categorie = register.getCategorie();
+                                if (categorie == null)
+                                    categorie = register.getMembre().getCategorie();
 
-                                        Categorie categorie = register.getCategorie();
-                                        if (categorie == null)
-                                            categorie = register.getMembre().getCategorie();
+                                builder2.cat((categorie == null) ? "---" : categorie.getName(BUNDLE));
+                                builder2.name(register.getName());
+                                builder2.w(w.get());
+                                builder2.l(l.get());
+                                builder2.ratioVictoire((l.get() == 0) ? w.get() : (float) w.get() / l.get());
+                                builder2.pointMake(pointMake.get());
+                                builder2.pointTake(pointTake.get());
+                                builder2.ratioPoint(
+                                        (pointTake.get() == 0) ? pointMake.get() : (float) pointMake.get() / pointTake.get());
 
-                                        builder2.cat((categorie == null) ? "---" : categorie.getName(BUNDLE));
-                                        builder2.name(register.getName());
-                                        builder2.w(w.get());
-                                        builder2.l(l.get());
-                                        builder2.ratioVictoire((l.get() == 0) ? w.get() : (float) w.get() / l.get());
-                                        builder2.pointMake(pointMake.get());
-                                        builder2.pointTake(pointTake.get());
-                                        builder2.ratioPoint(
-                                                (pointTake.get() == 0) ? pointMake.get() : (float) pointMake.get() / pointTake.get());
+                                tt_win.addAndGet(w.get());
+                                tt_match.addAndGet(w.get() + l.get());
 
-                                        tt_win.addAndGet(w.get());
-                                        tt_match.addAndGet(w.get() + l.get());
+                                return builder2.build();
+                            })
+                            .sorted(Comparator.comparing(ClubArrayData.CombData::name))
+                            .toList();
 
-                                        return builder2.build();
-                                    })
-                                    .sorted(Comparator.comparing(ClubArrayData.CombData::name))
-                                    .toList();
+                    builder.nb_match(tt_match.get());
+                    builder.match_w(tt_win.get());
+                    builder.ratioVictoire((float) combData.stream().filter(c -> c.l + c.w != 0)
+                            .mapToDouble(ClubArrayData.CombData::ratioVictoire).average().orElse(0L));
+                    builder.pointMake(combData.stream().mapToInt(ClubArrayData.CombData::pointMake).sum());
+                    builder.pointTake(combData.stream().mapToInt(ClubArrayData.CombData::pointTake).sum());
+                    builder.ratioPoint((float) combData.stream().filter(c -> c.l + c.w != 0)
+                            .mapToDouble(ClubArrayData.CombData::ratioPoint).average().orElse(0L));
+                    builder.combs(combData);
 
-                            builder.nb_match(tt_match.get());
-                            builder.match_w(tt_win.get());
-                            builder.ratioVictoire((float) combData.stream().filter(c -> c.l + c.w != 0)
-                                    .mapToDouble(ClubArrayData.CombData::ratioVictoire).average().orElse(0L));
-                            builder.pointMake(combData.stream().mapToInt(ClubArrayData.CombData::pointMake).sum());
-                            builder.pointTake(combData.stream().mapToInt(ClubArrayData.CombData::pointTake).sum());
-                            builder.ratioPoint((float) combData.stream().filter(c -> c.l + c.w != 0)
-                                    .mapToDouble(ClubArrayData.CombData::ratioPoint).average().orElse(0L));
-                            builder.combs(combData);
-
-                            return builder.build();
-                        })
-                );
+                    return builder.build();
+                });
     }
 
     @Builder

src/main/java/fr/titionfire/ffsaf/domain/service/UpdateService.java

@@ -0,0 +1,23 @@
+package fr.titionfire.ffsaf.domain.service;
+
+import jakarta.enterprise.context.ApplicationScoped;
+
+import java.util.HashMap;
+
+@ApplicationScoped
+public class UpdateService { // For public result page
+    static HashMap<Long, Long> lastUpdate = new HashMap<>();
+
+    public void setNewData(long id) {
+        lastUpdate.put(id, System.currentTimeMillis());
+    }
+
+    public boolean needUpdate(long id, long last_update) {
+        if (!lastUpdate.containsKey(id)) {
+            lastUpdate.put(id, System.currentTimeMillis() - 5000);
+            return true;
+        }
+
+        return lastUpdate.getOrDefault(id, 0L) > last_update;
+    }
+}

src/main/java/fr/titionfire/ffsaf/rest/ExternalResultEndpoints.java

@@ -0,0 +1,85 @@
+package fr.titionfire.ffsaf.rest;
+
+import fr.titionfire.ffsaf.domain.service.ResultService;
+import fr.titionfire.ffsaf.domain.service.UpdateService;
+import io.smallrye.mutiny.Uni;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.*;
+import jakarta.ws.rs.core.MediaType;
+
+import java.util.HashMap;
+
+@Path("api/public/result/{id}")
+public class ExternalResultEndpoints {
+
+    @Inject
+    ResultService resultService;
+
+    @Inject
+    UpdateService updateService;
+
+    @PathParam("id")
+    private String id;
+
+    @GET
+    @Path("/poule/list")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<HashMap<String, Long>> list() {
+        return resultService.getCategoryList(id);
+    }
+
+    @GET
+    @Path("/poule/data")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<?> getArray(@QueryParam("poule") long poule, @DefaultValue("-1") @QueryParam("rf") long rf) {
+        if (poule == 0)
+            return Uni.createFrom().voidItem();
+
+        if (updateService.needUpdate(poule, rf)) {
+            return resultService.getCategoryPublic(id, poule);
+        } else {
+            return Uni.createFrom().voidItem();
+        }
+    }
+
+    @GET
+    @Path("/comb/list")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<HashMap<String, String>> combList() {
+        return resultService.getCombList(id);
+    }
+
+    @GET
+    @Path("/comb/data")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<?> getArray(@QueryParam("comb") String comb) {
+        if (comb.equals("0"))
+            return Uni.createFrom().item("");
+        return resultService.getCombArrayPublic(id, comb.substring(0, comb.indexOf('¤')), comb.substring(comb.indexOf('¤') + 1));
+    }
+
+    @GET
+    @Path("/comb/get_all")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<?> getAll() {
+        return resultService.getAllCombArrayPublic(id);
+    }
+
+
+
+    @GET
+    @Path("/club/list")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<HashMap<String, Long>> clubList() {
+        return resultService.getClubList(id);
+    }
+
+    @GET
+    @Path("/club/data")
+    @Produces(MediaType.APPLICATION_JSON)
+    public Uni<?> getClubArray(@QueryParam("club") long club) {
+        if (club == 0)
+            return Uni.createFrom().item("");
+        return resultService.getClubArrayPublic(id, club);
+    }
+}

src/main/java/fr/titionfire/ffsaf/rest/data/ResultCategoryData.java

@@ -21,6 +21,8 @@ public class ResultCategoryData {
     HashMap<Character, List<PouleArrayData>> matchs = new HashMap<>();
     HashMap<Character, List<RankArray>> rankArray = new HashMap<>();
     ArrayList<TreeNode<TreeData>> trees;
+    String[] liceName;
+    long genTime;
 
     @Data
     @AllArgsConstructor

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

@@ -1,5 +1,7 @@
 package fr.titionfire.ffsaf.utils;
 
+import fr.titionfire.ffsaf.data.model.CompetitionGuestModel;
+import fr.titionfire.ffsaf.data.model.MembreModel;
 import io.smallrye.mutiny.Uni;
 import jakarta.ws.rs.core.HttpHeaders;
 import jakarta.ws.rs.core.MediaType;
@@ -365,4 +367,16 @@ public class Utils {
         }
         return result.toString().trim();
     }
+
+    public static String getFullName(Object ...models) {
+        for (Object model : models){
+            if (model == null)
+                continue;
+            if (model instanceof MembreModel membreModel)
+                return membreModel.getFname() + " " + membreModel.getLname();
+            if (model instanceof CompetitionGuestModel guestModel)
+                return guestModel.getFname() + " " + guestModel.getLname();
+        }
+        return "";
+    }
 }