@tekkare/romulus 0.1.250 → 0.1.252

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

@@ -0,0 +1,621 @@
+import { ES_INDEX } from "../esIndices";
+import type { EsIndexName } from "../esIndices";
+import type {
+  EsAggregations,
+  EsAggregationsSpec,
+  EsHit,
+  EsQueryClause,
+  EsSearchBody,
+  EsSort,
+} from "../types/elastic";
+import type { EsDocFor } from "../types/es/docByIndex";
+import { useOipEsIndices } from "../../composables/useOipEsIndices";
+
+// Portage de useHeartElastic de fr_drugs_app, pour les fiches medicament du
+// layer (cf. components/oip-drugs) : memes signatures, mais les requetes
+// passent par le proxy du layer (/api/oip/es, cluster `drugs`), joignable
+// depuis toutes les apps. Les listes nommees (`keyName`), que fr_drugs_app
+// rangeait dans son resultStore, restent dans l'instance : `lists[keyName]`.
+
+/**
+ * Un filtre du portail, tel que les pages le construisent : un nom et la
+ * valeur qui part dans la requete. `values` reste libre, c'est tantot une
+ * clause, tantot un tableau de clauses, tantot un nombre (la taille).
+ */
+export interface HeartQueryFilter {
+  filter?: string;
+  values?: any;
+  [option: string]: any;
+}
+
+/**
+ * Ce que rend une requete du portail : les documents de l'index interroge, ou
+ * les hits complets quand l'appelant demande `with_id` (il lui faut alors le
+ * `_id` Elasticsearch, cf. les projets Hub-R).
+ */
+export interface HeartQueryResult<TDoc, TWithId extends boolean | undefined> {
+  results: TWithId extends true ? Array<EsHit<TDoc>> : TDoc[];
+  total: number;
+  aggregations?: EsAggregations;
+}
+
+export default function useOipDrugsElastic() {
+  /** Les listes nommees (`keyName`), propres a l'instance (ex-resultStore). */
+  const lists = reactive<Record<string, { results: any[]; total: number; aggregations?: any }>>({});
+
+  const config = useRuntimeConfig();
+  //
+  // const resultsQuery = ref([] as Array<object>);
+  const queryTotalResults = ref(0 as number);
+  // const isLoadingQuery = ref(false as boolean);
+
+  const filterResults = ref({} as Object);
+
+  /**
+   * La derniere requete de liste a-t-elle echoue ?
+   *
+   * Les erreurs etaient avalees dans la console : quand le cluster refusait la
+   * requete, la page gardait les resultats precedents a l'ecran et donnait a
+   * lire une liste qui ne correspondait plus aux filtres poses. Une page peut
+   * desormais le dire. Les pages qui ne lisent pas ce drapeau se comportent
+   * exactement comme avant.
+   */
+  const queryError = ref<any>(null);
+
+  const resolveCluster = (cluster: string | undefined, index: EsIndexName) => {
+    if (cluster && cluster !== 'default') return cluster;
+    if (index === ES_INDEX.CURRENCY_RATE) return 'newCluster';
+    // Le catalogue designe les index par id Directus : le prefixe se lit sur
+    // le nom.
+    if (useOipEsIndices().nameOf(index ?? '').startsWith('ope_block303_')) return 'newCluster';
+    return 'pubmed';
+  };
+
+  const setFetchUrl = (cluster: string, index: EsIndexName) => {
+    // Une seule route, quel que soit le cluster logique : le proxy choisit la cle.
+    return `/api/oip/es?cluster=drugs&index=${encodeURIComponent(index)}`;
+  };
+
+  const setFetchHeaders = (cluster: string) => {
+    switch (cluster) {
+      case 'newCluster':
+        return {};
+      case 'pubmed':
+      default:
+        return {};
+    }
+  };
+
+  const mapHits = (resolved: string, hits: any[], withId: boolean) => {
+    if (withId) return hits;
+    if (resolved === 'newCluster') {
+      return hits.map((x: any) => {
+        const p = x._source;
+        p.id = x?._id;
+        return p;
+      });
+    }
+    return hits;
+  };
+
+  async function queryElastic<
+    TIndex extends EsIndexName,
+    TWithId extends boolean | undefined = undefined,
+  >({
+    index,
+    take,
+    skip,
+    customQuery,
+    sortQuery,
+    keyName,
+    source,
+    highlight,
+    with_id,
+    cluster,
+    aggs,
+    collapse
+  }: {
+    index: TIndex;
+    take: HeartQueryFilter | number | undefined;
+    skip?: number;
+    customQuery: HeartQueryFilter[];
+    sortQuery?: HeartQueryFilter | HeartQueryFilter[];
+    keyName?: string;
+    source?: string[] | boolean;
+    highlight?: Record<string, any>;
+    with_id?: TWithId;
+    cluster?: string;
+    aggs?: EsAggregationsSpec;
+    collapse?: EsSearchBody["collapse"];
+  }): Promise<HeartQueryResult<EsDocFor<TIndex>, TWithId>> {
+    let esResults: any = {
+      results: [],
+      total: 0,
+    };
+
+    // isLoadingQuery.value = true;
+    const queryMustValues = customQuery
+      .map((obj) => obj.values)
+      .filter((item) => item !== undefined);
+
+    // QUERY
+    let query: any = {
+      from: skip ? skip : 0,
+      _source: source ? source : [],
+      query: {
+        bool: {
+          must: queryMustValues,
+        },
+      },
+      aggregations: aggs ? aggs : {},
+      highlight: highlight ? highlight : {},
+      size: take && typeof take === "object" ? take.values : 10,
+      sort: sortQuery && !Array.isArray(sortQuery) ? sortQuery.values : [],
+      track_total_hits: true,
+    };
+
+    if (collapse) query.collapse = collapse;
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        queryError.value = null;
+        // IF NEED TO KEEP TRACK OF RESULTS ARRAY FROM STORE
+        if (res) {
+          if (keyName) {
+            if (!with_id) {
+              lists[keyName] = {
+                results: mapHits(resolved, res.hits.hits, false),
+                total: res.hits.total.value,
+                aggregations: res.aggregations,
+              };
+            }
+
+            if (with_id) {
+              lists[keyName] = {
+                results: res.hits.hits,
+                total: res.hits.total.value,
+                aggregations: res.aggregations,
+              };
+            }
+          } else {
+            // OTHERWISE USE resultsQuery as result
+
+            if (!with_id) {
+              esResults.results = mapHits(resolved, res.hits.hits, false);
+              esResults.total = res.hits.total.value;
+              esResults.aggregations = res.aggregations;
+            }
+
+            if (with_id) {
+              esResults.results = res.hits.hits;
+              esResults.total = res.hits.total.value;
+              esResults.aggregations = res.aggregations;
+            }
+          }
+        }
+
+        // isLoadingQuery.value = false;
+      })
+      .catch((err) => {
+        queryError.value = err;
+        console.log('Error', err);
+      });
+    return esResults;
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryOneElastic<TIndex extends EsIndexName>({
+    index,
+    path,
+    id,
+    source,
+    cluster,
+  }: {
+    index: TIndex;
+    path: string;
+    id: string | number | string[] | undefined;
+    source?: string[] | boolean;
+    cluster?: string;
+  }): Promise<EsDocFor<TIndex>> {
+    let esResults: any = {};
+
+    // QUERY
+    let query: any = {
+      from: 0,
+      _source: source ? source : [],
+      query: {
+        bool: {
+          must: [{ match: { [`${path}`]: id } }],
+        },
+      },
+
+      size: 1,
+
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        if (res) {
+          esResults = res.hits.hits.map((x: any) => x._source)[0];
+        }
+      })
+      .catch((err) => {
+        console.log('Error', err);
+      });
+    return esResults;
+  }
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryCustomElastic({
+    index,
+    customQuery,
+    onlyOne,
+    cluster,
+    allAnswer,
+  }: {
+    index: EsIndexName;
+    customQuery: EsSearchBody;
+    onlyOne?: boolean;
+    cluster?: string;
+    allAnswer?: boolean;
+  }) {
+    let esResults: any = {
+      results: [],
+      total: 0,
+    };
+
+    // QUERY
+    let query = customQuery;
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        if (res) {
+          if (onlyOne) {
+            esResults = res.hits.hits.map((x: any) => x._source)[0];
+          } else if (allAnswer) {
+            esResults = res;
+          } else {
+            esResults.results = res.hits.hits.map((x: any) => x._source);
+            esResults.total = res.hits.total.value;
+          }
+        }
+      })
+      .catch((err) => {
+        console.log('Error', err);
+      });
+    return esResults;
+  }
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryFilter({
+    index,
+    filters,
+    take,
+    customQuery,
+    cluster,
+  }: {
+    index: EsIndexName;
+    filters: HeartQueryFilter;
+    take: number;
+    customQuery: HeartQueryFilter[];
+    cluster?: string;
+  }) {
+    let esResults: any[] = [];
+
+    const queryMustValues = customQuery
+      .filter((x: any) => x.filter != filters.name)
+      .map((obj: any) => obj.values)
+      .filter((item: any) => item !== undefined);
+
+    // QUERY
+    let query = {
+      from: 0,
+      _source: false,
+      query: {
+        bool: {
+          must: queryMustValues,
+        },
+      },
+
+      aggs: filters.agg,
+
+      size: 0,
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        if (filters.isNested) {
+          esResults = res.aggregations[filters.path.split('.')[0]][
+            filters.path
+          ].buckets.map((x: { key: any }) => x.key);
+        }
+        else if (filters.isDoubleNested) {
+          esResults = res.aggregations[filters.path.split(".")[0]][`${filters.path.split(".")[0]}.${filters.path.split(".")[1]}`][
+            filters.path]
+          .buckets.map((x: { key: any }) => x.key);
+        } else {
+          esResults = res.aggregations[filters.path].buckets.map(
+            (x: { key: any }) => x.key
+          );
+        }
+      })
+      .catch((err) => {
+        console.log('Error', err);
+      });
+
+    return esResults;
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function querySearchFilter({
+    index,
+    filters,
+    take,
+    customQuery,
+    cluster,
+  }: {
+    index: EsIndexName;
+    filters: HeartQueryFilter;
+    take: number;
+    customQuery: HeartQueryFilter[];
+    cluster?: string;
+  }) {
+    let esResults: any[] = [];
+
+    const queryMustValues = customQuery
+      .map((obj: any) => obj.values)
+      .filter((item: any) => item !== undefined);
+
+    let query: any = {
+      from: 0,
+      _source: false,
+      query: {
+        bool: {
+          must: [
+            {
+              bool: {
+                must: queryMustValues,
+              },
+            },
+            filters.searchQuery,
+          ],
+        },
+      },
+
+      aggs: filters.agg,
+
+      size: 0,
+
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        // Avec une saisie, le `terms` est enveloppe dans une agg `filter`
+        // (alertFilter, molAtcFilter, FranceFilter) : les buckets sont alors un
+        // niveau plus bas, dans `filteredData`.
+        const bucketKeys = (agg: any) =>
+          (agg.filteredData?.buckets ?? agg.buckets).map((x: { key: any }) => x.key);
+        if (filters.isNested) {
+          esResults = bucketKeys(res.aggregations[filters.path][filters.path]);
+        }
+        else if (filters.isDoubleNested) {
+          const parts = filters.path.split(".");
+          esResults = bucketKeys(
+            res.aggregations[parts[0]][`${parts[0]}.${parts[1]}`][filters.path]
+          );
+        } else {
+          esResults = bucketKeys(res.aggregations[filters.path]);
+        }
+      })
+      .catch((err) => {
+        console.log("Error", err);
+      });
+    return esResults;
+  }
+
+  async function queryMultiFilter({
+    index,
+    filters,
+    take,
+    customQuery,
+    cluster
+  }: {
+    index: EsIndexName;
+    filters: HeartQueryFilter;
+    take: number;
+    customQuery: HeartQueryFilter[];
+    cluster?: string
+  }) {
+    let esResults: any[] = [];
+
+    const queryMustValues = customQuery
+      .filter((x: any) => x.filter != filters.name)
+      .map((obj: any) => obj.values)
+      .filter((item: any) => item !== undefined);
+
+    // QUERY
+    let query = {
+      from: 0,
+      _source: false,
+      query: {
+        bool: {
+          must: queryMustValues,
+        },
+      },
+
+      aggs: filters.agg,
+
+      size: take,
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        if (filters.isNested) {
+          esResults = res.aggregations[filters.path.split(".")[0]][
+            filters.aggName
+          ].buckets.map((x: { key: any }) => x.key);
+        }
+        else if(filters.isDoubleNested) {
+          esResults = res.aggregations[filters.path.split(".")[0]][filters.path][
+            filters.aggName
+          ].buckets.map((x: { key: any }) => x.key);
+        } else {
+          esResults = res.aggregations[filters.path].buckets.map(
+            (x: { key: any }) => x.key
+          );
+        }
+      })
+      .catch((err) => {
+        console.log('Error', err);
+      });
+    return esResults;
+  }
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  async function queryMultiSearchFilter({
+    index,
+    filters,
+    take,
+    customQuery,
+    cluster
+  }: {
+    index: EsIndexName;
+    filters: HeartQueryFilter;
+    take: number;
+    customQuery: HeartQueryFilter[];
+    cluster?: string
+  }) {
+    let esResults: any[] = [];
+
+    const queryMustValues = customQuery
+      .map((obj: any) => obj.values)
+      .filter((item: any) => item !== undefined);
+
+    let query: any = {
+      from: 0,
+      _source: false,
+      query: {
+        bool: {
+          must: [
+            {
+              bool: {
+                must: queryMustValues,
+              },
+            },
+            filters.searchQuery,
+          ],
+        },
+      },
+
+      aggs: filters.agg,
+
+      size: take,
+
+      track_total_hits: true,
+    };
+
+    // FETCH
+    const resolved = resolveCluster(cluster, index);
+    await $fetch(setFetchUrl(resolved, index), {
+      method: 'POST',
+      headers: setFetchHeaders(resolved),
+      body: query,
+    })
+      .then((res: any) => {
+        if (filters.isNested) {
+          esResults = res.aggregations[filters.path][filters.path][
+            filters.aggName
+          ].buckets.map((x: { key: any }) => x.key);
+        }else if(filters.isDoubleNested) {
+          esResults = res.aggregations[filters.path][filters.path][
+            filters.aggName
+          ].buckets.map((x: { key: any }) => x.key);
+        } else {
+          esResults = res.aggregations[filters.path].buckets.map(
+            (x: { key: any }) => x.key
+          );
+        }
+      })
+      .catch((err) => {
+        console.log("Error", err);
+      });
+    return esResults;
+  }
+
+
+
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+  // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+  return {
+    lists,
+    queryElastic,
+    queryError,
+    // isLoadingQuery,
+    queryTotalResults,
+    // resultsQuery,
+    // :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+    queryFilter,
+    filterResults,
+    queryCustomElastic,
+    querySearchFilter,
+
+    queryOneElastic,
+    queryMultiFilter,
+    queryMultiSearchFilter
+  };
+}

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

@@ -0,0 +1,58 @@
+import type { InjectionKey } from "vue";
+
+/**
+ * Etat vide d'une page a plusieurs blocs.
+ *
+ * Les blocs d'un ecran lisent la meme selection : quand elle ne ramene rien,
+ * ils se vident ensemble et repetent le meme message autant de fois qu'il y a
+ * de cartes. La page en montre un seul a leur place, et cache la pile.
+ *
+ * Chaque bloc s'inscrit lui-meme et dit s'il est vide. La page ne tient donc
+ * aucune liste : rien a tenir a jour quand un bloc arrive, part ou change de
+ * requete. Lire le cache des requetes aurait evite de toucher les blocs, mais
+ * leurs cles se composent a l'execution (`"medicamForecastSales" + index`) —
+ * la page aurait du refaire ce calcul, et se serait tue en silence a la
+ * premiere divergence.
+ *
+ * Un bloc cache par un onglet reste monte, donc compte : la page ne sort son
+ * etat vide que si TOUS ses blocs sont vides, onglets compris. C'est
+ * volontairement prudent — jamais d'etat vide par-dessus un onglet qui a de la
+ * donnee, au prix de laisser passer un onglet vide quand un autre est plein.
+ */
+type Registry = Record<number, boolean>;
+
+const PAGE_EMPTY = Symbol("oip-page-empty") as InjectionKey<Registry>;
+
+let nextId = 0;
+
+/**
+ * Cote page : ouvre le registre et rend le verdict.
+ *
+ * Vrai quand au moins un bloc s'est inscrit et qu'aucun n'a de ligne. Tant
+ * qu'un bloc n'a pas repondu, il n'est pas inscrit : la page reste affichee,
+ * avec ses squelettes.
+ */
+export function usePageEmpty() {
+  const blocks = reactive<Registry>({});
+  provide(PAGE_EMPTY, blocks);
+
+  return computed(() => {
+    const states = Object.values(blocks);
+    return states.length > 0 && states.every(Boolean);
+  });
+}
+
+/**
+ * Cote bloc : declare si ce bloc est vide, et le redit a chaque changement.
+ *
+ * Sans page a l'ecoute (le bloc est monte ailleurs), l'appel ne fait rien : un
+ * composant reste utilisable hors d'un ecran qui agrege.
+ */
+export function reportPageEmpty(empty: () => boolean) {
+  const blocks = inject(PAGE_EMPTY, null);
+  if (!blocks) return;
+
+  const id = nextId++;
+  watch(empty, (value) => { blocks[id] = value; }, { immediate: true });
+  onScopeDispose(() => { delete blocks[id]; });
+}