cat-documents-ng 1.0.4 → 1.0.6

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

@@ -0,0 +1,378 @@
+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';
+import { DocumentCategory } from '../models/document-category.model';
+import { UserListModel } from '../models/user-list.model';
+import { StatusDataModel } from '../models/status-data.model';
+import { DocumentListResponse } from '../models/document-list-response.model';
+import { DocumentListItem } from '../models/document-list-response.model';
+import { DocumentHistorySection } from '../models/document-history.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);
+  }
+
+  /**
+   * Selects the document categories.
+   * @returns {Observable<DocumentCategory[]>} Observable that emits the document categories.
+   */
+  selectDocumentCategories(): Observable<DocumentCategory[]> {
+    return this.select((state) => state.documentCategories);
+  }
+
+  // New query methods for selection state
+  /**
+   * Selects the currently selected menu item.
+   * @returns {Observable<string | null>} Observable that emits the currently selected menu item _id (not the label).
+   */
+  selectSelectedMenuItem(): Observable<string | null> {
+    return this.select((state) => state.selectedMenuItem);
+  }
+
+  /**
+   * Selects the currently selected user ID.
+   * @returns {Observable<string | null>} Observable that emits the currently selected user ID.
+   */
+  selectSelectedUserId(): Observable<string | null> {
+    return this.select((state) => state.selectedUserId);
+  }
+
+  /**
+   * Selects the currently selected status.
+   * @returns {Observable<string | null>} Observable that emits the currently selected status.
+   */
+  selectSelectedStatus(): Observable<string | null> {
+    return this.select((state) => state.selectedStatus);
+  }
+
+  /**
+   * Selects the current search key.
+   * @returns {Observable<string | null>} Observable that emits the current search key.
+   */
+  selectSearchKey(): Observable<string | null> {
+    return this.select((state) => state.searchKey);
+  }
+
+  /**
+   * Selects all selection state properties (menu item, user ID, status, search key).
+   * @returns {Observable<{menuItem: string | null, userId: string | null, status: string | null, searchKey: string | null}>} Observable that emits the current selection state.
+   * Note: menuItem is the _id of the selected menu item, not the label.
+   */
+  selectSelectionState(): Observable<{menuItem: string | null, userId: string | null, status: string | null, searchKey: string | null}> {
+    return this.select((state) => ({
+      menuItem: state.selectedMenuItem,
+      userId: state.selectedUserId,
+      status: state.selectedStatus,
+      searchKey: state.searchKey
+    }));
+  }
+
+  /**
+   * Gets the current selection state values (synchronous).
+   * @returns {Object} The current selection state values.
+   * Note: menuItem is the _id of the selected menu item, not the label.
+   */
+  getSelectionState(): {menuItem: string | null, userId: string | null, status: string | null, searchKey: string | null} {
+    const state = this.getValue();
+    return {
+      menuItem: state.selectedMenuItem,
+      userId: state.selectedUserId,
+      status: state.selectedStatus,
+      searchKey: state.searchKey
+    };
+  }
+
+  /**
+   * Selects the user list visibility state.
+   * @returns {Observable<boolean>} Observable that emits the current user list visibility.
+   */
+  selectShowUserList(): Observable<boolean> {
+    return this.select((state) => state.showUserList);
+  }
+
+  /**
+   * Gets the current user list visibility value (synchronous).
+   * @returns {boolean} The current user list visibility.
+   */
+  getShowUserList(): boolean {
+    return this.getValue().showUserList;
+  }
+
+  /**
+   * Selects the current document.
+   * @returns {Observable<DocumentModel | null>} Observable that emits the current document.
+   */
+  selectCurrentDocument(): Observable<DocumentModel | null> {
+    return this.select((state) => state.currentDocument);
+  }
+
+  /**
+   * Gets the current document value (synchronous).
+   * @returns {DocumentModel | null} The current document.
+   */
+  getCurrentDocument(): DocumentModel | null {
+    return this.getValue().currentDocument;
+  }
+
+  /**
+   * Selects the user list.
+   * @returns {Observable<UserListModel[]>} Observable that emits the user list.
+   */
+  selectUserList(): Observable<UserListModel[]> {
+    return this.select((state) => state.userList);
+  }
+
+  /**
+   * Gets the current user list value (synchronous).
+   * @returns {UserListModel[]} The current user list.
+   */
+  getUserList(): UserListModel[] {
+    return this.getValue().userList;
+  }
+
+  /**
+   * Selects the status data.
+   * @returns {Observable<StatusDataModel[]>} Observable that emits the status data.
+   */
+  selectStatusData(): Observable<StatusDataModel[]> {
+    return this.select((state) => state.statusData);
+  }
+
+  /**
+   * Gets the current status data value (synchronous).
+   * @returns {StatusDataModel[]} The current status data.
+   */
+  getStatusData(): StatusDataModel[] {
+    return this.getValue().statusData;
+  }
+
+  /**
+   * Selects the document list response.
+   * @returns {Observable<DocumentListResponse[] | null>} Observable that emits the document list response.
+   */
+  selectDocumentListResponse(): Observable<DocumentListResponse[] | null> {
+    return this.select((state) => state.documentListResponse);
+  }
+
+  /**
+   * Gets the current document list response value (synchronous).
+   * @returns {DocumentListResponse[] | null} The current document list response.
+   */
+  getDocumentListResponse(): DocumentListResponse[] | null {
+    return this.getValue().documentListResponse;
+  }
+
+  // Document Viewer State Query Methods
+  /**
+   * Selects the selected document for viewing.
+   * @returns {Observable<DocumentListItem | undefined>} Observable that emits the selected document.
+   */
+  selectSelectedDocument(): Observable<DocumentListItem | undefined> {
+    return this.select((state) => state.selectedDocument);
+  }
+
+  /**
+   * Gets the current selected document value (synchronous).
+   * @returns {DocumentListItem | undefined} The current selected document.
+   */
+  getSelectedDocument(): DocumentListItem | undefined {
+    return this.getValue().selectedDocument;
+  }
+
+  /**
+   * Selects the document history.
+   * @returns {Observable<DocumentHistorySection[]>} Observable that emits the document history.
+   */
+  selectDocumentHistory(): Observable<DocumentHistorySection[]> {
+    return this.select((state) => state.documentHistory);
+  }
+
+  /**
+   * Gets the current document history value (synchronous).
+   * @returns {DocumentHistorySection[]} The current document history.
+   */
+  getDocumentHistory(): DocumentHistorySection[] {
+    return this.getValue().documentHistory;
+  }
+
+  /**
+   * Selects the document history visibility state.
+   * @returns {Observable<boolean>} Observable that emits the current document history visibility.
+   */
+  selectShowDocumentHistory(): Observable<boolean> {
+    return this.select((state) => state.showDocumentHistory);
+  }
+
+  /**
+   * Gets the current document history visibility value (synchronous).
+   * @returns {boolean} The current document history visibility.
+   */
+  getShowDocumentHistory(): boolean {
+    return this.getValue().showDocumentHistory;
+  }
+
+  /**
+   * Selects the action loading state.
+   * @returns {Observable<boolean>} Observable that emits the current action loading state.
+   */
+  selectIsActionLoading(): Observable<boolean> {
+    return this.select((state) => state.isActionLoading);
+  }
+
+  /**
+   * Gets the current action loading value (synchronous).
+   * @returns {boolean} The current action loading state.
+   */
+  getIsActionLoading(): boolean {
+    return this.getValue().isActionLoading;
+  }
+
+  /**
+   * Selects the document status.
+   * @returns {Observable<'pending' | 'accepted' | 'rejected'>} Observable that emits the current document status.
+   */
+  selectDocumentStatus(): Observable<'pending' | 'accepted' | 'rejected'> {
+    return this.select((state) => state.documentStatus);
+  }
+
+  /**
+   * Gets the current document status value (synchronous).
+   * @returns {'pending' | 'accepted' | 'rejected'} The current document status.
+   */
+  getDocumentStatus(): 'pending' | 'accepted' | 'rejected' {
+    return this.getValue().documentStatus;
+  }
+
+  /**
+   * Selects the document uploaded state.
+   * @returns {Observable<boolean>} Observable that emits the current document uploaded state.
+   */
+  selectDocumentIsUploaded(): Observable<boolean> {
+    return this.select((state) => state.documentIsUploaded);
+  }
+
+  /**
+   * Gets the current document uploaded value (synchronous).
+   * @returns {boolean} The current document uploaded state.
+   */
+  getDocumentIsUploaded(): boolean {
+    return this.getValue().documentIsUploaded;
+  }
+
+  /**
+   * Selects the alert data.
+   * @returns {Observable<any>} Observable that emits the current alert data.
+   */
+  selectAlertData(): Observable<any> {
+    return this.select((state) => state.alertData);
+  }
+
+  /**
+   * Gets the current alert data value (synchronous).
+   * @returns {any} The current alert data.
+   */
+  getAlertData(): any {
+    return this.getValue().alertData;
+  }
+
+  /**
+   * Selects all document viewer state properties.
+   * @returns {Observable<{selectedDocument?: DocumentListItem, documentHistory: DocumentHistorySection[], showDocumentHistory: boolean, isActionLoading: boolean, documentStatus: 'pending' | 'accepted' | 'rejected', documentIsUploaded: boolean, alertData: any, deleteError: any, deleteSuccess: boolean}>} Observable that emits the current document viewer state.
+   */
+  selectDocumentViewerState(): Observable<{
+    selectedDocument?: DocumentListItem;
+    documentHistory: DocumentHistorySection[];
+    showDocumentHistory: boolean;
+    isActionLoading: boolean;
+    documentStatus: 'pending' | 'accepted' | 'rejected';
+    documentIsUploaded: boolean;
+    alertData: any;
+    deleteError: any;
+    deleteSuccess: boolean;
+  }> {
+    return this.select((state) => ({
+      selectedDocument: state.selectedDocument,
+      documentHistory: state.documentHistory,
+      showDocumentHistory: state.showDocumentHistory,
+      isActionLoading: state.isActionLoading,
+      documentStatus: state.documentStatus,
+      documentIsUploaded: state.documentIsUploaded,
+      alertData: state.alertData,
+      deleteError: state.deleteError,
+      deleteSuccess: state.deleteSuccess
+    }));
+  }
+
+  /**
+   * Gets the current document viewer state values (synchronous).
+   * @returns {Object} The current document viewer state values.
+   */
+  getDocumentViewerState(): {
+    selectedDocument?: DocumentListItem;
+    documentHistory: DocumentHistorySection[];
+    showDocumentHistory: boolean;
+    isActionLoading: boolean;
+    documentStatus: 'pending' | 'accepted' | 'rejected';
+    documentIsUploaded: boolean;
+    alertData: any;
+    deleteError: any;
+    deleteSuccess: boolean;
+  } {
+    const state = this.getValue();
+    return {
+      selectedDocument: state.selectedDocument,
+      documentHistory: state.documentHistory,
+      showDocumentHistory: state.showDocumentHistory,
+      isActionLoading: state.isActionLoading,
+      documentStatus: state.documentStatus,
+      documentIsUploaded: state.documentIsUploaded,
+      alertData: state.alertData,
+      deleteError: state.deleteError,
+      deleteSuccess: state.deleteSuccess
+    };
+  }
+}

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_FILE}`, 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_FILE}/${id}`).pipe(
+            tap(() => this.documentStore.remove(id))
+        );
+    }
 }

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

@@ -0,0 +1,100 @@
+import { EntityState } from '@datorama/akita';
+import { DocumentModel } from '../models/document.model';
+import { DocumentTypeModel } from '../models/document-type.model';
+import { DocumentAlertModel } from '../models/document-alert.model';
+import { FolderBlockModel } from '../models/folder.model';
+import { DocumentCategory } from '../models/document-category.model';
+import { Message } from 'primeng/api';
+import { UserListModel } from '../models/user-list.model';
+import { StatusDataModel } from '../models/status-data.model';
+import { DocumentListResponse } from '../models/document-list-response.model';
+import { DocumentListItem } from '../models/document-list-response.model';
+import { DocumentHistorySection } from '../models/document-history.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`.
+ * @interface DocumentState
+ * @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[];
+  dropdownOptions: DocumentTypeModel[];
+  uploadedDocumentFiles: DocumentModel[];
+  parentDocumentTypeId: string | null;
+  documentAlert:DocumentAlertModel
+  folders:FolderBlockModel[]
+  messages: Message[]
+  documentList : DocumentModel[]
+  documentCategories: DocumentCategory[];
+  selectedMenuItem: string | null; // Stores the _id of the selected menu item, not the label
+  selectedUserId: string | null;
+  selectedStatus: string | null;
+  searchKey: string | null; // Search term for filtering documents
+  showUserList: boolean;
+  currentDocument: DocumentModel | null;
+  userList: UserListModel[];
+  statusData: StatusDataModel[];
+  documentListResponse: DocumentListResponse[] | null;
+  
+  // Document Viewer State
+  selectedDocument?: DocumentListItem;
+  documentHistory: DocumentHistorySection[];
+  showDocumentHistory: boolean;
+  isActionLoading: boolean;
+  documentStatus: 'pending' | 'accepted' | 'rejected';
+  documentIsUploaded: boolean;
+  alertData: any;
+  deleteError: any;
+  deleteSuccess: boolean;
+}
+
+/**
+ * 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 function createInitialState(): DocumentState {
+  return {
+    records: [],
+    filteredRecords: [],
+    folderId: null,
+    isDialogOpen: false,
+    dropdownOptions: [], 
+    uploadedDocumentFiles: [],
+    parentDocumentTypeId: null,
+    documentAlert: {_id:''},
+    folders:[],
+    messages:[],
+    documentList : [],
+    documentCategories: [],
+    selectedMenuItem: null,
+    selectedUserId: null,
+    selectedStatus: null,
+    searchKey: null,
+    showUserList: true,
+    currentDocument: null,
+    userList: [],
+    statusData: [],
+    documentListResponse: null,
+    
+    // Document Viewer State
+    selectedDocument: undefined,
+    documentHistory: [],
+    showDocumentHistory: false,
+    isActionLoading: false,
+    documentStatus: 'pending' as 'pending',
+    documentIsUploaded: false,
+    alertData: null,
+    deleteError: null,
+    deleteSuccess: false
+  };
+}