http-request-manager 18.15.33 → 18.15.34

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

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

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

@@ -0,0 +1,372 @@
+import { HttpClient, HttpEvent, HttpEventType, HttpHeaderResponse } from '@angular/common/http';
+import { Injectable, inject, signal, computed } from '@angular/core';
+import { Observable, throwError } from 'rxjs';
+import { catchError, 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 { WebsocketService } from '../ws-manager-service';
+import { InvalidFileInfoModel, UploadValidationErrorModel } from '../../models';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RequestSignalsService extends WebsocketService {
+
+  private http = inject(HttpClient);
+  private pathQueryService = inject(PathQueryService);
+  private headersService = inject(HeadersService);
+
+  isPending = signal(false);
+  progress = signal(0);
+
+  isIdle = computed(() => !this.isPending());
+
+  // 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.set(true);
+
+    return (options.stream)
+      ? this.http.get<any>(urlPath, {
+          ...headers,
+          observe: 'events',
+          responseType: 'text',
+          reportProgress: true
+        }).pipe(
+          requestStreaming(StreamConfigModel.adapt({ streamType: options.streamType || StreamType.AI_STREAMING })),
+          this.requestStreamingOperator(options),
+          this.handleFinalize()
+        )
+      : this.http.get<T>(urlPath, headers).pipe(
+          this.request(options),
+          this.handleFinalize()
+        );
+  }
+
+  // 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.set(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.AI_STREAMING })),
+          this.requestStreamingOperator(options),
+          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 (!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 requestStreamingOperator<T>(options: ApiRequest): (source: Observable<StreamOutputModel<T>>) => Observable<T[]> {
+    return (source$: Observable<StreamOutputModel<T>>): Observable<T[]> => {
+      return source$.pipe(
+        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.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);
+        })
+      );
+  }
+
+  uploadFileRequest(options: ApiRequest): Observable<any> {
+    this.isPending.set(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.set(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.set(true);
+
+        switch (event.type) {
+          case HttpEventType.UploadProgress:
+            const status = event.total ? Math.round(event.loaded / (event.total || 1) * 100) : 0;
+            this.progress.set(status);
+            return null;
+
+          case HttpEventType.Response:
+            this.isPending.set(false);
+            this.progress.set(0);
+            return event.body;
+
+          default:
+            return null;
+        }
+      }),
+      filter((body: any) => body !== null),
+      catchError(err => {
+        this.isPending.set(false);
+        this.progress.set(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, index) => {
+      formData.append(`${fieldName}[${index}]`, file);
+    });
+    return formData;
+  }
+
+  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;
+  }
+}