@aakash58/chatbot 1.1.21 → 1.1.24

package/esm2022/lib/core/auth/auth.service.mjs

@@ -0,0 +1,391 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { BehaviorSubject, map, catchError, of, tap, retry, throwError, firstValueFrom, } from 'rxjs';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import logger from '../utils/logger.service';
+import { SnackbarUtils } from './../../shared/snackbar/snackbar.utils';
+import { DoohbotConst } from '../../constant/doohbot-constant';
+import { DOOHBOT_ADVANCED_CONFIG } from '../models/doohbot-config.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./account-api.service";
+import * as i2 from "../helpers/crypto-helper.service";
+import * as i3 from "./storage.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../services/core-config.service";
+export class AuthService {
+    get apiUrl() {
+        return this.coreConfig.apiUrl;
+    }
+    get storageKey() {
+        return this.coreConfig.storageKey;
+    }
+    get secretKey() {
+        return this.coreConfig.secretKey;
+    }
+    get companyCode() {
+        return this.coreConfig.companyCode;
+    }
+    constructor(accountService, cryptoHelper, tokenStorage, router, coreConfig) {
+        this.accountService = accountService;
+        this.cryptoHelper = cryptoHelper;
+        this.tokenStorage = tokenStorage;
+        this.router = router;
+        this.coreConfig = coreConfig;
+        this.jwtHelper = new JwtHelperService();
+        this.advancedConfig = inject(DOOHBOT_ADVANCED_CONFIG, { optional: true });
+        // Reactive Authentication State
+        this.authStatusSubject = new BehaviorSubject('unauthenticated');
+        this.authStatus$ = this.authStatusSubject.asObservable();
+        // UI State Signals (Merged from ChatAuthService)
+        this.isLoggingIn = signal(false);
+        this.authError = signal(null);
+        this.authSuccess = signal(null);
+        // Properties are now derived from coreConfig
+    }
+    /**
+     * Updates the service configuration from the component input
+     */
+    updateConfig(config) {
+        this.coreConfig.updateConfig(config);
+        if (config.secretKey) {
+            this.cryptoHelper.setSecretKey(config.secretKey);
+        }
+    }
+    getLoggedInUserName() {
+        const username = this.tokenStorage.get('username');
+        return username || '';
+    }
+    getLoggedInUserImageUrl() {
+        return DoohbotConst.userAvatar;
+    }
+    getLoggedInUserRole() {
+        const roles = this.tokenStorage.get('roles');
+        // If roles is an array, return the first role, otherwise return the string
+        if (Array.isArray(roles) && roles.length > 0) {
+            return roles[0];
+        }
+        return roles || 'User';
+    }
+    // Add getters for backward compatibility if needed, but preferably use authStatus$
+    get authStatus() {
+        return this.authStatusSubject.value;
+    }
+    /**
+     * Resolves a federated token from browser storage
+     */
+    resolveSilentToken() {
+        const config = this.coreConfig.config$();
+        const commonKeys = ['access_token', 'id_token', 'token', 'authToken'];
+        // 1. Try explicit authToken from config (Highest Priority)
+        if (config.authToken) {
+            logger.info(`[Auth] Using explicit authToken from input`);
+            return config.authToken;
+        }
+        // 2. Try configured storage key from advanced config
+        if (this.advancedConfig?.autoConfigFromStorage) {
+            const key = this.advancedConfig.autoConfigFromStorage;
+            const token = localStorage.getItem(key) || sessionStorage.getItem(key);
+            if (token) {
+                logger.debug(`[Auth] Resolved token from configured key: ${key}`);
+                return token;
+            }
+        }
+        // 3. Try common fallback keys
+        for (const key of commonKeys) {
+            const token = localStorage.getItem(key) || sessionStorage.getItem(key);
+            if (token) {
+                logger.debug(`[Auth] Resolved token from fallback key: ${key}`);
+                return token;
+            }
+        }
+        return null;
+    }
+    /**
+     * Authenticate user with federated credentials
+     */
+    async federatedLogin(credentials, silent = true) {
+        logger.log('>>>>>>>Attempting federated login...');
+        // Resolve token if not provided
+        if (!credentials.accessToken) {
+            credentials.accessToken = this.resolveSilentToken() || '';
+        }
+        // If still no token, exit gracefully
+        if (!credentials.accessToken) {
+            logger.log('[Auth] No federated token found in storage.');
+            return false;
+        }
+        this.isLoggingIn.set(true);
+        if (!silent) {
+            this.authError.set(null);
+            this.authSuccess.set(null);
+        }
+        try {
+            const response = await firstValueFrom(this.accountService.federateLogin(credentials));
+            logger.log('>>>>>>>>>>>Federated Login response<<<<<<<<<<:', response);
+            if (response && response.success && response.data) {
+                // Map federated result to something AuthService can handle
+                // Federated result: { access_token: string, remember_me: boolean }
+                const authResult = {
+                    access_token: response.data.access_token,
+                    refresh_token: credentials.rememberMe ? response.data.refresh_token : '',
+                };
+                this.setSession(authResult, credentials.rememberMe || false);
+                logger.log('Federated login successful, authenticated state set to true');
+                if (!silent) {
+                    SnackbarUtils.success('Login successful!');
+                    this.authSuccess.set('Login successful!');
+                }
+                this.isLoggingIn.set(false);
+                return true;
+            }
+            else {
+                if (!silent) {
+                    this.authError.set('Federated login failed.');
+                }
+                this.isLoggingIn.set(false);
+                return false;
+            }
+        }
+        catch (error) {
+            logger.error('Federated login failed:', error);
+            if (!silent) {
+                this.authError.set('An error occurred during federated login.');
+            }
+            this.isLoggingIn.set(false);
+            return false;
+        }
+    }
+    /**
+     * Authenticate user with credentials
+     */
+    async login(credentials, silent = false) {
+        this.isLoggingIn.set(true);
+        if (!silent) {
+            this.authError.set(null); //TODO
+            this.authSuccess.set(null);
+        }
+        try {
+            const response = await firstValueFrom(this.accountService.login(credentials));
+            logger.log('>>>>>>>>>>>Login response<<<<<<<<<<:', response);
+            if (response && response.success && response.data) {
+                this.setSession(response.data, credentials.rememberMe);
+                logger.log('Login successful, authenticated state set to true');
+                if (!silent) {
+                    this.authSuccess.set('Login successful!');
+                }
+                this.isLoggingIn.set(false);
+                return true;
+            }
+            else {
+                if (!silent) {
+                    SnackbarUtils.error('Login failed. Please check your credentials.');
+                    this.authError.set('Login failed. Please check your credentials.');
+                }
+                this.isLoggingIn.set(false);
+                return false;
+            }
+        }
+        catch (error) {
+            logger.error('Login failed:', error);
+            if (!silent) {
+                this.authError.set('An error occurred during login.');
+            }
+            this.isLoggingIn.set(false);
+            return false;
+        }
+    }
+    /*
+     * Logout logic enhanced with UI signals
+     */
+    async logout(refreshToken) {
+        const token = refreshToken || this.getRefreshToken() || '';
+        try {
+            // If no token, just clear local state
+            if (!token) {
+                this.clearAuth();
+                this.authSuccess.set('Logged out successfully!');
+                setTimeout(() => this.authSuccess.set(null), 3000);
+                return true;
+            }
+            const response = await firstValueFrom(this.accountService.logout(token));
+            if (response && response.success) {
+                this.clearAuth();
+                this.authSuccess.set('Logged out successfully!');
+                setTimeout(() => this.authSuccess.set(null), 3000);
+                return true;
+            }
+            else {
+                this.clearAuth();
+                return false;
+            }
+        }
+        catch (error) {
+            logger.error('Logout failed:', error);
+            SnackbarUtils.error('An error occurred during logout.');
+            // Force clear auth on error to ensure user isn't stuck
+            this.clearAuth();
+            return false;
+        }
+    }
+    // Utility
+    setSession(session, rememberMe = true) {
+        const user = this.jwtHelper.decodeToken(session.access_token);
+        // Set storage type based on rememberMe preference
+        this.tokenStorage.setRememberMe(rememberMe);
+        this.tokenStorage.set('access_token', session.access_token);
+        this.tokenStorage.set('refresh_token', session.refresh_token);
+        this.tokenStorage.set('user_id', user?.user_id);
+        this.tokenStorage.set('username', user?.username);
+        this.tokenStorage.set('roles', user?.roles);
+        this.tokenStorage.set('permissions', user?.permissions);
+        this.tokenStorage.set('organization_id', user?.organization_id);
+        this.tokenStorage.set('company_id', user?.company_id);
+        this.tokenStorage.set('office_id', user?.office_id);
+        // Notify subscribers
+        this.authStatusSubject.next('authenticated');
+    }
+    getOrganizationId() {
+        logger.debug('>>>>>>>>>>getOrganizationId<<<<<<<:', this.tokenStorage.get('organization_id'));
+        return this.tokenStorage.get('organization_id');
+    }
+    getRefreshToken() {
+        logger.debug('>>>>>>>>>>getRefreshToken<<<<<<<:', this.tokenStorage.get('refresh_token'));
+        return this.tokenStorage.get('refresh_token');
+    }
+    refreshToken() {
+        const refreshToken = this.getRefreshToken();
+        if (!refreshToken) {
+            return throwError(() => new Error('No refresh token available'));
+        }
+        return this.accountService.refreshLogin({ refresh_token: refreshToken }).pipe(retry(3), // Retry 3 times on failure
+        tap((response) => {
+            if (response && response.success && response.data) {
+                this.setSession(response.data);
+            }
+        }), map((response) => {
+            if (response && response.success && response.data) {
+                return response.data;
+            }
+            else {
+                throw new Error('Token refresh failed');
+            }
+        }), catchError((err) => {
+            logger.error('[Auth] Token refresh failed after retries:', err);
+            this.clearAuth();
+            SnackbarUtils.error('Session Expired. Please login.');
+            return throwError(() => err);
+        }));
+    }
+    isAuthenticated() {
+        const token = this.tokenStorage.get('access_token');
+        return !!token && !this.isTokenExpired();
+    }
+    isTokenExpired() {
+        let token = (this.tokenStorage.get('access_token') ?? '');
+        if (token) {
+            return this.jwtHelper.isTokenExpired(token);
+        }
+        else {
+            return true;
+        }
+    }
+    /**
+     * Validate stored token on app startup
+     */
+    validateStoredToken() {
+        const accessToken = this.tokenStorage.get('access_token');
+        //! No access token
+        if (!accessToken) {
+            //TODO: FORCE AUTHENTICATED FOR DEV
+            // this.authStatusSubject.next('authenticated');
+            // return of('authenticated');
+            //! For production ( Backend Validation )
+            this.authStatusSubject.next('unauthenticated');
+            return of('unauthenticated');
+        }
+        // Access token valid
+        if (!this.isTokenExpired()) {
+            this.authStatusSubject.next('authenticated');
+            return of('authenticated');
+        }
+        // Access Token expired -> try refresh
+        const refreshToken = this.getRefreshToken();
+        if (!refreshToken) {
+            this.clearAuth();
+            this.authStatusSubject.next('unauthenticated');
+            return of('unauthenticated');
+        }
+        //! Access expired but refresh token exists → attempt refresh
+        this.authStatusSubject.next('expired');
+        return this.refreshToken().pipe(map(() => {
+            this.authStatusSubject.next('authenticated');
+            return 'authenticated';
+        }), catchError((err) => {
+            logger.error('[Auth] Token refresh failed:', err);
+            this.clearAuth();
+            this.authStatusSubject.next('unauthenticated');
+            return of('unauthenticated');
+        }));
+    }
+    getUserId() {
+        return this.tokenStorage.get('user_id') || '';
+    }
+    getLicensingContext() {
+        const roles = this.tokenStorage.get('roles');
+        // Prefer company_id (specific tenant) over organization_id (system group)
+        const tenantId = this.tokenStorage.get('company_id') || this.getOrganizationId() || '';
+        return {
+            tenantId: tenantId,
+            principalId: this.getUserId() || '',
+            roles: Array.isArray(roles) ? roles : roles ? [roles] : [],
+        };
+    }
+    get licenseKey() {
+        return this.tokenStorage.get('license_key') || this.coreConfig.licenseKey || '';
+    }
+    get isFederated() {
+        return this.licenseKey.startsWith('doohbot_lic_');
+    }
+    setLicenseKey(key) {
+        this.tokenStorage.set('license_key', key);
+    }
+    //! clear local storage
+    /**
+     * Clear all authentication related data from local storage, session storage, cache, and tokens.
+     * This method is called when the user logs out.
+     */
+    clearAuth() {
+        const userId = this.getUserId();
+        logger.log('[Auth] Clearing auth:', { userId });
+        this.clearSession();
+        this.clearStorage();
+        this.clearCache();
+        this.clearLocalStorage();
+        // ENSURE authStatus$ emits unauthenticated
+        this.authStatusSubject.next('unauthenticated');
+        logger.log('[Auth] Auth cleared successfully');
+    }
+    clearSession() {
+        sessionStorage.clear();
+    }
+    clearTabInfo() {
+        localStorage.removeItem('tabs');
+    }
+    clearStorage() {
+        this.tokenStorage.clear();
+    }
+    clearLocalStorage() {
+        localStorage.clear();
+    }
+    clearCache() {
+        // this.cacheService.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, deps: [{ token: i1.AccountService }, { token: i2.CryptoHelperService }, { token: i3.StorageService }, { token: i4.Router }, { token: i5.CoreConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AccountService }, { type: i2.CryptoHelperService }, { type: i3.StorageService }, { type: i4.Router }, { type: i5.CoreConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/auth/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, signal } from '@angular/core';\r\nimport { CoreConfigService } from '../services/core-config.service';\r\nimport { DoohbotInput } from '../../doohbot-input';\r\nimport {\r\n  BehaviorSubject,\r\n  map,\r\n  Observable,\r\n  catchError,\r\n  of,\r\n  tap,\r\n  retry,\r\n  throwError,\r\n  firstValueFrom,\r\n} from 'rxjs';\r\nimport { AuthResult } from './models/auth-result.model';\r\nimport { FederatedLoginRequest } from './models/federated-login-request.model';\r\nimport { LoginRequest } from './models/login-request.model';\r\nimport { JwtHelperService } from '@auth0/angular-jwt';\r\nimport { CryptoHelperService } from '../helpers/crypto-helper.service';\r\nimport { StorageService } from './storage.service';\r\nimport logger from '../utils/logger.service';\r\nimport { AuthStatus } from '../types/auth-status.type';\r\nimport { AccountService } from './account-api.service';\r\nimport { SnackbarUtils } from './../../shared/snackbar/snackbar.utils';\r\nimport { DoohbotConst } from '../../constant/doohbot-constant';\r\nimport { Router } from '@angular/router';\r\nimport { LicensingContext } from '../models/license.model';\r\nimport { DOOHBOT_ADVANCED_CONFIG } from '../models/doohbot-config.model';\r\n\r\n//! inherit Window storageEventAdded for duplicate tab detection\r\ndeclare global {\r\n  interface Window {\r\n    storageEventAdded?: boolean;\r\n    tabCLoseEventAdded?: boolean;\r\n    abp?: any;\r\n    AppPreBootstrap?: any;\r\n    AppConsts?: any;\r\n  }\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class AuthService {\r\n  get apiUrl(): string {\r\n    return this.coreConfig.apiUrl;\r\n  }\r\n\r\n  get storageKey(): string {\r\n    return this.coreConfig.storageKey;\r\n  }\r\n\r\n  get secretKey(): string {\r\n    return this.coreConfig.secretKey;\r\n  }\r\n\r\n  get companyCode(): string {\r\n    return this.coreConfig.companyCode;\r\n  }\r\n\r\n  jwtHelper: JwtHelperService = new JwtHelperService();\r\n  private advancedConfig = inject(DOOHBOT_ADVANCED_CONFIG, { optional: true });\r\n\r\n  // Reactive Authentication State\r\n  private authStatusSubject = new BehaviorSubject<AuthStatus>('unauthenticated');\r\n  public authStatus$ = this.authStatusSubject.asObservable();\r\n\r\n  // UI State Signals (Merged from ChatAuthService)\r\n  public isLoggingIn = signal<boolean>(false);\r\n  public authError = signal<string | null>(null);\r\n  public authSuccess = signal<string | null>(null);\r\n\r\n  constructor(\r\n    private accountService: AccountService,\r\n    private cryptoHelper: CryptoHelperService,\r\n    private tokenStorage: StorageService,\r\n    private router: Router,\r\n    private coreConfig: CoreConfigService,\r\n  ) {\r\n    // Properties are now derived from coreConfig\r\n  }\r\n\r\n  /**\r\n   * Updates the service configuration from the component input\r\n   */\r\n  public updateConfig(config: DoohbotInput): void {\r\n    this.coreConfig.updateConfig(config);\r\n    if (config.secretKey) {\r\n      this.cryptoHelper.setSecretKey(config.secretKey);\r\n    }\r\n  }\r\n\r\n  getLoggedInUserName(): string {\r\n    const username = this.tokenStorage.get('username');\r\n    return username || '';\r\n  }\r\n\r\n  getLoggedInUserImageUrl(): string | null {\r\n    return DoohbotConst.userAvatar;\r\n  }\r\n\r\n  getLoggedInUserRole(): string {\r\n    const roles = this.tokenStorage.get('roles');\r\n    // If roles is an array, return the first role, otherwise return the string\r\n    if (Array.isArray(roles) && roles.length > 0) {\r\n      return roles[0];\r\n    }\r\n    return roles || 'User';\r\n  }\r\n\r\n  // Add getters for backward compatibility if needed, but preferably use authStatus$\r\n  public get authStatus(): AuthStatus {\r\n    return this.authStatusSubject.value;\r\n  }\r\n\r\n  /**\r\n   * Resolves a federated token from browser storage\r\n   */\r\n  private resolveSilentToken(): string | null {\r\n    const config = this.coreConfig.config$();\r\n    const commonKeys = ['access_token', 'id_token', 'token', 'authToken'];\r\n\r\n    // 1. Try explicit authToken from config (Highest Priority)\r\n    if (config.authToken) {\r\n      logger.info(`[Auth] Using explicit authToken from input`);\r\n      return config.authToken;\r\n    }\r\n\r\n    // 2. Try configured storage key from advanced config\r\n    if (this.advancedConfig?.autoConfigFromStorage) {\r\n      const key = this.advancedConfig.autoConfigFromStorage;\r\n      const token = localStorage.getItem(key) || sessionStorage.getItem(key);\r\n      if (token) {\r\n        logger.debug(`[Auth] Resolved token from configured key: ${key}`);\r\n        return token;\r\n      }\r\n    }\r\n\r\n    // 3. Try common fallback keys\r\n    for (const key of commonKeys) {\r\n      const token = localStorage.getItem(key) || sessionStorage.getItem(key);\r\n      if (token) {\r\n        logger.debug(`[Auth] Resolved token from fallback key: ${key}`);\r\n        return token;\r\n      }\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Authenticate user with federated credentials\r\n   */\r\n  async federatedLogin(\r\n    credentials: Partial<FederatedLoginRequest>,\r\n    silent: boolean = true,\r\n  ): Promise<boolean> {\r\n    logger.log('>>>>>>>Attempting federated login...');\r\n\r\n    // Resolve token if not provided\r\n    if (!credentials.accessToken) {\r\n      credentials.accessToken = this.resolveSilentToken() || '';\r\n    }\r\n\r\n    // If still no token, exit gracefully\r\n    if (!credentials.accessToken) {\r\n      logger.log('[Auth] No federated token found in storage.');\r\n      return false;\r\n    }\r\n\r\n    this.isLoggingIn.set(true);\r\n    if (!silent) {\r\n      this.authError.set(null);\r\n      this.authSuccess.set(null);\r\n    }\r\n\r\n    try {\r\n      const response = await firstValueFrom(\r\n        this.accountService.federateLogin(credentials as FederatedLoginRequest),\r\n      );\r\n      logger.log('>>>>>>>>>>>Federated Login response<<<<<<<<<<:', response);\r\n      if (response && response.success && response.data) {\r\n        // Map federated result to something AuthService can handle\r\n        // Federated result: { access_token: string, remember_me: boolean }\r\n        const authResult = {\r\n          access_token: response.data.access_token,\r\n          refresh_token: credentials.rememberMe ? response.data.refresh_token : '',\r\n        };\r\n\r\n        this.setSession(authResult, credentials.rememberMe || false);\r\n\r\n        logger.log('Federated login successful, authenticated state set to true');\r\n        if (!silent) {\r\n          SnackbarUtils.success('Login successful!');\r\n          this.authSuccess.set('Login successful!');\r\n        }\r\n        this.isLoggingIn.set(false);\r\n        return true;\r\n      } else {\r\n        if (!silent) {\r\n          this.authError.set('Federated login failed.');\r\n        }\r\n        this.isLoggingIn.set(false);\r\n        return false;\r\n      }\r\n    } catch (error) {\r\n      logger.error('Federated login failed:', error);\r\n      if (!silent) {\r\n        this.authError.set('An error occurred during federated login.');\r\n      }\r\n      this.isLoggingIn.set(false);\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Authenticate user with credentials\r\n   */\r\n  async login(credentials: LoginRequest, silent: boolean = false): Promise<boolean> {\r\n    this.isLoggingIn.set(true);\r\n    if (!silent) {\r\n      this.authError.set(null); //TODO\r\n      this.authSuccess.set(null);\r\n    }\r\n\r\n    try {\r\n      const response = await firstValueFrom(this.accountService.login(credentials));\r\n      logger.log('>>>>>>>>>>>Login response<<<<<<<<<<:', response);\r\n      if (response && response.success && response.data) {\r\n        this.setSession(response.data, credentials.rememberMe);\r\n\r\n        logger.log('Login successful, authenticated state set to true');\r\n        if (!silent) {\r\n          this.authSuccess.set('Login successful!');\r\n        }\r\n        this.isLoggingIn.set(false);\r\n        return true;\r\n      } else {\r\n        if (!silent) {\r\n          SnackbarUtils.error('Login failed. Please check your credentials.');\r\n          this.authError.set('Login failed. Please check your credentials.');\r\n        }\r\n        this.isLoggingIn.set(false);\r\n        return false;\r\n      }\r\n    } catch (error) {\r\n      logger.error('Login failed:', error);\r\n      if (!silent) {\r\n        this.authError.set('An error occurred during login.');\r\n      }\r\n      this.isLoggingIn.set(false);\r\n      return false;\r\n    }\r\n  }\r\n\r\n  /*\r\n   * Logout logic enhanced with UI signals\r\n   */\r\n  async logout(refreshToken?: string): Promise<boolean> {\r\n    const token = refreshToken || this.getRefreshToken() || '';\r\n\r\n    try {\r\n      // If no token, just clear local state\r\n      if (!token) {\r\n        this.clearAuth();\r\n        this.authSuccess.set('Logged out successfully!');\r\n        setTimeout(() => this.authSuccess.set(null), 3000);\r\n        return true;\r\n      }\r\n\r\n      const response = await firstValueFrom(this.accountService.logout(token));\r\n\r\n      if (response && response.success) {\r\n        this.clearAuth();\r\n        this.authSuccess.set('Logged out successfully!');\r\n        setTimeout(() => this.authSuccess.set(null), 3000);\r\n        return true;\r\n      } else {\r\n        this.clearAuth();\r\n        return false;\r\n      }\r\n    } catch (error) {\r\n      logger.error('Logout failed:', error);\r\n      SnackbarUtils.error('An error occurred during logout.');\r\n      // Force clear auth on error to ensure user isn't stuck\r\n      this.clearAuth();\r\n      return false;\r\n    }\r\n  }\r\n\r\n  // Utility\r\n  setSession(session: AuthResult, rememberMe: boolean = true) {\r\n    const user = this.jwtHelper.decodeToken(session.access_token);\r\n\r\n    // Set storage type based on rememberMe preference\r\n    this.tokenStorage.setRememberMe(rememberMe);\r\n\r\n    this.tokenStorage.set('access_token', session.access_token);\r\n    this.tokenStorage.set('refresh_token', session.refresh_token);\r\n    this.tokenStorage.set('user_id', user?.user_id);\r\n    this.tokenStorage.set('username', user?.username);\r\n    this.tokenStorage.set('roles', user?.roles);\r\n    this.tokenStorage.set('permissions', user?.permissions);\r\n    this.tokenStorage.set('organization_id', user?.organization_id);\r\n    this.tokenStorage.set('company_id', user?.company_id);\r\n    this.tokenStorage.set('office_id', user?.office_id);\r\n\r\n    // Notify subscribers\r\n    this.authStatusSubject.next('authenticated');\r\n  }\r\n\r\n  getOrganizationId(): string | null {\r\n    logger.debug('>>>>>>>>>>getOrganizationId<<<<<<<:', this.tokenStorage.get('organization_id'));\r\n    return this.tokenStorage.get('organization_id');\r\n  }\r\n\r\n  getRefreshToken(): string | null {\r\n    logger.debug('>>>>>>>>>>getRefreshToken<<<<<<<:', this.tokenStorage.get('refresh_token'));\r\n    return this.tokenStorage.get('refresh_token');\r\n  }\r\n\r\n  refreshToken(): Observable<AuthResult> {\r\n    const refreshToken = this.getRefreshToken();\r\n    if (!refreshToken) {\r\n      return throwError(() => new Error('No refresh token available'));\r\n    }\r\n\r\n    return this.accountService.refreshLogin({ refresh_token: refreshToken }).pipe(\r\n      retry(3), // Retry 3 times on failure\r\n      tap((response: any) => {\r\n        if (response && response.success && response.data) {\r\n          this.setSession(response.data);\r\n        }\r\n      }),\r\n      map((response: any) => {\r\n        if (response && response.success && response.data) {\r\n          return response.data as AuthResult;\r\n        } else {\r\n          throw new Error('Token refresh failed');\r\n        }\r\n      }),\r\n      catchError((err) => {\r\n        logger.error('[Auth] Token refresh failed after retries:', err);\r\n        this.clearAuth();\r\n        SnackbarUtils.error('Session Expired. Please login.');\r\n        return throwError(() => err);\r\n      }),\r\n    );\r\n  }\r\n\r\n  isAuthenticated(): boolean {\r\n    const token = this.tokenStorage.get('access_token');\r\n    return !!token && !this.isTokenExpired();\r\n  }\r\n\r\n  isTokenExpired(): boolean {\r\n    let token = (this.tokenStorage.get('access_token') ?? '') as string;\r\n    if (token) {\r\n      return this.jwtHelper.isTokenExpired(token);\r\n    } else {\r\n      return true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Validate stored token on app startup\r\n   */\r\n  validateStoredToken(): Observable<AuthStatus> {\r\n    const accessToken = this.tokenStorage.get('access_token');\r\n\r\n    //! No access token\r\n    if (!accessToken) {\r\n      //TODO: FORCE AUTHENTICATED FOR DEV\r\n      // this.authStatusSubject.next('authenticated');\r\n      // return of('authenticated');\r\n\r\n      //! For production ( Backend Validation )\r\n      this.authStatusSubject.next('unauthenticated');\r\n      return of('unauthenticated');\r\n    }\r\n\r\n    // Access token valid\r\n    if (!this.isTokenExpired()) {\r\n      this.authStatusSubject.next('authenticated');\r\n      return of('authenticated');\r\n    }\r\n\r\n    // Access Token expired -> try refresh\r\n    const refreshToken = this.getRefreshToken();\r\n    if (!refreshToken) {\r\n      this.clearAuth();\r\n      this.authStatusSubject.next('unauthenticated');\r\n      return of('unauthenticated');\r\n    }\r\n\r\n    //! Access expired but refresh token exists → attempt refresh\r\n    this.authStatusSubject.next('expired');\r\n    return this.refreshToken().pipe(\r\n      map(() => {\r\n        this.authStatusSubject.next('authenticated');\r\n        return 'authenticated' as AuthStatus;\r\n      }),\r\n      catchError((err) => {\r\n        logger.error('[Auth] Token refresh failed:', err);\r\n        this.clearAuth();\r\n        this.authStatusSubject.next('unauthenticated');\r\n        return of('unauthenticated' as AuthStatus);\r\n      }),\r\n    );\r\n  }\r\n\r\n  getUserId() {\r\n    return this.tokenStorage.get('user_id') || '';\r\n  }\r\n\r\n  getLicensingContext(): LicensingContext {\r\n    const roles = this.tokenStorage.get('roles');\r\n    // Prefer company_id (specific tenant) over organization_id (system group)\r\n    const tenantId = this.tokenStorage.get('company_id') || this.getOrganizationId() || '';\r\n\r\n    return {\r\n      tenantId: tenantId,\r\n      principalId: this.getUserId() || '',\r\n      roles: Array.isArray(roles) ? roles : roles ? [roles] : [],\r\n    };\r\n  }\r\n\r\n  get licenseKey(): string {\r\n    return this.tokenStorage.get('license_key') || this.coreConfig.licenseKey || '';\r\n  }\r\n\r\n  get isFederated(): boolean {\r\n    return this.licenseKey.startsWith('doohbot_lic_');\r\n  }\r\n\r\n  setLicenseKey(key: string) {\r\n    this.tokenStorage.set('license_key', key);\r\n  }\r\n\r\n  //! clear local storage\r\n  /**\r\n   * Clear all authentication related data from local storage, session storage, cache, and tokens.\r\n   * This method is called when the user logs out.\r\n   */\r\n  clearAuth() {\r\n    const userId = this.getUserId();\r\n    logger.log('[Auth] Clearing auth:', { userId });\r\n\r\n    this.clearSession();\r\n    this.clearStorage();\r\n    this.clearCache();\r\n    this.clearLocalStorage();\r\n\r\n    // ENSURE authStatus$ emits unauthenticated\r\n    this.authStatusSubject.next('unauthenticated');\r\n\r\n    logger.log('[Auth] Auth cleared successfully');\r\n  }\r\n\r\n  clearSession() {\r\n    sessionStorage.clear();\r\n  }\r\n\r\n  clearTabInfo() {\r\n    localStorage.removeItem('tabs');\r\n  }\r\n\r\n  clearStorage() {\r\n    this.tokenStorage.clear();\r\n  }\r\n  clearLocalStorage() {\r\n    localStorage.clear();\r\n  }\r\n\r\n  clearCache() {\r\n    // this.cacheService.clear();\r\n  }\r\n}\r\n"]}

package/esm2022/lib/core/auth/models/auth-result.model.mjs

@@ -0,0 +1,3 @@
+export class AuthResult {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1yZXN1bHQubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kb29oYm90L3NyYy9saWIvY29yZS9hdXRoL21vZGVscy9hdXRoLXJlc3VsdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sVUFBVTtDQUd0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBBdXRoUmVzdWx0IHtcclxuICBhY2Nlc3NfdG9rZW4hOiBzdHJpbmc7XHJcbiAgcmVmcmVzaF90b2tlbiE6IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2022/lib/core/auth/models/federated-login-request.model.mjs

@@ -0,0 +1,6 @@
+export class FederatedLoginRequest {
+    constructor() {
+        this.rememberMe = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmVkZXJhdGVkLWxvZ2luLXJlcXVlc3QubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kb29oYm90L3NyYy9saWIvY29yZS9hdXRoL21vZGVscy9mZWRlcmF0ZWQtbG9naW4tcmVxdWVzdC5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8scUJBQXFCO0lBQWxDO1FBRUUsZUFBVSxHQUFhLEtBQUssQ0FBQztJQUUvQixDQUFDO0NBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgRmVkZXJhdGVkTG9naW5SZXF1ZXN0IHtcclxuICBhY2Nlc3NUb2tlbiE6IHN0cmluZztcclxuICByZW1lbWJlck1lPzogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIGxpY2Vuc2U/OiBzdHJpbmc7XHJcbn1cclxuIl19

package/esm2022/lib/core/auth/models/login-request.model.mjs

@@ -0,0 +1,6 @@
+export class LoginRequest {
+    constructor() {
+        this.rememberMe = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9naW4tcmVxdWVzdC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Rvb2hib3Qvc3JjL2xpYi9jb3JlL2F1dGgvbW9kZWxzL2xvZ2luLXJlcXVlc3QubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFlBQVk7SUFBekI7UUFHRSxlQUFVLEdBQWEsS0FBSyxDQUFDO0lBRS9CLENBQUM7Q0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjbGFzcyBMb2dpblJlcXVlc3Qge1xyXG4gIHVzZXJuYW1lITogc3RyaW5nO1xyXG4gIHBhc3N3b3JkITogc3RyaW5nO1xyXG4gIHJlbWVtYmVyTWU/OiBib29sZWFuID0gZmFsc2U7XHJcbiAgbGljZW5zZT86IHN0cmluZztcclxufVxyXG4iXX0=

package/esm2022/lib/core/auth/storage.service.mjs

@@ -0,0 +1,110 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import Logger from '../utils/logger.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/core-config.service";
+export class StorageService {
+    get storageKey() {
+        return this.coreConfig.storageKey;
+    }
+    get secretKey() {
+        return this.coreConfig.secretKey;
+    }
+    constructor(coreConfig) {
+        this.coreConfig = coreConfig;
+        // Determine initial storage
+        // If session storage has data, use it (implies remember me was false)
+        // Otherwise default/fallback to local storage
+        if (sessionStorage.getItem(this.storageKey)) {
+            this.storage = sessionStorage;
+        }
+        else {
+            this.storage = localStorage;
+        }
+    }
+    setRememberMe(rememberMe) {
+        const currentData = this.storage.getItem(this.storageKey);
+        const targetStorage = rememberMe ? localStorage : sessionStorage;
+        // If storage type is changing, move data
+        if (this.storage !== targetStorage) {
+            if (currentData) {
+                targetStorage.setItem(this.storageKey, currentData);
+                this.storage.removeItem(this.storageKey);
+            }
+            this.storage = targetStorage;
+        }
+    }
+    set(key, value) {
+        const data = this.storage.getItem(this.storageKey);
+        let dataJson = {};
+        if (data) {
+            const dataDec = this.decrypt(data);
+            if (dataDec) {
+                dataJson = JSON.parse(dataDec);
+            }
+        }
+        dataJson = Object.assign(dataJson, { [key]: value });
+        this.storage.setItem(this.storageKey, this.encrypt(JSON.stringify(dataJson)));
+    }
+    get(key) {
+        const data = this.storage.getItem(this.storageKey);
+        if (data) {
+            const dataDec = this.decrypt(data);
+            if (dataDec) {
+                try {
+                    const dataJson = JSON.parse(dataDec);
+                    return dataJson[key] || null;
+                }
+                catch (e) {
+                    Logger.error('[TokenStorage] Failed to parse decrypted data, clearing corrupt storage:', e);
+                    this.clear();
+                    return null;
+                }
+            }
+            else {
+                // Decrypt failed, auto-clear corrupt storage
+                Logger.error('[TokenStorage] Decrypt failed, clearing corrupt storage');
+                this.clear();
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if storage is valid (can be decrypted) without side effects
+     */
+    isValid() {
+        const data = this.storage.getItem(this.storageKey);
+        if (!data)
+            return false;
+        const decrypted = this.decrypt(data);
+        return decrypted !== null && decrypted !== '';
+    }
+    clear() {
+        // Clear both to be safe
+        localStorage.removeItem(this.storageKey);
+        sessionStorage.removeItem(this.storageKey);
+    }
+    encrypt(value) {
+        return CryptoJS.AES.encrypt(value, this.secretKey).toString();
+    }
+    decrypt(value) {
+        try {
+            const bytes = CryptoJS.AES.decrypt(value, this.secretKey);
+            const decrypted = bytes.toString(CryptoJS.enc.Utf8);
+            return decrypted || null;
+        }
+        catch (e) {
+            Logger.error('[TokenStorage] Decryption error:', e);
+            return null;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StorageService, deps: [{ token: i1.CoreConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StorageService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.CoreConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage.service.js","sourceRoot":"","sources":["../../../../../../projects/doohbot/src/lib/core/auth/storage.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as CryptoJS from 'crypto-js';\r\nimport { CoreConfigService } from '../services/core-config.service';\r\nimport Logger from '../utils/logger.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class StorageService {\r\n  get storageKey(): string {\r\n    return this.coreConfig.storageKey;\r\n  }\r\n\r\n  get secretKey(): string {\r\n    return this.coreConfig.secretKey;\r\n  }\r\n\r\n  private storage: Storage;\r\n\r\n  constructor(private coreConfig: CoreConfigService) {\r\n    // Determine initial storage\r\n    // If session storage has data, use it (implies remember me was false)\r\n    // Otherwise default/fallback to local storage\r\n    if (sessionStorage.getItem(this.storageKey)) {\r\n      this.storage = sessionStorage;\r\n    } else {\r\n      this.storage = localStorage;\r\n    }\r\n  }\r\n\r\n  setRememberMe(rememberMe: boolean): void {\r\n    const currentData = this.storage.getItem(this.storageKey);\r\n    const targetStorage = rememberMe ? localStorage : sessionStorage;\r\n\r\n    // If storage type is changing, move data\r\n    if (this.storage !== targetStorage) {\r\n      if (currentData) {\r\n        targetStorage.setItem(this.storageKey, currentData);\r\n        this.storage.removeItem(this.storageKey);\r\n      }\r\n      this.storage = targetStorage;\r\n    }\r\n  }\r\n\r\n  set(key: string, value: any): void {\r\n    const data = this.storage.getItem(this.storageKey);\r\n    let dataJson: any = {};\r\n    if (data) {\r\n      const dataDec = this.decrypt(data);\r\n      if (dataDec) {\r\n        dataJson = JSON.parse(dataDec);\r\n      }\r\n    }\r\n    dataJson = Object.assign(dataJson, { [key]: value });\r\n    this.storage.setItem(this.storageKey, this.encrypt(JSON.stringify(dataJson)));\r\n  }\r\n\r\n  get(key: string): any {\r\n    const data = this.storage.getItem(this.storageKey);\r\n    if (data) {\r\n      const dataDec = this.decrypt(data);\r\n      if (dataDec) {\r\n        try {\r\n          const dataJson = JSON.parse(dataDec);\r\n          return dataJson![key] || null;\r\n        } catch (e) {\r\n          Logger.error(\r\n            '[TokenStorage] Failed to parse decrypted data, clearing corrupt storage:',\r\n            e,\r\n          );\r\n          this.clear();\r\n          return null;\r\n        }\r\n      } else {\r\n        // Decrypt failed, auto-clear corrupt storage\r\n        Logger.error('[TokenStorage] Decrypt failed, clearing corrupt storage');\r\n        this.clear();\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Check if storage is valid (can be decrypted) without side effects\r\n   */\r\n  isValid(): boolean {\r\n    const data = this.storage.getItem(this.storageKey);\r\n    if (!data) return false;\r\n    const decrypted = this.decrypt(data);\r\n    return decrypted !== null && decrypted !== '';\r\n  }\r\n\r\n  clear(): void {\r\n    // Clear both to be safe\r\n    localStorage.removeItem(this.storageKey);\r\n    sessionStorage.removeItem(this.storageKey);\r\n  }\r\n\r\n  private encrypt(value: string): string {\r\n    return CryptoJS.AES.encrypt(value, this.secretKey).toString();\r\n  }\r\n\r\n  private decrypt(value: string): string | null {\r\n    try {\r\n      const bytes = CryptoJS.AES.decrypt(value, this.secretKey);\r\n      const decrypted = bytes.toString(CryptoJS.enc.Utf8);\r\n      return decrypted || null;\r\n    } catch (e) {\r\n      Logger.error('[TokenStorage] Decryption error:', e);\r\n      return null;\r\n    }\r\n  }\r\n}\r\n"]}