@noatgnu/cupcake-core 1.3.0 → 1.3.2

package/fesm2022/noatgnu-cupcake-core.mjs

@@ -2,9 +2,9 @@ import * as i0 from '@angular/core';
 import { inject, InjectionToken, Injectable, signal, computed, Component, effect, ChangeDetectorRef, NgModule } from '@angular/core';
 import * as i1 from '@angular/common/http';
 import { HttpClient, HttpParams, provideHttpClient, withInterceptors, HttpClientModule } from '@angular/common/http';
-import { BehaviorSubject, catchError, throwError, switchMap, filter, take, map, tap, Subject, interval, timer, EMPTY, debounceTime, distinctUntilChanged } from 'rxjs';
+import { BehaviorSubject, catchError, throwError, switchMap, filter, take, map, tap, Subject, timer, EMPTY, interval, debounceTime, distinctUntilChanged } from 'rxjs';
 import { Router, ActivatedRoute, RouterModule } from '@angular/router';
-import { map as map$1, tap as tap$1, takeUntil, switchMap as switchMap$1 } from 'rxjs/operators';
+import { map as map$1, takeUntil, tap as tap$1, switchMap as switchMap$1, filter as filter$1 } from 'rxjs/operators';
 import * as i1$1 from '@angular/forms';
 import { FormBuilder, Validators, ReactiveFormsModule, FormsModule, NonNullableFormBuilder } from '@angular/forms';
 import * as i2 from '@angular/common';
@@ -1164,6 +1164,407 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
                 }]
         }] });
 
+const WEBSOCKET_ENDPOINT = new InjectionToken('WEBSOCKET_ENDPOINT', {
+    providedIn: 'root',
+    factory: () => 'notifications'
+});
+class WebSocketService {
+    authService;
+    ws = null;
+    config;
+    destroy$ = new Subject();
+    reconnectAttempts = 0;
+    isConnecting = false;
+    connectionState = signal('disconnected', ...(ngDevMode ? [{ debugName: "connectionState" }] : []));
+    lastError = signal(null, ...(ngDevMode ? [{ debugName: "lastError" }] : []));
+    messageSubject = new Subject();
+    connectionSubject = new BehaviorSubject(false);
+    messages$ = this.messageSubject.asObservable();
+    isConnected$ = this.connectionSubject.asObservable();
+    connectionState$ = computed(() => this.connectionState(), ...(ngDevMode ? [{ debugName: "connectionState$" }] : []));
+    lastError$ = computed(() => this.lastError(), ...(ngDevMode ? [{ debugName: "lastError$" }] : []));
+    config_token = inject(CUPCAKE_CORE_CONFIG);
+    endpoint = inject(WEBSOCKET_ENDPOINT, { optional: true }) || 'notifications';
+    constructor(authService) {
+        this.authService = authService;
+        this.config = {
+            url: this.getWebSocketUrl(),
+            endpoint: this.endpoint,
+            reconnectInterval: this.getAdaptiveReconnectInterval(),
+            maxReconnectAttempts: 3
+        };
+        this.authService.isAuthenticated$.subscribe(isAuthenticated => {
+            if (!isAuthenticated && this.ws) {
+                console.log('User logged out - disconnecting WebSocket');
+                this.disconnect();
+            }
+        });
+        this.setupBrowserResourceHandling();
+    }
+    getWebSocketUrl() {
+        const apiUrl = this.config_token.apiUrl;
+        try {
+            const url = new URL(apiUrl);
+            const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+            const host = url.host;
+            const endpoint = this.config?.endpoint || 'notifications';
+            return `${protocol}//${host}/ws/${endpoint}/`;
+        }
+        catch (error) {
+            console.error('Invalid API URL in cupcake config:', apiUrl);
+            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+            const host = window.location.host;
+            const endpoint = this.config?.endpoint || 'notifications';
+            return `${protocol}//${host}/ws/${endpoint}/`;
+        }
+    }
+    connect() {
+        console.log('🔌 WebSocket connect() called');
+        console.log('🔌 Current connection state:', this.connectionState());
+        console.log('🔌 WebSocket URL:', this.config.url);
+        if (this.isConnecting) {
+            console.log('WebSocket connection already in progress');
+            return;
+        }
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            console.log('WebSocket already connected');
+            return;
+        }
+        if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
+            console.log('Closing existing WebSocket connection');
+            this.ws.close();
+            this.ws = null;
+        }
+        const token = this.authService.getAccessToken();
+        if (!token) {
+            console.error('❌ Cannot connect WebSocket - no authentication token');
+            this.lastError.set('Authentication required');
+            this.connectionState.set('error');
+            return;
+        }
+        this.isConnecting = true;
+        this.connectionState.set('connecting');
+        this.lastError.set(null);
+        try {
+            const wsUrl = `${this.config.url}?token=${encodeURIComponent(token)}`;
+            console.log('Connecting to WebSocket:', wsUrl.replace(token, '[TOKEN_HIDDEN]'));
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = this.onOpen.bind(this);
+            this.ws.onmessage = this.onMessage.bind(this);
+            this.ws.onerror = this.onError.bind(this);
+            this.ws.onclose = this.onClose.bind(this);
+            const connectionTimeout = setTimeout(() => {
+                if (this.ws?.readyState === WebSocket.CONNECTING) {
+                    console.warn('WebSocket connection timeout - closing');
+                    this.ws.close();
+                    this.lastError.set('Connection timeout');
+                    this.connectionState.set('error');
+                    this.isConnecting = false;
+                }
+            }, 10000);
+            this.ws.onopen = (event) => {
+                clearTimeout(connectionTimeout);
+                this.onOpen(event);
+            };
+        }
+        catch (error) {
+            console.error('WebSocket connection error:', error);
+            this.connectionState.set('error');
+            this.lastError.set('Connection failed');
+            this.isConnecting = false;
+        }
+    }
+    disconnect() {
+        this.destroy$.next();
+        this.isConnecting = false;
+        if (this.ws) {
+            this.ws.close(1000, 'User disconnected');
+            this.ws = null;
+        }
+        this.connectionState.set('disconnected');
+        this.connectionSubject.next(false);
+        this.reconnectAttempts = 0;
+    }
+    send(message) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            console.warn('WebSocket not connected, cannot send message:', message);
+        }
+    }
+    subscribe(subscriptionType, options = {}) {
+        this.send({
+            type: 'subscribe',
+            subscription_type: subscriptionType,
+            ...options
+        });
+    }
+    onOpen(event) {
+        console.log('WebSocket connected');
+        this.isConnecting = false;
+        this.connectionState.set('connected');
+        this.connectionSubject.next(true);
+        this.reconnectAttempts = 0;
+        this.lastError.set(null);
+    }
+    onMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            console.log('WebSocket message received:', data);
+            this.messageSubject.next(data);
+        }
+        catch (error) {
+            console.error('Error parsing WebSocket message:', error);
+        }
+    }
+    onError(event) {
+        console.error('WebSocket error:', event);
+        this.isConnecting = false;
+        this.connectionState.set('error');
+        this.lastError.set('Connection error occurred');
+    }
+    onClose(event) {
+        console.log(`WebSocket closed: ${event.code} ${event.reason}`);
+        this.isConnecting = false;
+        this.connectionState.set('disconnected');
+        this.connectionSubject.next(false);
+        if (event.code === 4001) {
+            this.lastError.set('Authentication failed');
+            console.error('WebSocket authentication failed');
+            return;
+        }
+        else if (event.code === 4003) {
+            this.lastError.set('Insufficient permissions');
+            console.error('WebSocket permission denied');
+            return;
+        }
+        if (event.code !== 1000 && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
+            this.attemptReconnection();
+        }
+    }
+    attemptReconnection() {
+        this.reconnectAttempts++;
+        const delay = this.config.reconnectInterval || 5000;
+        console.log(`WebSocket reconnection attempt ${this.reconnectAttempts} in ${delay}ms`);
+        timer(delay).pipe(takeUntil(this.destroy$), tap$1(() => {
+            if (this.reconnectAttempts <= (this.config.maxReconnectAttempts || 5)) {
+                this.connect();
+            }
+            else {
+                console.error('Max WebSocket reconnection attempts reached');
+                this.lastError.set('Connection failed - max attempts reached');
+            }
+        })).subscribe();
+    }
+    filterMessages(type) {
+        return this.messages$.pipe(tap$1(msg => console.log('Filtering message:', msg.type, 'looking for:', type)), switchMap$1(message => message.type === type ? [message] : EMPTY));
+    }
+    getNotifications() {
+        return this.filterMessages('notification');
+    }
+    getSystemNotifications() {
+        return this.filterMessages('system.notification');
+    }
+    reconnectWithNewToken() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            console.log('Reconnecting WebSocket with new token');
+            this.disconnect();
+            setTimeout(() => this.connect(), 100);
+        }
+    }
+    shouldConnect() {
+        return this.authService.isAuthenticated() && !!this.authService.getAccessToken();
+    }
+    updateConfig() {
+        this.config.url = this.getWebSocketUrl();
+        console.log('WebSocket URL updated to:', this.config.url);
+    }
+    ngOnDestroy() {
+        this.disconnect();
+    }
+    getAdaptiveReconnectInterval() {
+        const baseInterval = 5000;
+        const tabCount = this.estimateTabCount();
+        if (tabCount > 20) {
+            return baseInterval * 3;
+        }
+        else if (tabCount > 10) {
+            return baseInterval * 2;
+        }
+        return baseInterval;
+    }
+    estimateTabCount() {
+        try {
+            if ('memory' in performance) {
+                const memory = performance.memory;
+                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
+                if (usedMB > 500)
+                    return 25;
+                if (usedMB > 300)
+                    return 15;
+                if (usedMB > 150)
+                    return 10;
+                return 5;
+            }
+            return 10;
+        }
+        catch (error) {
+            return 10;
+        }
+    }
+    canConnectSafely() {
+        try {
+            if ('memory' in performance) {
+                const memory = performance.memory;
+                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
+                const totalMB = memory.totalJSHeapSize / (1024 * 1024);
+                const memoryUsageRatio = usedMB / totalMB;
+                if (memoryUsageRatio > 0.9) {
+                    console.warn('High memory usage detected, delaying WebSocket connection');
+                    return false;
+                }
+            }
+            const tabCount = this.estimateTabCount();
+            if (tabCount > 30) {
+                console.warn('Too many tabs detected, may affect WebSocket reliability');
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            return true;
+        }
+    }
+    setupBrowserResourceHandling() {
+        document.addEventListener('visibilitychange', () => {
+            if (document.visibilityState === 'visible') {
+                if (this.shouldConnect() && this.connectionState() === 'disconnected') {
+                    console.log('Tab became active - attempting WebSocket reconnection');
+                    setTimeout(() => this.connect(), 1000);
+                }
+            }
+            else {
+                const tabCount = this.estimateTabCount();
+                if (tabCount > 15 && this.ws?.readyState === WebSocket.OPEN) {
+                    console.log('Tab inactive with high tab count - maintaining connection with reduced activity');
+                }
+            }
+        });
+        window.addEventListener('beforeunload', () => {
+            if (this.ws) {
+                this.ws.close(1000, 'Page unloading');
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: AuthService }] });
+
+class AsyncTaskMonitorService extends BaseApiService {
+    destroy$ = new Subject();
+    tasksSubject = new BehaviorSubject([]);
+    isSubscribed = false;
+    websocket = inject(WebSocketService);
+    tasks$ = this.tasksSubject.asObservable();
+    activeTasks$ = this.tasks$.pipe(map$1(tasks => {
+        const taskArray = Array.isArray(tasks) ? tasks : [];
+        const active = taskArray.filter(task => task.status === TaskStatus.QUEUED || task.status === TaskStatus.STARTED);
+        console.log('AsyncTaskMonitorService: activeTasks$ emitting:', active.length, 'active tasks out of', taskArray.length, 'total');
+        return active;
+    }));
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    startRealtimeUpdates() {
+        if (this.isSubscribed) {
+            console.log('AsyncTaskMonitorService: Already subscribed to real-time updates');
+            return;
+        }
+        console.log('AsyncTaskMonitorService: Starting real-time updates');
+        this.isSubscribed = true;
+        if (!this.websocket.connectionState$() || this.websocket.connectionState$() === 'disconnected') {
+            console.log('AsyncTaskMonitorService: WebSocket not connected, connecting now...');
+            this.websocket.connect();
+        }
+        else {
+            console.log('AsyncTaskMonitorService: WebSocket already connected');
+        }
+        this.websocket.isConnected$.pipe(takeUntil(this.destroy$), filter$1(connected => connected)).subscribe(() => {
+            console.log('AsyncTaskMonitorService: WebSocket connected, subscribing to async_task_updates');
+            this.websocket.subscribe('async_task_updates');
+        });
+        this.websocket.filterMessages('async_task.update').pipe(takeUntil(this.destroy$)).subscribe((message) => {
+            console.log('AsyncTaskMonitorService: Received async_task.update message:', message);
+            this.handleTaskUpdate(message);
+        });
+        this.loadAllTasks();
+    }
+    stopRealtimeUpdates() {
+        console.log('AsyncTaskMonitorService: Stopping real-time updates');
+        this.isSubscribed = false;
+        this.destroy$.next();
+    }
+    loadAllTasks() {
+        const httpParams = this.buildHttpParams({ limit: 100 });
+        this.get(`${this.apiUrl}/async-tasks/`, { params: httpParams }).subscribe({
+            next: (response) => {
+                const taskArray = Array.isArray(response.results) ? response.results : [];
+                console.log('AsyncTaskMonitorService: Loaded tasks from server:', taskArray.length);
+                this.tasksSubject.next(taskArray);
+            },
+            error: (error) => {
+                console.error('AsyncTaskMonitorService: Error loading tasks:', error);
+            }
+        });
+    }
+    cancelTask(taskId) {
+        return this.delete(`${this.apiUrl}/async-tasks/${taskId}/cancel/`);
+    }
+    handleTaskUpdate(message) {
+        console.log('AsyncTaskMonitorService: handleTaskUpdate called with message:', message);
+        const taskId = message.task_id;
+        const currentTasks = this.tasksSubject.value;
+        console.log('AsyncTaskMonitorService: Current tasks in subject:', currentTasks.length);
+        const existingTaskIndex = currentTasks.findIndex(t => t.id === taskId);
+        console.log('AsyncTaskMonitorService: Existing task index:', existingTaskIndex);
+        if (existingTaskIndex >= 0) {
+            const existingTask = currentTasks[existingTaskIndex];
+            const updatedTask = {
+                ...existingTask,
+                status: message.status,
+                progressPercentage: message.progress_percentage || existingTask.progressPercentage,
+                progressDescription: message.progress_description || existingTask.progressDescription,
+                errorMessage: message.error_message || existingTask.errorMessage,
+                result: message.result || existingTask.result,
+            };
+            const updatedTasks = [...currentTasks];
+            updatedTasks[existingTaskIndex] = updatedTask;
+            console.log('AsyncTaskMonitorService: Emitting updated tasks:', updatedTasks.length, 'active tasks:', updatedTasks.filter(t => t.status === TaskStatus.QUEUED || t.status === TaskStatus.STARTED).length);
+            this.tasksSubject.next(updatedTasks);
+        }
+        else {
+            console.log('AsyncTaskMonitorService: Task not found in current list, fetching all tasks');
+            this.loadAllTasks();
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: AsyncTaskMonitorService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: AsyncTaskMonitorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: AsyncTaskMonitorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 class ToastService {
     toastsSignal = signal([], ...(ngDevMode ? [{ debugName: "toastsSignal" }] : []));
     toasts = this.toastsSignal.asReadonly();
@@ -1401,443 +1802,140 @@ class ThemeService {
         this.mediaQuery.addEventListener('change', () => {
             if (this._theme() === 'auto') {
                 this.updateDocumentTheme();
-            }
-        });
-        this.updateDocumentTheme();
-    }
-    setTheme(theme) {
-        this._theme.set(theme);
-        localStorage.setItem(this.THEME_KEY, theme);
-        this.updateDocumentTheme();
-    }
-    toggleTheme() {
-        const current = this._theme();
-        if (current === 'light') {
-            this.setTheme('dark');
-        }
-        else if (current === 'dark') {
-            this.setTheme('auto');
-        }
-        else {
-            this.setTheme('light');
-        }
-    }
-    loadStoredTheme() {
-        const stored = localStorage.getItem(this.THEME_KEY);
-        return stored && ['light', 'dark', 'auto'].includes(stored) ? stored : 'auto';
-    }
-    updateDocumentTheme() {
-        const isDark = this.isDark();
-        document.documentElement.setAttribute('data-bs-theme', isDark ? 'dark' : 'light');
-        document.documentElement.classList.toggle('dark-mode', isDark);
-    }
-    getThemeIcon() {
-        const theme = this._theme();
-        switch (theme) {
-            case 'light': return 'bi-sun-fill';
-            case 'dark': return 'bi-moon-fill';
-            case 'auto': return 'bi-circle-half';
-            default: return 'bi-circle-half';
-        }
-    }
-    getThemeLabel() {
-        const theme = this._theme();
-        switch (theme) {
-            case 'light': return 'Light Mode';
-            case 'dark': return 'Dark Mode';
-            case 'auto': return 'Auto Mode';
-            default: return 'Auto Mode';
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ThemeService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ThemeService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [] });
-
-class UserManagementService {
-    apiService = inject(ApiService);
-    authService = inject(AuthService);
-    usersSubject = new BehaviorSubject([]);
-    users$ = this.usersSubject.asObservable();
-    totalUsersSubject = new BehaviorSubject(0);
-    totalUsers$ = this.totalUsersSubject.asObservable();
-    constructor() { }
-    getUserProfile() {
-        return this.apiService.getUserProfile();
-    }
-    updateProfile(profileData) {
-        return this.apiService.updateProfile(profileData);
-    }
-    changePassword(passwordData) {
-        return this.apiService.changePassword(passwordData);
-    }
-    requestEmailChange(emailData) {
-        return this.apiService.requestEmailChange(emailData);
-    }
-    getUsers(params) {
-        return this.apiService.getUsers(params);
-    }
-    getUser(id) {
-        return this.apiService.getUser(id);
-    }
-    createUser(userData) {
-        return this.apiService.createUser(userData);
-    }
-    updateUser(id, userData) {
-        return this.apiService.updateUser(id, userData);
-    }
-    deleteUser(id) {
-        return this.apiService.deleteUser(id);
-    }
-    resetUserPassword(userId, passwordData) {
-        return this.apiService.resetUserPassword(userId, passwordData);
-    }
-    getUserDisplayName(user) {
-        if (!user)
-            return '';
-        if (user.firstName || user.lastName) {
-            return `${user.firstName} ${user.lastName}`.trim();
-        }
-        return user.username || user.email || 'User';
-    }
-    formatDate(dateString) {
-        return dateString ? new Date(dateString).toLocaleDateString() : 'Never';
-    }
-    isCurrentUserAdmin() {
-        const user = this.authService.getCurrentUser();
-        return user?.isStaff || false;
-    }
-    isCurrentUserSuperuser() {
-        const user = this.authService.getCurrentUser();
-        return user?.isSuperuser || false;
-    }
-    updateUsersState(users, total) {
-        this.usersSubject.next(users);
-        this.totalUsersSubject.next(total);
-    }
-    getCurrentUsers() {
-        return this.usersSubject.getValue();
-    }
-    getCurrentTotalUsers() {
-        return this.totalUsersSubject.getValue();
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: UserManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: UserManagementService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: UserManagementService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: () => [] });
-
-const WEBSOCKET_ENDPOINT = new InjectionToken('WEBSOCKET_ENDPOINT', {
-    providedIn: 'root',
-    factory: () => 'notifications'
-});
-class WebSocketService {
-    authService;
-    ws = null;
-    config;
-    destroy$ = new Subject();
-    reconnectAttempts = 0;
-    isConnecting = false;
-    connectionState = signal('disconnected', ...(ngDevMode ? [{ debugName: "connectionState" }] : []));
-    lastError = signal(null, ...(ngDevMode ? [{ debugName: "lastError" }] : []));
-    messageSubject = new Subject();
-    connectionSubject = new BehaviorSubject(false);
-    messages$ = this.messageSubject.asObservable();
-    isConnected$ = this.connectionSubject.asObservable();
-    connectionState$ = computed(() => this.connectionState(), ...(ngDevMode ? [{ debugName: "connectionState$" }] : []));
-    lastError$ = computed(() => this.lastError(), ...(ngDevMode ? [{ debugName: "lastError$" }] : []));
-    config_token = inject(CUPCAKE_CORE_CONFIG);
-    endpoint = inject(WEBSOCKET_ENDPOINT, { optional: true }) || 'notifications';
-    constructor(authService) {
-        this.authService = authService;
-        this.config = {
-            url: this.getWebSocketUrl(),
-            endpoint: this.endpoint,
-            reconnectInterval: this.getAdaptiveReconnectInterval(),
-            maxReconnectAttempts: 3
-        };
-        this.authService.isAuthenticated$.subscribe(isAuthenticated => {
-            if (!isAuthenticated && this.ws) {
-                console.log('User logged out - disconnecting WebSocket');
-                this.disconnect();
-            }
-        });
-        this.setupBrowserResourceHandling();
-    }
-    getWebSocketUrl() {
-        const apiUrl = this.config_token.apiUrl;
-        try {
-            const url = new URL(apiUrl);
-            const protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-            const host = url.host;
-            const endpoint = this.config?.endpoint || 'notifications';
-            return `${protocol}//${host}/ws/${endpoint}/`;
-        }
-        catch (error) {
-            console.error('Invalid API URL in cupcake config:', apiUrl);
-            const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-            const host = window.location.host;
-            const endpoint = this.config?.endpoint || 'notifications';
-            return `${protocol}//${host}/ws/${endpoint}/`;
-        }
-    }
-    connect() {
-        console.log('🔌 WebSocket connect() called');
-        console.log('🔌 Current connection state:', this.connectionState());
-        console.log('🔌 WebSocket URL:', this.config.url);
-        if (this.isConnecting) {
-            console.log('WebSocket connection already in progress');
-            return;
-        }
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            console.log('WebSocket already connected');
-            return;
-        }
-        if (this.ws && this.ws.readyState !== WebSocket.CLOSED) {
-            console.log('Closing existing WebSocket connection');
-            this.ws.close();
-            this.ws = null;
-        }
-        const token = this.authService.getAccessToken();
-        if (!token) {
-            console.error('❌ Cannot connect WebSocket - no authentication token');
-            this.lastError.set('Authentication required');
-            this.connectionState.set('error');
-            return;
-        }
-        this.isConnecting = true;
-        this.connectionState.set('connecting');
-        this.lastError.set(null);
-        try {
-            const wsUrl = `${this.config.url}?token=${encodeURIComponent(token)}`;
-            console.log('Connecting to WebSocket:', wsUrl.replace(token, '[TOKEN_HIDDEN]'));
-            this.ws = new WebSocket(wsUrl);
-            this.ws.onopen = this.onOpen.bind(this);
-            this.ws.onmessage = this.onMessage.bind(this);
-            this.ws.onerror = this.onError.bind(this);
-            this.ws.onclose = this.onClose.bind(this);
-            const connectionTimeout = setTimeout(() => {
-                if (this.ws?.readyState === WebSocket.CONNECTING) {
-                    console.warn('WebSocket connection timeout - closing');
-                    this.ws.close();
-                    this.lastError.set('Connection timeout');
-                    this.connectionState.set('error');
-                    this.isConnecting = false;
-                }
-            }, 10000);
-            this.ws.onopen = (event) => {
-                clearTimeout(connectionTimeout);
-                this.onOpen(event);
-            };
-        }
-        catch (error) {
-            console.error('WebSocket connection error:', error);
-            this.connectionState.set('error');
-            this.lastError.set('Connection failed');
-            this.isConnecting = false;
-        }
-    }
-    disconnect() {
-        this.destroy$.next();
-        this.isConnecting = false;
-        if (this.ws) {
-            this.ws.close(1000, 'User disconnected');
-            this.ws = null;
-        }
-        this.connectionState.set('disconnected');
-        this.connectionSubject.next(false);
-        this.reconnectAttempts = 0;
+            }
+        });
+        this.updateDocumentTheme();
     }
-    send(message) {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(message));
+    setTheme(theme) {
+        this._theme.set(theme);
+        localStorage.setItem(this.THEME_KEY, theme);
+        this.updateDocumentTheme();
+    }
+    toggleTheme() {
+        const current = this._theme();
+        if (current === 'light') {
+            this.setTheme('dark');
+        }
+        else if (current === 'dark') {
+            this.setTheme('auto');
         }
         else {
-            console.warn('WebSocket not connected, cannot send message:', message);
+            this.setTheme('light');
         }
     }
-    subscribe(subscriptionType, options = {}) {
-        this.send({
-            type: 'subscribe',
-            subscription_type: subscriptionType,
-            ...options
-        });
+    loadStoredTheme() {
+        const stored = localStorage.getItem(this.THEME_KEY);
+        return stored && ['light', 'dark', 'auto'].includes(stored) ? stored : 'auto';
     }
-    onOpen(event) {
-        console.log('WebSocket connected');
-        this.isConnecting = false;
-        this.connectionState.set('connected');
-        this.connectionSubject.next(true);
-        this.reconnectAttempts = 0;
-        this.lastError.set(null);
+    updateDocumentTheme() {
+        const isDark = this.isDark();
+        document.documentElement.setAttribute('data-bs-theme', isDark ? 'dark' : 'light');
+        document.documentElement.classList.toggle('dark-mode', isDark);
     }
-    onMessage(event) {
-        try {
-            const data = JSON.parse(event.data);
-            console.log('WebSocket message received:', data);
-            this.messageSubject.next(data);
+    getThemeIcon() {
+        const theme = this._theme();
+        switch (theme) {
+            case 'light': return 'bi-sun-fill';
+            case 'dark': return 'bi-moon-fill';
+            case 'auto': return 'bi-circle-half';
+            default: return 'bi-circle-half';
         }
-        catch (error) {
-            console.error('Error parsing WebSocket message:', error);
+    }
+    getThemeLabel() {
+        const theme = this._theme();
+        switch (theme) {
+            case 'light': return 'Light Mode';
+            case 'dark': return 'Dark Mode';
+            case 'auto': return 'Auto Mode';
+            default: return 'Auto Mode';
         }
     }
-    onError(event) {
-        console.error('WebSocket error:', event);
-        this.isConnecting = false;
-        this.connectionState.set('error');
-        this.lastError.set('Connection error occurred');
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ThemeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+class UserManagementService {
+    apiService = inject(ApiService);
+    authService = inject(AuthService);
+    usersSubject = new BehaviorSubject([]);
+    users$ = this.usersSubject.asObservable();
+    totalUsersSubject = new BehaviorSubject(0);
+    totalUsers$ = this.totalUsersSubject.asObservable();
+    constructor() { }
+    getUserProfile() {
+        return this.apiService.getUserProfile();
     }
-    onClose(event) {
-        console.log(`WebSocket closed: ${event.code} ${event.reason}`);
-        this.isConnecting = false;
-        this.connectionState.set('disconnected');
-        this.connectionSubject.next(false);
-        if (event.code === 4001) {
-            this.lastError.set('Authentication failed');
-            console.error('WebSocket authentication failed');
-            return;
-        }
-        else if (event.code === 4003) {
-            this.lastError.set('Insufficient permissions');
-            console.error('WebSocket permission denied');
-            return;
-        }
-        if (event.code !== 1000 && this.reconnectAttempts < (this.config.maxReconnectAttempts || 5)) {
-            this.attemptReconnection();
-        }
+    updateProfile(profileData) {
+        return this.apiService.updateProfile(profileData);
     }
-    attemptReconnection() {
-        this.reconnectAttempts++;
-        const delay = this.config.reconnectInterval || 5000;
-        console.log(`WebSocket reconnection attempt ${this.reconnectAttempts} in ${delay}ms`);
-        timer(delay).pipe(takeUntil(this.destroy$), tap$1(() => {
-            if (this.reconnectAttempts <= (this.config.maxReconnectAttempts || 5)) {
-                this.connect();
-            }
-            else {
-                console.error('Max WebSocket reconnection attempts reached');
-                this.lastError.set('Connection failed - max attempts reached');
-            }
-        })).subscribe();
+    changePassword(passwordData) {
+        return this.apiService.changePassword(passwordData);
     }
-    filterMessages(type) {
-        return this.messages$.pipe(tap$1(msg => console.log('Filtering message:', msg.type, 'looking for:', type)), switchMap$1(message => message.type === type ? [message] : EMPTY));
+    requestEmailChange(emailData) {
+        return this.apiService.requestEmailChange(emailData);
     }
-    getNotifications() {
-        return this.filterMessages('notification');
+    getUsers(params) {
+        return this.apiService.getUsers(params);
     }
-    getSystemNotifications() {
-        return this.filterMessages('system.notification');
+    getUser(id) {
+        return this.apiService.getUser(id);
     }
-    reconnectWithNewToken() {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            console.log('Reconnecting WebSocket with new token');
-            this.disconnect();
-            setTimeout(() => this.connect(), 100);
-        }
+    createUser(userData) {
+        return this.apiService.createUser(userData);
     }
-    shouldConnect() {
-        return this.authService.isAuthenticated() && !!this.authService.getAccessToken();
+    updateUser(id, userData) {
+        return this.apiService.updateUser(id, userData);
     }
-    updateConfig() {
-        this.config.url = this.getWebSocketUrl();
-        console.log('WebSocket URL updated to:', this.config.url);
+    deleteUser(id) {
+        return this.apiService.deleteUser(id);
     }
-    ngOnDestroy() {
-        this.disconnect();
+    resetUserPassword(userId, passwordData) {
+        return this.apiService.resetUserPassword(userId, passwordData);
     }
-    getAdaptiveReconnectInterval() {
-        const baseInterval = 5000;
-        const tabCount = this.estimateTabCount();
-        if (tabCount > 20) {
-            return baseInterval * 3;
-        }
-        else if (tabCount > 10) {
-            return baseInterval * 2;
+    getUserDisplayName(user) {
+        if (!user)
+            return '';
+        if (user.firstName || user.lastName) {
+            return `${user.firstName} ${user.lastName}`.trim();
         }
-        return baseInterval;
+        return user.username || user.email || 'User';
     }
-    estimateTabCount() {
-        try {
-            if ('memory' in performance) {
-                const memory = performance.memory;
-                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
-                if (usedMB > 500)
-                    return 25;
-                if (usedMB > 300)
-                    return 15;
-                if (usedMB > 150)
-                    return 10;
-                return 5;
-            }
-            return 10;
-        }
-        catch (error) {
-            return 10;
-        }
+    formatDate(dateString) {
+        return dateString ? new Date(dateString).toLocaleDateString() : 'Never';
     }
-    canConnectSafely() {
-        try {
-            if ('memory' in performance) {
-                const memory = performance.memory;
-                const usedMB = memory.usedJSHeapSize / (1024 * 1024);
-                const totalMB = memory.totalJSHeapSize / (1024 * 1024);
-                const memoryUsageRatio = usedMB / totalMB;
-                if (memoryUsageRatio > 0.9) {
-                    console.warn('High memory usage detected, delaying WebSocket connection');
-                    return false;
-                }
-            }
-            const tabCount = this.estimateTabCount();
-            if (tabCount > 30) {
-                console.warn('Too many tabs detected, may affect WebSocket reliability');
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            return true;
-        }
+    isCurrentUserAdmin() {
+        const user = this.authService.getCurrentUser();
+        return user?.isStaff || false;
     }
-    setupBrowserResourceHandling() {
-        document.addEventListener('visibilitychange', () => {
-            if (document.visibilityState === 'visible') {
-                if (this.shouldConnect() && this.connectionState() === 'disconnected') {
-                    console.log('Tab became active - attempting WebSocket reconnection');
-                    setTimeout(() => this.connect(), 1000);
-                }
-            }
-            else {
-                const tabCount = this.estimateTabCount();
-                if (tabCount > 15 && this.ws?.readyState === WebSocket.OPEN) {
-                    console.log('Tab inactive with high tab count - maintaining connection with reduced activity');
-                }
-            }
-        });
-        window.addEventListener('beforeunload', () => {
-            if (this.ws) {
-                this.ws.close(1000, 'Page unloading');
-            }
-        });
+    isCurrentUserSuperuser() {
+        const user = this.authService.getCurrentUser();
+        return user?.isSuperuser || false;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, deps: [{ token: AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, providedIn: 'root' });
+    updateUsersState(users, total) {
+        this.usersSubject.next(users);
+        this.totalUsersSubject.next(total);
+    }
+    getCurrentUsers() {
+        return this.usersSubject.getValue();
+    }
+    getCurrentTotalUsers() {
+        return this.totalUsersSubject.getValue();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: UserManagementService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: UserManagementService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: WebSocketService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImport: i0, type: UserManagementService, decorators: [{
             type: Injectable,
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: AuthService }] });
+        }], ctorParameters: () => [] });
 
 const WEBSOCKET_ENDPOINTS = new InjectionToken('WEBSOCKET_ENDPOINTS');
 class WebSocketEndpoints {
@@ -3503,5 +3601,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.7", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { AnnotationType, ApiService, AuthService, BaseApiService, CUPCAKE_CORE_CONFIG, CupcakeCoreModule, InvitationStatus, InvitationStatusLabels, LabGroupService, LabGroupsComponent, LoginComponent, NotificationService, PoweredByFooterComponent, RegisterComponent, ResourceRole, ResourceRoleLabels, ResourceService, ResourceType, ResourceTypeLabels, ResourceVisibility, ResourceVisibilityLabels, SiteConfigComponent, SiteConfigService, TASK_STATUS_COLORS, TASK_STATUS_LABELS, TASK_TYPE_LABELS, TaskStatus, TaskType, ThemeService, ToastContainerComponent, ToastService, UserManagementComponent, UserManagementService, UserProfileComponent, WEBSOCKET_ENDPOINT, WEBSOCKET_ENDPOINTS, WebSocketConfigService, WebSocketEndpoints, WebSocketService, adminGuard, authGuard, authInterceptor, resetRefreshState };
+export { AnnotationType, ApiService, AsyncTaskMonitorService, AuthService, BaseApiService, CUPCAKE_CORE_CONFIG, CupcakeCoreModule, InvitationStatus, InvitationStatusLabels, LabGroupService, LabGroupsComponent, LoginComponent, NotificationService, PoweredByFooterComponent, RegisterComponent, ResourceRole, ResourceRoleLabels, ResourceService, ResourceType, ResourceTypeLabels, ResourceVisibility, ResourceVisibilityLabels, SiteConfigComponent, SiteConfigService, TASK_STATUS_COLORS, TASK_STATUS_LABELS, TASK_TYPE_LABELS, TaskStatus, TaskType, ThemeService, ToastContainerComponent, ToastService, UserManagementComponent, UserManagementService, UserProfileComponent, WEBSOCKET_ENDPOINT, WEBSOCKET_ENDPOINTS, WebSocketConfigService, WebSocketEndpoints, WebSocketService, adminGuard, authGuard, authInterceptor, resetRefreshState };
 //# sourceMappingURL=noatgnu-cupcake-core.mjs.map