integration-web-core--socle 1.4.2

package/cdp-due--customer-space-module-master/src/services/customerService.js

@@ -0,0 +1,485 @@
+import { addNotification } from '@/components/ipn-notification-toast/module/actions';
+import { config } from '@/config';
+import { tc } from '@/i18n';
+import { HOME_ROUTE } from '@/router/constants';
+import { AppError } from '@/utils/AppError';
+import { composeUrl } from '@/utils/composeUrl';
+import { logger } from '@/utils/logger';
+import { sleep } from '@/utils/sleep';
+
+import { NO_USER } from '../authentication/module/constants';
+import { PROFILE_BACKEND_URI } from '../constants';
+import queryHandler from '../queryHandler';
+
+const { LOCALE_ISO_CODE, NUMBER_OF_STORE_LIMIT, STORE_SEARCH_RAY_LIMIT } = config;
+
+const ACCOUNT = 'account';
+const CUSTOMER = 'customers';
+export const CUSTOMER_INFO = `${CUSTOMER}/[customerNumber]`;
+const CUSTOMER_LOYALTY = `${CUSTOMER_INFO}/loyalties`;
+const LOYALTY = 'loyalties';
+const PAYMENTS = 'payments';
+const FUNDING = '/funding';
+const CHECK_STORE = '/_checkStore';
+const CREDIT = '/credit';
+const CREDIT_CARD = '/creditCard';
+const ADDRESSES = 'addresses';
+const CUSTOMER_ADDRESSES = `${CUSTOMER_INFO}/addresses`;
+const CUSTOMER_CONSENTS = `${CUSTOMER_INFO}/consents`;
+const CUSTOMER_UNDERSCORE_CONSENT = `${CUSTOMER}/_consents`;
+const CUSTOMER_AVAILABLE_CONSENTS = `${CUSTOMER}/availableConsents`;
+const STORES = 'stores';
+const WALLET = 'customers/me/walletTokens';
+const WALLET_UPDATE = `${WALLET}/[id]`;
+const CUSTOMER_VALUES = `labels/${LOCALE_ISO_CODE}`;
+const CUSTOMER_CHECK = `${CUSTOMER}/_check`;
+const CUSTOMER_PREEXISTENCE_CHECK = `${CUSTOMER}/preexistence/_check`;
+const CUSTOMER_SEND_ACTIVATION_EMAIL = `${ACCOUNT}/sendActivationEmail`;
+const CUSTOMER_SEND_RESET_PWD_EMAIL = `${ACCOUNT}/sendResetPassword`;
+const CUSTOMER_PRESIGNUP = `${ACCOUNT}/presignup`;
+const TARGETED_OFFER = `${CUSTOMER_INFO}/targetedOffers`;
+const CUSTOMER_ADDRESSES_UPDATE = `${CUSTOMER_ADDRESSES}/[id]`;
+const TARGETED_OFFER_TERMS_OF_USE = '/contentful/targetedOffer/termOfUse';
+const TARGETED_OFFER_UPDATE = `${CUSTOMER_INFO}/targetedOffers/[id]`;
+const CUSTOMER_AVAILABLE_TRANSFORMATION_POINTS_REWARDS = `${CUSTOMER_INFO}/pointTransformations`;
+
+const TIME_TO_READ_POPUP_MESSAGE = 5000;
+
+const fetchCustomerAddresses = async () =>
+	queryHandler({
+		url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_ADDRESSES),
+	});
+
+const getAddressUpdateParams = (address) => {
+	const { id, customerNumber, ...data } = address;
+	if (id) {
+		return {
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_ADDRESSES_UPDATE, { id }),
+			method: 'put',
+			data,
+		};
+	}
+
+	return {
+		url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_ADDRESSES, {
+			customerNumber,
+		}),
+		method: 'post',
+		data,
+	};
+};
+
+const filterValues = (item) => {
+	const [key] = Object.keys(item);
+
+	if (key) {
+		const nestedItem = item[key];
+
+		if (nestedItem.values) {
+			const computedValues = nestedItem.values.map((value) => filterValues(value));
+
+			const children = computedValues.filter((item) => !!item?.[Object.keys(item)[0]].values);
+
+			return {
+				[key]: children.length ? children : computedValues,
+			};
+		}
+
+		return {
+			text: nestedItem.label,
+			value: key,
+		};
+	}
+};
+
+const serializeFilteredValues = (filteredValue) => {
+	const [key] = Object.keys(filteredValue);
+
+	if (filteredValue[key][0]?.value) {
+		return filteredValue;
+	}
+
+	return {
+		[key]: filteredValue[key].reduce(
+			(acc, value) => ({ ...acc, ...serializeFilteredValues(value) }),
+			{},
+		),
+	};
+};
+
+let counter = 0;
+
+export const customerService = {
+	// this function is allowed to retry 2 times in order to perform the account creation in case of timeout
+	createAccount: async (data) => {
+		async function createAccountWithCounter() {
+			return await queryHandler({
+				url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER),
+				method: 'POST',
+				...data,
+				onError: async (error) => {
+					if (error.response.status === 409) {
+						addNotification({
+							title: tc('customer-space_account-creation_success-with-error--title'),
+							text: tc('customer-space_account-creation_success-with-error--text'),
+						});
+
+						await sleep(TIME_TO_READ_POPUP_MESSAGE);
+						return { redirectUrl: HOME_ROUTE };
+					} else if (error.response.status >= 500) {
+						if (counter < 2) {
+							counter += 1;
+							return await createAccountWithCounter();
+						}
+					} else {
+						throw error;
+					}
+				},
+			});
+		}
+
+		return await createAccountWithCounter();
+	},
+
+	fetchCustomerAddresses,
+	fetchUserInfo: async () =>
+		await queryHandler({
+			url: `${PROFILE_BACKEND_URI}users/me`,
+			errorHandler: (e) => {
+				logger.error('Fetch user info error', e);
+				return NO_USER;
+			},
+		}),
+
+	fetchCustomerInfo: async (params) =>
+		await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_INFO, params),
+		}),
+
+	fetchCustomerValues: async () => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_VALUES),
+		});
+
+		const filteredValues = filterValues({
+			root: {
+				values: Object.keys(result.data).reduce(
+					(acc, key) => [...acc, { [key]: result.data[key] }],
+					[],
+				),
+			},
+		});
+
+		const serializedValues = serializeFilteredValues(filteredValues);
+
+		return serializedValues.root;
+	},
+
+	fetchLoyalty: async (customerNumber) =>
+		await queryHandler({
+			url: PROFILE_BACKEND_URI + LOYALTY,
+			method: 'GET',
+			params: { customerNumber },
+		}),
+
+	// TODO: merge avec fetchLoyalty car les seules différences sont les paramètres
+	fetchLoyaltyProgramCreation: async ({ customerType, storeId }) =>
+		await queryHandler({
+			url: PROFILE_BACKEND_URI + LOYALTY,
+			method: 'GET',
+			params: { customerType, storeId },
+		}),
+
+	checkFundingStoreExistence: async () =>
+		await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, `${CUSTOMER}/${PAYMENTS}${FUNDING}${CHECK_STORE}`),
+			method: 'GET',
+		}),
+
+	getFundingLink: async (customerNumber) =>
+		await queryHandler({
+			url: composeUrl(
+				PROFILE_BACKEND_URI,
+				`${CUSTOMER_INFO}/${PAYMENTS}${FUNDING}`,
+				customerNumber,
+			),
+			method: 'GET',
+		}),
+
+	getSubscribeCreditCardLink: async (customerNumber) =>
+		await queryHandler({
+			url: composeUrl(
+				PROFILE_BACKEND_URI,
+				`${CUSTOMER_INFO}/${PAYMENTS}${CREDIT_CARD}`,
+				customerNumber,
+			),
+			method: 'POST',
+		}),
+
+	getSubscribeCreditLink: async (customerNumber) =>
+		await queryHandler({
+			url: composeUrl(
+				PROFILE_BACKEND_URI,
+				`${CUSTOMER_INFO}/${PAYMENTS}${CREDIT}`,
+				customerNumber,
+			),
+			method: 'POST',
+		}),
+
+	getCustomerByLastNameAndCard({ lastName, cardNumber }) {
+		return queryHandler({
+			url: PROFILE_BACKEND_URI + CUSTOMER,
+			method: 'GET',
+			params: {
+				lastname: lastName,
+				id: cardNumber,
+			},
+			onError: () => {
+				throw new AppError(979812, 'Customer not found');
+			},
+		});
+	},
+	updateCustomer: async (data) =>
+		await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_INFO),
+			method: 'PUT',
+			data,
+			onError: (e) => {
+				throw e;
+			},
+		}),
+	checkEmail: async (email) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, `${CUSTOMER_CHECK}?email=${email}`),
+		});
+
+		return result?.status;
+	},
+	checkAdministrativeIdentifier: async (data) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_CHECK),
+			method: 'POST',
+			data,
+		});
+
+		return result?.status;
+	},
+	checkSiret: async (siret) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, `${CUSTOMER_CHECK}?siret=${siret}`),
+		});
+
+		return result?.status;
+	},
+	checkCif: async (cif) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, `${CUSTOMER_CHECK}?cif=${cif}`),
+		});
+		return result?.status;
+	},
+
+	checkNif: async (nif, customerType) => {
+		const result = await queryHandler({
+			url: composeUrl(
+				PROFILE_BACKEND_URI,
+				`${CUSTOMER_CHECK}?nif=${nif}&customerType=${customerType}`,
+			),
+		});
+		return result?.status;
+	},
+	updateCustomerAddress: async (address) => await queryHandler(getAddressUpdateParams(address)),
+
+	fetchCustomerConsents: async (types) =>
+		await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_CONSENTS),
+			params: { types },
+		}),
+
+	fetchOfflineCustomerConsents: async (token) =>
+		await queryHandler({
+			url: PROFILE_BACKEND_URI + CUSTOMER_UNDERSCORE_CONSENT,
+			params: { token },
+		}),
+	fetchAvailableConsents: async (types) =>
+		await queryHandler({
+			url: PROFILE_BACKEND_URI + CUSTOMER_AVAILABLE_CONSENTS,
+			...(types ? { params: { types } } : {}),
+		}),
+
+	updateCustomerConsents: async ({ payload, types }) => {
+		await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_CONSENTS),
+			method: 'PUT',
+			data: payload,
+			params: { types },
+		});
+		return types;
+	},
+
+	updateOfflineCustomerConsents: async ({ data, token }) =>
+		await queryHandler({
+			url: `${PROFILE_BACKEND_URI}customers/_consents`,
+			method: 'PUT',
+			params: { token },
+			data,
+		}),
+
+	fetchStores: async () => {
+		const result = await queryHandler({
+			url: PROFILE_BACKEND_URI + STORES,
+		});
+
+		return result.stores;
+	},
+
+	fetchStoresByZipCode: async (zipCode) => {
+		const result = await queryHandler({
+			url: `${PROFILE_BACKEND_URI}stores`,
+			params: {
+				zipCode,
+				count: NUMBER_OF_STORE_LIMIT,
+				ray: STORE_SEARCH_RAY_LIMIT,
+			},
+			onError: (e) => {
+				throw e;
+			},
+		});
+
+		return result.stores;
+
+		// Loyalty endpoints
+	},
+	createLoyalty: (data) =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_LOYALTY),
+			method: 'POST',
+			data,
+		}),
+
+	stopLoyalty: () =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_LOYALTY),
+			method: 'DELETE',
+			onError: (e) => {
+				throw e;
+			},
+		}),
+
+	fetchCustomDiscounts: () =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, TARGETED_OFFER),
+			method: 'GET',
+		}),
+
+	fetchCustomDiscountTermsOfUse: () =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, TARGETED_OFFER_TERMS_OF_USE),
+			method: 'GET',
+		}),
+
+	updateCustomDiscountStatus: ({ id, ...data }) =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, TARGETED_OFFER_UPDATE, { id }),
+			method: 'PATCH',
+			data,
+			onError: (e) => console.log(e),
+		}),
+
+	checkNickname: async (nickname, firstName) => {
+		const res = await queryHandler({
+			url: `${PROFILE_BACKEND_URI}profiles/_exists?nickname=${nickname}`,
+		});
+		if (res.nicknameExists) {
+			const suggestions = await queryHandler({
+				url: `${PROFILE_BACKEND_URI}profiles/_generate?nickname=${nickname}&firstname=${firstName}`,
+			});
+			return suggestions;
+		}
+		return [];
+	},
+
+	fetchCountries: () =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, '/countries'),
+			method: 'GET',
+		}),
+	fetchAddresses: (params) =>
+		queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, ADDRESSES),
+			params,
+		}),
+	checkCustomerExistence: async (data) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_PREEXISTENCE_CHECK),
+			method: 'POST',
+			data,
+		});
+
+		return result;
+	},
+	sendActivationEmail: async (data) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_SEND_ACTIVATION_EMAIL),
+			method: 'POST',
+			data,
+		});
+
+		return result;
+	},
+	sendResetPassword: async (data) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_SEND_RESET_PWD_EMAIL),
+			method: 'POST',
+			data,
+		});
+
+		return result;
+	},
+	presignup: async (data) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_PRESIGNUP),
+			method: 'POST',
+			data,
+		});
+
+		return result;
+	},
+	fetchAvailablePointsTransformation: async () => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_AVAILABLE_TRANSFORMATION_POINTS_REWARDS),
+			method: 'GET',
+		});
+
+		return result;
+	},
+	createPointsTransformation: async ({ activationCode, pointsToTransform }) => {
+		const result = await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, CUSTOMER_AVAILABLE_TRANSFORMATION_POINTS_REWARDS),
+			method: 'POST',
+			data: { activationCode, pointsToTransform },
+		});
+
+		return result;
+	},
+
+	checkSwitchToProEligibility: async () => {
+		const result = await queryHandler({
+			url: composeUrl(
+				PROFILE_BACKEND_URI,
+				`${CUSTOMER_INFO}/inhabitantTransformation/_check`,
+			),
+			method: 'GET',
+		});
+		return result;
+	},
+
+	switchCustomerAccountToPro: async (customerInfo) =>
+		await queryHandler({
+			url: composeUrl(PROFILE_BACKEND_URI, `${CUSTOMER_INFO}/inhabitantTransformation`),
+			method: 'POST',
+			data: customerInfo,
+			onError: (e) => {
+				throw e;
+			},
+		}),
+};

package/cdp-due--customer-space-module-master/src/services/errorHandler.js

@@ -0,0 +1,30 @@
+import { hasRole, ROLES } from '@/authentication';
+import { NOT_AUTHORIZED_ROUTE, UNKNOWN_ERROR_ROUTE } from '@/router/constants';
+
+export const defaultOnError = () => {
+	document.location.href = UNKNOWN_ERROR_ROUTE;
+};
+
+export const defaultErrorHandler = async (response, onError) => {
+	switch (response && response.status) {
+		case 401:
+			document.location.reload();
+			return;
+		case 403:
+			{
+				const isAnyCustomer = await hasRole([ROLES.ROLE_CUSTOMER, ROLES.ROLE_CUSTOMER_PRO]);
+				if (!isAnyCustomer.value) {
+					// WORKAROUND cannot use router here
+					document.location.href = NOT_AUTHORIZED_ROUTE;
+					return;
+				}
+			}
+			break;
+
+		default:
+			break;
+	}
+
+	// eslint-disable-next-line consistent-return
+	return onError(response.statusText);
+};

package/cdp-due--customer-space-module-master/src/services/errorMessages/shoppingListErrorMessage.js

@@ -0,0 +1,15 @@
+export const addToCartErrorMessages = {
+	'invalid-quantity': 'customer-space_add-to-cart_error-message_invalid-quantity--title',
+	'too-many-lines': 'customer-space_add-to-cart_error-message_too-many-lines--title',
+	'sample-quantity-exceeded':
+		'customer-space_add-to-cart_error-message_sample-quantity-exceeded--title',
+	'creation-need-valid-offer':
+		'customer-space_add-to-cart_error-message_creation-need-valid-offer--title',
+	'invalid-customer': 'customer-space_add-to-cart_error-message_invalid-customer--title',
+	'inconsistent-customer-user':
+		'customer-space_add-to-cart_error-message_inconsistent-customer-user--title',
+	'customer-order-not-found':
+		'customer-space_add-to-cart_error-message_customer-order-not-found--title',
+	'stage-not-allowed': 'customer-space_add-to-cart_error-message_stage-not-allowed--title',
+	'no-product-to-add': 'customer-space_add-to-cart_error-message_no-product-to-add--title',
+};

package/cdp-due--customer-space-module-master/src/services/projectsService.js

@@ -0,0 +1,60 @@
+import { config } from '@/config';
+import { composeUrl } from '@/utils/composeUrl';
+import { logger } from '@/utils/logger';
+
+import queryHandler from '../queryHandler';
+
+const { PROJECTS_BACKEND_URI, CART_PATH } = config;
+const CUSTOMER_INFO = 'customers/[customerNumber]';
+const PROJECTS_URL = 'plans/';
+const ASSOCIATE_TO_SALE_URL = `${CUSTOMER_INFO}/orders`;
+const ESTIMATES = `${CUSTOMER_INFO}/estimates`;
+const ESTIMATE = `${ESTIMATES}/[id]`;
+
+const projectsService = {
+	async getProjects() {
+		const res = await queryHandler({
+			url: composeUrl(PROJECTS_BACKEND_URI, PROJECTS_URL),
+			method: 'GET',
+		});
+
+		return res;
+	},
+	deleteProject: async (id) =>
+		await queryHandler({
+			url: PROJECTS_BACKEND_URI + PROJECTS_URL + id,
+			method: 'DELETE',
+		}),
+	associateToSale: async ({ customerNumber, onSuccessRedirectUrl }) => {
+		const result = await queryHandler({
+			url: composeUrl(PROJECTS_BACKEND_URI, ASSOCIATE_TO_SALE_URL, {
+				customerNumber,
+			}),
+			method: 'PUT',
+		});
+
+		if (result?.hasBeenMerged || result?.hasOngoingSale) {
+			return { redirectUrl: `${CART_PATH}?merged=true` };
+		}
+
+		return { redirectUrl: onSuccessRedirectUrl };
+	},
+	fetchEstimates: (params) =>
+		queryHandler({
+			url: composeUrl(PROJECTS_BACKEND_URI, ESTIMATES),
+			method: 'GET',
+			params,
+			onError: (e) => {
+				logger.error('Could not retrieve estimates', e);
+				throw e;
+			},
+		}),
+	fetchEstimate: ({ id, storeCode }) =>
+		queryHandler({
+			url: composeUrl(PROJECTS_BACKEND_URI, ESTIMATE, { id }),
+			method: 'GET',
+			params: { storeCode },
+		}),
+};
+
+export default projectsService;

package/cdp-due--customer-space-module-master/src/services/queries/fetchWrapper.js

@@ -0,0 +1,45 @@
+import { defaultErrorHandler, defaultOnError } from '../errorHandler';
+
+export async function fetchWrapper({
+	url,
+	params,
+	data,
+	formatter,
+	errorHandler = defaultErrorHandler,
+	onError = defaultOnError,
+	type,
+	...options
+}) {
+	try {
+		const response = await fetch(params ? `${url}?${new URLSearchParams(params)}` : `${url}`, {
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			...options,
+			...(data ? { body: JSON.stringify(data) } : {}),
+		});
+
+		if (!response.ok) {
+			throw response;
+		}
+
+		if (type === 'blob') {
+			return await response.blob();
+		}
+
+		const text = await response.text();
+
+		if (type === 'string') {
+			return text;
+		}
+
+		const json = text ? JSON.parse(text) : {};
+
+		if (formatter) {
+			return formatter(json);
+		}
+		return json;
+	} catch (error) {
+		return errorHandler(error, onError);
+	}
+}

package/cdp-due--customer-space-module-master/src/services/queries/queryBuilder.js

@@ -0,0 +1,24 @@
+import { AppError } from '@/utils/AppError';
+
+import { fetchWrapper } from './fetchWrapper';
+
+export const defaultConfig = {
+	// Prevent TanStack Query to fetch again if cache is still valid
+	cacheTime: Infinity,
+	// Prevent TanStack Query to fetch again silently if cache is still valid
+	staleTime: Infinity,
+	refetchOnWindowFocus: false,
+};
+
+export function queryBuilder({ cacheKey, options = {}, ...queryConfig }) {
+	if (!cacheKey || !Object.keys(queryConfig).length) {
+		throw new AppError(182642, 'Cache key and query config are mandatory !');
+	}
+
+	return {
+		queryKey: cacheKey,
+		queryFn: () => fetchWrapper(queryConfig),
+		...defaultConfig,
+		...options,
+	};
+}

package/cdp-due--customer-space-module-master/src/services/utils.js

@@ -0,0 +1,13 @@
+import { getCurrentCustomer } from '../contents/admin/module/getters';
+
+const CUSTOMER_NUMBER_PLACEHOLDER = 'customerNumber';
+
+export const composeUrl = (basePath, route, params = {}) => {
+	const customerNumber = getCurrentCustomer()?.id || 'me';
+	const reducer = { ...params, [CUSTOMER_NUMBER_PLACEHOLDER]: customerNumber };
+
+	return (
+		basePath +
+		Object.keys(reducer).reduce((acc, key) => acc.replace(`[${key}]`, reducer[key]), route)
+	);
+};

package/cdp-due--customer-space-module-master/src/store/edges-cases/siret/module/index.js

@@ -0,0 +1,8 @@
+import { createModule } from '@/utils/createModule';
+import { createSliceHandler } from '@/utils/createSliceHandler';
+
+export const MODULE_KEY = 'edgeCase';
+
+export const siretInfoTextHandler = createSliceHandler('siretInfoText', MODULE_KEY, {});
+
+export const edgeCasesModule = createModule([siretInfoTextHandler], MODULE_KEY);