@aakash58/chatbot 1.1.20 → 1.1.21

package/projects/doohbot/src/lib/core/helpers/crypto-helper.service.ts

@@ -0,0 +1,72 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CryptoHelperService {
+  private encoder = new TextEncoder();
+  private decoder = new TextDecoder();
+  private secretKey = ''; // Will be set by AuthService
+
+  setSecretKey(key: string) {
+    this.secretKey = key;
+  }
+
+  private async getKey() {
+    const salt = this.encoder.encode('fixed_salt'); // Keep constant
+    const baseKey = await crypto.subtle.importKey(
+      'raw',
+      this.encoder.encode(this.secretKey),
+      'PBKDF2',
+      false,
+      ['deriveKey'],
+    );
+
+    return crypto.subtle.deriveKey(
+      {
+        name: 'PBKDF2',
+        salt,
+        iterations: 100000,
+        hash: 'SHA-256',
+      },
+      baseKey,
+      { name: 'AES-GCM', length: 256 },
+      false,
+      ['encrypt', 'decrypt'],
+    );
+  }
+
+  async encrypt(value: string): Promise<string | null> {
+    if (!value) return null;
+
+    const key = await this.getKey();
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+
+    const encrypted = await crypto.subtle.encrypt(
+      { name: 'AES-GCM', iv },
+      key,
+      this.encoder.encode(value),
+    );
+
+    const merged = new Uint8Array(iv.length + encrypted.byteLength);
+    merged.set(iv, 0);
+    merged.set(new Uint8Array(encrypted), iv.length);
+
+    return btoa(String.fromCharCode(...merged));
+  }
+
+  async decrypt(value: string): Promise<string | null> {
+    if (!value) return null;
+
+    const raw = Uint8Array.from(atob(value), (c) => c.charCodeAt(0));
+
+    const iv = raw.slice(0, 12);
+    const data = raw.slice(12);
+
+    const key = await this.getKey();
+
+    const decrypted = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, data);
+
+    return this.decoder.decode(decrypted);
+  }
+}

package/projects/doohbot/src/lib/core/http/http-stream.service.ts

@@ -0,0 +1,105 @@
+import { Injectable, NgZone } from '@angular/core';
+import { HttpClient, HttpEventType, HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { StorageService } from '../auth/storage.service';
+import { ChatStreamResponse } from '../../app/chat/model/chat-stream-response.model';
+import logger from '../utils/logger.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HttpStreamService {
+  constructor(
+    private ngZone: NgZone,
+    private tokenStorage: StorageService,
+    private http: HttpClient,
+  ) {}
+
+  /**
+   * Creates a POST-based HTTP streaming connection using fetch()
+   */
+  createHttpStream(
+    url: string,
+    body: any,
+    headers?: Record<string, string>,
+  ): Observable<ChatStreamResponse> {
+    return new Observable<ChatStreamResponse>((observer) => {
+      // Note: Authorization header is added automatically by AuthInterceptor
+      let requestHeaders = new HttpHeaders({
+        'content-type': 'application/json',
+        accept: 'text/event-stream',
+        'cache-control': 'no-cache',
+      });
+
+      if (headers) {
+        Object.keys(headers).forEach((key) => {
+          requestHeaders = requestHeaders.set(key, headers[key]);
+        });
+      }
+
+      const req = this.http.request('POST', url, {
+        body,
+        headers: requestHeaders,
+        reportProgress: true,
+        observe: 'events',
+        responseType: 'text',
+      });
+
+      let lastLoaded = 0;
+
+      const sub = req.subscribe({
+        next: (event) => {
+          if (event.type === HttpEventType.DownloadProgress) {
+            // Process the new chunk of data
+            const fullText = (event as any).partialText;
+            if (!fullText) return;
+
+            const newText = fullText.slice(lastLoaded);
+            lastLoaded = fullText.length;
+
+            const lines = newText.split('\n');
+
+            for (const line of lines) {
+              if (line.trim() === '') continue;
+
+              if (line.startsWith('data: ')) {
+                const dataStr = line.substring(6).trim();
+
+                if (dataStr === '[DONE]') {
+                  this.ngZone.run(() => observer.complete());
+                  return;
+                }
+
+                try {
+                  const parsed = JSON.parse(dataStr);
+                  this.ngZone.run(() =>
+                    observer.next({
+                      content: parsed.content ?? parsed.message ?? '',
+                      type: parsed.type ?? 'chunk',
+                      id: parsed.response_id ?? '',
+                      created_at: parsed.created_at ?? '',
+                      sources: parsed.sources ?? [],
+                      error: parsed.error,
+                    }),
+                  );
+                } catch (e) {
+                  logger.warn('Failed to parse SSE data:', dataStr, e);
+                }
+              }
+            }
+          } else if (event.type === HttpEventType.Response) {
+            this.ngZone.run(() => observer.complete());
+          }
+        },
+        error: (err) => {
+          this.ngZone.run(() => observer.error(err));
+        },
+        complete: () => {
+          this.ngZone.run(() => observer.complete());
+        },
+      });
+
+      return () => sub.unsubscribe();
+    });
+  }
+}

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

@@ -0,0 +1,148 @@
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable, delay, retry, map, catchError, of } from 'rxjs';
+import { CoreConfigService } from '../services/core-config.service';
+import { StorageService } from '../auth/storage.service';
+import logger from '../utils/logger.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HttpService {
+  //   @BlockUI() blockUI!: NgBlockUI;
+
+  get apiUrl(): string {
+    return this.coreConfig.apiUrl;
+  }
+
+  constructor(
+    private http: HttpClient,
+    private tokenStorage: StorageService,
+    private coreConfig: CoreConfigService,
+  ) {
+    logger.log('HttpService: Initialized');
+  }
+
+  get(
+    url: string,
+    param?: object,
+    nestedParam = false,
+    showLoader = false,
+    refresh = true,
+    headers?: HttpHeaders,
+  ): Observable<any> {
+    // if (showLoader && !this.blockUI.isActive) {
+
+    //   this.blockUI.start();
+
+    // }
+
+    let params = {};
+
+    if (nestedParam) {
+      this.buildHttpParams(params, param, '');
+    } else {
+      params = param as HttpParams;
+    }
+
+    return this.http
+      .get(`${this.apiUrl}${url}`, {
+        params: params,
+        // withCredentials: true,
+        headers,
+      })
+      .pipe(
+        delay(100),
+
+        retry(0),
+
+        map((response) => this.returnResponse(response, showLoader)),
+
+        catchError((error) => {
+          // if (this.blockUI.isActive) {
+
+          //   this.blockUI.stop();
+
+          // }
+
+          return of(error);
+        }),
+      );
+  }
+
+  private buildHttpParams(params: any, data: any, currentPath: string) {
+    Object.keys(data).forEach((key) => {
+      if (data[key] instanceof Object && !(data[key] instanceof Array)) {
+        this.buildHttpParams(params, data[key], `${currentPath}${key}.`);
+      } else {
+        params[`${currentPath}${key}`] = data[key];
+      }
+    });
+  }
+
+  post(url: string, param?: object, showLoader = false, headers?: HttpHeaders): Observable<any> {
+    // if (showLoader && !this.blockUI.isActive) {
+    //   this.blockUI.start();
+    // }
+
+    return this.http.post(`${this.apiUrl}${url}`, param as HttpParams, { headers }).pipe(
+      delay(100),
+      retry(0),
+      map((response: any) => this.returnResponse(response, showLoader)),
+      catchError((error) => {
+        // if (this.blockUI.isActive) {
+        //   this.blockUI.stop();
+        // }
+
+        return of(error);
+      }),
+    );
+  }
+
+  patch(url: string, param?: object, showLoader = false, headers?: HttpHeaders): Observable<any> {
+    // if (showLoader && !this.blockUI.isActive) {
+    //   this.blockUI.start();
+    // }
+
+    return this.http.patch(`${this.apiUrl}${url}`, param as HttpParams, { headers }).pipe(
+      delay(100),
+      retry(0),
+      map((response: any) => this.returnResponse(response, showLoader)),
+      catchError((error) => {
+        // if (this.blockUI.isActive) {
+        //   this.blockUI.stop();
+        // }
+
+        return of(error);
+      }),
+    );
+  }
+
+  delete(url: string, param?: object, showLoader = false, headers?: HttpHeaders): Observable<any> {
+    // if (showLoader && !this.blockUI.isActive) {
+    //   this.blockUI.start();
+    // }
+    let params = {};
+    params = param as HttpParams;
+
+    return this.http.delete(`${this.apiUrl}${url}`, { body: param, headers }).pipe(
+      delay(100),
+      retry(0),
+      map((response: any) => this.returnResponse(response, showLoader)),
+      catchError((error) => {
+        // if (this.blockUI.isActive) {
+        //   this.blockUI.stop();
+        // }
+
+        return of(error);
+      }),
+    );
+  }
+
+  private returnResponse(value: any, showLoader: boolean = true): any {
+    // if (showLoader && this.blockUI.isActive) {
+    //   this.blockUI.reset();
+    // }
+    return value;
+  }
+}

package/projects/doohbot/src/lib/core/interceptors/auth.interceptor.ts

@@ -0,0 +1,118 @@
+import {
+  HttpErrorResponse,
+  HttpEvent,
+  HttpHandler,
+  HttpInterceptor,
+  HttpRequest,
+} from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, catchError, filter, Observable, switchMap, take, throwError } from 'rxjs';
+import { AuthService } from '../auth/auth.service';
+import { StorageService } from '../auth/storage.service';
+import { Injector } from '@angular/core';
+import logger from '../utils/logger.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AuthInterceptor implements HttpInterceptor {
+  private isRefreshing = false;
+  private clearingAuth = false; // Prevent multiple clearAuth calls
+  private refreshTokenSubject: BehaviorSubject<any> = new BehaviorSubject<any>(null);
+
+  constructor(
+    private tokenStorage: StorageService,
+    private injector: Injector,
+  ) {}
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    const authReq = this.getRequestWithHeaders(req);
+
+    return next.handle(authReq).pipe(
+      catchError((error) => {
+        // Handle 401 Unauthorized errors
+        if (
+          error instanceof HttpErrorResponse &&
+          error.status === 401 &&
+          !authReq.url.includes('auth/login') && // Don't retry login
+          !authReq.url.includes('auth/federated/login') && // Don't retry federated login
+          !authReq.url.includes('auth/logout') && // Don't retry logout
+          !authReq.url.includes('auth/refresh') // Don't retry refresh itself
+        ) {
+          logger.error('[AuthInterceptor] 401 Unauthorized:', {
+            url: authReq.url,
+            userId: this.tokenStorage.get('user_id'),
+          });
+          return this.handle401Error(authReq, next);
+        }
+        return throwError(() => error);
+      }),
+    );
+  }
+
+  private handle401Error(request: HttpRequest<any>, next: HttpHandler) {
+    // If already clearing, don't retry
+    if (this.clearingAuth) {
+      logger.log('[AuthInterceptor] Already clearing auth, rejecting request');
+      return throwError(() => new Error('Authentication cleared'));
+    }
+
+    if (!this.isRefreshing) {
+      this.isRefreshing = true;
+      this.refreshTokenSubject.next(null);
+
+      const authService = this.injector.get(AuthService);
+      return authService.refreshToken().pipe(
+        switchMap((token: any) => {
+          this.isRefreshing = false;
+          this.refreshTokenSubject.next(token.access_token);
+          // Retry the original request with the new token
+          return next.handle(this.getRequestWithHeaders(request));
+        }),
+        catchError((err) => {
+          this.isRefreshing = false;
+          // Refresh failed - logout user (only once)
+          if (!this.clearingAuth) {
+            this.clearingAuth = true;
+            const authService = this.injector.get(AuthService);
+            authService.clearAuth();
+            this.clearingAuth = false;
+          }
+          return throwError(() => err);
+        }),
+      );
+    } else {
+      // Wait while getting new token
+      return this.refreshTokenSubject.pipe(
+        filter((token) => token != null),
+        take(1),
+        switchMap((jwt) => {
+          // Rewrite with new token and retry
+          return next.handle(this.getRequestWithHeaders(request));
+        }),
+      );
+    }
+  }
+
+  getRequestWithHeaders(req: HttpRequest<any>): HttpRequest<any> {
+    // Skip adding token for login/refresh/logout endpoints
+    if (
+      req.url.includes('auth/login') ||
+      req.url.includes('auth/federated/login') ||
+      req.url.includes('auth/refresh') ||
+      req.url.includes('auth/logout')
+    ) {
+      return req;
+    }
+
+    let headers = req.headers;
+    // Get fresh token from new storage service
+    const token = this.tokenStorage.get('access_token') ?? '';
+
+    if (token != '') {
+      headers = headers.set('authorization', `Bearer ${token}`);
+    }
+
+    return req.clone({ headers });
+  }
+}

package/projects/doohbot/src/lib/core/interceptors/license.interceptor.ts

@@ -0,0 +1,50 @@
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
+import { Injectable, Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { AuthService } from '../auth/auth.service';
+import { LicenseService } from '../services/license.service';
+
+@Injectable()
+export class LicenseInterceptor implements HttpInterceptor {
+  constructor(private injector: Injector) {}
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    const authService = this.injector.get(AuthService);
+    const licenseService = this.injector.get(LicenseService);
+
+    // Skip if this is a login/auth request (AccountService handles it explicitly)
+    if (
+      req.url.includes('auth/login') ||
+      req.url.includes('auth/federated/login') ||
+      req.url.includes('auth/refresh') ||
+      req.url.includes('auth/logout')
+    ) {
+      return next.handle(req);
+    }
+
+    // Determine if this is an internal API request
+    const apiUrl = authService.apiUrl;
+
+    const isInternalApi =
+      (apiUrl && req.url.startsWith(apiUrl)) ||
+      (!req.url.startsWith('http') && !req.url.startsWith('assets/'));
+
+    if (!isInternalApi) {
+      return next.handle(req);
+    }
+
+    // Resolve License Key for Authenticated Request
+    const context = authService.getLicensingContext();
+    // Post-login, context.tenantId should be company_id
+    const licenseKey = licenseService.resolveLicenseKey(context, '');
+
+    if (licenseKey) {
+      const clonedReq = req.clone({
+        headers: req.headers.set('x-license-key', licenseKey),
+      });
+      return next.handle(clonedReq);
+    }
+
+    return next.handle(req);
+  }
+}

package/projects/doohbot/src/lib/core/models/api-config.model.ts

@@ -0,0 +1,82 @@
+import { InjectionToken } from '@angular/core';
+import { environment } from '../environments/environment.prod';
+
+/**
+ * Configuration for Doohbot API integration
+ */
+export interface DoohbotApiConfig {
+  /**
+   * Backend API endpoint URL
+   * Example: 'https://api.example.com/chat'
+   */
+  apiUrl: string;
+
+  /**
+   * Optional API key for authentication
+   */
+  apiKey?: string;
+
+  /**
+   * Request timeout in milliseconds
+   * @default 30000 (30 seconds)
+   */
+  timeout?: number; // no need
+
+  /**
+   * Enable API mode (true) or use local intent matching (false)
+   * @default false
+   */
+  enableApi?: boolean; // no need
+
+  /**
+   * Include message history in API requests
+   * @default false
+   */
+  includeHistory?: boolean; // no need
+
+  /**
+   * Maximum number of history messages to include in requests
+   * @default 10
+   */
+  maxHistoryMessages?: number; // no need
+
+  /**
+   * Custom headers to include in API requests
+   */
+  customHeaders?: Record<string, string>;
+
+  /**
+   * Enable retry on failure
+   * @default true
+   */
+  enableRetry?: boolean;
+
+  /**
+   * Number of retry attempts
+   * @default 2
+   */
+  retryAttempts?: number;
+
+  /**
+   * Delay between retries in milliseconds
+   * @default 1000
+   */
+  retryDelay?: number;
+}
+
+/**
+ * Injection token for providing Doohbot API configuration
+ */
+export const DOOHBOT_API_CONFIG = new InjectionToken<DoohbotApiConfig>('DOOHBOT_API_CONFIG', {
+  providedIn: 'root',
+  factory: () => ({
+    apiUrl: '',
+    timeout: 30000,
+    enableApi: false,
+    includeHistory: false,
+    maxHistoryMessages: 10,
+    enableRetry: true,
+    retryAttempts: 2,
+    retryDelay: 1000,
+  }),
+});

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

@@ -0,0 +1,92 @@
+import { PromptMode } from '../types/prompt-mode.type';
+import { Message } from './message';
+
+/**
+ * Request payload for chat API
+ */
+export interface ChatApiRequest {
+  /**
+   * User's message text
+   */
+  message: string;
+
+  /**
+   * Prompt mode
+   */
+  prompt_mode?: PromptMode;
+
+  /**
+   * Optional message history for context
+   */
+  history?: Message[];
+
+  /**
+   * Optional metadata
+   */
+  metadata?: Record<string, any>;
+
+  /**
+   * Timestamp of the request
+   */
+  timestamp?: string;
+}
+
+/**
+ * Response from chat API
+ */
+export interface ChatApiResponse {
+  /**
+   * Bot's reply message
+   */
+  reply: string;
+
+  /**
+   * Optional confidence score (0-1)
+   */
+  confidence?: number;
+
+  /**
+   * Whether to show suggestion chips
+   */
+  showSuggestions?: boolean;
+
+  /**
+   * Optional suggested responses
+   */
+  suggestions?: string[];
+
+  /**
+   * Optional metadata from the API
+   */
+  metadata?: Record<string, any>;
+
+  /**
+   * Optional message ID from the backend
+   */
+  messageId?: string;
+}
+
+/**
+ * Error response from chat API
+ */
+export interface ChatApiError {
+  /**
+   * Error message
+   */
+  message: string;
+
+  /**
+   * Error code
+   */
+  code?: string;
+
+  /**
+   * HTTP status code
+   */
+  statusCode?: number;
+
+  /**
+   * Additional error details
+   */
+  details?: any;
+}

package/projects/doohbot/src/lib/core/models/api-response.model.ts

@@ -0,0 +1,13 @@
+export class ApiResponse<T> {
+  success!: boolean;
+
+  message!: string;
+
+  data?: T;
+
+  constructor(success: boolean, message: string, data?: T) {
+    this.success = success;
+    this.message = message;
+    this.data = data;
+  }
+}