@tekkare/romulus 0.1.250 → 0.1.252

package/layer/app/oip-drugs/composables/useHeartBrandMatches.ts

@@ -0,0 +1,112 @@
+/**
+ * Correspondances de la recherche sur une marque, pour la fiche produit.
+ *
+ * La clause deposee par la liste est rejouee ici, restreinte a la marque
+ * affichee et avec des inner hits elargis : le moteur renvoie alors TOUS les
+ * avis qui repondent aux termes, et non l'echantillon suffisant a une carte.
+ * C'est ce qui permet de marquer chaque avis de l'historique.
+ */
+import { oipEsSearch } from "../../composables/useOipResources";
+import { heartExplainMatch } from "./useHeartMatchExplain";
+import type { MatchExplain } from "./useHeartMatchExplain";
+
+/** Le contexte que la liste de fr_drugs_app depose (cf. useHeartSearchContext). */
+type HeartSearchContext = {
+  /** Termes saisis, pour le surlignage du texte. */
+  terms: string[];
+  /** Clause ES de la recherche, inner hits compris. */
+  clause: any;
+};
+
+/** Meme cle que fr_drugs_app : la fiche montee dans l'app y relit le contexte. */
+const STORAGE_KEY = "oip-heart-search-context";
+
+/**
+ * Lecture seule du contexte de recherche (portage de `readStored` de
+ * useHeartSearchContext) : seule la liste l'ecrit, la fiche ne fait que le relire.
+ */
+function useStoredSearchContext() {
+  const context = useState<HeartSearchContext | null>(STORAGE_KEY, () => null);
+
+  function readStored() {
+    if (context.value) return context.value;
+    try {
+      const raw = sessionStorage.getItem(STORAGE_KEY);
+      if (raw) context.value = JSON.parse(raw);
+    } catch {
+      // Session illisible : la fiche s'affiche sans explication.
+    }
+    return context.value;
+  }
+
+  return { readStored };
+}
+
+/** Remonte la taille des inner hits d'une clause, sans toucher a l'originale. */
+function withLargeInnerHits(clause: any, size: number): any {
+  if (Array.isArray(clause)) return clause.map((item) => withLargeInnerHits(item, size));
+  if (!clause || typeof clause !== "object") return clause;
+
+  const copy: any = {};
+  for (const [key, value] of Object.entries<any>(clause)) {
+    if (key === "inner_hits" && value && typeof value === "object") {
+      copy[key] = { ...value, size };
+      continue;
+    }
+    copy[key] = withLargeInnerHits(value, size);
+  }
+  return copy;
+}
+
+export default function useHeartBrandMatches() {
+  const { locale } = useI18n();
+  const { readStored } = useStoredSearchContext();
+
+  const explain = ref<MatchExplain | null>(null);
+  const terms = ref<string[]>([]);
+
+  /**
+   * Interroge le moteur pour la marque donnee. Sans recherche en cours, ne
+   * lance rien et laisse l'explication vide.
+   */
+  async function load(brandGroup: string, index: string) {
+    const context = readStored();
+    if (!context || !brandGroup) {
+      explain.value = null;
+      terms.value = [];
+      return;
+    }
+
+    const body = {
+      size: 1,
+      _source: ["brand_group"],
+      query: {
+        bool: {
+          // `and` : tous les mots de la marque, sinon « KEYTRUDA » ramenait
+          // n'importe quelle marque partageant un mot avec elle.
+          must: [
+            { match: { brand_group: { query: brandGroup, operator: "and" } } },
+            withLargeInnerHits(context.clause, 100),
+          ],
+        },
+      },
+    };
+
+    try {
+      const res: any = await oipEsSearch("drugs", index, body);
+      const hit = res?.hits?.hits?.[0];
+      explain.value = hit ? heartExplainMatch(hit, locale.value) : null;
+      // Le contexte survit en sessionStorage : sans avis de cette marque qui
+      // reponde a la recherche, il vient d'une autre fiche, on ne surligne rien.
+      terms.value = hit ? context.terms : [];
+    } catch (error: any) {
+      console.warn("[heart] match explain failed:", error?.message || error);
+      explain.value = null;
+    }
+  }
+
+  /** Codes HAS des avis qui repondent a la recherche. */
+  const matchedCodes = computed(() => new Set(explain.value?.hasCodes ?? []));
+
+  return { explain, terms, matchedCodes, load };
+}

package/layer/app/oip-drugs/composables/useHeartDetailSearches.ts

@@ -0,0 +1,479 @@
+import type { MaybeRefOrGetter } from "vue";
+
+// Portage de useHeartDetailSearches de fr_drugs_app : les termes ne se lisent
+// plus dans le filterStore de l'app, ils arrivent par la prop `highlight` de
+// la fiche (cf. PORTING.md).
+
+const STOP_WORDS = new Set([
+  // French
+  "le", "la", "les", "de", "des", "du", "un", "une", "en", "et", "à", "au", "aux",
+  "ce", "ces", "cette", "par", "pour", "sur", "avec", "dans", "est", "sont",
+  "qui", "que", "dont", "où", "ne", "pas", "plus", "ou", "se", "son", "sa", "ses",
+  "l", "d", "n", "s", "qu",
+  // English
+  "the", "a", "an", "of", "in", "on", "at", "to", "for", "and", "or", "but",
+  "is", "are", "was", "were", "be", "it", "its", "this", "that", "not", "no",
+]);
+
+/**
+ * Split raw search terms into individual words and filter stop words
+ */
+export function heartSplitSearchTerms(rawSearches: any): string[] {
+  // Les appelants lisent le filterStore, qui n'est pas type : la valeur peut
+  // etre une liste de termes, un terme seul, ou une clause deja construite.
+  const list = Array.isArray(rawSearches) ? rawSearches : rawSearches ? [rawSearches] : [];
+  const terms = list
+    .map((a: any) => (a && typeof a === "object" ? a.value : a))
+    .filter((a: any) => typeof a === "string");
+  const words = terms
+    .flatMap((term: string) => term.split(/\s+/))
+    .filter(
+      (word: string) => word.length > 1 && !STOP_WORDS.has(word.toLowerCase())
+    );
+  return [...new Set(words)];
+}
+
+/**
+ * Termes de recherche de la fiche, decoupes en mots sans mots vides. Dans
+ * fr_drugs_app ils venaient des filtres « Search Filter » de toutes les pages
+ * de recherche ; ici, de la prop `highlight` passee par l'appelant.
+ */
+export function useHeartDetailSearches(highlight?: MaybeRefOrGetter<string[] | undefined>) {
+  const getSearches = computed(() => heartSplitSearchTerms(toValue(highlight) ?? []));
+
+  return { getSearches };
+}
+
+// --- Filter match utilities ---
+
+/**
+ * Extract disease names from rare disease filter values by stripping ORPHA codes.
+ * e.g. "Maladie de Fabry (ORPHA:324)" → "Maladie de Fabry"
+ */
+export function heartGetRareHighlightTerms(filterValues: string[]): string[] {
+  if (!filterValues || filterValues.length === 0) return [];
+  return filterValues
+    .map((v) => v.replace(/\s*\(ORPHA:\d+\)\s*/gi, "").trim())
+    .filter((v) => v.length > 0);
+}
+
+// --- Oncology tagging utilities (based on section data) ---
+
+/**
+ * Map ES field paths (from oncology_tagging section.matched_field) to FIELD_DEFS labels.
+ */
+const MATCHED_FIELD_MAP: Record<string, string> = {
+  "brand_history.indication": "indication",
+  "brand_history.indication_en": "indication",
+  "brand_history.syn_indication": "indication",
+  "brand_history.syn_indication_en": "indication",
+  "brand_history.relevant_indication": "indication",
+  "brand_history.relevant_indication_en": "indication",
+  "brand_history.essential": "essential",
+  "brand_history.essential_en": "essential",
+  "brand_history.conclusion": "conclusion",
+  "brand_history.conclusion_en": "conclusion",
+  "brand_history.target_population": "target_population",
+  "brand_history.target_population_en": "target_population",
+  "brand_history.syn_target_pop": "target_population",
+  "brand_history.syn_target_pop_en": "target_population",
+  "brand_history.therapeutic_strategy_place": "therapeutic_strategy_place",
+  "brand_history.therapeutic_strategy_place_en": "therapeutic_strategy_place",
+};
+
+function fieldDefFromKey(key: string, locale: string): { label: string; tab: string | null } | null {
+  const mapped = MATCHED_FIELD_MAP[key];
+  if (!mapped) return null;
+  const def = FIELD_DEFS.find((d) => d.fields.includes(mapped));
+  if (!def) return null;
+  return { label: locale === "en" ? def.labelEn : def.labelFr, tab: def.tab };
+}
+
+/**
+ * Extract highlight words (from <em> tags) for the tags matching the given filter values.
+ */
+export function heartGetTaggingHighlightWords(tagging: any[], filterValues: string[]): string[] {
+  if (!tagging || !Array.isArray(tagging) || !filterValues || filterValues.length === 0) return [];
+
+  const filterSet = new Set(filterValues.map((v) => v.toLowerCase().trim()));
+  const words = new Set<string>();
+
+  for (const tag of tagging) {
+    const tagLabels: string[] = [];
+    if (tag.preferred_label) tagLabels.push(tag.preferred_label.toLowerCase().trim());
+    if (tag.icd10 && Array.isArray(tag.icd10)) {
+      for (const icd of tag.icd10) {
+        if (icd.combined_label) tagLabels.push(icd.combined_label.toLowerCase().trim());
+      }
+    }
+
+    if (!tagLabels.some((tl) => filterSet.has(tl))) continue;
+
+    if (tag.section && Array.isArray(tag.section)) {
+      for (const sec of tag.section) {
+        if (!sec.highlight) continue;
+        const matches = sec.highlight.match(/<em>(.*?)<\/em>/gi);
+        if (matches) {
+          for (const m of matches) {
+            const word = m.replace(/<\/?em>/gi, "").trim();
+            if (word.length > 0) words.add(word);
+          }
+        }
+      }
+    }
+  }
+
+  return [...words];
+}
+
+export interface TaggingExcerpt {
+  html: string;
+  /** Mots <em> de CET extrait — pour retrouver l'avis d'ou il vient (cf. heartGetBestOpinionMatch). */
+  words: string[];
+}
+
+/**
+ * Extraits de texte (avec surlignage) pour les tags qui matchent les valeurs
+ * de filtre donnees — le "pourquoi" tel que le pipeline de tagging l'a
+ * lui-meme trouve dans le texte source, pas une reconstitution cote client.
+ * `<em>` (surlignage du pipeline) devient `<mark>` : c'est cette balise que
+ * la feuille du hub peint en rose partout ailleurs.
+ */
+export function heartGetTaggingExcerpts(tagging: any[], filterValues: string[]): TaggingExcerpt[] {
+  if (!tagging || !Array.isArray(tagging) || !filterValues || filterValues.length === 0) return [];
+
+  const filterSet = new Set(filterValues.map((v) => v.toLowerCase().trim()));
+  const byHtml = new Map<string, TaggingExcerpt>();
+
+  for (const tag of tagging) {
+    const tagLabels: string[] = [];
+    if (tag.preferred_label) tagLabels.push(tag.preferred_label.toLowerCase().trim());
+    if (tag.icd10 && Array.isArray(tag.icd10)) {
+      for (const icd of tag.icd10) {
+        if (icd.combined_label) tagLabels.push(icd.combined_label.toLowerCase().trim());
+      }
+    }
+
+    if (!tagLabels.some((tl) => filterSet.has(tl))) continue;
+
+    if (tag.section && Array.isArray(tag.section)) {
+      for (const sec of tag.section) {
+        if (typeof sec.highlight !== "string" || !sec.highlight) continue;
+        const html: string = sec.highlight.replace(/<\/?em>/gi, (m: string) => (m.startsWith("</") ? "</mark>" : "<mark>"));
+        if (byHtml.has(html)) continue;
+        const words = [...sec.highlight.matchAll(/<em>(.*?)<\/em>/gi)]
+          .map((m: RegExpMatchArray) => m[1]?.trim())
+          .filter((w): w is string => !!w && w.length > 0);
+        byHtml.set(html, { html, words });
+      }
+    }
+  }
+
+  return [...byHtml.values()];
+}
+
+// --- Matched fields utilities ---
+
+function removeAccents(str: string): string {
+  return str.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+
+function addSingleAccent(word: string, char: string, accentedChar: string): string[] {
+  const variants: string[] = [];
+  for (let i = 0; i < word.length; i++) {
+    if (word[i]!.toLowerCase() === char) {
+      variants.push(word.slice(0, i) + accentedChar + word.slice(i + 1));
+    }
+  }
+  return variants;
+}
+
+function addAccents(word: string): string[] {
+  let variants: string[] = [word];
+  if (!word.toLowerCase().includes("é")) {
+    variants = variants.concat(addSingleAccent(word, "e", "é"));
+  }
+  if (!word.toLowerCase().includes("ï")) {
+    variants = variants.concat(addSingleAccent(word, "i", "ï"));
+  }
+  return variants;
+}
+
+function handleEndingS(word: string): string[] {
+  const variants: string[] = [word];
+  if (word.toLowerCase().endsWith("s")) {
+    variants.push(word.slice(0, -1));
+  } else {
+    variants.push(word + "s");
+  }
+  return variants;
+}
+
+function escapeRegExp(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function buildSearchVariants(searches: string[]): string[] {
+  const result: string[] = [];
+  searches.forEach((word) => {
+    result.push(word);
+    const wordWithoutAccents = removeAccents(word);
+    if (word !== wordWithoutAccents) result.push(wordWithoutAccents);
+    const accentedVariants = addAccents(word);
+    accentedVariants.forEach((v) => {
+      if (!result.includes(v)) result.push(v);
+    });
+    [word, wordWithoutAccents, ...accentedVariants].forEach((w) => {
+      handleEndingS(w).forEach((s) => {
+        if (!result.includes(s)) result.push(s);
+      });
+    });
+  });
+  return result;
+}
+
+function fieldContainsSearch(fieldValue: any, regex: RegExp): boolean {
+  if (fieldValue === null || fieldValue === undefined) return false;
+  if (typeof fieldValue === "string") return regex.test(fieldValue);
+  if (Array.isArray(fieldValue))
+    return fieldValue.some((v) => fieldContainsSearch(v, regex));
+  return false;
+}
+
+const FIELD_DEFS: { fields: string[]; labelFr: string; labelEn: string; tab: string | null }[] = [
+  { fields: ["indication", "syn_indication", "relevant_indication"], labelFr: "Indication", labelEn: "Indication", tab: "indic" },
+  { fields: ["essential"], labelFr: "Synthèse", labelEn: "Summary", tab: "ess" },
+  { fields: ["conclusion"], labelFr: "Conclusion", labelEn: "Conclusion", tab: "ccl" },
+  { fields: ["molecule"], labelFr: "Molécule", labelEn: "Molecule", tab: null },
+  { fields: ["company"], labelFr: "Entreprise", labelEn: "Company", tab: null },
+  { fields: ["brand"], labelFr: "Marque", labelEn: "Brand", tab: null },
+  { fields: ["target_population", "syn_target_pop"], labelFr: "Population cible", labelEn: "Target pop.", tab: "pop" },
+  { fields: ["therapeutic_strategy_place"], labelFr: "Stratégie thérap.", labelEn: "Therap. strategy", tab: "ther" },
+  { fields: ["has_code"], labelFr: "Code HAS", labelEn: "HAS Code", tab: "info" },
+];
+
+/**
+ * Get matched field labels for a single opinion based on search terms.
+ * Only returns matches if ALL search terms are found in the same opinion.
+ */
+export function heartGetMatchedFields(
+  opinion: any,
+  searches: string[],
+  locale: string
+): { label: string; tab: string | null }[] {
+  if (!searches || searches.length === 0) return [];
+
+  const termRegexes = buildPerTermRegexes(searches);
+  if (termRegexes.length === 0) return [];
+
+  // Check ALL terms match in at least one same field of this opinion
+  if (!opinionMatchesAllTerms(opinion, termRegexes)) {
+    return [];
+  }
+
+  const matched: { label: string; tab: string | null }[] = [];
+  for (const def of FIELD_DEFS) {
+    // Only mark a field as matched if ALL search terms are found in it
+    const found = def.fields.some((f) => {
+      const val = opinion[f];
+      const valEn = opinion[f + "_en"];
+      return termRegexes.every(
+        (r) => fieldContainsSearch(val, r) || fieldContainsSearch(valEn, r)
+      );
+    });
+    if (found) {
+      matched.push({
+        label: locale === "en" ? def.labelEn : def.labelFr,
+        tab: def.tab,
+      });
+    }
+  }
+  return matched;
+}
+
+function buildSearchRegex(searches: string[]): RegExp | null {
+  const variants = buildSearchVariants(searches);
+  const escaped = variants
+    .filter((q) => q.trim() !== "")
+    .map((q) => escapeRegExp(q));
+  if (escaped.length === 0) return null;
+  return new RegExp(`\\b(${escaped.join("|")})`, "i");
+}
+
+/**
+ * Build one regex per original search term (with its variants).
+ * Used to check that ALL terms match in the same opinion.
+ */
+function buildPerTermRegexes(searches: string[]): RegExp[] {
+  return searches
+    .map((term) => {
+      const variants = buildSearchVariants([term]);
+      const escaped = variants
+        .filter((q) => q.trim() !== "")
+        .map((q) => escapeRegExp(q));
+      if (escaped.length === 0) return null;
+      return new RegExp(`\\b(${escaped.join("|")})`, "i");
+    })
+    .filter((r): r is RegExp => r !== null);
+}
+
+/**
+ * Check if ALL search terms are found within at least one same field of the opinion.
+ * This mirrors ES behavior (query_string with default_operator: AND on a single field).
+ */
+function opinionMatchesAllTerms(opinion: any, termRegexes: RegExp[]): boolean {
+  // At least one field must contain ALL terms
+  return FIELD_DEFS.some((def) =>
+    def.fields.some((f) => {
+      const val = opinion[f];
+      const valEn = opinion[f + "_en"];
+      return termRegexes.every(
+        (regex) =>
+          fieldContainsSearch(val, regex) || fieldContainsSearch(valEn, regex)
+      );
+    })
+  );
+}
+
+export interface OpinionMatch {
+  fields: { label: string; tab: string | null }[];
+  opinion: any;
+  date: string;
+  hasCode: string;
+  isLatest: boolean;
+}
+
+/**
+ * Find the best matching opinion across all brand_history entries.
+ * Only returns a match if ALL search terms are found in the same opinion.
+ * Returns the opinion with the most matched fields (most recent if tied).
+ */
+export function heartGetBestOpinionMatch(
+  brandHistory: any[],
+  searches: string[],
+  locale: string,
+  opinionTypeFilter?: string
+): OpinionMatch | null {
+  if (!searches || searches.length === 0) return null;
+
+  const regex = buildSearchRegex(searches);
+  if (!regex) return null;
+
+  const termRegexes = buildPerTermRegexes(searches);
+  if (termRegexes.length === 0) return null;
+
+  const filtered = opinionTypeFilter
+    ? brandHistory.filter((o: any) => o.opinion_type === opinionTypeFilter)
+    : brandHistory;
+
+  if (filtered.length === 0) return null;
+
+  // Sort by date desc to know which is latest
+  const sorted = [...filtered].sort(
+    (a, b) =>
+      new Date(b.decision_date).getTime() - new Date(a.decision_date).getTime()
+  );
+  const latestOpinionId = sorted[0]?.opinion_id;
+
+  let bestMatch: OpinionMatch | null = null;
+
+  for (const opinion of sorted) {
+    // Skip opinions where not ALL search terms are found
+    if (!opinionMatchesAllTerms(opinion, termRegexes)) continue;
+
+    const matched: { label: string; tab: string | null }[] = [];
+    for (const def of FIELD_DEFS) {
+      const found = def.fields.some((f) => {
+        const val = opinion[f];
+        const valEn = opinion[f + "_en"];
+        return fieldContainsSearch(val, regex) || fieldContainsSearch(valEn, regex);
+      });
+      if (found) {
+        matched.push({
+          label: locale === "en" ? def.labelEn : def.labelFr,
+          tab: def.tab,
+        });
+      }
+    }
+
+    if (matched.length > 0) {
+      if (!bestMatch || matched.length > bestMatch.fields.length) {
+        bestMatch = {
+          fields: matched,
+          opinion,
+          date: opinion.decision_date,
+          hasCode: opinion.has_code,
+          isLatest: opinion.opinion_id === latestOpinionId,
+        };
+      }
+    }
+  }
+
+  return bestMatch;
+}
+
+export interface RareExcerpt {
+  html: string;
+  date: string | null;
+  ref: string | null;
+}
+
+/** Fenetre de texte gardee de chaque cote du nom de maladie trouve. */
+const RARE_SNIPPET_RADIUS = 90;
+
+/**
+ * Extraits "pourquoi ça match" pour Maladies Rares.
+ *
+ * Contrairement a `oncology_tagging`, `rare_diseases` ne porte pas de
+ * `section[].highlight` pre-calcule par un pipeline — juste le nom de la
+ * maladie (cf. `heartGetRareHighlightTerms`). On reconstruit donc l'extrait
+ * cote client : chercher ce nom dans le texte de chaque avis (memes champs
+ * que `FIELD_DEFS`, du plus recent au plus ancien) et decouper une fenetre de
+ * texte autour de la premiere occurrence trouvee, comme le fait deja
+ * `heart-text-highlight` pour le surlignage en place — ici pour un extrait
+ * court plutot que tout le champ.
+ */
+export function heartGetRareExcerpts(brandHistory: any[], diseaseNames: string[]): RareExcerpt[] {
+  if (!brandHistory || !Array.isArray(brandHistory) || !diseaseNames || diseaseNames.length === 0) return [];
+
+  const sorted = [...brandHistory].sort(
+    (a, b) => new Date(b.decision_date).getTime() - new Date(a.decision_date).getTime()
+  );
+
+  const results: RareExcerpt[] = [];
+  const seen = new Set<string>();
+
+  for (const name of diseaseNames) {
+    const variants = buildSearchVariants([name]).filter((v) => v.trim() !== "");
+    if (variants.length === 0) continue;
+    const regex = new RegExp(`(${variants.map(escapeRegExp).join("|")})`, "i");
+
+    for (const opinion of sorted) {
+      let html: string | null = null;
+
+      outer: for (const def of FIELD_DEFS) {
+        for (const f of def.fields) {
+          for (const value of [opinion[f], opinion[`${f}_en`]]) {
+            if (typeof value !== "string" || !value) continue;
+            const match = regex.exec(value);
+            if (!match) continue;
+            const start = Math.max(0, match.index - RARE_SNIPPET_RADIUS);
+            const end = Math.min(value.length, match.index + match[0].length + RARE_SNIPPET_RADIUS);
+            const before = (start > 0 ? "… " : "") + value.slice(start, match.index);
+            const after = value.slice(match.index + match[0].length, end) + (end < value.length ? " …" : "");
+            html = `${before}<mark>${value.slice(match.index, match.index + match[0].length)}</mark>${after}`;
+            break outer;
+          }
+        }
+      }
+
+      if (html && !seen.has(html)) {
+        seen.add(html);
+        results.push({ html, date: opinion.decision_date ?? null, ref: opinion.has_code ?? null });
+      }
+      if (html) break;
+    }
+  }
+
+  return results;
+}