@tekkare/romulus 0.1.251 → 0.1.252

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

@@ -0,0 +1,207 @@
+<!--
+  Onglet Labels matches de la fiche professionnel (porte de la page
+  hcps/[id]/matched-labels de France Augmented Science). Dans FAS l'en-tete
+  chargeait le document (useState('current-hcp')) : l'onglet le relit lui-meme.
+  Le menu d'export de la carte (payload useGenerateExcel) est retire.
+-->
+<template>
+  <div class="oip-science">
+    <RmLoadingState v-if="isLoading" :lines="3" :chart-height="240" />
+    <RmTableCard v-if="!isLoading && hcp" :lang="lang">
+      <template #header>
+        <div>
+          <h3 class="rm-table-card__title">{{ $t('oipScience.common.matchedLabels') }}</h3>
+          <p class="rm-table-card__context">{{ uniqueRows.length }} {{ $t('oipScience.common.results') }}</p>
+          <OipScienceCommonSource :sources="['CT.gov', 'EUCT', 'PubMed']" :lang="lang" />
+        </div>
+        <div class="match-stats">
+            <div class="match-stat">
+              <p class="match-stat-label">{{ $t('oipScience.common.matchedLabels') }}</p>
+              <p class="match-stat-value">{{ uniqueRows.length }}</p>
+            </div>
+            <div class="match-stat">
+              <p class="match-stat-label">Score moyen</p>
+              <p class="match-stat-value">
+                <span
+                  class="match-stat-pill"
+                  :class="avgScorePct >= 80 ? 'high' : 'low'"
+                >{{ avgScorePct }}%</span>
+              </p>
+          </div>
+        </div>
+      </template>
+      <RmTable :columns="table.columns" :rows="table.rows" search>
+        <template v-for="key in table.typeKeys.Source" :key="key" #[key]="{ value }">
+          <RmTag class="no-wrap" :variant="sourceTagStyle(value)">
+            {{ sourceTagLabel(value) }}
+          </RmTag>
+        </template>
+        <template v-for="key in table.typeKeys.Score" :key="key" #[key]="{ value }">
+          <span
+            v-if="typeof value === 'number'"
+            class="score-badge"
+            :class="value >= 0.8 ? 'score-high' : 'score-low'"
+            :data-tooltip="$t('oipScience.common.matchingScoreTooltip')"
+          >{{ Math.round(value * 100) }}%</span>
+          <span v-else>-</span>
+        </template>
+      </RmTable>
+    </RmTableCard>
+    <RmEmptyState
+      v-if="!isLoading && hcp && uniqueRows.length === 0"
+      :title="$t('oipScience.common.noDataTitle')"
+      :text="$t('oipScience.common.noDataText')"
+    />
+  </div>
+</template>
+
+<script setup lang="ts">
+import indexConfig from '../../../oip-science/indexConfig.json';
+import useOipElastic from '../../../oip-science/composables/useOipElastic';
+import { valueTable } from '../../../oip-science/utils/valueTable';
+import { formatMatchMethod } from '../../../oip-science/utils/matchMethod';
+
+const props = withDefaults(defineProps<{ id: string; highlight?: string[]; lang?: 'fr' | 'en' }>(), {
+  highlight: () => [],
+  lang: undefined,
+});
+
+const { t } = useI18n();
+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 });
+
+type Source = 'NCT' | 'EUCT' | 'PubMed';
+type Row = { name: string; source: Source; match_method: string | null; score: number };
+
+// Dedupe by (name, source). Keep highest score per unique pair.
+const uniqueRows = computed<Row[]>(() => {
+  const h = hcp.value;
+  if (!h) return [];
+  const byKey = new Map<string, Row>();
+  const collect = (entries: any[] | null | undefined, source: Source) => {
+    if (!Array.isArray(entries)) return;
+    for (const m of entries) {
+      const name = m?.name || [m?.first_name, m?.last_name].filter(Boolean).join(' ').trim();
+      if (!name || typeof m?.score !== 'number') continue;
+      const key = `${source}|${name}`;
+      const existing = byKey.get(key);
+      if (!existing || (m.score ?? 0) > (existing.score ?? 0)) {
+        byKey.set(key, {
+          name,
+          source,
+          match_method: m.match_method ?? null,
+          score: m.score,
+        });
+      }
+    }
+  };
+  collect(h.nct_name, 'NCT');
+  collect(h.euct_name, 'EUCT');
+  collect(h.pubmed_name, 'PubMed');
+  return [...byKey.values()].sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+});
+
+const avgScorePct = computed(() => {
+  if (uniqueRows.value.length === 0) return 0;
+  const sum = uniqueRows.value.reduce((acc, r) => acc + (r.score || 0), 0);
+  return Math.round((sum / uniqueRows.value.length) * 100);
+});
+
+function sourceTagStyle(source: string): string {
+  if (source === 'NCT') return 'blue';
+  if (source === 'EUCT') return 'purple';
+  return 'green';
+}
+function sourceTagLabel(source: string): string {
+  if (source === 'NCT') return '🇺🇸 NCT';
+  if (source === 'EUCT') return '🇪🇺 EUCT';
+  return '📚 PubMed';
+}
+
+const getContent = computed(() =>
+  uniqueRows.value.map((r) => ({
+    values: [r.name, r.source, formatMatchMethod(r.match_method), r.score],
+  })),
+);
+
+const table = computed(() =>
+  valueTable(
+    [t('oipScience.common.name'), 'Source', t('oipScience.common.matchType'), t('oipScience.common.confidenceScore')],
+    getContent.value,
+    ['', 'Source', '', 'Score'],
+    { align: ['left', 'left', 'left', 'right'] },
+  ),
+);
+</script>
+
+<style scoped>
+.match-stats {
+  display: flex;
+  gap: 24px;
+  align-items: center;
+}
+.match-stat {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 2px;
+}
+.match-stat-label {
+  font-size: 11px;
+  color: var(--text-muted);
+  text-transform: uppercase;
+  letter-spacing: 0.5px;
+}
+.match-stat-value {
+  font-size: 18px;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin: 0;
+}
+.match-stat-pill {
+  display: inline-block;
+  padding: 2px 10px;
+  border-radius: 999px;
+  font-size: 14px;
+  font-variant-numeric: tabular-nums;
+}
+.match-stat-pill.high {
+  background: var(--color-success-bg);
+  color: var(--color-success);
+}
+.match-stat-pill.low {
+  background: var(--color-warning-bg);
+  color: var(--color-warning);
+}
+.score-badge {
+  display: inline-block;
+  padding: 2px 8px;
+  border-radius: 12px;
+  font-size: 12px;
+  font-weight: 600;
+  cursor: help;
+}
+.score-high { background: var(--color-success-bg); color: var(--color-success); }
+.score-low { background: var(--color-warning-bg); color: var(--color-warning); }
+</style>

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

@@ -0,0 +1,128 @@
+<!--
+  Onglet PubMed de la fiche professionnel (porte de la page hcps/[id]/pubmed
+  de France Augmented Science).
+-->
+<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"
+          :match-score="scoreByPmid[res.PubMed_ID] ?? null"
+          :match-method="methodByPmid[res.PubMed_ID] || null"
+          :highlight="highlight"
+        />
+      </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 useOipElastic from '../../../oip-science/composables/useOipElastic';
+
+const props = withDefaults(defineProps<{ id: string; highlight?: string[]; lang?: 'fr' | 'en' }>(), {
+  highlight: () => [],
+  lang: undefined,
+});
+
+const { queryCustomElastic, queryOneElastic } = useOipElastic();
+
+const isLoading = ref(true);
+const pubmedResults = ref<any[]>([]);
+const scoreByPmid = ref<Record<string, number | null>>({});
+const methodByPmid = ref<Record<string, string | null>>({});
+
+async function load(urlId: string) {
+  isLoading.value = true;
+  pubmedResults.value = [];
+  scoreByPmid.value = {};
+  methodByPmid.value = {};
+  try {
+    // Pull pubmed_trial[] directly from the new HCP directory doc
+    const hcp: any = await queryOneElastic({
+      index: indexConfig.hcps.index,
+      cluster: indexConfig.hcps.cluster,
+      path: 'hcp_code',
+      id: urlId,
+    });
+
+    const pubmedIds = [
+      ...new Set(
+        (hcp?.pubmed_trial || [])
+          .map((t: any) => t?.clinical_trial_id)
+          .filter(Boolean),
+      ),
+    ] as string[];
+
+    if (pubmedIds.length === 0) return;
+
+    // Fetch per-paper match scores for this HCP from the per-trial hcpPubmed index
+    const scoresRes = await queryCustomElastic({
+      index: indexConfig.hcpPubmed.index,
+      cluster: indexConfig.hcpPubmed.cluster,
+      customQuery: {
+        size: pubmedIds.length,
+        _source: ['PubMed_ID', 'hcp.hcp_code', 'hcp.score', 'hcp.match_method'],
+        query: {
+          bool: {
+            must: [
+              { terms: { PubMed_ID: pubmedIds } },
+              {
+                nested: {
+                  path: 'hcp',
+                  query: { term: { 'hcp.hcp_code.keyword': urlId } },
+                },
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    const scoreMap: Record<string, number | null> = {};
+    const methodMap: Record<string, string | null> = {};
+    for (const doc of scoresRes?.results || []) {
+      if (!doc?.PubMed_ID) continue;
+      const matched = (doc?.hcp || []).find((h: any) => h?.hcp_code === urlId);
+      if (matched) {
+        scoreMap[doc.PubMed_ID] = typeof matched.score === 'number' ? matched.score : null;
+        methodMap[doc.PubMed_ID] = matched.match_method || null;
+      }
+    }
+    scoreByPmid.value = scoreMap;
+    methodByPmid.value = methodMap;
+
+    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;
+  }
+}
+
+watch(() => props.id, (id) => { if (id) load(id); }, { immediate: true });
+</script>

package/layer/app/components/oip-science/local/SliderTabs.vue

@@ -0,0 +1,99 @@
+<!--
+  Onglets segmentes d'une liste (anciennement LocalSliderTabs de France
+  Augmented Science). L'onglet choisi va dans le contexte de la liste parente
+  (c-filterContext).
+-->
+<template>
+  <div>
+    <OipScienceLocalSliderTabsFull
+      v-if="isFullWidth"
+      :tabs="tabs"
+      :active-tab="selectedItem"
+      :switch-tab="changeSelectValue"
+      :sliderId="sliderId"
+    />
+
+    <RmSegmented
+      v-else
+      :model-value="selectedItem"
+      :options="indexedSegments(tabs)"
+      @update:model-value="changeSelectValue"
+    />
+  </div>
+</template>
+<script setup lang="ts">
+import { useOipFilterContext } from '../../../oip-science/utils/c-filterContext';
+import { indexedSegments } from '../../../oip-science/utils/sliderTabs';
+
+const filterContext = useOipFilterContext();
+
+const emit = defineEmits(['changeElement']);
+
+const props = defineProps({
+  filterValues: {
+    type: [Array, String, Function],
+    required: true,
+  },
+
+  filterName: {
+    type: String,
+    required: true,
+  },
+
+  keyName: {
+    type: String,
+    required: false,
+    default: null,
+  },
+
+  tabs: {
+    type: Array,
+    required: false,
+    default: [
+      { label: 'List', icon: 'List' },
+      { label: 'Dashboard', icon: 'SquaresFour' },
+    ],
+  },
+  sliderId: {
+    type: String,
+    required: false,
+    default: 'sliderTabs',
+  },
+  isFullWidth: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+});
+
+const selectedItem = ref(0 as Number);
+
+onMounted(() => {
+  selectedItem.value =
+    (props.filterValues as number[]).length > 0
+      ? (props.filterValues as number[])[0]
+      : 0;
+});
+
+watch(
+  () => selectedItem.value,
+  (val) => {
+    filterContext.setAppFilters({
+      filter: props.filterName,
+      keyName: props.keyName,
+      values: val != 0 ? [val] : [],
+    });
+    emit('changeElement', val);
+  }
+);
+
+const changeSelectValue = (val: any) => {
+  selectedItem.value = val;
+};
+</script>
+
+<style>
+.oip-science .isFullWidth > div > .wrapper {
+  width: 100% !important;
+}
+</style>

package/layer/app/components/oip-science/local/SliderTabsFull.vue

@@ -0,0 +1,135 @@
+<!-- Onglets pleine largeur a indicateur glissant (anciennement LocalSliderTabsFull de FAS). -->
+<template>
+  <div class="oip_row">
+    <div class="slider-tabs-columns wrapper relative">
+      <div
+        v-for="(tab, index) in tabs"
+        :key="index"
+        class="slider-tab-column"
+        :style="{ width: 100 / tabs.length + '%' }"
+        @click="updateButton(index)"
+      >
+        <div
+          :id="sliderId + tab.label + index"
+          :class="{ 'slider-tab-active': index === activeTab }"
+        >
+          <div class="slider-tab-label">
+            {{ tab.label }}
+          </div>
+        </div>
+      </div>
+
+      <!-- Barre d'indication animée -->
+      <div
+        class="slider-tab-indicator"
+        :style="{
+          width: `calc(${100 / tabs.length}% - ${4 / tabs.length}px)`,
+          transform: `translateX(calc(${activeTab * 100}% + ${
+            activeTab * (4 / tabs.length)
+          }px))`,
+        }"
+      ></div>
+    </div>
+  </div>
+</template>
+
+<script lang="ts">
+import { defineComponent } from 'vue';
+
+interface Tab {
+  label: string;
+  icon?: string;
+}
+type Tabs = Array<Tab>;
+
+export default defineComponent({
+  name: 'OipScienceLocalSliderTabsFull',
+
+  props: {
+    tabs: {
+      type: Array as () => Tabs,
+      required: true,
+      default: () => [{ label: '' }],
+    },
+    activeTab: {
+      type: Number,
+      required: true,
+      default: 0,
+    },
+    switchTab: {
+      type: Function,
+      required: true,
+    },
+    sliderId: {
+      type: String,
+      default: 'slider',
+    },
+  },
+
+  setup(props) {
+    const updateButton = (value: number) => {
+      props.switchTab(value);
+    };
+
+    return { updateButton };
+  },
+});
+</script>
+
+<style scoped>
+.wrapper {
+  border-radius: 8px;
+  border: 1px solid rgba(82, 86, 112, 0.1);
+  background: rgba(82, 86, 112, 0.04);
+  padding: 2px;
+  width: 100%;
+  box-sizing: border-box;
+  display: flex;
+  justify-content: center;
+  position: relative;
+  overflow: hidden;
+}
+
+.slider-tabs-columns {
+  display: flex;
+  width: 100%;
+  position: relative;
+}
+
+.slider-tab-column {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  cursor: pointer;
+  z-index: 2;
+  height: 30px;
+}
+
+.slider-tab-label {
+  text-align: center;
+  color: var(--Main-Dark, var(--text-secondary));
+  font-family: Figtree;
+  font-size: 14px;
+  font-weight: 500;
+  z-index: 2;
+}
+
+.slider-tab-active .slider-tab-label {
+  color: var(--white);
+}
+
+.slider-tab-active {
+  z-index: 3;
+}
+
+.slider-tab-indicator {
+  position: absolute;
+  bottom: 2px;
+  left: 2px;
+  height: calc(100% - 4px);
+  border-radius: 8px;
+  background: var(--primary);
+  transition: all 0.4s ease;
+  z-index: 1;
+}
+</style>

package/layer/app/components/oip-science/pubmed/Authors.vue

@@ -0,0 +1,128 @@
+<!--
+  Onglet « Auteurs » d'une publication PubMed (portage de la page
+  /pubmed/[id]/authors de France Augmented Science). Les auteurs de la
+  publication, rapproches des professionnels de sante par l'index.
+-->
+<template>
+  <div class="oip-science">
+    <OipScienceHcpsLinkedList
+      v-if="!loaded || isLoadingQueryPubmed || resultsQueryPubmed"
+      :people="people"
+      :title="$t('oipScience.publication.authors')"
+      :sources="['PubMed']"
+      index-last-update="PubMed"
+      :loading="!loaded || isLoadingQueryPubmed || isLoadingMatches"
+    />
+    <RmEmptyState v-else :title="$t('oipScience.common.noDataTitle')" :text="$t('oipScience.common.noDataText')" />
+  </div>
+</template>
+
+<script setup lang="ts">
+import usePubmed from '../../../oip-science/composables/usePubmed';
+import useAuthorMatching from '../../../oip-science/composables/useAuthorMatching';
+import type { LinkedPerson } from '../hcps/LinkedList.vue';
+
+const props = withDefaults(
+  defineProps<{
+    /** PMID de la publication. */
+    id: string;
+    highlight?: string[];
+    lang?: 'fr' | 'en';
+  }>(),
+  { highlight: () => [], lang: 'fr' },
+);
+
+const { findPubmedById, resultsQueryPubmed, isLoadingQueryPubmed } = usePubmed();
+const { fetchPubmedAuthorMatches, normalize } = useAuthorMatching();
+
+type PubmedHcpMatch = Awaited<ReturnType<typeof fetchPubmedAuthorMatches>>[number];
+const pubmedMatches = ref<PubmedHcpMatch[]>([]);
+const matchByName = ref<Map<string, PubmedHcpMatch>>(new Map());
+const isLoadingMatches = ref(true);
+// Le composable part a `false` : sans ce drapeau, l'etat vide sortirait avant la requete.
+const loaded = ref(false);
+
+async function load() {
+  if (!props.id) return;
+  const id = props.id.toString();
+  isLoadingMatches.value = true;
+  try {
+    await findPubmedById({ id, source: ['authors'] });
+    pubmedMatches.value = await fetchPubmedAuthorMatches(id);
+    const map = new Map<string, PubmedHcpMatch>();
+    for (const m of pubmedMatches.value) {
+      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);
+    }
+    matchByName.value = map;
+  } finally {
+    isLoadingMatches.value = false;
+    loaded.value = true;
+  }
+}
+
+onMounted(load);
+watch(() => props.id, load);
+
+function findMatch(name: string): PubmedHcpMatch | null {
+  const n = normalize(name);
+  if (!n) return null;
+  const direct = matchByName.value.get(n);
+  if (direct) return direct;
+  for (const m of pubmedMatches.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;
+}
+
+const people = computed<LinkedPerson[]>(() => {
+  const seen = new Set<string>();
+  const rows: LinkedPerson[] = (((resultsQueryPubmed.value as any)?.authors as any[]) || []).map((item) => {
+    const fullName = `${item.forename || ''} ${item.lastname || ''}`.trim();
+    const m = findMatch(fullName);
+    if (m) seen.add(m.hcp_code);
+    const primary = (m?.address || []).find((a: any) => a?.hco_et_code) || null;
+    return {
+      name: fullName || null,
+      facility: item.affiliation || primary?.hco_et_label || null,
+      city: primary?.city || null,
+      rpps: m?.hcp_code || null,
+      score: m?.score ?? null,
+    };
+  });
+
+  // Professionnels rapproches par l'index mais absents de la liste d'auteurs.
+  for (const m of pubmedMatches.value) {
+    if (seen.has(m.hcp_code)) continue;
+    const primary = (m.address || []).find((a: any) => a?.hco_et_code) || null;
+    rows.push({
+      name: `${m.first_name} ${m.family_name}`.trim(),
+      facility: primary?.hco_et_label || null,
+      city: primary?.city || null,
+      country: 'France',
+      rpps: m.hcp_code,
+      score: m.score,
+    });
+  }
+
+  // Une personne par RPPS, sinon par nom.
+  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()];
+});
+</script>