@tekkare/romulus 0.1.243 → 0.1.245

package/layer/app/utils/oipScopes.ts

@@ -0,0 +1,376 @@
+// Composable for scope operations - Using Pulses REST API (Virtual Lab)
+
+import { storeToRefs } from "pinia";
+import { useOipApi } from "#oip-app/api";
+import { oipSnackbar, oipTrack } from "#oip-app/ui";
+import type { defineOipScopeStore } from "./oipScopeStore";
+
+/**
+ * Fabrique du composable de vues enregistrees d'une famille (useScopes,
+ * useHeartScopes...) : memes appels a la Virtual Lab (pulses), seul le store
+ * change.
+ */
+export function createOipScopes(scopeStore: ReturnType<typeof defineOipScopeStore>) {
+  return function useScopes() {
+    // variables
+    const scopes = ref([] as Array<any>);
+    const scopeLoading = ref(false as boolean);
+    const scopeError = ref(null as any);
+    const router = useRouter();
+    const scopePinia = scopeStore();
+    const scopeState = storeToRefs(scopePinia);
+    const elysiaApi = useOipApi();
+    // Par `$i18n` et non `useI18n` : ce composable est aussi appele hors d'un
+    // `setup` (tiroirs de selection, gestionnaires d'evenements), ou `useI18n`
+    // leve. Les snackbars parlent la langue de l'ecran, et de « vue », le nom
+    // que porte l'objet a l'ecran (« scope » ne reste que cote API).
+    const { $i18n } = useNuxtApp() as any;
+    const fr = () => $i18n?.locale?.value !== "en";
+    const say = (texts: { fr: string; en: string }) => (fr() ? texts.fr : texts.en);
+
+    // Load scopes using the Pulses REST API
+    async function getScopes() {
+      const domain = window.location.host;
+
+      try {
+        scopeLoading.value = true;
+        // `limit` explicite : l'API rend 100 pulses par defaut, les plus recents
+        // d'abord, et les exports conserves partagent ce magasin. Sans plafond
+        // releve, une vingtaine d'exports frais poussent les vues les plus
+        // anciennes hors de la fenetre, sans erreur ni message.
+        const response = await elysiaApi.pulses.list({ domain, limit: 500 });
+
+        // criteria must be a JSON string for backward compatibility with components
+        const mappedScopes = response.data.map((pulse) => ({
+          id: pulse.id,
+          user_id: pulse.userId,
+          title: pulse.title,
+          description: pulse.description || "",
+          url: pulse.url,
+          page: pulse.page,
+          criteria:
+            typeof pulse.criteria === "string"
+              ? pulse.criteria
+              : JSON.stringify(pulse.criteria || []),
+          starred: pulse.starred ?? false,
+          isDefault: pulse.isDefault ?? false,
+          // Partage : la vue peut venir de quelqu'un d'autre. `isOwner` decide
+          // de ce que l'ecran laisse faire, jamais l'egalite des identifiants
+          // d'utilisateur, que le pulse d'une vue partagee ne porte pas.
+          visibility: pulse.visibility ?? "private",
+          isOwner: pulse.isOwner ?? true,
+          ownerName: pulse.ownerName ?? null,
+          sharedWith: pulse.sharedWith ?? [],
+          // Publication en template Tekkare : le dialogue de partage en a
+          // besoin pour rouvrir sur ce qui est deja pose.
+          isTemplate: pulse.isTemplate ?? false,
+          targetWorkspaces: pulse.targetWorkspaces ?? [],
+          createdAt: pulse.createdAt,
+          projects: pulse.projects || [],
+        }));
+
+        scopes.value = mappedScopes;
+        scopePinia.setList(scopes.value);
+        scopeLoading.value = false;
+      } catch (err) {
+        scopeLoading.value = false;
+        scopeError.value = err;
+        console.error("[useScopes] Error loading scopes:", err);
+      }
+    }
+
+    interface newScopeObject {
+      title: String;
+      description?: String;
+      criteria: Array<criteriaArray>;
+      currentPage?: String;
+    }
+
+    interface criteriaArray {
+      filter: String;
+      page?: String;
+      values: any;
+    }
+
+    // Save new scope using the Pulses REST API
+    async function createScope({
+      title = "",
+      description = "",
+      criteria = [],
+      currentPage,
+    }: newScopeObject) {
+      const url = window.location.href;
+      const page = currentPage ?? router.currentRoute.value.path;
+
+      try {
+        scopeLoading.value = true;
+        oipSnackbar([
+          { attribute: "isVisible", value: true },
+          { attribute: "text", value: say({ fr: "Enregistrement de la vue", en: "Saving your view" }) },
+          { attribute: "loader", value: true },
+        ]);
+
+        await elysiaApi.pulses.create({
+          title: title as string,
+          description: description as string,
+          url: url,
+          page: page as string,
+          criteria: criteria, // sent as an object, API handles it
+        });
+
+        oipSnackbar([
+          { attribute: "isVisible", value: true },
+          {
+            attribute: "text",
+            value: say({ fr: "Vue enregistrée", en: "Your view has been saved" }),
+          },
+          { attribute: "loader", value: false },
+          { attribute: "prefixIcon", value: "Check" },
+          { attribute: "prefixIconColor", value: "#32D175" },
+          { attribute: "hasTimeOut", value: true },
+        ]);
+
+        scopeLoading.value = false;
+        oipTrack("scope_created", { title, page: page as string });
+
+        await getScopes();
+      } catch (err) {
+        scopeLoading.value = false;
+        scopeError.value = err;
+        console.error("[useScopes] Error creating scope:", err);
+        oipSnackbar([
+          { attribute: "isVisible", value: true },
+          {
+            attribute: "text",
+            value: say({
+              fr: "L'enregistrement de la vue a échoué",
+              en: "Something went wrong saving your view",
+            }),
+          },
+          { attribute: "hasTimeOut", value: true },
+          { attribute: "loader", value: false },
+        ]);
+      }
+    }
+
+    // Update existing scope using the Pulses REST API
+    async function updateScope({
+      id,
+      title = "",
+      description = "",
+      criteria = [],
+      currentPage,
+      refreshAlerts = true,
+    }: newScopeObject & {
+      id: string;
+      /**
+       * Faux quand les criteres ne bougent pas (un renommage) : les alertes de la
+       * vue n'ont rien a repointer, et la requete de l'ecran courant n'a rien a
+       * faire dans une vue peut-etre retouchee depuis une autre page.
+       */
+      refreshAlerts?: boolean;
+    }) {
+      const url = window.location.href;
+      const page = currentPage ?? router.currentRoute.value.path;
+
+      try {
+        scopeLoading.value = true;
+        oipSnackbar([
+          { attribute: "isVisible", value: true },
+          { attribute: "text", value: say({ fr: "Mise à jour de la vue", en: "Updating your view" }) },
+          { attribute: "loader", value: true },
+        ]);
+
+        // Les alertes de cette vue portent une requete figee, que seule la page
+        // sait construire : l'envoyer permet a l'API de les repointer elle-meme.
+        // Sans elle, elles s'endorment et attendent un rearmement a la main.
+        const result = await elysiaApi.pulses.update(id, {
+          title: title as string,
+          description: description as string,
+          url: url,
+          page: page as string,
+          criteria: criteria,
+          ...(refreshAlerts ? alertRefreshPayload(page) : {}),
+        });
+
+        oipSnackbar([
+          { attribute: "isVisible", value: true },
+          {
+            attribute: "text",
+            value: `${say({ fr: "Vue mise à jour", en: "Your view has been updated" })}${alertRefreshNotice(result)}`,
+          },
+          { attribute: "loader", value: false },
+          { attribute: "prefixIcon", value: "Check" },
+          { attribute: "prefixIconColor", value: "#32D175" },
+          { attribute: "hasTimeOut", value: true },
+        ]);
+
+        scopeLoading.value = false;
+        oipTrack("scope_updated", { id, title, page: page as string });
+
+        await getScopes();
+      } catch (err) {
+        scopeLoading.value = false;
+        scopeError.value = err;
+        console.error("[useScopes] Error updating scope:", err);
+        oipSnackbar([
+          { attribute: "isVisible", value: true },
+          {
+            attribute: "text",
+            value: say({
+              fr: "La mise à jour de la vue a échoué",
+              en: "Something went wrong updating your view",
+            }),
+          },
+          { attribute: "hasTimeOut", value: true },
+          { attribute: "loader", value: false },
+        ]);
+      }
+    }
+
+    /**
+     * Favori et vue par defaut : deux marques portees par le pulse, ecrites
+     * seules.
+     *
+     * Elles ne passent pas par `updateScope` : celui-la reecrit titre,
+     * description et criteres, donc marquer un favori depuis une autre page que
+     * celle de la vue y ecraserait ses criteres. L'unicite de la vue par defaut
+     * (une par page) est tenue par l'API.
+     */
+    async function setStarred(id: string, starred: boolean) {
+      try {
+        await elysiaApi.pulses.setPrefs(id, { starred });
+        await getScopes();
+      } catch (err) {
+        scopeError.value = err;
+        console.error("[useScopes] Error starring scope:", err);
+      }
+    }
+
+    async function setDefault(id: string, isDefault: boolean) {
+      try {
+        await elysiaApi.pulses.setPrefs(id, { isDefault });
+        await getScopes();
+      } catch (err) {
+        scopeError.value = err;
+        console.error("[useScopes] Error setting default scope:", err);
+      }
+    }
+
+    /**
+     * A qui la vue est ouverte : personne, des gens nommes, tout l'espace.
+     *
+     * Reserve au proprietaire cote API. Les deux champs partent ensemble, la
+     * portee et la liste se lisant l'une l'autre : passer a « tout l'espace »
+     * sans vider la liste laisserait des destinataires que plus rien n'affiche.
+     *
+     * Rend l'issue de l'ecriture : refusee, elle ne change rien a l'ecran, et
+     * l'appelant doit pouvoir le dire. Un partage qui echoue en silence se lit
+     * comme un partage qui a marche.
+     */
+    async function shareScope(
+      id: string,
+      share: {
+        visibility: "private" | "workspace";
+        sharedWith: string[];
+        /**
+         * Publication en template Tekkare, quand le dialogue la propose
+         * (superadmin seul). Absents sinon : l'API refuse les champs a qui n'a
+         * pas le droit de les poser.
+         */
+        isTemplate?: boolean;
+        targetWorkspaces?: string[];
+        templateCriteria?: any;
+      },
+    ) {
+      try {
+        await elysiaApi.pulses.update(id, share);
+        await getScopes();
+        return true;
+      } catch (err) {
+        scopeError.value = err;
+        console.error("[useScopes] Error sharing scope:", err);
+        return false;
+      }
+    }
+
+    // Delete scope using the Pulses REST API
+    async function deleteScope(id: string) {
+      try {
+        scopeLoading.value = true;
+        await elysiaApi.pulses.delete(id as string);
+        scopeLoading.value = false;
+        await getScopes();
+      } catch (err) {
+        scopeLoading.value = false;
+        scopeError.value = err;
+        console.error("[useScopes] Error deleting scope:", err);
+      }
+    }
+
+    const scopeList = computed(() => {
+      return scopeState.list.value;
+    });
+
+    const selectedScope = computed(() => {
+      return scopeState.selectedScope.value;
+    });
+
+    const scopeLoadingState = computed(() => {
+      return scopeLoading.value as boolean;
+    });
+
+    function clearScope() {
+      scopePinia.clearScope();
+      clearAppFilters();
+      oipTrack("scope_cleared", {});
+    }
+
+    function setSelectedScope(scope: any) {
+      scopePinia.setScoped(true);
+      scopePinia.setSelectedScope(scope);
+
+      // Parse criteria if it's a string (backward compatibility)
+      let criteriaData = scope?.criteria;
+      if (typeof criteriaData === "string") {
+        try {
+          criteriaData = JSON.parse(criteriaData);
+        } catch (e) {
+          console.error("[useScopes] Error parsing criteria:", e);
+          criteriaData = [];
+        }
+      }
+
+      scopePinia.setScopeFilter(criteriaData);
+      oipTrack("scope_applied", { scopeId: scope?.id, title: scope?.title });
+    }
+
+    const getAppFilters = computed(() => {
+      return scopePinia.appFilters;
+    });
+
+    function clearAppFilters() {
+      scopePinia.clearAppFilters();
+    }
+
+    return {
+      scopes,
+      scopeLoading,
+      scopeError,
+      getScopes,
+      createScope,
+      updateScope,
+      setStarred,
+      setDefault,
+      shareScope,
+      deleteScope,
+      scopeList,
+      setSelectedScope,
+      selectedScope,
+      getAppFilters,
+      clearAppFilters,
+      clearScope,
+      scopeLoadingState,
+    };
+  };
+}

package/layer/app/utils/viewPages.ts

@@ -0,0 +1,30 @@
+/**
+ * Pages de vues : une vue enregistree sur une page vaut pour les pages de sa
+ * famille (portail, PHMEV...), et les anciennes cles de page restent lues.
+ * Les familles et les alias historiques sont propres a l'app (contrat
+ * #oip-app/views) ; la regle vit ici.
+ */
+import { LEGACY_VIEW_PAGES, VIEW_PAGE_FAMILIES } from "#oip-app/views";
+import { normalizePage } from "./viewTemplates";
+
+/** La cle de page d'une vue, dans la forme du jour. */
+export function canonicalViewPage(path: unknown): string {
+  const page = normalizePage(String(path ?? ""));
+  return LEGACY_VIEW_PAGES[page] ?? page;
+}
+
+/** Les pages dont les vues valent pour `path`, `path` compris. */
+export function viewPageFamily(path: unknown): string[] {
+  const page = canonicalViewPage(path);
+  return VIEW_PAGE_FAMILIES.find((family) => family.includes(page)) ?? [page];
+}
+
+/**
+ * Deux chemins qui designent la meme page, ou deux pages d'une meme famille.
+ * Prefixe de langue et barre finale ne comptent pas : une vue posee par un
+ * lien profond porte le chemin sans barre finale, la page l'a (`trailingSlash`),
+ * et un lecteur en anglais enregistre sous `/en/...`.
+ */
+export function sameViewPage(a: unknown, b: unknown): boolean {
+  return viewPageFamily(a).includes(canonicalViewPage(b));
+}

package/layer/app/utils/viewTemplateCriteria.ts

@@ -0,0 +1,215 @@
+/**
+ * viewTemplateCriteria - les criteres d'un template, tels qu'ils sont ranges.
+ *
+ * Un template publie par Tekkare est une vue enregistree, et une vue
+ * enregistree stocke des LIBELLES : « Insuffisant », « Oncologie: true »,
+ * « 30 derniers jours ». Ces libelles sont ecrits dans la langue de qui a
+ * pose les filtres. Range tel quel, un template ecrit en francais ouvre un
+ * ecran vide chez un lecteur anglais.
+ *
+ * On range donc la CLE plutot que le libelle a chaque fois qu'elle existe.
+ * Quatre mecanismes du catalogue en dur (`~/utils/viewTemplates`) traduisent
+ * leur valeur, et tous les quatre la tirent de l'i18n :
+ *
+ * | mecanisme            | ce qui est traduit          | ce qu'on range |
+ * |----------------------|-----------------------------|----------------|
+ * | periode relative     | « 30 derniers jours »       | `last30`       |
+ * | filtre booleen       | « Oncologie: true »         | `oncology`     |
+ * | onglet des avis HAS  | « Indications »             | `indic`        |
+ * | page Prix            | le NOM du filtre            | sa cle i18n    |
+ *
+ * Le reste des valeurs est neutre : « Liste en sus », « Commercialisée »,
+ * « Brand », les marques, les codes ATC, les laboratoires. Elles viennent des
+ * index, sortis de sources francaises, et un lecteur anglais les voit deja
+ * telles quelles aujourd'hui. Rien a faire pour elles.
+ *
+ * Reste une poignee de filtres dont les valeurs existent vraiment en deux
+ * orthographes, parce que l'index porte un champ `_fr` et un champ `_en`
+ * (cf. `LANGUAGE_BOUND`). Leur paire ne vit ni dans l'i18n ni dans le code :
+ * la resoudre demande une requete au cluster. La v1 ne la resout pas, elle
+ * range la valeur telle quelle avec la langue d'ecriture, et le dialogue de
+ * publication previent. Le jour ou le resolveur arrive, il remplit le cote
+ * manquant sans toucher une seule ligne deja enregistree : c'est tout
+ * l'interet de ranger une forme, et pas une chaine.
+ */
+import {
+  HAS_TABS,
+  LANGUAGE_BOUND,
+  PERIOD_FILTER,
+  PERIOD_SHORTCUTS,
+  TRANSLATED_FILTER_NAMES,
+} from "#oip-app/views";
+import { VIEW_PREFS_FILTER } from "../composables/useViews";
+
+export { LANGUAGE_BOUND };
+
+/** Langue d'ecriture d'un template. */
+export type TemplateLang = "fr" | "en";
+
+export interface TemplateCriteriaContext {
+  lang: TemplateLang;
+  t: (key: string) => string;
+  te: (key: string) => boolean;
+  /** Prefixe i18n des libelles de filtres de la page, sans le point final. */
+  namespace: string;
+}
+
+/**
+ * Un critere range. `kind` dit comment le relire :
+ * - `values` : les valeurs telles quelles, eventuellement dans les deux
+ *   langues quand la paire est connue ;
+ * - `check` / `tab` : une cle i18n, dont on refait le libelle a la lecture ;
+ * - `period` : un raccourci de periode, qui reste glissant.
+ */
+export interface StoredCriterion {
+  filter: string;
+  /** Cle i18n du NOM du filtre, quand c'est lui qui est traduit (page Prix). */
+  filterKey?: string;
+  kind: "values" | "check" | "tab" | "period";
+  /** `kind: "values"` sans paire connue. */
+  values?: string[];
+  /** `kind: "values"` avec sa paire, quand elle est connue. */
+  localized?: Record<TemplateLang, string[]>;
+  /** `kind` autre que `values` : la cle a relire. */
+  key?: string;
+  /** Langue d'ecriture, pour les valeurs qu'on ne sait pas encore traduire. */
+  lang?: TemplateLang;
+}
+
+// Filtres et libelles propres a l'app (periode, onglets, filtres traduits,
+// filtres lies a la langue) : contrat #oip-app/views.
+
+
+/** Les valeurs d'un critere, que la periode les garde en chaine ou non. */
+function valuesOf(item: any): string[] {
+  if (Array.isArray(item?.values)) return item.values.map(String);
+  return item?.values !== undefined && item?.values !== null ? [String(item.values)] : [];
+}
+
+/** La cle dont la traduction vaut `label`, parmi `keys`. */
+function keyOf(
+  keys: string[],
+  prefix: string,
+  label: string,
+  ctx: TemplateCriteriaContext,
+): string | null {
+  return (
+    keys.find((key) => ctx.te(`${prefix}${key}`) && ctx.t(`${prefix}${key}`) === label) ?? null
+  );
+}
+
+/**
+ * Range les criteres d'un ecran, dans la langue de qui les a poses.
+ *
+ * Ce qui n'est reconnu par aucun des quatre mecanismes part en valeurs
+ * telles quelles : c'est le cas de la grande majorite, et c'est le bon
+ * defaut — une valeur neutre rangee comme neutre se relit a l'identique.
+ */
+export function encodeCriteria(
+  criteria: any[],
+  ctx: TemplateCriteriaContext,
+): StoredCriterion[] {
+  return (criteria ?? []).map((item) => {
+    const filter = String(item?.filter ?? "");
+    const values = valuesOf(item);
+
+    // Les preferences de cartes ne sont pas un filtre : elles voyagent dans
+    // les criteres faute d'un autre champ libre, et ne se traduisent pas.
+    if (filter === VIEW_PREFS_FILTER) {
+      return { filter, kind: "values" as const, values };
+    }
+
+    // Le NOM du filtre est traduit : on range sa cle, pas son libelle.
+    const filterKey = TRANSLATED_FILTER_NAMES.find(
+      (key) => ctx.te(key) && ctx.t(key) === filter,
+    );
+    if (filterKey) {
+      return { filter, filterKey, kind: "values" as const, values, lang: ctx.lang };
+    }
+
+    // Periode relative : le raccourci reste glissant, les deux dates non.
+    if (filter === PERIOD_FILTER && values.length === 1) {
+      const key = keyOf(PERIOD_SHORTCUTS, "heart.period.", values[0]!, ctx);
+      if (key) return { filter, kind: "period" as const, key };
+    }
+
+    // Filtre booleen : la vue stocke « <libelle du filtre>: true ».
+    if (values.length === 1 && values[0]!.endsWith(": true")) {
+      const label = values[0]!.slice(0, -": true".length);
+      const key = `${ctx.namespace}.${filter}`;
+      if (ctx.te(key) && ctx.t(key) === label) {
+        return { filter, kind: "check" as const, key };
+      }
+    }
+
+    // Onglet des avis HAS.
+    if (filter === "Type" && values.length === 1) {
+      const key = keyOf(HAS_TABS, "heart.tabs.", values[0]!, ctx);
+      if (key) return { filter, kind: "tab" as const, key };
+    }
+
+    return {
+      filter,
+      kind: "values" as const,
+      values,
+      ...(LANGUAGE_BOUND.has(filter) && { lang: ctx.lang }),
+    };
+  });
+}
+
+/**
+ * Relit des criteres ranges, dans la langue de l'ecran.
+ *
+ * La periode rend une CHAINE et non un tableau : c'est ce que `rangePicker`
+ * attend, et c'est ce qui la garde relative.
+ */
+export function decodeCriteria(
+  stored: StoredCriterion[],
+  ctx: TemplateCriteriaContext,
+): Array<{ filter: string; values: string[] | string }> {
+  return (stored ?? []).map((item) => {
+    const filter = item.filterKey && ctx.te(item.filterKey)
+      ? ctx.t(item.filterKey)
+      : item.filter;
+
+    switch (item.kind) {
+      case "period":
+        return {
+          filter,
+          values: item.key && ctx.te(`heart.period.${item.key}`)
+            ? ctx.t(`heart.period.${item.key}`)
+            : (item.values?.[0] ?? ""),
+        };
+      case "check":
+        return {
+          filter,
+          values: [`${item.key && ctx.te(item.key) ? ctx.t(item.key) : filter}: true`],
+        };
+      case "tab":
+        return {
+          filter,
+          values: [
+            item.key && ctx.te(`heart.tabs.${item.key}`)
+              ? ctx.t(`heart.tabs.${item.key}`)
+              : (item.values?.[0] ?? ""),
+          ],
+        };
+      default:
+        return { filter, values: item.localized?.[ctx.lang] ?? item.values ?? [] };
+    }
+  });
+}
+
+/**
+ * Les filtres qui resteront dans la langue d'ecriture, parmi des criteres
+ * ranges. Ce que le dialogue de publication annonce avant d'enregistrer.
+ */
+export function languageBoundFilters(stored: StoredCriterion[]): string[] {
+  return [
+    ...new Set(
+      (stored ?? [])
+        .filter((item) => item.kind === "values" && !item.localized && LANGUAGE_BOUND.has(item.filter))
+        .map((item) => item.filter),
+    ),
+  ];
+}