http-request-manager 18.15.32 → 18.15.34

package/src/lib/services/request-manager-services/http-manager.service.ts

@@ -0,0 +1,727 @@
+import { Inject, inject, Injectable, Injector, Optional } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { BehaviorSubject, Observable, Subject, throwError, from, of } from 'rxjs';
+import { tap, map, finalize, catchError, concatMap, mergeMap, toArray, concat } from 'rxjs/operators';
+
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { RequestService } from './request.service';
+import { requestPolling, countdown, delayedRetry } from './rxjs-operators';
+
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ConfigOptions, BatchOptions, BatchResult, BatchRequestState } from '../../models';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
+import { WebSocketManagerService } from '../ws-manager-service/websocket-service';
+import { MessageTrackerService } from '../ws-manager-service/message-tracker.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HTTPManagerService<T> extends RequestService {
+
+  toastMessage = inject(ToastMessageDisplayService)
+  ng_injector = inject(Injector)
+  objectMergerService = inject(ObjectMergerService)
+  wsManager = inject(WebSocketManagerService)
+  messageTracker = inject(MessageTrackerService)
+
+  // Delegate WebSocket observables to WebSocketManagerService (singleton)
+  override connectionStatus$ = this.wsManager.connectionStatus$
+  override messages$ = this.messageTracker.messages$ // Messages flow through MessageTrackerService
+  override subscribedChannels$ = this.wsManager.subscribedChannels$
+  retryCount$ = this.wsManager.retryCount$
+  maxRetries$ = this.wsManager.maxRetries$
+
+  private countdown = new BehaviorSubject<number>(0);
+  countdown$ = this.countdown.asObservable();
+
+  private error = new BehaviorSubject<boolean>(false);
+  error$ = this.error.asObservable();
+
+  private data = new BehaviorSubject<any>(null)
+  data$ = this.data.asObservable()
+
+  private polling$ = new Subject<void>();
+
+  config = ApiRequest.adapt();
+
+  override streamProgress$ = this.streamProgress.asObservable();
+
+  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {
+    super()
+    this.config = (configOptions) ? ApiRequest.adapt(configOptions.httpRequestOptions) : this.config
+  }
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // WEBSOCKET METHODS (Delegated to WebSocketManagerService singleton)
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  /**
+   * Connect to WebSocket server
+   * Only the first call across ALL instances will establish a connection
+   */
+  override connect(options: any, jwtToken: string): void {
+    this.wsManager.connect(options, jwtToken);
+  }
+
+  /**
+   * Disconnect from WebSocket server
+   */
+  override disconnect(): void {
+    this.wsManager.disconnect();
+  }
+
+  /**
+   * Subscribe to a channel
+   */
+  override subscribeToChannel(channel: string, userData?: any): void {
+    this.messageTracker.subscribeToChannel(channel, userData);
+  }
+
+  /**
+   * Subscribe to multiple channels
+   */
+  override subscribeToChannels(channels: string[], userData?: any): void {
+    channels.forEach(channel => this.messageTracker.subscribeToChannel(channel, userData));
+  }
+
+  /**
+   * Unsubscribe from a channel
+   */
+  override unsubscribeFromChannel(channel: string): void {
+    this.wsManager.unsubscribeFromChannel(channel);
+  }
+
+  /**
+   * Get currently subscribed channels
+   */
+  override getSubscribedChannels(): Set<string> {
+    return this.wsManager.getSubscribedChannels();
+  }
+
+  /**
+   * Send broadcast message
+   */
+  override sendBroadcast(content: any): void {
+    this.wsManager.sendBroadcast(content);
+  }
+
+  /**
+   * Send message in channel (state manager message)
+   */
+  override sendMessageInChannel(channel: string, content: any): void {
+    this.wsManager.sendMessageInChannel(channel, content);
+  }
+
+  /**
+   * Send channel message
+   */
+  override sendChannelMessage(channel: string, content: any): void {
+    this.wsManager.sendChannelMessage(channel, content);
+  }
+
+  /**
+   * Send message to multiple channels
+   */
+  override sendChannelMessageToChannels(channels: string[], content: any): void {
+    this.wsManager.sendChannelMessageToChannels(channels, content);
+  }
+
+  /**
+   * Send message to user
+   */
+  override sendMessageToUser(user: string, content: any): void {
+    this.wsManager.sendMessageToUser(user, content);
+  }
+
+  /**
+   * Get all channels
+   */
+  override getAllChannels(): void {
+    this.wsManager.getAllChannels();
+  }
+
+  /**
+   * Create channel
+   */
+  override createChannel(channel: string): void {
+    this.wsManager.createChannel(channel);
+  }
+
+  /**
+   * Delete channel
+   */
+  override deleteChannel(channel: string): void {
+    this.wsManager.deleteChannel(channel);
+  }
+
+  /**
+   * Get users in channel
+   */
+  override getUsersInChannel(channel: string): void {
+    this.wsManager.getUsersInChannel(channel);
+  }
+
+  /**
+   * Create notification channel
+   */
+  override createNotificationChannel(channel: string): void {
+    this.wsManager.createNotificationChannel(channel);
+  }
+
+  /**
+   * Get notification channels
+   */
+  override getNotificationChannels(): void {
+    this.wsManager.getNotificationChannels();
+  }
+
+  /**
+   * Get today's notification channels
+   */
+  override getTodaysNotificationChannels(): void {
+    this.wsManager.getTodaysNotificationChannels();
+  }
+
+  /**
+   * Subscribe to notification channel
+   */
+  override subscribeToNotificationChannel(channel: string, options?: any, user?: any): void {
+    this.wsManager.subscribeToNotificationChannel(channel, options, user);
+  }
+
+  /**
+   * Unsubscribe from notification channel
+   */
+  override unsubscribeFromNotificationChannel(channel: string): void {
+    this.wsManager.unsubscribeFromNotificationChannel(channel);
+  }
+
+  /**
+   * Send notification to channel
+   */
+  override sendNotification(channel: string, content: any): void {
+    this.wsManager.sendNotification(channel, content);
+  }
+
+  // REQUESTS
+
+  getRequest<T>(options?: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+    this.streamProgress.next({
+      received: 0,
+      total: undefined,
+      percent: 0,
+      stage: 'connecting'
+    });
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.getRecordRequest;
+    const requests = this.createRequest(func, updatedOptions);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name)
+    .pipe(
+      tap(data => {
+        this.data.next(data)
+        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
+      }),
+      finalize(() => {
+        this.streamProgress.next({
+          ...this.streamProgress.value,
+          stage: 'complete'
+        });
+        this.isPending.next(false)
+      }),
+      catchError((err) => {
+        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
+        this.streamProgress.next({
+          ...this.streamProgress.value,
+          stage: 'error'
+        });
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+  }
+
+  postRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.createRecordRequest;
+    const requests = this.createRequest(func, updatedOptions, data);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(
+      tap(data => {
+        this.data.next(data)
+        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
+      }),
+      finalize(() => this.isPending.next(false)),
+      catchError((err) => {
+        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+  }
+
+  putRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.updateRecordRequest;
+    const requests = this.createRequest(func, updatedOptions, data);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(
+      tap(data => {
+        this.data.next(data)
+        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
+      }),
+      finalize(() => this.isPending.next(false)),
+      catchError((err) => {
+        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+  }
+
+  deleteRequest<T>(options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.deleteRecordRequest;
+    const requests = this.createRequest(func, updatedOptions);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(
+      tap(data => {
+        this.data.next(data)
+        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
+      }),
+      finalize(() => this.isPending.next(false)),
+      catchError((err) => {
+        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+  }
+
+  downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string) {
+
+    this.isPending.next(true);
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    const func = this.downloadFileRequest;
+    const requests = this.createRequest(func, updatedOptions)
+
+    return this.createObservable<T>(updatedOptions, requests, func.name)
+    .pipe(
+      catchError((err) => {
+        this.error.next(true)
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+
+  }
+
+  uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(null)
+
+    const updatedOptions = this.defineReqOptions(options, params)
+    updatedOptions.uploadFiles = files
+
+    const func = this.uploadFileRequest;
+    const requests = this.createRequest(func, updatedOptions);
+
+    return this.createObservable<T>(updatedOptions, requests, func.name).pipe(
+      tap(data => {
+        this.data.next(data)
+        if(updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage)
+      }),
+      finalize(() => this.isPending.next(false)),
+      catchError((err) => {
+        if(updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message)
+        this.isPending.next(false)
+        return this.handleError(err);
+      })
+    )
+  }
+
+  private createObservable<T>(options: ApiRequest, request$: Observable<T>, funcName: string) {
+
+    const polling = options.polling ? (options.polling > 0 ? true : false) : false;
+    const isPolling =
+      polling &&
+      !(funcName === 'deleteRecordRequest' || funcName === 'updateRecordRequest' || funcName === 'createRecordRequest')
+        ? true
+        : false;
+
+    this.polling$.next();
+
+    const polling$ =
+      (isPolling && options.polling) || 0 >= 3
+        ? request$.pipe(
+            requestPolling((options.polling || 0) + 1, this.polling$, this.isPending),
+            tap(() => this.countdown.next(0)),
+            tap(() => {
+              if (!options.polling) return;
+              const count = options.polling ? options.polling : 0;
+              // console.log('COUNT:', count);
+              countdown(count)
+                .pipe(
+                  map((x: number) => {
+                    // console.log('XX:', count, x);
+                    const pollingInSec = options.polling || 0;
+                    const percentageCompleted = ((pollingInSec - x) / pollingInSec) * 100;
+                    return Math.round(percentageCompleted);
+                  })
+                )
+                .subscribe((countDownValue: number) => {
+                  // console.log(this.countdown.value, countDownValue);
+                  this.countdown.next(countDownValue);
+                });
+            }),
+          )
+        : request$.pipe(
+            catchError((err: any) => {
+
+              if (err instanceof HttpErrorResponse) {
+                this.error.next(true);
+                return this.handleError(err);
+              }
+
+              return throwError(() => err);
+            }),
+            // finalize(() => this.isPending.next(false))
+          )
+
+    return polling$.pipe(
+      (options?.retry && options.retry.times > 0)
+        ? delayedRetry((options.retry.delay || 3) * 1000, (options.retry.times || 0) - 1)
+        : (source: Observable<T>) => source,
+      catchError((err: any, caught: Observable<T>) => {
+
+        if (err instanceof HttpErrorResponse) {
+          this.error.next(true);
+          if(isPolling) this.stopPolling();
+          return this.handleError(err);
+        }
+
+        return throwError(() => err);
+      })
+    );
+  }
+
+  private createRequest(func: Function, options: ApiRequest, data?: any | any[]) {
+    const dataItem = this.prepareRequestData(options, data, func.name);
+    return func.bind(this)(dataItem.options, dataItem.data);
+  }
+
+  private prepareRequestData(options: ApiRequest, data: any, funcName: string) {
+
+    if ((options.mapper && funcName === 'updateRecordRequest') || funcName === 'createRecordRequest') {
+      if (options?.mapper) {
+        data = options.mapper
+          ? Array.isArray(data)
+            ? map((item) => options.mapper(item))
+            : options.mapper(data)
+          : data;
+      }
+    } else {
+      if (options?.adapter) {
+        data = Array.isArray(data)
+            ? map((item) => options.adapter(item))
+            : options.adapter(data)
+      }
+    }
+
+    return { options: options, data: data };
+  }
+
+  // MISC
+
+  private handleError(error: Response | any) {
+    this.error.next(error.message || `${error.status} - ${error.statusText}`)
+    return throwError(() => error)
+  }
+
+  private handleErrorWithSnackBar(error: Response | any, message?: string) {
+
+    const displayError = ToastDisplay.adapt({
+            message: message || error.message || `${error.status} - ${error.statusText}`,
+            action: 'OK',
+            color: ToastColors.ERROR,
+            icon: 'error',
+            duration: 5 * 1000, //5 seconds
+          })
+
+    this.toastMessage.toastMessage(displayError)
+
+  }
+
+  private handleSuccessWithSnackBar(message?: string) {
+
+    const displaySuccess = ToastDisplay.adapt({
+            message: message || 'Success',
+            action: 'OK',
+            color: ToastColors.SUCCESS,
+            icon: 'check_circle',
+            duration: 3 * 1000, //3 seconds
+          })
+
+    this.toastMessage.toastMessage(displaySuccess)
+
+  }
+
+  private stopPolling() {
+    this.isPending.next(false);
+    this.polling$.next();
+  }
+
+  private defineReqOptions(options: any, params?: any[]) {
+
+    const req = ApiRequest.adapt(options)
+    if(req?.path) req.path = (params) ? [...req.path, ...params] : req.path
+
+    const optionsReq = (req)? req : ApiRequest.adapt()
+    const updatedOptions = this.objectMergerService.mergeOptions(optionsReq)
+
+    return updatedOptions
+
+  }
+
+  // BATCH REQUESTS
+
+  /**
+   * Execute multiple HTTP requests with configurable execution strategy
+   * @param requests Array of ApiRequest configurations
+   * @param options Optional batch configuration (all properties optional)
+   * @returns Observable emitting array of data in the order of requests provided
+   */
+  getBatchRequests<U = T>(
+    requests: ApiRequest[],
+    options?: BatchOptions
+  ): Observable<U[]> {
+    const batchOptions = BatchOptions.adapt(options);
+
+    const mode = batchOptions.mode || 'sequential';
+
+    if (mode === 'parallel') {
+      return this.getParallelRequest(requests, batchOptions);
+    } else {
+      return this.getSequentialRequest(requests, batchOptions);
+    }
+  }
+
+  /**
+   * Execute requests sequentially (one at a time, in order)
+   * @param requests Array of ApiRequest configurations
+   * @param options Optional batch configuration
+   * @returns Observable emitting array of data when all requests complete
+   */
+  getSequentialRequest<U = T>(
+    requests: ApiRequest[],
+    options?: BatchOptions,
+    successMessage?: string,
+    errorMessage?: string
+  ): Observable<U[]> {
+    const batchOptions = BatchOptions.adapt(options);
+    const results: U[] = new Array(requests.length);
+
+    return from(requests).pipe(
+      concatMap((req, index) => {
+        return this.getRequest<U>(req, undefined).pipe(
+          tap(data => {
+            results[index] = data;
+          }),
+          catchError(error => this.handleSequentialError(req, error, index, batchOptions))
+        );
+      }),
+      toArray(),
+      tap(() => {
+        if (batchOptions.displaySuccess) this.handleSuccessWithSnackBar(successMessage);
+      }),
+      map(() => results)
+    );
+  }
+
+  /**
+   * Execute requests in parallel with concurrency control
+   * @param requests Array of ApiRequest configurations
+   * @param options Optional batch configuration with concurrency limit
+   * @returns Observable emitting array of data when all requests complete
+   */
+  getParallelRequest<U = T>(
+    requests: ApiRequest[],
+    options?: BatchOptions,
+    successMessage?: string,
+    errorMessage?: string
+  ): Observable<U[]> {
+    const batchOptions = BatchOptions.adapt(options);
+    const concurrency = batchOptions.concurrency || 3;
+    const results: U[] = new Array(requests.length);
+
+    return from(requests).pipe(
+      mergeMap((req, index) => {
+        return this.getRequest<U>(req, undefined).pipe(
+          tap(data => {
+            results[index] = data;
+          }),
+          catchError(error => this.handleParallelError(req, error, index, batchOptions))
+        );
+      }, concurrency),
+      toArray(),
+      tap(() => {
+        if (batchOptions.displaySuccess) this.handleSuccessWithSnackBar(successMessage);
+      }),
+      map(() => results)
+    );
+  }
+
+  /**
+   * Execute multiple HTTP requests and emit individual state changes in real-time
+   * @param requests Array of ApiRequest configurations
+   * @param options Optional batch configuration (all properties optional)
+   * @returns Observable stream of individual request states
+   */
+  getBatchRequestsStream<U = T>(
+    requests: ApiRequest[],
+    options?: BatchOptions
+  ): Observable<BatchRequestState<U>> {
+    const batchOptions = BatchOptions.adapt(options);
+    const mode = batchOptions.mode || 'sequential';
+
+    if (mode === 'parallel') {
+      return this.getParallelStream(requests, batchOptions);
+    } else {
+      return this.getSequentialStream(requests, batchOptions);
+    }
+  }
+
+  /**
+   * Execute requests sequentially and emit state changes
+   */
+  private getSequentialStream<U>(
+    requests: ApiRequest[],
+    options: BatchOptions
+  ): Observable<BatchRequestState<U>> {
+    return from(requests).pipe(
+      concatMap((req, index) => {
+        const pending$: Observable<BatchRequestState<U>> = of({
+          index,
+          request: req,
+          isPending: true
+        });
+
+        const result$: Observable<BatchRequestState<U>> = this.getRequest<U>(req).pipe(
+          map((data) => ({
+            index,
+            request: req,
+            isPending: false,
+            data
+          }) as BatchRequestState<U>),
+          catchError((error) => of({
+            index,
+            request: req,
+            isPending: false,
+            error
+          } as BatchRequestState<U>))
+        );
+
+        return pending$.pipe(
+          concatMap(() => result$)
+        );
+      })
+    );
+  }
+
+  /**
+   * Execute requests in parallel and emit state changes
+   */
+  private getParallelStream<U>(
+    requests: ApiRequest[],
+    options: BatchOptions
+  ): Observable<BatchRequestState<U>> {
+    const concurrency = options.concurrency || 3;
+
+    return from(requests).pipe(
+      mergeMap((req, index) => {
+        const pending$: Observable<BatchRequestState<U>> = of({
+          index,
+          request: req,
+          isPending: true
+        });
+
+        const result$: Observable<BatchRequestState<U>> = this.getRequest<U>(req).pipe(
+          map((data) => ({
+            index,
+            request: req,
+            isPending: false,
+            data
+          }) as BatchRequestState<U>),
+          catchError((error) => of({
+            index,
+            request: req,
+            isPending: false,
+            error
+          } as BatchRequestState<U>))
+        );
+
+        return pending$.pipe(
+          concatMap(() => result$)
+        );
+      }, concurrency)
+    );
+  }
+
+  private handleSequentialError<U>(
+    request: ApiRequest,
+    error: any,
+    index: number,
+    options: BatchOptions
+  ): Observable<U> {
+    if (options.logErrors !== false) {
+      console.error(`Batch request ${index} failed:`, error);
+    }
+
+    if (options.stopOnError) {
+      return throwError(() => error);
+    }
+
+    if (options.ignoreErrors) {
+      return of(undefined as unknown as U);
+    }
+
+    return throwError(() => error);
+  }
+
+  private handleParallelError<U>(
+    request: ApiRequest,
+    error: any,
+    index: number,
+    options: BatchOptions
+  ): Observable<U> {
+    if (options.logErrors !== false) {
+      console.error(`Batch request ${index} failed:`, error);
+    }
+
+    if (options.ignoreErrors) {
+      return of(undefined as unknown as U);
+    }
+
+    return of(undefined as unknown as U);
+  }
+}
+