cat-documents-ng 0.0.3 → 0.0.5

package/{lib/document/components/folder-block/folder-block.component.d.ts → src/lib/document/components/folder-block/folder-block.component.ts}

@@ -1,37 +1,51 @@
+import { Component, Input } from '@angular/core';
 import { DocumentStore } from '../../state/document.store';
 import { FolderBlockModel } from '../../models/folder.model';
-import * as i0 from "@angular/core";
+import { SHARED } from '../../../../Shared/constant/SHARED';
+
 /**
  * The `FolderBlockComponent` is responsible for displaying a block of folders and
  * providing filtering functionality based on folder IDs.
  *
- * It uses data from the `DocumentStore` and constants from the `SHARED` configuration
+ * It uses data from the `DocumentStore` and constants from the `SHARED` configuration 
  * to display missing and pending file counts.
  */
-export declare class FolderBlockComponent {
-    documentStore: DocumentStore;
+@Component({
+    selector: 'lib-folder-block',
+    standalone: false,
+    templateUrl: './folder-block.component.html',
+    styleUrl: './folder-block.component.scss'
+})
+export class FolderBlockComponent {
     /**
      * Array of folder blocks data to display.
      * Each folder is represented as a `FolderBlockModel`.
      */
-    folderBlocks: FolderBlockModel[];
+    @Input() folderBlocks: FolderBlockModel[] = [];
+    
     /** Number of missing files, sourced from the `SHARED` constants. */
-    missingFileCount: number;
+    missingFileCount = SHARED.MISSINGCOUNT;
+
     /** Number of pending files, sourced from the `SHARED` constants. */
-    pendingFileCount: number;
+    pendingFileCount = SHARED.PENDINGCOUNT;
+
     /**
      * Injects the `DocumentStore` service to manage and access document-related state.
      * @param {DocumentStore} documentStore - The state management store for documents.
      */
-    constructor(documentStore: DocumentStore);
+    constructor(public documentStore: DocumentStore) {}
+
     /**
      * Handles the click event for filtering based on the provided folder ID.
-     * This method validates the folder ID and returns it for further processing.
+     * This method validates the folder ID and returns it for further processing. 
      * If the folder ID is not provided, an empty string is returned.
      * @param {string} folderBlockId - The unique identifier of the folder to filter by.
      * @returns {string} The validated folder ID, or an empty string if the input is invalid.
      */
-    handleClickForFilter(folderBlockId: string): string;
-    static ɵfac: i0.ɵɵFactoryDeclaration<FolderBlockComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<FolderBlockComponent, "lib-folder-block", never, { "folderBlocks": { "alias": "folderBlocks"; "required": false; }; }, {}, never, never, false, never>;
+    handleClickForFilter(folderBlockId: string): string {
+        if (!folderBlockId) {
+            return SHARED.EMPTY;
+        }
+        return folderBlockId;
+    }
 }

package/src/lib/document/components/folder-container/folder-container.component.html

@@ -0,0 +1,2 @@
+
+<lib-folder-block [folderBlocks]="folderBlocks"></lib-folder-block>

package/src/lib/document/components/folder-container/folder-container.component.ts

@@ -0,0 +1,29 @@
+import { Component, Input } from '@angular/core';
+import { FOLDERPANEL } from '../../../../Shared/constant/SHARED';
+import { DocumentModel } from '../../models/document.model';
+
+/**
+ * The `FolderContainerComponent` is responsible for rendering a container 
+ * that displays a list of documents and associated folder panel data.
+ *
+ * This component utilizes the `FOLDERPANEL` constant for folder panel data
+ * and accepts a document list input of type `DocumentModel`.
+ */
+@Component({
+  selector: 'lib-folder-container',
+  standalone: false,
+  templateUrl: './folder-container.component.html',
+  styleUrl: './folder-container.component.scss'
+})
+export class FolderContainerComponent {
+  /**
+   * A list of documents passed as input to the component.
+   * Represents the document data to be displayed in the folder container.
+   */
+  @Input() documentList?: DocumentModel[];
+
+  /**
+   * Folder blocks data, sourced from the `SHARED` constants.
+   */
+  folderBlocks = FOLDERPANEL;
+}

package/src/lib/document/document.module.ts

@@ -0,0 +1,191 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DocumentContainerComponent } from './components/document-container/document-container.component';
+import { FolderContainerComponent } from './components/folder-container/folder-container.component';
+import { FolderBlockComponent } from './components/folder-block/folder-block.component';
+import { DocumentListComponent } from './components/document-list/document-list.component';
+import { AccordionModule } from 'primeng/accordion';
+import { DocumentListItemComponent } from './components/document-list-item/document-list-item.component';
+import { ButtonModule } from 'primeng/button';
+import { SidebarModule } from 'primeng/sidebar';
+import { FileUploadModule } from 'primeng/fileupload';
+import { DocumentUploadComponent } from './components/document-upload/document-upload.component';
+import { MessageService } from 'primeng/api';
+import { HttpClientModule } from '@angular/common/http';
+import { ProgressBarModule } from 'primeng/progressbar';
+import { BadgeModule } from 'primeng/badge';
+import { ListboxModule } from 'primeng/listbox';
+import { TimelineModule } from 'primeng/timeline';
+import { CheckboxModule } from 'primeng/checkbox';
+import { InputTextareaModule } from 'primeng/inputtextarea';
+import { FormsModule } from '@angular/forms';
+import { DocumentViewerComponent } from './components/document-viewer/document-viewer.component';
+import { PdfViewerModule } from 'ng2-pdf-viewer';
+import { DialogModule } from 'primeng/dialog';
+import { AppConfigService } from '../../Shared/services/app-config.service';
+import { GlobalErrorHandler } from '../../Shared/services/global-error.handler';
+
+/**
+ * @module DocumentModule
+ * 
+ * The `DocumentModule` handles the organization and display of document and folder components 
+ * in the application. This module is designed to support features like folder containers, 
+ * document lists, and individual document items.
+ */
+@NgModule({
+  declarations: [
+    /**
+     * The main container for managing documents.
+     * DocumentContainerComponent
+     */
+    DocumentContainerComponent,
+
+    /**
+     * A container component to manage folders.
+     * FolderContainerComponent
+     */
+    FolderContainerComponent,
+
+    /**
+     * A block component that represents an individual folder.
+     * FolderBlockComponent
+     */
+    FolderBlockComponent,
+
+    /**
+     * A component to display a list of documents.
+     * DocumentListComponent
+     */
+    DocumentListComponent,
+
+    /**
+     * A component representing an individual item in the document list.
+     * DocumentListItemComponent
+     */
+    DocumentListItemComponent,
+
+    /** 
+     * A component representing to upload a file.
+     */
+    DocumentUploadComponent,
+
+    /**
+     * A component representing and allow you to view the document.
+     */
+    DocumentViewerComponent,
+
+  ],
+  imports: [
+    /**
+     * Angular's CommonModule is imported to access common directives like `ngIf` and `ngFor`.
+     */
+    CommonModule,
+
+    /**
+     * PrimeNG AccordionModule is used for creating collapsible sections in the UI.
+     */
+    AccordionModule,
+
+    /**
+     * HttpClienModule for the http calls
+     */
+    HttpClientModule,
+
+    /**
+     * PrimeNG ButtonModule is used for creating buttons in the UI.
+     */
+    ButtonModule,
+
+    /**
+     * PrimeNG SidebarModule is used for creating sidebar in the UI.
+     */
+    SidebarModule,
+
+    /**
+     * PrimeNG FileUploadModule is used for uploading file.
+     */
+    FileUploadModule,
+
+    /**
+     * PrimeNG ProgressBarModule is used for showing progress.
+     */
+    ProgressBarModule,
+
+    /**
+     * PrimeNG BadgeModule is used for showing badge value.
+     */
+    BadgeModule,
+
+    /**
+     * PrimeNG ListboxModule is used for showing listbox value.
+     */
+    ListboxModule,
+
+    /**
+     * PrimeNG CheckboxModule is used for showing checkbox value.
+     */
+    CheckboxModule,
+
+    /**
+     * PrimeNG TimelineModule is used for showing timeline value.
+     */
+    TimelineModule,
+    /**
+     * PrimeNG InputTextareaModule is used for showing textarea value.
+     */
+    InputTextareaModule,
+    /**
+     * FormsModule to handle the forms.
+     */
+    FormsModule,
+    /**
+     *  PdfViewerModule to handle and make visible the pdf.
+     */
+    PdfViewerModule,
+    /**
+     * PrimeNG DialogModule is used for showing dialog.
+     */
+    DialogModule
+  ],
+  exports: [
+    /**
+     * Exports the `DocumentContainerComponent` to be used in other modules.
+     */
+    DocumentContainerComponent,
+    /**
+     * Exports the `DocumentViewerComponent` to be used in other modules.
+     */
+    DocumentViewerComponent
+  ],
+  providers: [
+    /**
+     * Provide the messageservice to be used in other components.
+     */
+    MessageService,
+
+    /**
+     * Provide the messageservice to be used in other components.
+     */
+    { provide: GlobalErrorHandler, useClass: GlobalErrorHandler },
+    /**
+     * Initializes the application configuration by loading it from the AppConfigService
+     * before the application starts.
+     * This ensures that the configuration is available for the rest of the app when needed.
+     * The configuration is loaded asynchronously using the APP_INITIALIZER.
+     * @returns {Function} - A function that loads the configuration from the AppConfigService.
+     */
+    {
+      provide: APP_INITIALIZER,
+    /**
+     * This useFactory is executed when the app initializes.
+     */
+      useFactory: (configService: AppConfigService) => () =>
+        configService.loadAppConfig().catch((error) => {
+          throw new Error(error);
+        }),
+      deps: [AppConfigService],
+      multi: true,
+    }
+  ]
+})
+export class DocumentModule { }

package/src/lib/document/models/document.model.ts

@@ -0,0 +1,39 @@
+import { SHARED } from "../../../Shared/constant/SHARED";
+
+/**
+ * Represents a document model.
+ * 
+ * This class contains the structure for document-related data, including file name, 
+ * status, and document URL.
+ */
+export class DocumentModel {
+  /**
+   * The unique identifier for the document.
+   * @type {number}
+   */
+  _id: number = SHARED.INITIAL_COUNT;
+
+  /**
+   * The name of the document file.
+   * @type {?string}
+   */
+  fileName?: string;
+
+  /**
+   * The current status of the document.
+   * @type {?string}
+   */
+  status?: string;
+
+  /**
+   * The URL where the document is hosted or stored.
+   * @type {?string}
+   */
+  documentUrl?: string;
+
+  /**
+   * Date of document get uploaded
+   * @type {?Date}
+   */
+  createdAt?: Date
+}

package/{lib/document/models/folder.model.d.ts → src/lib/document/models/folder.model.ts}

@@ -1,27 +1,33 @@
+import { SHARED } from "../../../Shared/constant/SHARED";
+
 /**
  * Represents the model for a folder block.
- *
- * This class provides the structure for folder block data, including properties
+ * 
+ * This class provides the structure for folder block data, including properties 
  * for ID, file counts, descriptive text, and counts for missing and pending files.
  */
-export declare class FolderBlockModel {
+export class FolderBlockModel {
     /**
      * Unique identifier for the folder block.
      * Defaults to an empty string sourced from `SHARED.EMPTY`.
      */
-    _id: string;
+    _id: string = SHARED.EMPTY;
+
     /**
      * Total number of files within the folder block.
      */
     fileCount?: number;
+
     /**
      * Descriptive text associated with the folder block.
      */
     text?: string;
+
     /**
      * Number of files marked as missing in the folder block.
      */
     missingFiles?: number;
+
     /**
      * Number of files marked as pending in the folder block.
      */

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,23 @@
+import { Injectable } from '@angular/core';
+import { QueryEntity } from '@datorama/akita';
+import { DocumentStore } from './document.store';
+import { DocumentState } from './document.state';
+
+/**
+ * Service that provides querying capabilities for the `DocumentStore`.
+ * 
+ * The `DocumentQuery` class extends Akita's `QueryEntity`, allowing consumers
+ * to retrieve, observe, and filter data from the `DocumentStore` in a reactive manner.
+ * 
+ * @extends QueryEntity<DocumentState>
+ * * Creates an instance of `DocumentQuery`.
+   * 
+   * @param {DocumentStore} store - The underlying store that holds the document state.
+*/
+
+@Injectable({ providedIn: 'root' })
+export class DocumentQuery extends QueryEntity<DocumentState> {
+  constructor(protected override store: DocumentStore) {
+    super(store);
+  }
+}

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

@@ -1,9 +1,11 @@
+import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { DocumentStore } from './document.store';
-import { Observable } from 'rxjs';
+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';
-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.
@@ -12,53 +14,82 @@ import * as i0 from "@angular/core";
  * @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;
+@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(documentStore: DocumentStore, http: HttpClient, appConfigService: AppConfigService);
+    constructor(
+        public documentStore: DocumentStore,
+        private http: HttpClient,
+        public appConfigService: AppConfigService
+    ) { }
+
     /**
      * Get api url from appConfigService.
      * @readonly
      * @type {string}
      */
-    get apiUrl(): 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>;
+    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[]>;
+    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>;
+    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>;
+    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>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentService>;
+    delete(id: string): Observable<void> {
+        return this.http.delete<void>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${id}`).pipe(
+            tap(() => this.documentStore.remove(id))
+        );
+    }
 }

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

@@ -1,30 +1,39 @@
 import { EntityState } from '@datorama/akita';
 import { DocumentModel } from '../models/document.model';
+
 /**
  * Represents the state of the documents in the application.
- *
+ * 
  * This interface extends Akita's `EntityState` to include additional properties
  * for managing document-specific data, such as `records`, `filteredRecords` and `folderId`.
- *
+ * 
  * @extends EntityState<DocumentModel, string>
- *
+ * 
  * @property {any[]} records - A collection of records related to documents.
  * @property {any[]} filteredRecords - A collection of filteredRecords related to documents.
  * @property {string | null} folderId - The ID of the currently selected folder, or `null` if no folder is selected.
  * @property {boolean} isDialogOpen - A flag indicating whether a dialog is open.
  */
 export interface DocumentState extends EntityState<DocumentModel, string> {
-    records: DocumentModel[];
-    folderId: string | null;
-    isDialogOpen: boolean;
-    filteredRecords: DocumentModel[];
+  records: DocumentModel[];
+  folderId: string | null;
+  isDialogOpen: boolean;
+  filteredRecords:DocumentModel[]
 }
+
 /**
  * Creates the initial state for the `DocumentState` store.
- *
+ * 
  * This function provides default values for all properties in the `DocumentState` interface,
  * ensuring the store starts with a consistent initial structure.
- *
+ * 
  * @returns {DocumentState} The initial state of the document store.
  */
-export declare function createInitialState(): DocumentState;
+export function createInitialState(): DocumentState {
+  return {
+    records: [],
+    filteredRecords: [],
+    folderId: null,
+    isDialogOpen: false,
+  };
+}

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

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import { EntityStore, StoreConfig } from '@datorama/akita';
+import { createInitialState, DocumentState } from './document.state';
+
+/**
+ * Store that manages the state of documents in the application.
+ * 
+ * The `DocumentStore` class extends Akita's `EntityStore` to manage the entity state for documents.
+ * It uses the `createInitialState` function to initialize the store with default values and 
+ * is configured with the name `'documents'`.
+ * 
+ * @extends EntityStore<DocumentState>
+ */
+@Injectable({ providedIn: 'root' })
+@StoreConfig({ name: 'documents' })
+export class DocumentStore extends EntityStore<DocumentState> {
+  /**
+   * Creates an instance of `DocumentStore` with the initial state of the documents.
+   */
+  constructor() {
+    super(createInitialState());
+  }
+}

package/{public-api.d.ts → src/public-api.ts}

@@ -1,3 +1,8 @@
+/*
+ * Public API Surface of cat-document-lib
+ */
+
 export * from './lib/document/document.module';
 export * from './lib/document/components/document-container/document-container.component';
-export * from './lib/document/components/document-viewer/document-viewer.component';
+export * from './lib/document/components/document-viewer/document-viewer.component'
+