http-request-manager 18.15.33 → 18.15.34

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

@@ -0,0 +1,674 @@
+import { Inject, inject, Injectable, Injector, Optional, signal } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { 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 { RequestSignalsService } from './request-signals.service';
+import { requestPolling, countdown, delayedRetry } from './rxjs-operators';
+
+import { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ConfigOptions, BatchOptions, BatchResult, BatchRequestState } from '../../models';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import { WebSocketManagerService } from '../ws-manager-service/websocket-service';
+import { MessageTrackerService } from '../ws-manager-service/message-tracker.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HTTPManagerSignalsService<T> extends RequestSignalsService {
+
+  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$;
+  override subscribedChannels$ = this.wsManager.subscribedChannels$;
+
+  // ✅ Replaced BehaviorSubjects with Angular signals
+  countdown = signal<number>(0);
+  error = signal<string | boolean>(false);
+  data = signal<any>(null);
+
+  private polling$ = new Subject<void>();
+
+  config = ApiRequest.adapt();
+
+  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
+   */
+  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.set(true);
+    this.data.set(null);
+
+    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.set(data);
+        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
+      }),
+      finalize(() => this.isPending.set(false)),
+      catchError((err) => {
+        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message);
+        this.isPending.set(false);
+        return this.handleError(err);
+      })
+    );
+  }
+
+  postRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
+    this.isPending.set(true);
+    this.data.set(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.set(data);
+        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
+      }),
+      finalize(() => this.isPending.set(false)),
+      catchError((err) => {
+        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage);
+        this.isPending.set(false);
+        return this.handleError(err);
+      })
+    );
+  }
+
+  putRequest<T extends { id?: number|string }>(data: T, options: ApiRequest, params?: any[]) {
+    this.isPending.set(true);
+    this.data.set(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.set(data);
+        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
+      }),
+      finalize(() => this.isPending.set(false)),
+      catchError((err) => {
+        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage);
+        this.isPending.set(false);
+        return this.handleError(err);
+      })
+    );
+  }
+
+  deleteRequest<T>(options: ApiRequest, params?: any[]) {
+    this.isPending.set(true);
+    this.data.set(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.set(data);
+        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
+      }),
+      finalize(() => this.isPending.set(false)),
+      catchError((err) => {
+        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage);
+        this.isPending.set(false);
+        return this.handleError(err);
+      })
+    );
+  }
+
+  downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string) {
+    this.isPending.set(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.set(true);
+        this.isPending.set(false);
+        return this.handleError(err);
+      })
+    );
+  }
+  uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]) {
+    this.isPending.set(true);
+    this.data.set(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.set(data);
+        if (updatedOptions.displaySuccess) this.handleSuccessWithSnackBar(updatedOptions.successMessage);
+      }),
+      finalize(() => this.isPending.set(false)),
+      catchError((err) => {
+        if (updatedOptions.displayError) this.handleErrorWithSnackBar(err, updatedOptions.errorMessage || err?.message);
+        this.isPending.set(false);
+        return this.handleError(err);
+      })
+    );
+  }
+
+  // --- private helpers ---
+  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');
+
+    this.polling$.next();
+
+    const polling$ =
+      (isPolling && options.polling) || 0 >= 3
+        ? request$.pipe(
+            requestPolling((options.polling || 0) + 1, this.polling$, this.isPending),
+            tap(() => this.countdown.set(0)),
+            tap(() => {
+              if (!options.polling) return;
+              const count = options.polling ? options.polling : 0;
+              countdown(count)
+                .pipe(
+                  map((x: number) => {
+                    const pollingInSec = options.polling || 0;
+                    const percentageCompleted = ((pollingInSec - x) / pollingInSec) * 100;
+                    return Math.round(percentageCompleted);
+                  })
+                )
+                .subscribe((countDownValue: number) => {
+                  this.countdown.set(countDownValue);
+                });
+            }),
+          )
+        : request$.pipe(
+            catchError((err: any) => {
+              if (err instanceof HttpErrorResponse) {
+                this.error.set(true);
+                return this.handleError(err);
+              }
+              return throwError(() => err);
+            })
+          );
+
+    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.set(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 };
+  }
+
+  private handleError(error: Response | any) {
+    this.error.set(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,
+    });
+    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,
+    });
+    this.toastMessage.toastMessage(displaySuccess);
+  }
+
+  private stopPolling() {
+    this.isPending.set(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);
+  }
+}