http-request-manager 15.0.19 → 15.0.26

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

@@ -0,0 +1,274 @@
+import { Inject, inject, Injectable, Injector, Optional } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { BehaviorSubject, Observable, Subject, throwError } from 'rxjs';
+import { tap, map, finalize, catchError } 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 { ToastColors, ToastDisplay, ToastMessageDisplayService } from 'toast-message-display';
+
+import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
+import { ConfigOptions } from '../../models';
+import { ObjectMergerService } from '../utils/object-merger.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class HTTPManagerService<T> extends RequestService {
+
+  toastMessage = inject(ToastMessageDisplayService)
+  ng_injector = inject(Injector)
+  objectMergerService = inject(ObjectMergerService)
+
+  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();
+
+  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {
+    super()
+    this.config = (configOptions) ? ApiRequest.adapt(configOptions.httpRequestOptions) : this.config
+  }
+
+  // REQUESTS
+
+  getRequest<T>(options?: ApiRequest, params?: any[]) {
+
+    this.isPending.next(true);
+    this.data.next(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.next(data))
+    ).pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+          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)))
+      .pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+          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)))
+      .pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+            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)))
+      .pipe(
+        finalize(() => this.isPending.next(false)),
+        catchError((err) => {
+          if(updatedOptions.displayError) this.handleErrorWithSnackBar(err)
+          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);
+      })
+    )
+
+  }
+
+  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(
+      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);
+      }),
+      (options?.retry && options.retry.times > 0)
+        ? delayedRetry((options.retry.delay || 3) * 1000, (options.retry.times || 0) - 1)
+        : (source: Observable<T>) => source
+    );
+  }
+
+  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) {
+
+    const displayError = ToastDisplay.adapt({
+            message: error.message || `${error.status} - ${error.statusText}`,
+            action: 'OK',
+            color: ToastColors.ERROR,
+            icon: 'error',
+            duration: 5 * 1000, //5 seconds
+          })
+
+    this.toastMessage.toastMessage(displayError)
+
+  }
+
+  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
+
+  }
+}

package/{lib/services/request-manager-services/index.d.ts → src/lib/services/request-manager-services/index.ts}

@@ -1,3 +1,5 @@
 export * from "./http-manager.service";
+// export * from './request.service';
+
 export * from "../../models/index";
 export * from "./rxjs-operators/index";

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

@@ -0,0 +1,261 @@
+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 } 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 RequestService {
+
+  private http = inject(HttpClient)
+
+  private pathQueryService = inject(PathQueryService)
+  private headersService = inject(HeadersService)
+
+  isPending = new BehaviorSubject<boolean>(false)
+  isPending$ = this.isPending.asObservable().pipe(delay(1))
+
+  progress = new BehaviorSubject<number>(0)
+  progress$ = this.progress.asObservable()
+
+  getRecordRequest<T>(options: ApiRequest): Observable<T> {
+
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildCombinedHeaders(options);
+
+    this.isPending.next(true);
+
+    return (options.stream)
+        ? this.http.get<any>(urlPath, headers).pipe(
+            requestStreaming(),
+            this.handleFinalize()
+        )
+        : this.http.get<T>(urlPath, headers).pipe(
+            this.request(options),
+        )
+  }
+
+  createRecordRequest<T>(options: ApiRequest, data: any): Observable<T> {
+
+    const urlPath = this.buildUrlPath(options);
+    const headers = this.buildCombinedHeaders(options);
+
+    this.isPending.next(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),
+        )
+  }
+
+  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 (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.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 header_content = event.headers.get('Content-Disposition') || '';
+              // 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 = (fileNamePath !== '') ? fileNamePath : file
+
+              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/request-polling.ts

@@ -0,0 +1,21 @@
+import { BehaviorSubject, Observable, interval } from 'rxjs';
+import { mergeMap, startWith, takeUntil, tap } from 'rxjs/operators';
+
+/**
+ * @param pollInterval
+ * @param stopCondition$
+ * @param isPending$
+ */
+
+export function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: BehaviorSubject<boolean>) {
+  return (source: Observable<T>): Observable<T> => {
+    return interval(pollInterval * 1000)
+    .pipe(
+      startWith(0), 
+      tap(() => isPending$.next(true)),
+      mergeMap(() => source),
+      tap(() => isPending$.next(false)),
+      takeUntil(stopCondition$),
+    );
+  };
+}

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

@@ -0,0 +1,32 @@
+import { OperatorFunction } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { HttpEventType } from '@angular/common/http';
+
+export function requestStreaming(): OperatorFunction<any, any> {
+
+  return input$ => input$.pipe(
+    filter((event: any) =>
+      event.type === HttpEventType.DownloadProgress || event.type === HttpEventType.Response
+    ),
+
+    map((event: any) => {
+
+      if (event.type === HttpEventType.DownloadProgress) {
+        return event.partialText || ''
+      } else if (event.type === HttpEventType.Response) {
+        return event.body
+      }
+
+    }),
+
+    map((data: any) => {
+      if (typeof data === 'string') {
+        const matches = data.match(/{[^}]+}/g) || []
+        return (matches.length > 0) ? matches.map(match => JSON.parse(match)) : data
+      }
+      return data
+    })
+  )
+
+}
+