@tekkare/romulus 0.1.251 → 0.1.252

package/layer/app/components/oip-science/cross/publicationPubmed.vue

@@ -0,0 +1,484 @@
+<!--
+  Liste filtree des publications PubMed d'une fiche (onglets « Publications »
+  des essais, investigateurs, centres, professionnels, etablissements),
+  anciennement CrossPublicationPubmed de France Augmented Science.
+
+  Les filtres (periode, type d'article, onglets GeneRIF) vivaient dans les
+  stores de FAS ranges par route ; ici chaque liste a son propre contexte
+  (c-filterContext), donne a ses filtres : deux listes a l'ecran ne partagent
+  rien.
+-->
+<template>
+  <div class="oip-science">
+    <div class="oip_grid gap-16">
+      <div v-if="geneSymbol">
+        <div class="grid gap-16">
+          <div class="kk_two_grid" v-if="geneSymbol">
+            <OipScienceCommonForm
+              :title="$t('oipScience.cards.firstReference')"
+              :content="ifNoRes(geneFirstRef, 'date')"
+            />
+            <OipScienceCommonForm
+              :title="$t('oipScience.cards.lastGeneRif')"
+              :content="ifNoRes(geneLastRif, 'date')"
+            />
+          </div>
+
+          <OipScienceLocalSliderTabs
+            v-if="geneSymbol"
+            sliderId="sliderTabsFull"
+            :filterValues="getStore('SliderMenu')"
+            filterName="SliderMenu"
+            :active-tab="activeMenu"
+            @change-element="switchMenu"
+            :tabs="[
+              { label: $t('oipScience.cards.all') },
+              { label: $t('oipScience.cards.reference') },
+              { label: 'GeneRIF' },
+            ]"
+            isFullWidth
+          />
+
+        </div>
+      </div>
+
+      <!-- Recherche et filtres dans la barre des autres pages ; les onglets
+           GeneRIF n'ont pas de filtres, la recherche reste seule. -->
+      <RmFilterBar
+        v-if="!geneSymbol || activeMenu === 0"
+
+        :class="{ pub_fbar_top: !geneSymbol }"
+        :filters-amount="filtersAmount"
+        @clear-filters="clearFilters"
+        :lang="$i18n.locale === 'en' ? 'en' : 'fr'"
+      >
+        <template #Search>
+          <RmSearchBar
+            v-model="searchText"
+            class="pub_search"
+            :placeholder="$t('oipScience.common.searchPublications')"
+            :have-advanced="false"
+          />
+        </template>
+        <template #Filters>
+          <OipScienceElasticDateRangeFilter
+            :key="'period' + filtersKey"
+            :filterValues="getStore('Period')"
+            filterName="Period"
+            :label="$t('oipScience.ui.filters.period')"
+            field="article_date"
+            :indexFirstSelection="5"
+          />
+
+          <OipScienceElasticFilter
+            :key="'type' + filtersKey"
+            :filterValues="getStore('Article Type')"
+            field="publication_types"
+            filterName="Article Type"
+            :label="$t('oipScience.common.articleType')"
+            :indexQuery="indexQuery"
+            :matchQuery="matchQuery"
+            :cluster="clusterName"
+          />
+        </template>
+      </RmFilterBar>
+
+      <template v-if="!isLoadingQuery">
+        <RmResultsLine icon="Article" :items="[{ count: filteredItems.length, label: $t('oipScience.resultKpis.publications', filteredItems.length) }]" />
+        <RmSearchBar
+          v-if="geneSymbol && activeMenu !== 0"
+          v-model="searchText"
+          :placeholder="$t('oipScience.common.searchPublications')"
+          :have-advanced="false"
+        />
+
+        <!-- Meme carte que /pubmed. Seules les cartes affichees chargent la
+             fiche complete (resume, tags) : une liste peut compter 1000 articles. -->
+        <div class="oip_grid gap-8">
+          <template v-for="item in visibleItems" :key="item.PubMed_ID">
+            <OipSciencePubmedCards
+              v-if="fullDocs.get(String(item.PubMed_ID))"
+              :data="fullDocs.get(String(item.PubMed_ID))"
+              :id="String(item.PubMed_ID)"
+              :highlight="highlight"
+            />
+          </template>
+        </div>
+
+        <RmLoadingState v-if="isLoadingDocs" :lines="2" />
+        <RmEmptyState
+          v-if="!filteredItems.length"
+          :title="$t('oipScience.common.noMatchingResult')"
+        />
+        <RmButton
+          v-if="visibleItems.length < filteredItems.length"
+          variant="secondary"
+          class="load_more"
+          @click="displayCount += PAGE_SIZE"
+        >{{ $t('oipScience.common.loadMore') }}</RmButton>
+      </template>
+    </div>
+    <RmLoadingState v-if="isLoadingQuery" :lines="3" :chart-height="240" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { PropType } from 'vue';
+import indexConfig from '../../../oip-science/indexConfig.json';
+import useOipElastic from '../../../oip-science/composables/useOipElastic';
+import usePubmed from '../../../oip-science/composables/usePubmed';
+import { ifNoRes } from '../../../oip-science/utils/styleAndFormat';
+import { provideOipFilterContext } from '../../../oip-science/utils/c-filterContext';
+
+const props = defineProps({
+  customQuery: {
+    type: Object,
+    default: {},
+  },
+  geneSymbol: {
+    type: String,
+    default: null,
+  },
+  from: {
+    type: String,
+    required: true,
+  },
+  // Garde pour l'API de FAS, qui ne s'en servait pas.
+  searchHighlight: {
+    type: Array,
+    default: [],
+  },
+  // Termes surlignes dans les cartes (FAS les lisait dans le filterStore).
+  highlight: {
+    type: Array as PropType<string[]>,
+    default: () => [],
+  },
+});
+
+// Etat des filtres de cette liste (anciennement filterStore et
+// elasticQueryStore, par route).
+const filterContext = provideOipFilterContext();
+
+const { queryElastic } = useOipElastic();
+const indexQuery = ref(indexConfig.pubmed.index);
+const clusterName = ref(indexConfig.pubmed.cluster);
+const { pubmedContentFromIds } = usePubmed();
+const { queryCustomElastic } = useOipElastic();
+// :::::::::::::::::::::::::::::
+const resultsQuery = ref<any[] | null>(null);
+
+const isLoadingQuery = ref(true);
+// :::::::::::::::::::::::::::::
+// FILTERS
+
+// :::::::::::::::::::::::::::::
+
+const getStore = (filter: string) => {
+  return filterContext.findValuesStore({ filter });
+};
+
+// Puce « Filtres » : ce qui est pose a la main, et l'effacement. La requete
+// de la page (`Custom Query`) reste, seuls ces deux filtres partent ; les
+// composants sont remontes pour revenir a leur etat initial.
+const PUB_FILTERS = ['Period', 'Article Type'];
+const filtersKey = ref(0);
+const filtersAmount = computed(() =>
+  PUB_FILTERS.reduce((sum, filter) => sum + getStore(filter).flat().length, 0),
+);
+function clearFilters() {
+  for (const filter of PUB_FILTERS) {
+    filterContext.resetSelectedFilters({ filter });
+    filterContext.removeQueryFilter({ filter });
+  }
+  filtersKey.value++;
+}
+
+// La requete de la page est posee avant le montage des filtres (FAS la posait
+// a onMounted) : la premiere recherche part deja restreinte a la liste.
+filterContext.setQueryFilters({
+  filter: 'Custom Query',
+  values: props.customQuery,
+  keyName: null,
+});
+
+onMounted(async () => {
+  if (props.geneSymbol) {
+    await getLastRefRif();
+  }
+});
+
+const sources = ref([
+  'PubMed_ID',
+  'title',
+  'authors',
+  'article_date',
+  'publication_types',
+  'genomics',
+]);
+
+const geneFirstRef = ref(null as any);
+const geneLastRif = ref(null as any);
+
+// :::::::::::::::::::::::::::::
+const queriesFilters = computed(() => {
+  return filterContext.findQueryFromPage({});
+});
+
+const matchQuery = computed(() => {
+  return queriesFilters.value.filter(
+    (x) => x.filter !== 'Take' && x.filter !== 'Sort'
+  );
+});
+
+watch(
+  () => queriesFilters.value,
+  async (newVal, oldVal) => {
+    if (
+      !resultsQuery.value ||
+      (filterContext.findQueryFromPage({}).length != 0 &&
+        JSON.stringify(oldVal) !== JSON.stringify(newVal))
+    ) {
+      await launchQuery();
+    }
+  },
+  { deep: true, flush: 'post' }
+);
+
+// :::::::::::::::::::::::::::::
+
+const getLastRefRif = async () => {
+  try {
+    await queryCustomElastic({
+      index: indexConfig.gene.index,
+      cluster: indexConfig.gene.cluster,
+      customQuery: {
+        _source: ['date_first_reference', 'date_last_generif_update'],
+
+        from: 0,
+        query: {
+          bool: {
+            must: [
+              {
+                term: {
+                  'symbol.keyword': props.geneSymbol,
+                },
+              },
+            ],
+          },
+        },
+        size: 1000,
+        track_total_hits: true,
+      },
+    }).then((res) => {
+      if (res?.results?.length) {
+        geneFirstRef.value = res.results[0].date_first_reference;
+        geneLastRif.value = res.results[0].date_last_generif_update;
+      }
+    });
+  } catch (error) {
+    console.error('Error in launchQuery:', error);
+  }
+};
+
+const launchQuery = async (): Promise<void> => {
+  isLoadingQuery.value = true;
+
+  try {
+    if (!props.geneSymbol) {
+      await getPubmedInfos();
+    }
+    //    "is_gene_nih": true si
+    // => gene qui vient de la base NIH
+
+    //    "is_hugo_reference": true
+    // => gene qui vient de la base HUGO
+
+    //    "is_gene_rif": true
+    // => gene qui vient de la base Hugo mais qui possede des articles pubmed
+
+    //    "is_tekkare_reference": true,
+    // => gene qui vient d'aucune des bases
+
+    // Quand un true les autres sont false
+    if (props.geneSymbol) {
+      if (activeMenu.value === 0) {
+        await getPubmedInfos();
+      } else if (activeMenu.value === 1) {
+        await getGeneInfos('is_hugo_reference');
+      } else if (activeMenu.value === 2) {
+        await getGeneInfos('is_nih_generif');
+      }
+    }
+  } catch (e) {
+    console.error('Error queuing query:', e);
+  } finally {
+    isLoadingQuery.value = false;
+  }
+};
+
+const getPubmedInfos = async () => {
+  await queryElastic({
+    index: indexQuery.value,
+    source: sources.value,
+    take: 1000,
+    customQuery: matchQuery.value,
+    sortQuery: {
+      values: [
+        {
+          article_date: {
+            order: 'desc',
+          },
+        },
+      ],
+    },
+    cluster: clusterName.value,
+  }).then((res) => {
+    resultsQuery.value = res?.results;
+  });
+};
+
+const getGeneInfos = async (source: string) => {
+  await pubmedContentFromIds({
+    customQuery: {
+      _source: sources.value,
+
+      from: 0,
+      query: {
+        bool: {
+          must: [
+            {
+              term: {
+                delete: false,
+              },
+            },
+
+            {
+              nested: {
+                path: 'genomics',
+                query: {
+                  bool: {
+                    must: [
+                      {
+                        terms: {
+                          'genomics.gene_symbol.keyword': [props.geneSymbol],
+                        },
+                      },
+                      {
+                        term: {
+                          [`genomics.${source}`]: true,
+                        },
+                      },
+                    ],
+                  },
+                },
+              },
+            },
+          ],
+        },
+      },
+      size: 1000,
+      track_total_hits: true,
+      sort: [{ article_date: { order: 'desc' } }],
+    },
+  }).then((res: any) => {
+    resultsQuery.value = res.results;
+  });
+};
+
+// :::::::::::::::::::::::::::::
+
+// :::::::::::::::::::::::::::::
+// CARDS
+
+// Filtre local et affichage par paquets de cartes.
+const searchText = ref('');
+const PAGE_SIZE = 20;
+const displayCount = ref(PAGE_SIZE);
+
+const filteredItems = computed(() => {
+  const items = resultsQuery.value || [];
+  const q = searchText.value.trim().toLowerCase();
+  if (!q) return items;
+  return items.filter((item: any) =>
+    [
+      item.PubMed_ID,
+      item.title,
+      ...(item.authors || []).map(
+        (author: any) => `${author.forename} ${author.lastname}`
+      ),
+    ]
+      .filter(Boolean)
+      .join(' ')
+      .toLowerCase()
+      .includes(q)
+  );
+});
+
+const visibleItems = computed(() =>
+  filteredItems.value.slice(0, displayCount.value)
+);
+
+watch([searchText, resultsQuery], () => {
+  displayCount.value = PAGE_SIZE;
+});
+
+// Fiches completes des cartes affichees, chargees par paquet et gardees en
+// cache : la requete de liste ne ramene que les champs du filtre.
+const fullDocs = ref(new Map<string, any>());
+const isLoadingDocs = ref(false);
+
+watch(
+  visibleItems,
+  async (items) => {
+    const missing = items
+      .map((item: any) => String(item.PubMed_ID ?? ''))
+      .filter((id) => id && !fullDocs.value.has(id));
+    if (!missing.length) return;
+    isLoadingDocs.value = true;
+    try {
+      const res = await queryCustomElastic({
+        index: indexConfig.pubmed.index,
+        cluster: indexConfig.pubmed.cluster,
+        customQuery: {
+          size: missing.length,
+          _source: {
+            excludes: ['embedding', 'embeddings_small', 'med_embeddings'],
+          },
+          query: { terms: { PubMed_ID: missing } },
+        },
+      });
+      const next = new Map(fullDocs.value);
+      for (const doc of res?.results || []) {
+        if (doc?.PubMed_ID != null) next.set(String(doc.PubMed_ID), doc);
+      }
+      fullDocs.value = next;
+    } finally {
+      isLoadingDocs.value = false;
+    }
+  },
+  { immediate: true }
+);
+
+const activeMenu = ref(0 as number);
+watch(
+  () => activeMenu.value,
+  async (oldValue, newValue) => {
+    if (oldValue !== newValue) {
+      await launchQuery();
+    }
+  }
+);
+
+const switchMenu = (val: any) => {
+  activeMenu.value = val;
+};
+
+// :::::::::::::::::::::::::::::
+</script>
+
+<style scoped>
+.load_more {
+  align-self: center;
+  justify-self: center;
+}
+</style>

package/layer/app/components/oip-science/crossData/CrossDataLocations.vue

@@ -0,0 +1,71 @@
+<!--
+  Etablissements rapproches d'un essai (index hco__nct / hco__euct), pour un
+  essai et son jumeau de l'autre registre. Rendu avec la carte de la page
+  /establishments. (Portage de components/crossData/CrossDataLocations.vue de
+  France Augmented Science.)
+-->
+<template>
+  <OipScienceEstablishmentsLinkedList
+    :locations="locations"
+    :title="$t('oipScience.ui.matchedEstablishments')"
+    :sources="['CT.gov', 'EUCT', 'FINESS']"
+    index-last-update="CT.gov"
+    :loading="isLoading"
+  />
+</template>
+
+<script setup lang="ts">
+import type { LinkedLocation } from '../establishments/LinkedList.vue';
+import useEstablishmentMatching from '../../../oip-science/composables/useEstablishmentMatching';
+
+const props = defineProps<{
+  id: string;
+  nctLinked?: string | null;
+}>();
+
+const { fetchTrialHcoMatches } = useEstablishmentMatching();
+
+type Match = Awaited<ReturnType<typeof fetchTrialHcoMatches>>[number];
+const matches = ref<Match[]>([]);
+const isLoading = ref(true);
+
+async function loadAll() {
+  isLoading.value = true;
+  try {
+    const ids = [props.id, props.nctLinked].filter(Boolean) as string[];
+    const results = await Promise.all(
+      ids.map((id) =>
+        fetchTrialHcoMatches(id, id.startsWith('NCT') ? 'nct' : 'euct').catch(
+          () => [] as Match[],
+        ),
+      ),
+    );
+    // Un etablissement par FINESS, les deux registres confondus.
+    const seen = new Set<string>();
+    const merged: Match[] = [];
+    for (const list of results) {
+      for (const m of list) {
+        if (!m.hco_et_code || seen.has(m.hco_et_code)) continue;
+        seen.add(m.hco_et_code);
+        merged.push(m);
+      }
+    }
+    matches.value = merged;
+  } finally {
+    isLoading.value = false;
+  }
+}
+
+onMounted(loadAll);
+watch(() => props.id, loadAll);
+
+const locations = computed<LinkedLocation[]>(() =>
+  matches.value.map((m) => ({
+    name: m.hco_et_label || m.name || '',
+    city: m.hco_et_city || null,
+    country: 'France',
+    finess: m.hco_et_code || null,
+    score: typeof m.score === 'number' ? m.score : null,
+  })),
+);
+</script>

package/layer/app/components/oip-science/ctgov/Investigators.vue

@@ -0,0 +1,148 @@
+<!--
+  Onglet « Investigateurs » d'un essai CT.gov (portage de la page
+  /ctgov/[id]/investigators de France Augmented Science).
+-->
+<template>
+  <div class="oip-science">
+    <OipScienceHcpsLinkedList
+      :people="people"
+      :title="$t('oipScience.trial.investigatorsAndContacts')"
+      :sources="['CT.gov']"
+      index-last-update="CT.gov"
+      :loading="isLoadingQueryClinicalTrial || isLoadingMatches"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import useGlobalClinicalTrials from '../../../oip-science/composables/useGlobalClinicalTrials';
+import useAuthorMatching from '../../../oip-science/composables/useAuthorMatching';
+import type { LinkedPerson } from '../hcps/LinkedList.vue';
+
+const props = withDefaults(
+  defineProps<{
+    /** Numero NCT de l'essai. */
+    id: string;
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { findClinicalTrialById, isLoadingQueryClinicalTrial, resultsQueryClinicalTrial } = useGlobalClinicalTrials();
+const { normalize, fetchNctHcpMatches } = useAuthorMatching();
+
+type HcpMatch = Awaited<ReturnType<typeof fetchNctHcpMatches>>[number];
+const hcpMatches = ref<HcpMatch[]>([]);
+const hcpByName = ref<Map<string, HcpMatch>>(new Map());
+const isLoadingMatches = ref(true);
+
+async function loadMatchedHcps(nctId: string) {
+  const matches = await fetchNctHcpMatches(nctId);
+  hcpMatches.value = matches;
+  const map = new Map<string, HcpMatch>();
+  for (const m of matches) {
+    const first = normalize(m.first_name);
+    const family = normalize(m.family_name);
+    if (first && family) {
+      map.set(first + family, m);
+      map.set(family + first, m);
+    }
+    if (family) map.set(family, m);
+  }
+  hcpByName.value = map;
+}
+
+function findHcpMatch(name: string | null | undefined): HcpMatch | null {
+  if (!name) return null;
+  const n = normalize(name);
+  if (!n) return null;
+  const direct = hcpByName.value.get(n);
+  if (direct) return direct;
+  for (const m of hcpMatches.value) {
+    const family = normalize(m.family_name);
+    if (family && family.length >= 3 && n.includes(family)) {
+      const first = normalize(m.first_name);
+      if (!first || first.length < 2 || n.includes(first.slice(0, 2))) {
+        return m;
+      }
+    }
+  }
+  return null;
+}
+
+async function load() {
+  if (!props.id) return;
+  const nctId = props.id.toString();
+  isLoadingMatches.value = true;
+  await Promise.all([
+    findClinicalTrialById({
+      id: nctId,
+      source: ['facilitiesInvestigators', 'facilitiesContacts', 'overall_officials', 'facilities'],
+    }),
+    loadMatchedHcps(nctId).finally(() => {
+      isLoadingMatches.value = false;
+    }),
+  ]);
+}
+
+onMounted(load);
+watch(() => props.id, load);
+
+const people = computed<LinkedPerson[]>(() => {
+  const trial = resultsQueryClinicalTrial.value as any;
+  const facilities: any[] = trial?.facilities || [];
+  const facilityOf = (id: any) => facilities.find((f) => f.facility_id === id);
+  const seen = new Set<string>();
+
+  const person = (
+    name: string | null | undefined,
+    role: string | null | undefined,
+    facility?: any | null,
+    affiliation?: string | null,
+  ): LinkedPerson => {
+    const match = findHcpMatch(name);
+    if (match) seen.add(match.hcp_code);
+    return {
+      name: name || null,
+      role: role || null,
+      facility: facility?.name || affiliation || null,
+      city: facility?.city || null,
+      country: facility?.country || null,
+      rpps: match?.hcp_code || null,
+      score: match?.score ?? null,
+    };
+  };
+
+  const rows: LinkedPerson[] = [
+    ...(trial?.facilitiesInvestigators || []).map((y: any) =>
+      person(y.facility_investigator_name, y.facility_investigator_role, facilityOf(y.facility_id)),
+    ),
+    ...(trial?.overall_officials || []).map((y: any) => person(y.name, y.role, null, y.affiliation)),
+    ...(trial?.facilitiesContacts || []).map((y: any) =>
+      person(y.facility_contact_name, y.facility_contact_type, facilityOf(y.facility_id)),
+    ),
+  ];
+
+  // Professionnels rapproches par l'index mais absents du registre par leur nom.
+  for (const m of hcpMatches.value) {
+    if (seen.has(m.hcp_code)) continue;
+    rows.push({
+      name: `${m.family_name} ${m.first_name}`.trim(),
+      role: m.specialty.find((s: any) => s.type === 'PRINCIPAL')?.label || m.specialty[0]?.label || null,
+      country: 'France',
+      rpps: m.hcp_code,
+      score: m.score,
+    });
+  }
+
+  // Une personne par RPPS, sinon par nom ; la France en tete.
+  const unique = new Map<string, LinkedPerson>();
+  for (const row of rows) {
+    const key = row.rpps ? `rpps:${row.rpps}` : `name:${normalize(row.name || '')}`;
+    if (key === 'name:' || unique.has(key)) continue;
+    unique.set(key, row);
+  }
+  return [...unique.values()].sort((a, b) => (a.country === 'France' ? 0 : 1) - (b.country === 'France' ? 0 : 1));
+});
+</script>