cat-documents-ng 0.1.28 → 0.1.30

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

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+import { catchError, EMPTY, Observable, tap, throwError } from 'rxjs';
+import { URLS } from '../../../Shared/constant/URLS';
+import { AppConfigService } from '../../../Shared/services/app-config.service';
+import { DocumentStore } from '../state/document.store';
+import { HttpClient } from '@angular/common/http';
+import { DocumentTypeModel } from '../models/document-type.model';
+import { DocumentAlertModel } from '../models/document-alert.model';
+import { DocumentModel } from '../models/document.model';
+import { FolderBlockModel } from '../models/folder.model';
+
+/**
+ * Service for making HTTP requests related to documents.
+ * @class DocumentHttpService
+ * @typedef {DocumentHttpService}
+ */
+@Injectable({
+  providedIn: 'root'
+})
+
+export class DocumentHttpService {
+
+  /**
+   * Creates an instance of DocumentService.
+   * @param {DocumentStore} documentStore - Store managing the state of documents.
+   * @param {HttpClient} http - Angular HTTP client for making API requests.
+   * @param {AppConfigService} appConfigService - Service for retrieving application configuration, such as API base URL.
+   */
+  constructor(
+    public documentStore: DocumentStore,
+    private http: HttpClient,
+    public appConfigService: AppConfigService
+  ) { }
+
+  /**
+   * Get api url from appConfigService.
+   * @readonly
+   * @type {string}
+   */
+  get apiUrl(): string {
+    return this.appConfigService.apiBaseUrl;
+  }
+
+   /**
+    * Fetches a document by its path name and transforms the response for dropdown options.
+    * Includes error handling for failed API requests.
+    * @param {string} contextId - The context ID to fetch the document.
+    * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+    */
+  getFoldersData(contextId:string | undefined): Observable<FolderBlockModel[]> {
+    if(!contextId) return EMPTY;
+    return this.http.get<FolderBlockModel[]>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}${URLS.FOLDERS}${contextId}`).pipe(
+      tap((folders: FolderBlockModel[]) => {
+        this.documentStore.setFolders(folders);
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+   /**
+    * Fetches a document by its path name and transforms the response for dropdown options.
+    * Includes error handling for failed API requests.
+    * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+    */
+   getDocumentTypes(): Observable<DocumentTypeModel[]> {
+    return this.http.get<DocumentTypeModel[]>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${URLS.DOCUMENT_TYPES}`).pipe(
+      tap((documentTypes: DocumentTypeModel[]) => {
+        this.documentStore.setDocumentTypes(documentTypes);
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Fetches a document by its path name and transforms the response for dropdown options.
+   * @param {string} documentId - The document ID to fetch the document.
+   * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+   */
+  getAlertsByDocumentID(documentId:string): Observable<DocumentAlertModel> {
+    return this.http.get<DocumentAlertModel>(`${this.apiUrl}${URLS.ALERT_BY_DOCUMENT_ID}${documentId}`).pipe(
+      tap((documentAlert: DocumentAlertModel) => {
+        this.documentStore.setDocumentAlert(documentAlert);
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Fetches a document by its folder ID and transforms the response for dropdown options.
+   * @param {string} folderId - The folder ID to fetch the document.
+   * @param {string} contextId - The context ID to fetch the document.
+   * @returns {Observable<any>} Observable that emits the transformed data for dropdown options.
+   */
+   getDocumentByFolderID(folderId:string, contextId:string): Observable<DocumentModel[]> {
+    return this.http.get<DocumentModel[]>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${URLS.PARENT_DOCUMENT_TYPE_ID}${folderId}${URLS.CONTEXT_ID}${contextId}`).pipe(
+      tap((records: DocumentModel[]) => {
+        this.documentStore.set(records);
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Updates the name of a document.
+   * This method sends an HTTP PUT request to update the document's file name using the provided document ID and payload.
+   * In case of an error, it will return an observable that throws an Error.
+   * @param {string} documentId - The unique identifier of the document to update.
+   * @param {any} payload - The payload containing the updated document data (e.g., fileName).
+   * @returns {Observable<DocumentModel>} An observable that emits the updated DocumentModel.
+   */
+  updateDocumentName(documentId: string, payload: any): Observable<DocumentModel> {
+    return this.http.put<DocumentModel>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${documentId}`, payload).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+}

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

@@ -0,0 +1,99 @@
+import { fakeAsync, TestBed, tick } from '@angular/core/testing';
+import { DocumentUploadService } from './document-upload.service';
+import { DocumentService } from '../state/document.service';
+import { DocumentStore } from '../state/document.store';
+import { MessageService } from 'primeng/api';
+import { of, throwError } from 'rxjs';
+import { SHARED } from '../../../Shared/constant/SHARED';
+
+describe('DocumentUploadService', () => {
+  let service: DocumentUploadService;
+  let mockDocumentService: jasmine.SpyObj<DocumentService>;
+  let mockDocumentStore: jasmine.SpyObj<DocumentStore>;
+  let mockMessageService: jasmine.SpyObj<MessageService>;
+
+  beforeEach(() => {
+    mockDocumentService = jasmine.createSpyObj('DocumentService', ['create']);
+    mockDocumentStore = jasmine.createSpyObj('DocumentStore', ['setUploadedDocumentFiles', 'setMessage']);
+    mockMessageService = jasmine.createSpyObj('MessageService', ['add']);
+
+    TestBed.configureTestingModule({
+      providers: [
+        DocumentUploadService,
+        { provide: DocumentService, useValue: mockDocumentService },
+        { provide: DocumentStore, useValue: mockDocumentStore },
+        { provide: MessageService, useValue: mockMessageService }
+      ]
+    });
+
+    service = TestBed.inject(DocumentUploadService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should set uploadedFile, contextId, docName, and docTypeId when getUploadFileData is called', () => {
+    const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
+    const contextId = '1234';
+    
+    service.getUploadFileData(mockFile, contextId);
+    
+    expect(service.uploadedFile).toBe(mockFile);
+    expect(service.contextId).toBe(contextId);
+  });
+
+  it('should set document name and type when getDocumentNameAndType is called', () => {
+    const documentName = 'Test Document';
+    const documentTypeId = '5678';
+  
+    service.getDocumentNameAndType(documentTypeId);
+  
+    expect(service.docName).toBe(SHARED.EMPTY);
+    expect(service.docTypeId).toBe(documentTypeId);
+  });
+  
+  
+
+  it('should handle null formData in handleTemplatedUpload', () => {
+    const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
+    const contextId = '1234';
+    const documentName = 'Test Document';
+    const documentTypeId = '5678';
+    service.getUploadFileData(mockFile, contextId);
+    service.getDocumentNameAndType(documentTypeId);
+    spyOn(service, 'handleCreateFormData').and.returnValue(null);
+    service.handleTemplatedUpload();
+    expect(mockMessageService.add).toHaveBeenCalledWith({
+      severity: 'error',
+      summary: 'Form Data Missing',
+      detail: 'Required form data is missing. Please ensure the document and all required fields are provided.'
+    });
+  });
+  
+
+  it('should return null from handleCreateFormData if data is incomplete', () => {
+    const formData = service.handleCreateFormData();
+    expect(formData).toBeNull();
+  });
+
+  it('should call documentService.create and set uploaded files when handleTemplatedUpload is called', () => {
+    const mockFile = new File(['test content'], 'test.pdf', { type: 'application/pdf' });
+    const contextId = '1234';
+    const documentName = 'Test Document';
+    const documentTypeId = '5678';
+    const formData = new FormData();
+    formData.append(SHARED.FILE, mockFile);
+    
+    service.getUploadFileData(mockFile, contextId);
+    service.getDocumentNameAndType(documentTypeId);
+    
+    mockDocumentService.create.and.returnValue(of({ fileId: 'abcd1234' }));
+    
+    service.handleTemplatedUpload();
+    
+    expect(mockDocumentService.create).toHaveBeenCalledWith(formData);
+    expect(mockDocumentStore.setUploadedDocumentFiles).toHaveBeenCalled();
+  });
+
+});

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

@@ -0,0 +1,127 @@
+import { Injectable } 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 {
+
+
+  /**
+   * 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 {void}
+   */
+  handleTemplatedUpload() {
+    let formsData = this.handleCreateFormData()
+    if (!formsData) {
+      this.messageService.add({severity: SHARED.SEVERITY,summary: SHARED.UPLOAD_ERROR_SUMMERY,detail: SHARED.UPLOAD_ERROR_DETAILS});
+      return;
+    }
+    this.documentService.create(formsData)
+      .subscribe({
+        /**
+         * Handles the successful upload event.
+         * Updates the list of uploaded files and emits the file ID.
+         * @param {any} event - The event emitted by the upload service on success.
+         */
+        next: (event) => {
+          this.documentUploadStore.setUploadedDocumentFiles(event)
+          this.documentUploadStore.setMessage([{
+            severity: SHARED.SUCCESS_SEVERITY,
+            detail : SHARED.UPLOAD_SUCCESS
+          }]);
+        },
+        /**
+         * 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.documentUploadStore.setMessage([{severity: SHARED.SEVERITY,summary: SHARED.UPLOAD_SUMMERY,detail: error?.message}]);
+        },
+      });
+  }
+
+  /**
+   * 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) {
+      this.docTypeId = documentTypeId
+    }
+  }
+
+  /**
+   * Handle the creation of formdata.
+   * @returns {*} - The formdata object.
+   */
+  handleCreateFormData() {
+    if (this.uploadedFile && this.contextId && this.docTypeId) {
+      let formData = new FormData();
+      formData.append(SHARED.FILE, this.uploadedFile, this.uploadedFile.name);
+      formData.append(SHARED.CONTEXT_ID, this.contextId)
+      formData.append(SHARED.DOCUMENT_TYPE_ID, this.docTypeId)
+      return formData;
+    }else{
+      return null;
+    }
+    
+  }
+}

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

@@ -0,0 +1,29 @@
+import { Injectable } from "@angular/core";
+import { BehaviorSubject } from "rxjs";
+import { DocumentModel } from "../models/document.model";
+
+/**
+ * Service to manage the document data
+ */
+@Injectable({
+    providedIn: 'root',
+})
+export class DocumentService {
+    private documentSubject$ = new BehaviorSubject<DocumentModel | null>(null);
+
+    /**
+     * Set the document data
+     * @param document the document data
+     */
+    set(document: DocumentModel | null) {
+        this.documentSubject$.next(document);
+    }
+
+    /**
+     * Get the document data
+     * @returns the document data
+     */
+    get() {
+        return this.documentSubject$.asObservable();
+    }
+}

package/src/lib/document/services/file-format.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { FileFormatService } from './file-format.service';
+
+describe('FileFormatService', () => {
+  let service: FileFormatService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(FileFormatService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/document/services/file-format.service.ts

@@ -0,0 +1,41 @@
+import { Injectable } from '@angular/core';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { PrimeNGConfig } from 'primeng/api';
+
+/**
+ * Description placeholder
+ * @class FileFormatService
+ * @typedef {FileFormatService}
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class FileFormatService {
+
+  /**
+   * Creates an instance of FileFormatService.
+   * @constructor
+   */
+  constructor() { }
+
+    /**
+     * Description placeholder
+     * @param {number} bytes
+     * @param {PrimeNGConfig} config
+     * @returns {string}
+     */
+    formatFileSize(bytes: number, config:PrimeNGConfig): string {
+      const kilobyte = 1024;
+      const decimalPlaces = SHARED.ONE;
+      const sizes = config.translation.fileSizeTypes || SHARED.FILE_SIZE_UNITS;
+      if (bytes < kilobyte) {
+        return `${bytes} ${sizes[SHARED.INITIAL_COUNT]}`;
+      } else if (bytes < kilobyte * kilobyte) {
+        const kbSize = bytes / kilobyte;
+        return `${parseFloat(kbSize.toFixed(decimalPlaces))} ${sizes[SHARED.ONE]}`;
+      } else {
+        const mbSize = bytes / (kilobyte * kilobyte);
+        return `${parseFloat(mbSize.toFixed(decimalPlaces))} ${sizes[SHARED.TWO]}`;
+      }
+    }
+}

package/src/lib/document/state/document.query.ts

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { QueryEntity } from '@datorama/akita';
+import { DocumentStore } from './document.store';
+import { DocumentState } from './document.state';
+import { Observable } from 'rxjs';
+import { Message } from 'primeng/api';
+import { DocumentModel } from '../models/document.model';
+
+
+/**
+ * Query service for managing document state.
+ * This class extends Akita's `QueryEntity` to provide additional functionality for querying document data.
+ * @class DocumentQuery
+ * @typedef {DocumentQuery}
+ * @augments {QueryEntity<DocumentState>}
+ */
+@Injectable({ providedIn: 'root' })
+export class DocumentQuery extends QueryEntity<DocumentState> {
+  constructor(protected override store: DocumentStore) {
+    super(store);
+  }
+
+  /**
+   * Selects the currently selected folder ID from the document state.
+   * @returns {Observable<string | null>} Observable that emits the currently selected folder ID.
+   */
+  getParentDocumentTypeId() : string | null {
+    return this.getValue()['parentDocumentTypeId'];
+  }
+
+  /**
+   * Selects the currently selected folder ID from the document state.
+   * @returns {Observable<string | null>} Observable that emits the currently selected folder ID.
+   */
+  selectParentDocumentTypeId():Observable<string | null> {
+    return this.select((state) => state['parentDocumentTypeId']);
+  }
+  /**
+   * Selects the set messages.
+   * @returns {Observable<Message>} Observable that emits the current Message.
+   */
+  selectMessages():Observable<Message[]> {
+    return this.select((state) => state.messages);
+  }
+  /**
+   * Selects the set documents.
+   * @returns {Observable<DocumentModel[]>} Observable that emits the documets.
+   */
+  selectDocumets():Observable<DocumentModel[]> {
+    return this.select((state) => state.documentList);
+  }
+}

package/{lib/document/state/document.service.d.ts → src/lib/document/state/document.service.ts}

@@ -1,64 +1,95 @@
-import { HttpClient } from '@angular/common/http';
-import { DocumentStore } from './document.store';
-import { Observable } from 'rxjs';
-import { AppConfigService } from '../../../Shared/services/app-config.service';
-import { DocumentModel } from '../models/document.model';
-import * as i0 from "@angular/core";
-/**
- * Service for managing document-related operations.
- * The `DocumentService` acts as a bridge between the application and the backend API for handling document-related data.
- * It interacts with the `DocumentStore` for state management and uses `HttpClient` for making HTTP requests.
- * Creates an instance of `DocumentService`.
- * @param {DocumentStore} documentStore - The store that manages the state of documents.
- * @param {HttpClient} http - The Angular HTTP client for making API requests.
- */
-export declare class DocumentService {
-    documentStore: DocumentStore;
-    private http;
-    appConfigService: AppConfigService;
-    /**
-     * Creates an instance of DocumentService.
-     * @param {DocumentStore} documentStore - Store managing the state of documents.
-     * @param {HttpClient} http - Angular HTTP client for making API requests.
-     * @param {AppConfigService} appConfigService - Service for retrieving application configuration, such as API base URL.
-     */
-    constructor(documentStore: DocumentStore, http: HttpClient, appConfigService: AppConfigService);
-    /**
-     * Get api url from appConfigService.
-     * @readonly
-     * @type {string}
-     */
-    get apiUrl(): string;
-    /**
-     * Sends a request to create a new document.
-     * @param {*} entity - The data of the document to be created.
-     * @returns {Observable<any>} Observable that emits the newly created document.
-     */
-    create(entity: any): Observable<any>;
-    /**
-     * Fetches all documents from the backend.
-     * @returns {Observable<DocumentModel[]>} Observable that emits an array of documents.
-     */
-    getAll(): Observable<DocumentModel[]>;
-    /**
-     * Fetches a document by its ID.
-     * @param {string} id - The unique identifier of the document.
-     * @returns {Observable<any>} Observable that emits the retrieved document.
-     */
-    getById(id: string): Observable<any>;
-    /**
-     * Updates an existing document by its ID.
-     * @param {string} id - The unique identifier of the document.
-     * @param {DocumentModel} entity - The updated data of the document.
-     * @returns {Observable<DocumentModel>} Observable that emits the updated document.
-     */
-    update(id: string, entity: DocumentModel): Observable<DocumentModel>;
-    /**
-     * Deletes a document by its ID.
-     * @param {string} id - The unique identifier of the document to be deleted.
-     * @returns {Observable<void>} Observable that completes when the document is deleted.
-     */
-    delete(id: string): Observable<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentService>;
-}
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { DocumentStore } from './document.store';
+import { Observable, tap } from 'rxjs';
+import { AppConfigService } from '../../../Shared/services/app-config.service';
+import { URLS } from '../../../Shared/constant/URLS';
+import { DocumentModel } from '../models/document.model';
+
+/**
+ * Service for managing document-related operations.
+ * The `DocumentService` acts as a bridge between the application and the backend API for handling document-related data.
+ * It interacts with the `DocumentStore` for state management and uses `HttpClient` for making HTTP requests.
+ * Creates an instance of `DocumentService`.
+ * @param {DocumentStore} documentStore - The store that manages the state of documents.
+ * @param {HttpClient} http - The Angular HTTP client for making API requests.
+ */
+@Injectable({ providedIn: 'root' })
+export class DocumentService {
+
+    /**
+     * Creates an instance of DocumentService.
+     * @param {DocumentStore} documentStore - Store managing the state of documents.
+     * @param {HttpClient} http - Angular HTTP client for making API requests.
+     * @param {AppConfigService} appConfigService - Service for retrieving application configuration, such as API base URL.
+     */
+    constructor(
+        public documentStore: DocumentStore,
+        private http: HttpClient,
+        public appConfigService: AppConfigService
+    ) { }
+
+    /**
+     * Get api url from appConfigService.
+     * @readonly
+     * @type {string}
+     */
+    get apiUrl(): string {
+        return this.appConfigService.apiBaseUrl;
+    }
+
+    /**
+     * Sends a request to create a new document.
+     * @param {*} entity - The data of the document to be created.
+     * @returns {Observable<any>} Observable that emits the newly created document.
+     */
+    create(entity: any): Observable<any> {
+        return this.http.post<any>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}`, entity).pipe(
+            tap((newEntity: any) => this.documentStore.add(newEntity))
+        );
+    }
+
+    /**
+     * Fetches all documents from the backend.
+     * @returns {Observable<DocumentModel[]>} Observable that emits an array of documents.
+     */
+    getAll(): Observable<DocumentModel[]> {
+        return this.http.get<DocumentModel[]>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}`).pipe(
+            tap((entities: DocumentModel[]) => this.documentStore.set(entities))
+        );
+    }
+
+    /**
+     * Fetches a document by its ID.
+     * @param {string} id - The unique identifier of the document.
+     * @returns {Observable<any>} Observable that emits the retrieved document.
+     */
+    getById(id: string): Observable<any> {
+        return this.http.get<any>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${id}`).pipe(
+            tap((entity: any) => this.documentStore.upsert(id, entity))
+        );
+    }
+
+    /**
+     * Updates an existing document by its ID.
+     * @param {string} id - The unique identifier of the document.
+     * @param {DocumentModel} entity - The updated data of the document.
+     * @returns {Observable<DocumentModel>} Observable that emits the updated document.
+     */
+    update(id: string, entity: DocumentModel): Observable<DocumentModel> {
+        return this.http.put<DocumentModel>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${id}`, entity).pipe(
+            tap((updatedEntity: DocumentModel) => this.documentStore.update(id, updatedEntity))
+        );
+    }
+
+    /**
+     * Deletes a document by its ID.
+     * @param {string} id - The unique identifier of the document to be deleted.
+     * @returns {Observable<void>} Observable that completes when the document is deleted.
+     */
+    delete(id: string): Observable<void> {
+        return this.http.delete<void>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${id}`).pipe(
+            tap(() => this.documentStore.remove(id))
+        );
+    }
+}