http-request-manager 18.7.20 → 18.7.21

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

@@ -0,0 +1,214 @@
+import { HttpClient, HttpEvent, HttpEventType, HttpHeaderResponse } from '@angular/common/http';
+import { Injectable, inject, signal, computed } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { catchError, finalize, map } from 'rxjs/operators';
+
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { PathQueryService, HeadersService } from '../utils';
+import { requestStreaming } from './rxjs-operators/request-streaming';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RequestSignalsService {
+
+  private http = inject(HttpClient);
+  private pathQueryService = inject(PathQueryService);
+  private headersService = inject(HeadersService);
+
+  isPending = signal(false);
+  progress = signal(0);
+
+  isIdle = computed(() => !this.isPending());
+
+  getRecordRequest<T>(options: ApiRequest): Observable<T> {
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildCombinedHeaders(options);
+
+    this.isPending.set(true);
+
+    return (options.stream)
+      ? this.http.get<any>(urlPath, headers).pipe(
+          requestStreaming(),
+          this.handleFinalize()
+        )
+      : this.http.get<T>(urlPath, headers).pipe(
+          this.request(options),
+          this.handleFinalize()
+        );
+  }
+
+  createRecordRequest<T>(options: ApiRequest, data: any): Observable<T> {
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildCombinedHeaders(options);
+
+    this.isPending.set(true);
+
+    return (options.stream)
+      ? this.http.post<any>(urlPath, data, headers).pipe(
+          requestStreaming(),
+          this.handleFinalize()
+        )
+      : this.http.post<T>(urlPath, data, headers).pipe(
+          this.request(options),
+          this.handleFinalize()
+        );
+  }
+
+  updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T> {
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildHeaders(options);
+
+    this.isPending.set(true);
+
+    return this.http.put<any>(urlPath, data, headers).pipe(
+      this.request(options),
+      this.handleFinalize()
+    );
+  }
+
+  deleteRecordRequest<T>(options: ApiRequest): Observable<T> {
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildHeaders(options);
+
+    this.isPending.set(true);
+
+    return this.http.delete<any>(urlPath, headers).pipe(
+      this.request(options),
+      this.handleFinalize()
+    );
+  }
+
+  private buildUrlPath(options: ApiRequest): string {
+    return this.pathQueryService.buildAPIPath(options.server, options.path);
+  }
+
+  private buildHeaders(options: ApiRequest): any {
+    return this.headersService.generateHeaders(options.headers);
+  }
+
+  private buildCombinedHeaders(options: ApiRequest): any {
+    const headers = this.headersService.generateHeaders(options.headers);
+    return this.combineHeaders(headers, options.stream || false);
+  }
+
+  private request<T>(options: ApiRequest): (source: Observable<any>) => Observable<T> {
+    return (source$: Observable<any>): Observable<T> => {
+      return source$.pipe(
+        map(data => {
+          if (options?.adapter) {
+            return Array.isArray(data)
+              ? data.map((item: any) => options.adapter(item))
+              : options.adapter(data);
+          }
+          return data;
+        })
+      );
+    };
+  }
+
+  downloadFileRequest(options: ApiRequest): Observable<any> {
+    this.isPending.set(true);
+
+    const urlPath = this.buildUrlPath(options);
+
+    return this.http.get(urlPath, { responseType: 'blob', observe: 'events', reportProgress: true })
+      .pipe(
+        map((event: HttpEvent<any>) => {
+          this.isPending.set(true);
+
+          if (event instanceof HttpHeaderResponse) {
+            if (event.status !== 200) {
+              this.isPending.set(false);
+              throw new Error('Download failed');
+            }
+          }
+
+          switch (event.type) {
+            case HttpEventType.DownloadProgress:
+              const status = (event.total) ? Math.round(event.loaded / (event.total || 1) * 100) : 100;
+              this.progress.set(status);
+              return status;
+
+            case HttpEventType.Response:
+              try {
+                const fileNamePath = (options?.saveAs) ? options.saveAs : (options.path) ? options.path[options.path.length - 1] : [];
+                const header_content = event.headers.get('Content-Disposition') || '';
+                const file = (header_content) ? header_content.split('=')[1].substring(0, header_content.split('=')[1].length) : '';
+
+                const fileName = (fileNamePath !== '') ? fileNamePath : file;
+
+                if (fileName === '') {
+                  this.isPending.set(false);
+                  throw new Error('Save File: (file name and extension) not found in Headers or Path');
+                }
+
+                this.downloadFile(fileName, event.body);
+                this.isPending.set(false);
+
+                return 100;
+
+              } catch (error) {
+                throw new Error('Download failed');
+              }
+
+            default:
+              this.isPending.set(false);
+              return 0;
+          }
+        }),
+        catchError(err => {
+          return throwError(() => err);
+        })
+      );
+  }
+
+  private handleFinalize(): (source: Observable<any>) => Observable<any> {
+    return finalize(() => this.isPending.set(false));
+  }
+
+  private downloadFile(file: string, fileData: any) {
+    const navigatorAny = window.navigator as any;
+    const extension = file.split('.')[1]?.toLowerCase();
+    const newBlob = new Blob([fileData], { type: this.createFileType(extension) });
+
+    if (navigatorAny.msSaveOrOpenBlob) {
+      navigatorAny.msSaveOrOpenBlob(newBlob, file);
+    } else {
+      const link = document.createElement('a');
+      const url = window.URL.createObjectURL(newBlob);
+      link.href = url;
+      link.download = file;
+      link.click();
+      window.URL.revokeObjectURL(url);
+    }
+  }
+
+  private createFileType(ext: string): string {
+    let fileType = "";
+
+    if (ext === 'pdf' || ext === 'csv') fileType = `application/${ext}`;
+    else if (ext === 'jpeg' || ext === 'jpg' || ext === 'png') fileType = `image/${ext}`;
+    else if (ext === 'txt') fileType = 'text/plain';
+    else if (ext === 'ppt' || ext === 'pot' || ext === 'pps' || ext === 'ppa') fileType = 'application/vnd.ms-powerpoint';
+    else if (ext === 'pptx') fileType = 'application/vnd.openxmlformats-officedocument.presentationml.presentation';
+    else if (ext === 'doc' || ext === 'dot') fileType = 'application/msword';
+    else if (ext === 'docx') fileType = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
+    else if (ext === 'xls' || ext === 'xlt' || ext === 'xla') fileType = 'application/vnd.ms-excel';
+    else if (ext === 'xlsx') fileType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+
+    return fileType;
+  }
+
+  private combineHeaders(headers: any, isStreaming: boolean) {
+    return (isStreaming)
+      ? {
+          ...headers,
+          observe: 'events',
+          responseType: 'text',
+          reportProgress: true,
+          Accept: 'text/event-stream'
+        }
+      : headers;
+  }
+}

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

@@ -0,0 +1,309 @@
+import { HttpClient, HttpEvent, HttpEventType, HttpHeaderResponse } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject, Observable, throwError } from 'rxjs';
+import { catchError, delay, finalize, map, tap } from 'rxjs/operators';
+
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { StreamType } from '../request-manager-state-service/models/stream-type.enum';
+import { PathQueryService, HeadersService } from '../utils';
+import { requestStreaming, StreamConfig } from './rxjs-operators/request-streaming';
+import { WebsocketService } from '../ws-manager-service';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RequestService extends WebsocketService {
+
+  private http = inject(HttpClient)
+
+  private pathQueryService = inject(PathQueryService)
+  private headersService = inject(HeadersService)
+
+  isPending = new BehaviorSubject<boolean>(false)
+  isPending$ = this.isPending.asObservable()
+
+  progress = new BehaviorSubject<number>(0)
+  progress$ = this.progress.asObservable()
+
+  getRecordRequest<T>(options: ApiRequest): Observable<T>;
+  // Overload for non-streaming requests
+  getRecordRequest<T>(options: ApiRequest): Observable<T>;
+  // Overload for streaming requests  
+  getRecordRequest<T>(options: ApiRequest & { stream: true }): Observable<T[]>;
+  // Implementation  
+  getRecordRequest<T>(options: ApiRequest): Observable<any> {
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildCombinedHeaders(options);
+
+    this.isPending.next(true);
+
+    return (options.stream)
+        ? this.http.get<any>(urlPath, {
+            ...headers,
+            observe: 'events',
+            responseType: 'text',
+            reportProgress: true
+          }).pipe(
+            tap(data => console.log('STREAM DATA', data)),
+            requestStreaming({ streamType: options.streamType || StreamType.AI_STREAMING }),
+            this.requestStreaming(options),
+            this.handleFinalize()
+          )
+        : this.http.get<T>(urlPath, headers).pipe(
+            this.request(options),
+        )
+  }
+
+  createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+  createRecordRequest<T>(options: ApiRequest & { stream: true }, data: any): Observable<T[]>;
+  // Overload for non-streaming requests
+  createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+  // Overload for streaming requests  
+  createRecordRequest<T>(options: ApiRequest & { stream: true }, data: any): Observable<T[]>;
+  // Implementation  
+  createRecordRequest<T>(options: ApiRequest, data: any): Observable<any> {
+
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildCombinedHeaders(options);
+
+    this.isPending.next(true);
+
+    return (options.stream)
+        ? this.http.post<any>(urlPath, data, {
+            ...headers,
+            observe: 'events',
+            responseType: 'text',
+            reportProgress: true
+          }).pipe(
+            requestStreaming({ streamType: options.streamType || StreamType.AI_STREAMING }),
+            this.requestStreaming(options),
+            this.handleFinalize()
+          )
+        : this.http.post<T>(urlPath, data, headers).pipe(
+            this.request(options),
+        )
+  }
+
+  updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T> {
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildHeaders(options);
+
+    this.isPending.next(true);
+
+    return this.http.put<any>(urlPath, data, headers).pipe(
+        this.request(options),
+    )
+  }
+
+  deleteRecordRequest<T>(options: ApiRequest): Observable<T> {
+
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildHeaders(options);
+
+    this.isPending.next(true);
+
+    return this.http.delete<any>(urlPath, headers).pipe(
+      this.request(options),
+    )
+  }
+
+  // Helper functions
+  private buildUrlPath(options: ApiRequest): string {
+    return this.pathQueryService.buildAPIPath(options.server, options.path);
+  }
+
+  private buildHeaders(options: ApiRequest): any {
+    return this.headersService.generateHeaders(options.headers);
+  }
+
+  private buildCombinedHeaders(options: ApiRequest): any {
+    const headers = this.headersService.generateHeaders(options.headers)
+    return this.combineHeaders(headers, options.stream || false)
+  }
+
+  private request<T>(options: ApiRequest): (source: Observable<any>) => Observable<T> {
+    return (source$: Observable<any>): Observable<T> => {
+      return source$.pipe(
+        map(data => {
+          if (!data || (Array.isArray(data) && data.length === 0)) {
+            return data
+          }
+          if (options?.adapter) {
+            return Array.isArray(data)
+              ? data.map((item: any) => options.adapter(item))
+              : options.adapter(data)
+          }
+          return data
+        })
+      )
+    }
+  }
+
+  private requestStreaming<T>(options: ApiRequest): (source: Observable<T[]>) => Observable<T[]> {
+    return (source$: Observable<T[]>): Observable<T[]> => {
+      return source$.pipe(
+        map(data => {
+          if (!data || (Array.isArray(data) && data.length === 0)) {
+            return data
+          }
+          if (options?.adapter) {
+            return data.map((item: any) => options.adapter(item))
+          }
+          return data
+        })
+      )
+    }
+  }
+
+  downloadFileRequest(options: ApiRequest): Observable<any> {
+
+    this.isPending.next(true);
+
+    const urlPath = this.buildUrlPath(options);
+
+    return this.http.get(urlPath, { responseType: 'blob', observe: 'events', reportProgress: true })
+    .pipe(
+      map((event: HttpEvent<any>) => {
+
+        this.isPending.next(true)
+
+        if (event instanceof HttpHeaderResponse) {
+          if(event.status !== 200) {
+            this.isPending.next(false)
+            throw new Error('Download failed');
+          }
+        }
+
+        // 0	Sent	Request has been sent.
+        // 1	UploadProgress	Upload is in progress.
+        // 2	ResponseHeader	Response headers received.
+        // 3	DownloadProgress	Download is in progress.
+        // 4	Response	Response is fully received.
+        // 5	User	Custom user event.
+
+        switch (event.type) {
+
+          case HttpEventType.DownloadProgress:
+
+          const status = (event.total) ? Math.round(event.loaded / (event.total || 1) * 100) : 100
+          this.progress.next(status)
+          return status
+
+          case HttpEventType.Response:
+
+            try {
+
+              const fileNamePath = (options?.saveAs) ? options.saveAs : (options.path) ? options.path[options.path.length - 1] : []
+              const fileContentHeader = options.fileContentHeader || 'Content-Disposition'
+              const header_content = event.headers.get(fileContentHeader);
+
+              // checks if header_content is not empty and splits the header_content to get the file name
+              // otherwise, it will use the fileDownload - contains the file name and extension
+              const file = (header_content) ? header_content.split('=')[1].substring(0, header_content.split('=')[1].length) : ''
+
+              const fileName = (file) ? file : fileNamePath
+
+              if (fileName === '') {
+                this.isPending.next(false);
+                throw new Error('Save File: (file name and extension) not found in Headers or Path');
+              }
+
+              this.downloadFile(fileName, event.body)
+              this.isPending.next(false)
+
+              return 100
+
+            } catch (error) {
+              throw new Error('Download failed');
+            }
+
+            default:
+              this.isPending.next(false)
+              return 0
+        }
+
+      }),
+      catchError(err => {
+        return throwError(() => err)
+      })
+    )
+  }
+
+  private handleFinalize(): (source: Observable<any>) => Observable<any> {
+    return finalize(() => this.isPending.next(false));
+  }
+
+  private downloadFile(file:string, fileData: any) {
+
+    const navigatorAny = window.navigator as any
+
+    const extension = file.split('.')[1].toLowerCase()
+
+    var newBlob = new Blob([fileData], { type: this.createFileType(extension) })
+
+    if (navigatorAny.msSaveOrOpenBlob) {
+      navigatorAny.msSaveOrOpenBlob(newBlob, file)
+    } else {
+      const link = document.createElement('a')
+      const url = window.URL.createObjectURL(newBlob)
+      link.href = url
+      link.download = file
+      link.click()
+      window.URL.revokeObjectURL(url)
+    }
+
+  }
+
+  private createFileType(ext: any): string {
+
+    let fileType: string = ""
+
+    if (ext == 'pdf' || ext == 'csv') {
+      fileType = `application/${ext}`
+    }
+    else if (ext == 'jpeg' || ext == 'jpg' || ext == 'png') {
+      fileType = `image/${ext}`
+    }
+    else if (ext == 'txt') {
+      fileType = 'text/plain'
+    }
+
+    else if (ext == 'ppt' || ext == 'pot' || ext == 'pps' || ext == 'ppa') {
+      fileType = 'application/vnd.ms-powerpoint'
+    }
+    else if (ext == 'pptx') {
+      fileType = 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+    }
+    else if (ext == 'doc' || ext == 'dot') {
+      fileType = 'application/msword'
+    }
+    else if (ext == 'docx') {
+      fileType = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+    }
+    else if (ext == 'xls' || ext == 'xlt' || ext == 'xla') {
+      fileType = 'application/vnd.ms-excel'
+    }
+    else if (ext == 'xlsx') {
+      fileType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+    }
+
+    return fileType
+
+  }
+
+  private combineHeaders(headers: any, isStreaming: boolean) {
+
+    return (isStreaming) ?
+    {
+      ...headers,
+      observe: 'events',
+      responseType: 'text',
+      reportProgress: true,
+      Accept: 'text/event-stream'
+    }
+    : headers
+
+  }
+
+}

package/src/lib/services/request-manager-services/rxjs-operators/countdown.ts

@@ -0,0 +1,17 @@
+import { Observable, defer, interval } from 'rxjs';
+import { takeWhile, map, tap } from 'rxjs/operators';
+
+export function countdown(duration: number): Observable<number> {
+
+  return defer(() => {
+
+    const currentCount = { current: duration }
+
+    return interval(1000).pipe(
+      map(() => --currentCount.current),
+      takeWhile(count => count >= 0)
+    )
+
+  })
+
+}

package/src/lib/services/request-manager-services/rxjs-operators/delay-retry.ts

@@ -0,0 +1,16 @@
+import { Observable, timer } from 'rxjs';
+import { retry } from 'rxjs/operators';
+
+const DEFAULT_MAX_RETRIES = 3;
+
+export function delayedRetry<T>(delayMs: number, maxRetry = DEFAULT_MAX_RETRIES) {
+  return (src: Observable<T>) =>
+    src.pipe(
+      retry({
+        count: maxRetry,
+        delay: () => timer(delayMs)
+      })
+    );
+}
+
+

package/src/lib/services/request-manager-services/rxjs-operators/index.ts

@@ -0,0 +1,4 @@
+export * from "./countdown";
+export * from "./delay-retry";
+export * from "./request-polling";
+export * from "./request-streaming";

package/src/lib/services/request-manager-services/rxjs-operators/request-polling.ts

@@ -0,0 +1,35 @@
+import { Observable, interval } from 'rxjs';
+import { mergeMap, startWith, takeUntil, tap } from 'rxjs/operators';
+
+export function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: any) {
+  return (source: Observable<T>): Observable<T> => {
+    return interval(pollInterval * 1000)
+    .pipe(
+      startWith(0),
+      tap(() => {
+        try {
+          if (isPending$ && typeof isPending$.next === 'function') {
+            isPending$.next(true);
+          } else if (isPending$ && typeof isPending$.set === 'function') {
+            isPending$.set(true);
+          }
+        } catch (e) {
+          // no-op if setting fails
+        }
+      }),
+      mergeMap(() => source),
+      tap(() => {
+        try {
+          if (isPending$ && typeof isPending$.next === 'function') {
+            isPending$.next(false);
+          } else if (isPending$ && typeof isPending$.set === 'function') {
+            isPending$.set(false);
+          }
+        } catch (e) {
+          // no-op if setting fails
+        }
+      }),
+      takeUntil(stopCondition$),
+    );
+  };
+}