@tekkare/romulus 0.1.250 → 0.1.252

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

@@ -0,0 +1,624 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+import { ifNoRes } from '../utils/styleAndFormat';
+// Types de France Augmented Science (types/ClinicalTrials) : pas portes, le document reste libre.
+type ClinicalTrial = any;
+type ClinicalTrialCondition = any;
+type ClinicalTrialIntervention = any;
+type ClinicalTrialResultDesignGroupsIntervention = any;
+type ClinicalTrialDesignOutcome = any;
+type ClinicalTrialOverallOfficial = any;
+type ClinicalTrialFacilityInvestigator = any;
+type ClinicalTrialFacility = any;
+
+export default function useGlobalClinicalTrials() {
+  const { queryElastic, queryCustomElastic, queryOneElastic } = useOipElastic();
+
+  const indexQuery = ref(indexConfig.globalCT.index);
+  const cluster = ref(indexConfig.globalCT.cluster);
+  // GENE CONTENT
+  const isLoadingctList = ref(false as boolean);
+  const isLoadingQueryClinicalTrial = ref(false);
+
+  const resultsQueryClinicalTrial = ref(null as ClinicalTrial | null);
+  const ctListResult = ref(null as ClinicalTrial[] | null);
+
+  const findClinicalTrialById = ({
+    id,
+    source,
+  }: {
+    id: string;
+    source?: string[];
+  }): Promise<ClinicalTrial> => {
+    isLoadingQueryClinicalTrial.value = true;
+    return new Promise<ClinicalTrial>(async (resolve, reject) => {
+      try {
+        const res = await queryOneElastic({
+          index: indexQuery.value,
+          path: 'nct_id',
+          source: source,
+          cluster: cluster.value,
+          id,
+        });
+        if (res) {
+          resultsQueryClinicalTrial.value = res as ClinicalTrial;
+          resolve(res as ClinicalTrial);
+        } else {
+          // Document absent de l'index : la fiche montre son etat vide.
+          resolve(null as any);
+        }
+      } catch (error) {
+        reject(error);
+      } finally {
+        isLoadingQueryClinicalTrial.value = false;
+      }
+    });
+  };
+
+  const findManyClinicalTrialById = async ({
+    ids,
+    source,
+  }: {
+    ids: string[];
+    source?: string[];
+  }): Promise<ClinicalTrial[]> => {
+    isLoadingQueryClinicalTrial.value = true;
+
+    try {
+      const query = {
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        sort: [{ study_first_posted_date: { order: 'desc' } }],
+        _source: {
+          include: source || [],
+          exclude: [],
+        },
+      };
+
+      const res = await queryCustomElastic({
+        index: indexQuery.value,
+        customQuery: query,
+        cluster: cluster.value,
+      });
+
+      if (res && res.results) {
+        ctListResult.value = res.results as ClinicalTrial[];
+        return res.results as ClinicalTrial[];
+      } else {
+        throw new Error('Aucun résultat trouvé');
+      }
+    } catch (error) {
+      throw error;
+    } finally {
+      isLoadingQueryClinicalTrial.value = false;
+    }
+  };
+
+  async function ctContentFromIds({
+    ids,
+    customQuery,
+  }: {
+    ids?: any;
+    customQuery?: any;
+  }): Promise<any> {
+    isLoadingctList.value = true;
+    return new Promise((resolve, reject) => {
+      let query = {
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                terms: {
+                  _id: ids,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+        sort: [{ study_first_posted_date: { order: 'desc' } }],
+      };
+
+      queryCustomElastic({
+        index: indexQuery.value,
+        customQuery: customQuery ? customQuery : query,
+        cluster: cluster.value,
+      })
+        .then((res) => {
+          if (res) {
+            ctListResult.value = res?.results;
+            resolve(res);
+          } else {
+            reject('Aucun résultat trouvé');
+          }
+        })
+        .catch((error) => {
+          reject(error);
+        })
+        .finally(() => {
+          isLoadingctList.value = false;
+        });
+    });
+  }
+
+  // SPECIAL QUERY
+  // ::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  const CTDiseaseQuery = (name: string, synonymes?: string[]) => {
+    // IF ICD10
+
+    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: ['official_title'],
+              default_operator: 'AND',
+              analyze_wildcard: true,
+              allow_leading_wildcard: false,
+              phrase_slop: 0,
+              auto_generate_synonyms_phrase_query: true,
+              fuzziness: 'AUTO',
+            },
+          },
+          {
+            nested: {
+              path: 'brief_summary',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['brief_summary.brief_summary'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'brief_summary',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['brief_summary.brief_summary'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'keywords',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['keywords.keyword_name'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'rare_diseases',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['rare_diseases.concat_disease_name_orpha_code'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'rare_diseases',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['rare_diseases.disease_synonyms'],
+                  default_operator: 'AND',
+                  analyze_wildcard: true,
+                  allow_leading_wildcard: false,
+                  phrase_slop: 0,
+                  auto_generate_synonyms_phrase_query: true,
+                  fuzziness: 'AUTO',
+                },
+              },
+            },
+          },
+          {
+            nested: {
+              path: 'conditions',
+              query: {
+                query_string: {
+                  query: `(\"${name}\")`,
+                  fields: ['conditions.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;
+    }
+    // IF RARE DISEASES
+    else {
+      return {
+        bool: {
+          should: [
+            {
+              nested: {
+                path: 'rare_diseases',
+                query: {
+                  query_string: {
+                    query: `(\"${name}\")`,
+                    fields: ['rare_diseases.concat_disease_name_orpha_code'],
+                    default_operator: 'AND',
+                    analyze_wildcard: true,
+                    allow_leading_wildcard: false,
+                    phrase_slop: 0,
+                    auto_generate_synonyms_phrase_query: true,
+                    fuzziness: 'AUTO',
+                  },
+                },
+              },
+            },
+            {
+              nested: {
+                path: 'rare_diseases',
+                query: {
+                  query_string: {
+                    query: `(\"${name}\")`,
+                    fields: ['rare_diseases.disease_synonyms'],
+                    default_operator: 'AND',
+                    analyze_wildcard: true,
+                    allow_leading_wildcard: false,
+                    phrase_slop: 0,
+                    auto_generate_synonyms_phrase_query: true,
+                    fuzziness: 'AUTO',
+                  },
+                },
+              },
+            },
+            {
+              nested: {
+                path: 'conditions',
+                query: {
+                  query_string: {
+                    query: `(\"${name}\")`,
+                    fields: ['conditions.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 CTMoleculeQuery = (label: string) => ({
+    bool: {
+      should: [
+        // {
+        //   match: {
+        //     'atc5.molecule.keyword': label,
+        //   },
+        // },
+        {
+          query_string: {
+            query: `(\"${label}\")`,
+            fields: ['atc5.molecule.keyword', 'official_title'],
+            default_operator: 'AND',
+            analyze_wildcard: true,
+            allow_leading_wildcard: false,
+            phrase_slop: 0,
+            auto_generate_synonyms_phrase_query: true,
+            fuzziness: 'AUTO',
+          },
+        },
+      ],
+    },
+  });
+
+  const CTIdsQuery = (ids: string) => ({
+    bool: {
+      must: [
+        {
+          terms: {
+            _id: ids,
+          },
+        },
+      ],
+    },
+  });
+
+  // FOR EXPORTS AND TABLES
+  // ::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  const formatCTGlobalData = (results: ClinicalTrial[]) => {
+    return results.map((item: ClinicalTrial) => ({
+      ...item,
+
+      brief_summary: item.brief_summary?.[0]?.brief_summary || null,
+
+      conditions: item.conditions?.length
+        ? item.conditions
+            .map(
+              (x: ClinicalTrialCondition) =>
+                `${x.condition_name_en || x.condition_name_fr}${
+                  x.condition_description ? `\n${x.condition_description}` : ''
+                }`
+            )
+            .join(',\n\n')
+        : null,
+
+      intervention: item.intervention?.length
+        ? item.intervention
+            .map(
+              (x: ClinicalTrialIntervention) =>
+                `${x.intervention_type}: ${x.intervention_name}\n${x.intervention_description}`
+            )
+            .join(',\n\n')
+        : null,
+
+      with_result: item.with_result ? 'Yes' : 'No',
+
+      allocation: Array.isArray(item?.designs)
+        ? item.designs[0]?.allocation
+        : null,
+
+      intervention_model: Array.isArray(item?.designs)
+        ? item?.designs[0]?.intervention_model
+        : null,
+
+      masking: Array.isArray(item?.designs)
+        ? item.designs[0]?.subject_masked
+          ? 'Yes'
+          : 'No'
+        : null,
+
+      masking_description: Array.isArray(item?.designs)
+        ? item.designs[0]?.masking
+        : null,
+
+      primary_purpose: Array.isArray(item?.designs)
+        ? item?.designs[0]?.primary_purpose
+        : null,
+
+      arms: item?.resultDesignGroupsInterventions?.length
+        ? item.resultDesignGroupsInterventions
+            .map(
+              (x: ClinicalTrialResultDesignGroupsIntervention) =>
+                `${x.title} : ${x.intervention_type}\n${x.intervention_description}`
+            )
+            .join(',\n\n')
+        : null,
+
+      primary_outcomes_measures: item.design_outcomes?.filter(
+        (d: ClinicalTrialDesignOutcome) => d.outcome_type === 'primary'
+      )?.length
+        ? item.design_outcomes
+            .filter(
+              (d: ClinicalTrialDesignOutcome) => d.outcome_type === 'primary'
+            )
+            .map(
+              (x: ClinicalTrialDesignOutcome) =>
+                `${x.measure}\nDescription: ${ifNoRes(
+                  x.outcome_description
+                )}\nTime frame: ${ifNoRes(x.time_frame)}\nPopulation: ${ifNoRes(
+                  x.population
+                )}`
+            )
+            .join(',\n\n')
+        : null,
+
+      secondary_outcomes_measures: item.design_outcomes?.filter(
+        (d: ClinicalTrialDesignOutcome) => d.outcome_type === 'secondary'
+      )?.length
+        ? item.design_outcomes
+            .filter(
+              (d: ClinicalTrialDesignOutcome) => d.outcome_type === 'secondary'
+            )
+            .map(
+              (x: ClinicalTrialDesignOutcome) =>
+                `${x.measure}\nDescription: ${ifNoRes(
+                  x.outcome_description
+                )}\nTime frame: ${ifNoRes(x.time_frame)}\nPopulation: ${ifNoRes(
+                  x.population
+                )}`
+            )
+            .join(',\n\n')
+        : null,
+
+      other_outcomes_measures: item.design_outcomes?.filter(
+        (d: ClinicalTrialDesignOutcome) => d.outcome_type === 'other'
+      )?.length
+        ? item.design_outcomes
+            .filter(
+              (d: ClinicalTrialDesignOutcome) => d.outcome_type === 'other'
+            )
+            .map(
+              (x: ClinicalTrialDesignOutcome) =>
+                `${x.measure}\nDescription: ${ifNoRes(
+                  x.outcome_description
+                )}\nTime frame: ${ifNoRes(x.time_frame)}\nPopulation: ${ifNoRes(
+                  x.population
+                )}`
+            )
+            .join(',\n\n')
+        : null,
+
+      minimum_age: item.eligibilities?.length
+        ? `${item.eligibilities[0]?.minimum_age} to ${item.eligibilities[0]?.maximum_age}`
+        : null,
+
+      gender: item.eligibilities?.[0]?.gender || null,
+
+      gender_based:
+        item.eligibilities?.[0]?.gender_based !== undefined
+          ? item.eligibilities[0].gender_based
+            ? 'Yes'
+            : 'No'
+          : null,
+
+      healthy_volunteers: item.eligibilities?.[0]?.healthy_volunteers
+        ? 'Yes'
+        : 'No',
+
+      criteria: item.eligibilities?.[0]?.criteria || null,
+
+      scientific_leadership: item.overall_officials?.length
+        ? item.overall_officials
+            .map(
+              (x: ClinicalTrialOverallOfficial) =>
+                `Role: ${x.role}\nName: ${x.name}\nAffiliation: ${x.affiliation}`
+            )
+            .join(',\n\n')
+        : null,
+
+      investigators: item.facilitiesInvestigators?.length
+        ? item.facilitiesInvestigators
+            .map((x: ClinicalTrialFacilityInvestigator) => {
+              const facility = item.facilities?.find(
+                (y: ClinicalTrialFacility) => y.facility_id === x.facility_id
+              );
+              return `Role: ${x.facility_investigator_role}\nName: ${x.name}${
+                facility
+                  ? `\nLocation: ${facility.name} \nCity: ${facility.city} \nCountry: ${facility.country}`
+                  : ''
+              }`;
+            })
+            .join(',\n\n')
+        : null,
+
+      is_fda_regulated_drug: item.is_fda_regulated_drug ? 'Yes' : 'No',
+      is_fda_regulated_device: item.is_fda_regulated_device ? 'Yes' : 'No',
+
+      genomics: item.genomics?.length
+        ? item.genomics.map((x: any) => `${x.symbol}`).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 as any).diseases?.length
+        ? (item as any).diseases
+            .flatMap((x: any) => x.icd10?.map((icd: any) => icd.combined_label) ?? [])
+            .filter((v: any, i: number, a: any[]) => a.indexOf(v) === i)
+            .join(',\n')
+        : null,
+
+      oncology_terms: (item as any).diseases?.length
+        ? (item as any).diseases
+            .flatMap((x: any) => x.section?.map((s: any) => s.label) ?? [])
+            .filter((v: any, i: number, a: any[]) => v && a.indexOf(v) === i)
+            .join(',\n')
+        : null,
+
+      info_keywords: item.keywords?.length
+        ? item.keywords.map((x: any) => `${x.keyword}`).join(',\n\n')
+        : null,
+
+      info_link: item.nct_id
+        ? `https://clinicaltrials.gov/ct2/show/${item.nct_id}`
+        : null,
+
+      countries: item.countries?.length
+        ? item.countries.map((x: any) => x.country_name).join(',\n')
+        : null,
+
+      sponsors: item.sponsors?.length
+        ? item.sponsors
+            .map((x: any) => `${x.sponsor_name} (${x.sponsor_type})`)
+            .join(',\n\n')
+        : null,
+
+      contacts: item.facilitiesContacts?.length
+        ? item.facilitiesContacts
+            .map((x: any) => {
+              const facility = item.facilities?.find(
+                (y: ClinicalTrialFacility) => y.facility_id === x.facility_id
+              );
+              return `Name: ${x.name}\nPhone: ${x.phone}\nEmail: ${x.email}${
+                facility
+                  ? `\nLocation: ${facility.name} \nCity: ${facility.city} \nCountry: ${facility.country}`
+                  : ''
+              }`;
+            })
+            .join(',\n\n')
+        : null,
+    }));
+  };
+
+  return {
+    ctContentFromIds,
+    ctListResult,
+    isLoadingctList,
+    CTIdsQuery,
+    CTDiseaseQuery,
+    CTMoleculeQuery,
+    findClinicalTrialById,
+    resultsQueryClinicalTrial,
+    isLoadingQueryClinicalTrial,
+    findManyClinicalTrialById,
+    formatCTGlobalData,
+  };
+}

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

@@ -0,0 +1,83 @@
+import indexConfig from '../indexConfig.json';
+import useOipElastic from './useOipElastic';
+
+/**
+ * Essais enregistres dans les deux registres : l'essai EUCT porte le numero
+ * NCT (`nct_number`), c'est le seul lien. Une liste charge l'essai jumeau de
+ * ses resultats en une requete, limitee aux nouveaux numeros et aux champs
+ * que la carte double affiche ; « Charger plus » ne redemande que la suite.
+ */
+const EUCT_FIELDS = [
+  'euct_number',
+  'nct_number',
+  'public_title',
+  'global_status',
+  'trial_phase',
+  'medical_condition.condition_name_en',
+  'products.productDictionaryInfo.prodName',
+  'products.productDictionaryInfo.activeSubstanceName',
+  'co_sponsors.organisation.name',
+  'enrollment_status.total_planned_enrollment',
+];
+
+const NCT_FIELDS = [
+  'nct_id',
+  'official_title',
+  'overall_status',
+  'phase',
+  'conditions.condition_name_en',
+  'intervention.intervention_name',
+  'sponsors.sponsor_name',
+  'enrollment',
+];
+
+export function useLinkedTrials(kind: 'euct' | 'nct') {
+  const { queryCustomElastic } = useOipElastic();
+  /** Numero de l'essai de la liste -> essai jumeau (null : pas de jumeau). */
+  const linked = ref<Record<string, any | null>>({});
+
+  async function load(ids: (string | null | undefined)[]) {
+    const wanted = [...new Set(ids.filter((x): x is string => !!x))].filter(
+      (id) => !(id in linked.value),
+    );
+    if (!wanted.length) return;
+    const next: Record<string, any | null> = Object.fromEntries(wanted.map((id) => [id, null]));
+    try {
+      if (kind === 'euct') {
+        // Liste NCT : les essais EUCT qui citent ces numeros NCT.
+        const res = await queryCustomElastic({
+          index: indexConfig.euct.index,
+          cluster: indexConfig.euct.cluster,
+          customQuery: {
+            size: wanted.length,
+            _source: EUCT_FIELDS,
+            query: { terms: { 'nct_number.keyword': wanted } },
+          },
+        });
+        for (const doc of res?.results || []) {
+          if (doc?.nct_number && doc.nct_number in next) next[doc.nct_number] = doc;
+        }
+      } else {
+        // Liste EUCT : `wanted` porte les numeros NCT cites, cle = NCT.
+        const res = await queryCustomElastic({
+          index: indexConfig.globalCT.index,
+          cluster: indexConfig.globalCT.cluster,
+          customQuery: {
+            size: wanted.length,
+            _source: NCT_FIELDS,
+            query: { ids: { values: wanted } },
+          },
+        });
+        for (const doc of res?.results || []) {
+          if (doc?.nct_id && doc.nct_id in next) next[doc.nct_id] = doc;
+        }
+      }
+    } catch (e) {
+      console.error('Error fetching linked trials:', e);
+      return;
+    }
+    linked.value = { ...linked.value, ...next };
+  }
+
+  return { linked, load };
+}