@proconnect-gouv/proconnect.identite 1.0.0

package/src/managers/certification/is-organization-dirigeant.test.ts

@@ -0,0 +1,125 @@
+//
+
+import { NotFoundError } from "#src/errors";
+import {
+  LiElJonsonFranceConnectUserInfo,
+  RogalDornFranceConnectUserInfo,
+} from "#testing/seed/franceconnect";
+import {
+  LiElJonsonEstablishment,
+  RogalDornEstablishment,
+} from "#testing/seed/insee";
+import { UlysseToriMandataire } from "#testing/seed/mandataires";
+import {
+  Papillon,
+  RogalDornEntrepreneur as RogalDornSireneEntrepreneur,
+} from "@proconnect-gouv/proconnect.entreprise/testing/seed/insee/siret";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { isOrganizationDirigeantFactory } from "./is-organization-dirigeant.js";
+
+//
+
+describe("isOrganizationDirigeantFactory", () => {
+  it("should recognize a user as executive of a auto-entrepreneur", async () => {
+    const isOrganizationDirigeant = isOrganizationDirigeantFactory({
+      EntrepriseApiInfogreffeRepository: {
+        findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
+      },
+      EntrepriseApiInseeRepository: {
+        findBySiret: () => Promise.resolve(RogalDornSireneEntrepreneur),
+      },
+      InseeApiRepository: {
+        findBySiret: () => Promise.resolve(RogalDornEstablishment),
+      },
+      getFranceConnectUserInfo: () =>
+        Promise.resolve(RogalDornFranceConnectUserInfo),
+    });
+    const isDirigeant = await isOrganizationDirigeant(
+      RogalDornSireneEntrepreneur.siret,
+      1,
+    );
+    assert.equal(isDirigeant, true);
+  });
+
+  it("should not match another mandataire", async () => {
+    const isOrganizationDirigeant = isOrganizationDirigeantFactory({
+      EntrepriseApiInfogreffeRepository: {
+        findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
+      },
+      EntrepriseApiInseeRepository: {
+        findBySiret: () => Promise.resolve(RogalDornSireneEntrepreneur),
+      },
+      InseeApiRepository: {
+        findBySiret: () => Promise.resolve(LiElJonsonEstablishment),
+      },
+      getFranceConnectUserInfo: () =>
+        Promise.resolve(RogalDornFranceConnectUserInfo),
+    });
+    const isDirigeant = await isOrganizationDirigeant(
+      RogalDornSireneEntrepreneur.siret,
+      1,
+    );
+    assert.equal(isDirigeant, false);
+  });
+
+  it("should match Ulysse Tori as an executive of Papillon", async () => {
+    const isOrganizationDirigeant = isOrganizationDirigeantFactory({
+      EntrepriseApiInfogreffeRepository: {
+        findMandatairesSociauxBySiren: () =>
+          Promise.resolve([UlysseToriMandataire]),
+      },
+      EntrepriseApiInseeRepository: {
+        findBySiret: () => Promise.resolve(Papillon),
+      },
+      InseeApiRepository: {
+        findBySiret: () => Promise.reject(new Error("💣")),
+      },
+      getFranceConnectUserInfo: () =>
+        Promise.resolve(RogalDornFranceConnectUserInfo),
+    });
+    const isDirigeant = await isOrganizationDirigeant(Papillon.siret, 1);
+    assert.equal(isDirigeant, false);
+  });
+
+  it("❎ fail with no franceconnect user info", async () => {
+    const isOrganizationDirigeant = isOrganizationDirigeantFactory({
+      EntrepriseApiInfogreffeRepository: {
+        findMandatairesSociauxBySiren: () => Promise.reject(new Error("💣")),
+      },
+      EntrepriseApiInseeRepository: {
+        findBySiret: () => Promise.resolve(RogalDornSireneEntrepreneur),
+      },
+      InseeApiRepository: {
+        findBySiret: () => Promise.reject(new Error("💣")),
+      },
+      getFranceConnectUserInfo: () => Promise.resolve(undefined),
+    });
+
+    await assert.rejects(
+      isOrganizationDirigeant("94957325700019", 1),
+      new NotFoundError("FranceConnect UserInfo not found"),
+    );
+  });
+
+  it("❎ fail with no mandataires", async () => {
+    const isOrganizationDirigeant = isOrganizationDirigeantFactory({
+      EntrepriseApiInfogreffeRepository: {
+        findMandatairesSociauxBySiren: () => Promise.resolve([]),
+      },
+      EntrepriseApiInseeRepository: {
+        findBySiret: () => Promise.resolve(Papillon),
+      },
+      InseeApiRepository: {
+        findBySiret: () => Promise.reject(new Error("💣")),
+      },
+      getFranceConnectUserInfo: () =>
+        Promise.resolve(LiElJonsonFranceConnectUserInfo),
+    });
+
+    await assert.rejects(
+      isOrganizationDirigeant(Papillon.siret, 1),
+      new NotFoundError("No mandataires found"),
+    );
+  });
+});

package/src/managers/certification/is-organization-dirigeant.ts

@@ -0,0 +1,136 @@
+//
+
+import { NotFoundError } from "#src/errors";
+import { fromInfogreffe } from "#src/mappers/certification";
+import { fromSiret } from "#src/mappers/organization";
+import type { GetFranceConnectUserInfoHandler } from "#src/repositories/user";
+import { isEntrepriseUnipersonnelle } from "#src/services/organization";
+import type { IdentityVector } from "#src/types";
+import type {
+  EntrepriseApiInfogreffeRepository,
+  EntrepriseApiInseeRepository,
+} from "@proconnect-gouv/proconnect.entreprise/api";
+import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.entreprise/types";
+import type { InseeApiRepository } from "@proconnect-gouv/proconnect.insee/api";
+import { formatBirthdate } from "@proconnect-gouv/proconnect.insee/formatters";
+import { distance } from "./distance.js";
+
+//
+
+type IsOrganizationExecutiveFactoryFactoryConfig = {
+  EntrepriseApiInfogreffeRepository: EntrepriseApiInfogreffeRepository;
+  EntrepriseApiInseeRepository: Pick<
+    EntrepriseApiInseeRepository,
+    "findBySiret"
+  >;
+  EQUALITY_THRESHOLD?: number;
+  getFranceConnectUserInfo: GetFranceConnectUserInfoHandler;
+  InseeApiRepository: Pick<InseeApiRepository, "findBySiret">;
+  log?: typeof console.log;
+};
+
+//
+
+export function isOrganizationDirigeantFactory(
+  config: IsOrganizationExecutiveFactoryFactoryConfig,
+) {
+  const {
+    EQUALITY_THRESHOLD = 0,
+    EntrepriseApiInseeRepository,
+    EntrepriseApiInfogreffeRepository,
+    InseeApiRepository,
+    getFranceConnectUserInfo,
+    log = () => {},
+  } = config;
+
+  return async function isOrganizationDirigeant(
+    siret: string,
+    user_id: number,
+  ) {
+    const establishment = await EntrepriseApiInseeRepository.findBySiret(siret);
+    const franceconnectUserInfo = await getFranceConnectUserInfo(user_id);
+    if (!franceconnectUserInfo) {
+      throw new NotFoundError("FranceConnect UserInfo not found");
+    }
+
+    const sourceDirigeants =
+      await getSourceDirigeantsFromEstablishment(establishment);
+
+    if (sourceDirigeants.length === 0) {
+      throw new NotFoundError("No mandataires found");
+    }
+
+    const distances = sourceDirigeants.map((sourceDirigeant) =>
+      Math.abs(distance(franceconnectUserInfo, sourceDirigeant)),
+    );
+
+    const closestSourceDirigeantDistance = Math.min(...distances);
+    const closestSourceDirigeant =
+      sourceDirigeants[distances.indexOf(closestSourceDirigeantDistance)];
+
+    log(
+      closestSourceDirigeant,
+      " is the closest source dirigeant to ",
+      franceconnectUserInfo,
+      " with a distance of ",
+      closestSourceDirigeantDistance,
+    );
+
+    return closestSourceDirigeantDistance === EQUALITY_THRESHOLD;
+  };
+
+  async function getSourceDirigeantsFromEstablishment(
+    establishment: InseeSireneEstablishmentSiretResponseData,
+  ): Promise<IdentityVector[]> {
+    const organization = fromSiret(establishment);
+
+    if (
+      isEntrepriseUnipersonnelle({
+        cached_libelle_categorie_juridique:
+          organization.libelleCategorieJuridique,
+        cached_tranche_effectifs: organization.trancheEffectifs,
+      })
+    ) {
+      return getSourceDirigeantsFromInsseApi(establishment.siret);
+    }
+    return getSourceDirigeantsFromEntrepriseApi(
+      establishment.unite_legale.siren,
+    );
+  }
+
+  async function getSourceDirigeantsFromInsseApi(siret: string) {
+    const { uniteLegale } = await InseeApiRepository.findBySiret(siret);
+    const birthdate = formatBirthdate(
+      String(uniteLegale?.dateNaissanceUniteLegale),
+    );
+
+    return [
+      {
+        birthplace: uniteLegale?.codeCommuneNaissanceUniteLegale ?? null,
+        birthdate: isNaN(birthdate.getTime()) ? null : birthdate,
+        family_name: uniteLegale?.nomUniteLegale ?? null,
+        given_name: [
+          uniteLegale?.prenom1UniteLegale,
+          uniteLegale?.prenom2UniteLegale,
+          uniteLegale?.prenom3UniteLegale,
+          uniteLegale?.prenom4UniteLegale,
+        ]
+          .filter(Boolean)
+          .join(" "),
+      } satisfies IdentityVector,
+    ];
+  }
+
+  async function getSourceDirigeantsFromEntrepriseApi(siren: string) {
+    const mandataires =
+      await EntrepriseApiInfogreffeRepository.findMandatairesSociauxBySiren(
+        siren,
+      );
+
+    return mandataires.map((mandataire) => fromInfogreffe(mandataire));
+  }
+}
+
+export type IsOrganizationDirigeantHandler = ReturnType<
+  typeof isOrganizationDirigeantFactory
+>;

package/src/managers/franceconnect/index.ts

@@ -0,0 +1,3 @@
+//
+
+export * from "./openid-client.js";

package/src/managers/franceconnect/openid-client.ts

@@ -0,0 +1,131 @@
+//
+
+import {
+  FranceConnectUserInfoResponseSchema,
+  type FranceConnectUserInfoResponse,
+} from "#src/types";
+import {
+  allowInsecureRequests,
+  authorizationCodeGrant,
+  buildAuthorizationUrl,
+  buildEndSessionUrl,
+  ClientSecretBasic,
+  discovery,
+  fetchUserInfo,
+  randomNonce,
+  randomState,
+  type ClientMetadata,
+} from "openid-client";
+import { z } from "zod";
+
+//
+
+export type FranceConnectConfigurationParams = {
+  allowLocalhost?: boolean;
+  clientId: string;
+  clientSecret: string;
+  metadata: Partial<ClientMetadata>;
+  server: URL;
+};
+
+export function getFranceConnectConfigurationFactory(
+  params: FranceConnectConfigurationParams,
+) {
+  const { allowLocalhost, clientId, clientSecret, metadata, server } = params;
+  return function getFranceConnectConfiguration() {
+    return discovery(
+      server,
+      clientId,
+      metadata,
+      ClientSecretBasic(clientSecret),
+      allowLocalhost ? { execute: [allowInsecureRequests] } : undefined,
+    );
+  };
+}
+
+export type GetFranceConnectConfigurationHandler = ReturnType<
+  typeof getFranceConnectConfigurationFactory
+>;
+
+export function createOidcChecks() {
+  return {
+    state: randomState(),
+    nonce: randomNonce(),
+  };
+}
+
+export function getFranceConnectRedirectUrlFactory(
+  getConfiguration: GetFranceConnectConfigurationHandler,
+  parameters: {
+    callbackUrl: string;
+    scope: string;
+  },
+) {
+  const { callbackUrl, scope } = parameters;
+  return async function getFranceConnectUser(nonce: string, state: string) {
+    const config = await getConfiguration();
+    return buildAuthorizationUrl(
+      config,
+      new URLSearchParams({
+        acr_values: "eidas1",
+        nonce,
+        redirect_uri: callbackUrl,
+        scope,
+        state,
+      }),
+    );
+  };
+}
+
+export function getFranceConnectUserFactory(
+  getConfiguration: GetFranceConnectConfigurationHandler,
+) {
+  return async function getFranceConnectUser(parameters: {
+    code: string;
+    currentUrl: URL;
+    expectedNonce: string;
+    expectedState: string;
+  }) {
+    const { code, currentUrl, expectedNonce, expectedState } = parameters;
+    const config = await getConfiguration();
+    const tokens = await authorizationCodeGrant(
+      config,
+      currentUrl,
+      {
+        expectedNonce,
+        expectedState,
+      },
+      { code },
+    );
+
+    const claims = tokens.claims();
+
+    const { sub } = await z.object({ sub: z.string() }).parseAsync(claims);
+    const user_info_response = await fetchUserInfo(
+      config,
+      tokens.access_token,
+      sub,
+    );
+
+    const user_info: FranceConnectUserInfoResponse =
+      await FranceConnectUserInfoResponseSchema.parseAsync(user_info_response);
+    return { user_info, id_token: tokens.id_token };
+  };
+}
+
+export function getFranceConnectLogoutRedirectUrlFactory(
+  getConfiguration: GetFranceConnectConfigurationHandler,
+) {
+  return async function getFranceConnectLogoutRedirectUrl(
+    id_token_hint: string,
+    post_logout_redirect_uri: string,
+    state: string,
+  ) {
+    const config = await getConfiguration();
+    return buildEndSessionUrl(config, {
+      id_token_hint,
+      post_logout_redirect_uri,
+      state,
+    });
+  };
+}

package/src/managers/organization/force-join-organization.test.ts

@@ -0,0 +1,94 @@
+import { NotFoundError } from "#src/errors";
+import type { Organization, User } from "#src/types";
+import assert from "node:assert/strict";
+import { suite, test } from "node:test";
+import type { EmailDomain } from "../../types/index.js";
+import { forceJoinOrganizationFactory } from "./force-join-organization.js";
+
+suite("forceJoinOrganizationFactory", () => {
+  test("should update the organization user link ", async () => {
+    const forceJoinOrganization = forceJoinOrganizationFactory({
+      findEmailDomainsByOrganizationId: () => Promise.resolve([]),
+      getById: () => Promise.resolve({ id: 42 } as Organization),
+      getUserById: () =>
+        Promise.resolve({ email: "lion.eljonson@darkangels.world" } as User),
+      linkUserToOrganization: (values) => Promise.resolve(values as any),
+    });
+
+    assert.deepEqual(
+      await forceJoinOrganization({
+        organization_id: 42,
+        user_id: 42,
+      }),
+      {
+        is_external: false,
+        organization_id: 42,
+        user_id: 42,
+        verification_type: "no_validation_means_available",
+      },
+    );
+  });
+
+  test("should update the organization user link with domain verification ", async () => {
+    const forceJoinOrganization = forceJoinOrganizationFactory({
+      findEmailDomainsByOrganizationId: () =>
+        Promise.resolve([
+          {
+            domain: "darkangels.world",
+            verification_type: "verified",
+          } as EmailDomain,
+        ]),
+      getById: () => Promise.resolve({ id: 42 } as Organization),
+      getUserById: () =>
+        Promise.resolve({ email: "lion.eljonson@darkangels.world" } as User),
+      linkUserToOrganization: (values) => Promise.resolve(values as any),
+    });
+
+    assert.deepEqual(
+      await forceJoinOrganization({
+        organization_id: 42,
+        user_id: 42,
+      }),
+      {
+        is_external: false,
+        organization_id: 42,
+        user_id: 42,
+        verification_type: "domain",
+      },
+    );
+  });
+
+  test("❎ throws NotFoundError for unknown organization", async () => {
+    const forceJoinOrganization = forceJoinOrganizationFactory({
+      findEmailDomainsByOrganizationId: () => Promise.resolve([]),
+      getById: () => Promise.reject(new NotFoundError("💣")),
+      getUserById: () => Promise.resolve({ id: 42 } as User),
+      linkUserToOrganization: () => Promise.reject(),
+    });
+
+    await assert.rejects(
+      forceJoinOrganization({
+        organization_id: 42,
+        user_id: 42,
+      }),
+      new NotFoundError("💣"),
+    );
+  });
+
+  test("❎ throws NotFoundError for unknown user", async () => {
+    const forceJoinOrganization = forceJoinOrganizationFactory({
+      findEmailDomainsByOrganizationId: () => Promise.resolve([]),
+      getById: () => Promise.resolve({ id: 42 } as Organization),
+      getUserById: () => Promise.reject(new NotFoundError("💣")),
+      linkUserToOrganization: () => Promise.reject(),
+    });
+
+    await assert.rejects(
+      forceJoinOrganization({
+        organization_id: 42,
+        user_id: 42,
+      }),
+      new NotFoundError("💣"),
+    );
+  });
+});

package/src/managers/organization/force-join-organization.ts

@@ -0,0 +1,90 @@
+//
+
+import type { FindEmailDomainsByOrganizationIdHandler } from "#src/repositories/email-domain";
+import type {
+  GetByIdHandler as GetOrganizationByIdHandler,
+  LinkUserToOrganizationHandler,
+} from "#src/repositories/organization";
+import type { GetByIdHandler as GetUserByIdHandler } from "#src/repositories/user";
+import type { BaseUserOrganizationLink } from "#src/types";
+import { getEmailDomain } from "@proconnect-gouv/proconnect.core/services/email";
+import { match } from "ts-pattern";
+import { UserOrganizationLinkVerificationTypeSchema } from "../../types/index.js";
+
+//
+
+type FactoryDependencies = {
+  findEmailDomainsByOrganizationId: FindEmailDomainsByOrganizationIdHandler;
+  getById: GetOrganizationByIdHandler;
+  getUserById: GetUserByIdHandler;
+  linkUserToOrganization: LinkUserToOrganizationHandler;
+};
+
+//
+
+export function forceJoinOrganizationFactory({
+  findEmailDomainsByOrganizationId,
+  getById,
+  getUserById,
+  linkUserToOrganization,
+}: FactoryDependencies) {
+  return async function forceJoinOrganization({
+    organization_id,
+    user_id,
+    is_external = false,
+  }: {
+    organization_id: number;
+    user_id: number;
+    is_external?: boolean;
+  }) {
+    const user = await getUserById(user_id);
+
+    // Ensure that the organization exists (Ceinture Bretelle)
+    await getById(organization_id);
+
+    const { email } = user;
+    const domain = getEmailDomain(email);
+    const organizationEmailDomains =
+      await findEmailDomainsByOrganizationId(organization_id);
+
+    const link_verification_type = organizationEmailDomains
+      .filter(({ domain: currentDomain }) => currentDomain === domain)
+      .reduce(
+        (acc, { verification_type }) => {
+          if (acc === "domain") {
+            return acc;
+          }
+
+          return match(verification_type)
+            .with(
+              "verified",
+              "trackdechets_postal_mail",
+              "external",
+              "official_contact",
+              () => UserOrganizationLinkVerificationTypeSchema.enum.domain,
+            )
+            .with(
+              null,
+              "blacklisted",
+              "refused",
+              () =>
+                UserOrganizationLinkVerificationTypeSchema.enum
+                  .no_validation_means_available,
+            )
+            .exhaustive();
+        },
+        "no_validation_means_available" as BaseUserOrganizationLink["verification_type"],
+      );
+
+    return await linkUserToOrganization({
+      organization_id,
+      user_id,
+      is_external,
+      verification_type: link_verification_type,
+    });
+  };
+}
+
+export type ForceJoinOrganizationHandler = ReturnType<
+  typeof forceJoinOrganizationFactory
+>;

package/src/managers/organization/get-organization-info.test.ts

@@ -0,0 +1,47 @@
+import { NotFoundError } from "#src/errors";
+import {
+  CommunautéDeCommunes,
+  RogalDornEntrepreneur,
+} from "@proconnect-gouv/proconnect.entreprise/testing/seed/insee/siret";
+import type { InseeSireneEstablishmentSiretResponseData } from "@proconnect-gouv/proconnect.entreprise/types";
+import assert from "node:assert/strict";
+import { suite, test } from "node:test";
+import { getOrganizationInfoFactory } from "./get-organization-info.js";
+
+suite("getOrganizationInfo", () => {
+  test("should return valid payload for diffusible siret", async (t) => {
+    const getOrganizationInfo = getOrganizationInfoFactory({
+      findBySiren: () => Promise.reject(),
+      findBySiret: () => Promise.resolve(CommunautéDeCommunes),
+    });
+    t.assert.snapshot(await getOrganizationInfo("20007184300060"));
+  });
+
+  test("should return valid payload for diffusible siren", async (t) => {
+    const getOrganizationInfo = getOrganizationInfoFactory({
+      findBySiren: () => Promise.resolve(CommunautéDeCommunes),
+      findBySiret: () => Promise.reject(),
+    });
+    t.assert.snapshot(await getOrganizationInfo("200071843"));
+  });
+
+  test("should show partial data for partially non diffusible établissement", async (t) => {
+    const getOrganizationInfo = getOrganizationInfoFactory({
+      findBySiren: () => Promise.reject(),
+      findBySiret: () => Promise.resolve(RogalDornEntrepreneur),
+    });
+
+    t.assert.snapshot(await getOrganizationInfo("94957325700019"));
+  });
+
+  test.skip("should throw for totally non diffusible établissement", async () => {
+    const getOrganizationInfo = getOrganizationInfoFactory({
+      findBySiren: () => Promise.reject(),
+      findBySiret: () =>
+        Promise.resolve({
+          status_diffusion: "non_diffusible",
+        } as InseeSireneEstablishmentSiretResponseData),
+    });
+    await assert.rejects(getOrganizationInfo("53512638700013"), NotFoundError);
+  });
+});

package/src/managers/organization/get-organization-info.test.ts.snapshot

@@ -0,0 +1,68 @@
+exports[`getOrganizationInfo > should return valid payload for diffusible siren 1`] = `
+{
+  "activitePrincipale": "84.11Z",
+  "adresse": "3 rue maison de vatimesnil, 27150 Etrepagny",
+  "categorieJuridique": "7346",
+  "codeOfficielGeographique": "27226",
+  "codePostal": "27150",
+  "enseigne": "",
+  "estActive": true,
+  "estDiffusible": true,
+  "etatAdministratif": "A",
+  "libelle": "Cc du vexin normand",
+  "libelleActivitePrincipale": "84.11Z - Administration publique générale",
+  "libelleCategorieJuridique": "Communauté de communes",
+  "libelleTrancheEffectif": "100 à 199 salariés, en 2022",
+  "nomComplet": "Cc du vexin normand",
+  "siret": "20007184300060",
+  "statutDiffusion": "diffusible",
+  "trancheEffectifs": "22",
+  "trancheEffectifsUniteLegale": "22"
+}
+`;
+
+exports[`getOrganizationInfo > should return valid payload for diffusible siret 1`] = `
+{
+  "activitePrincipale": "84.11Z",
+  "adresse": "3 rue maison de vatimesnil, 27150 Etrepagny",
+  "categorieJuridique": "7346",
+  "codeOfficielGeographique": "27226",
+  "codePostal": "27150",
+  "enseigne": "",
+  "estActive": true,
+  "estDiffusible": true,
+  "etatAdministratif": "A",
+  "libelle": "Cc du vexin normand",
+  "libelleActivitePrincipale": "84.11Z - Administration publique générale",
+  "libelleCategorieJuridique": "Communauté de communes",
+  "libelleTrancheEffectif": "100 à 199 salariés, en 2022",
+  "nomComplet": "Cc du vexin normand",
+  "siret": "20007184300060",
+  "statutDiffusion": "diffusible",
+  "trancheEffectifs": "22",
+  "trancheEffectifsUniteLegale": "22"
+}
+`;
+
+exports[`getOrganizationInfo > should show partial data for partially non diffusible établissement 1`] = `
+{
+  "activitePrincipale": "62.02A",
+  "adresse": "06155 Vallauris",
+  "categorieJuridique": "1000",
+  "codeOfficielGeographique": "06155",
+  "codePostal": "06155",
+  "enseigne": "",
+  "estActive": true,
+  "estDiffusible": false,
+  "etatAdministratif": "A",
+  "libelle": "Nom inconnu",
+  "libelleActivitePrincipale": "62.02A - Conseil en systèmes et logiciels informatiques",
+  "libelleCategorieJuridique": "Entrepreneur individuel",
+  "libelleTrancheEffectif": "",
+  "nomComplet": "Nom inconnu",
+  "siret": "94957325700019",
+  "statutDiffusion": "partiellement_diffusible",
+  "trancheEffectifs": null,
+  "trancheEffectifsUniteLegale": null
+}
+`;