cat-documents-ng 1.0.4 → 1.0.6

package/src/lib/document/services/document-history-style.service.ts

@@ -0,0 +1,138 @@
+import { Injectable } from '@angular/core';
+import { DOCUMENT_HISTORY } from '../constant/DOCUMENT_HISTORY';
+import { SHARED } from '../../../Shared/constant/SHARED';
+
+/**
+ * Service for handling document history styling logic
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentHistoryStyleService {
+
+  constructor() {}
+
+  /**
+   * Get the appropriate icon class based on the action label
+   */
+  getActionIcon(label: string): string {
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return DOCUMENT_HISTORY.ICONS.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return DOCUMENT_HISTORY.ICONS.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return DOCUMENT_HISTORY.ICONS.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+        return DOCUMENT_HISTORY.ICONS.DOCUMENT_REQUESTED;
+      default:
+        return DOCUMENT_HISTORY.ICONS.DOCUMENT_REQUESTED;
+    }
+  }
+
+  /**
+   * Get the appropriate color class based on the action label
+   */
+  getActionColor(label: string): string {
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return DOCUMENT_HISTORY.TEXT_COLORS.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return DOCUMENT_HISTORY.TEXT_COLORS.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return DOCUMENT_HISTORY.TEXT_COLORS.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+        return DOCUMENT_HISTORY.TEXT_COLORS.DOCUMENT_REQUESTED;
+      default:
+        return DOCUMENT_HISTORY.TEXT_COLORS.DOCUMENT_REQUESTED;
+    }
+  }
+
+  /**
+   * Get the appropriate background color class based on the action label
+   */
+  getActionBgColor(label: string): string {
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return DOCUMENT_HISTORY.BG_COLORS.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return DOCUMENT_HISTORY.BG_COLORS.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return DOCUMENT_HISTORY.BG_COLORS.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+        return DOCUMENT_HISTORY.BG_COLORS.DOCUMENT_REQUESTED;
+      default:
+        return DOCUMENT_HISTORY.BG_COLORS.DOCUMENT_REQUESTED;
+    }
+  }
+
+  /**
+   * Get the appropriate border color class based on the action label
+   */
+  getActionBorderColor(label: string): string {
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return DOCUMENT_HISTORY.BORDER_COLORS.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return DOCUMENT_HISTORY.BORDER_COLORS.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return DOCUMENT_HISTORY.BORDER_COLORS.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+        return DOCUMENT_HISTORY.BORDER_COLORS.DOCUMENT_REQUESTED;
+      default:
+        return DOCUMENT_HISTORY.BORDER_COLORS.DOCUMENT_REQUESTED;
+    }
+  }
+
+  /**
+   * Get the appropriate icon background color class based on the action label
+   */
+  getActionIconBgColor(label: string): string {
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return DOCUMENT_HISTORY.ICON_BG_COLORS.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return DOCUMENT_HISTORY.ICON_BG_COLORS.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return DOCUMENT_HISTORY.ICON_BG_COLORS.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+        return DOCUMENT_HISTORY.ICON_BG_COLORS.DOCUMENT_REQUESTED;
+      default:
+        return DOCUMENT_HISTORY.ICON_BG_COLORS.DOCUMENT_REQUESTED;
+    }
+  }
+
+    /**
+   * Check if a section has valid content to display
+   */
+  checkValidContent(section: any): boolean {
+    return section.list && section.list.length > 0 && 
+           section.list.some((item:any) => 
+             item.label || 
+             item.requestDescription || 
+             item.documentUrl || 
+             item.userName
+           );
+  }
+
+  getAccordionClass(section: any): string {
+    if (!section.list || section.list.length === 0) {
+      return SHARED.DOCUMENT_REQUESTED;
+    }
+
+    const firstItem = section.list[0];
+    const label = firstItem.label;
+
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return SHARED.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return SHARED.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return SHARED.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+      default:
+        return SHARED.DOCUMENT_REQUESTED;
+    }
+  }
+} 

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

@@ -0,0 +1,129 @@
+import { Injectable } from '@angular/core';
+import { DocumentHistoryItem, DocumentHistorySection } from '../models/document-history.model';
+import { DocumentHistoryStyleService } from './document-history-style.service';
+import { DOCUMENT_HISTORY } from '../constant/DOCUMENT_HISTORY';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { ERRORS } from '../../../Shared/constant/ERROR';
+import { HttpClient } from '@angular/common/http';
+
+// Extended interface for processed items with computed properties
+interface ProcessedDocumentHistoryItem extends DocumentHistoryItem {
+  actionIcon: string;
+  actionColor: string;
+  actionBgColor: string;
+  actionBorderColor: string;
+  actionIconBgColor: string;
+}
+
+interface ProcessedDocumentHistorySection extends DocumentHistorySection {
+  list: ProcessedDocumentHistoryItem[];
+  accordionClass?: string;
+  hasValidContent?: boolean;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentHistoryService {
+
+  constructor(private documentHistoryStyleService: DocumentHistoryStyleService, private http : HttpClient) {}
+
+  /**
+   * Get the CSS class for accordion styling based on the section's label
+   */
+  private getAccordionClass(section: ProcessedDocumentHistorySection): string {
+    if (!section.list || section.list.length === 0) {
+      return SHARED.DOCUMENT_REQUESTED; // Default class
+    }
+
+    const firstItem = section.list[0];
+    const label = firstItem.label;
+
+    switch (label) {
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_UPLOADED:
+        return SHARED.DOCUMENT_UPLOADED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REJECTED:
+        return SHARED.DOCUMENT_REJECTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_ACCEPTED:
+        return SHARED.DOCUMENT_ACCEPTED;
+      case DOCUMENT_HISTORY.LABELS.DOCUMENT_REQUESTED:
+      default:
+        return SHARED.DOCUMENT_REQUESTED;
+    }
+  }
+
+  /**
+   * Check if a section has valid content to display
+   */
+  private checkValidContent(section: ProcessedDocumentHistorySection): boolean {
+    return section.list && section.list.length > 0 && 
+           section.list.some(item => 
+             item.requestDescription !== SHARED.EMPTY && 
+             item.documentUrl !== SHARED.EMPTY && 
+             (item.userName !== SHARED.EMPTY && item.userName !== SHARED.UNKNOWN_USER)
+           );
+  }
+
+  /**
+   * Process history data to add computed properties
+   */
+  processHistoryData(historyData: DocumentHistorySection[]): ProcessedDocumentHistorySection[] {
+    if (!historyData) {
+      return SHARED.EMPTY_ARRAY;
+    }
+
+    return historyData.map(section => {
+      const processedSection: ProcessedDocumentHistorySection = {
+        ...section,
+        list: section.list.map(item => ({
+          ...item,
+          dateTime: item.dateTime || ERRORS.NO_VALUE_FOUND,
+          actionIcon: this.documentHistoryStyleService.getActionIcon(item.label),
+          actionColor: this.documentHistoryStyleService.getActionColor(item.label),
+          actionBgColor: this.documentHistoryStyleService.getActionBgColor(item.label),
+          actionBorderColor: this.documentHistoryStyleService.getActionBorderColor(item.label),
+          actionIconBgColor: this.documentHistoryStyleService.getActionIconBgColor(item.label)
+        }))
+      };
+      processedSection.accordionClass = this.getAccordionClass(processedSection);
+      processedSection.hasValidContent = this.checkValidContent(processedSection);
+
+      return processedSection;
+    }).sort((a, b) => {
+      if (a.header === SHARED.INITIAL_REQUEST) return -1;
+      if (b.header === SHARED.INITIAL_REQUEST) return 1;
+      return 0;
+    }).map(section => ({
+      ...section,
+      list: section.list.reverse()
+    }));
+  }
+
+  /**
+   * Downloads a document when clicked
+   * @param documentUrl - The URL of the document to download
+   * @param docName - The name of the document
+   */
+  downloadDocument(documentUrl: string, docName?: string): void {
+    if (!documentUrl) {
+      console.warn(ERRORS.NO_DOCUMENT_URL);
+      return;
+    }
+    this.http.get(documentUrl, { responseType: 'blob' }).subscribe({
+      next: (blob) => {
+        const blobUrl = window.URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = blobUrl;
+        a.download = docName ?? SHARED.DOCUMENT;
+        a.style.display = SHARED.NONE;
+        document.body.appendChild(a);
+        a.click();
+        a.remove();
+        window.URL.revokeObjectURL(blobUrl);
+      },
+      error: (err) => {
+        console.error(ERRORS.DOWNLOAD_FAIL, err);
+      }
+    });
+  }
+} 

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

@@ -0,0 +1,119 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { DocumentHttpService } from './document-http.service';
+import { DocumentStore } from '../state/document.store';
+import { AppConfigService } from '../../../Shared/services/app-config.service';
+import { URLS } from '../../../Shared/constant/URLS';
+import { DocumentTypeModel } from '../models/document-type.model';
+import { throwError } from 'rxjs';
+import { FolderBlockModel } from '../models/folder.model';
+import { DocumentModel } from '../models/document.model';
+
+describe('DocumentHttpService', () => {
+  let service: DocumentHttpService;
+  let httpMock: HttpTestingController;
+  let documentStoreSpy: jasmine.SpyObj<DocumentStore>;
+  let appConfigServiceSpy: jasmine.SpyObj<AppConfigService>;
+
+  beforeEach(() => {
+    documentStoreSpy = jasmine.createSpyObj('DocumentStore', ['setDocumentTypes', 'setFolders']);
+    appConfigServiceSpy = jasmine.createSpyObj('AppConfigService', ['apiBaseUrl'], {
+      apiBaseUrl: 'http://localhost/api'
+    });
+
+    TestBed.configureTestingModule({
+      imports: [HttpClientTestingModule],
+      providers: [
+        DocumentHttpService,
+        { provide: DocumentStore, useValue: documentStoreSpy },
+        { provide: AppConfigService, useValue: appConfigServiceSpy }
+      ]
+    });
+
+    service = TestBed.inject(DocumentHttpService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should fetch document types and update the store', () => {
+    const mockDocumentTypes: DocumentTypeModel[] = [
+      {
+        _id: '1',
+        label: 'Parent-child1',
+        name: 'Type 1',
+        matchRules: 'Rule 1',
+        parentDocumentTypeId: '0'
+      },
+      {
+        _id: '2',
+        label: 'Parent-child2',
+        name: 'Type 2',
+        matchRules: 'Rule 2',
+        parentDocumentTypeId: '1'
+      }
+    ];
+
+    service.getDocumentTypes().subscribe((documentTypes) => {
+      expect(documentTypes).toEqual(mockDocumentTypes);
+      expect(documentStoreSpy.setDocumentTypes).toHaveBeenCalledWith(mockDocumentTypes);
+    });
+
+    const req = httpMock.expectOne(
+      `${appConfigServiceSpy.apiBaseUrl}${URLS.DOCUMENT_UPLOAD}/${URLS.DOCUMENT_TYPES}`
+    );
+    expect(req.request.method).toBe('GET');
+    req.flush(mockDocumentTypes); // Mock the response with data
+  });
+
+ 
+  
+  it('should fetch folders data and update the store', () => {
+    const contextId = 'someContextId';
+    const mockFolderData: FolderBlockModel[] = [
+      { _id: '1', folderName: 'Folder 1' },
+      { _id: '2', folderName: 'Folder 2' }
+    ];
+  
+    service.getFoldersData(contextId).subscribe((foldersData) => {
+      expect(foldersData).toEqual(mockFolderData);
+      expect(documentStoreSpy.setFolders).toHaveBeenCalledWith(mockFolderData); // ✅ Corrected method
+    });
+  
+    const req = httpMock.expectOne(
+      `${appConfigServiceSpy.apiBaseUrl}${URLS.DOCUMENT_UPLOAD}${URLS.FOLDERS}${contextId}`
+    );
+    expect(req.request.method).toBe('GET');
+    req.flush(mockFolderData);
+  });
+    
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should update document name successfully', () => {
+    const documentId = '123';
+    const payload = { fileName: 'New Document Name' };
+    const mockUpdatedDocument: DocumentModel = {
+      _id: documentId,
+      fileName: 'New Document Name'
+    } as DocumentModel;
+
+    service.updateDocumentName(documentId, payload).subscribe((updatedDoc) => {
+      expect(updatedDoc).toEqual(jasmine.objectContaining(mockUpdatedDocument));
+    });
+
+    const req = httpMock.expectOne(
+      `${appConfigServiceSpy.apiBaseUrl}${URLS.DOCUMENT_UPLOAD}/${documentId}`
+    );
+    expect(req.request.method).toBe('PUT');
+    expect(req.request.body).toEqual(payload);
+    req.flush(mockUpdatedDocument);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+});