always update businessName from siret, stop infinite loop on route pa…

…rams

front/src/app/components/forms/convention/sections/establishment/EstablishmentBusinessFields.tsx

@@ -6,7 +6,10 @@ import { ConventionDto } from "shared";
 import { formConventionFieldsLabels } from "src/app/contents/forms/convention/formConvention";
 import { getFormContents } from "src/app/hooks/formContents.hooks";
 import { useAppSelector } from "src/app/hooks/reduxHooks";
-import { useSiretFetcher } from "src/app/hooks/siret.hooks";
+import {
+  useSiretFetcher,
+  useSiretRelatedField,
+} from "src/app/hooks/siret.hooks";
 import { conventionSelectors } from "src/core-logic/domain/convention/convention.selectors";
 
 export const EstablishmentBusinessFields = (): JSX.Element => {
@@ -18,10 +21,22 @@ export const EstablishmentBusinessFields = (): JSX.Element => {
     isFetchingSiret,
   } = useSiretFetcher({ shouldFetchEvenIfAlreadySaved: true });
   const convention = useAppSelector(conventionSelectors.convention);
-
   const { getValues, register, control, setValue } =
     useFormContext<ConventionDto>();
   const values = getValues();
+  const isSiretFetcherEnabled =
+    values.status === "DRAFT" && values.immersionAddress === "";
+
+  const isSiretFetcherDisabled = !isSiretFetcherEnabled;
+
+  useSiretRelatedField("businessName", {
+    disabled: false, // the input is always disabled, so we can safely update businessName from siret
+  });
+  useSiretRelatedField("businessAddress", {
+    fieldToUpdate: "immersionAddress",
+    disabled: isSiretFetcherDisabled,
+  });
+
   const siretValueOnForm = useWatch({ control, name: "siret" });
 
   const { getFormFields } = getFormContents(

front/src/app/components/forms/convention/sections/immersion-details/ImmersionDetailsSection.tsx

@@ -9,23 +9,11 @@ import { ConventionFormProfession } from "src/app/components/forms/convention/Co
 import { booleanSelectOptions } from "src/app/contents/forms/common/values";
 import { formConventionFieldsLabels } from "src/app/contents/forms/convention/formConvention";
 import { getFormContents } from "src/app/hooks/formContents.hooks";
-import { useSiretRelatedField } from "src/app/hooks/siret.hooks";
 
 export const ImmersionDetailsSection = () => {
   const { setValue, getValues, register } = useFormContext<ConventionReadDto>();
   const values = getValues();
-  const isSiretFetcherEnabled =
-    values.status === "DRAFT" && values.immersionAddress === "";
 
-  const isSiretFetcherDisabled = !isSiretFetcherEnabled;
-
-  useSiretRelatedField("businessName", {
-    disabled: isSiretFetcherDisabled,
-  });
-  useSiretRelatedField("businessAddress", {
-    fieldToUpdate: "immersionAddress",
-    disabled: isSiretFetcherDisabled,
-  });
   const { getFormFields } = getFormContents(
     formConventionFieldsLabels(values.internshipKind),
   );

front/src/app/components/forms/convention/useUpdateConventionValuesInUrl.ts

@@ -38,14 +38,24 @@ export const useUpdateConventionValuesInUrl = (
         const filteredParams = filterParamsForRoute(
           urlParams,
           conventionParams,
+          ["fedId", "fedIdProvider"],
         );
-        routes[route.name]({ ...filteredParams, ...watchedValues }).replace();
+        const {
+          fedId: _,
+          fedIdProvider: __,
+          ...watchedValuesWithoutFederatedIdentity
+        } = watchedValues;
+        routes[route.name]({
+          ...filteredParams,
+          ...watchedValuesWithoutFederatedIdentity,
+        }).replace();
       }
 
       if (route.name === "conventionImmersionForExternals") {
         const filteredParams = filterParamsForRoute(
           urlParams,
           conventionForExternalParams,
+          ["fedId", "fedIdProvider"],
         );
         routes
           .conventionImmersionForExternals({

front/src/app/pages/convention/ConventionImmersionPage.tsx

@@ -1,7 +1,7 @@
 import { fr } from "@codegouvfr/react-dsfr";
 import { Button } from "@codegouvfr/react-dsfr/Button";
 import { keys } from "ramda";
-import React, { useEffect, useMemo, useState } from "react";
+import React, { useEffect, useMemo, useRef, useState } from "react";
 import { Loader, MainWrapper, PageHeader } from "react-design-system";
 import { useDispatch } from "react-redux";
 import { FederatedIdentityProvider, loginPeConnect } from "shared";
@@ -143,29 +143,29 @@ const PageContent = ({ route }: ConventionImmersionPageProps) => {
 
 const useFederatedIdentityFromUrl = (route: ConventionImmersionPageRoute) => {
   const dispatch = useDispatch();
-
-  const {
-    fedId,
-    fedIdProvider,
-    email = "",
-    firstName = "",
-    lastName = "",
-  } = route.params;
+  const initialRouteParams = useRef(route.params).current;
 
   useEffect(() => {
-    if (fedId && fedIdProvider) {
+    if (
+      initialRouteParams.fedId &&
+      initialRouteParams.fedIdProvider &&
+      initialRouteParams.email &&
+      initialRouteParams.firstName &&
+      initialRouteParams.lastName
+    ) {
       const {
         fedId: _,
         fedIdProvider: __,
         ...paramsWithoutFederatedIdentity
-      } = route.params;
+      } = initialRouteParams;
       dispatch(
         authSlice.actions.federatedIdentityProvided({
-          provider: fedIdProvider as FederatedIdentityProvider,
-          token: fedId,
-          email,
-          firstName,
-          lastName,
+          provider:
+            initialRouteParams.fedIdProvider as FederatedIdentityProvider,
+          token: initialRouteParams.fedId,
+          email: initialRouteParams.email,
+          firstName: initialRouteParams.firstName,
+          lastName: initialRouteParams.lastName,
           idToken: "should-not-need-for-pe-connect",
         }),
       );
@@ -176,7 +176,7 @@ const useFederatedIdentityFromUrl = (route: ConventionImmersionPageRoute) => {
         })
         .replace();
     }
-  }, [fedId, fedIdProvider, email, firstName, lastName, dispatch]);
+  }, [initialRouteParams, dispatch]);
 };
 
 const SharedConventionMessage = ({

front/src/app/utils/url.utils.ts

@@ -6,7 +6,10 @@ export const getUrlParameters: (location: Location) => {
 export const filterParamsForRoute = (
   urlParams: Record<string, unknown>,
   matchingParams: Record<string, unknown>,
+  forceExcludeParams?: string[],
 ) =>
   Object.fromEntries(
-    Object.entries(urlParams).filter(([key]) => key in matchingParams),
+    Object.entries(urlParams).filter(
+      ([key]) => key in matchingParams && !forceExcludeParams?.includes(key),
+    ),
   );