@tekkare/romulus 0.1.250 → 0.1.252

package/layer/app/components/oip-science/elastic/Filter.vue

@@ -0,0 +1,719 @@
+<!--
+  Filtre a valeurs d'une liste (anciennement ElasticFilter de France Augmented
+  Science). Ses valeurs et sa clause Elasticsearch vont dans le contexte de la
+  liste parente (c-filterContext), plus dans les stores par route de FAS.
+-->
+<template>
+  <div @click="lauchQuery">
+    <!---->
+
+    <RmComplexSelect
+      v-if="typeSelection == 'complex'"
+      select-all-count
+      :has-more="filtersData.length === sizeTarget"
+      :loading="isLoadingQuery"
+      :label="label || filterName"
+      :label-info="haveInfo"
+      v-model="selectedItem"
+     
+      :options="filtersData"
+      :show-select-all="show_select_all"
+      @search="changeAddInputValue"
+      :presets="toPresets(isSmartSelection ? getSourceSmartSelection : null)"
+      :filter-search="
+        otherResearchField.length || otherResearchNestedField.length
+          ? false
+          : true
+      " :lang="$i18n.locale === 'en' ? 'en' : 'fr'" />
+
+    <RmMultipleSelect
+     
+      v-if="typeSelection == 'multiple'"
+      :loading="isLoadingQuery"
+      :label="label || filterName"
+      :label-info="haveInfo"
+      :search="false"
+      v-model="selectedItem"
+      :options="filtersData"
+      @search="changeAddInputValue"
+      :filter-search="
+        otherResearchField.length || otherResearchNestedField.length
+          ? false
+          : true
+      " :lang="$i18n.locale === 'en' ? 'en' : 'fr'" />
+  </div>
+</template>
+<script setup lang="ts">
+import smartSelection from "../../../oip-science/assets/smartSelection.json";
+import useOipElastic from "../../../oip-science/composables/useOipElastic";
+import { useOipFilterContext } from "../../../oip-science/utils/c-filterContext";
+import { toPresets } from "../../../oip-science/utils/toPresets";
+import { caseInsensitive, frDiseaseRegex } from "../../../oip-science/utils/frDiseaseTerms";
+
+const filterContext = useOipFilterContext();
+
+const { queryFilter, querySearchFilter } = useOipElastic();
+
+const emit = defineEmits(["changeElement"]);
+
+const props = defineProps({
+  filterValues: {
+    type: [Array, String, Function],
+    required: true,
+  },
+  field: {
+    type: String,
+    required: false,
+    default: null,
+  },
+  filterName: {
+    type: String,
+    required: true,
+  },
+  label: {
+    type: String,
+    default: null,
+  },
+  sizeTarget: {
+    type: Number,
+    required: false,
+    default: 50,
+  },
+  nestedField: {
+    type: String,
+    required: false,
+    default: null,
+  },
+  indexQuery: {
+    type: String,
+    required: true,
+  },
+  isSmartSelection: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  typeSelection: {
+    type: String,
+    required: false,
+    default: "complex",
+  },
+  matchQuery: {
+    type: Array,
+    required: false,
+    default: [],
+  },
+  keyName: {
+    type: String,
+    required: false,
+    default: null,
+  },
+  includeFields: {
+    type: Array,
+    required: false,
+    default: [],
+  },
+  excludeFields: {
+    type: Array,
+    required: false,
+    default: [],
+  },
+  cluster: {
+    type: String,
+    required: false,
+    default: null,
+  },
+  fuziness: {
+    type: String,
+    required: false,
+    default: "AUTO",
+  },
+
+  otherResearchField: {
+    type: [String, Array],
+    required: false,
+    default: [],
+  },
+  otherResearchNestedField: {
+    type: [String, Array],
+    required: false,
+    default: [],
+  },
+  // Filtres maladie/oncologie : la saisie francaise cherche aussi l'anglais (cf. frDiseaseRegex)
+  frDiseaseSearch: {
+    type: Boolean,
+    default: false,
+  },
+  // props ajouté pour avoir un point info dans le titre du filtre
+  haveInfo: {
+    type: Boolean,
+    default: false,
+  },
+
+  sourceSmartSelection: {
+    type: String,
+    required: false,
+    default: "Countries",
+  },
+  forceList: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  show_select_all: {
+    type: Boolean,
+    required: false,
+    default: true,
+  },
+  mustNot: {
+    type: Array,
+    required: false,
+    default: null,
+  },
+  // Stable, locale-independent key used to read/write filterStore entries.
+  // The page's `getStore('Sponsors')` lookup uses an English hard-coded key
+  // while `filterName` is `$t('common.sponsors')` = "Promoteurs" in French.
+  // Without `storeKey`, Filter.vue would write under "Promoteurs" and the
+  // parent would read under "Sponsors" → no match → saved scopes never
+  // restore. Pages should pass `storeKey="Sponsors"` matching their
+  // getStore call. Falls back to `filterName` when omitted.
+  storeKey: {
+    type: String,
+    required: false,
+    default: null,
+  },
+  // Pass true when the field is numeric/keyword-direct (no `.keyword` sub-field).
+  // Required for `long`/`integer`/`float` ES fields like PHRC.period.
+  noKeyword: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+  // Index EUCT (champs sans nested) ; FAS le lisait dans la route (`/euct`).
+  euct: {
+    type: Boolean,
+    required: false,
+    default: false,
+  },
+});
+
+// Returns the field path to use in queries / aggregations.
+// When `noKeyword` is true, the raw field is used (numeric or already-keyword
+// fields); otherwise `.keyword` is appended (text fields with a keyword sub-field).
+const kw = (field: string) => (props.noKeyword ? field : `${field}.keyword`);
+
+// Use `storeKey` when provided so reads (via the parent's `getStore(key)`)
+// and writes (here) target the same filterStore entry regardless of the
+// current locale. Otherwise fall back to `filterName` for back-compat.
+const effectiveStoreKey = computed(
+  () => props.storeKey || props.filterName,
+);
+
+const search = ref("" as string);
+const filtersData = ref([] as any);
+const isLoadingQuery = ref(false);
+
+const selectedItem = ref([] as any);
+
+const timeoutId = ref(null as any);
+
+const dynamicFuzzyThreshold = computed(() => {
+  const cleanInput = search.value.replace(/[+\/!]/g, "").trim();
+  // Pour les codes courts (≤ 6 caractères), threshold très permissif
+  if (cleanInput.length <= 6) {
+    return 0.9;
+  }
+  // Pour les recherches moyennes (7-10 caractères), threshold moyen
+  else if (cleanInput.length <= 10) {
+    return 0.7;
+  }
+  // Pour les recherches longues, threshold strict
+  else {
+    return 0.5;
+  }
+});
+
+// Le pays de retour de FAS (layoutConfig.returnCountry) n'existe pas hors de l'app.
+onMounted(() => {
+  selectedItem.value =
+    props.filterValues.length > 0 ? props.filterValues : [];
+});
+
+const getSourceSmartSelection = computed(() => {
+  switch (props.sourceSmartSelection) {
+    case "Pubmed Journal Name":
+      return smartSelection.orphanetPubmedJournalSelection;
+    case "country_eu":
+      return smartSelection.countries_eu;
+    default:
+      return smartSelection.countries;
+  }
+});
+
+// Sync selectedItem when the parent passes a new `filterValues` prop —
+// notably when a saved scope is recalled and the parent re-renders with
+// the restored values. Without this watch, `selectedItem` is only read
+// from the prop once in `onMounted`, so any later prop change is invisible
+// and the UI stays empty even though the store has the recalled entries.
+watch(
+  () => props.filterValues,
+  (newVal) => {
+    const target = Array.isArray(newVal) ? newVal : [];
+    // Skip no-op syncs (avoids feedback loops with the watch below).
+    if (JSON.stringify(selectedItem.value) === JSON.stringify(target)) return;
+    selectedItem.value = target;
+  },
+  { deep: true },
+);
+
+watch(
+  () => selectedItem.value,
+  async (val, oldVal) => {
+    if (val.length > 0) {
+      filterContext.setAppFilters({
+        filter: effectiveStoreKey.value,
+        keyName: props.keyName,
+        values: val,
+      });
+    } else if (oldVal && oldVal.length > 0) {
+      // Only reset when going from a real selection to empty — i.e. the
+      // user actually cleared the filter. Skip the noisy 0→0 transitions
+      // that fire on mount because `selectedItem` is initialized to `[]`
+      // and then re-assigned to (a possibly-still-empty) `props.filterValues`.
+      // Without this guard, recalled scope entries get wiped by the watch
+      // before the prop has a chance to deliver the restored values.
+      filterContext.resetSelectedFilters({
+        filter: effectiveStoreKey.value,
+        keyName: props.keyName,
+      });
+    }
+
+    setSearch(val);
+  }
+);
+
+const changeAddInputValue = (val: string) => {
+  clearTimeout(timeoutId.value);
+  search.value = val;
+  timeoutId.value = setTimeout(() => {
+    lauchQuery();
+  }, 300);
+};
+
+const setSearch = async (search: any) => {
+  let obj = null;
+
+  if (search.length > 0 && props.field) {
+    obj = {
+      terms: {
+        [kw(props.field)]: search,
+      },
+    };
+  }
+
+  if (search.length > 0 && props.nestedField) {
+    // Pour EUCT, pas de nested
+    if (props.euct) {
+      obj = {
+        terms: {
+          [`${props.nestedField}.keyword`]: search,
+        },
+      };
+    } else {
+      obj = {
+        nested: {
+          path: props.nestedField.split(".").slice(0, -1).join("."),
+          query: {
+            terms: {
+              [`${props.nestedField}.keyword`]: search,
+            },
+          },
+        },
+      };
+    }
+  }
+
+  if (obj != null) {
+    filterContext.setQueryFilters({
+      filter: props.filterName,
+      values: obj,
+      keyName: props.keyName,
+    });
+  } else {
+    filterContext.removeQueryFilter({
+      filter: props.filterName,
+      keyName: props.keyName,
+    });
+  }
+};
+
+const lauchQuery = async () => {
+  isLoadingQuery.value = true;
+  if (search.value != "") {
+    await lauchQueryWithSearch();
+  } else {
+    await launchQueryWithoutSearch();
+  }
+
+  isLoadingQuery.value = false;
+};
+
+const aggregationsQuery = computed(() => {
+  let obj;
+
+  if (props.field) {
+    obj = {
+      [`${props.field}`]: {
+        terms: {
+          field: kw(props.field),
+
+          size: props.sizeTarget,
+          order: {
+            _key: "asc",
+          },
+        },
+      },
+    };
+
+    if (props.includeFields.length > 0) {
+      obj[`${props.field}`].terms.include = props.includeFields;
+    }
+    if (props.excludeFields.length > 0) {
+      obj[`${props.field}`].terms.exclude = props.excludeFields;
+    }
+  }
+
+  if (props.nestedField) {
+    // Pour EUCT, pas de nested
+    if (props.euct) {
+      obj = {
+        [`${props.nestedField}`]: {
+          terms: {
+            field: `${props.nestedField}.keyword`,
+            size: props.sizeTarget,
+            order: {
+              _key: "asc",
+            },
+          },
+        },
+      };
+    } else {
+      obj = {
+        [`${props.nestedField.split(".")[0]}`]: {
+          nested: {
+            path: props.nestedField.split(".").slice(0, -1).join("."),
+          },
+          aggs: {
+            [`${props.nestedField}`]: {
+              terms: {
+                field: `${props.nestedField}.keyword`,
+                size: props.sizeTarget,
+                order: {
+                  _key: "asc",
+                },
+              },
+            },
+          },
+        },
+      };
+    }
+
+    if (props.includeFields.length > 0) {
+      if (props.euct) {
+        obj[`${props.nestedField}`].terms.include = props.includeFields;
+      } else {
+        obj[`${props.nestedField.split(".").slice(0, -1).join(".")}`].aggs[
+          `${props.nestedField}`
+        ].terms.include = props.includeFields;
+      }
+    }
+    if (props.excludeFields.length > 0) {
+      if (props.euct) {
+        obj[`${props.nestedField}`].terms.exclude = props.excludeFields;
+      } else {
+        obj[`${props.nestedField.split(".").slice(0, -1).join(".")}`].aggs[
+          `${props.nestedField}`
+        ].terms.exclude = props.excludeFields;
+      }
+    }
+  }
+
+  return obj;
+});
+
+const aggregationsSearchQuery = computed(() => {
+  let obj;
+  
+  // Normalise les codes médicaux en majuscules pour matcher les champs keyword
+  const normalizedQuery = search.value.replace(/\b(orpha|nct|icd|atc|ema|fda)([\w:-]*)/gi, (match: string, prefix: string, suffix: string) => {
+    return prefix.toUpperCase() + suffix.toUpperCase();
+  });
+  
+  // Détecte si la valeur contient des wildcards
+  const hasWildcard = search.value.includes('*') || search.value.includes('?');
+  
+  // Construit un pattern case-insensitive pour chaque caractère
+  const makeCaseInsensitive = (str: string) => {
+    return str.split('').map(char => {
+      if (/[a-zA-Z]/.test(char)) {
+        return `[${char.toLowerCase()}${char.toUpperCase()}]`;
+      }
+      // Échapper les caractères spéciaux regex
+      if (/[.*+?^${}()|[\]\\]/.test(char)) {
+        return `\\${char}`;
+      }
+      return char;
+    }).join('');
+  };
+  
+  let includePattern = '';
+  
+  if (hasWildcard) {
+    // Convertir les wildcards et rendre case-insensitive
+    const withWildcards = normalizedQuery.replace(/\*/g, '.*').replace(/\?/g, '.');
+    includePattern = makeCaseInsensitive(withWildcards);
+  } else {
+    // Chercher ce qui contient le terme (case insensitive)
+    includePattern = `.*${makeCaseInsensitive(normalizedQuery)}.*`;
+  }
+  if (frRegex.value) includePattern += `|.*(${caseInsensitive(frRegex.value)}).*`;
+  
+  if (props.field) {
+    obj = [props.field, props.otherResearchField]
+      .flat()
+      .map((field) => {
+        return {
+          [`${field}`]: {
+            terms: {
+              field: kw(field as string),
+              size: props.sizeTarget,
+              include: includePattern,
+            },
+          },
+        };
+      })
+      .reduce((acc, curr) => Object.assign(acc, curr), {});
+  }
+
+  if (props.nestedField) {
+    obj = [props.nestedField, props.otherResearchNestedField]
+      .flat()
+      .map((field) => {
+        return {
+          [`${field}`]: {
+            nested: {
+              // @ts-ignore
+              path: field.split(".").slice(0, -1).join("."),
+            },
+            aggs: {
+              [`${field}`]: {
+                terms: {
+                  field: `${field}.keyword`,
+                  // Sans size, ES retombe sur 10 buckets triés par doc count :
+                  // un code exact peu représenté (ex: ORPHA:18) sort du top 10
+                  // et disparaît. On récupère un superset, trié côté client.
+                  size: 1000,
+                  include: includePattern,
+                },
+              },
+            },
+          },
+        };
+      })
+      .reduce((acc, curr) => Object.assign(acc, curr), {});
+  }
+
+  return obj;
+});
+
+// La saisie francaise traduite en anglais, null hors filtres maladie ou sans traduction.
+const frRegex = computed(() => (props.frDiseaseSearch ? frDiseaseRegex(search.value) : null));
+
+const searchQuery = computed(() => {
+  let query;
+
+  // Détecte si la requête contient des codes courts (ORPHA:, NCT, ICD, etc.)
+  const hasShortCodes = /\b(ORPHA|NCT|ICD|ATC|EMA|FDA)[\w:-]{1,10}\b/i.test(search.value);
+  
+  // Détecte si ce sont des termes très courts (≤3 caractères)
+  const hasVeryShortTerms = search.value.split(/\s+/).some((term: string) => 
+    term.replace(/[^\w]/g, '').length <= 3 && term.replace(/[^\w]/g, '').length > 0
+  );
+
+  // Normalise les codes médicaux en majuscules pour matcher les champs keyword
+  const normalizedQuery = search.value.replace(/\b(orpha|nct|icd|atc|ema|fda)([\w:-]*)/gi, (match: string, prefix: string, suffix: string) => {
+    return prefix.toUpperCase() + suffix.toUpperCase();
+  });
+
+  // Ajuste la fuzzyness et phrase_slop selon le contexte
+  const adaptiveFuzziness = hasShortCodes || hasVeryShortTerms ? "0" : props.fuziness;
+  const adaptivePhraseSlop = hasShortCodes ? 0 : 2;
+
+  // Détecte si la valeur contient des wildcards
+  const hasWildcard = search.value.includes('*') || search.value.includes('?');
+
+  if (props.field) {
+    query = {
+      bool: {
+        should: [
+          ...[props.field, props.otherResearchField].flat().map((field) => ({
+            bool: {
+              should: [
+                // Regexp pour recherche partielle (contient)
+                {
+                  regexp: {
+                    [`${field}.keyword`]: {
+                      value: `.*${normalizedQuery}.*${frRegex.value ? `|.*(${frRegex.value}).*` : ''}`,
+                      flags: "ALL",
+                      case_insensitive: true,
+                    },
+                  },
+                },
+                // Wildcard pour recherche préfixe (commence par)
+                {
+                  wildcard: {
+                    [`${field}.keyword`]: {
+                      value: hasWildcard ? normalizedQuery.toLowerCase() : `${normalizedQuery.toLowerCase()}*`,
+                      case_insensitive: true,
+                    },
+                  },
+                },
+              ],
+            },
+          })),
+        ],
+      },
+    };
+  }
+  if (props.nestedField) {
+    query = {
+      bool: {
+        should: [
+          ...[props.nestedField, props.otherResearchNestedField]
+            .flat()
+            .map((field) => ({
+              nested: {
+                path: (field as string).split(".").slice(0, -1).join("."),
+                query: {
+                  bool: {
+                    should: [
+                      // Regexp pour recherche partielle (contient)
+                      {
+                        regexp: {
+                          [`${field}.keyword`]: {
+                            value: `.*${normalizedQuery}.*${frRegex.value ? `|.*(${frRegex.value}).*` : ''}`,
+                            flags: "ALL",
+                            case_insensitive: true,
+                          },
+                        },
+                      },
+                      // Wildcard pour recherche préfixe (commence par)
+                      {
+                        wildcard: {
+                          [`${field}.keyword`]: {
+                            value: hasWildcard ? normalizedQuery.toLowerCase() : `${normalizedQuery.toLowerCase()}*`,
+                            case_insensitive: true,
+                          },
+                        },
+                      },
+                    ],
+                  },
+                },
+              },
+            })),
+        ],
+      },
+    };
+  }
+  return query;
+});
+
+const filtersWithoutSearch = computed(() => {
+  return {
+    name: props.filterName,
+    agg: aggregationsQuery.value,
+    path: props.field ? props.field : props.nestedField,
+    values: selectedItem.value,
+    isNested: props.nestedField,
+  };
+});
+const filtersWitSearch = computed(() => {
+  return {
+    agg: aggregationsSearchQuery.value,
+    path: props.field ? props.field : props.nestedField,
+    isNested: props.nestedField ? true : false,
+    searchQuery: searchQuery.value,
+  };
+});
+
+const launchQueryWithoutSearch = async () => {
+  await queryFilter({
+    index: props.indexQuery,
+    filters: filtersWithoutSearch.value,
+    take: props.sizeTarget,
+    customQuery: props.matchQuery,
+    cluster: props.cluster,
+    mustNot: props.mustNot,
+  }).then((data) => {
+    filtersData.value = data;
+  });
+};
+
+// Trie les résultats par pertinence vis-à-vis de la recherche : ES renvoie les
+// buckets par doc count, donc un match exact (ex: ORPHA:18) n'est jamais premier.
+// Ordre : code orpha exact > préfixe de code > préfixe de nom > contient > reste.
+const sortByRelevance = (results: any): string[] => {
+  const raw = search.value.trim();
+  if (!raw || !Array.isArray(results)) return results;
+  const q = raw.toLowerCase();
+  const codeQueryMatch = raw.match(/^(?:orpha:?\s*)?(\d+)$/i);
+  const qCode = codeQueryMatch ? codeQueryMatch[1] : null;
+
+  const codeOf = (item: string) => (item.match(/orpha:\s*(\d+)/i) || [])[1];
+
+  const score = (item: string) => {
+    const lower = item.toLowerCase();
+    const code = codeOf(item);
+    if (qCode && code) {
+      if (code === qCode) return 0;
+      if (code.startsWith(qCode)) return 1;
+    }
+    if (lower.startsWith(q)) return 2;
+    if (lower.includes(q)) return 3;
+    return 4;
+  };
+
+  return [...results].sort((a, b) => {
+    const diff = score(a) - score(b);
+    if (diff !== 0) return diff;
+    const ca = codeOf(a);
+    const cb = codeOf(b);
+    // À score égal, code le plus court d'abord (ORPHA:18 avant ORPHA:180)
+    if (ca && cb && ca.length !== cb.length) return ca.length - cb.length;
+    return a.localeCompare(b);
+  });
+};
+
+const lauchQueryWithSearch = async () => {
+  // await querySearchFilter({
+  //   index: props.indexQuery,
+  //   filters: filtersWitSearch.value,
+  //   take: props.sizeTarget,
+  //   customQuery: props.matchQuery,
+  //   cluster: props.cluster,
+  // }).then((data) => {
+  //   filtersData.value = data;
+  // });
+
+  await querySearchFilter({
+    index: props.indexQuery,
+    filters: filtersWitSearch.value,
+    take: props.sizeTarget,
+    customQuery: [],
+    cluster: props.cluster,
+    mustNot: props.mustNot,
+  }).then((data) => {
+    filtersData.value = sortByRelevance(data).slice(0, props.sizeTarget);
+  });
+};
+</script>