@tekkare/romulus 0.1.242 → 0.1.244

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/postLoginRedirect.ts

@@ -0,0 +1,58 @@
+/**
+ * Post-login redirect handling.
+ *
+ * When an unauthenticated user hits a protected deep link, the auth middleware
+ * bounces them to `/?redirect=<path>`. That query param is enough for in-SPA
+ * login flows, but it is lost as soon as we leave the app (OAuth round-trip
+ * through FusionAuth, magic-link email opened later). We therefore also persist
+ * the intended destination in sessionStorage so it survives a full reload.
+ */
+
+const STORAGE_KEY = "postLoginRedirect";
+
+/**
+ * Only accept in-app relative paths to avoid open-redirect attacks.
+ * Must start with a single "/" (not "//" or "/\" which browsers treat as
+ * protocol-relative external URLs).
+ */
+function isSafeRedirectPath(target: unknown): target is string {
+  return (
+    typeof target === "string" &&
+    target.startsWith("/") &&
+    !target.startsWith("//") &&
+    !target.startsWith("/\\")
+  );
+}
+
+/** Persist the intended destination (no-op if invalid). */
+export function savePostLoginRedirect(target: unknown): void {
+  if (import.meta.client && isSafeRedirectPath(target)) {
+    sessionStorage.setItem(STORAGE_KEY, target);
+  }
+}
+
+/**
+ * Resolve the best post-login destination without mutating storage: query
+ * param first (most explicit), then persisted storage, then "/".
+ */
+export function getPostLoginRedirect(queryRedirect?: unknown): string {
+  if (isSafeRedirectPath(queryRedirect)) {
+    return queryRedirect;
+  }
+  if (import.meta.client) {
+    const stored = sessionStorage.getItem(STORAGE_KEY);
+    if (isSafeRedirectPath(stored)) {
+      return stored;
+    }
+  }
+  return "/";
+}
+
+/** Same as getPostLoginRedirect but clears storage so it is used only once. */
+export function takePostLoginRedirect(queryRedirect?: unknown): string {
+  const target = getPostLoginRedirect(queryRedirect);
+  if (import.meta.client) {
+    sessionStorage.removeItem(STORAGE_KEY);
+  }
+  return target;
+}

package/layer/app/utils/valueTable.ts

@@ -0,0 +1,126 @@
+/**
+ * valueTable - un tableau Auriga rendu par RmTable.
+ *
+ * Les analyses du portail construisent leurs tableaux comme `arg-table` les
+ * attendait : une liste de libelles de tete, et des lignes `{ values: [...] }`
+ * dans le meme ordre. RmTable, lui, lit des colonnes nommees et des lignes
+ * indexees par ces noms. La conversion est mecanique : elle vit ici plutot que
+ * recopiee dans chaque composant, et le calcul des valeurs reste ou il est.
+ *
+ * Les colonnes portent des cles positionnelles (`c0`, `c1`...) : les libelles
+ * de tete sont traduits et ne font pas des cles stables. `valueKeys` donne les
+ * colonnes de valeurs, celles dont le composant rend le contenu par un slot.
+ *
+ * `types` reprend `column-type` d'`arg-table`, `style` reprend `columnStyle`.
+ */
+export interface ValueTableRow {
+  values: any[];
+}
+
+export interface ValueTableStyle {
+  /** Parts de largeur, comme `columnStyle.size` d'`arg-table`. */
+  size?: readonly number[];
+  /** Alignements imposes, comme `columnStyle.align`. Priment sur `types`. */
+  align?: readonly ("left" | "right" | "center")[];
+  /**
+   * Largeur plancher par colonne (CSS). A la difference de `size`, qui repartit
+   * la place restante, elle ne se rogne pas : la table defile plutot que
+   * d'ecraser une colonne de libelles longs.
+   */
+  minWidth?: readonly (string | undefined)[];
+}
+
+export function valueTable(
+  heads: any[],
+  contents: any[],
+  types?: any[],
+  style?: ValueTableStyle,
+) {
+  // Sans types, la premiere colonne porte le libelle et les suivantes des
+  // valeurs. Certains tableaux en ont deux (le nom puis le code) : leurs types
+  // de colonnes le disent deja, une colonne sans type ne porte pas un nombre.
+  // `url` est la colonne d'action d'`arg-table` : un bouton se centre.
+  const alignOf = (index: number): "left" | "right" | "center" => {
+    if (style?.align?.[index]) return style.align[index];
+    if (!types) return index === 0 ? "left" : "right";
+    if (!types[index]) return "left";
+    return types[index] === "url" ? "center" : "right";
+  };
+
+  // `arg-table` reglait la largeur des colonnes par des parts (`size: [1, 4, 1]`)
+  // : la colonne a 4 prend quatre fois la place de celle a 1. RmTable prend une
+  // largeur CSS, on rend donc la part en pourcentage du total.
+  const sizes = style?.size;
+  const total = sizes ? sizes.reduce((sum, part) => sum + part, 0) : 0;
+  const widthOf = (index: number) =>
+    sizes && total && sizes[index]
+      ? `${Math.round((sizes[index] * 1000) / total) / 10}%`
+      : undefined;
+
+  const allColumns = heads.map((label: any, index: number) => ({
+    key: `c${index}`,
+    label: String(label),
+    sortable: true,
+    align: alignOf(index),
+    width: widthOf(index),
+    minWidth: style?.minWidth?.[index],
+  }));
+
+  // La colonne de type `More` d'`arg-table` ne portait pas une valeur a lire :
+  // elle tenait le chevron de depliage et la charge utile du detail. RmTable
+  // pose son propre chevron (`expandable`) dans une colonne a lui, celle-ci
+  // sort donc de la tete ; la charge reste dans la ligne, sous sa cle, ou le
+  // slot `expanded` va la chercher.
+  const moreIndex = (types ?? []).findIndex((type: any) => type === "More");
+  // Cle vide plutot que `null` quand la table n'a pas de colonne `More` : les
+  // pages lisent `row[table.moreKey]` dans leurs slots, et une cle nullable ne
+  // s'indexe pas. Une cle vide ne designe aucune colonne, ce que `null`
+  // disait deja.
+  const moreKey = moreIndex >= 0 ? `c${moreIndex}` : "";
+  const columns = allColumns.filter((column) => column.key !== moreKey);
+
+  const rows = (Array.isArray(contents) ? contents : [])
+    .filter((row: any) => Array.isArray(row?.values))
+    .map((row: ValueTableRow) =>
+      Object.fromEntries(row.values.map((value, index) => [`c${index}`, value])),
+    );
+
+  // `arg-table` nommait ses slots de cellule par le type de colonne
+  // (`#Date`, `#Price`), plusieurs colonnes pouvant partager un type. RmTable
+  // nomme les siens par la cle de colonne : `typeKeys` dit quelles cles porte
+  // un type, pour que la page rende le slot une fois par cle.
+  const typeKeys: Record<string, string[]> = {};
+  (types ?? []).forEach((type: any, index: number) => {
+    if (!type || type === "More" || !allColumns[index]) return;
+    (typeKeys[type] ??= []).push(allColumns[index]!.key);
+  });
+
+  return {
+    columns,
+    rows,
+    typeKeys,
+    /** Vrai quand la table avait une colonne `More` : passer `expandable` a RmTable. */
+    expandable: moreIndex >= 0,
+    /** Cle ou vit la charge utile du detail, a lire dans le slot `expanded`. Vide sans colonne `More`. */
+    moreKey,
+    valueKeys: columns.slice(1).map((column) => column.key),
+  };
+}
+
+/**
+ * Les cles de colonne qui portent un type donne, quand la table a ete
+ * construite sans ses `types` : `columnKeysOfType(tableTypes, "int")` rend
+ * `["c2", "c3"]`, de quoi rendre le slot de cellule une fois par colonne.
+ *
+ * C'est le pendant de `typeKeys` ci-dessus pour les tableaux qui gardent
+ * leurs types a part, parce que les passer a `valueTable` changerait aussi
+ * l'alignement des colonnes. Vingt et un composants le recopiaient, sous
+ * trois ecritures differentes.
+ */
+export const columnKeysOfType = (
+  types: readonly any[] | undefined,
+  wanted: string,
+): string[] =>
+  (types ?? [])
+    .map((type, index) => (type === wanted ? `c${index}` : null))
+    .filter((key): key is string => key !== null);

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));
+}