@tekkare/romulus 0.1.251 → 0.1.252

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

@@ -0,0 +1,125 @@
+<!--
+  Onglet « Investigateurs » d'un essai EUCT (portage de la page
+  /euct/[id]/investigators de France Augmented Science).
+-->
+<template>
+  <div class="oip-science">
+    <OipScienceHcpsLinkedList
+      :people="people"
+      :title="$t('oipScience.trial.investigatorsAndContacts')"
+      :sources="['EUCT']"
+      index-last-update="EUCT"
+      :loading="isLoadingQueryEuct || isLoadingMatches"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import useEuct from '../../../oip-science/composables/useEuct';
+import useAuthorMatching from '../../../oip-science/composables/useAuthorMatching';
+import type { LinkedPerson } from '../hcps/LinkedList.vue';
+
+const props = withDefaults(
+  defineProps<{
+    /** Numero EUCT de l'essai. */
+    id: string;
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { findEuctById, resultsQueryEuct, isLoadingQueryEuct } = useEuct();
+const { normalize, fetchEuctHcpMatches } = useAuthorMatching();
+
+type HcpMatch = Awaited<ReturnType<typeof fetchEuctHcpMatches>>[number];
+const hcpMatches = ref<HcpMatch[]>([]);
+const hcpByName = ref<Map<string, HcpMatch>>(new Map());
+const isLoadingMatches = ref(true);
+
+async function loadMatchedHcps(euctId: string) {
+  const matches = await fetchEuctHcpMatches(euctId);
+  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 euctId = props.id.toString();
+  isLoadingMatches.value = true;
+  await Promise.all([
+    findEuctById({ id: euctId, source: ['hcps', 'sites'] }),
+    loadMatchedHcps(euctId).finally(() => {
+      isLoadingMatches.value = false;
+    }),
+  ]);
+}
+
+onMounted(load);
+watch(() => props.id, load);
+
+const people = computed<LinkedPerson[]>(() => {
+  const seen = new Set<string>();
+  const rows: LinkedPerson[] = (((resultsQueryEuct.value as any)?.hcps as any[]) || []).map((item) => {
+    const name = `${item.title ? item.title + ' ' : ''}${item.first_name || ''} ${item.last_name || ''}`.trim();
+    const match = findHcpMatch(`${item.first_name || ''} ${item.last_name || ''}`);
+    if (match) seen.add(match.hcp_code);
+    return {
+      name: name || null,
+      role: item.department_name || null,
+      country: item.country || null,
+      rpps: match?.hcp_code || null,
+      score: match?.score ?? null,
+    };
+  });
+
+  // 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>

package/layer/app/components/oip-science/euct/Locations.vue

@@ -0,0 +1,102 @@
+<!--
+  Onglet « Sites » d'un essai EUCT (portage de la page
+  /euct/[id]/locations de France Augmented Science).
+-->
+<template>
+  <div class="oip-science">
+    <OipScienceEstablishmentsLinkedList
+      :locations="locations"
+      :title="$t('oipScience.trial.locations')"
+      :sources="['EUCT']"
+      index-last-update="EUCT"
+      :loading="isLoadingQueryEuct || isLoadingMatches"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import useEuct from '../../../oip-science/composables/useEuct';
+import useAuthorMatching from '../../../oip-science/composables/useAuthorMatching';
+import useEstablishmentMatching from '../../../oip-science/composables/useEstablishmentMatching';
+import type { LinkedLocation } from '../establishments/LinkedList.vue';
+
+const props = withDefaults(
+  defineProps<{
+    /** Numero EUCT de l'essai. */
+    id: string;
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { findEuctById, resultsQueryEuct, isLoadingQueryEuct } = useEuct();
+const { normalize } = useAuthorMatching();
+const { fetchEuctHcoMatches } = useEstablishmentMatching();
+
+// Etablissements rapproches de l'essai (index hco__euct). Chaque entree porte
+// le libelle EUCT d'origine dans `name` : lien site <-> HCO un a un.
+type TrialHcoMatch = Awaited<ReturnType<typeof fetchEuctHcoMatches>>[number];
+const hcoMatches = ref<TrialHcoMatch[]>([]);
+const matchByName = ref<Map<string, TrialHcoMatch>>(new Map());
+const isLoadingMatches = ref(true);
+
+async function loadHcoMatches(euctId: string) {
+  const matches = await fetchEuctHcoMatches(euctId);
+  hcoMatches.value = matches;
+  const map = new Map<string, TrialHcoMatch>();
+  for (const m of matches) {
+    const key = normalize(m.name || '');
+    if (key) map.set(key, m);
+  }
+  matchByName.value = map;
+}
+
+async function load() {
+  if (!props.id) return;
+  const euctId = props.id.toString();
+  isLoadingMatches.value = true;
+  await Promise.all([
+    findEuctById({ id: euctId, source: ['sites'] }),
+    loadHcoMatches(euctId).finally(() => {
+      isLoadingMatches.value = false;
+    }),
+  ]);
+}
+
+onMounted(load);
+watch(() => props.id, load);
+
+const locations = computed<LinkedLocation[]>(() => {
+  const sites: any[] = (resultsQueryEuct.value as any)?.sites || [];
+  const seen = new Set<string>();
+
+  // 1. Les sites EUCT, la France en tete, enrichis du FINESS rapproche.
+  const rows: LinkedLocation[] = [...sites]
+    .sort((a, b) => (a.country === 'France' ? 0 : 1) - (b.country === 'France' ? 0 : 1))
+    .map((item) => {
+      const match = matchByName.value.get(normalize(item.organisation_name || ''));
+      if (match?.hco_et_code) seen.add(match.hco_et_code);
+      return {
+        name: item.organisation_name,
+        country: item.country,
+        city: item.city,
+        finess: match?.hco_et_code || null,
+        score: typeof match?.score === 'number' ? match.score : null,
+      };
+    });
+
+  // 2. Les etablissements rapproches qu'aucun site n'a repris.
+  for (const m of hcoMatches.value) {
+    if (!m.hco_et_code || seen.has(m.hco_et_code)) continue;
+    rows.push({
+      name: m.name || m.hco_et_label || '',
+      country: 'France',
+      city: m.hco_et_city || '',
+      finess: m.hco_et_code,
+      score: typeof m.score === 'number' ? m.score : null,
+    });
+  }
+  return rows;
+});
+</script>

package/layer/app/components/oip-science/euct/Products.vue

@@ -0,0 +1,101 @@
+<!--
+  Onglet « Produits » d'un essai EUCT (portage de la page
+  /euct/[id]/products de France Augmented Science).
+-->
+<template>
+  <div class="oip-science">
+    <RmTableCard v-if="loaded && !isLoadingQueryEuct">
+      <template #header>
+        <div>
+          <h3 class="rm-table-card__title">{{ $t('oipScience.trial.products') }}</h3>
+          <p class="rm-table-card__context">
+            {{ ifNoRes(getContent.length, 'number') }} {{ $t('oipScience.trial.resultsCount') }}
+          </p>
+          <OipScienceCommonSource :sources="['EUCT']" :lang="lang" />
+        </div>
+      </template>
+      <RmTable :columns="table.columns" :rows="table.rows" search>
+        <template v-for="key in table.typeKeys.Highlight" :key="key" #[key]="{ value }">
+          <RmTextHighlight :queries="highlight" :text="value" />
+        </template>
+        <template v-for="key in table.typeKeys.Tags" :key="key" #[key]="{ value }">
+          <RmTag v-if="value" variant="blue" style="width: max-content">
+            {{ $t('oipScience.trial.orphanDrug') }}
+          </RmTag>
+          <p v-else>-</p>
+        </template>
+      </RmTable>
+    </RmTableCard>
+    <RmLoadingState v-else :lines="3" :chart-height="240" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import useEuct from '../../../oip-science/composables/useEuct';
+import { ifNoRes } from '../../../oip-science/utils/styleAndFormat';
+import { valueTable } from '../../../oip-science/utils/valueTable';
+
+const props = withDefaults(
+  defineProps<{
+    /** Numero EUCT de l'essai. */
+    id: string;
+    /** Termes de la recherche en cours, surlignes dans le tableau. */
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { t } = useI18n();
+const { findEuctById, resultsQueryEuct, isLoadingQueryEuct } = useEuct();
+
+// Le composable part a `false` : le tableau attend la premiere lecture.
+const loaded = ref(false);
+
+async function load() {
+  if (!props.id) return;
+  await findEuctById({ id: props.id.toString(), source: ['products'] });
+  loaded.value = true;
+}
+
+onMounted(load);
+watch(() => props.id, load);
+
+// Sept colonnes dans l'en-tete, sept types : le tableau Auriga n'en declarait
+// que six, le tag « orphelin » se posait sur le code ATC et le booleen sortait brut.
+const getColumnType = computed(() => ['Highlight', 'Highlight', 'Highlight', 'Highlight', 'Highlight', 'Highlight', 'Tags']);
+
+const getHeader = computed(() => [
+  'euMpNumber',
+  t('oipScience.trial.role'),
+  t('oipScience.trial.productName'),
+  t('oipScience.trial.activeSubstance'),
+  t('oipScience.trial.atcName'),
+  t('oipScience.trial.atcCode'),
+  t('oipScience.trial.tags'),
+]);
+
+const getContent = computed(() => {
+  const products = (resultsQueryEuct.value as any)?.products;
+  if (products && products.length > 0) {
+    return products.map((item: any) => ({
+      values: [
+        item?.productDictionaryInfo?.euMpNumber,
+        item?.Role,
+        item?.productDictionaryInfo?.prodName,
+        item?.productDictionaryInfo?.activeSubstanceName,
+        item?.productDictionaryInfo?.atcName,
+        item?.productDictionaryInfo?.atcCode,
+        item?.isOrphanDesignation,
+      ],
+    }));
+  }
+  return [];
+});
+
+const table = computed(() =>
+  valueTable(getHeader.value, getContent.value, getColumnType.value, {
+    align: ['left', 'left', 'left', 'left', 'left', 'left', 'right'],
+  }),
+);
+</script>

package/layer/app/components/oip-science/euct/Publications.vue

@@ -0,0 +1,89 @@
+<!--
+  Onglet « Publications » d'un essai EUCT (portage de la page
+  /euct/[id]/publications de France Augmented Science) : les publications
+  PubMed que l'essai cite.
+-->
+<template>
+  <div class="oip-science">
+    <div v-if="!isLoading && pubmedResults.length" class="oip_grid gap-24">
+      <RmResultsLine
+        icon="Article"
+        :items="[{ count: pubmedResults.length, label: $t('oipScience.resultKpis.publications', pubmedResults.length) }]"
+      />
+      <div v-for="(res, index) in pubmedResults" :key="index">
+        <OipSciencePubmedCards :data="res" :id="res.PubMed_ID" />
+      </div>
+    </div>
+    <RmLoadingState v-if="isLoading" :lines="3" :chart-height="240" />
+    <RmEmptyState
+      v-if="!isLoading && !pubmedResults.length"
+      :title="$t('oipScience.common.noDataTitle')"
+      :text="$t('oipScience.common.noDataText')"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import indexConfig from '../../../oip-science/indexConfig.json';
+import useEuct from '../../../oip-science/composables/useEuct';
+import useOipElastic from '../../../oip-science/composables/useOipElastic';
+
+const props = withDefaults(
+  defineProps<{
+    /** Numero EUCT de l'essai. */
+    id: string;
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { queryCustomElastic } = useOipElastic();
+const { findEuctById, resultsQueryEuct } = useEuct();
+
+const isLoading = ref(true);
+const pubmedResults = ref<any[]>([]);
+
+async function load() {
+  const pageId = props.id?.toString();
+  if (!pageId) {
+    isLoading.value = false;
+    return;
+  }
+
+  isLoading.value = true;
+  pubmedResults.value = [];
+  try {
+    await findEuctById({ id: pageId, source: ['pubmed_citations_id'] });
+    const pubmedIds = [
+      ...new Set((((resultsQueryEuct.value as any)?.pubmed_citations_id as string[]) || []).filter(Boolean)),
+    ];
+
+    if (pubmedIds.length === 0) return;
+
+    const batchSize = 1000;
+    const all: any[] = [];
+    for (let i = 0; i < pubmedIds.length; i += batchSize) {
+      const batch = pubmedIds.slice(i, i + batchSize);
+      const res = await queryCustomElastic({
+        index: indexConfig.pubmed.index,
+        cluster: indexConfig.pubmed.cluster,
+        customQuery: {
+          size: batch.length,
+          query: { terms: { 'PubMed_ID.keyword': batch } },
+          sort: [{ article_date: { order: 'desc' } }],
+        },
+      });
+      all.push(...(res?.results || []));
+    }
+    pubmedResults.value = all;
+  } catch (e) {
+    console.error(e);
+  } finally {
+    isLoading.value = false;
+  }
+}
+
+onMounted(load);
+watch(() => props.id, load);
+</script>

package/layer/app/components/oip-science/euct/Sponsors.vue

@@ -0,0 +1,86 @@
+<!--
+  Onglet « Sponsors » d'un essai EUCT (portage de la page
+  /euct/[id]/sponsors de France Augmented Science).
+-->
+<template>
+  <div class="oip-science">
+    <RmTableCard v-if="loaded && !isLoadingQueryEuct">
+      <template #header>
+        <div>
+          <h3 class="rm-table-card__title">{{ $t('oipScience.trial.sponsorsAndCollaborators') }}</h3>
+          <p class="rm-table-card__context">
+            {{ ifNoRes(getContent.length, 'number') }} {{ $t('oipScience.trial.resultsCount') }}
+          </p>
+          <OipScienceCommonSource :sources="['EUCT']" :lang="lang" />
+        </div>
+      </template>
+      <RmTable :columns="table.columns" :rows="table.rows" search>
+        <template v-for="key in table.typeKeys.Tag" :key="key" #[key]="{ value }">
+          <div v-if="value" class="oip_row gap-8 wrap end">
+            <div v-for="(item, index) in value" :key="index">
+              <RmTag variant="gray" class="no-wrap">
+                {{ getCountryEmoji(item.address.countryName) }}
+              </RmTag>
+            </div>
+          </div>
+        </template>
+      </RmTable>
+    </RmTableCard>
+    <RmLoadingState v-else :lines="3" :chart-height="240" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import useEuct from '../../../oip-science/composables/useEuct';
+import { getCountryEmoji, ifNoRes } from '../../../oip-science/utils/styleAndFormat';
+import { valueTable } from '../../../oip-science/utils/valueTable';
+
+const props = withDefaults(
+  defineProps<{
+    /** Numero EUCT de l'essai. */
+    id: string;
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { t } = useI18n();
+const { findEuctById, resultsQueryEuct, isLoadingQueryEuct } = useEuct();
+
+// Le composable part a `false` : le tableau attend la premiere lecture.
+const loaded = ref(false);
+
+async function load() {
+  if (!props.id) return;
+  await findEuctById({ id: props.id.toString(), source: ['co_sponsors'] });
+  loaded.value = true;
+}
+
+onMounted(load);
+watch(() => props.id, load);
+
+const getColumnType = computed(() => ['', '', 'Tag']);
+
+const getHeader = computed(() => [t('oipScience.common.name'), t('oipScience.common.type'), t('oipScience.trial.country')]);
+
+const getContent = computed(() => {
+  const coSponsors = (resultsQueryEuct.value as any)?.co_sponsors;
+  if (coSponsors && coSponsors.length > 0) {
+    return coSponsors.map((item: any) => ({
+      values: [
+        item?.organisation?.name,
+        item?.organisation?.type,
+        item.addresses && item.addresses.length > 0 ? item.addresses : null,
+      ],
+    }));
+  }
+  return [];
+});
+
+const table = computed(() =>
+  valueTable(getHeader.value, getContent.value, getColumnType.value, {
+    align: ['left', 'left', 'right'],
+  }),
+);
+</script>