integration-web-core--socle 1.4.2

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/LoyaltyProgramsController.java

@@ -0,0 +1,81 @@
+package com.adeo.customerprofilebackend.loyalty;
+
+import com.adeo.customerprofilebackend.commons.helpers.JwtHelper;
+import com.adeo.customerprofilebackend.commons.helpers.LdapHelper;
+import com.adeo.customerprofilebackend.commons.log.ActionType;
+import com.adeo.customerprofilebackend.commons.log.LogService;
+import com.adeo.customerprofilebackend.customer.CustomerService;
+import com.adeo.customerprofilebackend.customer.enums.CustomerTypeEnum;
+import com.adeo.customerprofilebackend.customer.mapper.CustomerTypeMapper;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramsDto;
+import com.adeo.ipnteam.lys.client.models.MembershipAction;
+import com.adeo.ipnteam.reachfive.client.AccessTokenManager;
+import io.kobi.security.common.KobiUser;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.security.core.annotation.AuthenticationPrincipal;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+
+import static com.adeo.customerprofilebackend.config.Constants.HAS_ROLE_CUSTOMER_OR_HAS_ROLE_COLLAB_AND_AUTHORITY_LOYALTY_READ;
+
+@RestController
+@Slf4j
+@RequestMapping("/loyalties")
+@RequiredArgsConstructor
+public class LoyaltyProgramsController {
+
+    private final LoyaltyService loyaltyService;
+    private final LogService logService;
+    private final CustomerService customerService;
+    private final AccessTokenManager accessTokenManager;
+
+    @GetMapping
+    public Mono<ProgramsDto> getAvailableProgramsForCustomer(
+            final ServerWebExchange serverWebExchange,
+            @AuthenticationPrincipal final KobiUser kobiUser,
+            @RequestParam(value = "customerNumber", required = false) final String customerNumber,
+            @RequestParam(value = "storeId", required = false) final Integer storeId,
+            @RequestParam(value = "customerType", required = false) final CustomerTypeEnum customerTypeEnum) {
+
+        if (kobiUser == null) {
+            if (storeId != null) {
+                return loyaltyService.getAvailableLoyaltyProgramsFor(storeId, CustomerTypeMapper.customerTypeEnumToLysCustomerType(customerTypeEnum), null, MembershipAction.MEMBERSHIP, null);
+            } else {
+                throw new IllegalArgumentException("storeId is required");
+            }
+        } else if (JwtHelper.isCollab(kobiUser) && customerNumber != null) {
+            return accessTokenManager.getManagementToken()
+                    .flatMap(token -> customerService.getCustomer(token.getAccessToken(), customerNumber, LdapHelper.extractAdeoOperator(kobiUser.getUserId())))
+                    .flatMap(customer -> loyaltyService.getAvailableProgramsForCustomer(kobiUser, customer)
+                            .doOnSuccess(customers -> logService.logAction(
+                                    serverWebExchange,
+                                    ActionType.GET,
+                                    kobiUser.getUserId(),
+                                    customerNumber,
+                                    "get available loyalty programs")
+                            ));
+
+        } else if (StringUtils.isNotEmpty(kobiUser.getUserId())) {
+            return customerService.getCustomer(kobiUser.getAccessToken(), kobiUser.getUserId(), null)
+                    .flatMap(customer -> loyaltyService.getAvailableProgramsForCustomer(kobiUser, customer));
+        } else {
+            throw new IllegalArgumentException("Unauthorized");
+        }
+    }
+
+    @PreAuthorize(HAS_ROLE_CUSTOMER_OR_HAS_ROLE_COLLAB_AND_AUTHORITY_LOYALTY_READ)
+    @GetMapping("/{type}")
+    public Mono<ProgramDto> getLoyaltyProgramByType(
+            @PathVariable("type") final String type) {
+        return loyaltyService.getLoyaltyProgramByType(type);
+    }
+}

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/LoyaltyService.java

@@ -0,0 +1,262 @@
+package com.adeo.customerprofilebackend.loyalty;
+
+import com.adeo.customerprofilebackend.clients.exceptions.UnauthorizedException;
+import com.adeo.customerprofilebackend.commons.helpers.JwtHelper;
+import com.adeo.customerprofilebackend.commons.helpers.LdapHelper;
+import com.adeo.customerprofilebackend.commons.oney.StoreProperties;
+import com.adeo.customerprofilebackend.config.LoyaltyProgramConfig;
+import com.adeo.customerprofilebackend.config.OneyConfig;
+import com.adeo.customerprofilebackend.customer.dtos.CustomerDto;
+import com.adeo.customerprofilebackend.customer.enums.CustomerTypeEnum;
+import com.adeo.customerprofilebackend.loyalty.dtos.LoyaltyCardDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramsDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.invitations.LoyaltyInvitationDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.invitations.UserInvitationAction;
+import com.adeo.customerprofilebackend.loyalty.dtos.pointshistories.LoyaltyPointsHistoriesDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.pointtransformation.PointTransformationDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.targetedoffer.PromotionalRewardDto;
+import com.adeo.customerprofilebackend.loyalty.exceptions.CoOwnerInvitationNotFoundException;
+import com.adeo.customerprofilebackend.loyalty.mappers.LoyaltyAccountMapper;
+import com.adeo.customerprofilebackend.loyalty.mappers.LoyaltyInvitationsMapper;
+import com.adeo.customerprofilebackend.loyalty.mappers.LoyaltyProgramMapper;
+import com.adeo.customerprofilebackend.loyalty.mappers.PointTansformationMapper;
+import com.adeo.customerprofilebackend.loyalty.mappers.TargetedOfferMapper;
+import com.adeo.customerprofilebackend.loyalty.requests.PatchTargetedOfferRequest;
+import com.adeo.customerprofilebackend.loyalty.requests.PointTransformationRequest;
+import com.adeo.customerprofilebackend.payments.mappers.OneyMapper;
+import com.adeo.customerprofilebackend.resource.StoreService;
+import com.adeo.ipnteam.lys.client.LysClient;
+import com.adeo.ipnteam.lys.client.LysClientException;
+import com.adeo.ipnteam.lys.client.models.CustomerType;
+import com.adeo.ipnteam.lys.client.models.MembershipAction;
+import com.adeo.ipnteam.lys.client.models.MembershipContext;
+import com.adeo.ipnteam.lys.client.models.SortDirection;
+import com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationActorType;
+import com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationTopic;
+import com.adeo.ipnteam.lyse.targetedoffer.client.LyseCotationClient;
+import com.adeo.ipnteam.lyse.targetedoffer.client.LyseTargetedOfferClient;
+import com.adeo.ipnteam.lyse.targetedoffer.client.models.NextRewardPrediction;
+import com.adeo.ipnteam.oney.client.OneyClient;
+import com.adeo.ipnteam.oney.client.models.UrlResponse;
+import com.adeo.ipnteam.ping.client.PingTokenManager;
+import io.kobi.security.common.KobiUser;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Collections;
+
+import static com.adeo.customerprofilebackend.config.Constants.STORE_CODE_ATTRIBUTE;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class LoyaltyService {
+
+    private final LysClient lysClient;
+
+    private final LyseTargetedOfferClient lyseTargetedOfferClient;
+
+    private final LyseCotationClient lyseCotationClient;
+
+    private final OneyClient oneyClient;
+
+    private final OneyConfig oneyConfiguration;
+
+    private final PingTokenManager pingTokenManager;
+
+    private final LoyaltyProgramConfig loyaltyProgramConfig;
+
+    private final StoreService storeService;
+
+    @Value("${currency.label}")
+    private String currencyLabel;
+
+    public Mono<ProgramsDto> getAvailableProgramsForCustomer(final KobiUser kobiUser, final CustomerDto customerDto) {
+
+        return getAvailableLoyaltyProgramsFor(getPointOfSale(kobiUser, customerDto.getStoreCode()), customerDto,
+                LdapHelper.extractAdeoOperator(kobiUser.getUserId()));
+    }
+
+    public Integer getPointOfSale(final KobiUser kobiUser, final Integer storeCode) {
+        if (storeCode == null) {
+            if (StringUtils.isEmpty(kobiUser.getAttributes().get(STORE_CODE_ATTRIBUTE))) {
+                return loyaltyProgramConfig.getDefaultStoreCode();
+            } else {
+                return Integer.valueOf(kobiUser.getAttributes().get(STORE_CODE_ATTRIBUTE));
+            }
+        }
+        return storeCode;
+    }
+
+    private Mono<ProgramsDto> getAvailableLoyaltyProgramsFor(final Integer pointOfSale,
+                                                             final CustomerDto customerDto,
+                                                             final String adeoOperator) {
+
+        final CustomerType customerType;
+
+        if (customerDto.getType() == null) {
+            log.error("Customer type is null on getAvailableLoyaltyProgramsFor call. UserId={}", customerDto.getId()); //Issue detected in production. Check after front refactoring
+            customerType = CustomerType.PARTICULAR;
+        } else {
+            customerType = CustomerTypeEnum.INHABITANT.equals(customerDto.getType()) ? CustomerType.PARTICULAR : CustomerType.PROFESSIONAL;
+        }
+
+        if (customerDto.getLoyalty() != null
+                && customerDto.getLoyalty().getType() != null
+                && customerDto.getLoyalty().getType().getLabel() != null) {
+
+            final String loyaltyType = String.valueOf(customerDto.getLoyalty().getType().getId());
+            final MembershipAction membershipAction = customerDto.getLoyalty().getRemembershipAvailable() != null && customerDto.getLoyalty().getRemembershipAvailable()
+                    ? MembershipAction.REMEMBERSHIP : MembershipAction.UPGRADE;
+
+            return getAvailableLoyaltyProgramsFor(pointOfSale, customerType, loyaltyType, membershipAction, adeoOperator);
+        }
+
+        return getAvailableLoyaltyProgramsFor(pointOfSale, customerType, null, MembershipAction.MEMBERSHIP, adeoOperator);
+    }
+
+    public Mono<ProgramsDto> getAvailableLoyaltyProgramsFor(final Integer pointOfSale,
+                                                            final CustomerType customerType,
+                                                            final String currentLoyaltyType,
+                                                            final MembershipAction membershipAction,
+                                                            final String adeoOperator) {
+
+        final MembershipContext membershipContext = StringUtils.isEmpty(adeoOperator) ? MembershipContext.AUTONOMY : MembershipContext.ASSISTED;
+
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(accessToken -> lysClient.getAvailableProgramsForChangeAndRemembership(accessToken, adeoOperator, customerType, pointOfSale,
+                                currentLoyaltyType, membershipAction, membershipContext)
+                        .map(programs -> LoyaltyProgramMapper.mapPrograms(programs, loyaltyProgramConfig))
+                        .onErrorMap(LysClientException.class, e -> new LysClientException(e.getStatus(), e.getMessage())));
+    }
+
+    public Mono<ProgramDto> getLoyaltyProgramByType(final String type) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(token -> lysClient.getLoyaltyProgram(type, token))
+                .map(LoyaltyProgramMapper::mapProgram);
+    }
+
+    public Mono<LoyaltyCardDto> getLoyaltyInfos(final String customerNumber, final boolean includeCoOwner, final String performingUser) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(token -> lysClient.getLoyaltyAccount(customerNumber, includeCoOwner, token, LdapHelper.extractAdeoOperator(performingUser)))
+                .map(loyaltyAccountModel -> LoyaltyAccountMapper.loyaltyCardModelToLoyaltyCardDto(loyaltyAccountModel, customerNumber))
+                .switchIfEmpty(Mono.just(buildEmptyLoyaltyCard()));
+    }
+
+    private LoyaltyCardDto buildEmptyLoyaltyCard() {
+
+        return LoyaltyCardDto.builder()
+                .hasLoyalty(false)
+                .build();
+    }
+
+    @Deprecated
+    /**
+     @deprecrated use same method defined in PaymentsService
+     */
+    public Mono<String> getFundingUrl(final KobiUser kobiUser, final String customerNumber) {
+        if (kobiUser.getAttributes() == null || kobiUser.getAttributes().get(STORE_CODE_ATTRIBUTE) == null) {
+            throw new IllegalStateException("No store code defined for the collaborator " + kobiUser.getUserId());
+        }
+        final String userStore = kobiUser.getAttributes().get(STORE_CODE_ATTRIBUTE);
+        final StoreProperties storeProperties = oneyConfiguration.getStorePropertiesByStoreId(userStore);
+        if (storeProperties == null) {
+            throw new IllegalArgumentException("the store " + userStore + " cannot create a funding loyalty");
+        }
+        return oneyClient.generatePaymentUrl(
+                        OneyMapper.getGeneratePaymentUrlRequest(
+                                oneyConfiguration.getLanguage(),
+                                storeProperties.getMerchantGuid(),
+                                oneyConfiguration.getPspGuid(),
+                                oneyConfiguration.getSuccessUrl(),
+                                LdapHelper.extractAdeoOperator(kobiUser.getUserId())))
+                .map(UrlResponse::getReturnedUrl);
+    }
+
+    public Flux<PointTransformationDto> getAvailablePointTransformations(final String customerNumber) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(accessToken -> lyseCotationClient.getAvailablePointTransformations(customerNumber, accessToken, NextRewardPrediction.FIRST)
+                        .map(cotationLoyaltyRewards -> PointTansformationMapper.cotationLoyaltyRewardsToPointTransformationDto(cotationLoyaltyRewards, currencyLabel)))
+                .flatMapMany(Flux::fromIterable);
+    }
+
+    public Mono<Void> subscribeToPointTransformation(final String customerNumber, final PointTransformationRequest request) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(accessToken ->
+                        lyseCotationClient.subscribePointTransformation(customerNumber, accessToken, request.getActivationCode(), request.getPointsToTransform()).then()
+                );
+    }
+
+    public Mono<LoyaltyPointsHistoriesDto> getLoyaltyPointsHistories(final String customerNumber,
+                                                                     final Integer page,
+                                                                     final Integer rowsPerPage,
+                                                                     final SortDirection sortDirection) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(accessToken -> lysClient.getPointsHistories(customerNumber, page, rowsPerPage, sortDirection, accessToken))
+                .zipWith(storeService.retrieveAllStoresOfCompany().collectMap(poi -> poi.getPoiId().toString(), poi -> poi))
+                .map(tuple2 -> LoyaltyAccountMapper.loyaltyPointsHistoriesModelToLoyaltyPointsHistoriesDto(tuple2.getT1(), tuple2.getT2()));
+    }
+
+    public Flux<PromotionalRewardDto> getTargetedOffersByCustomer(final KobiUser kobiUser, final String customerNumber) {
+        return lyseTargetedOfferClient.getTargetedOffersByCustomer(customerNumber, LdapHelper.extractAdeoOperator(kobiUser.getUserId()))
+                .map(lyseTargetedOffer -> TargetedOfferMapper.lyseTargetedOfferToPromotionalRewardsDto(lyseTargetedOffer, true))
+                .flatMap(Flux::fromIterable);
+    }
+
+    public Flux<PromotionalRewardDto> getReactivableTargetedOffers(final KobiUser kobiUser, final String customerNumber) {
+        return lyseTargetedOfferClient.getReactivableTargetedOffers(customerNumber, LdapHelper.extractAdeoOperator(kobiUser.getUserId()))
+                .map(lyseTargetedOffer -> TargetedOfferMapper.lyseTargetedOfferToPromotionalRewardsDto(lyseTargetedOffer, false))
+                .onErrorReturn(Collections.emptyList())
+                .flatMap(Flux::fromIterable);
+    }
+
+    public Mono<Void> patchTargetedOffer(final KobiUser kobiUser, final String customerNumber, final String offerId, final PatchTargetedOfferRequest patchTargetedOfferRequest) {
+        if (patchTargetedOfferRequest != null && Boolean.TRUE.equals(patchTargetedOfferRequest.getActive())) {
+            return lyseTargetedOfferClient.reactivateTargetedOffer(customerNumber, offerId, patchTargetedOfferRequest.getReasonCode(), LdapHelper.extractAdeoOperator(kobiUser.getUserId()));
+        }
+        return Mono.empty();
+    }
+
+    public Mono<LoyaltyInvitationDto> getLoyaltyInvitationById(final String invitationId, final String customerNumber) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(token -> lysClient.getLoyaltyInvitationById(invitationId, token)
+                        .flatMap(loyaltyInvitation -> lysClient.getLoyaltyProgram(loyaltyInvitation.getTargetAccountType(), token)
+                                .map(loyaltyProgram -> LoyaltyInvitationsMapper.loyaltyInvitationToDto(loyaltyInvitation, loyaltyProgram))
+                        )
+                )
+                .switchIfEmpty(Mono.error(new CoOwnerInvitationNotFoundException(String.format("No pending or expired invitation found for id %s", invitationId))))
+                .flatMap(loyaltyInvitationDto -> !StringUtils.equals(loyaltyInvitationDto.getCustomerNumber(), customerNumber) ? Mono.error(new UnauthorizedException(String.format("Invitation %s is not assigned to you", invitationId))) : Mono.just(loyaltyInvitationDto));
+    }
+
+    public Flux<LoyaltyInvitationDto> getLoyaltyInvitationsByCustomer(final String customerNumber, final LoyaltyInvitationTopic topic) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMapMany(token -> lysClient.getLoyaltyInvitationByCustomer(customerNumber, token, topic)
+                        .flatMapMany(loyaltyInvitationResponse -> Flux.fromIterable(loyaltyInvitationResponse.getInvitations())
+                                .filter(loyaltyInvitation -> customerNumber.equals(loyaltyInvitation.getGuestCustomerNumber()))
+                                .map(LoyaltyInvitationsMapper::loyaltyInvitationToDto)
+                                .switchIfEmpty(Flux.empty())));
+    }
+
+    public Mono<LoyaltyInvitationDto> updateLoyaltyInvitationStatus(final String invitationId, final KobiUser kobiUser, final UserInvitationAction userInvitationAction) {
+        LoyaltyInvitationActorType loyaltyInvitationActorType = JwtHelper.isCollab(kobiUser) ? LoyaltyInvitationActorType.EMPLOYEE : LoyaltyInvitationActorType.CUSTOMER;
+        String userId = loyaltyInvitationActorType.equals(LoyaltyInvitationActorType.EMPLOYEE)?LdapHelper.extractAdeoOperator(kobiUser.getUserId()):kobiUser.getUserId();
+
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(token -> lysClient.updateLoyaltyInvitationStatus(invitationId, LoyaltyInvitationsMapper.getUpdateLoyaltyInvitationStatusRequest(userId, userInvitationAction, loyaltyInvitationActorType), token)
+                        .map(LoyaltyInvitationsMapper::loyaltyInvitationToDto)
+                );
+    }
+
+
+    public Mono<Void> resendInvitationByEmail(final String invitationId, final String receiverValue,final KobiUser kobiUser) {
+        return pingTokenManager.getFreshApplicationAccessToken()
+                .flatMap(token -> lysClient.resendInvitationByEmail(invitationId, receiverValue, token, LdapHelper.extractAdeoOperator(kobiUser.getUserId()))
+                );
+    }
+}

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/PdfService.java

@@ -0,0 +1,267 @@
+package com.adeo.customerprofilebackend.loyalty;
+
+import com.adeo.customerprofilebackend.commons.helpers.DateHelper;
+import com.adeo.customerprofilebackend.config.LoyaltyPdfConfig;
+import com.adeo.customerprofilebackend.customer.CustomerService;
+import com.adeo.customerprofilebackend.customer.mapper.CustomerMapper;
+import com.adeo.customerprofilebackend.loyalty.models.pdf.PdfOutputStream;
+import com.adeo.customerprofilebackend.resource.StoreService;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.Address;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.Customer;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyCustomer;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.enums.CommunicationTypeEnum;
+import com.adeo.ipnteam.lys.client.LysAccountNotFoundException;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jasperreports.engine.JREmptyDataSource;
+import net.sf.jasperreports.engine.JRException;
+import net.sf.jasperreports.engine.JasperCompileManager;
+import net.sf.jasperreports.engine.JasperExportManager;
+import net.sf.jasperreports.engine.JasperFillManager;
+import net.sf.jasperreports.engine.JasperPrint;
+import net.sf.jasperreports.engine.JasperReport;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.core.io.buffer.DataBuffer;
+import org.springframework.core.io.buffer.DataBufferFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.server.reactive.ServerHttpResponse;
+import org.springframework.stereotype.Service;
+import reactor.core.publisher.Mono;
+
+import java.io.InputStream;
+import java.text.DecimalFormat;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class PdfService {
+
+    public static final String DEFAULT_TEMPLATE_KEY = "default";
+    private static final String FRONT_DATE_FORMAT = "dd/MM/yyyy";
+    private static final String EXPIRES_HEADER_VALUE = "0";
+    private static final String CACHE_CONTROL_HEADER_VALUE = "must-revalidate, post-check=0, pre-check=0";
+    private static final String PRAGMA_HEADER_VALUE = "public";
+    private static final String CONTENT_DISPOSITION_HEADER_PREFIX = "attachment; filename=";
+    private static final String FILE_EXTENSION = ".pdf";
+    private static final String BLANK_SPACE = " ";
+    private static final String END_OF_LINE = "\n";
+    private static final String COMA = ",";
+    private static final DateTimeFormatter FRONT_FORMATTER = DateTimeFormatter.ofPattern(FRONT_DATE_FORMAT);
+
+    private final CustomerService customerService;
+
+    private final StoreService storeService;
+
+    private final LoyaltyPdfConfig loyaltyPdfConfig;
+
+    private static String getCurrentDateFormatted() {
+
+        return LocalDate.now()
+                .format(FRONT_FORMATTER);
+    }
+
+    public Mono<Void> createLoyaltyPdfAndSetHeaders(
+            final ServerHttpResponse response,
+            final String accessToken,
+            final String customerNumber,
+            final String performingUser) {
+
+        final DataBufferFactory bufferFactory = response.bufferFactory();
+
+        final Mono<DataBuffer> dataBufferMono = getCustomerWithStoreNameAndLoyalty(accessToken, customerNumber, performingUser)
+                .map(this::createLoyaltyPDF)
+                .map(bufferFactory::wrap)
+                .doOnSuccess(dataBuffer -> setHeadersForPDF(response, customerNumber));
+
+        return response.writeWith(dataBufferMono);
+    }
+
+    private byte[] createLoyaltyPDF(
+            final CustomerWithStore customer) {
+
+        final LoyaltyCustomer loyalty = customer.getCustomer().getLoyalty();
+
+        return createLoyaltyCardPDF(customer, loyalty,
+                loyaltyPdfConfig.getLysTypeTemplateMapping().getOrDefault(loyalty.getType(), loyaltyPdfConfig.getLysTypeTemplateMapping().get(DEFAULT_TEMPLATE_KEY)))
+                .getBuf();
+    }
+
+    public PdfOutputStream createLoyaltyCardPDF(
+            final CustomerWithStore customerWithStore,
+            final LoyaltyCustomer loyaltyCustomer,
+            final String pdfTemplate) {
+
+        final Customer customer = customerWithStore.getCustomer();
+        final String storeName = customerWithStore.getStoreName();
+        final Address mainAddress = getMainAddressOrEmptyAddress(customerWithStore.getCustomer().getAddresses());
+
+        final Map<String, Object> parameters = new HashMap<>();
+        parameters.put("withCotit", "false");
+
+        final StringBuilder nomTop = new StringBuilder();
+
+        final String civility = CustomerMapper.toCivility(customer.getCivility());
+        nomTop.append(civility).append(BLANK_SPACE);
+        nomTop.append(customer.getLastName()).append(BLANK_SPACE);
+        nomTop.append(customer.getFirstName()).append(COMA);
+        parameters.put("nom_top", nomTop.toString());
+
+        final String nomBottom = civility + BLANK_SPACE +
+                customer.getLastName() + BLANK_SPACE +
+                customer.getFirstName() + COMA;
+        parameters.put("nom_bottom", nomBottom);
+
+        final String fullName = customer.getFirstName() +
+                BLANK_SPACE +
+                customer.getLastName();
+        parameters.put("fullName", fullName);
+
+        parameters.put("date", getCurrentDateFormatted());
+
+        // Always true
+        if (loyaltyCustomer != null) {
+
+            if (StringUtils.isEmpty(loyaltyCustomer.getTypeLabel())) {
+                log.error("Error : loyalty card type label must not be empty");
+                throw new IllegalStateException("Error : loyalty card type label must not be empty");
+            }
+
+            parameters.put("dureecarte", loyaltyCustomer.getTypeLabel());
+            parameters.put("montant", buildAmountLabel(loyaltyCustomer.getMembershipFeeToPay()));
+            parameters.put("barcode", loyaltyCustomer.getCardNumber());
+
+            final String validityDate = loyaltyCustomer.getValidityEndDate() == null ? null : DateHelper.zonedDateTimeToPdfFormat(loyaltyCustomer.getValidityEndDate());
+            parameters.put("datevalidite", validityDate);
+
+        }
+
+        // Infos du client
+        parameters.put("email", CustomerMapper.getCommunicationChannel(customer.getCommunicationChannels(), CommunicationTypeEnum.EMAIL));
+        parameters.put("numero_regroupement", customer.getId());
+
+        // Magasin de rattachement
+        parameters.put("magasin", storeName);
+
+        final StringBuilder address = new StringBuilder();
+        address.append(mainAddress.getStreetNameNumber()).append(END_OF_LINE);
+        if (StringUtils.isNotBlank(mainAddress.getComplementaryLocalizationAddress())) {
+            address.append(mainAddress.getComplementaryLocalizationAddress()).append(END_OF_LINE);
+        }
+        if (StringUtils.isNotBlank(mainAddress.getComplementaryCity())) {
+            address.append(mainAddress.getComplementaryCity()).append(END_OF_LINE);
+        }
+        address.append(mainAddress.getZipCode()).append(END_OF_LINE);
+        address.append(mainAddress.getCity()).append(END_OF_LINE);
+        address.append(mainAddress.getCountryCode()).append(END_OF_LINE);
+
+        parameters.put("adresse", address.toString());
+
+        PdfOutputStream result = null;
+        try {
+            result = this.createPDF(pdfTemplate, parameters);
+        } catch (final JRException e) {
+            log.error("An error occured while trying to create loyalty pdf : ", e);
+        }
+        return result;
+    }
+
+    private PdfOutputStream createPDF(final String templateName, final Map<String, Object> parameters) throws JRException {
+
+        log.debug("Trying to load jrxml from the following path : {}", templateName);
+
+        final InputStream templateStream = Thread.currentThread().getContextClassLoader().getResourceAsStream(templateName);
+
+        final JasperReport report = JasperCompileManager.compileReport(templateStream);
+
+        final PdfOutputStream pdfStream = new PdfOutputStream();
+        final JasperPrint jasperPrint = JasperFillManager.fillReport(report, parameters, new JREmptyDataSource());
+        JasperExportManager.exportReportToPdfStream(jasperPrint, pdfStream);
+        return pdfStream;
+    }
+
+    private Address getMainAddressOrEmptyAddress(final List<Address> addresses) {
+        if (CollectionUtils.isEmpty(addresses)) {
+            return Address.builder()
+                    .streetNameNumber("")
+                    .zipCode("")
+                    .complementaryCity("")
+                    .city("")
+                    .countryCode("")
+                    .build();
+        }
+        return addresses.stream()
+                .filter(Address::getMainAddress)
+                .findFirst()
+                .orElse(Address.builder()
+                        .streetNameNumber("")
+                        .zipCode("")
+                        .complementaryCity("")
+                        .city("")
+                        .countryCode("")
+                        .build());
+    }
+
+    private Mono<CustomerWithStore> getCustomerWithStoreNameAndLoyalty(
+            final String accessToken,
+            final String customerNumber,
+            final String performingUser) {
+
+        return customerService.getOrchestrationProfile(accessToken, customerNumber, performingUser)
+                .flatMap(customer -> {
+                    if (customer.getLoyalty() == null || StringUtils.isEmpty(customer.getLoyalty().getCardNumber())) {
+                        return Mono.error(new LysAccountNotFoundException(HttpStatus.NOT_FOUND, "Not loyalty account found"));
+                    }
+                    return storeService.getStoreFromCache(customer.getManagementStore())
+                            .map(store -> new CustomerWithStore(customer, store.getLabel()));
+                });
+    }
+
+    private void setHeadersForPDF(final ServerHttpResponse response, final String customerNumber) {
+
+        final String filename = "loyalty-" + customerNumber + FILE_EXTENSION;
+        final HttpHeaders headers = response.getHeaders();
+
+        headers.setContentType(MediaType.APPLICATION_PDF);
+        headers.add(HttpHeaders.EXPIRES, EXPIRES_HEADER_VALUE);
+        headers.add(HttpHeaders.CACHE_CONTROL, CACHE_CONTROL_HEADER_VALUE);
+        headers.add(HttpHeaders.PRAGMA, PRAGMA_HEADER_VALUE);
+        headers.add(HttpHeaders.CONTENT_DISPOSITION, CONTENT_DISPOSITION_HEADER_PREFIX + filename);
+    }
+
+    /**
+     * This method return the amount to pay for membership (ex: "9.00 euros")
+     *
+     * @param membershipFeeToPay
+     * @return
+     */
+    private String buildAmountLabel(Float membershipFeeToPay) {
+
+        if (membershipFeeToPay == null) {
+            membershipFeeToPay = 0.0F;
+        }
+        final DecimalFormat decimalFormat = new DecimalFormat();
+        // Ensure that the amount is always printed with 2 decimal places
+        decimalFormat.setMaximumFractionDigits(2);
+        return decimalFormat.format(membershipFeeToPay) + BLANK_SPACE + loyaltyPdfConfig.getCurrency();
+    }
+
+    @AllArgsConstructor
+    @Getter
+    static class CustomerWithStore {
+
+        private Customer customer;
+
+        private String storeName;
+    }
+
+}

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/dtos/ActionType.java

@@ -0,0 +1,6 @@
+package com.adeo.customerprofilebackend.loyalty.dtos;
+
+public enum ActionType {
+    RENEW,
+    CHANGE,
+}

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/dtos/BadgeDto.java

@@ -0,0 +1,19 @@
+package com.adeo.customerprofilebackend.loyalty.dtos;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public class BadgeDto {
+
+    private BadgeTypeDto type;
+}

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/dtos/BadgeTypeDto.java

@@ -0,0 +1,20 @@
+package com.adeo.customerprofilebackend.loyalty.dtos;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@NoArgsConstructor
+@Builder
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public class BadgeTypeDto {
+
+    private String value;
+    private String label;
+}

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/loyalty/dtos/CguDto.java

@@ -0,0 +1,16 @@
+package com.adeo.customerprofilebackend.loyalty.dtos;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Setter;
+
+@Getter
+@Setter
+@AllArgsConstructor
+@Builder
+public class CguDto {
+
+    private String language;
+    private String url;
+}