@tekkare/romulus 0.1.243 → 0.1.245

package/layer/app/composables/useViewCardActions.ts

@@ -0,0 +1,500 @@
+/**
+ * Menu des cartes de vue et ce qu'il declenche : renommer, alerte, export,
+ * dupliquer, partager, par defaut, supprimer.
+ *
+ * Partage par le panneau « Mes vues » du rail et l'etat vide des pages a vue
+ * obligatoire : les memes cartes doivent offrir le meme menu aux deux
+ * endroits, sans deux copies du partage a tenir a jour. Chaque appelant monte
+ * son propre `RmShareDialog` sur ce que renvoie le composable.
+ *
+ * `apply` reste a l'appelant : l'etat vide ramene la vue sur le chemin de la
+ * page, le panneau l'applique telle quelle.
+ */
+import { useOipApi } from "#oip-app/api";
+import { oipSnackbar } from "#oip-app/ui";
+import { encodeCriteria, languageBoundFilters } from "../utils/viewTemplateCriteria";
+
+export function useViewCardActions(apply: (id: string) => void) {
+const { locale, t, te } = useI18n();
+const views = useViews();
+const alerts = useAlerts();
+const editing = useViewEditing();
+
+const source = computed(() => views.current.value);
+const filterLabel = useViewFilterLabels(() => source.value?.filterNamespace);
+const store = () => views.scopes.value();
+const selected = computed(() => views.active.value);
+const parseCriteria = parseViewCriteria;
+
+function scopeOf(id: string) {
+  return store().scopeList.value.find((scope: any) => scope.id === id) ?? null;
+}
+
+/*
+ * Les menus de carte, declares avant `cardsOf` qui les lit.
+ *
+ * Ils vivaient plus bas, et un `watch` sur la liste des vues recues evaluait
+ * sa source des le `setup` : la carte d'une vue partagee allait chercher son
+ * menu avant la ligne qui le declare. En developpement rien ne se voyait ; le
+ * bundle, lui, jetait « Cannot access ... before initialization » et vidait
+ * l'ecran — chez le destinataire d'un partage, lui seul, puisque lui seul a
+ * une vue qui n'est pas la sienne.
+ */
+/** Le libelle dit ce que le clic va faire, pas juste ce qu'est l'entree :
+    une vue deja par defaut doit pouvoir se retirer, pas se redefinir. */
+function defaultEntry(isDefault: boolean) {
+  return {
+    key: "default",
+    label: isDefault
+      ? (locale.value === "en" ? "Remove as default" : "Retirer par défaut")
+      : (locale.value === "en" ? "Set as default" : "Définir par défaut"),
+    icon: "PushPin",
+  };
+}
+
+/**
+ * Raccourci vers le formulaire d'alerte, sur la vue de la carte.
+ *
+ * Avant, il fallait appliquer la vue, passer sur l'onglet Alertes, ouvrir la
+ * modale et y rechoisir la vue. Une vue recue le propose aussi : l'API
+ * accepte une alerte sur toute vue que le lecteur voit.
+ */
+const alertEntry = computed(() => ({
+  key: "alert",
+  label: locale.value === "en" ? "Create an alert" : "Créer une alerte",
+  icon: "Bell",
+}));
+
+/**
+ * Raccourci vers le classeur Excel de la vue : l'appliquer, puis laisser la
+ * tuile Export generer avec sa recette par defaut (tous onglets, toutes
+ * colonnes). Demande client : garder une selection dans Excel sans passer par
+ * le panneau. Absent quand la page n'exporte rien.
+ */
+const exportSource = useExportSource();
+const exportEntry = computed(() =>
+  exportSource.has.value
+    ? [{ key: "export", label: locale.value === "en" ? "Export to Excel" : "Exporter en Excel", icon: "FileXls" }]
+    : [],
+);
+
+const duplicateEntry = computed(() => ({
+  key: "duplicate",
+  label: locale.value === "en" ? "Duplicate" : "Dupliquer",
+  icon: "Copy",
+}));
+
+function ownerMenu(scope: any) {
+  const isDefault = scope.isDefault === true;
+  return [
+    // Le formulaire complet (nom, description, contenu), celui de la pastille
+    // de vue : renommer sur place ne laissait toucher qu'au titre.
+    {
+      key: "edit",
+      label: locale.value === "en" ? "Edit" : "Modifier",
+      icon: "PencilSimple",
+    },
+    alertEntry.value,
+    ...exportEntry.value,
+    duplicateEntry.value,
+    {
+      key: "share",
+      label: locale.value === "en" ? "Share" : "Partager",
+      icon: "UsersThree",
+    },
+    defaultEntry(isDefault),
+    {
+      key: "delete",
+      label: locale.value === "en" ? "Delete" : "Supprimer",
+      icon: "Trash",
+      danger: true,
+      confirm: true,
+      confirmText: deleteQuestion(scope),
+    },
+  ];
+}
+
+/**
+ * La question posee avant de supprimer. « Supprimer definitivement ? » suffit
+ * pour une vue que personne d'autre ne voit ; une vue partagee ou publiee en
+ * template disparait aussi chez ses lecteurs, et c'est ce qu'il faut dire.
+ */
+function deleteQuestion(scope: any): string | undefined {
+  const en = locale.value === "en";
+  const title = `« ${scope.title} »`;
+  if (scope.isTemplate) {
+    return en
+      ? `${title} is a Tekkare template offered to client workspaces. Deleting it removes it from all of them. Delete anyway?`
+      : `${title} est un template Tekkare offert à des espaces clients. La supprimer le retire chez tous. Supprimer quand même ?`;
+  }
+  if (isShared(scope)) {
+    const n = scope.sharedWith?.length ?? 0;
+    const who =
+      scope.visibility === "workspace"
+        ? en
+          ? "the whole workspace"
+          : "tout l'espace"
+        : en
+          ? `${n} ${n > 1 ? "people" : "person"}`
+          : `${n} personne${n > 1 ? "s" : ""}`;
+    return en
+      ? `${title} is shared with ${who}. Deleting it removes it for them too. Delete anyway?`
+      : `${title} est partagée avec ${who}. La supprimer la retire aussi chez eux. Supprimer quand même ?`;
+  }
+  return undefined;
+}
+
+/**
+ * Menu d'une vue recue : la marquer et la dupliquer, rien d'autre. Le favori
+ * et la vue par defaut sont des marques du lecteur, elles valent ici aussi ;
+ * renommer, partager et supprimer appartiennent au proprietaire.
+ *
+ * Dupliquer est la sortie de secours : qui veut changer les filtres d'une vue
+ * recue s'en fait une copie, qui devient la sienne.
+ */
+function readerMenu(isDefault: boolean) {
+  return [alertEntry.value, ...exportEntry.value, defaultEntry(isDefault), duplicateEntry.value];
+}
+
+/** La vue est ouverte a d'autres : a tout l'espace, ou a des gens nommes. */
+function isShared(scope: any): boolean {
+  return scope.visibility === "workspace" || (scope.sharedWith?.length ?? 0) > 0;
+}
+
+// ------------------------------------------------------------------- partage
+
+const elysia = useOipApi();
+const { data: session } = useAuth();
+
+/** Vue dont on regle le partage, ou null. */
+const sharingId = ref<string | null>(null);
+const sharing = computed({
+  get: () => sharingId.value !== null,
+  set: (open: boolean) => {
+    if (!open) sharingId.value = null;
+  },
+});
+const shareTarget = computed(() => (sharingId.value ? scopeOf(sharingId.value) : null));
+
+const members = ref<{ userId: string; name: string; email?: string }[]>([]);
+const membersLoaded = ref(false);
+
+/**
+ * Publication en template : reservee a qui administre la plateforme.
+ *
+ * Le portillon et la liste des espaces ne sont demandes qu'a l'ouverture du
+ * dialogue : sans cela, tout le monde paierait deux allers-retours pour une
+ * option que presque personne ne voit.
+ */
+const { isSuperAdmin, workspaces, ensureLoaded, ensureWorkspaces } = useAdminAccess();
+
+/**
+ * Ce que la publication ne saura pas traduire, dit avant d'enregistrer.
+ *
+ * Quelques filtres portent des valeurs qui existent en deux orthographes
+ * dans l'index (cf. `LANGUAGE_BOUND`) : leur paire ne vit ni dans l'i18n ni
+ * dans le code, et la v1 ne la resout pas. Le template s'affichera alors dans
+ * la langue ou il a ete ecrit, ce qui se dit plutot que se decouvre.
+ */
+const templateNote = computed(() => {
+  if (!shareTarget.value) return "";
+  const bound = languageBoundFilters(encodedCriteria(shareTarget.value));
+  if (!bound.length) return "";
+  const names = bound.map((filter) => filterLabel(filter)).join(", ");
+  return locale.value === "en"
+    ? `Kept in English: ${names}. Those values exist in one language only for now, so readers in French will see them as written.`
+    : `Gardé en français : ${names}. Ces valeurs n'existent pour l'instant que dans une langue, les lecteurs en anglais les verront telles quelles.`;
+});
+
+/** Les criteres d'une vue, ranges pour se relire dans les deux langues. */
+function encodedCriteria(scope: any) {
+  return encodeCriteria(parseCriteria(scope), {
+    lang: locale.value === "en" ? "en" : "fr",
+    t,
+    te: (key: string) => te(key),
+    namespace: source.value?.filterNamespace ?? "filters",
+  });
+}
+
+/**
+ * Membres de l'espace, moi excepte : se partager sa propre vue n'a pas de
+ * sens, et la ligne se lirait comme un destinataire de plus.
+ *
+ * Charges a la premiere ouverture du dialogue, pas au montage du panneau :
+ * la plupart des ouvertures de « Mes vues » ne partagent rien.
+ */
+async function loadMembers() {
+  if (membersLoaded.value) return;
+  membersLoaded.value = true;
+  try {
+    const response = await elysia.profile.getWorkspaceMembers();
+    const me = (session.value as any)?.user ?? {};
+    members.value = (response.members ?? [])
+      .filter(
+        (member: any) =>
+          member.email !== me.email && member.userId !== (me.id ?? me.sub),
+      )
+      .map((member: any) => ({
+        userId: member.userId,
+        name:
+          member.displayName ||
+          [member.firstName, member.lastName].filter(Boolean).join(" ") ||
+          member.email,
+        email: member.email,
+      }));
+  } catch (error) {
+    // Le dialogue reste utilisable : « tout l'espace » ne demande aucune liste.
+    membersLoaded.value = false;
+    console.error("[views] Error loading workspace members:", error);
+  }
+}
+
+async function openShare(id: string) {
+  sharingId.value = id;
+  outsiders.value = [];
+  await Promise.all([
+    loadMembers(),
+    ensureLoaded().then((admin) => (admin ? ensureWorkspaces() : [])),
+  ]);
+}
+
+/**
+ * Personnes hors de l'espace, trouvees par la recherche du dialogue.
+ *
+ * Un administrateur de la plateforme partage ses vues avec des gens
+ * d'espaces clients, qui ne sont pas membres du sien : la liste des membres
+ * ne les connait pas, la plateforme entiere si. La recherche part a chaque
+ * frappe (deux lettres au moins), le dialogue filtre ensuite lui-meme ; les
+ * membres de l'espace, deja listes, n'y sont pas repris. Ces personnes
+ * portent la mention « hors de l'espace » pour qu'on sache a qui on ouvre.
+ */
+const outsiders = ref<{ userId: string; name: string; email?: string; hint?: string }[]>([]);
+let outsiderSearch: ReturnType<typeof setTimeout> | null = null;
+
+const shareMembers = computed(() => [...members.value, ...outsiders.value]);
+
+function onShareSearch(query: string) {
+  if (!isSuperAdmin.value) return;
+  if (outsiderSearch) clearTimeout(outsiderSearch);
+  if (query.length < 2) {
+    outsiders.value = [];
+    return;
+  }
+  outsiderSearch = setTimeout(async () => {
+    try {
+      const response = await elysia.admin.users({ search: query, limit: 20 });
+      const known = new Set(members.value.map((member) => member.userId));
+      const me = (session.value as any)?.user ?? {};
+      outsiders.value = (response.users ?? [])
+        .filter((user) => !known.has(user.userId) && user.email !== me.email)
+        .map((user) => ({
+          userId: user.userId,
+          name:
+            user.displayName ||
+            [user.firstName, user.lastName].filter(Boolean).join(" ") ||
+            user.email,
+          email: user.email,
+          hint: locale.value === "en" ? "outside the workspace" : "hors de l'espace",
+        }));
+    } catch (error) {
+      console.error("[views] Error searching platform users:", error);
+    }
+  }, 250);
+}
+
+/** Un mot dans la barre du bas. Meme mecanisme que le panneau des alertes. */
+function notify(text: string) {
+  oipSnackbar([
+    { attribute: "isVisible", value: true },
+    { attribute: "text", value: text },
+    { attribute: "loader", value: false },
+    { attribute: "hasTimeOut", value: true },
+  ]);
+}
+
+/**
+ * Ce que le partage vient de faire, dit a l'ecran.
+ *
+ * Une vue partagee ne change presque rien a sa carte, et une publication
+ * refusee n'y change rien du tout : sans un mot, les deux se lisent pareil,
+ * c'est-a-dire comme si rien ne s'etait passe.
+ */
+function shareOutcome(
+  share: { visibility: string; sharedWith: string[]; isTemplate?: boolean },
+  targets: number,
+): string {
+  const en = locale.value === "en";
+  if (share.isTemplate) {
+    if (targets === 0) {
+      return en
+        ? "View published as a Tekkare template, offered to every workspace."
+        : "Vue publiée comme template Tekkare, offerte à tous les espaces.";
+    }
+    return en
+      ? `View published as a Tekkare template for ${targets} workspace${targets > 1 ? "s" : ""}.`
+      : `Vue publiée comme template Tekkare pour ${targets} espace${targets > 1 ? "s" : ""}.`;
+  }
+  if (share.visibility === "workspace") {
+    return en ? "View shared with the whole workspace." : "Vue partagée à tout l'espace.";
+  }
+  if (share.sharedWith.length) {
+    const n = share.sharedWith.length;
+    return en
+      ? `View shared with ${n} ${n > 1 ? "people" : "person"}.`
+      : `Vue partagée à ${n} personne${n > 1 ? "s" : ""}.`;
+  }
+  return en ? "View is private again." : "Vue redevenue privée.";
+}
+
+async function confirmShare(share: {
+  visibility: "private" | "workspace";
+  sharedWith: string[];
+  isTemplate?: boolean;
+  targetWorkspaces?: string[];
+}) {
+  const id = sharingId.value;
+  const target = shareTarget.value;
+  sharingId.value = null;
+  if (!id) return;
+
+  // Les criteres encodes ne partent qu'a la publication : ils vont dans leur
+  // propre colonne, et la vue garde les siens, ceux que l'ecran applique.
+  const ok = await store().shareScope(id, {
+    ...share,
+    ...(share.isTemplate && target && { templateCriteria: encodedCriteria(target) }),
+  });
+
+  if (ok) {
+    notify(shareOutcome(share, share.targetWorkspaces?.length ?? 0));
+    return;
+  }
+
+  // La publication est la seule portee que l'API peut refuser a qui a pu
+  // l'afficher : le portillon est relu cote serveur, et un compte qui perd
+  // son acces garde le dialogue ouvert jusqu'au rechargement.
+  notify(
+    share.isTemplate
+      ? locale.value === "en"
+        ? "Publishing the template was refused. Platform administration access is needed."
+        : "La publication du template a été refusée. Il faut un accès à l'administration de la plateforme."
+      : locale.value === "en"
+        ? "The view could not be shared."
+        : "Le partage de la vue n'a pas abouti.",
+  );
+}
+
+
+async function rename(id: string, title: string) {
+  const scope = scopeOf(id);
+  if (!scope) return;
+  await store().updateScope({
+    id,
+    title,
+    description: scope.description,
+    criteria: parseCriteria(scope),
+    currentPage: scope.page,
+    // Les criteres ne bougent pas : rien a repointer cote alertes, et la
+    // requete de l'ecran courant n'a rien a faire dans une vue qu'on renomme
+    // peut-etre depuis une autre page.
+    refreshAlerts: false,
+  });
+  // La vue active porte une copie : sans ce rappel, la banniere et le bandeau
+  // continueraient d'afficher l'ancien nom.
+  if (selected.value?.id === id) apply(id);
+}
+
+async function duplicate(id: string) {
+  const scope = scopeOf(id);
+  if (!scope) return;
+  const suffix = locale.value === "en" ? "copy" : "copie";
+  await store().createScope({
+    title: `${scope.title} (${suffix})`,
+    description: scope.description,
+    criteria: parseCriteria(scope),
+    currentPage: scope.page,
+  });
+}
+
+async function remove(id: string) {
+  if (selected.value?.id === id) store().clearScope();
+  await store().deleteScope(id);
+}
+
+function onAction(key: string, id: string) {
+  if (key === "edit") editView(id);
+  else if (key === "alert") createAlert(id);
+  else if (key === "export") exportView(id);
+  else if (key === "duplicate") duplicate(id);
+  else if (key === "share") openShare(id);
+  // Une entree de menu, deux sens : la poser sur la vue qui la porte deja la
+  // retire, comme le faisait le marquage local.
+  else if (key === "default") setDefault(id);
+  else if (key === "delete") remove(id);
+}
+
+/**
+ * Appliquer la vue, puis ouvrir son formulaire de modification : il compare la
+ * vue a l'ecran et retouche son contenu depuis la page, l'ecran doit donc la
+ * porter. Le cadre ouvre la tuile « Mes vues » des que `editing` est pose.
+ */
+function editView(id: string) {
+  apply(id);
+  editing.value = { id };
+}
+
+/**
+ * Appliquer la vue, puis ouvrir le formulaire d'alerte : la requete
+ * Elasticsearch part de l'ecran, il doit donc porter cette vue. Le formulaire
+ * preselectionne la vue active, et le cadre passe sur l'onglet Alertes des
+ * que `creating` monte (cf. LayoutShell).
+ */
+function createAlert(id: string) {
+  apply(id);
+  alerts.creating.value = true;
+}
+
+/**
+ * Appliquer la vue, puis demander le classeur : l'export part de l'ecran,
+ * il doit donc porter cette vue. Le cadre passe sur la tuile Export, qui
+ * lance la generation a son montage (cf. useExportSource.quick).
+ */
+function exportView(id: string) {
+  apply(id);
+  exportSource.quick.value = "xlsx";
+}
+
+/** Marquer par defaut, ou retirer la marque si la vue la porte deja. */
+async function setDefault(id: string) {
+  const scope = scopeOf(id);
+  if (!scope) return;
+  await store().setDefault(id, scope.isDefault !== true);
+}
+
+async function star(id: string) {
+  const scope = scopeOf(id);
+  if (!scope) return;
+  await store().setStarred(id, scope.starred !== true);
+}
+
+
+/** Le menu d'une carte : complet pour mes vues, reduit pour une vue recue. */
+function menuOf(scope: any) {
+  return scope.isOwner !== false ? ownerMenu(scope) : readerMenu(scope.isDefault === true);
+}
+
+return {
+  menuOf,
+  isShared,
+  onAction,
+  rename,
+  star,
+  sharing,
+  shareTarget,
+  shareMembers,
+  isSuperAdmin,
+  workspaces,
+  templateNote,
+  onShareSearch,
+  confirmShare,
+};
+}