Added partner app

2026-09-28 16:13:42 +02:00
parent 242a4c6fbb
commit 7d510d9fbc
36 changed files with 5920 additions and 0 deletions
@@ -0,0 +1,156 @@
+import { apiClient } from './httpClient';
+
+export const LOCAL_STORAGE_USER_SYNC_KEY = 'pfm_user_sync_record';
+export const LOCAL_STORAGE_ACTIVATION_PENDING_KEY = 'pfm_user_pending_activation';
+export const LOCAL_STORAGE_ACTIVATION_REASON_KEY = 'pfm_user_pending_activation_reason';
+
+export interface UserSyncRecord {
+  sub: string;
+  syncedAt: number;
+  syncedEndpoint: string;
+  tokenSnippet: string;
+  status: 'synced';
+  userData?: any;
+}
+
+export interface UserSyncProfile {
+  id?: string;
+  sub?: string;
+  email?: string | null;
+  name?: string | null;
+  role?: string | null;
+  tenant?: string | null;
+  tenant_id?: number | string | null;
+  organisationId?: number | string | null;
+}
+
+export interface UserSyncResult {
+  success: boolean;
+  isUnauthorized?: boolean;
+  isActivationPending?: boolean;
+  endpoint?: string;
+  data?: any;
+  errorMessage?: string;
+}
+
+let inFlightSyncPromise: Promise<UserSyncResult> | null = null;
+
+export function isActivationPending(): boolean {
+  try { return localStorage.getItem(LOCAL_STORAGE_ACTIVATION_PENDING_KEY) === 'true'; } catch { return false; }
+}
+
+export function getActivationPendingReason(): string | null {
+  try { return localStorage.getItem(LOCAL_STORAGE_ACTIVATION_REASON_KEY); } catch { return null; }
+}
+
+export function setActivationPending(pending: boolean, reason?: string): void {
+  try {
+    if (pending) {
+      localStorage.setItem(LOCAL_STORAGE_ACTIVATION_PENDING_KEY, 'true');
+      if (reason) localStorage.setItem(LOCAL_STORAGE_ACTIVATION_REASON_KEY, reason);
+    } else {
+      localStorage.removeItem(LOCAL_STORAGE_ACTIVATION_PENDING_KEY);
+      localStorage.removeItem(LOCAL_STORAGE_ACTIVATION_REASON_KEY);
+    }
+  } catch {}
+}
+
+export function isUserSyncedInBrowser(currentSub?: string, currentToken?: string | null): boolean {
+  try {
+    if (isActivationPending()) return false;
+    const raw = localStorage.getItem(LOCAL_STORAGE_USER_SYNC_KEY);
+    if (!raw) return false;
+    const record: UserSyncRecord = JSON.parse(raw);
+    if (!record || record.status !== 'synced') return false;
+    if (currentSub && record.sub && record.sub !== currentSub) return false;
+    if (currentToken && record.tokenSnippet && record.tokenSnippet !== currentToken.slice(-16)) return false;
+    return true;
+  } catch { return false; }
+}
+
+export function saveUserSyncInBrowser(sub: string, token: string | null | undefined, endpoint: string, userData?: any): void {
+  try {
+    const record: UserSyncRecord = {
+      sub: sub || 'authenticated_user',
+      syncedAt: Date.now(),
+      syncedEndpoint: endpoint,
+      tokenSnippet: token ? token.slice(-16) : '',
+      status: 'synced',
+      userData,
+    };
+    localStorage.setItem(LOCAL_STORAGE_USER_SYNC_KEY, JSON.stringify(record));
+  } catch {}
+}
+
+export function clearUserSyncInBrowser(): void {
+  try {
+    localStorage.removeItem(LOCAL_STORAGE_USER_SYNC_KEY);
+    localStorage.removeItem(LOCAL_STORAGE_ACTIVATION_PENDING_KEY);
+    localStorage.removeItem(LOCAL_STORAGE_ACTIVATION_REASON_KEY);
+  } catch {}
+}
+
+export const USER_SYNC_CANDIDATE_ENDPOINTS = [
+  '/v1/api/integration/sync',
+  '/v1/api/users/sync',
+  '/v1/api/user/sync',
+];
+
+async function executeBackendSync(userSub?: string, profile?: UserSyncProfile): Promise<{ endpoint: string; data?: any }> {
+  const payload = {
+    id: userSub || profile?.id || profile?.sub,
+    sub: userSub || profile?.sub,
+    email: profile?.email || undefined,
+    name: profile?.name || undefined,
+    role: profile?.role || undefined,
+    tenant_id: profile?.tenant_id ? Number(profile.tenant_id) : undefined,
+    organisationId: profile?.organisationId ? Number(profile.organisationId) : undefined,
+  };
+
+  let lastError: any = null;
+  for (const endpoint of USER_SYNC_CANDIDATE_ENDPOINTS) {
+    try {
+      const res = await apiClient.post(endpoint, payload);
+      return { endpoint, data: res?.data };
+    } catch (err: any) {
+      lastError = err;
+      const status = err?.response?.status;
+      if (status === 401 || status === 403 || status === 423) throw err;
+    }
+  }
+  throw lastError || new Error('Failed to reach user sync endpoint');
+}
+
+export async function syncUserAccount(userSub?: string, token?: string | null, profile?: UserSyncProfile, force = false): Promise<UserSyncResult> {
+  const effectiveToken = token || (typeof window !== 'undefined' ? localStorage.getItem('pfm_access_token') : null);
+  const effectiveSub = userSub || (typeof window !== 'undefined' ? localStorage.getItem('pfm_user_sub') || '' : '');
+
+  if (!force && isUserSyncedInBrowser(effectiveSub, effectiveToken) && !isActivationPending()) {
+    return { success: true, endpoint: '/v1/api/users/sync' };
+  }
+
+  if (inFlightSyncPromise) return inFlightSyncPromise;
+
+  inFlightSyncPromise = (async (): Promise<UserSyncResult> => {
+    try {
+      const result = await executeBackendSync(effectiveSub, profile);
+      setActivationPending(false);
+      saveUserSyncInBrowser(effectiveSub, effectiveToken, result.endpoint, result.data);
+      return { success: true, endpoint: result.endpoint, data: result.data };
+    } catch (err: any) {
+      const status = err?.response?.status;
+      if (status === 401) {
+        clearUserSyncInBrowser();
+        setActivationPending(false);
+        return { success: false, isUnauthorized: true, errorMessage: 'Session expired (HTTP 401).' };
+      }
+      const serverMsg = err?.response?.data?.detail || err?.response?.data?.message || 'Account activation pending.';
+      setActivationPending(true, serverMsg);
+      return { success: false, isUnauthorized: false, isActivationPending: true, errorMessage: serverMsg };
+    } finally {
+      inFlightSyncPromise = null;
+    }
+  })();
+
+  return inFlightSyncPromise;
+}