@aakash58/chatbot 1.1.21 → 1.1.22

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

@@ -1,72 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-  }
-}