@tekkare/romulus 0.1.243 → 0.1.245

package/layer/app/composables/useAlertSource.ts

@@ -0,0 +1,210 @@
+/**
+ * useAlertSource - ce qu'une page donne a surveiller.
+ *
+ * Une alerte rejoue la requete d'une vue sauvegardee et rapporte ce qui y
+ * apparait, y change ou en sort. L'API ne sait pas construire cette requete :
+ * la DSL Elasticsearch est assemblee dans le navigateur, clause par clause,
+ * par les composants de filtre de la page (`elasticQueryStore`). La page la
+ * remet donc telle quelle au moment ou l'alerte est creee, et l'API la garde
+ * figee.
+ *
+ * Consequence assumee : une vue modifiee doit repointer ses alertes. Quand
+ * l'edition part de la page, le client renvoie la nouvelle requete avec les
+ * criteres et l'API repart d'une nouvelle reference. Par tout autre chemin,
+ * l'alerte passe en `stale` et attend d'etre rearmee ici.
+ *
+ * Meme forme que `useExportSource` et `useViews` : un `shallowRef` de module,
+ * pose au montage, retire au demontage, donc rien a nettoyer a la main et rien
+ * qui traverse le rendu serveur (les descripteurs portent des fonctions).
+ */
+import type { AlertResourceType as HubrResourceType } from "#oip-app/alerts";
+import { VIEW_BRAND_FILTERS } from "#oip-app/views";
+
+/** Un champ que la page propose de surveiller. */
+export interface AlertField {
+  /** Chemin du champ dans le `_source`, points admis. */
+  value: string;
+  /** Libelle affiche, deja traduit. */
+  label: string;
+}
+
+export interface AlertSource {
+  /** Index Elasticsearch interroge par la page. */
+  index: string;
+  /** Famille du document, cf. `useHubrResourceKinds`. */
+  resourceType: HubrResourceType;
+  /**
+   * Requete de l'ecran, relue au moment ou l'alerte est creee.
+   *
+   * La clause `query` seule : ni tri, ni agregation, ni pagination. Le tri ne
+   * decrit rien pour une alerte (le diff porte sur un ensemble, pas sur un
+   * classement) et les agregations couteraient cher pour rien.
+   */
+  query: () => any;
+  /**
+   * Champs relus pour nommer un element dans le journal : titre, puis
+   * sous-titre. Ils sont aussi gardes dans la reference, seul endroit ou le
+   * nom d'un element sorti de la vue existe encore.
+   */
+  labelFields: [string] | [string, string];
+  /** Champs surveillables, tels que la page les propose a l'ecran. */
+  fields: AlertField[];
+  /** Titre suggere a la creation. Defaut : le nom de la vue. */
+  defaultTitle?: string;
+}
+
+const registry = shallowRef<(() => AlertSource | null) | null>(null);
+
+/**
+ * Marques que la page affichee met en avant, quand elle en met une.
+ *
+ * Deuxieme registre plutot qu'un champ de `AlertSource` : une fiche produit et
+ * l'ecran de recherche ne livrent aucune requete surveillable (l'une est un
+ * document, l'autre un agregat de dix index), ils n'ont donc pas de source du
+ * tout. Ils ont pourtant la seule chose dont une alerte de MARQUE a besoin :
+ * le nom du produit qu'on regarde.
+ *
+ * Ce sont des candidats, pas des marques : le panneau les confronte au
+ * repertoire avant de cocher quoi que ce soit, parce qu'un terme de recherche
+ * peut etre une molecule (« pembrolizumab ») ou n'exister nulle part.
+ */
+const brandRegistry = shallowRef<(() => string[]) | null>(null);
+
+export function useAlertSource() {
+  /**
+   * Declare la source de la page. A appeler dans le `setup`, une seule fois :
+   * le descripteur est relu a chaque acces, donc il peut lire des refs.
+   */
+  const declare = (build: () => AlertSource | null) => {
+    // Page du tiroir de projet : les alertes restent celles de l'ecran dessous.
+    if (useHubrEmbedded()) return;
+    // Le moteur d'alertes interroge Elasticsearch lui-meme, par NOM : l'id
+    // Directus du catalogue est traduit ici, une fois pour tous les appels.
+    const { nameOf } = useOipEsIndices();
+    const named = () => {
+      const source = build();
+      return source ? { ...source, index: nameOf(source.index) } : null;
+    };
+    registry.value = named;
+    onScopeDispose(() => {
+      if (registry.value === named) registry.value = null;
+    });
+  };
+
+  /** La source de la page affichee, ou `null` si elle n'en declare pas. */
+  const current = computed(() => registry.value?.() ?? null);
+
+  /**
+   * Declare les marques de la page. Meme forme que `declare`, et independant :
+   * une page peut n'avoir que ca.
+   */
+  const declareBrands = (build: () => string[]) => {
+    if (useHubrEmbedded()) return;
+    brandRegistry.value = build;
+    onScopeDispose(() => {
+      if (brandRegistry.value === build) brandRegistry.value = null;
+    });
+  };
+
+  /** Les marques candidates de la page affichee, vides si elle n'en propose pas. */
+  const brands = computed(() =>
+    (brandRegistry.value?.() ?? []).map((brand) => String(brand).trim()).filter(Boolean),
+  );
+
+  return { declare, current, declareBrands, brands };
+}
+
+/**
+ * Noms sous lesquels une vue range sa selection de produits.
+ *
+ * Le portail ecrit `brands` (cf. useDrugsViews), les delivrances
+ * hospitalieres `brandSelection` : c'est le nom qu'elles donnent en base
+ * depuis l'origine, garde tel quel pour ne pas perdre les vues deja
+ * enregistrees.
+ */
+
+/**
+ * Les marques que porte une vue, s'il y en a.
+ *
+ * Sur les pages de ventes, une vue EST une selection de produits : faute de
+ * requete de documents a livrer, « surveiller cette vue » ne peut vouloir
+ * dire que « surveiller ces marques ». C'est ce qui pre-remplit le formulaire
+ * d'alerte, et ce qu'on propose de reporter sur une alerte existante quand la
+ * vue change.
+ */
+export function viewBrandsFromCriteria(criteria: any[]): string[] {
+  const entry = (Array.isArray(criteria) ? criteria : []).find((item: any) =>
+    VIEW_BRAND_FILTERS.includes(item?.filter),
+  );
+  return Array.isArray(entry?.values) ? entry.values.map(String) : [];
+}
+
+/** Deux chemins qui designent la meme page, `trailingSlash` etant actif. */
+const samePage = (a: unknown, b: unknown): boolean =>
+  String(a ?? "").replace(/\/$/, "") === String(b ?? "").replace(/\/$/, "");
+
+/**
+ * Ce qu'une mise a jour de vue doit emporter pour que ses alertes survivent.
+ *
+ * L'API repointe toute seule les alertes d'une vue dont les criteres ont
+ * bouge, mais elle a besoin de la requete : sa DSL est assemblee dans le
+ * navigateur, elle ne sait pas la reconstruire. Sans elle, les alertes
+ * passent en `stale` et attendent un rearmement a la main depuis la page.
+ *
+ * Rien n'est envoye si la vue mise a jour n'est pas celle de la page
+ * affichee : la requete de l'ecran decrirait alors une autre page que la vue
+ * qu'on enregistre.
+ */
+export function alertRefreshPayload(
+  page: unknown,
+): { alertQuery?: any; alertIndex?: string } {
+  const declared = registry.value?.() ?? null;
+  if (!declared) return {};
+  if (!samePage(page, useViews().current.value?.page)) return {};
+  return { alertQuery: declared.query(), alertIndex: declared.index };
+}
+
+/**
+ * Ce que la snackbar ajoute quand des alertes ont suivi, ou pas.
+ *
+ * Sans ce mot, l'API rendait deja ces deux nombres et personne ne les lisait :
+ * une vue elargie endormait ses alertes en silence, et la panne ne se
+ * decouvrait qu'en ouvrant le panneau, parfois des jours plus tard.
+ */
+export function alertRefreshNotice(result: unknown): string {
+  const refreshed = Number((result as any)?.alertsRefreshed ?? 0);
+  const stale = Number((result as any)?.alertsStale ?? 0);
+  // Appelee depuis les magasins, hors setup : la langue vient de l'app, pas de useI18n.
+  const fr = String(tryUseNuxtApp()?.$i18n?.locale?.value ?? "fr") !== "en";
+  const plural = (n: number) => (n > 1 ? "s" : "");
+  if (stale > 0) {
+    return fr
+      ? ` (${stale} alerte${plural(stale)} à réarmer)`
+      : ` (${stale} alert${plural(stale)} to re-arm)`;
+  }
+  if (refreshed > 0) {
+    return fr
+      ? ` (${refreshed} alerte${plural(refreshed)} mise${plural(refreshed)} à jour)`
+      : ` (${refreshed} alert${plural(refreshed)} updated)`;
+  }
+  return "";
+}
+
+/**
+ * Requete d'alerte a partir des filtres d'une page heart.
+ *
+ * Les pages du hub tiennent leurs clauses dans `elasticQueryStore` sous la
+ * forme `{ filter, page, values, keyName }`, et `useHeartElastic` les assemble
+ * en `bool.must` au moment d'interroger le cluster. On reprend exactement le
+ * meme assemblage : une alerte qui ne poserait pas la meme question que
+ * l'ecran ne vaut rien.
+ */
+export function alertQueryFromFilters(filters: any[]): any {
+  return {
+    bool: {
+      must: (filters ?? [])
+        .map((entry: any) => entry?.values)
+        .filter((clause: unknown) => clause !== undefined && clause !== null),
+    },
+  };
+}

package/layer/app/composables/useAlerts.ts

@@ -0,0 +1,345 @@
+/**
+ * useAlerts - les alertes posees sur les vues sauvegardees.
+ *
+ * Une alerte = une vue + ce qu'on y surveille. Elle vit cote API (worker
+ * quotidien, journal d'evenements) ; ici on ne fait que lire la liste, la
+ * creer depuis la page et marquer les evenements comme lus.
+ *
+ * Le point delicat est la requete : c'est la page qui la fournit, via
+ * `useAlertSource`. Une alerte ne peut donc etre creee que depuis la page
+ * qu'elle surveille, et une vue temporaire (posee par un lien profond, jamais
+ * enregistree) n'en accepte pas : il n'y a rien a quoi l'attacher.
+ */
+import { useOipApi, type Alert, type AlertEvent, type AlertTrigger } from "#oip-app/api";
+import { sameViewPage } from "../utils/viewPages";
+
+export function useAlerts() {
+  const elysiaApi = useOipApi();
+  const source = useAlertSource();
+  const views = useViews();
+
+  const alerts = useState<Alert[]>("alerts:list", () => []);
+  /**
+   * Le mode d'essai est ouvert cote API : cadence de cinq minutes et passage
+   * manuel. Faux en production, et l'ecran n'en montre alors aucune trace.
+   */
+  const testCadence = useState<boolean>("alerts:testCadence", () => false);
+  const loaded = useState<boolean>("alerts:loaded", () => false);
+  const loading = useState<boolean>("alerts:loading", () => false);
+  /**
+   * Formulaire de creation ouvert.
+   *
+   * L'etat est partage plutot que local au panneau parce que la visite guidee
+   * des alertes doit pouvoir ouvrir le formulaire : ses etapes expliquent le
+   * parametrage, elles n'auraient rien a designer devant un panneau ferme. Le
+   * panneau le remet a faux en se demontant (cf. son composant), donc rouvrir
+   * la tuile ne rouvre pas la modale d'hier.
+   */
+  const creating = useState<boolean>("alerts:creating", () => false);
+
+  const load = async (force = false) => {
+    if (loading.value) return;
+    if (loaded.value && !force) return;
+    loading.value = true;
+    try {
+      const response = await elysiaApi.alerts.list();
+      alerts.value = response?.alerts ?? [];
+      testCadence.value = !!response?.testCadence;
+      loaded.value = true;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  /**
+   * Suit une alerte jusqu'a ce que sa reference soit posee.
+   *
+   * La capture prend quelques secondes cote worker. Sans ce suivi, la carte
+   * reste sur « en préparation » indefiniment alors que le passage a peut-etre
+   * deja echoue — et le message d'echec est justement ce qu'il faut lire.
+   */
+  const followSeeding = async (attempts = 6, delayMs = 2500) => {
+    for (let i = 0; i < attempts; i++) {
+      if (!alerts.value.some((alert) => alert.status === "seeding")) return;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+      await load(true);
+    }
+  };
+
+  const router = useRouter();
+
+  /**
+   * L'alerte a ete posee depuis cette app.
+   *
+   * L'API rend les alertes de tout l'espace de travail, toutes apps
+   * confondues : sans ce tri, le panneau de France Drugs montrait celles de
+   * France Epidemio. L'hote de la vue surveillee dit d'ou elle vient. Une
+   * alerte sans URL (projet) n'appartient a aucune app : elle reste.
+   *
+   * En local, l'hote ne dit rien (les vues portent celui du staging) : on
+   * demande alors au routeur si la page existe ici.
+   */
+  const fromThisApp = (alert: Alert): boolean => {
+    if (!alert.url || !import.meta.client) return true;
+    let url: URL;
+    try {
+      url = new URL(alert.url);
+    } catch {
+      return true;
+    }
+    if (url.host === window.location.host) return true;
+    if (!/^(localhost|127\.0\.0\.1)$|\.localhost$/.test(window.location.hostname)) return false;
+    return router.resolve(url.pathname).matched.length > 0;
+  };
+
+  /**
+   * Pastille de la tuile du rail : ce que l'utilisateur n'a pas encore lu,
+   * dans cette app. Les autres apps ont leur propre pastille.
+   */
+  const unreadTotal = computed(() =>
+    alerts.value
+      .filter(fromThisApp)
+      .reduce((total, alert) => total + alert.unreadCount, 0),
+  );
+
+  /** Les alertes de la page affichee, celles que son panneau montre en premier. */
+  const forCurrentPage = computed(() => {
+    const page = views.current.value?.page;
+    if (!page) return [];
+    return alerts.value.filter((alert) => samePage(alert.page, page));
+  });
+
+  /**
+   * Vue active, quand elle existe en base.
+   *
+   * Une vue temporaire n'a pas d'identifiant (cf. `isTemporaryView`) : elle
+   * n'existe pas en base, une alerte ne peut pas s'y accrocher telle quelle.
+   */
+  const watchableView = computed(() => {
+    const active = views.active.value;
+    return active && !isTemporaryView(active) ? active : null;
+  });
+
+  /** Les vues enregistrees de la page affichee. */
+  const pageViews = computed(() => {
+    const page = views.current.value?.page;
+    if (!page) return [];
+    return views.scopes
+      .value()
+      .scopeList.value.filter((scope: any) => sameViewPage(scope.page, page));
+  });
+
+  /**
+   * Une alerte peut naitre des que la page sait livrer sa requete et qu'il y
+   * a de quoi la rattacher : une vue deja enregistree, ou des filtres a
+   * l'ecran dont on fera une vue.
+   *
+   * Ne pas exiger une vue ACTIVE : c'est la modale qui choisit, et exiger
+   * l'application prealable obligeait a passer par un autre panneau avant de
+   * pouvoir cliquer.
+   *
+   * Sans source declaree, il reste l'alerte de MARQUE : elle ne surveille
+   * aucune page, donc aucune requete d'ecran ne lui manque, et depuis que
+   * l'API accepte une alerte sans pulse, aucune vue non plus. C'est ce qui
+   * ouvre les alertes aux pages de ventes (Medic'AM, delivrances
+   * hospitalieres, statistiques), dont les ecrans sont des agregats, et aux
+   * pages qui nomment un produit sans rien offrir a filtrer : la fiche
+   * produit, l'ecran de recherche.
+   */
+  const canCreate = computed(() => {
+    if (source.brands.value.length > 0) return true;
+    // Sans requete, une alerte de marque suffit : les produits de la vue
+    // affichee, enregistree ou non, en font une. Exiger une vue en base
+    // grisait le bouton sur tout le portail des qu'aucune vue n'existait sur
+    // ce domaine, alors que la selection etait bien a l'ecran.
+    if (!source.current.value) {
+      return (
+        pageViews.value.length > 0 ||
+        viewBrandsFromCriteria(views.current.value?.criteria?.() ?? []).length > 0
+      );
+    }
+    return (
+      pageViews.value.length > 0 ||
+      (views.current.value?.criteria?.().length ?? 0) > 0
+    );
+  });
+
+  const create = async (payload: {
+    title: string;
+    /** `product` : des marques, sur tout le hub. Defaut : une vue. */
+    kind?: "view" | "product";
+    brands?: string[];
+    /** Vue a surveiller. Absent : la vue active. */
+    viewId?: string | null;
+    triggers: AlertTrigger[];
+    watchedFields: string[];
+    channels?: string[];
+    cadence?: string;
+    visibility?: "private" | "workspace";
+  }) => {
+    const declared = source.current.value;
+    const product = payload.kind === "product";
+    // La vue nommee par la modale l'emporte : elle vient d'etre appliquee a
+    // l'ecran, donc c'est bien elle que la requete decrit. Pas de repli sur
+    // la premiere vue de la page : quand la vue active est temporaire,
+    // l'alerte s'accrocherait a une vue qui n'a rien a voir avec l'ecran.
+    //
+    // Une alerte de produit, elle, ne surveille aucune vue : elle nomme des
+    // marques, couvre tous les index du hub et ne tient d'aucune page. Elle
+    // garde pourtant l'identifiant de la vue active quand il y en a une : c'est
+    // par lui que `useAlertBrandSync` la retrouve pour proposer de suivre les
+    // marques de la vue. Il ne sert qu'a ce lien, jamais a l'affichage, qui se
+    // decide sur `kind`.
+    const pulseId = product
+      ? (watchableView.value?.id ?? null)
+      : (payload.viewId ?? watchableView.value?.id ?? null);
+    if (!product && (!pulseId || !declared)) return null;
+
+    const alert = await elysiaApi.alerts.create({
+      pulseId: pulseId ?? undefined,
+      kind: payload.kind,
+      brands: payload.brands,
+      title: payload.title,
+      // Une alerte de produit n'a ni index ni requete : le moteur les engendre
+      // pour les sept index du hub.
+      index: product ? undefined : declared!.index,
+      // Relue maintenant : c'est l'ecran tel qu'il est, pas tel qu'il etait a
+      // l'ouverture du panneau.
+      query: product ? undefined : declared!.query(),
+      resourceType: product ? undefined : declared!.resourceType,
+      // L'API nomme l'app par son registre quand elle connait l'hote ; ce
+      // nom-ci sert de repli, pour que le digest ne dise pas « OIP » a un
+      // client tant que l'app n'y est pas inscrite.
+      appName: String(useRuntimeConfig().public.app_name ?? "") || undefined,
+      watchedFields: payload.watchedFields,
+      // Les libelles partent avec l'alerte : seule l'app les traduit, et le
+      // digest ne peut pas ecrire `last_price_update` dans la boite d'un
+      // client.
+      fieldLabels: Object.fromEntries(
+        (declared?.fields ?? [])
+          .filter(
+            (field) =>
+              // « * » suit le document entier : tous les libelles servent.
+              payload.watchedFields.includes("*") ||
+              payload.watchedFields.includes(field.value),
+          )
+          .map((field) => [field.value, field.label]),
+      ),
+      labelFields: product ? ["label", "brand"] : declared!.labelFields,
+      triggers: payload.triggers,
+      channels: payload.channels,
+      cadence: payload.cadence,
+      visibility: payload.visibility,
+    });
+
+    if (alert) {
+      alerts.value = [alert, ...alerts.value];
+      // Pas d'attente : la modale se ferme, la carte se met a jour derriere.
+      followSeeding();
+    }
+    return alert;
+  };
+
+  const update = async (
+    id: string,
+    payload: Parameters<typeof elysiaApi.alerts.update>[1],
+  ) => {
+    const updated = await elysiaApi.alerts.update(id, payload);
+    if (updated) {
+      alerts.value = alerts.value.map((alert) =>
+        alert.id === id ? { ...alert, ...updated } : alert,
+      );
+    }
+    return updated;
+  };
+
+  const remove = async (id: string) => {
+    await elysiaApi.alerts.delete(id);
+    alerts.value = alerts.value.filter((alert) => alert.id !== id);
+  };
+
+  /**
+   * Repointe une alerte perimee sur la requete courante de la page.
+   *
+   * Ne marche que depuis la page surveillee, seule a savoir construire la
+   * requete. L'alerte repart d'une nouvelle reference : l'ancienne repondait a
+   * une autre question.
+   */
+  const rearm = async (id: string) => {
+    const declared = source.current.value;
+    if (!declared) return null;
+    const result = await elysiaApi.alerts.rearm(id, {
+      query: declared.query(),
+      index: declared.index,
+    });
+    await load(true);
+    return result;
+  };
+
+  /** Rejoue une alerte et relit la liste : le resultat se voit tout de suite. */
+  const runNow = async (id: string) => {
+    const result = await elysiaApi.alerts.run(id);
+    await load(true);
+    return result;
+  };
+
+  /** Envoie son propre digest tout de suite. */
+  const simulate = async (
+    id: string,
+    payload: { kind?: "appeared" | "changed" | "disappeared"; count?: number; sources?: number } = {},
+  ) => {
+    const result = await elysiaApi.alerts.simulate(id, payload);
+    await load(true);
+    return result;
+  };
+
+  const sendDigestNow = async () => elysiaApi.alerts.runDigest();
+
+  const events = async (id: string, limit = 50): Promise<AlertEvent[]> => {
+    const response = await elysiaApi.alerts.events(id, limit);
+    return response?.events ?? [];
+  };
+
+  const markRead = async (payload: { alertId?: string; eventIds?: string[] }) => {
+    const result = await elysiaApi.alerts.markRead(payload);
+    if (payload.alertId) {
+      alerts.value = alerts.value.map((alert) =>
+        alert.id === payload.alertId ? { ...alert, unreadCount: 0 } : alert,
+      );
+    }
+    return result;
+  };
+
+  return {
+    alerts,
+    loading,
+    creating,
+    load,
+    followSeeding,
+    unreadTotal,
+    fromThisApp,
+    forCurrentPage,
+    watchableView,
+    pageViews,
+    canCreate,
+    create,
+    update,
+    remove,
+    rearm,
+    events,
+    markRead,
+    testCadence,
+    runNow,
+    simulate,
+    sendDigestNow,
+  };
+}
+
+/**
+ * Deux chemins qui designent la meme page. Meme raison que dans `useViews` :
+ * `trailingSlash` est actif et les vues d'un lien profond portent le chemin
+ * sans barre finale.
+ */
+function samePage(a: unknown, b: unknown): boolean {
+  return String(a ?? "").replace(/\/$/, "") === String(b ?? "").replace(/\/$/, "");
+}