@tekkare/romulus 0.1.251 → 0.1.253

package/layer/app/composables/useOipResourceViews.ts

@@ -0,0 +1,117 @@
+import { defineAsyncComponent, type Component } from "vue";
+
+/**
+ * Le composant de chaque onglet de fiche, par type et par cle d'onglet (cf.
+ * OIP_RESOURCE_SPECS). Charges a la demande : une fiche ouverte ne tire que
+ * ses onglets, ce qui compte sur les reseaux lents des hopitaux.
+ *
+ * Contrat d'un onglet : props `id` (l'identifiant de route, cf.
+ * `spec.routeId`), `highlight` (termes a surligner) et `lang`. Ses liens vers
+ * d'autres fiches passent par useOipResourceNav, ses sources par
+ * useOipResourceHooks().
+ */
+const LOADERS: Record<string, Record<string, () => Promise<any>>> = {
+  PubMed: {
+    "summary": () => import("../components/OipPubmedSummary.vue"),
+    "authors": () => import("../components/oip-science/pubmed/Authors.vue"),
+    "clinical-trials": () => import("../components/oip-science/pubmed/ClinicalTrials.vue"),
+  },
+  ClinicalTrialsNCT: {
+    "study-description": () => import("../components/oip-science/ctgov/StudyDescription.vue"),
+    "investigators": () => import("../components/oip-science/ctgov/Investigators.vue"),
+    "locations": () => import("../components/oip-science/ctgov/Locations.vue"),
+    "sponsors": () => import("../components/oip-science/ctgov/Sponsors.vue"),
+    "publications": () => import("../components/oip-science/ctgov/Publications.vue"),
+  },
+  ClinicalTrialsEUCT: {
+    "study-description": () => import("../components/oip-science/euct/StudyDescription.vue"),
+    "products": () => import("../components/oip-science/euct/Products.vue"),
+    "investigators": () => import("../components/oip-science/euct/Investigators.vue"),
+    "locations": () => import("../components/oip-science/euct/Locations.vue"),
+    "sponsors": () => import("../components/oip-science/euct/Sponsors.vue"),
+    "publications": () => import("../components/oip-science/euct/Publications.vue"),
+  },
+  HCP: {
+    "informations": () => import("../components/oip-science/hcps/Informations.vue"),
+    "clinical-trials": () => import("../components/oip-science/hcps/ClinicalTrials.vue"),
+    "appels-a-projet": () => import("../components/oip-science/hcps/AppelsAProjet.vue"),
+    "pubmed": () => import("../components/oip-science/hcps/Pubmed.vue"),
+    "matched-labels": () => import("../components/oip-science/hcps/MatchedLabels.vue"),
+  },
+  Establishment: {
+    "informations": () => import("../components/oip-science/establishments/Informations.vue"),
+    "clinical-trials": () => import("../components/oip-science/establishments/ClinicalTrials.vue"),
+    "public-finance": () => import("../components/oip-science/establishments/PublicFinance.vue"),
+    "hcps": () => import("../components/oip-science/establishments/Hcps.vue"),
+    "matched-labels": () => import("../components/oip-science/establishments/MatchedLabels.vue"),
+  },
+  ClinicalTrialsInvestigatorsNCT: {
+    "informations": () => import("../components/oip-science/ctgov-investigators/Informations.vue"),
+    "clinical-trials": () => import("../components/oip-science/ctgov-investigators/ClinicalTrials.vue"),
+    "publications": () => import("../components/oip-science/ctgov-investigators/Publications.vue"),
+  },
+  ClinicalTrialsInvestigatorsEUCT: {
+    "informations": () => import("../components/oip-science/euct-investigators/Informations.vue"),
+    "clinical-trials": () => import("../components/oip-science/euct-investigators/ClinicalTrials.vue"),
+    "publications": () => import("../components/oip-science/euct-investigators/Publications.vue"),
+  },
+  ClinicalTrialsCentersNCT: {
+    "clinical-trials": () => import("../components/oip-science/ctgov-centers/ClinicalTrials.vue"),
+    "publications": () => import("../components/oip-science/ctgov-centers/Publications.vue"),
+  },
+  ClinicalTrialsCentersEUCT: {
+    "clinical-trials": () => import("../components/oip-science/euct-centers/ClinicalTrials.vue"),
+    "publications": () => import("../components/oip-science/euct-centers/Publications.vue"),
+  },
+};
+
+/**
+ * Les vues d'un seul tenant (`spec.view`, fiches de fr_drugs_app) et les
+ * fiches qu'un lien peut viser (cf. utils/oipFicheRoutes).
+ *
+ * - `drugs-<famille>` : la ressource rangee, par son `resourceId` (props `id`,
+ *   parfois `by`). Une PUT, une MITM, un prix ou une AMM ouvrent la fiche
+ *   marque sur leur onglet, comme fr_drugs_app.
+ * - `drugs-<fiche>-fiche` : la fiche elle-meme, telle que la page de
+ *   fr_drugs_app la monte (props de sa route : `brand` et `tab`, `code`,
+ *   `id`, `label`).
+ */
+const VIEW_LOADERS: Record<string, () => Promise<any>> = {
+  "science-phrc": () => import("../components/oip-science/resources/Phrc.vue"),
+  "drugs-brand": () => import("../components/oip-drugs/resources/Brand.vue"),
+  "drugs-put": () => import("../components/oip-drugs/resources/Put.vue"),
+  "drugs-mitm": () => import("../components/oip-drugs/resources/Mitm.vue"),
+  "drugs-price": () => import("../components/oip-drugs/resources/Price.vue"),
+  "drugs-ansm": () => import("../components/oip-drugs/resources/Ansm.vue"),
+  "drugs-indication": () => import("../components/oip-drugs/resources/Indication.vue"),
+  "drugs-pnds": () => import("../components/oip-drugs/resources/Pnds.vue"),
+  "drugs-jo": () => import("../components/oip-drugs/resources/Jo.vue"),
+  "drugs-association": () => import("../components/oip-drugs/resources/Association.vue"),
+  "drugs-contribution": () => import("../components/oip-drugs/resources/Contribution.vue"),
+  "drugs-national-assembly": () => import("../components/oip-drugs/resources/NationalAssembly.vue"),
+  "drugs-medicam": () => import("../components/oip-drugs/resources/Medicam.vue"),
+  "drugs-outpatient": () => import("../components/oip-drugs/resources/Outpatient.vue"),
+  "drugs-hospital": () => import("../components/oip-drugs/resources/Hospital.vue"),
+  "drugs-brand-fiche": () => import("../components/oip-drugs/fiches/BrandFiche.vue"),
+  "drugs-indication-fiche": () => import("../components/oip-drugs/fiches/IndicationFiche.vue"),
+  "drugs-pnds-fiche": () => import("../components/oip-drugs/fiches/PndsFiche.vue"),
+  "drugs-jo-fiche": () => import("../components/oip-drugs/fiches/JoFiche.vue"),
+  "drugs-association-fiche": () => import("../components/oip-drugs/fiches/AssociationFiche.vue"),
+};
+
+const cache = new Map<string, Component>();
+
+export function oipResourceViewComponent(key: string): Component | null {
+  const loader = VIEW_LOADERS[key];
+  if (!loader) return null;
+  if (!cache.has(`view:${key}`)) cache.set(`view:${key}`, defineAsyncComponent(loader));
+  return cache.get(`view:${key}`)!;
+}
+
+export function oipResourceTabComponent(type: string, key: string): Component | null {
+  const loader = LOADERS[type]?.[key];
+  if (!loader) return null;
+  const cacheKey = `${type}/${key}`;
+  if (!cache.has(cacheKey)) cache.set(cacheKey, defineAsyncComponent(loader));
+  return cache.get(cacheKey)!;
+}

package/layer/app/composables/useOipResources.ts

@@ -0,0 +1,83 @@
+import {
+  oipResourceAppUrl,
+  oipResourceSpec,
+  OIP_RESOURCE_APPS,
+  type OipEsCluster,
+  type OipResourceTypeEntry,
+} from "../utils/oipResources";
+
+/**
+ * Lecture des ressources pour les vues du layer : le proxy Elasticsearch
+ * commun (/api/oip/es) et le registre des types de l'API.
+ */
+
+/** Une recherche dans un index declare par une vue (cf. OIP_RESOURCE_SPECS). */
+export function oipEsSearch<T = any>(cluster: OipEsCluster, index: string, body: Record<string, unknown>) {
+  return $fetch<T>("/api/oip/es", { method: "POST", query: { cluster, index }, body });
+}
+
+/** Un document par son `_id`, ou null. */
+export async function oipEsGet<S = any>(
+  cluster: OipEsCluster,
+  index: string,
+  id: string,
+  source?: string[],
+): Promise<{ _id: string; _source: S } | null> {
+  const response = await oipEsSearch<any>(cluster, index, {
+    size: 1,
+    query: { ids: { values: [id] } },
+    ...(source ? { _source: source } : {}),
+  });
+  return response?.hits?.hits?.[0] ?? null;
+}
+
+/**
+ * Les documents d'un type decrit par le layer, par `_id`, pour lister ses
+ * elements dans la page d'un projet. Vide pour un type que le layer ne
+ * connait pas : l'app le relit elle-meme.
+ */
+export async function oipHydrate(type: string, ids: string[]): Promise<Record<string, any>> {
+  const spec = oipResourceSpec(type);
+  if (!spec || !ids.length) return {};
+  const response = await oipEsSearch<any>(spec.cluster, spec.kind.index, {
+    size: ids.length,
+    ...(spec.kind.source ? { _source: spec.kind.source } : {}),
+    query: { ids: { values: ids } },
+  });
+  const docs: Record<string, any> = Object.fromEntries(
+    (response?.hits?.hits ?? []).map((hit: any) => [String(hit._id), hit._source]),
+  );
+  // Une contribution se titre par la marque, lue dans l'index HAS.
+  if (type === "FrPatientContribution") {
+    const { withContributionBrands } = await import("../oip-drugs/utils/contributions");
+    await withContributionBrands(Object.values(docs));
+  }
+  return docs;
+}
+
+// Le registre change quelques fois par an : un appel par session suffit.
+let registry: Promise<OipResourceTypeEntry[]> | null = null;
+
+export function useOipResourceTypes(): Promise<OipResourceTypeEntry[]> {
+  registry ??= $fetch<OipResourceTypeEntry[]>("/api/oip/resource-types").catch(() => {
+    registry = null;
+    return [];
+  });
+  return registry;
+}
+
+/**
+ * Le lien vers la fiche dans son app d'origine, et le nom de cette app. Pour
+ * un type sans vue, l'URL du registre (deja absolue, remplie par l'appelant).
+ */
+export function oipResourceOrigin(type: string, id: string, lang: "fr" | "en") {
+  const spec = oipResourceSpec(type);
+  if (!spec) return null;
+  return {
+    name: OIP_RESOURCE_APPS[spec.app].name,
+    url: oipResourceAppUrl(spec.app, spec.detailPath(id), lang),
+  };
+}
+
+/** La marque des contributions patients, lue dans l'index HAS (cf. oip-drugs/utils/contributions). */
+export { withContributionBrands } from "../oip-drugs/utils/contributions";

package/layer/app/oip-drugs/PORTING.md

@@ -0,0 +1,120 @@
+# Porter une fiche médicament de fr_drugs_app dans le layer
+
+Les fiches médicament (marque HAS et ses onglets, indication, PNDS, publication JO,
+association, contribution, évolutions des ventes) vivent ici pour s'afficher **à
+l'identique** dans toutes les apps du portail : la page de fr_drugs_app et le tiroir des
+projets de n'importe quelle app montent le même composant. Source :
+`~/Projects/fr_drugs_app/app` (lecture seule).
+
+Le rendu de fr_drugs_app est la spec : on porte son code presque tel quel, en ne changeant
+que ce qui l'attache à l'app. Pas de refonte. Même démarche que les fiches science
+(`../oip-science/PORTING.md`), à lire pour l'esprit ; les règles ci-dessous priment.
+
+## Où ranger
+
+| Quoi | Où | Nom / import |
+|---|---|---|
+| Composant | `app/components/oip-drugs/<dossier>/<Nom>.vue` | auto-importé sous `OipDrugs<Dossier><Nom>` (ex. `oip-drugs/heart/TextHighlight.vue` → `<OipDrugsHeartTextHighlight>`) |
+| Composable, util, store porté | `app/oip-drugs/composables/*.ts`, `app/oip-drugs/utils/*.ts` | **pas** auto-importés : import relatif explicite. Garder les noms de fr_drugs_app. |
+| Index ES | `app/oip-drugs/esIndices.ts` (copie de `types/esIndices.ts`) | `import { ES_INDEX } from "<rel>/oip-drugs/esIndices"` |
+| Types ES | `app/oip-drugs/types/` (copie de `types/elastic.ts`, `types/es/*`, `types/heart/*`) | imports relatifs |
+| Monographies | `app/oip-drugs/monographs/*.vue` (copie de `app/monographs/*.vue`) | `import.meta.glob` relatif |
+| Rapports PDF/HTML | `layer/public/reports/` (déjà copiés) | même URL `/reports/...` |
+
+Dans fr_drugs_app, un composant de `components/heart/x/y.vue` devient
+`components/oip-drugs/heart/x/Y.vue` (même arborescence sous `oip-drugs/`, nom de fichier
+avec une majuscule). Tous les lots suivent cette règle : un lot utilise le composant d'un
+autre par ce nom, même s'il n'existe pas encore.
+
+## Remplacements obligatoires
+
+- **Racine** : chaque fiche, vue de ressource et composant monté seul (tiroirs téléportés
+  compris) porte la classe `oip-drugs` sur sa racine. Les classes globales de fr_drugs_app
+  (`main.css`, `heart/css/scoped.css` : `heart_*`, `oip_*`…) marchent dessous (cf.
+  `drugs.css`). Ne pas les réécrire. Les règles `.heart_app X` deviennent `.oip-drugs X`.
+- **Elasticsearch** : `useHeartElastic()` → `useOipDrugsElastic()`
+  (`app/oip-drugs/composables/useOipDrugsElastic.ts`, mêmes fonctions). Les listes nommées
+  (`keyName`), que la page relisait dans `useResultStore`, sont dans `lists[keyName]` du
+  même objet. `$fetch('/api/es?index=…')` et `useElasticGeneral`/`useFetch('/api/es…')` →
+  `oipEsSearch('drugs', index, body)` (`app/composables/useOipResources.ts`). Index par
+  `ES_INDEX.X` (ids Directus). Les surcharges `esIndexFromConfig(runtimeConfig.public.x, …)`
+  prennent la valeur du catalogue.
+- **Routes serveur** : `/api/pdf?url=` → `/api/oip/pdf?url=`, `/api/reports` →
+  `/api/oip/reports`, `/api/sources` → `/api/oip/sources` (déjà servies par le layer).
+- **i18n** : clés sous `oipDrugs.` : `$t('heart.price')` → `$t('oipDrugs.heart.price')`
+  (fichiers `app/oip-drugs/locales/*.json`, copie complète de fr_drugs_app, ne pas les éditer).
+- **Route** : jamais `useRoute()`, `route.params`, `route.query`. Ce que la page lisait dans
+  sa route devient une prop (`brand`, `tab`, `code`, `id`, `label`, `cis`, `indication`…).
+  Un changement d'onglet que la page écrivait dans `?tab=` devient
+  `emit('update:tab', key)` (prop `tab` + `v-model:tab`).
+- **Liens** (`navigateTo`, `router.push`, `NuxtLink`, `localePath`, `heartOpenCard`,
+  `heartBrandPath`, `associationPath`) : `const nav = useOipResourceNav()` (auto-importé),
+  puis `nav.openApp('fr_drugs_app', path)` au clic et `:href="nav.appHref('fr_drugs_app', path)"`
+  pour garder le Ctrl/Cmd-clic (`@click.prevent` sauf touche modificatrice). `path` est le
+  chemin de fr_drugs_app, inchangé (`drugsBrandPath`, `drugsAssociationPath` de
+  `app/oip-drugs/kinds.ts`). Dans un tiroir, le layer empile la fiche si elle est connue
+  (cf. `app/utils/oipFicheRoutes.ts`) ; dans une page, il navigue. Liens externes inchangés.
+- **Bouton Projet** (`hubr-project-add`, `HubrProjectAdd`) :
+  `const { projectButton } = useOipResourceHooks()` puis
+  `<component :is="projectButton" v-if="projectButton" :resource-id="…" type="…" :label="…" compact />`.
+  Ne jamais importer `useHubrProjects`, `useHubrResourceKinds`, `useElysiaApi`.
+- **Sources** (`sourceContainerElastic`, `useHeartSourceUuids`, `HEART_SOURCE_UUIDS`) :
+  `<OipResourceSource :uuid="…" />` par uuid (le composant du layer lit `/api/oip/sources`
+  et ouvre le panneau Sources par le hook de l'app). Les uuids viennent de
+  `app/oip-drugs/utils/sourceUuids.ts` (lot P), plus de `route.path`.
+- **Stores Pinia et `useState`** (`filterStore`, `sharedFiltersStore`, `resultStore`,
+  `elasticQueryStore`, `appConfigStore`, `CurrencyStore`, `countryMapping`,
+  `priceCurrencyStore`, `countryEdito`, `retail`, `outpatient`, `cardPrefs`,
+  `useHeartDetailTab`) : état local du composant, ou petit composable par instance dans
+  `app/oip-drugs/composables/`. Les données de référence (taux de change, table des pays)
+  deviennent un composable qui les charge.
+  `cardPrefs` / `useCardPrefOptions` → prop `prefs` avec les valeurs par défaut de fr_drugs_app.
+- **Cadre de l'app** : retirer `useExportSource`, `useAlertSource`, `useViews`,
+  `useHeartLayout().setToolbar*`, `useAppLayout`, `definePageMeta`, `usePosthogTracking`,
+  `useHubrEmbedded` (toujours « embarqué » dans le layer) et l'export de la fiche
+  (`details/export.vue`, `les/export.vue`, `mitm/export.vue`) : l'en-tête et l'export restent
+  dans la page de fr_drugs_app, qui les passe au slot `actions` de la fiche.
+- Surlignage de recherche lu dans un store : prop `highlight: string[]` (défaut `[]`).
+
+## Contrats
+
+- **Fiche** (`components/oip-drugs/fiches/*Fiche.vue`, montée par la page de fr_drugs_app
+  et par le tiroir) : props de sa route (`BrandFiche` : `brand`, `tab` ;
+  `IndicationFiche` : `code` ; `PndsFiche` : `id` ; `JoFiche` : `id` ;
+  `AssociationFiche` : `label`), plus `lang`, `highlight`. Elle rend son bandeau
+  (`RmPageHeader` : titre, onglets) et son contenu ; slot `actions` dans le bandeau pour
+  l'export et le bouton Projet de la page. Emet `update:tab`. Charge ses données elle-même.
+- **Vue de ressource** (`components/oip-drugs/resources/*.vue`, montée par le tiroir d'un
+  projet pour un `resourceType`) : props `id` (le `resourceId`), `type`, `lang`,
+  `highlight`, parfois `by` (`"cis"`, `"local_drug_id"` : l'id est ce champ et non l'`_id`).
+  Elle relit le document et monte la fiche ou la carte qui convient.
+
+Affichage tant que les données arrivent : `RmLoadingState` ; document absent : l'état
+vide de fr_drugs_app, sinon `RmEmptyState`.
+
+## Répartition (sept lots en parallèle)
+
+Chaque fichier de fr_drugs_app a un seul lot propriétaire. Un lot n'écrit que ses
+fichiers et utilise ceux des autres par leur nom cible (même API que l'original). Fichier
+utile absent du tableau : le créer sous un nom préfixé par la lettre du lot
+(`oip-drugs/utils/q-<nom>.ts`) et le signaler.
+
+| Lot | Contenu (chemins fr_drugs_app sous `app/`) |
+|---|---|
+| P, socle | composants `heart/textHighlight`, `heart/elastic/sourceContainerElastic` (→ liste d'`OipResourceSource`), `heart/results/{matchExplain,prefRows,asmrCursor,indicCard,accesCard,evalCard,alertCard}`, `heart/searchPage/dynamicSource` ; composables `useHeartMatchExplain`, `useHeartSearchFields`, `useHeartSourceUuids` (→ `oip-drugs/utils/sourceUuids.ts`, uuids explicites), `useDirectusSources`, `useMergeByKey`, `usePageEmpty`, `useCardPrefOptions` (→ défauts) ; utils `heartStyleAndFormat`, `styleAndFormat`, `latestDate`, `heartStyleAnsm`, `associationFields`, `esHighlight`, `priceExport`, `exportSheets` ; stores `CurrencyStore` (→ `oip-drugs/composables/useCurrency.ts`), `countryMapping` (→ util) |
+| Q, fiche marque (cadre et onglets HAS) | `pages/hubr/heart/details/[id].vue` → `fiches/BrandFiche.vue` (onglets par clé, `tab`) ; `heart/results/details/{monograph,hasHistory,opinionDrawer,recordList,recordDrawer}` ; `heart/les/{drawer,indicationDetail,card,source,sourceTag}` ; `useHeartLesIndication`, `useHeartDetailSearches` ; `app/monographs/*.vue` ; vue de ressource `resources/Brand.vue` (doc BRAND_HAS par `_id` → `brand_group` → `BrandFiche`) |
+| R, fiche marque (prix et international) | `heart/results/details/{priceOverview,presentationDrawer,internationalOverview,internationalCountryCard,internationalPriceDrawer}` ; `useHeartIntlApprovals`, `useHeartReports` (→ `/api/oip/reports`), `useHeartBrandMatches`, utils `heartIntlPrice` |
+| S, fiche marque (ANSM, MITM) et redirections | `heart/ansm/cisDetail` (+ puces CIS), `heart/mitm/details/overview` ; vues de ressource `resources/{Put,Mitm,Price,Ansm}.vue` : relire le document (`_id`, ou `by`), trouver la marque comme la page de fr_drugs_app (`put/[id]`, `mitm/[id]`, `prices/details/[id]`, `ansm/details/[id]`) et monter `BrandFiche` sur l'onglet `put`, `mitm`, `price`, `ansm` ; sans marque, ce que la page montre alors (au minimum sa carte : `heart/put/card`, `heart/mitm/...`, `heart/results/brandGroupCard`, `heart/ansm/brandCard`) |
+| T, indication, PNDS, JO | `pages/hubr/heart/indication/[id].vue` → `fiches/IndicationFiche.vue` (+ `heart/results/details/price`) ; `pages/hubr/heart/pnds/[id].vue` → `fiches/PndsFiche.vue` ; `pages/hubr/heart/prices/jo/[id].vue` → `fiches/JoFiche.vue` (+ `heart/joCard`) ; vues `resources/{Indication,Pnds,Jo}.vue` |
+| U, associations | `pages/hubr/heart/associations/[id].vue` → `fiches/AssociationFiche.vue` ; `heart/associations/{transcriptionCard,nationalAssemblyCard,nationalAssemblyFiche}` ; `useAssociationDetail`, `useAssociationExport` (la partie lecture), `useAssociationLookup` ; vues `resources/{Association,NationalAssembly}.vue` ; `resources/Contribution.vue` : **le détail de la contribution** (décision produit), en reprenant le contenu de `~/Projects/france_augmented_science_app/app/components/drugs/ContributionDetail.vue` mais avec les composants et le style de fr_drugs_app, et un lien vers l'association |
+| V, évolutions des ventes | `hubr/projectMedicamEvolution` + `medicam/market/chart` (store `retail` → état local) → `resources/Medicam.vue` ; `outpatient/productEvolution` (+ `useElasticGeneral`, store `outpatient` → état local) → `resources/Outpatient.vue` ; `resources/Hospital.vue` pour `FrSusBrand` et `FrRetrocessionBrand` (**décision produit** : un graphe d'évolution par marque, au gabarit des deux autres, en reprenant les données et requêtes de `~/Projects/france_augmented_science_app/app/components/drugs/HospitalEvolution.vue`) |
+
+## Compte rendu attendu de chaque lot
+
+Fichiers créés, écarts de rendu volontaires, clés i18n manquantes, dépendances vers
+d'autres lots, ce qui n'a pas pu être porté.
+
+## Règles de texte
+
+Aucun tiret cadratin (—) dans un texte visible : parenthèses ou virgules. Commentaires en
+français sans accents dans le code, comme le reste du layer.

package/layer/app/oip-drugs/composables/useAssociationDetail.ts

@@ -0,0 +1,220 @@
+/**
+ * Tout ce que les sept index disent d'une association, pour sa fiche (portage
+ * de useAssociationDetail de fr_drugs_app).
+ *
+ * Cinq index portent `association_label_regroup` et se lisent directement.
+ * Les deux autres ne l'ont pas : les seances du comite d'interface ANSM se
+ * rejoignent par `session_url` en passant par la liste des participants, et le
+ * texte des debats HAS par `has_code` + `transcription_url` en passant par la
+ * transcription. Les blocs ne partent qu'a la demande : il y en a deux cent
+ * cinquante par debat, et une fiche en cite huit.
+ */
+import type { Ref } from "vue";
+import { ES_INDEX } from "../esIndices";
+import type { EsIndexName } from "../esIndices";
+import { ASSOCIATION_FIELDS, NATIONAL_ASSEMBLY_FIELDS } from "../utils/associationFields";
+import useOipDrugsElastic from "./useOipDrugsElastic";
+import { useAssociationHasBrands } from "./useAssociationExport";
+
+/** Plafond des listes de la fiche. Aucune association n'en approche. */
+const PAGE_SIZE = 200;
+/** Plafond des blocs d'un debat. Le plus long en compte environ 400. */
+const BLOCKS_SIZE = 500;
+/** Plafond des participants d'une fiche : une vingtaine par seance. */
+const ATTENDEES_SIZE = 1000;
+
+export function useAssociationDetail(label: Ref<string>) {
+  const { queryCustomElastic } = useOipDrugsElastic();
+
+  const directory = ref<any>(null);
+  const contributions = ref<any[]>([]);
+  const transcriptions = ref<any[]>([]);
+  const sessions = ref<any[]>([]);
+  const nationalAssembly = ref<any[]>([]);
+  const loading = ref(true);
+
+  /**
+   * Toutes les ecritures du nom que l'annuaire connait pour cette
+   * association : son nom regroupe, et les appellations brutes des sources
+   * qu'il liste dans `association_label`.
+   *
+   * Filtrer sur le seul nom regroupe laissait 55 associations sur 159 sans
+   * aucune contribution a l'ecran : le regroupement de l'annuaire et celui des
+   * index sources ne sont pas le meme. L'appellation brute, elle, se retrouve
+   * de part et d'autre. A retirer le jour ou `association_label_regroup` sera
+   * aligne sur les six index.
+   */
+  const knownLabels = ref<string[]>([]);
+
+  function labelsFrom(doc: any): string[] {
+    const raw = doc?.[ASSOCIATION_FIELDS.labelVariants];
+    const names = new Set<string>([label.value]);
+    if (typeof raw === "string") {
+      raw.split(";").forEach((value) => {
+        const name = value.trim();
+        if (name) names.add(name);
+      });
+    }
+    return [...names];
+  }
+
+  /** Les deux champs de nom des index sources, contre toutes ces ecritures. */
+  const byLabel = () => ({
+    bool: {
+      should: [
+        { terms: { [ASSOCIATION_FIELDS.label]: knownLabels.value } },
+        { terms: { [ASSOCIATION_FIELDS.labelVariants]: knownLabels.value } },
+      ],
+      minimum_should_match: 1,
+    },
+  });
+
+  async function hits(index: EsIndexName, body: Record<string, any>) {
+    const res: any = await queryCustomElastic({ index, customQuery: body as any, allAnswer: true });
+    return (res?.hits?.hits ?? []).map((hit: any) => hit._source);
+  }
+
+  /**
+   * Les autres associations presentes a chaque seance, par `session_url`. Une
+   * seance du comite d'interface reunit une vingtaine d'associations : la
+   * fiche les nomme, l'association affichee en moins.
+   */
+  const sessionAttendees = ref<Record<string, string[]>>({});
+
+  /** Les seances suivies par l'association, via la liste des participants. */
+  async function loadSessions() {
+    const attendees = await hits(ES_INDEX.ASSOCIATION_SESSION_ATTENDEE_ANSM, {
+      size: PAGE_SIZE,
+      _source: ["session_url"],
+      query: { bool: { must: [byLabel()] } },
+    });
+    const urls = [...new Set(attendees.map((a: any) => a.session_url).filter(Boolean))];
+    if (!urls.length) return [];
+
+    const [found, others] = await Promise.all([
+      hits(ES_INDEX.ASSOCIATION_SESSION_ANSM, {
+        size: PAGE_SIZE,
+        query: { terms: { session_url: urls } },
+        sort: [{ session_date: { order: "desc" } }],
+      }),
+      // Toute la liste des participants de ces seances, en une requete : une
+      // requete par carte aurait fait autant d'allers-retours qu'il y a de
+      // seances.
+      hits(ES_INDEX.ASSOCIATION_SESSION_ATTENDEE_ANSM, {
+        size: ATTENDEES_SIZE,
+        query: { terms: { session_url: urls } },
+      }),
+    ]);
+
+    sessionAttendees.value = groupAttendees(others);
+    return found;
+  }
+
+  /**
+   * Les participants regroupes par seance, l'association affichee retiree et
+   * les doublons de nom ecartes : une meme association peut figurer deux fois
+   * dans la liste sous deux ecritures qui se regroupent sous le meme nom.
+   */
+  function groupAttendees(attendees: any[]) {
+    const mine = new Set(knownLabels.value.map((name) => name.toLowerCase()));
+    const out: Record<string, string[]> = {};
+    attendees.forEach((attendee: any) => {
+      const url = attendee?.session_url;
+      const name =
+        attendee?.[ASSOCIATION_FIELDS.label] || attendee?.[ASSOCIATION_FIELDS.labelVariants];
+      if (!url || !name || mine.has(String(name).toLowerCase())) return;
+      const names = (out[url] ??= []);
+      if (!names.some((value) => value.toLowerCase() === String(name).toLowerCase())) {
+        names.push(String(name));
+      }
+    });
+    Object.values(out).forEach((names) => names.sort((a, b) => a.localeCompare(b, "fr")));
+    return out;
+  }
+
+  async function load() {
+    loading.value = true;
+
+    // L'annuaire d'abord : c'est lui qui dit sous quels noms chercher le
+    // reste.
+    const directoryHits = await hits(ES_INDEX.ASSOCIATION_DIRECTORY, {
+      size: 1,
+      query: { term: { _id: label.value } },
+    });
+    directory.value = directoryHits[0] ?? null;
+    knownLabels.value = labelsFrom(directory.value);
+
+    const [contributionHits, transcriptionHits, sessionHits, nationalAssemblyHits] = await Promise.all([
+      hits(ES_INDEX.ASSOCIATION_CONTRIBUTION_HAS, {
+        size: PAGE_SIZE,
+        query: { bool: { must: [byLabel()] } },
+        sort: [{ contribution_date: { order: "desc" } }],
+      }),
+      hits(ES_INDEX.ASSOCIATION_TRANSCRIPTION_HAS, {
+        size: PAGE_SIZE,
+        query: { bool: { must: [byLabel()] } },
+        sort: [{ session_date: { order: "desc" } }],
+      }),
+      loadSessions(),
+      // Les comptes rendus de commission portent deux listes de noms
+      // regroupes : les associations citees et celles de la fiche. Une
+      // association compte si elle est dans l'une ou l'autre, sous toutes ses
+      // ecritures connues.
+      hits(ES_INDEX.ASSOCIATION_COMMISSION_SESSION_NATIONAL_ASSEMBLY, {
+        size: PAGE_SIZE,
+        _source: { excludes: [NATIONAL_ASSEMBLY_FIELDS.text] },
+        query: {
+          bool: {
+            should: [NATIONAL_ASSEMBLY_FIELDS.associations, NATIONAL_ASSEMBLY_FIELDS.ficheAssociations].map(
+              (field) => ({ terms: { [field]: knownLabels.value } }),
+            ),
+            minimum_should_match: 1,
+          },
+        },
+        sort: [{ [NATIONAL_ASSEMBLY_FIELDS.sessionDate]: { order: "desc" } }],
+      }),
+    ]);
+
+    contributions.value = contributionHits;
+    transcriptions.value = transcriptionHits;
+    sessions.value = sessionHits;
+    nationalAssembly.value = nationalAssemblyHits;
+    loading.value = false;
+
+    // Apres coup : les cartes s'affichent sans attendre, le lien vers l'avis
+    // apparait quand la marque est resolue.
+    await loadBrands(contributionHits.map((contribution: any) => contribution.has_code));
+  }
+
+  /** La marque de l'avis de chaque contribution, par code HAS (cf. useAssociationHasBrands). */
+  const { brands, load: loadBrands } = useAssociationHasBrands();
+
+  /** Le fil d'un debat, tour de parole par tour de parole. */
+  async function loadBlocks(hasCode: string, transcriptionUrl: string) {
+    return await hits(ES_INDEX.ASSOCIATION_TRANSCRIPTION_BLOCK_HAS, {
+      size: BLOCKS_SIZE,
+      query: {
+        bool: {
+          must: [
+            { term: { has_code: hasCode } },
+            { term: { transcription_url: transcriptionUrl } },
+          ],
+        },
+      },
+      sort: [{ block_index: { order: "asc" } }],
+    });
+  }
+
+  return {
+    directory,
+    contributions,
+    transcriptions,
+    sessions,
+    nationalAssembly,
+    sessionAttendees,
+    loading,
+    load,
+    loadBlocks,
+    brands,
+  };
+}

package/layer/app/oip-drugs/composables/useAssociationExport.ts

@@ -0,0 +1,63 @@
+/**
+ * Portage de la partie lecture de useAssociationExport de fr_drugs_app : la
+ * marque de l'avis auquel une contribution se rattache. Les schemas de
+ * colonnes et la lecture des index lies pour l'export restent dans
+ * fr_drugs_app, qui garde l'export de la fiche.
+ */
+import { ES_INDEX } from "../esIndices";
+import useOipDrugsElastic from "./useOipDrugsElastic";
+
+/**
+ * La marque de l'avis auquel se rattache chaque contribution, par code HAS.
+ *
+ * Les index associations ne portent que le code ; la fiche produit du hub
+ * s'ouvre, elle, sur le nom de marque. C'est l'index des avis qui fait le
+ * lien, son historique portant le code. Tous les codes partent ensemble, en
+ * une agregation : une requete par contribution ferait autant d'allers-retours
+ * qu'il y a de contributions. Requete a part : l'index des avis n'est pas un
+ * index associations.
+ */
+export function useAssociationHasBrands() {
+  const { queryCustomElastic } = useOipDrugsElastic();
+  const hasIndex = ES_INDEX.BRAND_HAS;
+  const brands = ref<Record<string, string>>({});
+
+  async function load(hasCodes: unknown[]) {
+    const codes = [...new Set(hasCodes.filter((code): code is string => typeof code === "string" && code !== ""))].filter(
+      (code) => !(code in brands.value),
+    );
+    if (!codes.length) return;
+
+    const res: any = await queryCustomElastic({
+      index: hasIndex,
+      customQuery: {
+        size: 0,
+        aggs: {
+          history: {
+            nested: { path: "brand_history" },
+            aggs: {
+              by_code: {
+                // `include` borne l'agregation aux codes demandes : sans lui,
+                // `terms` remonterait les codes les plus frequents de l'index.
+                terms: { field: "brand_history.has_code.keyword", include: codes, size: codes.length },
+                aggs: {
+                  up: { reverse_nested: {}, aggs: { brand: { terms: { field: "brand_group.keyword", size: 1 } } } },
+                },
+              },
+            },
+          },
+        },
+      } as any,
+      allAnswer: true,
+    });
+
+    const found: Record<string, string> = {};
+    (res?.aggregations?.history?.by_code?.buckets ?? []).forEach((bucket: any) => {
+      const brand = bucket?.up?.brand?.buckets?.[0]?.key;
+      if (brand) found[bucket.key] = brand;
+    });
+    brands.value = { ...brands.value, ...found };
+  }
+
+  return { brands, load };
+}