cat-documents-ng 1.0.4 → 1.0.6

package/src/lib/document/services/document-upload.service.ts

@@ -0,0 +1,209 @@
+import { Injectable, EventEmitter } from '@angular/core';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { DocumentService } from '../state/document.service';
+import { DocumentStore } from '../state/document.store';
+import { MessageService } from 'primeng/api';
+
+/**
+ * Service for handling document uploads.
+ * @class DocumentUploadService
+ * @typedef {DocumentUploadService}
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentUploadService {
+
+  /**
+   * Event emitter for upload completion
+   */
+  uploadCompleted = new EventEmitter<{file: File, response: any}>();
+
+  /**
+   * The file to upload.
+   * @type {*}
+   */
+  uploadedFile: any;
+
+  /**
+   * Represent contextId
+   * @type {string}
+   */
+  contextId: string = SHARED.EMPTY;
+
+  /**
+   * Represent document name
+   * @type {string}
+   */
+  docName: string = SHARED.EMPTY
+
+  /**
+   * Represent document id
+   * @type {string}
+   */
+  docTypeId: string = SHARED.EMPTY
+
+  /**
+   * Creates an instance of DocumentUploadService.
+   * @param {DocumentService} documentService - Service for handling document uploads.
+   * @param {DocumentStore} documentUploadStore - Store for managing uploaded documents.
+   * @param {MessageService} messageService - Service for displaying messages.
+   * @returns {void}
+   */
+  constructor(public documentService: DocumentService, public documentUploadStore: DocumentStore, public messageService: MessageService) { }
+
+  /**
+   * Prepares the files for upload by creating a FormData object.
+   * This method appends each file to the FormData for submission.
+   * @returns {Promise<any>} Promise that resolves when upload completes
+   */
+  handleTemplatedUpload(file: File, contextId: string): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let formsData = this.handleCreateFormData(file, contextId)
+      if (!formsData) {
+        const error = new Error('Failed to create form data');
+        this.messageService.add({severity: SHARED.SEVERITY,summary: SHARED.UPLOAD_ERROR_SUMMERY,detail: SHARED.UPLOAD_ERROR_DETAILS});
+        reject(error);
+        return;
+      }
+      this.documentService.create(formsData)
+        .subscribe({
+          /**
+           * Handles the successful upload event.
+           * Updates the list of uploaded files and emits the file ID.
+           * @returns {void}
+           */
+          next: (event) => {
+            this.documentUploadStore.setUploadedDocumentFiles(event)
+            this.documentUploadStore.setMessage([{severity: SHARED.SUCCESS_SEVERITY,detail : SHARED.UPLOAD_SUCCESS}]);
+            this.uploadCompleted.emit({file: file, response: event});
+            resolve(event);
+          },
+          /**
+           * Handles the error event during file upload.
+           * Updates the progress of the file to indicate failure.
+           * @param {any} error - The error object returned by the upload service.
+           */
+          error: (error) => {
+            this.messageService.add({severity: SHARED.SEVERITY,summary: SHARED.UPLOAD_SUMMERY,detail: error?.message});
+            reject(error);
+          },
+        });
+    });
+  }
+
+  /**
+   * Uploads multiple files sequentially using promises
+   * @param files - Array of files to upload
+   * @param contextId - The context ID for upload
+   * @returns {Promise<any[]>} Promise that resolves with all upload responses
+   */
+  async uploadFilesSequentially(files: File[], contextId: string): Promise<any[]> {
+    const results: any[] = [];
+    
+    for (const file of files) {
+      try {
+        const result = await this.handleTemplatedUpload(file, contextId);
+        results.push(result);
+      } catch (error) {
+        console.error(`Failed to upload file ${file.name}:`, error);
+        results.push({ error: true, fileName: file.name, errorMessage: error });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Alternative method to upload files sequentially with progress tracking
+   * @param files - Array of files to upload
+   * @param contextId - The context ID for upload
+   * @param onProgress - Optional callback for progress updates
+   * @returns {Promise<any[]>} Promise that resolves with all upload responses
+   */
+  async uploadFilesSequentiallyWithProgress(
+    files: File[], 
+    contextId: string, 
+    onProgress?: (currentFile: File, currentIndex: number, totalFiles: number) => void
+  ): Promise<any[]> {
+    const results: any[] = [];
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (onProgress) {
+        onProgress(file, i, files.length);
+      }
+      
+      try {
+        const result = await this.handleTemplatedUpload(file, contextId);
+        results.push(result);
+      } catch (error) {
+        console.error(`Failed to upload file ${file.name}:`, error);
+        results.push({ error: true, fileName: file.name, errorMessage: error });
+      }
+    }
+    
+    return results;
+  }
+
+  /**
+   * Get the file and contextId
+   * @param file - The file to upload.
+   * @param contextId - The contextId to upload.
+   */
+  getUploadFileData(file: File, contextId: string) {
+    if (file && contextId) {
+      this.uploadedFile = file;
+      this.contextId = contextId;
+    }
+  }
+
+  /**
+   * Get the document name and document type id
+   * @param documentName - The document name to upload.
+   * @param documentTypeId - The document type id to upload.
+   */
+  getDocumentNameAndType(documentTypeId: string) {
+    if (documentTypeId && documentTypeId !== SHARED.EMPTY) {
+      this.docTypeId = documentTypeId
+    }
+  }
+
+  /**
+   * Handle the creation of formdata.
+   * @returns {*} - The formdata object.
+   */
+  handleCreateFormData(uploadedFile?: File, contextId?: string) {
+   
+    if (uploadedFile) {
+      let formData = new FormData();
+      formData.append(SHARED.FILE, uploadedFile, uploadedFile.name);
+      formData.append(SHARED.CONTEXT_ID, this.contextId || contextId || SHARED.EMPTY)
+      return formData;
+    }else{
+      return null;
+    }
+    
+  }
+
+  /**
+   * Generic method to sort any list of objects by a specified property.
+   * Supports fallback properties if the primary property is undefined.
+   * @param list - Array of objects to sort
+   * @param primaryProperty - Primary property to sort by
+   * @param fallbackProperty - Optional fallback property if primary is undefined
+   * @returns Sorted array
+   */
+  sortListByProperty<T>(list: T[], primaryProperty: keyof T, fallbackProperty?: keyof T): T[] {
+    return list.sort((a, b) => {
+      const valueA = a[primaryProperty] || (fallbackProperty ? a[fallbackProperty] : SHARED.EMPTY);
+      const valueB = b[primaryProperty] || (fallbackProperty ? b[fallbackProperty] : SHARED.EMPTY);
+      
+      if (typeof valueA === 'string' && typeof valueB === 'string') {
+        return valueA.localeCompare(valueB);
+      }
+      if (valueA < valueB) return -1;
+      if (valueA > valueB) return 1;
+      return 0;
+    });
+  }
+}

package/src/lib/document/services/document-viewer.service.ts

@@ -0,0 +1,279 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DocumentHttpService } from './document-http.service';
+import { DocumentHelperService } from './document.service';
+import { DocumentListItem } from '../models/document-list-response.model';
+import { DocumentHistorySection } from '../models/document-history.model';
+import { DocumentAction } from './document-actions.service';
+import { DocumentAlertList, SHARED, SUPPORTED_IMAGE_TYPES } from '../../../Shared/constant/SHARED';
+import { MessageService } from 'primeng/api';
+import { DocumentStore } from '../state/document.store';
+import { DocumentQuery } from '../state/document.query';
+
+export interface DocumentViewerState {
+  selectedDocument?: DocumentListItem;
+  documentHistory: DocumentHistorySection[];
+  showDocumentHistory: boolean;
+  isActionLoading: boolean;
+  documentStatus: 'pending' | 'accepted' | 'rejected';
+  documentIsUploaded: boolean;
+  alertData: any;
+  deleteError: any;
+  deleteSuccess: boolean;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentViewerService {
+  constructor(
+    private documentHttpService: DocumentHttpService,
+    private documentService: DocumentHelperService,
+    private messageService: MessageService,
+    private documentStore: DocumentStore,
+    private documentQuery: DocumentQuery
+  ) {}
+
+  /**
+   * Gets the current document viewer state as an observable
+   */
+  get state$(): Observable<DocumentViewerState> {
+    return this.documentQuery.selectDocumentViewerState();
+  }
+
+  /**
+   * Gets the current document viewer state synchronously
+   */
+  getCurrentState(): DocumentViewerState {
+    return this.documentQuery.getDocumentViewerState();
+  }
+
+  /**
+   * Updates the selected document and recalculates all computed properties
+   * @param document The selected document
+   */
+  updateSelectedDocument(document: DocumentListItem, skipLoadDocumentHistory: boolean = false): void {
+    this.documentService.set(document);
+    const alertData = this.getAlertData(document);
+    const documentStatus = this.calculateDocumentStatus(document);
+    const documentIsUploaded = this.calculateIsDocumentUploaded(document);
+
+    this.documentStore.updateDocumentViewerState(
+      document,
+      undefined, 
+      undefined,
+      undefined,
+      documentStatus,
+      documentIsUploaded,
+      alertData
+    );
+
+    if( !skipLoadDocumentHistory && document?._id ) this.loadDocumentHistory(document._id);
+  }
+
+  /**
+   * Loads document history data
+   * @param documentId The document ID
+   */
+  loadDocumentHistory(documentId: string): void {
+    if (documentId) {
+      this.documentHttpService.getDocumentHistory(documentId)
+        .subscribe({
+          next: (history) => {
+            this.documentStore.updateDocumentViewerState(
+              undefined,
+              history,
+              true
+            );
+          },
+          error: (error) => {
+            this.documentStore.updateDocumentViewerState(
+              undefined,
+              undefined,
+              false
+            );
+          }
+        });
+    }
+  }
+
+  /**
+   * Determines if the given content type is an image
+   * @param contentType The MIME type of the content
+   * @returns True if the content type is an image
+   */
+  isImage(contentType?: string): boolean {
+    return contentType ? SUPPORTED_IMAGE_TYPES.includes(contentType) : false;
+  }
+
+  /**
+   * Handles document actions and updates status
+   * @param action The action performed
+   * @param contextId The context ID for API calls
+   */
+  handleDocumentAction(action: DocumentAction, contextId?: string): void {
+    const currentState = this.documentQuery.getDocumentViewerState();
+    if (!currentState.selectedDocument?._id) {
+      console.error('No document ID available');
+      return;
+    }
+
+    switch (action.type) {
+      case SHARED.ACCEPT_ACTION:
+        this.updateDocumentStatus(SHARED.STATUS_APPROVED, action.note || SHARED.DOCUMENT_ACCEPTED_MESSAGE, contextId);
+        break;
+      case SHARED.REJECT_ACTION:
+        this.updateDocumentStatus(SHARED.STATUS_REJECTED, action.note || SHARED.DOCUMENT_REJECTED_MESSAGE, contextId);
+        break;
+      case SHARED.DELETE_ACTION:
+        this.deleteDocument(currentState.selectedDocument._id, contextId);
+        // Don't emit success event here - it will be emitted only on successful delete
+        break;
+    }
+  }
+
+  /**
+   * Updates the document status via API call and refreshes all related data
+   * @param status The new status (Approved, Rejected)
+   * @param description The status update description
+   * @param contextId The context ID for API calls
+   */
+  private updateDocumentStatus(status: string, description: string, contextId?: string): void {
+    const currentState = this.documentQuery.getDocumentViewerState();
+    if (!currentState.selectedDocument?._id) {
+      console.error('No document ID available');
+      return;
+    }
+
+    this.documentStore.setIsActionLoading(true);
+
+    this.documentHttpService.updateDocumentStatus(
+      currentState.selectedDocument._id,
+      status,
+      description
+    ).subscribe({
+      next: (response) => {
+        if (currentState.selectedDocument && response.status) {
+          const normalizedStatus = response.normalizedStatus || response.status.toLowerCase();
+          const updatedDocument = {
+            ...currentState.selectedDocument,
+            status: normalizedStatus
+          };
+          
+          this.updateSelectedDocument(updatedDocument);
+        }
+        this.refreshAllData(contextId);
+      },
+      error: (error) => {
+        console.error('Error updating document status:', error);
+      },
+      complete: () => {
+        this.documentStore.setIsActionLoading(false);
+      }
+    });
+  }
+
+  /**
+   * Deletes a document without immediate refresh - refresh will happen when viewer is closed
+   * @param documentId The ID of the document to delete
+   * @param contextId The context ID for API calls
+   */
+  private deleteDocument(documentId: string, contextId?: string): void {
+    if (!contextId) {
+      console.error('No context ID available for delete operation');
+      return;
+    }
+
+    this.documentStore.setIsActionLoading(true);
+
+    this.documentHttpService.deleteDocument(documentId, contextId).subscribe({
+      next: (res:any) => {
+        if(res){
+          // this.documentService.refreshAllDataWithCurrentFilters(contextId);
+          this.documentStore.setDeleteSuccess(true);
+          this.documentStore.clearDocumentViewerState();
+        }
+      },
+      error: (error) => {
+        this.documentStore.setIsActionLoading(false);
+        this.documentStore.setDeleteError(error.message);
+      }
+    });
+  }
+
+  /**
+   * Refreshes all related data after document status update
+   * @param contextId The context ID for API calls
+   */
+  private refreshAllData(contextId?: string): void {
+    if (!contextId) {
+      console.error('No context ID available for data refresh');
+      return;
+    }
+
+    const currentState = this.documentQuery.getDocumentViewerState();
+    if (currentState.selectedDocument?._id) {
+      this.loadDocumentHistory(currentState.selectedDocument._id);
+    }
+
+    // Use the same refresh method as other components for consistency
+    this.documentService.refreshAllDataWithCurrentFilters(contextId);
+  }
+
+  /**
+   * Gets alert data for the document
+   * @param document The document
+   * @returns Alert data
+   */
+  private getAlertData(document: DocumentListItem): any {
+    return DocumentAlertList.find((res: any) => res.status === document?.status);
+  }
+
+  /**
+   * Calculates the current status of the document for the actions component
+   * @param document The document
+   * @returns The current document status
+   */
+  private calculateDocumentStatus(document: DocumentListItem): 'pending' | 'accepted' | 'rejected' {
+    if (!document) return SHARED.STATUS_PENDING as 'pending';
+    
+    // First check statusId from API response if available
+    if (document.statusId) {
+      switch (document.statusId.toLowerCase()) {
+        case SHARED.STATUS_APPROVED.toLowerCase():
+          return SHARED.STATUS_ACCEPTED as 'accepted';
+        case SHARED.STATUS_REJECTED.toLowerCase():
+          return SHARED.STATUS_REJECTED_LOWERCASE as 'rejected';
+        case SHARED.STATUS_PENDING:
+          return SHARED.STATUS_PENDING as 'pending';
+      }
+    }
+    
+    // Fall back to status field mapping
+    switch (document.status?.toLowerCase()) {
+      case SHARED.STATUS_APPROVED.toLowerCase():
+      case SHARED.STATUS_ACCEPTED:
+        return SHARED.STATUS_ACCEPTED as 'accepted';
+      case SHARED.STATUS_REJECTED.toLowerCase():
+      case SHARED.STATUS_DECLINED:
+        return SHARED.STATUS_REJECTED_LOWERCASE as 'rejected';
+      default:
+        return SHARED.STATUS_PENDING as 'pending';
+    }
+  }
+
+  /**
+   * Calculates if the document is uploaded and ready for actions
+   * @param document The document
+   * @returns True if document is uploaded
+   */
+  private calculateIsDocumentUploaded(document: DocumentListItem): boolean {
+    if (!document) return false;
+    
+    // Check if document has a URL and is not in a pending state
+    const isPending = document.statusId?.toLowerCase() === SHARED.STATUS_PENDING || 
+                     document.status?.toLowerCase() === SHARED.STATUS_PENDING;
+    
+    return !!(document.documentUrl && !isPending);
+  }
+} 

package/src/lib/document/services/document-zoom.service.spec.ts

@@ -0,0 +1,56 @@
+import { TestBed } from '@angular/core/testing';
+import { DocumentZoomService } from './document-zoom.service';
+
+describe('DocumentZoomService', () => {
+  let service: DocumentZoomService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DocumentZoomService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should start with default zoom level', () => {
+    expect(service.currentZoom).toBe(100);
+  });
+
+  it('should zoom in correctly', () => {
+    service.zoomIn();
+    expect(service.currentZoom).toBe(125);
+  });
+
+  it('should zoom out correctly', () => {
+    service.zoomOut();
+    expect(service.currentZoom).toBe(75);
+  });
+
+  it('should respect max zoom limit', () => {
+    service.setZoom(400);
+    service.zoomIn();
+    expect(service.currentZoom).toBe(400);
+  });
+
+  it('should respect min zoom limit', () => {
+    service.setZoom(25);
+    service.zoomOut();
+    expect(service.currentZoom).toBe(25);
+  });
+
+  it('should reset zoom to default', () => {
+    service.setZoom(200);
+    service.resetZoom();
+    expect(service.currentZoom).toBe(100);
+  });
+
+  it('should emit zoom changes', (done) => {
+    service.zoomLevel$.subscribe(zoom => {
+      expect(zoom).toBe(150);
+      done();
+    });
+    
+    service.setZoom(150);
+  });
+});

package/src/lib/document/services/document-zoom.service.ts

@@ -0,0 +1,164 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+
+export interface ZoomConfig {
+  defaultZoom: number;
+  zoomStep: number;
+  minZoom: number;
+  maxZoom: number;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentZoomService {
+  private readonly DEFAULT_CONFIG: ZoomConfig = {
+    defaultZoom: 100,
+    zoomStep: 25,
+    minZoom: 25,
+    maxZoom: 400
+  };
+
+  private zoomLevelSubject = new BehaviorSubject<number>(this.DEFAULT_CONFIG.defaultZoom);
+  private config: ZoomConfig = { ...this.DEFAULT_CONFIG };
+
+  /**
+   * Gets the current zoom level as an observable
+   */
+  get zoomLevel$(): Observable<number> {
+    return this.zoomLevelSubject.asObservable();
+  }
+
+  /**
+   * Gets the current zoom level value
+   */
+  get currentZoom(): number {
+    return this.zoomLevelSubject.value;
+  }
+
+  /**
+   * Gets the current zoom configuration
+   */
+  get zoomConfig(): ZoomConfig {
+    return { ...this.config };
+  }
+
+  /**
+   * Sets custom zoom configuration
+   */
+  setZoomConfig(config: Partial<ZoomConfig>): void {
+    this.config = { ...this.DEFAULT_CONFIG, ...config };
+    this.setZoom(this.config.defaultZoom);
+  }
+
+  /**
+   * Zooms in by the configured step
+   */
+  zoomIn(): void {
+    const newZoom = Math.min(
+      this.currentZoom + this.config.zoomStep,
+      this.config.maxZoom
+    );
+    this.setZoom(newZoom);
+  }
+
+  /**
+   * Zooms out by the configured step
+   */
+  zoomOut(): void {
+    const newZoom = Math.max(
+      this.currentZoom - this.config.zoomStep,
+      this.config.minZoom
+    );
+    this.setZoom(newZoom);
+  }
+
+  /**
+   * Sets zoom to a specific level
+   */
+  setZoom(zoom: number): void {
+    const clampedZoom = Math.max(
+      this.config.minZoom,
+      Math.min(zoom, this.config.maxZoom)
+    );
+    this.zoomLevelSubject.next(clampedZoom);
+  }
+
+  /**
+   * Resets zoom to default level
+   */
+  resetZoom(): void {
+    this.setZoom(this.config.defaultZoom);
+  }
+
+  /**
+   * Handles mouse wheel zoom
+   */
+  handleWheelZoom(event: WheelEvent, zoomFactor: number = 0.1): void {
+    event.preventDefault();
+    // Only use deltaY for zoom (vertical wheel movement)
+    const delta = event.deltaY > 0 ? -1 : 1;
+    const zoomStep = this.config.zoomStep * zoomFactor;
+    const newZoom = this.currentZoom + (delta * zoomStep);
+    this.setZoom(newZoom);
+  }
+
+  /**
+   * Applies zoom transform to an iframe element
+   * @param iframe - The iframe element to apply zoom to
+   * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+   */
+  applyIframeZoom(iframe: HTMLIFrameElement, zoomLevel?: number): void {
+    const zoom = zoomLevel ?? this.currentZoom;
+    const zoomScale = zoom / 100;
+
+    if (zoom === 100) {
+      iframe.style.transform = 'none';
+      iframe.style.width = '100%';
+      iframe.style.height = '100%';
+    } else {
+      iframe.style.transform = `scale(${zoomScale})`;
+      iframe.style.transformOrigin = 'top left';
+      iframe.style.width = `${100 / zoomScale}%`;
+      iframe.style.height = `${100 / zoomScale}%`;
+    }
+  }
+
+  /**
+   * Applies zoom transform to multiple iframe elements
+   * @param iframes - Array of iframe elements to apply zoom to
+   * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+   */
+  applyIframeZoomToMultiple(iframes: HTMLIFrameElement[], zoomLevel?: number): void {
+    iframes.forEach(iframe => this.applyIframeZoom(iframe, zoomLevel));
+  }
+
+  /**
+   * Applies zoom transform to iframes within a container element
+   * @param container - The container element to search for iframes
+   * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+   */
+  applyIframeZoomToContainer(container: HTMLElement, zoomLevel?: number): void {
+    const iframes = container.querySelectorAll('iframe') as NodeListOf<HTMLIFrameElement>;
+    this.applyIframeZoomToMultiple(Array.from(iframes), zoomLevel);
+  }
+
+  /**
+   * Applies zoom transform to iframes within multiple container elements
+   * @param containers - Array of container elements to search for iframes
+   * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+   */
+  applyIframeZoomToContainers(containers: HTMLElement[], zoomLevel?: number): void {
+    containers.forEach(container => this.applyIframeZoomToContainer(container, zoomLevel));
+  }
+
+  /**
+   * Applies zoom transform to iframes by CSS selector
+   * @param selector - CSS selector to find iframe containers
+   * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+   */
+  applyIframeZoomBySelector(selector: string, zoomLevel?: number): void {
+    const containers = document.querySelectorAll(selector) as NodeListOf<HTMLElement>;
+    this.applyIframeZoomToContainers(Array.from(containers), zoomLevel);
+  }
+}