integration-web-core--socle 1.4.2

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

@@ -0,0 +1,287 @@
+package com.adeo.customerprofilebackend.loyalty.mappers;
+
+import com.adeo.customerprofilebackend.commons.DateFormatter;
+import com.adeo.customerprofilebackend.config.LoyaltyTypesConfig;
+import com.adeo.customerprofilebackend.loyalty.dtos.BadgeDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.BadgeTypeDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.CoOwnerDTO;
+import com.adeo.customerprofilebackend.loyalty.dtos.LoyaltyCardDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.LoyaltyCardDto.LoyaltyCardDtoBuilder;
+import com.adeo.customerprofilebackend.loyalty.dtos.LoyaltyCardType;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramsDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.RankDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.RankTypeDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.ReEnrollDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.RewardAttributeDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.RewardBurnCriteriaDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.RewardDto;
+import com.adeo.customerprofilebackend.loyalty.helpers.BarcodeHelper;
+import com.adeo.customerprofilebackend.loyalty.helpers.LoyaltyCardHelper;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyBadge;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyCoOwner;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyCounter;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyCustomer;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyRank;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.LoyaltyReward;
+import com.adeo.ipnteam.customerorchestrationv2.client.models.enums.LoyaltyAccountStatus;
+import com.adeo.ipnteam.lys.client.models.LoyaltyAccount;
+import com.adeo.ipnteam.lys.client.models.Support;
+import lombok.RequiredArgsConstructor;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.stream.Collectors;
+
+@RequiredArgsConstructor
+@Component
+public class LoyaltyCustomerMapper {
+
+    public static final String POINTS_TYPE_VALUE = "P";
+    private static final String DEMATERIALIZED_SUPPORT_TAG = "DEMATERIALIZED";
+    private final LoyaltyTypesConfig loyaltyTypesConfig;
+
+    private static LoyaltyCardDtoBuilder getRewards(final LoyaltyCardDtoBuilder builder, final List<LoyaltyReward> rewards) {
+        if (CollectionUtils.isNotEmpty(rewards)) {
+            builder.rewards(toRewardDtoList(rewards));
+            final List<String> filteredDates = rewards.stream()
+                    .filter(reward -> reward.getValidityEndDate() != null && DateFormatter.format(reward.getValidityEndDate()).length() >= 10)
+                    .map(reward -> DateFormatter.format(reward.getValidityEndDate()).substring(0, 10))
+                    .collect(Collectors.toList());
+            getRewardAditionnalData(builder, filteredDates, rewards.size());
+        } else {
+            builder.rewardsCount(0);
+        }
+        return builder;
+    }
+
+    public static void getRewardAditionnalData(final LoyaltyCardDtoBuilder builder, final List<String> filteredDates, final int size) {
+        builder
+                .rewardsCount(size);
+        final String rewardsExpirationDate = filteredDates.stream()
+                .min(CharSequence::compare)
+                .orElse(null);
+        if (StringUtils.isNotEmpty(rewardsExpirationDate)) {
+            final Long expiringRewardsCount = filteredDates.stream()
+                    .filter(date -> date.equals(rewardsExpirationDate))
+                    .count();
+            builder
+                    .rewardsExpirationDate(rewardsExpirationDate)
+                    .expiringRewardsCount(expiringRewardsCount);
+        }
+    }
+
+    public static LoyaltyCardDto toLoyaltyCardDto(final LoyaltyCustomer customerLoyalty, final LocalDate movingDate) {
+
+        return toLoyaltyCardDto(customerLoyalty, movingDate, Fields.values());
+    }
+
+    public static LoyaltyCardDto toLoyaltyCardDto(final LoyaltyCustomer customerLoyalty, final LocalDate movingDate, final Fields... fields) {
+
+        if (customerLoyalty == null || customerLoyalty.getErrorMessage() != null) {
+            return null;
+        }
+
+        final LoyaltyCardDtoBuilder builder = LoyaltyCardDto.builder();
+
+        Arrays.stream(fields).forEach(
+                field -> field.fillBuilder(builder, customerLoyalty)
+        );
+
+        return builder.build();
+    }
+
+    public static String loyaltyCardTypeToLoyaltyCardTypeSupport(final String loyaltyCardType, final ProgramsDto availablePrograms) {
+
+        if (loyaltyCardType == null) {
+            return null;
+        } else if (availablePrograms != null) {
+            return availablePrograms.getPrograms().stream()
+                    .filter(programDto -> loyaltyCardType.equals(programDto.getType()))
+                    .findFirst()
+                    .orElseThrow(() -> new IllegalArgumentException("Program " + loyaltyCardType + " is not available for current subscription"))
+                    .getSupports().stream()
+                    .filter(support -> DEMATERIALIZED_SUPPORT_TAG.equals(support.getTag()))
+                    .findFirst()
+                    .orElse(Support.builder().build())
+                    .getType();
+        }
+
+        return null;
+    }
+
+    public static LoyaltyCardType toLoyaltyCardType(final LoyaltyAccount loyaltyAccount) {
+        if (loyaltyAccount == null) {
+            return null;
+        }
+        return getLoyaltyCardType(loyaltyAccount.getType(), loyaltyAccount.getTypeLabel());
+    }
+
+    public static LoyaltyCardType toLoyaltyCardType(final LoyaltyCustomer loyaltyCustomer) {
+        if (loyaltyCustomer == null || loyaltyCustomer.getErrorMessage() != null) {
+            return null;
+        }
+        return getLoyaltyCardType(loyaltyCustomer.getType(), loyaltyCustomer.getTypeLabel());
+    }
+
+    private static LoyaltyCardType getLoyaltyCardType(final String type, final String typeLabel) {
+        if (type == null) {
+            return null;
+        }
+        return LoyaltyCardType.builder().id(type).label(typeLabel).build();
+
+    }
+
+    private static long computePoints(final List<LoyaltyCounter> counterList) {
+
+        if (counterList == null) {
+            return 0;
+        }
+
+        return counterList.stream()
+                .filter(counter -> POINTS_TYPE_VALUE.equals(counter.getType()))
+                .findFirst()
+                .map(LoyaltyCounter::getValue)
+                .map(Float::longValue)
+                .orElse(0L);
+    }
+
+    private static boolean computeInvalid(final LoyaltyCustomer customerLoyalty) {
+
+        return LoyaltyAccountStatus.INVALID.equals(customerLoyalty.getStatus())
+                || LoyaltyCardHelper.isCardExpireSinceLessThanSixMonths(customerLoyalty);
+    }
+
+    private static ReEnrollDto buildEnrollDto(final LoyaltyCustomer loyaltyAccount) {
+
+        return ReEnrollDto.builder()
+                .valid(LoyaltyCardHelper.isEnrollCard(loyaltyAccount))
+                .endDate(LoyaltyCardHelper.getDateUntilCustomerCanReEnroll(loyaltyAccount))
+                .build();
+    }
+
+    private static List<RewardDto> toRewardDtoList(final List<LoyaltyReward> rewards) {
+
+        if (rewards == null) {
+            return Collections.emptyList();
+        }
+        return rewards.stream()
+                .map(reward -> RewardDto.builder()
+                        .modelCode(reward.getCode())
+                        .modelLabel(reward.getLabel())
+                        .attributes(RewardAttributeDto.builder()
+                                .validityEndDate(DateFormatter.format(reward.getValidityEndDate()))
+                                .value(reward.getValue())
+                                .build())
+                        .burnCriterias(RewardBurnCriteriaDto.builder()
+                                .counterType(reward.getRewardType())
+                                .build())
+                        .build())
+                .collect(Collectors.toList());
+    }
+
+    private static List<BadgeDto> toBadgesDtoList(final List<LoyaltyBadge> badges) {
+
+        return CollectionUtils.isEmpty(badges) ?
+                Collections.emptyList() :
+                badges.stream()
+                        .map(LoyaltyCustomerMapper::toBadgeDto)
+                        .collect(Collectors.toList());
+    }
+
+    private static BadgeDto toBadgeDto(final LoyaltyBadge badge) {
+
+        if (badge == null || badge.getType() == null) {
+            return null;
+        }
+
+        return BadgeDto.builder()
+                .type(BadgeTypeDto.builder()
+                        .value(badge.getType().getValue())
+                        .label(badge.getType().getLabel())
+                        .build())
+                .build();
+    }
+
+    private static RankDto toRankDto(final LoyaltyRank rank) {
+
+        if (rank == null || rank.getType() == null) {
+            return null;
+        }
+
+        return RankDto.builder()
+                .id(rank.getId())
+                .status(rank.getStatus())
+                .type(RankTypeDto.builder()
+                        .label(rank.getType().getLabel())
+                        .value(rank.getType().getValue())
+                        .build())
+                .creationDate(rank.getCreationDate() == null ? null : DateFormatter.format(rank.getCreationDate()))
+                .updateDate(rank.getUpdateDate() == null ? null : DateFormatter.format(rank.getUpdateDate()))
+                .endDate(rank.getEndDate() == null ? null : DateFormatter.format(rank.getEndDate()))
+                .build();
+    }
+
+    private static List<CoOwnerDTO> toCoOwnerDtos(final List<LoyaltyCoOwner> loyaltyCoOwners) {
+        if (CollectionUtils.isEmpty(loyaltyCoOwners)) {
+            return Collections.emptyList();
+        }
+        return loyaltyCoOwners.stream().map(LoyaltyCustomerMapper::toCoOwnerDto).collect(Collectors.toList());
+    }
+
+    private static CoOwnerDTO toCoOwnerDto(final LoyaltyCoOwner loyaltyCoOwner) {
+
+        if (loyaltyCoOwner == null) {
+            return null;
+        }
+
+        return CoOwnerDTO.builder()
+                .name(loyaltyCoOwner.getName())
+                .firstName(loyaltyCoOwner.getFirstName())
+                .cardNumber(loyaltyCoOwner.getCardNumber())
+                .customerId(loyaltyCoOwner.getCustomerId())
+                .build();
+    }
+
+    public enum Fields {
+        NUMBER((builder, loyalty) -> builder.number(loyalty.getCardNumber())),
+        TYPE((builder, loyalty) -> builder.type(toLoyaltyCardType(loyalty))),
+        POINTS((builder, loyalty) -> builder.points(computePoints(loyalty.getCounters()))),
+        STATUS((builder, loyalty) -> builder.status(loyalty.getStatus())),
+        INVALID((builder, loyalty) -> builder.invalid(computeInvalid(loyalty))),
+        EXPIRED((builder, loyalty) -> builder.expired(LoyaltyCardHelper.isCardExpired(loyalty))),
+        RE_ENROLL((builder, loyalty) -> builder.reEnroll(buildEnrollDto(loyalty))),
+        START_DATE((builder, loyalty) -> builder.startDate(DateFormatter.format(loyalty.getValidityStartDate()))),
+        END_DATE((builder, loyalty) -> builder.endDate(DateFormatter.format(loyalty.getValidityEndDate()))),
+        BAR_CODE((builder, loyalty) -> builder.barcode(BarcodeHelper.generateBarcodeBase64(loyalty.getCardNumber()))),
+        HAS_LOYALTY((builder, loyalty) -> builder.hasLoyalty(true)),
+        HAS_CARD_NUMBER((builder, loyalty) -> builder.hasCardNumber(StringUtils.isNotEmpty(loyalty.getCardNumber()))),
+        REWARDS((builder, loyalty) -> getRewards(builder, loyalty.getRewards())),
+        BADGES((builder, loyalty) -> builder.badges(toBadgesDtoList(loyalty.getBadges()))),
+        RANK((builder, loyalty) -> builder.rank(toRankDto(loyalty.getRank()))),
+        MIGRATION_STATE((builder, loyalty) -> builder.migrationState(loyalty.getMigrationState())),
+        CO_OWNER((builder, loyalty) -> builder.coOwners(toCoOwnerDtos(loyalty.getCoOwners()))),
+        REMEMBERSHIP_AVAILABLE((builder, loyalty) -> builder.remembershipAvailable(loyalty.getRemembershipAvailable())),
+        CGU((builder, loyalty) -> builder.cgu(loyalty.getCgu())),
+        POINT_TRANSFORMATION_AVAILABLE((builder, loyalty) -> builder.pointTransformationAvailable(loyalty.getPointTransformationAvailable())),
+        ACCESS_PARTNER_PLATFORM_AVAILABLE((builder, loyalty) -> builder.isAccessPartnerPlatformAvailable(loyalty.isAccessPartnerPlatformAvailable()));
+
+
+        private final BiConsumer<LoyaltyCardDtoBuilder, LoyaltyCustomer> operation;
+
+        Fields(final BiConsumer<LoyaltyCardDtoBuilder, LoyaltyCustomer> operation) {
+
+            this.operation = operation;
+        }
+
+        public void fillBuilder(final LoyaltyCardDtoBuilder loyaltyCardDtoBuilder, final LoyaltyCustomer o) {
+
+            operation.accept(loyaltyCardDtoBuilder, o);
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+package com.adeo.customerprofilebackend.loyalty.mappers;
+
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.invitations.LoyaltyInvitationDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.invitations.UserInvitationAction;
+import com.adeo.customerprofilebackend.loyalty.requests.CreateLoyaltyInvitationAttributesPreRequest;
+import com.adeo.customerprofilebackend.loyalty.requests.CreateLoyaltyInvitationPreRequest;
+import com.adeo.ipnteam.lys.client.models.LoyaltyProgram;
+import com.adeo.ipnteam.lys.client.models.invitations.CreateLoyaltyInvitationRequest;
+import com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitation;
+import com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationActor;
+import com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationActorType;
+import com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationStatus;
+import com.adeo.ipnteam.lys.client.models.invitations.UpdateLoyaltyInvitationStatusRequest;
+import lombok.experimental.UtilityClass;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.NotImplementedException;
+
+import static com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationActorType.CUSTOMER;
+import static com.adeo.ipnteam.lys.client.models.invitations.LoyaltyInvitationActorType.EMPLOYEE;
+
+@UtilityClass
+public class LoyaltyInvitationsMapper {
+
+    public LoyaltyInvitationDto loyaltyInvitationToDto(LoyaltyInvitation loyaltyInvitation) {
+        return loyaltyInvitationToDto(loyaltyInvitation, null);
+    }
+
+    public LoyaltyInvitationDto loyaltyInvitationToDto(LoyaltyInvitation loyaltyInvitation, LoyaltyProgram loyaltyProgram) {
+        ProgramDto programDto = LoyaltyProgramMapper.mapProgram(loyaltyProgram);
+        return LoyaltyInvitationDto.builder()
+                .id(loyaltyInvitation.getId())
+                .topic(loyaltyInvitation.getTopic())
+                .senderIdentifier(loyaltyInvitation.getHostNumber())
+                .senderFirstName(loyaltyInvitation.getHostFirstname())
+                .senderLastName(loyaltyInvitation.getHostName())
+                .customerNumber(loyaltyInvitation.getGuestCustomerNumber())
+                .validityStartDate(loyaltyInvitation.getValidityStartDate())
+                .validityEndDate(loyaltyInvitation.getValidityEndDate())
+                .isExpired(LoyaltyInvitationStatus.EXPIRED.equals(loyaltyInvitation.getStatus()))
+                .status(loyaltyInvitation.getStatus())
+                .accountType(loyaltyInvitation.getTargetAccountType())
+                .cguUrl(programDto != null && CollectionUtils.isNotEmpty(programDto.getCgus()) ? programDto.getCgus().get(0).getUrl() : null)
+                .build();
+    }
+
+    public UpdateLoyaltyInvitationStatusRequest getUpdateLoyaltyInvitationStatusRequest(final String senderValue, final UserInvitationAction userInvitationAction, final LoyaltyInvitationActorType senderType) {
+
+        return UpdateLoyaltyInvitationStatusRequest.builder()
+                .action(userInvitationAction.getUserAction())
+                .senderIdentifierType(senderType)
+                .senderIdentifierValue(senderValue)
+                .build();
+    }
+
+
+
+    public CreateLoyaltyInvitationRequest getCreateLoyaltyInvitationRequest(final String customerNumber, final String performingUser, final CreateLoyaltyInvitationPreRequest preRequest, final CreateLoyaltyInvitationAttributesPreRequest attributes) {
+
+        switch (preRequest.getInvitationTopic()) {
+            case ADD_CO_OWNER:
+                return mapToCreateAddCoownerInvitationRequest();
+
+            case MEMBERSHIP:
+                return mapToCreateMembershipInvitationRequest(customerNumber, performingUser, preRequest, attributes);
+
+            default:
+                return null;
+        }
+    }
+
+    private static CreateLoyaltyInvitationRequest mapToCreateMembershipInvitationRequest(String customerNumber, String performingUser, CreateLoyaltyInvitationPreRequest preRequest, CreateLoyaltyInvitationAttributesPreRequest attributesPreRequest) {
+
+        CreateLoyaltyInvitationRequest.Attributes attributes = CreateLoyaltyInvitationRequest.Attributes.builder()
+                .employeeUid(preRequest.getEmployeeUid())
+                .accountType(preRequest.getAccountType())
+                .channel(attributesPreRequest.getChannel())
+                .pointOfSale(attributesPreRequest.getManagementPointOfSale())
+                .build();
+
+        LoyaltyInvitationActor host = LoyaltyInvitationActor.builder()
+                .identifierType(EMPLOYEE)
+                .identifierValue(performingUser)
+                .build();
+
+        LoyaltyInvitationActor guest = LoyaltyInvitationActor.builder()
+                .identifierType(CUSTOMER)
+                .identifierValue(customerNumber)
+                .build();
+
+        return CreateLoyaltyInvitationRequest.builder()
+                .topic(preRequest.getInvitationTopic())
+                .host(host)
+                .guest(guest)
+                .attributes(attributes)
+                .build();
+    }
+
+    private static CreateLoyaltyInvitationRequest mapToCreateAddCoownerInvitationRequest() {
+        throw new NotImplementedException();
+    }
+
+}

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

@@ -0,0 +1,129 @@
+package com.adeo.customerprofilebackend.loyalty.mappers;
+
+import com.adeo.customerprofilebackend.config.LoyaltyProgramConfig;
+import com.adeo.customerprofilebackend.loyalty.dtos.CguDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.MembershipProcess;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramDto;
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramsDto;
+import com.adeo.ipnteam.lys.client.models.LoyaltyAvailablePrograms;
+import com.adeo.ipnteam.lys.client.models.LoyaltyProgram;
+import com.adeo.ipnteam.lys.client.models.RewardDescription;
+import org.springframework.util.CollectionUtils;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class LoyaltyProgramMapper {
+
+    public static final String YYYY_MM_DD = "yyyyMMdd";
+    private static final String CGU_CODE = "CGU";
+
+    public static ProgramsDto mapPrograms(final LoyaltyAvailablePrograms programs, final LoyaltyProgramConfig loyaltyProgramConfig) {
+
+        final List<ProgramDto> programsDto;
+        if (CollectionUtils.isEmpty(programs.getAvailablePrograms())) {
+            programsDto = Collections.emptyList();
+        } else {
+            programsDto = programs.getAvailablePrograms().stream()
+                    .filter(program -> loyaltyProgramConfig.getExcludedProgramIds() == null || !loyaltyProgramConfig.getExcludedProgramIds().contains(program.getType()))
+                    .map(LoyaltyProgramMapper::mapProgram)
+                    .collect(Collectors.toList());
+        }
+
+        return ProgramsDto.builder()
+                .programs(programsDto)
+                .membershipProcess(computeMembershipProcess(programs))
+                .build();
+    }
+
+    public static ProgramDto mapProgram(final LoyaltyProgram program) {
+
+        if (program == null) {
+            return null;
+        }
+
+        return ProgramDto.builder()
+                .type(program.getType())
+                .label(getTitleFrom(program.getTitle()))
+                .fee(program.getFee())
+                .duration(program.getDuration())
+                .durationUnit(program.getDurationUnit())
+                .cgus(getCguLinksFromLoyaltyProgram(program))
+                .rewards(getRewardsFromDescription(program.getDescription()))
+                .customerTypes(CollectionUtils.isEmpty(program.getCustomerType()) ? Collections.emptyList() : program.getCustomerType())
+                .supports(program.getSupports())
+                .availableFeatures(program.getAvailableFeatures())
+                .build();
+    }
+
+    private static String getTitleFrom(final Map<String, String> titles) {
+
+        if (CollectionUtils.isEmpty(titles)) {
+            return "";
+        }
+
+        return titles.entrySet()
+                .stream()
+                .findFirst()
+                .flatMap(translationValue -> Optional.ofNullable(translationValue.getValue()))
+                .orElse("");
+    }
+
+    private static List<String> getRewardsFromDescription(final Map<String, List<RewardDescription>> description) {
+
+        if (CollectionUtils.isEmpty(description)) {
+            return Collections.emptyList();
+        }
+
+        return description.entrySet().stream()
+                .findFirst()
+                .map(translation -> translation.getValue().stream()
+                        .map(RewardDescription::getTitle)
+                        .collect(Collectors.toList()))
+                .orElseGet(Collections::emptyList);
+    }
+
+    private static List<CguDto> getCguLinksFromLoyaltyProgram(final LoyaltyProgram program) {
+
+        if (CollectionUtils.isEmpty(program.getTerms())) {
+            return Collections.emptyList();
+        }
+
+        return program.getTerms().stream()
+                .filter(term -> term.getCode().equals(CGU_CODE))
+                .findFirst()
+                .flatMap(term -> term.getVersions().stream()
+                        .reduce((v1, v2) -> convertIntoLocalDate(v1.getStartDate()).isAfter(convertIntoLocalDate(v2.getStartDate())) ? v1 : v2)
+                        .flatMap(version -> Optional.ofNullable(version.getLink())))
+                .map(entries -> entries.entrySet().stream()
+                        .map(entry -> CguDto.builder().language(entry.getKey().toUpperCase()).url(entry.getValue()).build())
+                        .collect(Collectors.toList()))
+                .orElse(Collections.emptyList());
+    }
+
+    private static LocalDate convertIntoLocalDate(final String date) {
+        if (date != null && !date.isEmpty()) {
+            final DateTimeFormatter formatter = DateTimeFormatter.ofPattern(YYYY_MM_DD);
+            return LocalDate.parse(date, formatter);
+        }
+
+        return LocalDate.now();
+    }
+
+    private static MembershipProcess computeMembershipProcess(final LoyaltyAvailablePrograms programs) {
+        if (CollectionUtils.isEmpty(programs.getAvailablePrograms())) {
+            return MembershipProcess.NO_MEMBERSHIP;
+        }
+
+        if (programs.isMembershipIsMandatory()) {
+            return programs.getAvailablePrograms().size() == 1 ? MembershipProcess.AUTO_MEMBERSHIP : MembershipProcess.MANDATORY_CLIENT_MEMBERSHIP;
+        } else {
+            return MembershipProcess.OPTIONAL_CLIENT_MEMBERSHIP;
+        }
+    }
+}

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

@@ -0,0 +1,47 @@
+package com.adeo.customerprofilebackend.loyalty.mappers;
+
+import com.adeo.customerprofilebackend.loyalty.dtos.ProgramsDto;
+import com.adeo.customerprofilebackend.loyalty.requests.CreateLoyaltyRequest;
+import com.adeo.ipnteam.lys.client.models.MembershipRequest;
+import com.adeo.ipnteam.lys.client.models.Support;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Collections;
+import java.util.Objects;
+
+@Component
+@RequiredArgsConstructor
+public class MembershipRequestMapper {
+
+    public MembershipRequest from(final CreateLoyaltyRequest createLoyalty, final String channel, final int pointOfSale, final ProgramsDto availablePrograms) {
+
+        Objects.requireNonNull(createLoyalty);
+        return from(createLoyalty.getPartnerCode(), createLoyalty.getType(), channel, pointOfSale, availablePrograms);
+    }
+
+    public MembershipRequest from(final String partnerCode, final String type, final String channel, final int pointOfSale, final ProgramsDto availablePrograms) {
+
+        Objects.requireNonNull(type);
+        return MembershipRequest.builder()
+                .channel(channel)
+                .pointOfSale(pointOfSale)
+                .partnerCode(partnerCode)
+                .type(type)
+                .supports(Collections.singletonList(Support.builder()
+                        .type(LoyaltyCustomerMapper.loyaltyCardTypeToLoyaltyCardTypeSupport(type, availablePrograms))
+                        .build()
+                ))
+                .build();
+    }
+
+    public MembershipRequest forReapply(final String type, final String channel, final int pointOfSale) {
+
+        return MembershipRequest.builder()
+                .channel(channel)
+                .pointOfSale(pointOfSale)
+                .type(type)
+                .build();
+    }
+
+}

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

@@ -0,0 +1,94 @@
+package com.adeo.customerprofilebackend.loyalty.mappers;
+
+import com.adeo.customerprofilebackend.commons.DateFormatter;
+import com.adeo.customerprofilebackend.loyalty.dtos.pointtransformation.PointTransformationDto;
+import com.adeo.ipnteam.lyse.targetedoffer.client.models.ClientLoyaltyReward;
+import com.adeo.ipnteam.lyse.targetedoffer.client.models.CotationLoyaltyRewards;
+import lombok.experimental.UtilityClass;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import java.time.LocalDate;
+import java.time.Period;
+import java.time.YearMonth;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static java.time.temporal.ChronoUnit.MONTHS;
+
+@UtilityClass
+public class PointTansformationMapper {
+
+    private static final String POINT_TYPE = "P";
+    private static final String POINTS_LABEL = "points";
+    private static final String CURRENCY_TYPE = "CURRENCY";
+    private static final String PERCENT_TYPE = "PERCENT";
+    private static final String PERCENT_LABEL = "%";
+
+    public List<PointTransformationDto> cotationLoyaltyRewardsToPointTransformationDto(final CotationLoyaltyRewards cotationLoyaltyRewards, final String currencyLabel) {
+        if (cotationLoyaltyRewards == null || CollectionUtils.isEmpty(cotationLoyaltyRewards.getClientLoyaltyRewards())) {
+            return Collections.emptyList();
+        }
+        return cotationLoyaltyRewards.getClientLoyaltyRewards().stream()
+                .map(clientLoyaltyReward -> PointTansformationMapper.clientLoyaltyRewardToPointTransformationDto(clientLoyaltyReward, currencyLabel))
+                .sorted(Comparator.comparing(PointTransformationDto::getActive).thenComparing(PointTransformationDto::getFactor).reversed())
+                .collect(Collectors.toList());
+    }
+
+    private PointTransformationDto clientLoyaltyRewardToPointTransformationDto(final ClientLoyaltyReward clientLoyaltyReward, final String currencyLabel) {
+        final PointTransformationDto.PointTransformationDtoBuilder pointTransformationDtoBuilder = PointTransformationDto.builder();
+        if (clientLoyaltyReward.getLoyaltyReward() != null) {
+            pointTransformationDtoBuilder
+                    .activationCode(clientLoyaltyReward.getLoyaltyReward().getTriggerCode())
+                    .rewardLabel(getLabel(clientLoyaltyReward.getLoyaltyReward().getType(), currencyLabel))
+                    .reward(clientLoyaltyReward.getLoyaltyReward().getValue())
+                    .description(clientLoyaltyReward.getLoyaltyReward().getLabel());
+            if (clientLoyaltyReward.getLoyaltyReward().getCounterRequirement() != null) {
+                pointTransformationDtoBuilder
+                        .amountLabel(getLabel(clientLoyaltyReward.getLoyaltyReward().getCounterRequirement().getType(), currencyLabel))
+                        .amount(clientLoyaltyReward.getLoyaltyReward().getCounterRequirement().getAmount())
+                        .missingAmount(clientLoyaltyReward.getCounterGap() == null ? null : clientLoyaltyReward.getCounterGap().getAmount());
+            }
+        }
+        return pointTransformationDtoBuilder
+                .active(isActive(clientLoyaltyReward))
+                .factor(clientLoyaltyReward.getAvailabilityFactor())
+                .validityEndDate(getValidityEndDate(clientLoyaltyReward.getPeriod()))
+                .build();
+    }
+
+    private String getValidityEndDate(final Period period) {
+        if (period == null) {
+            return null;
+        }
+        if (period.getMonths() != 0) {
+            return DateFormatter.format(YearMonth.now().plus(period.getMonths(), MONTHS).atEndOfMonth());
+        }
+        return DateFormatter.format(LocalDate.now().plus(period));
+    }
+
+    private Boolean isActive(final ClientLoyaltyReward clientLoyaltyReward) {
+        if (clientLoyaltyReward.getAvailable()) {
+            return true;
+        }
+        if (clientLoyaltyReward.getPotential()) {
+            return false;
+        }
+        return null;
+    }
+
+    private String getLabel(final String type, final String currencyLabel) {
+        switch (type) {
+            case CURRENCY_TYPE:
+                return currencyLabel;
+            case PERCENT_TYPE:
+                return PERCENT_LABEL;
+            case POINT_TYPE:
+                return POINTS_LABEL;
+            default:
+                return StringUtils.EMPTY;
+        }
+    }
+}