536 lines
27 KiB
Java
536 lines
27 KiB
Java
package fr.titionfire.ffsaf.domain.service;
|
|
|
|
import fr.titionfire.ffsaf.data.model.ClubModel;
|
|
import fr.titionfire.ffsaf.data.model.LicenceModel;
|
|
import fr.titionfire.ffsaf.data.model.MembreModel;
|
|
import fr.titionfire.ffsaf.data.repository.*;
|
|
import fr.titionfire.ffsaf.net2.ServerCustom;
|
|
import fr.titionfire.ffsaf.net2.data.SimpleCombModel;
|
|
import fr.titionfire.ffsaf.net2.request.SReqComb;
|
|
import fr.titionfire.ffsaf.rest.data.MeData;
|
|
import fr.titionfire.ffsaf.rest.data.SimpleLicence;
|
|
import fr.titionfire.ffsaf.rest.data.SimpleMembre;
|
|
import fr.titionfire.ffsaf.rest.data.SimpleMembreInOutData;
|
|
import fr.titionfire.ffsaf.rest.exception.DBadRequestException;
|
|
import fr.titionfire.ffsaf.rest.exception.DForbiddenException;
|
|
import fr.titionfire.ffsaf.rest.exception.DNotFoundException;
|
|
import fr.titionfire.ffsaf.rest.from.FullMemberForm;
|
|
import fr.titionfire.ffsaf.utils.*;
|
|
import io.quarkus.hibernate.reactive.panache.Panache;
|
|
import io.quarkus.hibernate.reactive.panache.PanacheQuery;
|
|
import io.quarkus.hibernate.reactive.panache.common.WithSession;
|
|
import io.quarkus.panache.common.Page;
|
|
import io.quarkus.panache.common.Sort;
|
|
import io.quarkus.vertx.VertxContextSupport;
|
|
import io.smallrye.mutiny.Uni;
|
|
import io.smallrye.mutiny.unchecked.Unchecked;
|
|
import jakarta.enterprise.context.ApplicationScoped;
|
|
import jakarta.inject.Inject;
|
|
import jakarta.ws.rs.core.HttpHeaders;
|
|
import jakarta.ws.rs.core.MediaType;
|
|
import jakarta.ws.rs.core.Response;
|
|
import org.eclipse.microprofile.config.inject.ConfigProperty;
|
|
import org.hibernate.reactive.mutiny.Mutiny;
|
|
import org.jboss.logging.Logger;
|
|
|
|
import java.io.File;
|
|
import java.io.FilenameFilter;
|
|
import java.io.IOException;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.*;
|
|
import java.util.concurrent.atomic.AtomicReference;
|
|
|
|
import static fr.titionfire.ffsaf.domain.service.ClubService.getPdf;
|
|
|
|
|
|
@WithSession
|
|
@ApplicationScoped
|
|
public class MembreService {
|
|
private static final Logger LOGGER = Logger.getLogger(MembreService.class);
|
|
|
|
@Inject
|
|
CombRepository repository;
|
|
@Inject
|
|
ClubRepository clubRepository;
|
|
@Inject
|
|
LicenceRepository licenceRepository;
|
|
|
|
@Inject
|
|
CompetitionRepository competitionRepository;
|
|
|
|
@Inject
|
|
ServerCustom serverCustom;
|
|
@Inject
|
|
KeycloakService keycloakService;
|
|
|
|
@ConfigProperty(name = "upload_dir")
|
|
String media;
|
|
|
|
@ConfigProperty(name = "pdf-maker.jar-path")
|
|
String pdfMakerJarPath;
|
|
@Inject
|
|
RegisterRepository registerRepository;
|
|
|
|
@Inject
|
|
LoggerService ls;
|
|
|
|
public SimpleCombModel find(int licence, String np) throws Throwable {
|
|
return VertxContextSupport.subscribeAndAwait(() -> Panache.withTransaction(() ->
|
|
repository.find(
|
|
"licence = ?1 AND (unaccent(lname) ILIKE unaccent(?2) OR unaccent(fname) ILIKE unaccent(?2))",
|
|
licence, np).firstResult().map(SimpleCombModel::fromModel)));
|
|
}
|
|
|
|
public SimpleCombModel findByIdOptionalComb(long id) throws Throwable {
|
|
return VertxContextSupport.subscribeAndAwait(
|
|
() -> Panache.withTransaction(() -> repository.findById(id).map(SimpleCombModel::fromModel)));
|
|
}
|
|
|
|
final static String FIND_NAME_REQUEST = "unaccent(fname) ILIKE unaccent(?1) OR unaccent(lname) ILIKE unaccent(?1) " +
|
|
"OR unaccent(fname || ' ' || lname) ILIKE unaccent(?1) OR unaccent(lname || ' ' || fname) ILIKE unaccent(?1)";
|
|
|
|
public Uni<PageResult<SimpleMembre>> searchAdmin(int limit, int page, String search, String club) {
|
|
if (search == null)
|
|
search = "";
|
|
search = "%" + search.replaceAll(" ", "% %") + "%";
|
|
|
|
PanacheQuery<MembreModel> query;
|
|
|
|
if (club == null || club.isBlank()) {
|
|
query = repository.find(FIND_NAME_REQUEST, Sort.ascending("fname", "lname"), search)
|
|
.page(Page.ofSize(limit));
|
|
} else {
|
|
if (club.equals("null")) {
|
|
query = repository.find(
|
|
"club IS NULL AND (" + FIND_NAME_REQUEST + ")",
|
|
Sort.ascending("fname", "lname"), search).page(Page.ofSize(limit));
|
|
} else {
|
|
query = repository.find(
|
|
"LOWER(club.name) LIKE LOWER(?2) AND (" + FIND_NAME_REQUEST + ")",
|
|
Sort.ascending("fname", "lname"), search, club + "%").page(Page.ofSize(limit));
|
|
}
|
|
}
|
|
return getPageResult(query, limit, page);
|
|
}
|
|
|
|
public Uni<PageResult<SimpleMembre>> search(int limit, int page, String search, String subject) {
|
|
if (search == null)
|
|
search = "";
|
|
search = "%" + search.replaceAll(" ", "% %") + "%";
|
|
|
|
String finalSearch = search;
|
|
return repository.find("userId = ?1", subject).firstResult()
|
|
.chain(membreModel -> {
|
|
PanacheQuery<MembreModel> query = repository.find(
|
|
"club = ?2 AND (" + FIND_NAME_REQUEST + ")",
|
|
Sort.ascending("fname", "lname"), finalSearch, membreModel.getClub())
|
|
.page(Page.ofSize(limit));
|
|
return getPageResult(query, limit, page);
|
|
});
|
|
}
|
|
|
|
private Uni<PageResult<SimpleMembre>> getPageResult(PanacheQuery<MembreModel> query, int limit, int page) {
|
|
return Uni.createFrom().item(new PageResult<SimpleMembre>())
|
|
.invoke(result -> result.setPage(page))
|
|
.invoke(result -> result.setPage_size(limit))
|
|
.call(result -> query.count().invoke(result::setResult_count))
|
|
.call(result -> query.pageCount()
|
|
.invoke(Unchecked.consumer(pages -> {
|
|
if (page > pages) throw new DBadRequestException("Page out of range");
|
|
}))
|
|
.invoke(result::setPage_count))
|
|
.call(result -> query.page(Page.of(page, limit)).list()
|
|
.map(membreModels -> membreModels.stream().map(SimpleMembre::fromModel).toList())
|
|
.invoke(result::setResult));
|
|
}
|
|
|
|
public Uni<List<SimpleMembreInOutData>> getAllExport(String subject) {
|
|
return repository.find("userId = ?1", subject).firstResult()
|
|
.chain(membreModel -> repository.list("club = ?1", membreModel.getClub()))
|
|
.chain(membres -> licenceRepository.list("saison = ?1 AND membre IN ?2", Utils.getSaison(), membres)
|
|
.map(l -> membres.stream().map(m -> SimpleMembreInOutData.fromModel(m, l)).toList()));
|
|
}
|
|
|
|
public Uni<String> allImporte(String subject, List<SimpleMembreInOutData> data) {
|
|
if (data == null)
|
|
return Uni.createFrom().nullItem();
|
|
final List<SimpleMembreInOutData> data2 = data.stream()
|
|
.filter(dataIn -> dataIn.getNom() != null && !dataIn.getNom()
|
|
.isBlank() && dataIn.getPrenom() != null && !dataIn.getPrenom().isBlank()).toList();
|
|
if (data2.isEmpty())
|
|
return Uni.createFrom().nullItem();
|
|
AtomicReference<ClubModel> clubModel = new AtomicReference<>();
|
|
|
|
return repository.find("userId = ?1", subject).firstResult()
|
|
.chain(membreModel -> {
|
|
clubModel.set(membreModel.getClub());
|
|
if (data2.stream().noneMatch(d -> d.getLicence() != null))
|
|
return Uni.createFrom().item(new ArrayList<MembreModel>());
|
|
return repository.list("licence IN ?1 OR LOWER(lname || ' ' || fname) IN ?2",
|
|
data2.stream().map(SimpleMembreInOutData::getLicence).filter(Objects::nonNull).toList(),
|
|
data2.stream().map(o -> (o.getNom() + " " + o.getPrenom()).toLowerCase()).toList());
|
|
})
|
|
.call(Unchecked.function(membres -> {
|
|
for (MembreModel membreModel : membres) {
|
|
if (!Objects.equals(membreModel.getClub(), clubModel.get()))
|
|
throw new DForbiddenException(
|
|
"Le membre n°" + membreModel.getLicence() + " n'appartient pas à votre club");
|
|
}
|
|
Uni<Void> uniResult = Uni.createFrom().voidItem();
|
|
for (SimpleMembreInOutData dataIn : data2) {
|
|
MembreModel model = membres.stream()
|
|
.filter(m -> Objects.equals(m.getLicence(), dataIn.getLicence()) || m.getLname()
|
|
.equals(dataIn.getNom()) && m.getFname().equals(dataIn.getPrenom())).findFirst()
|
|
.orElseGet(() -> {
|
|
MembreModel mm = new MembreModel();
|
|
mm.setClub(clubModel.get());
|
|
mm.setLicences(new ArrayList<>());
|
|
mm.setCountry("FR");
|
|
return mm;
|
|
});
|
|
|
|
boolean add = model.getId() == null;
|
|
|
|
if ((!add && StringSimilarity.similarity(model.getLname().toUpperCase(),
|
|
dataIn.getNom().toUpperCase()) > 3) || (!add && StringSimilarity.similarity(
|
|
model.getFname().toUpperCase(), dataIn.getPrenom().toUpperCase()) > 3)) {
|
|
throw new DBadRequestException(
|
|
"Pour enregistrer un nouveau membre, veuillez laisser le champ licence vide.");
|
|
}
|
|
|
|
ls.logChange("Nom", model.getLname(), dataIn.getNom().toUpperCase(), model);
|
|
ls.logChange("Prénom", model.getFname(),
|
|
dataIn.getPrenom().toUpperCase().charAt(0) + dataIn.getPrenom().substring(1), model);
|
|
|
|
model.setLname(dataIn.getNom().toUpperCase());
|
|
model.setFname(dataIn.getPrenom().toUpperCase().charAt(0) + dataIn.getPrenom().substring(1));
|
|
|
|
|
|
if (dataIn.getEmail() != null && !dataIn.getEmail().isBlank()) {
|
|
ls.logChange("Email", model.getEmail(), dataIn.getEmail(), model);
|
|
model.setEmail(dataIn.getEmail());
|
|
}
|
|
model.setGenre(Genre.fromString(dataIn.getGenre()));
|
|
if (dataIn.getBirthdate() != null) {
|
|
if (model.getBirth_date() == null || !Objects.equals(model.getBirth_date().getTime(),
|
|
dataIn.getBirthdate().getTime()))
|
|
ls.logChange("Date de naissance", model.getBirth_date(), dataIn.getBirthdate(), model);
|
|
model.setBirth_date(dataIn.getBirthdate());
|
|
model.setCategorie(Utils.getCategoryFormBirthDate(model.getBirth_date(), new Date()));
|
|
}
|
|
|
|
uniResult = uniResult
|
|
.call(() -> Panache.withTransaction(() -> repository.persist(model)
|
|
.chain(membreModel1 -> dataIn.isLicenceCurrent() ? licenceRepository.find(
|
|
"membre.id = ?1 AND saison = ?2", membreModel1.getId(),
|
|
Utils.getSaison())
|
|
.firstResult()
|
|
.call(l -> {
|
|
if (l == null) {
|
|
l = new LicenceModel();
|
|
l.setMembre(membreModel1);
|
|
l.setClub_id(clubModel.get().getId());
|
|
l.setValidate(false);
|
|
l.setSaison(Utils.getSaison());
|
|
}
|
|
l.setCertificate(dataIn.getCertif());
|
|
return licenceRepository.persist(l);
|
|
}) : licenceRepository.delete(
|
|
"membre = ?1 AND saison = ?2 AND validate = false", membreModel1,
|
|
Utils.getSaison()))));
|
|
if (add)
|
|
uniResult = uniResult.call(() -> ls.logAAdd(model));
|
|
else
|
|
uniResult = uniResult.call(() -> ls.append());
|
|
}
|
|
return uniResult;
|
|
}))
|
|
.map(__ -> "OK");
|
|
}
|
|
|
|
public Uni<MembreModel> getById(long id) {
|
|
return repository.findById(id);
|
|
}
|
|
|
|
public Uni<MembreModel> getByIdWithLicence(long id) {
|
|
return repository.findById(id)
|
|
.call(m -> Mutiny.fetch(m.getLicences()));
|
|
}
|
|
|
|
public Uni<MembreModel> getByAccountId(String subject) {
|
|
return repository.find("userId = ?1", subject).firstResult();
|
|
}
|
|
|
|
public Uni<MembreModel> getByLicence(long licence) {
|
|
return repository.find("licence = ?1", licence).firstResult();
|
|
}
|
|
|
|
public Uni<String> update(long id, FullMemberForm membre) {
|
|
return update(repository.findById(id)
|
|
.chain(membreModel -> clubRepository.findById(membre.getClub())
|
|
.map(club -> new Pair<>(membreModel, club)))
|
|
.onItem().transform(pair -> {
|
|
MembreModel m = pair.getKey();
|
|
|
|
ls.logChange("Rôle", m.getRole(), membre.getRole(), m);
|
|
m.setRole(membre.getRole());
|
|
ls.logChange("Club", m.getClub(), pair.getValue(), m);
|
|
m.setClub(pair.getValue());
|
|
ls.logChange("Grade d'arbitrage", m.getGrade_arbitrage(), membre.getGrade_arbitrage(), m);
|
|
m.setGrade_arbitrage(membre.getGrade_arbitrage());
|
|
return m;
|
|
}), membre, true);
|
|
}
|
|
|
|
public Uni<String> update(long id, FullMemberForm membre, SecurityCtx securityCtx) {
|
|
return update(repository.findById(id)
|
|
.invoke(Unchecked.consumer(membreModel -> {
|
|
if (!securityCtx.isInClubGroup(membreModel.getClub().getId()))
|
|
throw new DForbiddenException();
|
|
}))
|
|
.invoke(Unchecked.consumer(membreModel -> {
|
|
RoleAsso source = RoleAsso.MEMBRE;
|
|
if (securityCtx.roleHas("club_president")) source = RoleAsso.PRESIDENT;
|
|
else if (securityCtx.roleHas("club_secretaire")) source = RoleAsso.SECRETAIRE;
|
|
else if (securityCtx.roleHas("club_respo_intra")) source = RoleAsso.MEMBREBUREAU;
|
|
if (!membre.getRole().equals(membreModel.getRole()) && membre.getRole().level >= source.level)
|
|
throw new DForbiddenException("Permission insuffisante");
|
|
}))
|
|
.onItem().transform(target -> {
|
|
if (!securityCtx.getSubject().equals(target.getUserId())) {
|
|
ls.logChange("Rôle", target.getRole(), membre.getRole(), target);
|
|
target.setRole(membre.getRole());
|
|
}
|
|
return target;
|
|
}), membre, false);
|
|
}
|
|
|
|
private Uni<String> update(Uni<MembreModel> uni, FullMemberForm membre, boolean admin) {
|
|
return uni.chain(target -> {
|
|
ls.logChange("Prénom", target.getFname(), membre.getFname(), target);
|
|
target.setFname(membre.getFname());
|
|
ls.logChange("Nom", target.getLname(), membre.getLname(), target);
|
|
target.setLname(membre.getLname().toUpperCase());
|
|
ls.logChange("Pays", target.getCountry(), membre.getCountry(), target);
|
|
target.setCountry(membre.getCountry());
|
|
if (membre.getBirth_date() != null && (target.getBirth_date() == null || !Objects.equals(
|
|
target.getBirth_date().getTime(), membre.getBirth_date().getTime()))) {
|
|
ls.logChange("Date de naissance", target.getBirth_date(), membre.getBirth_date(), target);
|
|
target.setBirth_date(membre.getBirth_date());
|
|
target.setCategorie(Utils.getCategoryFormBirthDate(membre.getBirth_date(), new Date()));
|
|
}
|
|
ls.logChange("Genre", target.getGenre(), membre.getGenre(), target);
|
|
target.setGenre(membre.getGenre());
|
|
ls.logChange("Email", target.getEmail(), membre.getEmail(), target);
|
|
target.setEmail(membre.getEmail());
|
|
|
|
return Panache.withTransaction(() -> repository.persist(target)).call(() -> ls.append());
|
|
})
|
|
.invoke(membreModel -> SReqComb.sendIfNeed(serverCustom.clients,
|
|
SimpleCombModel.fromModel(membreModel)))
|
|
.call(membreModel -> (admin && membreModel.getUserId() != null) ?
|
|
((membreModel.getClub() != null) ?
|
|
keycloakService.setClubGroupMembre(membreModel, membreModel.getClub()) :
|
|
keycloakService.clearUser(membreModel.getUserId()))
|
|
: Uni.createFrom().nullItem())
|
|
.call(membreModel -> (membreModel.getUserId() != null) ?
|
|
keycloakService.setAutoRoleMembre(membreModel.getUserId(), membreModel.getRole(),
|
|
membreModel.getGrade_arbitrage()) : Uni.createFrom().nullItem())
|
|
.call(membreModel -> (membreModel.getUserId() != null) ?
|
|
keycloakService.setEmail(membreModel.getUserId(), membreModel.getEmail()) : Uni.createFrom()
|
|
.nullItem())
|
|
.call(membreModel -> {
|
|
Calendar calendar = Calendar.getInstance();
|
|
calendar.add(Calendar.DAY_OF_YEAR, -7);
|
|
Date dateLimit = calendar.getTime();
|
|
|
|
return competitionRepository.list("date > ?1", dateLimit)
|
|
.call(l -> l.isEmpty() ? Uni.createFrom().nullItem() :
|
|
Uni.join().all(l.stream().map(competitionModel ->
|
|
registerRepository.update(
|
|
"categorie = ?1, club = ?2 where competition = ?3 AND membre = ?4",
|
|
membreModel.getCategorie(), membreModel.getClub(), competitionModel,
|
|
membreModel)
|
|
).toList()).andFailFast());
|
|
})
|
|
.call(membreModel -> licenceRepository.update("club_id = ?1 where membre = ?2 AND saison = ?3",
|
|
(membreModel.getClub() == null) ? null : membreModel.getClub().getId(), membreModel,
|
|
Utils.getSaison()))
|
|
.call(membreModel -> membre.getPhoto_data().length > 0 ? ls.logAUpdate("Photo",
|
|
membreModel) : Uni.createFrom().nullItem())
|
|
.map(__ -> "OK");
|
|
}
|
|
|
|
|
|
public Uni<Long> add(FullMemberForm input) {
|
|
return clubRepository.findById(input.getClub())
|
|
.chain(clubModel -> {
|
|
MembreModel model = getMembreModel(input, clubModel);
|
|
return Panache.withTransaction(() -> repository.persist(model));
|
|
})
|
|
.call(membreModel -> ls.logAAdd(membreModel))
|
|
.invoke(membreModel -> SReqComb.sendIfNeedAdd(serverCustom.clients,
|
|
SimpleCombModel.fromModel(membreModel)))
|
|
.map(MembreModel::getId);
|
|
}
|
|
|
|
public Uni<Long> add(FullMemberForm input, String subject) {
|
|
return repository.find("userId = ?1", subject).firstResult()
|
|
.chain(membreModel -> {
|
|
MembreModel model = getMembreModel(input, membreModel.getClub());
|
|
model.setRole(RoleAsso.MEMBRE);
|
|
model.setGrade_arbitrage(GradeArbitrage.NA);
|
|
return Panache.withTransaction(() -> repository.persist(model));
|
|
})
|
|
.call(membreModel -> ls.logAAdd(membreModel))
|
|
.invoke(membreModel -> SReqComb.sendIfNeedAdd(serverCustom.clients,
|
|
SimpleCombModel.fromModel(membreModel)))
|
|
.map(MembreModel::getId);
|
|
}
|
|
|
|
public Uni<String> delete(long id) {
|
|
return repository.findById(id)
|
|
.call(membreModel -> (membreModel.getUserId() != null) ?
|
|
keycloakService.removeAccount(membreModel.getUserId()) : Uni.createFrom().nullItem())
|
|
.call(membreModel -> ls.logADelete(membreModel))
|
|
.call(membreModel -> Panache.withTransaction(() -> repository.delete(membreModel)))
|
|
.invoke(membreModel -> SReqComb.sendRm(serverCustom.clients, id))
|
|
.map(__ -> "Ok");
|
|
}
|
|
|
|
public Uni<String> delete(long id, SecurityCtx securityCtx) {
|
|
return repository.findById(id)
|
|
.invoke(Unchecked.consumer(membreModel -> {
|
|
if (!securityCtx.isInClubGroup(membreModel.getClub().getId()))
|
|
throw new DForbiddenException();
|
|
}))
|
|
.invoke(Unchecked.consumer(membreModel -> {
|
|
if (membreModel.getLicence() != null) {
|
|
throw new DBadRequestException(
|
|
"Impossible de supprimer un membre qui a déjà un numéro de licence");
|
|
}
|
|
}))
|
|
.call(membreModel -> licenceRepository.find("membre = ?1", membreModel).count()
|
|
.invoke(Unchecked.consumer(l -> {
|
|
if (l > 0)
|
|
throw new DBadRequestException("Impossible de supprimer un membre avec des licences");
|
|
})))
|
|
.call(membreModel -> (membreModel.getUserId() != null) ?
|
|
keycloakService.removeAccount(membreModel.getUserId()) : Uni.createFrom().nullItem())
|
|
.call(membreModel -> ls.logADelete(membreModel))
|
|
.call(membreModel -> Panache.withTransaction(() -> repository.delete(membreModel)))
|
|
.invoke(membreModel -> SReqComb.sendRm(serverCustom.clients, id))
|
|
.call(__ -> Utils.deleteMedia(id, media, "ppMembre"))
|
|
.map(__ -> "Ok");
|
|
}
|
|
|
|
public Uni<?> setUserId(Long id, String id1) {
|
|
return repository.findById(id).chain(membreModel -> {
|
|
ls.logChange("KC UUID", membreModel.getUserId(), id1, membreModel);
|
|
membreModel.setUserId(id1);
|
|
return Panache.withTransaction(() -> repository.persist(membreModel))
|
|
.call(() -> ls.append());
|
|
});
|
|
}
|
|
|
|
private static MembreModel getMembreModel(FullMemberForm input, ClubModel clubModel) {
|
|
MembreModel model = new MembreModel();
|
|
model.setFname(input.getFname());
|
|
model.setLname(input.getLname());
|
|
model.setEmail(input.getEmail());
|
|
model.setLicence(null);
|
|
model.setGenre(input.getGenre());
|
|
model.setCountry(input.getCountry());
|
|
model.setBirth_date(input.getBirth_date());
|
|
model.setCategorie(Utils.getCategoryFormBirthDate(input.getBirth_date(), new Date()));
|
|
model.setClub(clubModel);
|
|
model.setRole(input.getRole());
|
|
model.setGrade_arbitrage(input.getGrade_arbitrage());
|
|
return model;
|
|
}
|
|
|
|
public Uni<List<SimpleMembre>> getSimilar(String fname, String lname) {
|
|
return repository.listAll().map(membreModels -> membreModels.stream()
|
|
.filter(m -> StringSimilarity.similarity(m.getFname(), fname) <= 3 &&
|
|
StringSimilarity.similarity(m.getLname(), lname) <= 3)
|
|
.map(SimpleMembre::fromModel).toList());
|
|
}
|
|
|
|
public Uni<MeData> getMembre(String subject) {
|
|
MeData meData = new MeData();
|
|
return repository.find("userId = ?1", subject).firstResult()
|
|
.invoke(meData::setMembre)
|
|
.chain(membreModel -> Mutiny.fetch(membreModel.getLicences()))
|
|
.map(licences -> licences.stream().map(SimpleLicence::fromModel).toList())
|
|
.invoke(meData::setLicences)
|
|
.map(__ -> meData);
|
|
}
|
|
|
|
public Uni<Response> getLicencePdf(String subject) {
|
|
return getLicencePdf(repository.find("userId = ?1", subject).firstResult()
|
|
.call(m -> Mutiny.fetch(m.getLicences())));
|
|
}
|
|
|
|
public Uni<Response> getLicencePdf(Uni<MembreModel> uniBase) {
|
|
return uniBase
|
|
.map(Unchecked.function(m -> {
|
|
LicenceModel licence = m.getLicences().stream()
|
|
.filter(licenceModel -> licenceModel.getSaison() == Utils.getSaison() && licenceModel.isValidate())
|
|
.findFirst()
|
|
.orElseThrow(() -> new DNotFoundException("Pas de licence pour la saison en cours"));
|
|
|
|
try {
|
|
byte[] buff = make_pdf(m, licence);
|
|
if (buff == null)
|
|
throw new IOException("Error making pdf");
|
|
|
|
String mimeType = "application/pdf";
|
|
|
|
Response.ResponseBuilder resp = Response.ok(buff);
|
|
resp.type(MediaType.APPLICATION_OCTET_STREAM);
|
|
resp.header(HttpHeaders.CONTENT_LENGTH, buff.length);
|
|
resp.header(HttpHeaders.CONTENT_TYPE, mimeType);
|
|
resp.header(HttpHeaders.CONTENT_DISPOSITION,
|
|
"inline; " + "filename=\"Attestation d'adhésion " + Utils.getSaison() + "-" +
|
|
(Utils.getSaison() + 1) + " de " + m.getLname() + " " + m.getFname() + ".pdf\"");
|
|
return resp.build();
|
|
} catch (Exception e) {
|
|
throw new IOException(e);
|
|
}
|
|
}));
|
|
}
|
|
|
|
private byte[] make_pdf(MembreModel m, LicenceModel licence) throws IOException, InterruptedException {
|
|
List<String> cmd = new ArrayList<>();
|
|
cmd.add("java");
|
|
cmd.add("-jar");
|
|
cmd.add(pdfMakerJarPath);
|
|
|
|
UUID uuid = UUID.randomUUID();
|
|
|
|
cmd.add("/tmp/" + uuid + ".pdf");
|
|
cmd.add("membre");
|
|
cmd.add(m.getFname());
|
|
cmd.add(m.getLname());
|
|
cmd.add(m.getGenre().str);
|
|
cmd.add(m.getCategorie().getName());
|
|
cmd.add(licence.getCertificate() == null ? "" : licence.getCertificate());
|
|
cmd.add(Utils.getSaison() + "");
|
|
cmd.add(m.getLicence() + "");
|
|
cmd.add(m.getClub().getName());
|
|
cmd.add(m.getClub().getNo_affiliation() + "");
|
|
cmd.add(m.getBirth_date() == null ? "--" : new SimpleDateFormat("dd/MM/yyyy").format(m.getBirth_date()));
|
|
|
|
FilenameFilter filter = (directory, filename) -> filename.startsWith(m.getId() + ".");
|
|
File[] files = new File(media, "ppMembre").listFiles(filter);
|
|
if (files != null && files.length > 0) {
|
|
File file = files[0];
|
|
cmd.add(file.getAbsolutePath());
|
|
} else {
|
|
cmd.add("/dev/null");
|
|
}
|
|
|
|
return getPdf(cmd, uuid, LOGGER);
|
|
}
|
|
}
|