@tekkare/romulus 0.1.251 → 0.1.253

package/layer/app/oip-science/composables/useAuthorMatching.ts

@@ -0,0 +1,342 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+
+const normalize = (s: string | null | undefined) =>
+  (s || '')
+    .toString()
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[^a-zA-Z0-9]/g, '')
+    .toLowerCase();
+
+export default function useAuthorMatching() {
+  const { queryCustomElastic } = useOipElastic();
+
+  type PubmedAuthorMatch = {
+    hcp_code: string;
+    first_name: string;
+    family_name: string;
+    match_method: string | null;
+    score: number | null;
+    address: Array<{
+      hco_et_code: string | null;
+      hco_et_label: string | null;
+      city: string | null;
+    }>;
+  };
+
+  async function fetchPubmedAuthorMatches(pubmedId: string): Promise<PubmedAuthorMatch[]> {
+    const res = await queryCustomElastic({
+      index: indexConfig.hcpPubmed.index,
+      cluster: indexConfig.hcpPubmed.cluster,
+      customQuery: {
+        size: 1,
+        query: { term: { PubMed_ID: pubmedId } },
+      },
+    });
+
+    const doc = res?.results?.[0];
+    const matches: PubmedAuthorMatch[] = [];
+    for (const h of doc?.hcp || []) {
+      if (!h?.hcp_code || h.hcp_code.length !== 11) continue;
+      matches.push({
+        hcp_code: h.hcp_code,
+        first_name: h.hcp_first_name || '',
+        family_name: h.hcp_family_name || '',
+        match_method: h.match_method || null,
+        score: typeof h.score === 'number' ? h.score : null,
+        address: (h.address || []).map((a: any) => ({
+          hco_et_code: a.hco_et_code || null,
+          hco_et_label: a.hco_et_label || null,
+          city: a.hcp_city || null,
+        })),
+      });
+    }
+    return matches;
+  }
+
+  type TrialHcpMatch = {
+    hcp_code: string;
+    first_name: string;
+    family_name: string;
+    full_name: string;
+    match_method: string | null;
+    score: number | null;
+    specialty: Array<{ label: string; type: string }>;
+    address: Array<{
+      hco_et_label: string | null;
+      city: string | null;
+      dpt_label: string | null;
+      region_label: string | null;
+    }>;
+  };
+
+  async function fetchTrialHcpMatches(
+    trialId: string,
+    source: 'nct' | 'euct',
+  ): Promise<TrialHcpMatch[]> {
+    const cfg = source === 'nct' ? indexConfig.hcpNct : indexConfig.hcpEuct;
+    const res = await queryCustomElastic({
+      index: cfg.index,
+      cluster: cfg.cluster,
+      customQuery: {
+        size: 1,
+        query: { term: { clinical_trial_id: trialId } },
+      },
+    });
+
+    const doc = res?.results?.[0];
+    const matches: TrialHcpMatch[] = [];
+    for (const h of doc?.hcp || []) {
+      if (!h?.hcp_code || h.hcp_code.length !== 11) continue;
+      // NCT exposes `hcp_full_name`; EUCT exposes accented `first_name`/`last_name`
+      const firstAccented = h.first_name || h.hcp_first_name || '';
+      const familyAccented = h.last_name || h.hcp_family_name || '';
+      matches.push({
+        hcp_code: h.hcp_code,
+        first_name: h.hcp_first_name || '',
+        family_name: h.hcp_family_name || '',
+        full_name: h.hcp_full_name || `${firstAccented} ${familyAccented}`.trim(),
+        match_method: h.match_method || null,
+        score: typeof h.score === 'number' ? h.score : null,
+        specialty: (h.specialty || []).map((s: any) => ({
+          label: s.hcp_specialty_label_regroup || '',
+          type: s.hcp_specialty_type || '',
+        })),
+        address: (h.address || []).map((a: any) => ({
+          hco_et_code: a.hco_et_code || null,
+          hco_et_label: a.hco_et_label || null,
+          city: a.hcp_city || null,
+          dpt_label: a.hcp_dpt_label || null,
+          region_label: a.hcp_region_label || null,
+        })),
+      });
+    }
+    return matches;
+  }
+
+  const fetchNctHcpMatches = (nctId: string) => fetchTrialHcpMatches(nctId, 'nct');
+  const fetchEuctHcpMatches = (euctId: string) => fetchTrialHcpMatches(euctId, 'euct');
+
+  // Bulk variant: one ES request fetches all matches for many trial IDs at
+  // once. Used by the Generate-a-Report bulk export to enrich Investigators
+  // / Authors tabs with RPPS without firing N round-trips.
+  async function fetchTrialHcpMatchesBulk(
+    trialIds: string[],
+    source: 'nct' | 'euct' | 'pubmed',
+  ): Promise<Map<string, TrialHcpMatch[]>> {
+    const out = new Map<string, TrialHcpMatch[]>();
+    if (!trialIds.length) return out;
+    const cfg =
+      source === 'nct'
+        ? indexConfig.hcpNct
+        : source === 'euct'
+          ? indexConfig.hcpEuct
+          : indexConfig.hcpPubmed;
+    const idField = source === 'pubmed' ? 'PubMed_ID' : 'clinical_trial_id';
+    const res = await queryCustomElastic({
+      index: cfg.index,
+      cluster: cfg.cluster,
+      customQuery: {
+        size: trialIds.length,
+        query: { terms: { [idField]: trialIds } },
+      },
+    });
+    for (const doc of res?.results || []) {
+      const id = doc?.[idField];
+      if (!id) continue;
+      const matches: TrialHcpMatch[] = [];
+      for (const h of doc?.hcp || []) {
+        if (!h?.hcp_code || h.hcp_code.length !== 11) continue;
+        const firstAccented = h.first_name || h.hcp_first_name || '';
+        const familyAccented = h.last_name || h.hcp_family_name || '';
+        matches.push({
+          hcp_code: h.hcp_code,
+          first_name: h.hcp_first_name || '',
+          family_name: h.hcp_family_name || '',
+          full_name:
+            h.hcp_full_name || `${firstAccented} ${familyAccented}`.trim(),
+          match_method: h.match_method || null,
+          score: typeof h.score === 'number' ? h.score : null,
+          specialty: (h.specialty || []).map((s: any) => ({
+            label: s.hcp_specialty_label_regroup || '',
+            type: s.hcp_specialty_type || '',
+          })),
+          address: (h.address || []).map((a: any) => ({
+            hco_et_code: a.hco_et_code || null,
+            hco_et_label: a.hco_et_label || null,
+            city: a.hcp_city || null,
+            dpt_label: a.hcp_dpt_label || null,
+            region_label: a.hcp_region_label || null,
+          })),
+        });
+      }
+      out.set(String(id), matches);
+    }
+    return out;
+  }
+
+  type HcpTrialRow = {
+    clinical_trial_id: string;
+    result_id: string;
+    score: number | null;
+    match_method: string | null;
+  };
+
+  async function fetchTrialsForHcps(
+    rppsIds: string[],
+    source: 'nct' | 'euct',
+  ): Promise<HcpTrialRow[]> {
+    if (!rppsIds.length) return [];
+    const cfg = source === 'nct' ? indexConfig.hcpNct : indexConfig.hcpEuct;
+    const rppsSet = new Set(rppsIds);
+    const res = await queryCustomElastic({
+      index: cfg.index,
+      cluster: cfg.cluster,
+      customQuery: {
+        size: 10000,
+        _source: ['clinical_trial_id', 'hcp'],
+        query: {
+          nested: {
+            path: 'hcp',
+            query: { terms: { 'hcp.hcp_code.keyword': rppsIds } },
+          },
+        },
+      },
+    });
+    const rows: HcpTrialRow[] = [];
+    for (const doc of res?.results || []) {
+      if (!doc?.clinical_trial_id) continue;
+      for (const h of doc.hcp || []) {
+        if (!h?.hcp_code || !rppsSet.has(h.hcp_code)) continue;
+        rows.push({
+          clinical_trial_id: doc.clinical_trial_id,
+          result_id: h.hcp_code,
+          score: typeof h.score === 'number' ? h.score : null,
+          match_method: h.match_method || null,
+        });
+      }
+    }
+    return rows;
+  }
+
+  async function filterExistingHcps(rppsIds: (string | null)[]): Promise<Set<string>> {
+    const ids = [...new Set(rppsIds.filter((x): x is string => !!x))];
+    if (ids.length === 0) return new Set();
+    const res = await queryCustomElastic({
+      index: indexConfig.hcps.index,
+      cluster: indexConfig.hcps.cluster,
+      customQuery: {
+        size: ids.length,
+        _source: ['hcp_code'],
+        query: { terms: { hcp_code: ids } },
+      },
+    });
+    const set = new Set<string>();
+    for (const r of res?.results || []) {
+      if (r?.hcp_code) set.add(r.hcp_code);
+    }
+    return set;
+  }
+
+  // Build enriched author rows for one or many PubMed documents — pairs
+  // each author with its RPPS / FINESS / Matching Score / Match Method
+  // by querying the hcp-pubmed match index in a single bulk request.
+  // The returned rows feed the "Authors" tab on every PubMed Excel export.
+  type PubmedAuthorExportRow = {
+    pmid: string;
+    name: string | null;
+    affiliation: string | null;
+    rpps: string | null;
+    finess_et: string | null;
+    finess_label: string | null;
+    city: string | null;
+    score: number | null;
+    match_method: string | null;
+  };
+
+  async function buildPubmedAuthorExportRows(
+    pubmedDocs: Array<{
+      PubMed_ID?: string | number;
+      authors?: Array<any>;
+    }>,
+  ): Promise<PubmedAuthorExportRow[]> {
+    if (!pubmedDocs?.length) return [];
+    const pmids = pubmedDocs
+      .map((d) => (d.PubMed_ID != null ? String(d.PubMed_ID) : ''))
+      .filter((id) => id);
+    if (!pmids.length) return [];
+
+    const matchesByPmid = await fetchTrialHcpMatchesBulk(pmids, 'pubmed').catch(
+      () => new Map<string, TrialHcpMatch[]>(),
+    );
+
+    const rows: PubmedAuthorExportRow[] = [];
+    for (const doc of pubmedDocs) {
+      const pmid = doc.PubMed_ID != null ? String(doc.PubMed_ID) : '';
+      const docMatches = matchesByPmid.get(pmid) || [];
+      // Index matches by normalized first+last and last+first for tolerant lookup.
+      const byName = new Map<string, TrialHcpMatch>();
+      for (const m of docMatches) {
+        const a = normalize(`${m.first_name || ''}${m.family_name || ''}`);
+        const b = normalize(`${m.family_name || ''}${m.first_name || ''}`);
+        if (a) byName.set(a, m);
+        if (b) byName.set(b, m);
+      }
+      const seen = new Set<string>();
+      for (const author of doc.authors || []) {
+        const forename = author?.forename || '';
+        const lastname = author?.lastname || '';
+        const fullName = `${forename} ${lastname}`.trim();
+        if (!fullName) continue;
+        const a = normalize(`${forename}${lastname}`);
+        const b = normalize(`${lastname}${forename}`);
+        const m = byName.get(a) || byName.get(b) || null;
+        if (m?.hcp_code) seen.add(m.hcp_code);
+        const primary = (m?.address || []).find((x: any) => x?.hco_et_code);
+        rows.push({
+          pmid,
+          name: fullName,
+          affiliation: author?.affiliation || null,
+          rpps: m?.hcp_code || null,
+          finess_et: primary?.hco_et_code || null,
+          finess_label: primary?.hco_et_label || null,
+          city: primary?.city || null,
+          score: m?.score ?? null,
+          match_method: m?.match_method ?? null,
+        });
+      }
+      // Any matched HCP that wasn't paired to a doc author (e.g. matched on
+      // a normalized variant we didn't try) still deserves a row so the
+      // Excel reflects the full set of HCPs identified for this PMID.
+      for (const m of docMatches) {
+        if (!m.hcp_code || seen.has(m.hcp_code)) continue;
+        const primary = (m.address || []).find((x: any) => x?.hco_et_code);
+        rows.push({
+          pmid,
+          name: `${m.first_name || ''} ${m.family_name || ''}`.trim() || null,
+          affiliation: null,
+          rpps: m.hcp_code,
+          finess_et: primary?.hco_et_code || null,
+          finess_label: primary?.hco_et_label || null,
+          city: primary?.city || null,
+          score: typeof m.score === 'number' ? m.score : null,
+          match_method: m.match_method ?? null,
+        });
+      }
+    }
+    return rows;
+  }
+
+  return {
+    normalize,
+    fetchPubmedAuthorMatches,
+    buildPubmedAuthorExportRows,
+    fetchTrialHcpMatches,
+    fetchTrialHcpMatchesBulk,
+    fetchNctHcpMatches,
+    fetchEuctHcpMatches,
+    fetchTrialsForHcps,
+    filterExistingHcps,
+  };
+}

package/layer/app/oip-science/composables/useCTCenter.ts

@@ -0,0 +1,107 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+import type { CTCenters } from '../utils/f-types';
+
+export default function useCTCenter() {
+  // Une instance par composant (dans FAS, useElastic etait appele au niveau du module)
+  const { queryCustomElastic, queryOneElastic } = useOipElastic();
+  const indexQuery = ref(indexConfig.globalCTCenters.index);
+  const cluster = ref(indexConfig.globalCTCenters.cluster);
+
+  const resultsCTCenters = ref(null as CTCenters | null);
+  const CTCentersResultsList = ref(null as CTCenters[] | null);
+  const isLoadingQueryCTCenters = ref(false);
+
+  const findCTCentersById = ({
+    id,
+    source,
+  }: {
+    id: string;
+    source?: string[];
+  }): Promise<CTCenters> => {
+    isLoadingQueryCTCenters.value = true;
+    return new Promise<CTCenters>(async (resolve, reject) => {
+      try {
+        const res = await queryOneElastic({
+          index: indexQuery.value,
+          path: '_id',
+          source: {
+            include: source || [],
+            exclude: [],
+          },
+          cluster: cluster.value,
+          id,
+        });
+        if (res) {
+          resultsCTCenters.value = res as CTCenters;
+          resolve(res as CTCenters);
+        } else {
+          // Document absent de l'index : la fiche montre son etat vide.
+          resolve(null as any);
+        }
+      } catch (error) {
+        reject(error);
+      } finally {
+        isLoadingQueryCTCenters.value = false;
+      }
+    });
+  };
+
+  const findManyCTCentersById = async ({
+    ids,
+    source,
+  }: {
+    ids: string[];
+    source?: string[];
+  }): Promise<CTCenters[]> => {
+    isLoadingQueryCTCenters.value = true;
+
+    try {
+      const query = {
+        from: 0,
+
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        _source: {
+          include: source || [],
+          exclude: [],
+        },
+      };
+
+      const res = await queryCustomElastic({
+        index: indexQuery.value,
+        customQuery: query,
+        cluster: cluster.value,
+      });
+      if (res && res.results) {
+        CTCentersResultsList.value = res.results as CTCenters[];
+        return res.results as CTCenters[];
+      } else {
+        throw new Error('Aucun résultat trouvé');
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      isLoadingQueryCTCenters.value = false;
+    }
+  };
+
+  return {
+    resultsCTCenters,
+    CTCentersResultsList,
+    isLoadingQueryCTCenters,
+    findCTCentersById,
+    findManyCTCentersById,
+  };
+}

package/layer/app/oip-science/composables/useCTInvestigators.ts

@@ -0,0 +1,107 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+import type { CTInvestigators } from '../utils/f-types';
+export default function useCTInvestigators() {
+  // Une instance par composant (dans FAS, useElastic etait appele au niveau du module)
+  const { queryCustomElastic, queryOneElastic } = useOipElastic();
+  const indexQuery = ref(indexConfig.globalCTInvestigators.index);
+  const cluster = ref(indexConfig.globalCTInvestigators.cluster);
+
+  const resultsCTInvestigators = ref(null as CTInvestigators | null);
+  const CTInvestigatorsResultsList = ref(null as CTInvestigators[] | null);
+  const isLoadingQueryCTInvestigators = ref(false);
+
+  const findCTInvestigatorsById = ({
+    id,
+    source,
+  }: {
+    id: string;
+    source?: string[];
+  }): Promise<CTInvestigators> => {
+    isLoadingQueryCTInvestigators.value = true;
+    return new Promise<CTInvestigators>(async (resolve, reject) => {
+      try {
+        const res = await queryOneElastic({
+          index: indexQuery.value,
+          path: '_id',
+          source: {
+            include: source || [],
+            exclude: ['pubmed_data.all_authors'],
+          },
+          cluster: cluster.value,
+          id,
+        });
+        if (res) {
+          resultsCTInvestigators.value = res as CTInvestigators;
+          resolve(res as CTInvestigators);
+        } else {
+          // Document absent de l'index : la fiche montre son etat vide.
+          resolve(null as any);
+        }
+      } catch (error) {
+        reject(error);
+      } finally {
+        isLoadingQueryCTInvestigators.value = false;
+      }
+    });
+  };
+
+  const findManyCTInvestigatorsById = async ({
+    ids,
+    source,
+  }: {
+    ids: string[];
+    source?: string[];
+  }): Promise<CTInvestigators[]> => {
+    isLoadingQueryCTInvestigators.value = true;
+
+    try {
+      const query = {
+        from: 0,
+
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        _source: {
+          include: source || [],
+          exclude: ['pubmed_data.all_authors'],
+        },
+      };
+
+      const res = await queryCustomElastic({
+        index: indexQuery.value,
+        customQuery: query,
+        cluster: cluster.value,
+      });
+
+      if (res && res.results) {
+        CTInvestigatorsResultsList.value = res.results as CTInvestigators[];
+        return res.results as CTInvestigators[];
+      } else {
+        throw new Error('Aucun résultat trouvé');
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      isLoadingQueryCTInvestigators.value = false;
+    }
+  };
+
+  return {
+    resultsCTInvestigators,
+    CTInvestigatorsResultsList,
+    isLoadingQueryCTInvestigators,
+    findCTInvestigatorsById,
+    findManyCTInvestigatorsById,
+  };
+}

package/layer/app/oip-science/composables/useEstablishmentCrossData.ts

@@ -0,0 +1,139 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+
+interface CrossDataResult {
+  clinical_trial_id: string;
+  establishment_id: string;
+  verified_id?: string;
+  ai_matched_id?: string;
+  nct_id_linked?: string;
+  name?: string;
+  status?: string;
+  score?: number;
+  match_method?: string;
+}
+
+interface EstablishmentCrossData {
+  crossResults: CrossDataResult[];
+  nctIds: string[];
+  euctIds: string[];
+  nctToEuct: Record<string, string>;
+  euctLinkedToNct: Set<string>;
+}
+
+export default function useEstablishmentCrossData() {
+  const crossData = useState<EstablishmentCrossData | null>('oip-science-establishment-cross-data', () => null);
+  const isLoading = useState<boolean>('oip-science-establishment-cross-data-loading', () => false);
+  const fetchedForId = useState<string | null>('oip-science-establishment-cross-data-id', () => null);
+
+  async function fetchCrossData(urlId: string) {
+    // Skip if already fetched for this establishment
+    if (fetchedForId.value === urlId && crossData.value) return crossData.value;
+
+    isLoading.value = true;
+    fetchedForId.value = urlId;
+
+    try {
+      const { queryCustomElastic, queryOneElastic } = useOipElastic();
+
+      // 1. Fetch establishment doc from the new HCO directory
+      const establishment: any = await queryOneElastic({
+        index: indexConfig.establishments.index,
+        cluster: indexConfig.establishments.cluster,
+        path: 'hco_et_code',
+        id: urlId,
+      });
+
+      if (!establishment) {
+        crossData.value = {
+          crossResults: [],
+          nctIds: [],
+          euctIds: [],
+          nctToEuct: {},
+          euctLinkedToNct: new Set(),
+        };
+        return crossData.value;
+      }
+
+      // 2. Extract NCT and EUCT IDs from embedded arrays
+      const nctIds: string[] = (establishment.nct_trial || [])
+        .map((t: any) => t?.clinical_trial_id)
+        .filter(Boolean);
+      const euctIds: string[] = (establishment.euct_trial || [])
+        .map((t: any) => t?.clinical_trial_id)
+        .filter(Boolean);
+
+      // 3. Build top-scored name lookups so consumers can read item.name / item.score
+      const bestByMethodName = (entries: any[] | null | undefined): { name?: string; score?: number; match_method?: string } => {
+        if (!Array.isArray(entries) || entries.length === 0) return {};
+        // Take highest-scored entry
+        const top = [...entries].sort((a: any, b: any) => (b?.score ?? 0) - (a?.score ?? 0))[0];
+        return { name: top?.name, score: top?.score, match_method: top?.match_method };
+      };
+
+      const nctMeta = bestByMethodName(establishment.nct_name);
+      const euctMeta = bestByMethodName(establishment.euct_name);
+
+      const crossResults: CrossDataResult[] = [
+        ...nctIds.map((id: string) => ({
+          clinical_trial_id: id,
+          establishment_id: `FR-${urlId}`,
+          name: nctMeta.name,
+          score: nctMeta.score,
+          match_method: nctMeta.match_method,
+        })),
+        ...euctIds.map((id: string) => ({
+          clinical_trial_id: id,
+          establishment_id: `FR-${urlId}`,
+          name: euctMeta.name,
+          score: euctMeta.score,
+          match_method: euctMeta.match_method,
+        })),
+      ];
+
+      // 4. Compute NCT <-> EUCT linkage by fetching EUCT details (only euct_number + nct_number)
+      const nctToEuct: Record<string, string> = {};
+      const euctLinkedToNct = new Set<string>();
+      const nctIdSet = new Set(nctIds);
+
+      if (euctIds.length > 0) {
+        const euctRes = await queryCustomElastic({
+          index: indexConfig.euct.index,
+          cluster: indexConfig.euct.cluster,
+          customQuery: {
+            size: euctIds.length,
+            _source: ['euct_number', 'nct_number'],
+            query: { terms: { 'euct_number.keyword': euctIds } },
+          },
+        });
+
+        for (const euct of euctRes?.results || []) {
+          if (euct?.nct_number && nctIdSet.has(euct.nct_number)) {
+            nctToEuct[euct.nct_number] = euct.euct_number;
+            euctLinkedToNct.add(euct.euct_number);
+          }
+        }
+      }
+
+      crossData.value = { crossResults, nctIds, euctIds, nctToEuct, euctLinkedToNct };
+      return crossData.value;
+    } catch (e) {
+      console.error('Error fetching cross-data:', e);
+      return null;
+    } finally {
+      isLoading.value = false;
+    }
+  }
+
+  function clear() {
+    crossData.value = null;
+    fetchedForId.value = null;
+  }
+
+  return {
+    crossData,
+    isLoading,
+    fetchCrossData,
+    clear,
+  };
+}