@aakash58/chatbot 1.1.19 → 1.1.21

package/projects/doohbot/src/lib/core/auth/auth.service.ts

@@ -0,0 +1,478 @@
+import { inject, Injectable, signal } from '@angular/core';
+import { CoreConfigService } from '../services/core-config.service';
+import { DoohbotInput } from '../../doohbot-input';
+import {
+  BehaviorSubject,
+  map,
+  Observable,
+  catchError,
+  of,
+  tap,
+  retry,
+  throwError,
+  firstValueFrom,
+} from 'rxjs';
+import { AuthResult } from './models/auth-result.model';
+import { FederatedLoginRequest } from './models/federated-login-request.model';
+import { LoginRequest } from './models/login-request.model';
+import { JwtHelperService } from '@auth0/angular-jwt';
+import { CryptoHelperService } from '../helpers/crypto-helper.service';
+import { StorageService } from './storage.service';
+import logger from '../utils/logger.service';
+import { AuthStatus } from '../types/auth-status.type';
+import { AccountService } from './account-api.service';
+import { SnackbarUtils } from './../../shared/snackbar/snackbar.utils';
+import { DoohbotConst } from '../../constant/doohbot-constant';
+import { Router } from '@angular/router';
+import { LicensingContext } from '../models/license.model';
+import { DOOHBOT_ADVANCED_CONFIG } from '../models/doohbot-config.model';
+
+//! inherit Window storageEventAdded for duplicate tab detection
+declare global {
+  interface Window {
+    storageEventAdded?: boolean;
+    tabCLoseEventAdded?: boolean;
+    abp?: any;
+    AppPreBootstrap?: any;
+    AppConsts?: any;
+  }
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AuthService {
+  get apiUrl(): string {
+    return this.coreConfig.apiUrl;
+  }
+
+  get storageKey(): string {
+    return this.coreConfig.storageKey;
+  }
+
+  get secretKey(): string {
+    return this.coreConfig.secretKey;
+  }
+
+  get companyCode(): string {
+    return this.coreConfig.companyCode;
+  }
+
+  jwtHelper: JwtHelperService = new JwtHelperService();
+  private advancedConfig = inject(DOOHBOT_ADVANCED_CONFIG, { optional: true });
+
+  // Reactive Authentication State
+  private authStatusSubject = new BehaviorSubject<AuthStatus>('unauthenticated');
+  public authStatus$ = this.authStatusSubject.asObservable();
+
+  // UI State Signals (Merged from ChatAuthService)
+  public isLoggingIn = signal<boolean>(false);
+  public authError = signal<string | null>(null);
+  public authSuccess = signal<string | null>(null);
+
+  constructor(
+    private accountService: AccountService,
+    private cryptoHelper: CryptoHelperService,
+    private tokenStorage: StorageService,
+    private router: Router,
+    private coreConfig: CoreConfigService,
+  ) {
+    // Properties are now derived from coreConfig
+  }
+
+  /**
+   * Updates the service configuration from the component input
+   */
+  public updateConfig(config: DoohbotInput): void {
+    this.coreConfig.updateConfig(config);
+    if (config.secretKey) {
+      this.cryptoHelper.setSecretKey(config.secretKey);
+    }
+  }
+
+  getLoggedInUserName(): string {
+    const username = this.tokenStorage.get('username');
+    return username || '';
+  }
+
+  getLoggedInUserImageUrl(): string | null {
+    return DoohbotConst.userAvatar;
+  }
+
+  getLoggedInUserRole(): string {
+    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$
+  public get authStatus(): AuthStatus {
+    return this.authStatusSubject.value;
+  }
+
+  /**
+   * Resolves a federated token from browser storage
+   */
+  private resolveSilentToken(): string | null {
+    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: Partial<FederatedLoginRequest>,
+    silent: boolean = true,
+  ): Promise<boolean> {
+    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 as FederatedLoginRequest),
+      );
+      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: LoginRequest, silent: boolean = false): Promise<boolean> {
+    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?: string): Promise<boolean> {
+    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: AuthResult, rememberMe: boolean = 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(): string | null {
+    logger.debug('>>>>>>>>>>getOrganizationId<<<<<<<:', this.tokenStorage.get('organization_id'));
+    return this.tokenStorage.get('organization_id');
+  }
+
+  getRefreshToken(): string | null {
+    logger.debug('>>>>>>>>>>getRefreshToken<<<<<<<:', this.tokenStorage.get('refresh_token'));
+    return this.tokenStorage.get('refresh_token');
+  }
+
+  refreshToken(): Observable<AuthResult> {
+    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: any) => {
+        if (response && response.success && response.data) {
+          this.setSession(response.data);
+        }
+      }),
+      map((response: any) => {
+        if (response && response.success && response.data) {
+          return response.data as AuthResult;
+        } 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(): boolean {
+    const token = this.tokenStorage.get('access_token');
+    return !!token && !this.isTokenExpired();
+  }
+
+  isTokenExpired(): boolean {
+    let token = (this.tokenStorage.get('access_token') ?? '') as string;
+    if (token) {
+      return this.jwtHelper.isTokenExpired(token);
+    } else {
+      return true;
+    }
+  }
+
+  /**
+   * Validate stored token on app startup
+   */
+  validateStoredToken(): Observable<AuthStatus> {
+    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' as AuthStatus;
+      }),
+      catchError((err) => {
+        logger.error('[Auth] Token refresh failed:', err);
+        this.clearAuth();
+        this.authStatusSubject.next('unauthenticated');
+        return of('unauthenticated' as AuthStatus);
+      }),
+    );
+  }
+
+  getUserId() {
+    return this.tokenStorage.get('user_id') || '';
+  }
+
+  getLicensingContext(): LicensingContext {
+    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(): string {
+    return this.tokenStorage.get('license_key') || this.coreConfig.licenseKey || '';
+  }
+
+  get isFederated(): boolean {
+    return this.licenseKey.startsWith('doohbot_lic_');
+  }
+
+  setLicenseKey(key: string) {
+    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();
+  }
+}

package/projects/doohbot/src/lib/core/auth/models/auth-result.model.ts

@@ -0,0 +1,4 @@
+export class AuthResult {
+  access_token!: string;
+  refresh_token!: string;
+}

package/projects/doohbot/src/lib/core/auth/models/federated-login-request.model.ts

@@ -0,0 +1,5 @@
+export class FederatedLoginRequest {
+  accessToken!: string;
+  rememberMe?: boolean = false;
+  license?: string;
+}

package/projects/doohbot/src/lib/core/auth/models/login-request.model.ts

@@ -0,0 +1,6 @@
+export class LoginRequest {
+  username!: string;
+  password!: string;
+  rememberMe?: boolean = false;
+  license?: string;
+}

package/projects/doohbot/src/lib/core/auth/storage.service.ts

@@ -0,0 +1,113 @@
+import { Injectable } from '@angular/core';
+import * as CryptoJS from 'crypto-js';
+import { CoreConfigService } from '../services/core-config.service';
+import Logger from '../utils/logger.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class StorageService {
+  get storageKey(): string {
+    return this.coreConfig.storageKey;
+  }
+
+  get secretKey(): string {
+    return this.coreConfig.secretKey;
+  }
+
+  private storage: Storage;
+
+  constructor(private coreConfig: CoreConfigService) {
+    // 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: boolean): void {
+    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: string, value: any): void {
+    const data = this.storage.getItem(this.storageKey);
+    let dataJson: any = {};
+    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: string): any {
+    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(): boolean {
+    const data = this.storage.getItem(this.storageKey);
+    if (!data) return false;
+    const decrypted = this.decrypt(data);
+    return decrypted !== null && decrypted !== '';
+  }
+
+  clear(): void {
+    // Clear both to be safe
+    localStorage.removeItem(this.storageKey);
+    sessionStorage.removeItem(this.storageKey);
+  }
+
+  private encrypt(value: string): string {
+    return CryptoJS.AES.encrypt(value, this.secretKey).toString();
+  }
+
+  private decrypt(value: string): string | null {
+    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;
+    }
+  }
+}