@tekkare/romulus 0.1.251 → 0.1.252

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

@@ -0,0 +1,176 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+
+export default function useEstablishmentMatching() {
+  const { queryCustomElastic } = useOipElastic();
+
+  type TrialHcoMatch = {
+    hco_et_code: string;
+    hco_ej_code: string | null;
+    hco_et_label: string | null;
+    hco_ej_label: string | null;
+    hco_et_city: string | null;
+    hco_et_dpt_label: string | null;
+    hco_et_region_label: string | null;
+    hco_et_level_label_3: string | null;
+    hco_et_level_label_4: string | null;
+    hco_et_sector: string | null;
+    name: string | null;
+    match_method: string | null;
+    score: number | null;
+  };
+
+  async function fetchTrialHcoMatches(
+    trialId: string,
+    source: 'nct' | 'euct',
+  ): Promise<TrialHcoMatch[]> {
+    const cfg = source === 'nct' ? indexConfig.hcoNct : indexConfig.hcoEuct;
+    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: TrialHcoMatch[] = [];
+    for (const h of doc?.hco || []) {
+      if (!h?.hco_et_code) continue;
+      matches.push({
+        hco_et_code: h.hco_et_code,
+        hco_ej_code: h.hco_ej_code || null,
+        hco_et_label: h.hco_et_label || null,
+        hco_ej_label: h.hco_ej_label || null,
+        hco_et_city: h.hco_et_city || null,
+        hco_et_dpt_label: h.hco_et_dpt_label || null,
+        hco_et_region_label: h.hco_et_region_label || null,
+        hco_et_level_label_3: h.hco_et_level_label_3 || null,
+        hco_et_level_label_4: h.hco_et_level_label_4 || null,
+        hco_et_sector: h.hco_et_sector || null,
+        name: h.name || null,
+        match_method: h.match_method || null,
+        score: typeof h.score === 'number' ? h.score : null,
+      });
+    }
+    return matches;
+  }
+
+  const fetchNctHcoMatches = (nctId: string) => fetchTrialHcoMatches(nctId, 'nct');
+  const fetchEuctHcoMatches = (euctId: string) => fetchTrialHcoMatches(euctId, 'euct');
+
+  // Bulk variant: one ES request fetches all HCO matches for many trial IDs
+  // at once. Used by the Generate-a-Report bulk export to enrich the
+  // Locations / Enrollment-sites tabs with FINESS without N round-trips.
+  async function fetchTrialHcoMatchesBulk(
+    trialIds: string[],
+    source: 'nct' | 'euct',
+  ): Promise<Map<string, TrialHcoMatch[]>> {
+    const out = new Map<string, TrialHcoMatch[]>();
+    if (!trialIds.length) return out;
+    const cfg = source === 'nct' ? indexConfig.hcoNct : indexConfig.hcoEuct;
+    const res = await queryCustomElastic({
+      index: cfg.index,
+      cluster: cfg.cluster,
+      customQuery: {
+        size: trialIds.length,
+        query: { terms: { clinical_trial_id: trialIds } },
+      },
+    });
+    for (const doc of res?.results || []) {
+      const id = doc?.clinical_trial_id;
+      if (!id) continue;
+      const matches: TrialHcoMatch[] = [];
+      for (const h of doc?.hco || []) {
+        if (!h?.hco_et_code) continue;
+        matches.push({
+          hco_et_code: h.hco_et_code,
+          hco_ej_code: h.hco_ej_code || null,
+          hco_et_label: h.hco_et_label || null,
+          hco_ej_label: h.hco_ej_label || null,
+          hco_et_city: h.hco_et_city || null,
+          hco_et_dpt_label: h.hco_et_dpt_label || null,
+          hco_et_region_label: h.hco_et_region_label || null,
+          hco_et_level_label_3: h.hco_et_level_label_3 || null,
+          hco_et_level_label_4: h.hco_et_level_label_4 || null,
+          hco_et_sector: h.hco_et_sector || null,
+          name: h.name || null,
+          match_method: h.match_method || null,
+          score: typeof h.score === 'number' ? h.score : null,
+        });
+      }
+      out.set(String(id), matches);
+    }
+    return out;
+  }
+
+  type HcoTrialRow = {
+    clinical_trial_id: string;
+    hco_et_code: string;
+    score: number | null;
+    match_method: string | null;
+  };
+
+  async function fetchTrialsForHcos(
+    finessCodes: string[],
+    source: 'nct' | 'euct',
+  ): Promise<HcoTrialRow[]> {
+    if (!finessCodes.length) return [];
+    const cfg = source === 'nct' ? indexConfig.hcoNct : indexConfig.hcoEuct;
+    const codeSet = new Set(finessCodes);
+    const res = await queryCustomElastic({
+      index: cfg.index,
+      cluster: cfg.cluster,
+      customQuery: {
+        size: 10000,
+        _source: ['clinical_trial_id', 'hco'],
+        query: { terms: { 'hco.hco_et_code.keyword': finessCodes } },
+      },
+    });
+    const rows: HcoTrialRow[] = [];
+    for (const doc of res?.results || []) {
+      if (!doc?.clinical_trial_id) continue;
+      for (const h of doc.hco || []) {
+        if (!h?.hco_et_code || !codeSet.has(h.hco_et_code)) continue;
+        rows.push({
+          clinical_trial_id: doc.clinical_trial_id,
+          hco_et_code: h.hco_et_code,
+          score: typeof h.score === 'number' ? h.score : null,
+          match_method: h.match_method || null,
+        });
+      }
+    }
+    return rows;
+  }
+
+  async function filterExistingEstablishments(
+    finessCodes: (string | null)[],
+  ): Promise<Set<string>> {
+    const codes = [...new Set(finessCodes.filter((x): x is string => !!x))];
+    if (codes.length === 0) return new Set();
+    const res = await queryCustomElastic({
+      index: indexConfig.establishments.index,
+      cluster: indexConfig.establishments.cluster,
+      customQuery: {
+        size: codes.length,
+        _source: ['hco_et_code'],
+        query: { terms: { hco_et_code: codes } },
+      },
+    });
+    const set = new Set<string>();
+    for (const r of res?.results || []) {
+      if (typeof r?.hco_et_code === 'string') set.add(r.hco_et_code);
+    }
+    return set;
+  }
+
+  return {
+    fetchTrialHcoMatches,
+    fetchTrialHcoMatchesBulk,
+    fetchNctHcoMatches,
+    fetchEuctHcoMatches,
+    fetchTrialsForHcos,
+    filterExistingEstablishments,
+  };
+}

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

@@ -0,0 +1,418 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+import { getSexe } from '../utils/styleAndFormat';
+
+// Types de France Augmented Science (types/Euct) : pas portes, le document reste libre.
+type Euct = any;
+type EuctCountries = any;
+type EuctCoSponsor = any;
+type EuctSecondaryObjective = any;
+type EuctPrincipalInclusionCriteria = any;
+type EuctPrincipalExclusionCriteria = any;
+type EuctPrimaryEndPoint = any;
+type EuctSecondaryEndPoint = any;
+type EuctHcp = any;
+type EuctSites = any;
+
+export default function useEuct() {
+  const { queryElastic, queryCustomElastic, queryOneElastic } = useOipElastic();
+
+  // GENE CONTENT
+  const isLoadingeuctList = ref(false as boolean);
+
+  const indexQuery = ref(indexConfig.euct.index);
+  const cluster = ref(indexConfig.euct.cluster);
+  const resultsQueryEuct = ref(null as Euct | null);
+  const euctListResult = ref(null as Euct[] | null);
+
+  const isLoadingQueryEuct = ref(false);
+
+  const findEuctById = ({
+    id,
+    source,
+  }: {
+    id: string;
+    source?: string[];
+  }): Promise<Euct> => {
+    isLoadingQueryEuct.value = true;
+    return new Promise<Euct>(async (resolve, reject) => {
+      try {
+        const res = await queryOneElastic({
+          index: indexQuery.value,
+          path: 'euct_number',
+          source: source,
+          cluster: cluster.value,
+          id,
+        });
+        // `queryOneElastic` returns `undefined` when the trial isn't in the
+        // index. Resolving anyway matters: guarding the resolve on a truthy
+        // result left the promise pending forever and the detail page stuck
+        // on its loader.
+        resultsQueryEuct.value = (res as Euct) ?? null;
+        resolve(res as Euct);
+      } catch (error) {
+        reject(error);
+      } finally {
+        isLoadingQueryEuct.value = false;
+      }
+    });
+  };
+
+  const findManyEuctById = async ({
+    ids,
+    source,
+  }: {
+    ids: string[];
+    source?: string[];
+  }): Promise<Euct[]> => {
+    isLoadingQueryEuct.value = true;
+
+    try {
+      const query = {
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        sort: [{ first_submitted_date: { order: 'desc' } }],
+        _source: {
+          include: source || [],
+          exclude: [],
+        },
+      };
+
+      const res = await queryCustomElastic({
+        index: indexConfig.euct.index,
+        customQuery: query,
+        cluster: cluster.value,
+      });
+
+      if (res && res.results) {
+        euctListResult.value = res.results as Euct[];
+        return res.results as Euct[];
+      } else {
+        throw new Error('Aucun résultat trouvé');
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      isLoadingQueryEuct.value = false;
+    }
+  };
+
+  async function euctContentFromIds({
+    ids,
+    customQuery,
+  }: {
+    ids?: any;
+    customQuery?: any;
+  }): Promise<any> {
+    isLoadingeuctList.value = true;
+    return new Promise((resolve, reject) => {
+      let query = {
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        sort: [{ first_submitted_date: { order: 'desc' } }],
+      };
+
+      queryCustomElastic({
+        index: 'ope_block374_clinical_trials_euct',
+        customQuery: customQuery ? customQuery : query,
+      })
+        .then((res) => {
+          if (res) {
+            euctListResult.value = res?.results;
+            resolve(res);
+          } else {
+            reject('Aucun résultat trouvé');
+          }
+        })
+        .catch((error) => {
+          reject(error);
+        })
+        .finally(() => {
+          isLoadingeuctList.value = false;
+        });
+    });
+  }
+
+  // SPECIAL QUERY
+  // ::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  const euctDiseaseQuery = (name: string, synonymes?: string[]) => {
+    if (synonymes && synonymes.length) {
+      const mergeResult = synonymes.concat(name);
+      const query = {
+        bool: {
+          should: [] as any[],
+        },
+      };
+
+      mergeResult.forEach((name) => {
+        query.bool.should.push({
+          query_string: {
+            query: `(\"${name}\")`,
+            fields: [
+              'public_title',
+              'full_title',
+              'main_objective_en',
+              'rare_diseases.concat_disease_name_orpha_code',
+              'rare_diseases.disease_synonyms',
+              'medical_condition.condition_name_en',
+            ],
+            default_operator: 'AND',
+            analyze_wildcard: true,
+            allow_leading_wildcard: false,
+            phrase_slop: 0,
+            auto_generate_synonyms_phrase_query: true,
+            fuzziness: 'AUTO',
+          },
+        });
+      });
+      return query;
+    }
+
+    return {
+      bool: {
+        must: [
+          {
+            query_string: {
+              query: `(\"${name}\")`,
+              fields: [
+                'rare_diseases.concat_disease_name_orpha_code',
+                'rare_diseases.disease_synonyms',
+                'medical_condition.condition_name_en',
+              ],
+              default_operator: 'AND',
+              analyze_wildcard: true,
+              allow_leading_wildcard: false,
+              phrase_slop: 0,
+              auto_generate_synonyms_phrase_query: true,
+              fuzziness: 'AUTO',
+            },
+          },
+        ],
+      },
+    };
+  };
+
+  const euctMoleculeQuery = (label: string) => ({
+    bool: {
+      must: [
+        {
+          query_string: {
+            query: `(\"${label}\")`,
+            fields: [
+              'products.productDictionaryInfo.prodName',
+              'products.productDictionaryInfo.atcName',
+              'products.productDictionaryInfo.atcCode',
+              'products.productDictionaryInfo.activeSubstanceName',
+            ],
+            default_operator: 'AND',
+            analyze_wildcard: true,
+            allow_leading_wildcard: false,
+            phrase_slop: 0,
+            auto_generate_synonyms_phrase_query: true,
+            fuzziness: 'AUTO',
+          },
+        },
+      ],
+    },
+  });
+
+  const euctIdsQuery = (ids: string) => ({
+    bool: {
+      must: [
+        {
+          terms: {
+            _id: ids,
+          },
+        },
+      ],
+    },
+  });
+
+  // FOR EXPORTS AND TABLES
+  // ::::::::::::::::::::::::::::::::::::::::::::::::::
+  const formatEUCTData = (results: Euct[]) => {
+    return results.map((item: Euct) => ({
+      ...item,
+
+      therapeutic_area: item.therapeutic_area?.length
+        ? item.therapeutic_area.join(',\n')
+        : null,
+
+      medical_condition: item?.medical_condition?.length
+        ? item.medical_condition
+            .map((x: any) => x.condition_name_en)
+            .join(',\n')
+        : null,
+
+      products: item.products?.length
+        ? item.products
+            .map((x: any) =>
+              x.productDictionaryInfo.prodName
+                ? x.productDictionaryInfo.prodName
+                : x.productDictionaryInfo.activeSubstanceName
+            )
+            .join(',\n')
+        : null,
+
+      countries: item.countries?.length
+        ? item.countries.map((x: EuctCountries) => x.country_name).join(',\n')
+        : null,
+
+      co_sponsors: item.co_sponsors?.length
+        ? item.co_sponsors
+            .map((x: EuctCoSponsor) => x?.organisation?.name)
+            .join(',\n')
+        : null,
+
+      enrollment_status: `${
+        item.enrollment_status?.total_planned_enrollment || 0
+      } subjects in ${item.sites?.length || 0} site(s)`,
+
+      trial_scope: item?.trial_scope?.length
+        ? item.trial_scope.join(',\n')
+        : null,
+
+      secondary_objective: item.secondary_objective?.length
+        ? item.secondary_objective
+            .sort((a: any, b: any) => a.objective_number - b.objective_number)
+            .map(
+              (x: EuctSecondaryObjective) =>
+                `${x.objective_number}. ${x.second_objective_en}`
+            )
+            .join(',\n\n')
+        : null,
+
+      principal_inclusion_criteria: item?.principal_inclusion_criteria?.length
+        ? item.principal_inclusion_criteria
+            .sort((a: any, b: any) => a.criteria_number - b.criteria_number)
+            .map(
+              (x: EuctPrincipalInclusionCriteria) =>
+                `${x.criteria_number}. ${x.inclusion_criteria_en}`
+            )
+            .join(',\n\n')
+        : null,
+
+      principal_exclusion_criteria: item?.principal_exclusion_criteria?.length
+        ? item.principal_exclusion_criteria
+            .sort((a: any, b: any) => a.criteria_number - b.criteria_number)
+            .map(
+              (x: EuctPrincipalExclusionCriteria) =>
+                `${x.criteria_number}. ${x.exclusion_criteria_en}`
+            )
+            .join(',\n\n')
+        : null,
+
+      primary_end_point: item?.primary_end_point?.length
+        ? item.primary_end_point
+            .sort((a: any, b: any) => a.end_point_number - b.end_point_number)
+            .map(
+              (x: EuctPrimaryEndPoint) =>
+                `${x.end_point_number}. ${x.primary_end_point_en}`
+            )
+            .join(',\n\n')
+        : null,
+
+      secondary_end_point: item?.secondary_end_point?.length
+        ? item.secondary_end_point
+            .sort((a: any, b: any) => a.end_point_number - b.end_point_number)
+            .map(
+              (x: EuctSecondaryEndPoint) =>
+                `${x.end_point_number}. ${x.secondary_end_point_en}`
+            )
+            .join(',\n\n')
+        : null,
+
+      hcps: item.hcps?.length
+        ? item.hcps
+            .map(
+              (x: EuctHcp) =>
+                `Name: ${x.title} ${x.first_name} ${x.last_name} - Role: ${x.department_name} - Country: ${x.country} - RPPS: ${x.hcp_id}`
+            )
+            .join(',\n\n')
+        : null,
+
+      sites: item.sites?.length
+        ? item.sites
+            .map(
+              (x: EuctSites) =>
+                `Name:  ${x.organisation_name} - Country: ${x.country} - City: ${x.city}`
+            )
+            .join(',\n\n')
+        : null,
+
+      rare_diseases: item?.rare_diseases?.length
+        ? item.rare_diseases
+            .map((x: any) => `${x.concat_disease_name_orpha_code}`)
+            .join(',\n\n')
+        : null,
+
+      oncology_icd10: item.diseases?.length
+        ? item.diseases
+            .flatMap((x) => x.icd10?.map((icd) => icd.combined_label) ?? [])
+            .filter((v, i, a) => a.indexOf(v) === i)
+            .join(',\n')
+        : null,
+
+      oncology_terms: item.diseases?.length
+        ? item.diseases
+            .flatMap((x) => x.section?.map((s) => s.label) ?? [])
+            .filter((v, i, a) => v && a.indexOf(v) === i)
+            .join(',\n')
+        : null,
+
+      subject_population: item.subject_population?.age_range,
+
+      subject_gender: getSexe(
+        item?.subject_population?.has_female,
+        item?.subject_population?.has_male
+      ),
+
+      pubmed_citations_id: item.pubmed_citations_id?.length || 0,
+
+      euct_link: `https://euclinicaltrials.eu/search-for-clinical-trials/?lang=en&EUCT=${item.euct_number}?lang=en`,
+
+      nct_link: item.nct_number
+        ? `https://clinicaltrials.gov/ct2/show/${item.nct_number}`
+        : null,
+    }));
+  };
+
+  return {
+    euctContentFromIds,
+    euctListResult,
+    isLoadingeuctList,
+    euctIdsQuery,
+    euctDiseaseQuery,
+    euctMoleculeQuery,
+    findEuctById,
+    resultsQueryEuct,
+    isLoadingQueryEuct,
+    findManyEuctById,
+    formatEUCTData,
+  };
+}

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

@@ -0,0 +1,107 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+import type { EuctCenters } from '../utils/f-types';
+
+export default function useEuctCenter() {
+  // Une instance par composant (dans FAS, useElastic etait appele au niveau du module)
+  const { queryCustomElastic, queryOneElastic } = useOipElastic();
+  const indexQuery = ref(indexConfig.euctCenters.index);
+  const cluster = ref(indexConfig.euctCenters.cluster);
+
+  const resultsEuctCenters = ref(null as EuctCenters | null);
+  const euctCentersResultsList = ref(null as EuctCenters[] | null);
+  const isLoadingQueryEuctCenters = ref(false);
+
+  const findEuctCentersById = ({
+    id,
+    source,
+  }: {
+    id: string;
+    source?: string[];
+  }): Promise<EuctCenters> => {
+    isLoadingQueryEuctCenters.value = true;
+    return new Promise<EuctCenters>(async (resolve, reject) => {
+      try {
+        const res = await queryOneElastic({
+          index: indexQuery.value,
+          path: '_id',
+          source: {
+            include: source || [],
+            exclude: [],
+          },
+          cluster: cluster.value,
+          id,
+        });
+        if (res) {
+          resultsEuctCenters.value = res as EuctCenters;
+          resolve(res as EuctCenters);
+        } else {
+          // Document absent de l'index : la fiche montre son etat vide.
+          resolve(null as any);
+        }
+      } catch (error) {
+        reject(error);
+      } finally {
+        isLoadingQueryEuctCenters.value = false;
+      }
+    });
+  };
+
+  const findManyEuctCentersById = async ({
+    ids,
+    source,
+  }: {
+    ids: string[];
+    source?: string[];
+  }): Promise<EuctCenters[]> => {
+    isLoadingQueryEuctCenters.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) {
+        euctCentersResultsList.value = res.results as EuctCenters[];
+        return res.results as EuctCenters[];
+      } else {
+        throw new Error('Aucun résultat trouvé');
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      isLoadingQueryEuctCenters.value = false;
+    }
+  };
+
+  return {
+    euctCentersResultsList,
+    resultsEuctCenters,
+    isLoadingQueryEuctCenters,
+    findEuctCentersById,
+    findManyEuctCentersById,
+  };
+}