@tekkare/romulus 0.1.251 → 0.1.252

package/layer/app/components/oip-science/hcps/ClinicalTrials.vue

@@ -0,0 +1,78 @@
+<!--
+  Onglet Essais cliniques de la fiche professionnel (porte de la page
+  hcps/[id]/clinical-trials de France Augmented Science).
+-->
+<template>
+  <div class="oip-science">
+    <OipScienceClinicalTrialsLinkedList
+      :nct-ids="nctIds"
+      :euct-ids="euctIds"
+      :extras="extras"
+      :title="$t('oipScience.common.clinicalTrials')"
+      :sources="['CT.gov', 'EUCT', 'RPPS']"
+      index-last-update="HCPs"
+      :loading="isLoading"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import indexConfig from '../../../oip-science/indexConfig.json';
+import useOipElastic from '../../../oip-science/composables/useOipElastic';
+
+// Meme forme que LinkedTrialExtra de clinical-trials/LinkedList.vue.
+type LinkedTrialExtra = { score?: number | null; role?: string | null };
+type HcpTrialName = { first_name?: string; last_name?: string; name?: string; match_method: string; score: number };
+
+const props = withDefaults(defineProps<{ id: string; highlight?: string[]; lang?: 'fr' | 'en' }>(), {
+  highlight: () => [],
+  lang: undefined,
+});
+
+const { queryOneElastic } = useOipElastic();
+
+const isLoading = ref(true);
+const hcp = ref<any>(null);
+
+async function load(urlId: string) {
+  isLoading.value = true;
+  hcp.value = null;
+  try {
+    hcp.value = await queryOneElastic({
+      index: indexConfig.hcps.index,
+      cluster: indexConfig.hcps.cluster,
+      path: 'hcp_code',
+      id: urlId,
+    });
+  } catch (e) {
+    console.error(e);
+  } finally {
+    isLoading.value = false;
+  }
+}
+
+watch(() => props.id, (id) => { if (id) load(id); }, { immediate: true });
+
+const nctIds = computed<string[]>(() =>
+  (hcp.value?.nct_trial || []).map((t: any) => t?.clinical_trial_id).filter(Boolean),
+);
+const euctIds = computed<string[]>(() =>
+  (hcp.value?.euct_trial || []).map((t: any) => t?.clinical_trial_id).filter(Boolean),
+);
+
+// Le meilleur score de rapprochement du professionnel, par registre.
+const topScore = (entries: HcpTrialName[] | null | undefined) => {
+  if (!Array.isArray(entries) || !entries.length) return null;
+  const top = [...entries].sort((a, b) => (b?.score ?? 0) - (a?.score ?? 0))[0];
+  return typeof top?.score === 'number' ? top.score : null;
+};
+
+const extras = computed<Record<string, LinkedTrialExtra>>(() => {
+  const nct = { score: topScore(hcp.value?.nct_name) };
+  const euct = { score: topScore(hcp.value?.euct_name) };
+  return Object.fromEntries([
+    ...nctIds.value.map((id) => [id, nct]),
+    ...euctIds.value.map((id) => [id, euct]),
+  ]);
+});
+</script>

package/layer/app/components/oip-science/hcps/Informations.vue

@@ -0,0 +1,296 @@
+<!--
+  Onglet Informations de la fiche professionnel (porte de la page
+  hcps/[id]/informations de France Augmented Science).
+-->
+<template>
+  <div class="oip-science oip_grid gap-24">
+    <RmLoadingState v-if="isLoading" :lines="3" :chart-height="240" />
+    <RmEmptyState
+      v-if="!isLoading && !rppsData && !hcp"
+      :title="$t('oipScience.common.noDataTitle')"
+      :text="$t('oipScience.common.noDataText')"
+    />
+
+    <RmSectionCard v-if="!isLoading && (rppsData || hcp)" position="none" class="hcp-info-card">
+      <div class="oip_grid gap-24">
+        <div class="hcp-info-header" style="position: relative;">
+          <div class="hcp-dates-block">
+            <div class="oip_row v-center gap-8" v-if="principalEntryDate !== '-'">
+              <p class="kk_text cool_grey">{{ $t('oipScience.common.entry') }}:</p>
+              <p class="kk_text">{{ principalEntryDate }}</p>
+            </div>
+            <div class="oip_row v-center gap-8" v-if="updateDate">
+              <p class="kk_text cool_grey">{{ $t('oipScience.common.updateDate') }}:</p>
+              <p class="kk_text">{{ updateDate }}</p>
+            </div>
+          </div>
+
+          <div class="oip_grid gap-8">
+            <div class="oip_row v-center gap-8 wrap">
+              <RmTag
+                v-if="principalSpecialty"
+                variant="blue"
+              >
+                {{ principalSpecialty }}
+              </RmTag>
+              <RmTag
+                v-for="(spec, i) in secondarySpecialties"
+                :key="i"
+                variant="gray"
+              >
+                {{ spec }}
+              </RmTag>
+            </div>
+
+            <h1 class="kk_title_medium">{{ fullName }}</h1>
+
+            <div class="oip_row v-center gap-8 wrap">
+              <RmIcon name="IdentificationCard" color="var(--cool-grey)" :size="14" />
+              <p class="kk_text cool_grey">RPPS:</p>
+              <p class="kk_text">{{ ifNoRes(rppsCode) }}</p>
+              <p class="kk_text cool_grey" v-if="exerciceMode !== '-'">-</p>
+              <RmIcon v-if="exerciceMode !== '-'" name="Briefcase" color="var(--cool-grey)" :size="14" />
+              <p class="kk_text cool_grey" v-if="exerciceMode !== '-'">{{ $t('oipScience.common.exerciceMode') }}:</p>
+              <p class="kk_text" v-if="exerciceMode !== '-'">{{ exerciceMode }}</p>
+            </div>
+          </div>
+        </div>
+
+        <RmTable
+          v-if="tableContent.length"
+          flat
+          :columns="addressTable.columns"
+          :rows="addressTable.rows"
+        />
+      </div>
+    </RmSectionCard>
+
+    <div v-if="!isLoading && (rppsData || hcp)" class="hcp-kpi-row oip_row gap-16 wrap">
+      <div class="hcp-kpi-card" v-if="nctCount > 0">
+        <p class="hcp-kpi-label">🇺🇸 NCT</p>
+        <p class="hcp-kpi-value">{{ nctCount }}</p>
+        <p class="hcp-kpi-sub">{{ $t('oipScience.kpi.trials') }}</p>
+      </div>
+      <div class="hcp-kpi-card" v-if="euctCount > 0">
+        <p class="hcp-kpi-label">🇪🇺 EUCT (CTIS)</p>
+        <p class="hcp-kpi-value">{{ euctCount }}</p>
+        <p class="hcp-kpi-sub">{{ $t('oipScience.kpi.trials') }}</p>
+      </div>
+      <div class="hcp-kpi-card" v-if="pubmedCount > 0">
+        <p class="hcp-kpi-label">📚 PubMed</p>
+        <p class="hcp-kpi-value">{{ pubmedCount }}</p>
+        <p class="hcp-kpi-sub">{{ $t('oipScience.kpi.citations') }}</p>
+      </div>
+      <div class="hcp-kpi-card" v-if="aapCount > 0">
+        <p class="hcp-kpi-label">📋 {{ $t('oipScience.common.aap') }}</p>
+        <p class="hcp-kpi-value">{{ aapCount }}</p>
+        <p class="hcp-kpi-sub">{{ $t('oipScience.kpi.studies') }}</p>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import indexConfig from '../../../oip-science/indexConfig.json';
+import useOipElastic from '../../../oip-science/composables/useOipElastic';
+import { dateFormat, ifNoRes } from '../../../oip-science/utils/styleAndFormat';
+import { valueTable } from '../../../oip-science/utils/valueTable';
+
+const props = withDefaults(defineProps<{ id: string; highlight?: string[]; lang?: 'fr' | 'en' }>(), {
+  highlight: () => [],
+  lang: undefined,
+});
+
+const { t } = useI18n();
+const { queryOneElastic, queryCustomElastic } = useOipElastic();
+
+const tableHeads = computed(() => [t('oipScience.common.establishment'), t('oipScience.common.address'), t('oipScience.common.entryDate')]);
+
+const isLoading = ref(true);
+const hcp = ref<any>(null);
+const rppsData = ref<any>(null);
+const aapCount = ref(0);
+const pubmedCount = ref(0);
+const nctCount = ref(0);
+const euctCount = ref(0);
+
+async function load(urlId: string) {
+  isLoading.value = true;
+  hcp.value = null;
+  rppsData.value = null;
+  aapCount.value = 0;
+  try {
+    const [hcpRes, rppsRes, aapRes] = await Promise.all([
+      queryOneElastic({
+        index: indexConfig.hcps.index,
+        cluster: indexConfig.hcps.cluster,
+        path: 'hcp_code',
+        id: urlId,
+      }),
+      queryCustomElastic({
+        index: indexConfig.rpps.index,
+        cluster: indexConfig.rpps.cluster,
+        customQuery: {
+          size: 1,
+          query: { term: { 'hcp_code.keyword': urlId } },
+        },
+      }),
+      queryCustomElastic({
+        index: indexConfig.phrc.index,
+        cluster: indexConfig.phrc.cluster,
+        customQuery: {
+          size: 0,
+          query: { term: { 'hcp_code.keyword': urlId } },
+          track_total_hits: true,
+        },
+        allAnswer: true,
+      }),
+    ]);
+
+    hcp.value = hcpRes;
+    rppsData.value = rppsRes?.results?.[0] || null;
+    aapCount.value = aapRes?.hits?.total?.value || 0;
+    nctCount.value = hcpRes?.nct_trial_count || 0;
+    euctCount.value = hcpRes?.euct_trial_count || 0;
+    pubmedCount.value = hcpRes?.pubmed_trial_count || 0;
+  } catch (e) {
+    console.error(e);
+  } finally {
+    isLoading.value = false;
+  }
+}
+
+watch(() => props.id, (id) => { if (id) load(id); }, { immediate: true });
+
+// Use rppsData (new index) with fallback to hcp (old index)
+const src = computed(() => rppsData.value || null);
+
+const fullName = computed(() => {
+  const fallback = src.value || hcp.value;
+  if (!fallback) return '';
+  return `${fallback.hcp_family_name || ''} ${fallback.hcp_first_name || ''}`.trim().toUpperCase();
+});
+
+const allSpecialties = computed(() => {
+  const specs = src.value?.specialty || hcp.value?.specialty;
+  return Array.isArray(specs) ? specs : [];
+});
+
+const principalSpecialty = computed(() => {
+  const principal = allSpecialties.value.find((s: any) => s.hcp_specialty_type === 'PRINCIPAL');
+  return principal?.hcp_specialty_label_regroup || null;
+});
+
+const secondarySpecialties = computed(() => {
+  return allSpecialties.value
+    .filter((s: any) => s.hcp_specialty_type !== 'PRINCIPAL')
+    .map((s: any) => s.hcp_specialty_label_regroup)
+    .filter(Boolean);
+});
+
+const principalEntryDate = computed(() => {
+  const principal = allSpecialties.value.find((s: any) => s.hcp_specialty_type === 'PRINCIPAL');
+  return principal?.hcp_specialty_entry_date ? dateFormat(principal.hcp_specialty_entry_date, props.lang) : '-';
+});
+
+const updateDate = computed(() => {
+  const raw = src.value?.update_date || hcp.value?.update_date;
+  return raw ? dateFormat(raw, props.lang) : null;
+});
+
+const exerciceMode = computed(() => {
+  return src.value?.hcp_exercice_mode || hcp.value?.hcp_exercice_mode || '-';
+});
+
+const rppsCode = computed(() => {
+  return src.value?.hcp_code || hcp.value?.hcp_code || props.id;
+});
+
+const addresses = computed(() => {
+  const addrs = src.value?.address || hcp.value?.address;
+  if (!Array.isArray(addrs)) return [];
+  return [...addrs].sort((a, b) => {
+    const da = a?.hcp_address_entry_date || '';
+    const db = b?.hcp_address_entry_date || '';
+    return db.localeCompare(da);
+  });
+});
+
+const tableContent = computed(() => {
+  return addresses.value
+    .filter((a: any) => a?.hco_et_label || a?.hcp_city)
+    .map((a: any) => {
+      const streetParts = [
+        a?.hcp_street_number,
+        a?.hcp_street_type_code,
+        a?.hcp_street_label,
+      ].filter(Boolean);
+      const street = streetParts.join(' ').trim();
+      const cityPart = [a?.hcp_zip_code, a?.hcp_city].filter(Boolean).join(' ');
+      const address = [street, cityPart].filter(Boolean).join(' - ') || cityPart || '-';
+      return {
+        values: [
+          a?.hco_et_label || '-',
+          address,
+          a?.hcp_address_entry_date ? dateFormat(a.hcp_address_entry_date, props.lang) : '-',
+        ],
+      };
+    });
+});
+
+const addressTable = computed(() =>
+  valueTable(tableHeads.value, tableContent.value, undefined, {
+    align: ['left', 'left', 'left'],
+  }),
+);
+</script>
+
+<style scoped>
+.hcp-info-card :deep(.card_content) {
+  padding: 0;
+}
+.hcp-info-header {
+  padding: 24px 24px 0 24px;
+}
+.hcp-dates-block {
+  position: absolute;
+  top: 24px;
+  right: 24px;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 4px;
+}
+.hcp-kpi-card {
+  flex: 1 1 0;
+  min-width: 140px;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  gap: 4px;
+  padding: 16px 20px;
+  background: var(--white);
+  border: 1px solid var(--Main-Light, var(--border-default));
+  border-radius: 12px;
+  box-shadow: var(--small-shadow);
+}
+.hcp-kpi-label {
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--text-muted);
+  white-space: nowrap;
+}
+.hcp-kpi-value {
+  font-size: 22px;
+  font-weight: 700;
+  color: var(--text-primary);
+}
+.hcp-kpi-sub {
+  font-size: 11px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+</style>

package/layer/app/components/oip-science/hcps/LinkedList.vue

@@ -0,0 +1,153 @@
+<!--
+  Liste de personnes liees a une fiche (investigateurs d'un essai, auteurs
+  d'une publication, professionnels rapproches). Une personne reconnue dans
+  l'annuaire RPPS a la carte de la page /hcps ; les autres gardent le meme
+  gabarit, sans lien. Filtre local et affichage par paquets : un essai peut
+  lister des centaines de contacts. (Portage de components/hcps/LinkedList.vue
+  de France Augmented Science.)
+-->
+<template>
+  <div class="oip-science">
+    <div v-if="!loading && !isLoadingDocs" class="oip_grid gap-16">
+      <RmSearchBar
+        v-model="searchText"
+        :placeholder="$t('oipScience.common.searchTrialInvestigators')"
+        :have-advanced="false"
+      />
+
+      <RmResultsLine icon="UserCircle" :items="[{ count: filtered.length, label: $t('oipScience.resultKpis.hcps', filtered.length) }]" />
+      <div class="oip_grid gap-8">
+        <template v-for="(person, index) in visible" :key="index">
+          <OipScienceHcpsCards
+            v-if="person.rpps && hcpDocs.get(person.rpps)"
+            :data="hcpDocs.get(person.rpps)"
+          >
+            <template #extra>
+              <RmTag v-if="person.role" variant="gray">{{ person.role }}</RmTag>
+              <OipScienceCommonScoreBadge :score="person.score" />
+            </template>
+          </OipScienceHcpsCards>
+
+          <RmResultCard v-else :actions="false">
+            <template #title>{{ ifNoRes(person.name) }}</template>
+            <template #subtitle>
+              {{ $t('oipScience.common.city') }}: {{ ifNoRes(person.city) }}
+              <template v-if="person.facility"> · {{ person.facility }}</template>
+            </template>
+            <template #meta>
+              <RmTag v-if="person.role" variant="gray">{{ person.role }}</RmTag>
+              <RmTag v-if="person.country" variant="gray" class="no-wrap">
+                {{ getCountryEmoji(person.country) }}
+              </RmTag>
+            </template>
+            <template #footer>
+              <OipScienceCommonSource :sources="sources" />
+            </template>
+          </RmResultCard>
+        </template>
+      </div>
+
+      <RmEmptyState v-if="!filtered.length" :title="$t('oipScience.common.noMatchingResult')" />
+      <RmButton
+        v-if="visible.length < filtered.length"
+        variant="secondary"
+        class="load_more"
+        @click="displayCount += PAGE_SIZE"
+      >{{ $t('oipScience.common.loadMore') }}</RmButton>
+    </div>
+    <RmLoadingState v-else :lines="3" :chart-height="240" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import indexConfig from '../../../oip-science/indexConfig.json';
+import useOipElastic from '../../../oip-science/composables/useOipElastic';
+import useAuthorMatching from '../../../oip-science/composables/useAuthorMatching';
+import { getCountryEmoji, ifNoRes } from '../../../oip-science/utils/styleAndFormat';
+
+export type LinkedPerson = {
+  name: string | null;
+  role?: string | null;
+  facility?: string | null;
+  city?: string | null;
+  country?: string | null;
+  rpps?: string | null;
+  score?: number | null;
+};
+
+const props = withDefaults(
+  defineProps<{
+    people: LinkedPerson[];
+    title: string;
+    sources: string[];
+    indexLastUpdate: string;
+    loading?: boolean;
+  }>(),
+  { loading: false },
+);
+
+const { normalize } = useAuthorMatching();
+const { queryCustomElastic } = useOipElastic();
+
+// Fiches annuaire des personnes reconnues, en une seule requete.
+const hcpDocs = ref<Map<string, any>>(new Map());
+const isLoadingDocs = ref(false);
+
+async function loadHcpDocs(codes: (string | null | undefined)[]) {
+  const ids = [...new Set(codes.filter((x): x is string => !!x))].filter(
+    (id) => !hcpDocs.value.has(id),
+  );
+  if (!ids.length) return;
+  isLoadingDocs.value = true;
+  try {
+    const res = await queryCustomElastic({
+      index: indexConfig.hcps.index,
+      cluster: indexConfig.hcps.cluster,
+      customQuery: {
+        size: ids.length,
+        query: { terms: { hcp_code: ids } },
+      },
+    });
+    const map = new Map(hcpDocs.value);
+    for (const doc of res?.results || []) {
+      if (doc?.hcp_code) map.set(String(doc.hcp_code), doc);
+    }
+    hcpDocs.value = map;
+  } finally {
+    isLoadingDocs.value = false;
+  }
+}
+
+watch(
+  () => props.people.map((p) => p.rpps),
+  (codes) => loadHcpDocs(codes),
+  { immediate: true },
+);
+
+const searchText = ref('');
+const PAGE_SIZE = 20;
+const displayCount = ref(PAGE_SIZE);
+
+const filtered = computed(() => {
+  const q = normalize(searchText.value);
+  if (!q) return props.people;
+  return props.people.filter((p) =>
+    normalize(
+      [p.name, p.role, p.facility, p.city, p.country, p.rpps].filter(Boolean).join(' '),
+    ).includes(q),
+  );
+});
+
+const visible = computed(() => filtered.value.slice(0, displayCount.value));
+
+watch(searchText, () => {
+  displayCount.value = PAGE_SIZE;
+});
+</script>
+
+<style scoped>
+.load_more {
+  align-self: center;
+  justify-self: center;
+}
+</style>