@7365admin1/layer-common 4.116.0 → 4.117.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @iservice365/layer-common
 
+## 4.117.0
+
+### Minor Changes
+
+- 48657c4: Post-login "Accept Terms & Privacy Policy" screen for every web app. `01-auth` asks `GET /api/users/terms` once per page load; if the account has never accepted the live version (or a newer one was published) it goes to `/accept-terms`, which shows the Super Admin text and records acceptance with `POST /api/users/terms/accept`. An account that accepted is never asked again on any device or app. Fails open on any error or timeout. Print, PDF, preview, kiosk and public pages (plain layouts) and headless browsers are never interrupted.
+
 ## 4.116.0
 
 ### Minor Changes
@@ -3111,11 +3117,11 @@ Monthly report: a month that had patrols opens the list of that month's patrol r
   `utils/console-tier.ts` + `composables/useConsoleTier.ts` mirror the server's
   own rule from two endpoints the console already calls, unprojected:
 
-                                                                                                                                                                                                                                                                                                                                                                                                    GET /api/members/user/:user/app/admin    the Seven365 staff membership
-                                                                                                                                                                                                                                                                                                                                                                                                    GET /api/roles/id/:role                  that membership's role document
+                                                                                                                                                                                                                                                                                                                                                                                                      GET /api/members/user/:user/app/admin    the Seven365 staff membership
+                                                                                                                                                                                                                                                                                                                                                                                                      GET /api/roles/id/:role                  that membership's role document
 
-                                                                                                                                                                                                                                                                                                                                                                                                    owner  = member.type === "admin" && role.type === "admin" && role.default === true
-                                                                                                                                                                                                                                                                                                                                                                                                    staff  = member.type === "admin" && role.type === "admin"
+                                                                                                                                                                                                                                                                                                                                                                                                      owner  = member.type === "admin" && role.type === "admin" && role.default === true
+                                                                                                                                                                                                                                                                                                                                                                                                      staff  = member.type === "admin" && role.type === "admin"
 
   `role.default` is the marker because it is the only property of a platform
   staff role no API caller can set - `role.controller.ts` validates create and

package/composables/useTermsGate.ts

@@ -0,0 +1,65 @@
+import { shouldPrompt, type TermsGateReply } from "../utils/terms-gate";
+
+const TIMEOUT_MS = 5000;
+const FAIL_RETRY_MS = 60_000;
+
+type GateState = { sid: string; mustAccept: boolean; reply: TermsGateReply | null; failedAt: number };
+
+/**
+ * The post-login "Accept Terms and Privacy Policy" gate.
+ *
+ * Acceptance is stored per ACCOUNT on the server, so an account that has
+ * accepted the live version is never asked again (any device, any app); only a
+ * newly published version asks again. FAILS OPEN: any error, timeout or empty
+ * answer lets the user in and asks again later - this is a consent screen, not
+ * an API lock.
+ */
+export function useTermsGate() {
+  const { cookieConfig } = useRuntimeConfig().public;
+  const state = useState<GateState | null>("termsGate", () => null);
+
+  async function load(): Promise<TermsGateReply | null> {
+    try {
+      return await useNuxtApp().$api<TermsGateReply>("/api/users/terms", { timeout: TIMEOUT_MS, retry: 0 });
+    } catch {
+      return null;
+    }
+  }
+
+  /** True when this account must accept before continuing. */
+  async function check(force = false): Promise<boolean> {
+    const sid = String(useCookie("sid", cookieConfig).value ?? "");
+    if (!sid) return false;
+    if (import.meta.client && navigator.onLine === false) return false;
+
+    const s = state.value;
+    if (!force && s && s.sid === sid) {
+      if (!s.failedAt || Date.now() - s.failedAt < FAIL_RETRY_MS) return s.mustAccept;
+    }
+
+    const reply = await load();
+    state.value = {
+      sid,
+      reply,
+      mustAccept: shouldPrompt(reply),
+      failedAt: reply ? 0 : Date.now(),
+    };
+    return state.value.mustAccept;
+  }
+
+  async function accept(): Promise<void> {
+    const id = state.value?.reply?.latest?._id;
+    if (!id) throw new Error("No terms to accept.");
+    await useNuxtApp().$api("/api/users/terms/accept", { method: "POST", body: { terms: id } });
+    const sid = String(useCookie("sid", cookieConfig).value ?? "");
+    state.value = { sid, reply: state.value?.reply ?? null, mustAccept: false, failedAt: 0 };
+  }
+
+  /** "Not now" after the server could not record it: let them in, ask again soon. */
+  function deferAfterFailure() {
+    const sid = String(useCookie("sid", cookieConfig).value ?? "");
+    state.value = { sid, reply: state.value?.reply ?? null, mustAccept: false, failedAt: Date.now() };
+  }
+
+  return { state, check, accept, deferAfterFailure };
+}

package/middleware/01.auth.ts

@@ -1,3 +1,5 @@
+import { termsGateSkips } from "../utils/terms-gate";
+
 export default defineNuxtRouteMiddleware(async (route) => {
   const { cookieConfig } = useRuntimeConfig().public;
 
@@ -12,4 +14,13 @@ export default defineNuxtRouteMiddleware(async (route) => {
     // Redirect to login page if no access token
     return navigateTo({ name: "index" });
   }
+
+  // Terms and Privacy Policy: ask once per account per published version.
+  // Fails open; print/PDF/preview/kiosk/public (plain layout) pages are skipped.
+  if (import.meta.client && !termsGateSkips(route, navigator.userAgent)) {
+    const { check } = useTermsGate();
+    if (await check()) {
+      return navigateTo({ path: "/accept-terms", query: { redirect: route.fullPath } });
+    }
+  }
 });

package/package.json

@@ -2,7 +2,7 @@
   "name": "@7365admin1/layer-common",
   "license": "MIT",
   "type": "module",
-  "version": "4.116.0",
+  "version": "4.117.0",
   "author": "7365admin1",
   "main": "./nuxt.config.ts",
   "//files": "What a consumer extending this layer actually loads. Without this npm ships the whole working tree - the changesets, the CI workflows, the render harness in tools/ and any scratch directory that happened to exist at publish time. Nuxt resolves a layer by directory, so every runtime directory below has to stay listed; adding a new top-level runtime directory means adding it here too.",

package/pages/accept-terms.vue

@@ -0,0 +1,126 @@
+<template>
+  <v-container class="py-8" style="max-width: 860px">
+    <v-card class="pa-4 pa-sm-6" variant="flat" border>
+      <h1 class="text-h5 font-weight-bold mb-1">Terms &amp; Privacy Policy</h1>
+      <p class="text-body-2 text-medium-emphasis mb-4">
+        Please read and accept our Terms &amp; Conditions and Privacy Policy to continue.
+        <template v-if="version">(Version {{ version }})</template>
+      </p>
+
+      <div v-if="loading" class="d-flex justify-center py-8">
+        <v-progress-circular indeterminate />
+      </div>
+
+      <template v-else>
+        <div class="terms-scroll mb-4">
+          <h2 v-if="termsHtml" class="text-subtitle-1 font-weight-bold mb-2">Terms &amp; Conditions</h2>
+          <!-- Published by Seven365 in Super Admin -> Terms & Privacy Policy. -->
+          <div v-if="termsHtml" class="platform-terms mb-6" v-html="termsHtml" />
+          <h2 v-if="policiesHtml" class="text-subtitle-1 font-weight-bold mb-2">Privacy Policy</h2>
+          <div v-if="policiesHtml" class="platform-terms" v-html="policiesHtml" />
+        </div>
+
+        <v-checkbox
+          v-model="agreed"
+          hide-details
+          density="comfortable"
+          label="I have read and accept the Terms & Conditions and Privacy Policy"
+        />
+
+        <v-alert v-if="errorText" type="error" variant="tonal" class="mt-3" density="compact">
+          {{ errorText }}
+          <div v-if="failed" class="mt-2">
+            <a href="#" @click.prevent="notNow">Continue for now (we will ask again next time)</a>
+          </div>
+        </v-alert>
+
+        <div class="d-flex flex-wrap ga-3 mt-4">
+          <v-btn color="primary" :disabled="!agreed" :loading="saving" @click="onAccept">I accept</v-btn>
+          <v-btn variant="text" :disabled="saving" @click="onSignOut">Sign out</v-btn>
+        </div>
+      </template>
+    </v-card>
+  </v-container>
+</template>
+
+<script setup lang="ts">
+import { safeRedirect } from "../utils/terms-gate";
+
+// No 01-auth here (no redirect loop); signed-out visitors are sent to sign-in.
+definePageMeta({ layout: "plain", skipTermsGate: true });
+useHead({ title: "Terms & Privacy Policy" });
+
+const route = useRoute();
+const { cookieConfig } = useRuntimeConfig().public;
+const { state, check, accept, deferAfterFailure } = useTermsGate();
+const { logout } = useLocalAuth();
+
+const loading = ref(true);
+const saving = ref(false);
+const agreed = ref(false);
+const failed = ref(false);
+const errorText = ref("");
+
+const latest = computed(() => state.value?.reply?.latest ?? null);
+const version = computed(() => latest.value?.version);
+const termsHtml = computed(() => sanitizeHtml(latest.value?.terms));
+const policiesHtml = computed(() => sanitizeHtml(latest.value?.policies));
+
+function goBack() {
+  return navigateTo(safeRedirect(route.query.redirect), { replace: true });
+}
+
+onMounted(async () => {
+  if (!useCookie("sid", cookieConfig).value) {
+    await navigateTo({ name: "index" });
+    return;
+  }
+  // Re-ask the server: already accepted (another tab/device/app), nothing
+  // published, or the server is down -> straight through.
+  if (!(await check(true))) {
+    await goBack();
+    return;
+  }
+  loading.value = false;
+});
+
+async function onAccept() {
+  saving.value = true;
+  errorText.value = "";
+  failed.value = false;
+  try {
+    await accept();
+    await goBack();
+  } catch (e: any) {
+    failed.value = true;
+    errorText.value =
+      e?.statusCode === 400
+        ? "A newer version was just published. Please reload this page."
+        : "We could not save your acceptance. Please try again.";
+  } finally {
+    saving.value = false;
+  }
+}
+
+async function notNow() {
+  deferAfterFailure();
+  await goBack();
+}
+
+async function onSignOut() {
+  await logout();
+  await navigateTo({ name: "index" });
+}
+</script>
+
+<style scoped>
+.terms-scroll {
+  max-height: 55vh;
+  overflow-y: auto;
+  padding-right: 8px;
+}
+.platform-terms {
+  line-height: 1.6;
+  overflow-wrap: anywhere;
+}
+</style>

package/utils/terms-gate.ts

@@ -0,0 +1,45 @@
+/**
+ * Pure rules for the post-login "Accept Terms and Privacy Policy" gate, kept
+ * apart from Nuxt so they can be unit-tested. The server decides who must
+ * accept (GET /api/users/terms -> mustAccept, per ACCOUNT); an account that has
+ * accepted the live version is never asked again on any device or app.
+ */
+
+export type TermsGateReply = {
+  latest?: { _id?: string; version?: number; terms?: string; policies?: string } | null;
+  mustAccept?: boolean;
+};
+
+/** Gate only when the server positively says so AND sent text to accept. */
+export function shouldPrompt(reply: TermsGateReply | null | undefined): boolean {
+  if (!reply || reply.mustAccept !== true) return false;
+  const latest = reply.latest;
+  return Boolean(latest?._id && (latest.terms || latest.policies));
+}
+
+const NEVER_GATED_LAYOUTS = ["plain", "plain-dark"];
+
+/**
+ * Pages that must never be interrupted: print/PDF/preview/kiosk/public pages
+ * (they use the plain layouts), the accept page itself, an explicit opt-out,
+ * and a headless browser (the PDF service).
+ */
+export function termsGateSkips(
+  to: { path?: string; meta?: Record<string, unknown> },
+  userAgent = "",
+): boolean {
+  if (to.path === "/accept-terms") return true;
+  const meta = to.meta ?? {};
+  if (meta.skipTermsGate) return true;
+  if (typeof meta.layout === "string" && NEVER_GATED_LAYOUTS.includes(meta.layout)) return true;
+  return /HeadlessChrome|Puppeteer/i.test(userAgent);
+}
+
+/** Only ever go back to a path on this site. */
+export function safeRedirect(value: unknown): string {
+  const path = Array.isArray(value) ? value[0] : value;
+  if (typeof path !== "string" || !path.startsWith("/") || path.startsWith("//") || path.includes("\\")) {
+    return "/";
+  }
+  return path;
+}