http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,435 @@
+import { HttpClient, HttpEvent, HttpEventType, HttpHeaderResponse } from '@angular/common/http';
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject, Observable, throwError } from 'rxjs';
+import { catchError, delay, filter, 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 } from './rxjs-operators/request-streaming';
+import { StreamConfigModel } from '../request-manager-state-service/models/stream-config.model';
+import { StreamOutputModel } from '../request-manager-state-service/models/stream-output.model';
+import { StreamProgressModel } from '../request-manager-state-service/models/stream-progress.model';
+import { WebsocketService } from '../ws-manager-service';
+import { InvalidFileInfoModel, UploadValidationErrorModel } from '../../models';
+
+
+@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()
+
+  streamProgress = new BehaviorSubject<StreamProgressModel>(StreamProgressModel.adapt({
+    received: 0,
+    total: undefined,
+    percent: 0,
+    stage: 'connecting'
+  }))
+  streamProgress$ = this.streamProgress.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(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.NDJSON, totalHeader: 'X-Total-Count' })),
+            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[]>;
+  createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+  createRecordRequest<T>(options: ApiRequest & { stream: true }, data: any): Observable<T[]>;
+  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(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.NDJSON, totalHeader: 'X-Total-Count' })),
+            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<StreamOutputModel<T>>) => Observable<T[]> {
+    return (source$: Observable<StreamOutputModel<T>>): Observable<T[]> => {
+      return source$.pipe(
+        tap(output => {
+          // Update progress from stream output
+          this.progress.next(output.progress.received);
+          this.streamProgress.next(output.progress);
+        }),
+        map(output => {
+          const data = output.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)
+      })
+    )
+  }
+
+  uploadFileRequest(options: ApiRequest): Observable<any> {
+    this.isPending.next(true);
+
+    const files = options.uploadFiles ? (Array.isArray(options.uploadFiles) ? options.uploadFiles : [options.uploadFiles]) : [];
+    const validation = this.validateUploadFiles(files, options);
+
+    if (validation.validFiles.length === 0) {
+      this.isPending.next(false);
+      return throwError(() => new UploadValidationErrorModel(
+        validation.invalidFiles,
+        0,
+        files.length
+      ));
+    }
+
+    const fieldName = options.uploadFieldName || (files.length === 1 ? 'file' : 'files');
+    const formData = this.buildFormData(validation.validFiles, fieldName);
+    const urlPath = this.buildUrlPath(options);
+    const method = options.uploadHttpMethod || 'POST';
+
+    return this.http.request(method, urlPath, {
+      body: formData,
+      observe: 'events',
+      reportProgress: true
+    }).pipe(
+      map((event: HttpEvent<any>) => {
+        this.isPending.next(true);
+
+        switch (event.type) {
+          case HttpEventType.UploadProgress:
+            const status = event.total ? Math.round(event.loaded / (event.total || 1) * 100) : 0;
+            this.progress.next(status);
+            return null;
+
+          case HttpEventType.Response:
+            this.isPending.next(false);
+            this.progress.next(0);
+            return event.body;
+
+          default:
+            return null;
+        }
+      }),
+      filter((body: any) => body !== null),
+      catchError(err => {
+        this.isPending.next(false);
+        this.progress.next(0);
+        return throwError(() => err);
+      })
+    );
+  }
+
+  private validateUploadFiles(files: File[], options: ApiRequest): { validFiles: File[]; invalidFiles: InvalidFileInfoModel[] } {
+    const validFiles: File[] = [];
+    const invalidFiles: InvalidFileInfoModel[] = [];
+    let totalSize = 0;
+
+    for (const file of files) {
+      const errors: string[] = [];
+
+      if (options.allowedTypes && options.allowedTypes.length > 0) {
+        const isAllowed = options.allowedTypes.some(type => {
+          if (type.endsWith('/*')) {
+            return file.type.startsWith(type.replace('/*', '/'));
+          }
+          return file.type === type;
+        });
+        if (!isAllowed) {
+          errors.push('type not allowed');
+        }
+      }
+
+      const maxFileSize = options.maxFileSize !== undefined ? options.maxFileSize : Infinity;
+      if (file.size > maxFileSize) {
+        errors.push('exceeds maxFileSize');
+      }
+
+      if (errors.length > 0) {
+        invalidFiles.push(new InvalidFileInfoModel(file.name, file.size, file.type, errors));
+      } else {
+        validFiles.push(file);
+        totalSize += file.size;
+      }
+    }
+
+    const maxTotalSize = options.maxTotalSize !== undefined ? options.maxTotalSize : Infinity;
+    if (totalSize > maxTotalSize) {
+      return {
+        validFiles: [],
+        invalidFiles: [
+          new InvalidFileInfoModel(
+            'total',
+            totalSize,
+            '',
+            ['exceeds maxTotalSize']
+          )
+        ]
+      };
+    }
+
+    return { validFiles, invalidFiles };
+  }
+
+  private buildFormData(files: File[], fieldName: string): FormData {
+    const formData = new FormData();
+    files.forEach((file) => {
+      formData.append(fieldName, file);
+    });
+    return formData;
+  }
+
+  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$),
+    );
+  };
+}