Thibaut/ffsaf-site
1
0
Fork 0
Code Issues Pull Requests Actions Packages Releases Activity

feat: HelloAsso payment

Browse Source
This commit is contained in:
Thibaut Valentin
2025-08-14 22:45:03 +02:00
parent 0a56f8c180
commit 15f65b1014
28 changed files with 1003 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
src/main/java/fr/titionfire/ffsaf/data/model/CheckoutModel.java Normal file
View File

@@ -0,0 +1,41 @@
package fr.titionfire.ffsaf.data.model;
import io.quarkus.runtime.annotations.RegisterForReflection;
import jakarta.persistence.*;
import lombok.*;
import org.eclipse.microprofile.openapi.annotations.media.Schema;
import java.util.Date;
import java.util.List;
@Getter
@Setter
@Builder
@AllArgsConstructor
@NoArgsConstructor
@RegisterForReflection
@Entity
@Table(name = "checkout")
public class CheckoutModel {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Schema(description = "Identifiant du checkout", example = "42")
Long id;
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "membre", referencedColumnName = "id")
MembreModel membre;
Date creationDate = new Date();
List<Long> licenseIds;
Integer checkoutId;
PaymentStatus paymentStatus;
public enum PaymentStatus {
PENDING, AUTHORIZED, REFUSED, UNKNOW, REGISTERED, REFUNDING, REFUNDED, CONTESTED
}
}

9
src/main/java/fr/titionfire/ffsaf/data/repository/CheckoutRepository.java Normal file
View File

@@ -0,0 +1,9 @@
package fr.titionfire.ffsaf.data.repository;
import fr.titionfire.ffsaf.data.model.CheckoutModel;
import io.quarkus.hibernate.reactive.panache.PanacheRepositoryBase;
import jakarta.enterprise.context.ApplicationScoped;
@ApplicationScoped
public class CheckoutRepository implements PanacheRepositoryBase<CheckoutModel, Long> {
}

161
src/main/java/fr/titionfire/ffsaf/domain/service/CheckoutService.java Normal file
View File

@@ -0,0 +1,161 @@
package fr.titionfire.ffsaf.domain.service;
import fr.titionfire.ffsaf.data.model.CheckoutModel;
import fr.titionfire.ffsaf.data.model.LogModel;
import fr.titionfire.ffsaf.data.repository.CheckoutRepository;
import fr.titionfire.ffsaf.data.repository.LicenceRepository;
import fr.titionfire.ffsaf.rest.client.HelloAssoService;
import fr.titionfire.ffsaf.rest.client.dto.CheckoutIntentsRequest;
import fr.titionfire.ffsaf.rest.client.dto.CheckoutIntentsResponse;
import fr.titionfire.ffsaf.rest.client.dto.CheckoutMetadata;
import fr.titionfire.ffsaf.rest.exception.DInternalError;
import fr.titionfire.ffsaf.utils.SecurityCtx;
import fr.titionfire.ffsaf.utils.Utils;
import io.quarkus.hibernate.reactive.panache.Panache;
import io.quarkus.hibernate.reactive.panache.common.WithSession;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.hibernate.reactive.mutiny.Mutiny;
import java.util.List;
@WithSession
@ApplicationScoped
public class CheckoutService {
@Inject
CheckoutRepository repository;
@Inject
LicenceRepository licenceRepository;
@Inject
MembreService membreService;
@Inject
LicenceService licenceService;
@Inject
LoggerService ls;
@RestClient
HelloAssoService helloAssoService;
@ConfigProperty(name = "frontRootUrl")
String frontRootUrl;
@ConfigProperty(name = "unitLicencePrice")
int unitLicencePrice;
@ConfigProperty(name = "helloasso.organizationSlug")
String organizationSlug;
public Uni<Boolean> canDeleteLicence(long id) {
return repository.find("?1 IN licenseIds", id).count().map(count -> count == 0);
}
public Uni<String> create(List<Long> ids, SecurityCtx securityCtx) {
return membreService.getByAccountId(securityCtx.getSubject())
.call(membreModel -> Mutiny.fetch(membreModel.getClub()))
.chain(membreModel -> {
CheckoutModel model = new CheckoutModel();
model.setMembre(membreModel);
model.setLicenseIds(ids);
model.setPaymentStatus(CheckoutModel.PaymentStatus.UNKNOW);
return Panache.withTransaction(() -> repository.persist(model));
})
.chain(checkoutModel -> {
CheckoutIntentsRequest request = new CheckoutIntentsRequest();
request.setTotalAmount(unitLicencePrice * checkoutModel.getLicenseIds().size());
request.setInitialAmount(unitLicencePrice * checkoutModel.getLicenseIds().size());
request.setItemName("%d licences %d-%d pour %s".formatted(checkoutModel.getLicenseIds().size(),
Utils.getSaison(), Utils.getSaison() + 1, checkoutModel.getMembre().getClub().getName()));
request.setBackUrl(frontRootUrl + "/club/member/pay");
request.setErrorUrl(frontRootUrl + "/club/member/pay/error");
request.setReturnUrl(frontRootUrl + "/club/member/pay/return");
request.setContainsDonation(false);
request.setPayer(new CheckoutIntentsRequest.Payer(checkoutModel.getMembre().getFname(),
checkoutModel.getMembre().getLname(), checkoutModel.getMembre().getEmail()));
request.setMetadata(new CheckoutMetadata(checkoutModel.getId()));
return helloAssoService.checkout(organizationSlug, request)
.call(response -> {
checkoutModel.setCheckoutId(response.getId());
return Panache.withTransaction(() -> repository.persist(checkoutModel));
});
})
.onFailure().transform(t -> new DInternalError(t.getMessage()))
.map(CheckoutIntentsResponse::getRedirectUrl);
}
public Uni<Response> paymentStatusChange(String state, CheckoutMetadata metadata) {
return repository.findById(metadata.getCheckoutDBId())
.chain(checkoutModel -> {
CheckoutModel.PaymentStatus newStatus = CheckoutModel.PaymentStatus.valueOf(state.toUpperCase());
Uni<?> uni = Uni.createFrom().nullItem();
if (checkoutModel.getPaymentStatus().equals(newStatus))
return uni;
if (newStatus.equals(CheckoutModel.PaymentStatus.AUTHORIZED)) {
for (Long id : checkoutModel.getLicenseIds()) {
uni = uni.chain(__ -> licenceRepository.findById(id)
.onFailure().recoverWithNull()
.call(licenceModel -> {
if (licenceModel == null) {
ls.logAnonymous(LogModel.ActionType.UPDATE, LogModel.ObjectType.Licence,
"Fail to save payment for licence (checkout n°" + checkoutModel.getCheckoutId() + ")",
"", id);
return Uni.createFrom().nullItem();
}
ls.logUpdateAnonymous("Paiement de la licence", licenceModel);
licenceModel.setPay(true);
if (licenceModel.getCertificate() != null && licenceModel.getCertificate()
.length() > 3) {
if (!licenceModel.isValidate())
ls.logUpdateAnonymous("Validation automatique de la licence",
licenceModel);
return licenceService.validateLicences(licenceModel);
} else {
return Panache.withTransaction(
() -> licenceRepository.persist(licenceModel));
}
}));
}
} else if (checkoutModel.getPaymentStatus().equals(CheckoutModel.PaymentStatus.AUTHORIZED)) {
for (Long id : checkoutModel.getLicenseIds()) {
uni = uni.chain(__ -> licenceRepository.findById(id)
.onFailure().recoverWithNull()
.call(licenceModel -> {
if (licenceModel == null)
return Uni.createFrom().nullItem();
ls.logUpdateAnonymous("Annulation automatique du paiement de la licence",
licenceModel);
licenceModel.setPay(false);
if (licenceModel.isValidate())
ls.logUpdateAnonymous(
"Annulation automatique de la validation de la licence",
licenceModel);
licenceModel.setValidate(false);
return Panache.withTransaction(() -> licenceRepository.persist(licenceModel));
}));
}
}
uni = uni.call(__ -> ls.append());
checkoutModel.setPaymentStatus(newStatus);
return uni.chain(__ -> Panache.withTransaction(() -> repository.persist(checkoutModel)));
})
.onFailure().invoke(Throwable::printStackTrace)
.map(__ -> Response.ok().build());
}
}

68
src/main/java/fr/titionfire/ffsaf/domain/service/HelloAssoTokenService.java Normal file
View File

@@ -0,0 +1,68 @@
package fr.titionfire.ffsaf.domain.service;
import fr.titionfire.ffsaf.rest.client.HelloAssoAuthClient;
import fr.titionfire.ffsaf.rest.client.dto.TokenResponse;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.jboss.logging.Logger;
@ApplicationScoped
public class HelloAssoTokenService {
private static final Logger LOG = Logger.getLogger(HelloAssoTokenService.class);
@Inject
@RestClient
HelloAssoAuthClient authClient;
@ConfigProperty(name = "helloasso.client-id")
String clientId;
@ConfigProperty(name = "helloasso.client-secret")
String clientSecret;
private TokenResponse currentToken; // Stockage en mémoire (pour un seul pod)
// Récupère un token valide (en le rafraîchissant si nécessaire)
public Uni<String> getValidAccessToken() {
if (currentToken == null || currentToken.isExpired()) {
return fetchNewToken(clientId, clientSecret);
}
return Uni.createFrom().item(currentToken.accessToken);
}
// Récupère un nouveau token (via client_credentials ou refresh_token)
private Uni<String> fetchNewToken(String clientId, String clientSecret) {
if (currentToken != null && currentToken.refreshToken != null) {
// On utilise le refresh_token si disponible
return authClient.refreshToken("refresh_token", clientId, currentToken.refreshToken)
.onItem().invoke(token -> {
LOG.info("Token rafraîchi avec succès");
currentToken = token;
})
.onFailure().recoverWithItem(e -> {
LOG.warn("Échec du rafraîchissement, utilisation des credentials", e);
return null; // Force l'utilisation des credentials
})
.flatMap(token -> token != null ?
Uni.createFrom().item(token.accessToken) :
getTokenWithCredentials(clientId, clientSecret)
);
} else {
return getTokenWithCredentials(clientId, clientSecret);
}
}
// Récupère un token avec client_id/client_secret
private Uni<String> getTokenWithCredentials(String clientId, String clientSecret) {
return authClient.getToken("client_credentials", clientId, clientSecret)
.onItem().invoke(token -> {
LOG.info("Nouveau token obtenu");
currentToken = token;
})
.onFailure().invoke(e -> LOG.error("Erreur lors de l'obtention du token", e))
.map(token -> token.accessToken);
}
}

43
src/main/java/fr/titionfire/ffsaf/domain/service/LicenceService.java
View File

@@ -42,6 +42,9 @@ public class LicenceService {
@Inject
LoggerService ls;
@Inject
CheckoutService checkoutService;
public Uni<List<LicenceModel>> getLicence(long id, Consumer<MembreModel> checkPerm) {
return combRepository.findById(id).invoke(checkPerm)
.chain(combRepository -> Mutiny.fetch(combRepository.getLicences()));
@@ -64,17 +67,21 @@ public class LicenceService {
.chain(model -> {
if (!model.isValidate())
ls.logUpdate("validation de la licence", model);
model.setValidate(true);
return Panache.withTransaction(() -> repository.persist(model)
.call(m -> Mutiny.fetch(m.getMembre())
.call(genLicenceNumberAndAccountIfNeed())
));
return validateLicences(model);
}))
.map(__ -> "OK");
}
return uni.call(__ -> ls.append());
}
protected Uni<LicenceModel> validateLicences(LicenceModel model) {
model.setValidate(true);
return Panache.withTransaction(() -> repository.persist(model)
.call(m -> Mutiny.fetch(m.getMembre())
.call(genLicenceNumberAndAccountIfNeed())
));
}
public Uni<LicenceModel> setLicence(long id, LicenceForm form) {
if (form.getId() == -1) {
return combRepository.findById(id).chain(membreModel -> {
@@ -122,8 +129,29 @@ public class LicenceService {
: Uni.createFrom().nullItem());
}
public Uni<String> payLicences(List<Long> ids, Consumer<MembreModel> checkPerm, SecurityCtx securityCtx) {
return repository.list("membre.id IN ?1 AND saison = ?2 AND pay = FALSE", ids, Utils.getSaison())
.invoke(Unchecked.consumer(models -> {
if (models.size() != ids.size())
throw new DBadRequestException("Erreur lors de la sélection des membres");
}))
.call(models -> {
Uni<?> uni = Uni.createFrom().nullItem();
for (LicenceModel model : models)
uni = uni.chain(__ -> Mutiny.fetch(model.getMembre()).invoke(checkPerm));
return uni;
})
.chain(models -> checkoutService.create(models.stream().map(LicenceModel::getId).toList(),
securityCtx));
}
public Uni<?> deleteLicence(long id) {
return repository.findById(id)
.call(__ -> checkoutService.canDeleteLicence(id)
.invoke(Unchecked.consumer(b -> {
if (!b) throw new DBadRequestException(
"Impossible de supprimer une licence pour laquelle un paiement est en cours");
})))
.call(model -> ls.logADelete(model))
.chain(model -> repository.delete(model));
}
@@ -160,6 +188,11 @@ public class LicenceService {
public Uni<?> deleteAskLicence(long id, Consumer<MembreModel> checkPerm) {
return repository.findById(id)
.call(licenceModel -> Mutiny.fetch(licenceModel.getMembre()).invoke(checkPerm))
.call(__ -> checkoutService.canDeleteLicence(id)
.invoke(Unchecked.consumer(b -> {
if (!b) throw new DBadRequestException(
"Impossible de supprimer une licence pour laquelle un paiement est en cours");
})))
.invoke(Unchecked.consumer(licenceModel -> {
if (licenceModel.isValidate())
throw new DBadRequestException("Impossible de supprimer une licence déjà validée");

12
src/main/java/fr/titionfire/ffsaf/domain/service/LoggerService.java
View File

@@ -71,10 +71,18 @@ public class LoggerService {
message));
}
public void logAnonymous(ActionType action, ObjectType object, String message, String target_name, Long target_id) {
buffer.add(new LogModel(null, null, new Date(), action, object, target_id, target_name, message));
}
public void log(ActionType action, String message, LoggableModel model) {
log(action, model.getObjectType(), message, model.getObjectName(), model.getId());
}
public void logAnonymous(ActionType action, String message, LoggableModel model) {
logAnonymous(action, model.getObjectType(), message, model.getObjectName(), model.getId());
}
public void logAdd(LoggableModel model) {
log(ActionType.ADD, "", model);
}
@@ -83,6 +91,10 @@ public class LoggerService {
log(ActionType.UPDATE, message, model);
}
public void logUpdateAnonymous(String message, LoggableModel model) {
logAnonymous(ActionType.UPDATE, message, model);
}
public void logChange(String champ, Object o1, Object o2, LoggableModel model) {
if (Objects.equals(o1, o2))
return;

28
src/main/java/fr/titionfire/ffsaf/domain/service/WebhookService.java Normal file
View File

@@ -0,0 +1,28 @@
package fr.titionfire.ffsaf.domain.service;
import fr.titionfire.ffsaf.rest.client.dto.HelloassoNotification;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.config.inject.ConfigProperty;
@ApplicationScoped
public class WebhookService {
@Inject
CheckoutService checkoutService;
@ConfigProperty(name = "helloasso.organizationSlug")
String organizationSlug;
public Uni<Response> helloAssoNotification(HelloassoNotification notification) {
if (notification.getEventType().equals("Payment")){
if (notification.getData().getOrder().getOrganizationSlug().equalsIgnoreCase(organizationSlug)){
return checkoutService.paymentStatusChange(notification.getData().getState(), notification.getMetadata());
}
}
return Uni.createFrom().item(Response.ok().build());
}
}

18
src/main/java/fr/titionfire/ffsaf/rest/LicenceEndpoints.java
View File

@@ -81,6 +81,21 @@ public class LicenceEndpoints {
.map(licenceModels -> licenceModels.stream().map(SimpleLicence::fromModel).toList());
}
@POST
@Path("pay")
@RolesAllowed({"club_president", "club_secretaire", "club_respo_intra"})
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Operation(summary = "Paiement des licence", description = "Retourne le lien de paiement pour les licence des membre fournie")
@APIResponses(value = {
@APIResponse(responseCode = "200", description = "Commande avec succès"),
@APIResponse(responseCode = "403", description = "Accès refusé"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
})
public Uni<String> payLicences(@Parameter(description = "Id des membres") List<Long> ids) {
return licenceService.payLicences(ids, checkPerm, securityCtx);
}
@POST
@Path("{id}")
@RolesAllowed("federation_admin")
@@ -98,7 +113,6 @@ public class LicenceEndpoints {
return licenceService.setLicence(id, form).map(SimpleLicence::fromModel);
}
@POST
@Path("validate")
@RolesAllowed("federation_admin")
@@ -110,7 +124,7 @@ public class LicenceEndpoints {
@APIResponse(responseCode = "403", description = "Accès refusé"),
@APIResponse(responseCode = "500", description = "Erreur interne du serveur")
})
public Uni<?> valideLicences(@Parameter(description = "Id des membre a valider") List<Long> ids) {
public Uni<?> valideLicences(@Parameter(description = "Id des membres a valider") List<Long> ids) {
return licenceService.valideLicences(ids);
}

53
src/main/java/fr/titionfire/ffsaf/rest/WebhookEndpoints.java Normal file
View File

@@ -0,0 +1,53 @@
package fr.titionfire.ffsaf.rest;
import fr.titionfire.ffsaf.domain.service.WebhookService;
import fr.titionfire.ffsaf.rest.client.dto.HelloassoNotification;
import io.smallrye.mutiny.Uni;
import io.vertx.ext.web.RoutingContext;
import jakarta.inject.Inject;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.config.inject.ConfigProperty;
import org.eclipse.microprofile.openapi.annotations.Operation;
import org.jboss.logging.Logger;
@Path("api/webhook")
public class WebhookEndpoints {
private static final Logger LOGGER = Logger.getLogger(WebhookEndpoints.class);
@Inject
WebhookService webhookService;
@Inject
RoutingContext context;
@ConfigProperty(name = "helloasso.webhook.ip-source")
String helloassoIp;
@ConfigProperty(name = "quarkus.http.proxy.proxy-address-forwarding")
boolean proxyForwarding;
@POST
@Path("ha")
@Operation(hidden = true)
@Consumes(MediaType.APPLICATION_JSON)
public Uni<Response> helloAsso(HelloassoNotification notification) {
String ip;
if (proxyForwarding) {
ip = context.request().getHeader("X-Forwarded-For");
if (ip == null)
ip = context.request().authority().host();
} else {
ip = context.request().authority().host();
}
if (!helloassoIp.equals(ip)) {
LOGGER.infof("helloAsso webhook reject : bas ip (%s)", ip);
return Uni.createFrom().item(Response.status(Response.Status.FORBIDDEN).build());
}
return webhookService.helloAssoNotification(notification);
}
}

32
src/main/java/fr/titionfire/ffsaf/rest/client/HelloAssoAuthClient.java Normal file
View File

@@ -0,0 +1,32 @@
package fr.titionfire.ffsaf.rest.client;
import fr.titionfire.ffsaf.rest.client.dto.TokenResponse;
import io.smallrye.mutiny.Uni;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
@Path("/")
@RegisterRestClient(configKey = "helloasso-auth")
public interface HelloAssoAuthClient {
@POST
@Path("/token")
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Produces(MediaType.APPLICATION_JSON)
Uni<TokenResponse> getToken(
@FormParam("grant_type") String grantType,
@FormParam("client_id") String clientId,
@FormParam("client_secret") String clientSecret
);
@POST
@Path("/token")
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
@Produces(MediaType.APPLICATION_JSON)
Uni<TokenResponse> refreshToken(
@FormParam("grant_type") String grantType,
@FormParam("client_id") String clientId,
@FormParam("refresh_token") String refreshToken
);
}

24
src/main/java/fr/titionfire/ffsaf/rest/client/HelloAssoHeadersFactory.java Normal file
View File

@@ -0,0 +1,24 @@
package fr.titionfire.ffsaf.rest.client;
import fr.titionfire.ffsaf.domain.service.HelloAssoTokenService;
import io.quarkus.rest.client.reactive.ReactiveClientHeadersFactory;
import io.smallrye.mutiny.Uni;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.MultivaluedMap;
import org.jboss.resteasy.reactive.common.util.MultivaluedTreeMap;
@ApplicationScoped
public class HelloAssoHeadersFactory extends ReactiveClientHeadersFactory {
@Inject
HelloAssoTokenService helloAssoTokenService;
@Override
public Uni<MultivaluedMap<String, String>> getHeaders(MultivaluedMap<String, String> incomingHeaders,
MultivaluedMap<String, String> clientOutgoingHeaders) {
MultivaluedMap<String, String> map = new MultivaluedTreeMap<>();
return helloAssoTokenService.getValidAccessToken()
.invoke(token -> map.putSingle("Authorization", "Bearer " + token)).map(__ -> map);
}
}

51
src/main/java/fr/titionfire/ffsaf/rest/client/HelloAssoService.java Normal file
View File

@@ -0,0 +1,51 @@
package fr.titionfire.ffsaf.rest.client;
import fr.titionfire.ffsaf.rest.client.dto.CheckoutIntentsRequest;
import fr.titionfire.ffsaf.rest.client.dto.CheckoutIntentsResponse;
import io.quarkus.rest.client.reactive.ClientExceptionMapper;
import io.smallrye.mutiny.Uni;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import org.eclipse.microprofile.rest.client.annotation.RegisterClientHeaders;
import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;
import java.io.ByteArrayInputStream;
import java.lang.reflect.Method;
import java.nio.charset.StandardCharsets;
@Path("/")
@RegisterRestClient(configKey = "helloasso-api")
@RegisterClientHeaders(HelloAssoHeadersFactory.class)
public interface HelloAssoService {
@GET
@Path("/users/me/organizations")
@Produces("text/plain")
Uni<String> test();
@POST
@Path("organizations/{organizationSlug}/checkout-intents")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
Uni<CheckoutIntentsResponse> checkout(@PathParam("organizationSlug") String organizationSlug,
CheckoutIntentsRequest data);
@ClientExceptionMapper
static RuntimeException toException(Response response, Method method) {
if (!method.getDeclaringClass().getName().equals("fr.titionfire.ffsaf.rest.client.HelloAssoService"))
return null;
if (method.getName().equals("checkout")) {
if (response.getStatus() == 400) {
if (response.getEntity() instanceof ByteArrayInputStream) {
ByteArrayInputStream error = response.readEntity(ByteArrayInputStream.class);
return new RuntimeException(new String(error.readAllBytes(), StandardCharsets.UTF_8));
}
return new RuntimeException("The remote service responded with HTTP 400");
}
}
return null;
}
}

14
src/main/java/fr/titionfire/ffsaf/rest/client/dto/ApiError.java Normal file
View File

@@ -0,0 +1,14 @@
package fr.titionfire.ffsaf.rest.client.dto;
import io.quarkus.runtime.annotations.RegisterForReflection;
@RegisterForReflection
public class ApiError {
public String error;
public String error_description;
@Override
public String toString() {
return error + ": " + error_description;
}
}

30
src/main/java/fr/titionfire/ffsaf/rest/client/dto/CheckoutIntentsRequest.java Normal file
View File

@@ -0,0 +1,30 @@
package fr.titionfire.ffsaf.rest.client.dto;
import io.quarkus.runtime.annotations.RegisterForReflection;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@RegisterForReflection
public class CheckoutIntentsRequest {
public int totalAmount;
public int initialAmount;
public String itemName;
public String backUrl;
public String errorUrl;
public String returnUrl;
public boolean containsDonation;
public Payer payer;
public CheckoutMetadata metadata;
@Data
@AllArgsConstructor
@RegisterForReflection
public static class Payer {
public String firstName;
public String lastName;
public String email;
}
}

11
src/main/java/fr/titionfire/ffsaf/rest/client/dto/CheckoutIntentsResponse.java Normal file
View File

@@ -0,0 +1,11 @@
package fr.titionfire.ffsaf.rest.client.dto;
import io.quarkus.runtime.annotations.RegisterForReflection;
import lombok.Data;
@Data
@RegisterForReflection
public class CheckoutIntentsResponse {
public int id;
public String redirectUrl;
}

12
src/main/java/fr/titionfire/ffsaf/rest/client/dto/CheckoutMetadata.java Normal file
View File

@@ -0,0 +1,12 @@
package fr.titionfire.ffsaf.rest.client.dto;
import io.quarkus.runtime.annotations.RegisterForReflection;
import lombok.AllArgsConstructor;
import lombok.Data;
@Data
@AllArgsConstructor
@RegisterForReflection
public class CheckoutMetadata {
public long checkoutDBId;
}

16
src/main/java/fr/titionfire/ffsaf/rest/client/dto/HelloassoNotification.java Normal file
View File

@@ -0,0 +1,16 @@
package fr.titionfire.ffsaf.rest.client.dto;
import io.quarkus.runtime.annotations.RegisterForReflection;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@RegisterForReflection
public class HelloassoNotification {
private NotificationData data;
private String eventType;
private CheckoutMetadata metadata;
}

30
src/main/java/fr/titionfire/ffsaf/rest/client/dto/NotificationData.java Normal file
View File

@@ -0,0 +1,30 @@
package fr.titionfire.ffsaf.rest.client.dto;
import io.quarkus.runtime.annotations.RegisterForReflection;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@RegisterForReflection
public class NotificationData {
private Order order;
private Integer id;
private String organizationSlug;
private String checkoutIntentId;
private String oldSlugOrganization; // Pour les changements de nom d'association
private String newSlugOrganization;
private String state; // Pour les formulaires
@Data
@NoArgsConstructor
@AllArgsConstructor
@RegisterForReflection
public static class Order {
private Integer id;
private String organizationSlug;
}
}

30
src/main/java/fr/titionfire/ffsaf/rest/client/dto/TokenResponse.java Normal file
View File

@@ -0,0 +1,30 @@
package fr.titionfire.ffsaf.rest.client.dto;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.quarkus.runtime.annotations.RegisterForReflection;
@RegisterForReflection
public class TokenResponse {
@JsonProperty("access_token")
public String accessToken;
@JsonProperty("refresh_token")
public String refreshToken;
@JsonProperty("token_type")
public String tokenType; // Toujours "bearer"
@JsonProperty("expires_in")
public long expiresIn; // Durée de validité en secondes (1800s = 30min)
// Pour stocker l'heure d'obtention du token
private long timestamp;
public TokenResponse() {
this.timestamp = System.currentTimeMillis() / 1000; // Timestamp en secondes
}
// Vérifie si le token est expiré
public boolean isExpired() {
return (System.currentTimeMillis() / 1000) - timestamp >= expiresIn;
}
}