integration-web-core--socle 1.4.2

package/cdp-hpn--customer-profile-backend-master/src/main/java/com/adeo/customerprofilebackend/personaldata/services/PatchCustomerService.java

@@ -0,0 +1,713 @@
+package com.adeo.customerprofilebackend.personaldata.services;
+
+import com.adeo.customerprofilebackend.commons.helpers.PhoneHelper;
+import com.adeo.customerprofilebackend.customer.enums.CustomerTypeEnum;
+import com.adeo.customerprofilebackend.customer.mapper.CustomerMapper;
+import com.adeo.customerprofilebackend.customer.requests.UpdateCustomerRequest;
+import com.adeo.customerprofilebackend.personaldata.dtos.PhoneDto;
+import com.adeo.customerprofilebackend.personaldata.mappers.ApiCiamMapper;
+import com.adeo.customerprofilebackend.personaldata.mappers.ApiMdmMapper;
+import com.adeo.customerprofilebackend.personaldata.request.UpdateCompanyRequest;
+import com.adeo.customerprofilebackend.personaldata.request.UpdateProfileRequest;
+import com.adeo.ipnteam.ciam.client.CiamClient;
+import com.adeo.ipnteam.ciam.client.CiamClientException;
+import com.adeo.ipnteam.ciam.client.models.models.WebUser;
+import com.adeo.ipnteam.mdm.client.MdmClient;
+import com.adeo.ipnteam.mdm.client.MdmClientException;
+import com.adeo.ipnteam.mdmcommons.models.MdmActivity;
+import com.adeo.ipnteam.mdmcommons.models.MdmAdministrativeCodes;
+import com.adeo.ipnteam.mdmcommons.models.MdmEmailAddress;
+import com.adeo.ipnteam.mdmcommons.models.MdmGlobal;
+import com.adeo.ipnteam.mdmcommons.models.MdmInhabitant;
+import com.adeo.ipnteam.mdmcommons.models.MdmMember;
+import com.adeo.ipnteam.mdmcommons.models.MdmPatchObjectRequest;
+import com.adeo.ipnteam.mdmcommons.models.MdmPhone;
+import com.adeo.ipnteam.mdmcommons.models.MdmProfessionnalOrganisation;
+import com.adeo.ipnteam.mdmcommons.models.enums.MdmClientTypeEnum;
+import com.adeo.ipnteam.mdmcommons.models.enums.MdmCodeType;
+import com.adeo.ipnteam.mdmcommons.models.enums.MdmOperationsEnum;
+import com.adeo.ipnteam.reachfive.client.ReachFiveClient;
+import com.adeo.ipnteam.reachfive.client.ReachFiveClientConfig;
+import com.adeo.ipnteam.reachfive.client.enums.GrantTypeEnum;
+import com.adeo.ipnteam.reachfive.client.models.TokenRequest;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import reactor.core.publisher.Mono;
+
+import java.beans.BeanInfo;
+import java.beans.IntrospectionException;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static com.adeo.customerprofilebackend.config.Constants.FRENCH_BU_CODE;
+
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class PatchCustomerService {
+
+    public static final String EMAIL_ADDRESSES = "/emailAddresses/";
+    public static final String SIRET = "SIRET";
+    public static final String IDE = "IDE";
+    private static final String PHONES_PATH = "/phones/";
+    private static final String INHABITANT_PATH = "/inhabitant/";
+    private static final String MEMBERS_PATH = "/members/";
+    private static final String ADMINISTRATIVE_IDENTIFIERS_PATH = INHABITANT_PATH + "administrativeIdentifiers/";
+    private static final String PROFESSIONAL_ORGANIZATION_PATH = "/professionalOrganization/";
+    private static final String ACTIVE_PATH = "/active";
+    private static final String EMAIL = "/email";
+    private static final String CIVILITY = "civility";
+    private static final String FIRST_NAME = "firstName";
+    private static final String LAST_NAME = "lastName";
+    private static final String DATE_OF_BIRTH = "dateOfBirth";
+    private static final String CIVIL_STATUS = "civilStatus";
+    private static final String NB_OF_KIDS = "nbOfKids";
+    private static final String NB_OF_FAMILY_MEMBERS = "nbOfFamilyMembers";
+    private static final String PROFESSIONAL_CLASSIFICATION = "professionalClassification";
+    private static final String CLASS = "class";
+    private static final String REGISTERED_NAME_PATH = PROFESSIONAL_ORGANIZATION_PATH + "registeredName";
+    private static final String LEGAL_FORM_PATH = PROFESSIONAL_ORGANIZATION_PATH + "legalForm";
+    private static final String ACTIVITY_SECTOR_PATH = PROFESSIONAL_ORGANIZATION_PATH + "activitySector";
+    private static final String ADMINISTRATIVE_CODES_PATH = PROFESSIONAL_ORGANIZATION_PATH + "administrativeCodes/";
+    private static final String ACTIVITIES_PATH = PROFESSIONAL_ORGANIZATION_PATH + "activities";
+    private static final String PEC = "PEC";
+    private static final String CODICE_DESTINATORIO = "codiceDestinatario";
+    private static final String COD_FISC = "codFisc";
+    private static final String DNI = "dni";
+    private static final String NIE = "nie";
+    private static final String NIF = "nif";
+    private static final String NIP = "nip";
+    private static final String PASSPORT = "passport";
+    private static final String CIF = "cif";
+    private static final String OTHER_FISCAL_IDENTIFIER_TYPE = "otherFiscalIdentifierType";
+    private static final String PIVA = "pIva";
+    private static final String TVA_INTRA_COMMUNAUTAIRE = "TVAIntraCommunautaire";
+    private static final String DECLARED_STORE_ATTACHEMENT = "/declaredStoreAttachement";
+
+    private static final String MOVE_DATE = "/moveDate";
+
+    private final CiamClient ciamClient;
+    private final MdmClient mdmClient;
+    private final ReachFiveClient reachFiveClient;
+
+    private final AddressesService addressesService;
+    private final ReachFiveClientConfig reachFiveClientConfig;
+    @Value("${adeo.bu}")
+    private String adeoBu;
+
+    public Mono<Void> updateCustomerProfile(
+            final String accessToken,
+            final String customerId,
+            final UpdateProfileRequest updateProfileRequest,
+            final String performingUser) {
+
+        return updateCustomerPassword(accessToken, customerId, updateProfileRequest, performingUser)
+                .flatMap(a -> updateCustomerLogin(accessToken, customerId, updateProfileRequest, performingUser)
+                        .flatMap(b -> mdmClient.getCustomerFromCustomerNumber(customerId, performingUser, accessToken)
+                                .flatMap(customerToUpdate -> updateCustomerInfo(customerId, customerToUpdate, updateProfileRequest, performingUser, accessToken)))
+                );
+    }
+
+    public Mono<Void> updateGlobalInfos(final String accessToken,
+                                        final String customerId,
+                                        final UpdateCustomerRequest updateCustomerRequest,
+                                        final String performingUser) {
+        UpdateProfileRequest updateProfileRequest = CustomerMapper.updateCustomerToUpdateProfileRequest(updateCustomerRequest);
+        List<MdmPatchObjectRequest> mdmPatchObjectRequests = new ArrayList<>();
+        return updateCustomerLogin(accessToken, customerId, updateProfileRequest, performingUser)
+                .flatMap(a -> mdmClient.getCustomerFromCustomerNumber(customerId, performingUser, accessToken)
+                        .flatMap(customerToUpdate -> {
+                            mdmPatchObjectRequests.addAll(buildCustomerInfoPatchObject(customerId, customerToUpdate, updateProfileRequest));
+                            if (MdmClientTypeEnum.PROFESSIONALORGANIZATION.equals(customerToUpdate.getData().getClientType())) {
+                                mdmPatchObjectRequests.addAll(buildCompanyProfilePatchObject(customerToUpdate, CustomerMapper.updateCustomerToUpdateCompanyRequest(updateCustomerRequest)));
+                            }
+                            if (updateCustomerRequest.getAddress() != null) {
+                                mdmPatchObjectRequests.addAll(addressesService.createOrPatchMainAddress(customerToUpdate.getData().getAddresses(), updateCustomerRequest.getAddress()));
+                            }
+                            return performPatch(customerId, performingUser, accessToken, mdmPatchObjectRequests);
+                        }));
+
+    }
+
+    public Mono<Void> updateCustomerInfo(final String userId, final MdmGlobal customerToUpdate, final UpdateProfileRequest updateProfileRequest, final String performingUser, final String accessToken) {
+        return performPatch(userId, performingUser, accessToken, buildCustomerInfoPatchObject(userId, customerToUpdate, updateProfileRequest));
+    }
+
+    private List<MdmPatchObjectRequest> buildCustomerInfoPatchObject(final String customerId, final MdmGlobal customerToUpdate, final UpdateProfileRequest updateProfileRequest) {
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        updateCustomerIdentity(customerToUpdate, updateProfileRequest, body, customerId);
+        if (updateProfileRequest.getPhones() != null && !updateProfileRequest.getPhones().isEmpty()) {
+            try {
+                buildUpdateMdmCustomerPhonesBody(updateProfileRequest.getPhones(), customerToUpdate, body, customerId);
+            } catch (final InvocationTargetException | IllegalAccessException | IntrospectionException e) {
+                throw new MdmClientException(HttpStatus.INTERNAL_SERVER_ERROR, e.getMessage());
+            }
+        }
+
+        if (updateProfileRequest.getEmail() != null) {
+            if (customerToUpdate.getData().getClientType().equals(MdmClientTypeEnum.INHABITANT)) {
+                final List<MdmEmailAddress> emailAddresses = customerToUpdate.getData().getEmailAddresses();
+                if (CollectionUtils.isEmpty(emailAddresses)) {
+                    body.add(
+                            getMdmPatchObject(
+                                    MdmOperationsEnum.ADD, EMAIL_ADDRESSES + "-", MdmEmailAddress.builder()
+                                            .email(updateProfileRequest.getEmail())
+                                            .isContactPriority(true)
+                                            .build())
+                    );
+                } else {
+                    body.add(
+                            getMdmPatchObject(
+                                    MdmOperationsEnum.REPLACE,
+                                    EMAIL_ADDRESSES + emailAddresses.get(0).getEmail() + EMAIL, updateProfileRequest.getEmail())
+                    );
+                }
+            } else {
+                final MdmMember member = customerToUpdate.getData()
+                        .getMembers()
+                        .stream()
+                        .filter(mdmMember -> mdmMember.getClientNumber().toString().equals(customerId))
+                        .findFirst()
+                        .orElse(null);
+                if (member != null) {
+                    final List<MdmEmailAddress> emailAddresses = member.getEmailAddresses();
+                    if (CollectionUtils.isEmpty(emailAddresses)) {
+                        body.add(
+                                getMdmPatchObject(
+                                        MdmOperationsEnum.ADD, MEMBERS_PATH + customerId + EMAIL_ADDRESSES + "-", MdmEmailAddress.builder()
+                                                .email(updateProfileRequest.getEmail())
+                                                .isContactPriority(true)
+                                                .build())
+                        );
+                    } else {
+                        body.add(
+                                getMdmPatchObject(
+                                        MdmOperationsEnum.REPLACE,
+                                        MEMBERS_PATH + customerId + EMAIL_ADDRESSES + member.getEmailAddresses().get(0).getEmail() + EMAIL,
+                                        updateProfileRequest.getEmail()
+                                )
+                        );
+                    }
+                }
+            }
+        }
+        return body;
+    }
+
+    private void buildUpdateMdmCustomerPhonesBody(final List<PhoneDto> phonesRequest, final MdmGlobal mdmGlobal, final List<MdmPatchObjectRequest> body, final String customerId) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
+
+        if (mdmGlobal.getData().getClientType().equals(MdmClientTypeEnum.INHABITANT)) {
+            final List<MdmPhone> actualPhones = mdmGlobal.getData().getPhones();
+            final List<PhoneDto> phonesToAdd = phonesRequest.stream()
+                    .filter(phone -> Objects.isNull(phone.getOldValue()) && !StringUtils.isEmpty(phone.getValue())).collect(Collectors.toList());
+            final List<PhoneDto> phonesToUpdate = phonesRequest.stream()
+                    .filter(phone -> Objects.nonNull(phone.getOldValue()) && !StringUtils.isEmpty(phone.getValue())).toList();
+            for (final PhoneDto phoneRequest : phonesToUpdate) {
+                body.addAll(updateMdmCustomerPhones(actualPhones, phoneRequest));
+            }
+            final List<String> actualPhoneNumbers = CollectionUtils.isEmpty(actualPhones) ? Collections.emptyList() : actualPhones.stream().map(MdmPhone::getNumber).collect(Collectors.toList());
+            body.addAll(addMdmCustomerPhones(actualPhoneNumbers, phonesToAdd));
+            body.addAll(removeMdmCustomerPhones(actualPhoneNumbers, phonesToAdd.stream().map(PhoneDto::getValue).collect(Collectors.toList()),
+                    phonesToUpdate.stream().map(PhoneDto::getOldValue).collect(Collectors.toList())));
+        } else {
+            final MdmMember member = mdmGlobal.getData().getMembers().stream().filter(mdmMember -> mdmMember.getClientNumber().toString().equals(customerId)).findFirst().orElse(null);
+            if (member != null) {
+                final List<MdmPhone> actualPhones = member.getPhones();
+                final List<PhoneDto> phonesToAdd = phonesRequest.stream()
+                        .filter(phone -> Objects.isNull(phone.getOldValue()) && !StringUtils.isEmpty(phone.getValue())).collect(Collectors.toList());
+                final List<PhoneDto> phonesToUpdate = phonesRequest.stream()
+                        .filter(phone -> Objects.nonNull(phone.getOldValue()) && !StringUtils.isEmpty(phone.getValue())).collect(Collectors.toList());
+                for (final PhoneDto phoneRequest : phonesToUpdate) {
+                    body.addAll(updateMdmMemberPhones(actualPhones, phoneRequest, customerId));
+                }
+                final List<String> actualPhoneNumbers = CollectionUtils.isEmpty(actualPhones) ? Collections.emptyList() : actualPhones.stream().map(MdmPhone::getNumber).collect(Collectors.toList());
+                body.addAll(addMdmMemberPhones(actualPhoneNumbers, phonesToAdd, customerId));
+                body.addAll(removeMdmMemberPhones(actualPhoneNumbers, phonesToAdd.stream().map(PhoneDto::getValue).collect(Collectors.toList()),
+                        phonesToUpdate.stream().map(PhoneDto::getOldValue).collect(Collectors.toList()), customerId));
+            }
+        }
+    }
+
+    private Collection<? extends MdmPatchObjectRequest> updateMdmMemberPhones(final List<MdmPhone> actualPhones, final PhoneDto updatePhoneRequest, final String memberId) throws IntrospectionException, InvocationTargetException, IllegalAccessException {
+        final MdmPhone phoneToUpdate = updatePhoneRequestToMdmPhone(updatePhoneRequest);
+        final BeanInfo beanInfo = Introspector.getBeanInfo(MdmPhone.class);
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        for (final PropertyDescriptor propertyDesc : beanInfo.getPropertyDescriptors()) {
+            final String propertyName = propertyDesc.getName();
+            final Object value = propertyDesc.getReadMethod().invoke(phoneToUpdate);
+            if (value != null && !propertyName.equals(CLASS)) {
+                body.add(getMdmPatchObject(MdmOperationsEnum.REPLACE, MEMBERS_PATH + memberId + PHONES_PATH + updatePhoneRequest.getOldValue() + "/" + propertyName, value));
+            }
+        }
+        return body;
+    }
+
+    private List<MdmPatchObjectRequest> removeMdmMemberPhones(final List<String> actualPhoneNumbers, final List<String> phonesToAddNumbers, final List<String> phoneToUpdateNumbers, final String memberId) {
+
+        Collections.reverse(actualPhoneNumbers);
+        phonesToAddNumbers.addAll(phoneToUpdateNumbers);
+        actualPhoneNumbers.removeAll(phonesToAddNumbers);
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        for (final String phoneNumber : actualPhoneNumbers) {
+            body.add(getMdmPatchObject(MdmOperationsEnum.REMOVE, MEMBERS_PATH + memberId + PHONES_PATH + phoneNumber, null));
+        }
+        return body;
+    }
+
+    private List<MdmPatchObjectRequest> removeMdmCustomerPhones(final List<String> actualPhoneNumbers, final List<String> phonesToAddNumbers, final List<String> phoneToUpdateNumbers) {
+
+        Collections.reverse(actualPhoneNumbers);
+        phonesToAddNumbers.addAll(phoneToUpdateNumbers);
+        actualPhoneNumbers.removeAll(phonesToAddNumbers);
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        for (final String phoneNumber : actualPhoneNumbers) {
+            body.add(getMdmPatchObject(MdmOperationsEnum.REMOVE, PHONES_PATH + phoneNumber, null));
+        }
+        return body;
+    }
+
+    private List<MdmPatchObjectRequest> addMdmMemberPhones(final List<String> actualPhonesNumbers, final List<PhoneDto> phonesToAdd, final String memberId) {
+
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        final List<MdmPhone> mdmPhonesToAdd = updatePhoneRequestListToMdmPhoneList(phonesToAdd);
+        for (final MdmPhone mdmPhone : mdmPhonesToAdd) {
+            if (!actualPhonesNumbers.contains(mdmPhone.getNumber())) {
+                body.add(getMdmPatchObject(MdmOperationsEnum.ADD, MEMBERS_PATH + memberId + PHONES_PATH + "-", mdmPhone));
+            }
+        }
+        return body;
+    }
+
+    private List<MdmPatchObjectRequest> addMdmCustomerPhones(final List<String> actualPhonesNumbers, final List<PhoneDto> phonesToAdd) {
+
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        final List<MdmPhone> mdmPhonesToAdd = updatePhoneRequestListToMdmPhoneList(phonesToAdd);
+        for (final MdmPhone mdmPhone : mdmPhonesToAdd) {
+            if (!actualPhonesNumbers.contains(mdmPhone.getNumber())) {
+                body.add(getMdmPatchObject(MdmOperationsEnum.ADD, PHONES_PATH + "-", mdmPhone));
+            }
+        }
+        return body;
+    }
+
+    private List<MdmPatchObjectRequest> updateMdmCustomerPhones(final List<MdmPhone> actualPhones, final PhoneDto updatePhoneRequest) {
+        final MdmPhone phoneToUpdate = updatePhoneRequestToMdmPhone(updatePhoneRequest);
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+        body.add(getMdmPatchObject(MdmOperationsEnum.REPLACE, PHONES_PATH + updatePhoneRequest.getOldValue(), phoneToUpdate));
+        return body;
+    }
+
+    private List<MdmPhone> updatePhoneRequestListToMdmPhoneList(final List<PhoneDto> updatePhoneRequestList) {
+
+        return updatePhoneRequestList.stream().map(this::updatePhoneRequestToMdmPhone).collect(Collectors.toList());
+    }
+
+    private MdmPhone updatePhoneRequestToMdmPhone(final PhoneDto updatePhoneRequest) {
+
+        return MdmPhone.builder()
+                .isContactPriority(updatePhoneRequest.getMain())
+                .number(updatePhoneRequest.getValue())
+                .type(PhoneHelper.getMdmPhoneTypeFromValue(updatePhoneRequest.getValue()))
+                .build();
+    }
+
+    private void updateCustomerIdentity(final MdmGlobal customerToUpdate, final UpdateProfileRequest updateProfileRequest, final List<MdmPatchObjectRequest> body, final String customerId) {
+
+        final MdmInhabitant customerIdentity = ApiMdmMapper.updateProfileRequestToMdmInhabitantDto(updateProfileRequest);
+        if (customerToUpdate.getData().getClientType().equals(MdmClientTypeEnum.INHABITANT)) {
+            updateInhabitantIdentity(customerToUpdate, body, customerIdentity);
+        } else {
+            updateProfessionalMemberIdentity(customerToUpdate, customerIdentity, body, customerId);
+        }
+
+        if (updateProfileRequest.getDeclaredStoreAttachment() != null) {
+            addMdmPatchObject(String.valueOf(updateProfileRequest.getDeclaredStoreAttachment()), customerToUpdate.getData().getDeclaredStoreAttachement(), body, DECLARED_STORE_ATTACHEMENT);
+        }
+
+        addMdmPatchObject(updateProfileRequest.getMovingDate(), customerToUpdate.getData().getMoveDate(), body, MOVE_DATE);
+    }
+
+    private void updateProfessionalMemberIdentity(final MdmGlobal customerToUpdate, final MdmInhabitant customerIdentity, final List<MdmPatchObjectRequest> body, final String customerId) {
+
+        final MdmMember member = customerToUpdate.getData().getMembers().stream().filter(mdmMember -> mdmMember.getClientNumber().toString().equals(customerId)).findFirst().orElse(null);
+        if (member != null) {
+
+            if (customerIdentity.getCivility() != null) {
+                addMdmPatchObject(customerIdentity.getCivility().name(), member.getCivility().name(), body, MEMBERS_PATH + customerId + '/' + CIVILITY);
+            }
+
+            addMdmPatchObject(customerIdentity.getFirstName(), member.getFirstName(), body, MEMBERS_PATH + customerId + '/' + FIRST_NAME);
+
+            addMdmPatchObject(customerIdentity.getLastName(), member.getLastName(), body, MEMBERS_PATH + customerId + '/' + LAST_NAME);
+
+            addMdmPatchObject(customerIdentity.getDateOfBirth(), member.getDateOfBirth(), body, MEMBERS_PATH + customerId + '/' + DATE_OF_BIRTH);
+        } else {
+            log.warn("member " + customerId + " is not a member of the company " + customerToUpdate.getData().getClientNumber());
+        }
+    }
+
+    private void updateInhabitantIdentity(final MdmGlobal customerToUpdate, final List<MdmPatchObjectRequest> body, final MdmInhabitant customerIdentity) {
+
+        final MdmInhabitant actualIdentity = customerToUpdate.getData().getInhabitant();
+
+        if (customerIdentity.getCivility() != null) {
+            addMdmPatchObject(customerIdentity.getCivility().name(), actualIdentity.getCivility() != null ? actualIdentity.getCivility().name() : null, body, INHABITANT_PATH + CIVILITY);
+        }
+
+        addMdmPatchObject(customerIdentity.getFirstName(), actualIdentity.getFirstName(), body, INHABITANT_PATH + FIRST_NAME);
+
+        addMdmPatchObject(customerIdentity.getLastName(), actualIdentity.getLastName(), body, INHABITANT_PATH + LAST_NAME);
+
+        addMdmPatchObject(customerIdentity.getDateOfBirth(), actualIdentity.getDateOfBirth(), body, INHABITANT_PATH + DATE_OF_BIRTH);
+
+        addMdmPatchObject(customerIdentity.getNbOfKids(), actualIdentity.getNbOfKids(), body, INHABITANT_PATH + NB_OF_KIDS);
+
+        addMdmPatchObject(customerIdentity.getNbOfFamilyMembers(), actualIdentity.getNbOfFamilyMembers(), body, INHABITANT_PATH + NB_OF_FAMILY_MEMBERS);
+
+        addMdmPatchObject(customerIdentity.getCivilStatus(), actualIdentity.getCivilStatus(), body, INHABITANT_PATH + CIVIL_STATUS);
+
+        if (customerIdentity.getAdministrativeIdentifiers() != null) {
+
+            clearCurrentAdministrativeIdentifiers(actualIdentity, customerIdentity, body);
+
+            if (customerIdentity.getAdministrativeIdentifiers().getCodFisc() != null) {
+                addMdmPatchObject(customerIdentity.getAdministrativeIdentifiers().getCodFisc(), actualIdentity.getAdministrativeIdentifiers().getCodFisc(), body, ADMINISTRATIVE_IDENTIFIERS_PATH + COD_FISC);
+            }
+            if (customerIdentity.getAdministrativeIdentifiers().getDni() != null) {
+                addMdmPatchObject(customerIdentity.getAdministrativeIdentifiers().getDni(), actualIdentity.getAdministrativeIdentifiers().getDni(), body, ADMINISTRATIVE_IDENTIFIERS_PATH + DNI);
+            }
+            if (customerIdentity.getAdministrativeIdentifiers().getNie() != null) {
+                addMdmPatchObject(customerIdentity.getAdministrativeIdentifiers().getNie(), actualIdentity.getAdministrativeIdentifiers().getNie(), body, ADMINISTRATIVE_IDENTIFIERS_PATH + NIE);
+            }
+            if (customerIdentity.getAdministrativeIdentifiers().getNif() != null) {
+                addMdmPatchObject(customerIdentity.getAdministrativeIdentifiers().getNif(), actualIdentity.getAdministrativeIdentifiers().getNif(), body, ADMINISTRATIVE_IDENTIFIERS_PATH + NIF);
+            }
+            if (customerIdentity.getAdministrativeIdentifiers().getPassport() != null) {
+                addMdmPatchObject(customerIdentity.getAdministrativeIdentifiers().getPassport(), actualIdentity.getAdministrativeIdentifiers().getPassport(), body, ADMINISTRATIVE_IDENTIFIERS_PATH + PASSPORT);
+            }
+            if (customerIdentity.getAdministrativeIdentifiers().getOtherFiscalIdentifierType() != null) {
+                addMdmPatchObject(customerIdentity.getAdministrativeIdentifiers().getOtherFiscalIdentifierType(), actualIdentity.getAdministrativeIdentifiers().getOtherFiscalIdentifierType(), body, ADMINISTRATIVE_IDENTIFIERS_PATH + OTHER_FISCAL_IDENTIFIER_TYPE);
+            }
+        }
+
+        addMdmPatchObject(customerIdentity.getProfessionalClassification(), actualIdentity.getProfessionalClassification(), body, INHABITANT_PATH + PROFESSIONAL_CLASSIFICATION);
+    }
+
+    public Mono<ResponseEntity<Void>> updateCustomerLogin(
+            final String accessToken,
+            final String customerId,
+            final UpdateProfileRequest updateProfileRequest, final String performingUser) {
+
+        if (updateProfileRequest.getLogin() == null) {
+            return Mono.just(new ResponseEntity(HttpStatus.OK));
+        }
+        return getAccountId(accessToken, customerId, performingUser).flatMap(
+                accountId ->
+                        ciamClient.updateWebUser(accessToken,
+                                ApiCiamMapper.updateProfileRequestToWebUser(updateProfileRequest),
+                                accountId,
+                                performingUser));
+    }
+
+    private Mono<ResponseEntity<Void>> updateCustomerPassword(
+            final String accessToken,
+            final String customerId,
+            final UpdateProfileRequest updateProfileRequest,
+            final String performingUser) {
+
+        if (updateProfileRequest.getNewPassword() == null) {
+            return Mono.just(new ResponseEntity(HttpStatus.OK));
+        }
+
+        if (!updateProfileRequest.getNewPassword().equals(updateProfileRequest.getConfirmNewPassword())) {
+            return Mono.error(new IllegalArgumentException("New password and confirm password are different"));
+        }
+
+        // Call to ciamClient to get login of the customer
+        // Request can send a different login because customer want to update it
+        return this.getAccount(accessToken, customerId, performingUser)
+                .flatMap(webUser ->
+                        this.reachFiveClient.getAccessTokenWithPasswordFlow(TokenRequest.builder()
+                                        .clientId(reachFiveClientConfig.getClientIdIdentity())
+                                        .clientSecret(reachFiveClientConfig.getClientSecretIdentity())
+                                        .scope(reachFiveClientConfig.getScopesIdentity())
+                                        .grantType(GrantTypeEnum.PASSWORD)
+                                        .username(webUser.getAccount().getLogins().getEmailAddress().getValue())
+                                        .password(updateProfileRequest.getPassword())
+                                        .build(), reachFiveClientConfig.getBasicAuth())
+                                .flatMap(ignore -> getAccountId(accessToken, customerId, performingUser).flatMap(
+                                        accountId ->
+                                                ciamClient.updateWebUser(accessToken,
+                                                        ApiCiamMapper.changePasswordRequestToWebUser(updateProfileRequest),
+                                                        accountId,
+                                                        performingUser))
+                                )
+                );
+    }
+
+    private Mono<String> getAccountId(final String accessToken, final String customerId, final String performingUser) {
+
+        return ciamClient.getWebUsers(accessToken, customerId, performingUser).flatMap(
+                webUserResponse -> {
+                    if (webUserResponse.size() == 1) {
+                        return Mono.just(webUserResponse.get(0).getAccount().getAccountId());
+                    }
+                    return Mono.error(new CiamClientException(HttpStatus.MULTIPLE_CHOICES, "retrieveUserRequest"));
+                });
+    }
+
+    private Mono<WebUser> getAccount(final String accessToken, final String customerId, final String performingUser) {
+
+        return this.ciamClient.getWebUsers(accessToken, customerId, performingUser)
+                .flatMap(webUserResponses -> {
+                    if (webUserResponses.size() == 1) {
+                        return Mono.just(webUserResponses.get(0));
+                    }
+                    return Mono.error(new CiamClientException(HttpStatus.MULTIPLE_CHOICES, "retrieveUserRequest"));
+                });
+    }
+
+    public Mono<Void> updateCompanyProfile(final String userId, final UpdateCompanyRequest companyRequest, final String performingUser, final String accessToken) {
+
+        return mdmClient.getCustomerFromCustomerNumber(userId, performingUser, accessToken)
+                .flatMap(customerToUpdate -> updateCompanyProfile(userId, customerToUpdate, companyRequest, performingUser, accessToken));
+    }
+
+    public Mono<Void> updateCompanyProfile(final String userId, final MdmGlobal customerToUpdate, final UpdateCompanyRequest companyRequest, final String performingUser, final String accessToken) {
+        return performPatch(userId, performingUser, accessToken, buildCompanyProfilePatchObject(customerToUpdate, companyRequest));
+    }
+
+    public List<MdmPatchObjectRequest> buildCompanyProfilePatchObject(final MdmGlobal customerToUpdate, final UpdateCompanyRequest companyRequest) {
+
+
+        final List<MdmPatchObjectRequest> body = new ArrayList<>();
+
+        final MdmProfessionnalOrganisation professionnalOrganisationToUpdate = customerToUpdate.getData().getProfessionalOrganization();
+        final MdmAdministrativeCodes administrativeCodesToUpdate = professionnalOrganisationToUpdate.getAdministrativeCodes();
+
+        if (companyRequest.isAdministrativeCodePatch()) {
+            clearCurrentAdministrativeCode(administrativeCodesToUpdate, companyRequest, body);
+
+            addMdmPatchObject(companyRequest.getCertifiedEmail(), administrativeCodesToUpdate.getPec(), body, ADMINISTRATIVE_CODES_PATH + PEC);
+
+            addMdmPatchObject(companyRequest.getElectronicInvoicingCode(), administrativeCodesToUpdate.getCodiceDestinatario(), body, ADMINISTRATIVE_CODES_PATH + CODICE_DESTINATORIO);
+
+            addMdmPatchObject(companyRequest.getFiscalCode(), administrativeCodesToUpdate.getCodFisc(), body, ADMINISTRATIVE_CODES_PATH + COD_FISC);
+
+            if (FRENCH_BU_CODE.equals(adeoBu)) {
+                addMdmPatchObject(companyRequest.getVatNumber(), administrativeCodesToUpdate.getTvaIntraCommunautaire(), body, ADMINISTRATIVE_CODES_PATH + TVA_INTRA_COMMUNAUTAIRE);
+            } else {
+                addMdmPatchObject(companyRequest.getVatNumber(), administrativeCodesToUpdate.getPiva(), body, ADMINISTRATIVE_CODES_PATH + PIVA);
+            }
+
+            addMdmPatchObject(companyRequest.getSiret(), administrativeCodesToUpdate.getSiret(), body, ADMINISTRATIVE_CODES_PATH + SIRET);
+
+            addMdmPatchObject(companyRequest.getIde(), administrativeCodesToUpdate.getIde(), body, ADMINISTRATIVE_CODES_PATH + IDE);
+
+            addMdmPatchObject(companyRequest.getCif(), administrativeCodesToUpdate.getCif(), body, ADMINISTRATIVE_CODES_PATH + CIF);
+
+            addMdmPatchObject(companyRequest.getNif(), administrativeCodesToUpdate.getNif(), body, ADMINISTRATIVE_CODES_PATH + NIF);
+
+            addMdmPatchObject(companyRequest.getNip(), administrativeCodesToUpdate.getNip(), body, ADMINISTRATIVE_CODES_PATH + NIP);
+        }
+        addMdmPatchObject(companyRequest.getName(), professionnalOrganisationToUpdate.getRegisteredName(), body, REGISTERED_NAME_PATH);
+
+        addMdmPatchObject(ApiMdmMapper.toMdmLegalForm(companyRequest.getLegalForm(), adeoBu), professionnalOrganisationToUpdate.getLegalForm(), body, LEGAL_FORM_PATH);
+
+        addMdmPatchObject(companyRequest.getActivitySector(), professionnalOrganisationToUpdate.getActivitySector(), body, ACTIVITY_SECTOR_PATH);
+
+        patchMdmActivities(companyRequest, body, professionnalOrganisationToUpdate);
+
+        return body;
+    }
+
+    private Mono<Void> performPatch(String userId, String performingUser, String accessToken, List<MdmPatchObjectRequest> body) {
+        if (!body.isEmpty()) {
+            return mdmClient.patchCustomer(userId, body, performingUser, accessToken).then();
+        }
+        return Mono.empty();
+    }
+
+    private void patchMdmActivities(final UpdateCompanyRequest companyRequest, final List<MdmPatchObjectRequest> body, final MdmProfessionnalOrganisation professionnalOrganisationToUpdate) {
+        if (!StringUtils.isEmpty(companyRequest.getCae())) {
+            final List<MdmActivity> activities = professionnalOrganisationToUpdate.getActivities();
+            final MdmActivity mdmActivity = activities.stream()
+                    .filter(activity -> activity.getIsMainActivity() && MdmCodeType.CAE.equals(activity.getCodeType()))
+                    .findFirst()
+                    .orElse(activities.stream().filter(activity -> MdmCodeType.CAE.equals(activity.getCodeType()))
+                            .findFirst()
+                            .orElse(null));
+            if (mdmActivity != null) {
+                mdmActivity.setCode(companyRequest.getCae());
+            } else {
+                activities.add(MdmActivity.builder()
+                        .isMainActivity(true)
+                        .code(companyRequest.getCae())
+                        .codeType(MdmCodeType.CAE)
+                        .build());
+            }
+            body.add(getMdmPatchObject(MdmOperationsEnum.REPLACE, ACTIVITIES_PATH, activities));
+        }
+    }
+
+    private void addMdmPatchObject(final String newValue, final String actualValue, final List<MdmPatchObjectRequest> body, final String path) {
+        if (newValue != null && !newValue.equals(actualValue))
+            body.add(getMdmPatchObject(actualValue == null ? MdmOperationsEnum.ADD : MdmOperationsEnum.REPLACE, path, newValue));
+    }
+
+    private void addMdmPatchObject(final Enum<?> newEnumValue, final Enum<?> actualEnumValue, final List<MdmPatchObjectRequest> body, final String path) {
+        final String newValue = newEnumValue != null ? newEnumValue.name() : null;
+        final String currentValue = actualEnumValue != null ? actualEnumValue.name() : null;
+
+        addMdmPatchObject(newValue, currentValue, body, path);
+    }
+
+
+    private MdmPatchObjectRequest getMdmPatchObject(final MdmOperationsEnum mdmOperation, final String path, final Object newValue) {
+
+        return MdmPatchObjectRequest.builder()
+                .op(mdmOperation.getValue())
+                .path(path)
+                .value(newValue)
+                .build();
+    }
+
+
+    public Mono<MdmGlobal> enableCustomer(final String customerId, final boolean enable, final String performingUser, final CustomerTypeEnum customerType, final String accessToken) {
+        final MdmPatchObjectRequest mdmPatchObjectRequest = MdmPatchObjectRequest.builder()
+                .path(CustomerTypeEnum.COMPANY.equals(customerType) ? MEMBERS_PATH + customerId + ACTIVE_PATH : ACTIVE_PATH)
+                .op(MdmOperationsEnum.REPLACE.getValue())
+                .value(enable)
+                .build();
+        return mdmClient.patchCustomer(customerId, Collections.singletonList(mdmPatchObjectRequest), performingUser, accessToken);
+    }
+
+    /**
+     * If current MDM organization has already one administrative code, with different type from new one, we generate REMOVE patch object to clean it
+     * On Customer Space, customer can only have one administrative code
+     *
+     * @param currentAdministrativeCodes
+     * @param body
+     */
+    private void clearCurrentAdministrativeCode(MdmAdministrativeCodes currentAdministrativeCodes, UpdateCompanyRequest updateCompanyRequest, final List<MdmPatchObjectRequest> body) {
+        String newAdministrativeCodesPath = getAdministrativeCodesPath(updateCompanyRequestToMdmAdministrativeCodes(updateCompanyRequest));
+        String currentAdministrativeIdentifiersPath = getAdministrativeCodesPath(currentAdministrativeCodes);
+
+        if (StringUtils.isNotEmpty(currentAdministrativeIdentifiersPath)
+                && StringUtils.isNotEmpty(newAdministrativeCodesPath)
+                && !currentAdministrativeIdentifiersPath.equals(newAdministrativeCodesPath)) {
+            body.add(getMdmPatchObject(MdmOperationsEnum.REMOVE, ADMINISTRATIVE_CODES_PATH + currentAdministrativeIdentifiersPath, null));
+        }
+    }
+
+    private MdmAdministrativeCodes updateCompanyRequestToMdmAdministrativeCodes(UpdateCompanyRequest updateCompanyRequest) {
+        MdmAdministrativeCodes.MdmAdministrativeCodesBuilder mdmAdministrativeCodesBuilder = MdmAdministrativeCodes.builder()
+                .siret(updateCompanyRequest.getSiret())
+                .codFisc(updateCompanyRequest.getFiscalCode())
+                .cif(updateCompanyRequest.getCif())
+                .nif(updateCompanyRequest.getNif())
+                .codiceDestinatario(updateCompanyRequest.getElectronicInvoicingCode())
+                .nip(updateCompanyRequest.getNip())
+                .pec(updateCompanyRequest.getCertifiedEmail())
+                .ide(updateCompanyRequest.getIde());
+        if (FRENCH_BU_CODE.equals(adeoBu)) {
+            mdmAdministrativeCodesBuilder.tvaIntraCommunautaire(updateCompanyRequest.getVatNumber());
+        } else {
+            mdmAdministrativeCodesBuilder.piva(updateCompanyRequest.getVatNumber());
+        }
+        return mdmAdministrativeCodesBuilder
+                .build();
+    }
+
+    /**
+     * If current MDM inhabitant has already one administrative identifier, with different type from new one, we generate REMOVE patch object to clean it
+     * On Customer Space, customer can only have one administrative identifier
+     *
+     * @param actualIdentity
+     * @param body
+     */
+    private void clearCurrentAdministrativeIdentifiers(MdmInhabitant actualIdentity, final MdmInhabitant newCustomerIdentity, final List<MdmPatchObjectRequest> body) {
+        String newAdministrativeIdentifiersPath = getAdministrativeIdentifiersPath(newCustomerIdentity);
+        String currentAdministrativeIdentifiersPath = getAdministrativeIdentifiersPath(actualIdentity);
+
+        if (StringUtils.isNotEmpty(currentAdministrativeIdentifiersPath)
+                && StringUtils.isNotEmpty(newAdministrativeIdentifiersPath)
+                && !currentAdministrativeIdentifiersPath.equals(newAdministrativeIdentifiersPath)) {
+            body.add(getMdmPatchObject(MdmOperationsEnum.REMOVE, ADMINISTRATIVE_IDENTIFIERS_PATH + currentAdministrativeIdentifiersPath, null));
+        }
+    }
+
+    private String getAdministrativeCodesPath(MdmAdministrativeCodes mdmAdministrativeCodes) {
+        if (mdmAdministrativeCodes.getSiret() != null) {
+            return SIRET;
+        }
+        if (mdmAdministrativeCodes.getCif() != null) {
+            return CIF;
+        }
+        if (mdmAdministrativeCodes.getNie() != null) {
+            return NIE;
+        }
+        if (mdmAdministrativeCodes.getNif() != null) {
+            return NIF;
+        }
+        if (mdmAdministrativeCodes.getCodFisc() != null) {
+            return COD_FISC;
+        }
+        if (mdmAdministrativeCodes.getTvaIntraCommunautaire() != null) {
+            return TVA_INTRA_COMMUNAUTAIRE;
+        }
+        if (mdmAdministrativeCodes.getIde() != null) {
+            return IDE;
+        }
+        if (mdmAdministrativeCodes.getCodiceDestinatario() != null) {
+            return CODICE_DESTINATORIO;
+        }
+        if (mdmAdministrativeCodes.getPiva() != null) {
+            return PIVA;
+        }
+        if (mdmAdministrativeCodes.getPec() != null) {
+            return PEC;
+        }
+        if (mdmAdministrativeCodes.getNip() != null) {
+            return NIP;
+        }
+        return null;
+    }
+
+    private String getAdministrativeIdentifiersPath(MdmInhabitant inhabitant) {
+        if (inhabitant.getAdministrativeIdentifiers().getCodFisc() != null) {
+            return COD_FISC;
+        }
+        if (inhabitant.getAdministrativeIdentifiers().getDni() != null) {
+            return DNI;
+        }
+        if (inhabitant.getAdministrativeIdentifiers().getNie() != null) {
+            return NIE;
+        }
+        if (inhabitant.getAdministrativeIdentifiers().getNif() != null) {
+            return NIF;
+        }
+        if (inhabitant.getAdministrativeIdentifiers().getPassport() != null) {
+            return PASSPORT;
+        }
+        if (inhabitant.getAdministrativeIdentifiers().getOtherFiscalIdentifierType() != null) {
+            return OTHER_FISCAL_IDENTIFIER_TYPE;
+        }
+
+        return null;
+    }
+
+}