cat-documents-ng 1.0.4 → 1.0.6

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

@@ -0,0 +1,497 @@
+import { Injectable } from '@angular/core';
+import { catchError, EMPTY, Observable, of, tap, throwError } from 'rxjs';
+import { URLS } from '../../../Shared/constant/URLS';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { AppConfigService } from '../../../Shared/services/app-config.service';
+import { DocumentStore } from '../state/document.store';
+import { HttpClient, HttpHeaders, HttpParams } 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';
+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 { DocumentHistorySection } from '../models/document-history.model';
+
+/**
+ * Service for making HTTP requests related to documents.
+ * Authentication is handled automatically by the HTTP interceptor in the main project.
+ * @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 catagories by its path name.
+    * 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.
+    */
+  getDocumentCatagories(contextId:string): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.get<any>(`${this.apiUrl}${URLS.DOCUMENTS_CATAGORIES}/${contextId}`, { headers })
+    .pipe(
+      tap((response: any) => {
+        if (response && response.categories) {
+          this.documentStore.setDocumentCategories(response.categories);
+        }
+      }),
+      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[]> {
+  let headers = new HttpHeaders( {
+    'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+  });
+   return this.http.get<DocumentModel[]>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD}/${URLS.PARENT_DOCUMENT_TYPE_ID}${folderId}${URLS.CONTEXT_ID}${contextId}`, { headers }).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> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.put<DocumentModel>(`${this.apiUrl}${URLS.ALIAS_NAME}${documentId}`, payload, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+   /**
+   * Fetches a userlist by its path name.
+   * @param {string} contextId - The document ID to fetch the document.
+   * @returns {Observable<UserListModel[]>} Observable that emits the user list data.
+   */
+  getUserListByContextId(contextId : string): Observable<UserListModel[]> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    if(!contextId) return EMPTY;
+    return this.http.get<UserListModel[]>(`${this.apiUrl}${URLS.USERLIST}${contextId}`, { headers }).pipe(
+      tap((userList: UserListModel[]) => {
+        this.documentStore.setUserList(userList);
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Fetches document status count data by application ID with optional context ID and category parameters.
+   * @param {string} applicationId - The application ID to fetch status data.
+   * @param {string | null} contextId - The context ID (applicant ID) to filter by. If null, uses applicationId.
+   * @param {string | null} categoryId - The category ID to filter by.
+   * @returns {Observable<StatusDataModel[]>} Observable that emits the status data.
+   */
+  getStatusDocumentCount(applicationId: string, contextId: string | null = null, categoryId: string | null = null): Observable<StatusDataModel[]> {
+    if(!applicationId) return EMPTY;
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    let url = `${this.apiUrl}${URLS.STATUS_DOCUMENT_COUNT}${applicationId}`;
+    let params = new HttpParams();
+    const contextParam = contextId || null;
+    if (contextParam) {
+      params = params.set(SHARED.CONTEXT_ID, contextParam);
+    } 
+    if (categoryId) {
+      params = params.set(SHARED.CATEGORY, categoryId);
+    }
+    return this.http.get<StatusDataModel[]>(url, { params, headers }).pipe(
+      tap((statusData: StatusDataModel[]) => {
+        this.documentStore.setStatusData(statusData);
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+
+  /**
+   * Fetches documents based on selection criteria (user ID, status, and search key).
+   * This method sends an HTTP GET request with query parameters for the selected filters.
+   * Note: Menu item filtering has been removed - menu items are now used for navigation only.
+   * @param {string} contextId - The context ID (applicationId or applicantId).
+   * @param {string | null} menuItem - Reserved parameter (no longer used for filtering).
+   * @param {string | null} userId - The selected user ID filter.
+   * @param {string | null} status - The selected status filter.
+   * @param {string | null} searchKey - The search key filter.
+   * @returns {Observable<any>} An observable that emits the filtered document data.
+   */
+  getDocumentsBySelection(contextId: string, menuItem: string | null, userId: string | null, status: string | null, searchKey: string | null = null): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    let params = new HttpParams();
+    if (userId) {
+      params = params.set(SHARED.CONTEXT_ID, userId);
+    }
+    
+    if (status) {
+      params = params.set(SHARED.STATUS_PARAM, status);
+    }
+
+    if (searchKey) {
+      params = params.set(SHARED.SEARCH_KEY, searchKey);
+    }
+    return this.http.get<any>(`${this.apiUrl}${URLS.GETALL}/${contextId}`, { params, headers }).pipe(
+      tap((response: any) => {
+        if (response.documents) {
+          this.documentStore.setDocumentList(response.documents);
+        }
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+ getDocumentHistory(documentId: string): Observable<DocumentHistorySection[]> {
+  let headers = new HttpHeaders( {
+    'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+  });
+    if (!documentId) {
+      return of([]);
+    }
+    return this.http.get<DocumentHistorySection[]>(`${this.apiUrl}${URLS.DOCUMENT_HISTORY}${documentId}`, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Fetches document categories by source (Applicant/Application).
+   * @param {string} source - The source type (Applicant or Application).
+   * @returns {Observable<DocumentCategory[]>} Observable that emits the categories.
+   */
+  getCategoriesBySource(source: string): Observable<DocumentCategory[]> {
+    if (!source) return EMPTY;
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.get<DocumentCategory[]>(`${this.apiUrl}${URLS.GET_CATEGORIES_BY_SOURCE}${source}`, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Fetches document types by category ID.
+   * @param {string} categoryId - The category ID to fetch document types for.
+   * @returns {Observable<DocumentTypeModel[]>} Observable that emits the document types.
+   */
+  getDocumentTypesByCategory(categoryId: string): Observable<DocumentTypeModel[]> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    if (!categoryId) return EMPTY;
+    return this.http.get<DocumentTypeModel[]>(`${this.apiUrl}${URLS.GET_DOCUMENT_TYPES_BY_CATEGORY}${categoryId}`, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Uploads a single file using the uploadFile API.
+   * @param {FormData} formData - The form data containing the file and metadata.
+   * @returns {Observable<any>} Observable that emits the upload response.
+   */
+  uploadFile(formData: FormData): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.post<any>(`${this.apiUrl}${URLS.DOCUMENT_UPLOAD_FILE}`, formData, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Saves the complete document upload data.
+   * @param {any} payload - The document upload payload containing all necessary data.
+   * @returns {Observable<any>} Observable that emits the save response.
+   */
+  saveDocumentUpload(payload: any): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.post<any>(`${this.apiUrl}${URLS.SAVE_DOCUMENT_UPLOAD}`, payload, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Updates the status of a document by document ID
+   * @param {string} documentId - The ID of the document to update
+   * @param {string} status - The new status (Approved, Rejected, etc.)
+   * @param {string} statusUpdateDescription - The description/note for the status update
+   * @returns {Observable<any>} Observable that emits the updated document data with normalized status
+   */
+  updateDocumentStatus(documentId: string, status: string, statusUpdateDescription: string): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    const payload = {
+      statusUpdateDescription: statusUpdateDescription
+    };
+    return this.http.put<any>(`${this.apiUrl}${URLS.UPDATE_DOCUMENT_STATUS}${documentId}/${status}`, payload, { headers }).pipe(
+      tap((response) => {
+        if (response && response.status) {
+          const normalizedStatus = this.normalizeStatus(response.status);
+          response.normalizedStatus = normalizedStatus;
+        }
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Normalizes the status from API response to match component expectations
+   * @param {string} status - The status from API response (Approved, Rejected, etc.)
+   * @returns {string} Normalized status value
+   */
+  private normalizeStatus(status: string): string {
+    switch (status.toLowerCase()) {
+      case SHARED.APPROVED:
+        return SHARED.STATUS_ACCEPTED;
+      case SHARED.STATUS_REJECTED_LOWERCASE:
+        return SHARED.STATUS_REJECTED_LOWERCASE;
+      case SHARED.STATUS_PENDING:
+        return SHARED.STATUS_PENDING;
+      default:
+        return status.toLowerCase();
+    }
+  }
+
+  /**
+   * Deletes a document by its ID and refreshes all data (categories, userlist, status, and document list)
+   * @param {string} documentId - The ID of the document to delete
+   * @param {string} contextId - The context ID to refresh all data
+   * @returns {Observable<any>} Observable that emits the delete response
+   */
+  deleteDocument(documentId: string, contextId: string): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.delete<any>(`${this.apiUrl}${URLS.DELETE_DOCUMENT}${documentId}`, { headers }).pipe(
+      tap(() => {
+        this.getDocumentCatagories(contextId).subscribe();
+        this.getUserListByContextId(contextId).subscribe();
+        this.getStatusDocumentCount(contextId).subscribe();
+        this.getDocumentsBySelection(contextId, null, null, null, null).subscribe();
+      }),
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Downloads an Excel file with proper authentication headers
+   * Authentication is handled automatically by the HTTP interceptor
+   * @param {string} documentUrl - The URL of the Excel file to download
+   * @returns {Observable<ArrayBuffer>} Observable that emits the file data as ArrayBuffer
+   */
+  downloadExcelFile(documentUrl: string): Observable<ArrayBuffer> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+      return this.http.get(documentUrl, { headers,
+      responseType: 'arraybuffer'
+    }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Downloads a CSV file with proper authentication headers
+   * Authentication is handled automatically by the HTTP interceptor
+   * @param {string} documentUrl - The URL of the CSV file to download
+   * @returns {Observable<string>} Observable that emits the file data as string
+   */
+  downloadCsvFile(documentUrl: string): Observable<string> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.get(documentUrl, { headers,
+      responseType: 'text'
+    }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  
+  /**
+   * Downloads an email file (EML) with appropriate handling for different storage types
+   * @param documentUrl - URL of the email file
+   * @returns Observable of file content as text
+   */
+  downloadEmailFile(documentUrl: string): Observable<string> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    const isAzureBlobStorage = documentUrl.includes('.blob.core.windows.net');
+    if (isAzureBlobStorage) {
+      return this.http.get(documentUrl, { headers,
+        responseType: 'text'
+      }).pipe(
+        catchError((error) => {
+          return throwError(() => new Error('Failed to download email file. Please check if the file URL is valid and accessible.'));
+        })
+      );
+    } else {
+      return this.http.get<string>(documentUrl, { headers }
+      ).pipe(
+        catchError((error) => {
+          return throwError(() => new Error('Failed to download email file. Please check if the file URL is valid and accessible.'));
+        })
+      );
+    }
+  }
+
+  documentRequest(payload: any): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    return this.http.post<any>(`${this.apiUrl}${URLS.DOCUMENT_REQUEST}`, payload, { headers }).pipe(
+      catchError((error) => {
+        return throwError(() => new Error(error));
+      })
+    );
+  }
+
+  /**
+   * Checks if valuation report data exists for the given context ID
+   * @param {string} contextId - The context ID to check for valuation report data
+   * @returns {Observable<any>} Observable that emits the valuation report data or empty object
+   */
+  getValuationReportByContextId(contextId: string): Observable<any> {
+    let headers = new HttpHeaders( {
+      'Authorization': `Bearer 4fe17947-30bf-4079-b4ea-798ff73cd473`
+    });
+    if (!contextId) return EMPTY;
+    return this.http.get<any>(`${this.apiUrl}${URLS.VALUATION_REPORT}${contextId}`, { headers }).pipe(
+      catchError((error) => {
+        // Return empty object if no data found or error occurs
+        return of(null);
+      })
+    );
+  }
+}

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

@@ -0,0 +1,195 @@
+import { Injectable } from '@angular/core';
+import { Observable, of, throwError } from 'rxjs';
+import { DocumentUploadService } from './document-upload.service';
+import { DocumentHttpService } from './document-http.service';
+import { DocumentQuery } from '../state/document.query';
+import { DocumentStore } from '../state/document.store';
+import { DocumentTableBuilderService } from './document-table-builder.service';
+import { DocumentHelperService } from './document.service';
+import { DocumentListItem, DocumentListResponse } from '../models/document-list-response.model';
+import { TableData } from '../../../Shared/components/table-primary/table-primary.model';
+import { SHARED } from '../../../Shared/constant/SHARED';
+import { ERRORS } from '../../../Shared/constant/ERROR';
+import { Message } from 'primeng/api';
+import { DocumentCategory } from '../models/document-category.model';
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentListService {
+
+  constructor(
+    private documentUploadService: DocumentUploadService,
+    private documentHttpService: DocumentHttpService,
+    private documentQuery: DocumentQuery,
+    private documentStore: DocumentStore,
+    private documentTableBuilder: DocumentTableBuilderService,
+    private documentHelperService: DocumentHelperService
+  ) {}
+
+  /**
+   * Handle file upload click event
+   */
+  handleFileUploadClick(): void {
+    this.documentStore.setMessage(SHARED.EMPTY_ARRAY);
+  }
+
+  /**
+   * Handle save click to update document name
+   */
+  handleSaveClick(fileName: string, selectedDocument: DocumentListItem): Observable<any> {
+    const payload = { fileName };
+    return this.documentHttpService.updateDocumentName(selectedDocument._id, payload);
+  }
+
+
+  /**
+   * Get completion count for a category
+   */
+  getCompletionCount(category: DocumentListResponse): string {
+    return this.documentTableBuilder.getCompletionCount(category);
+  }
+
+  /**
+   * Get pending document count for a category
+   */
+  getPendingDocumentCount(category: DocumentListResponse): number {
+    return this.documentTableBuilder.getPendingDocumentCount(category);
+  }
+
+  /**
+   * Get approved document count for a category
+   */
+  getApprovedDocumentCount(category: DocumentListResponse): number {
+    return this.documentTableBuilder.getApprovedDocumentCount(category);
+  }
+
+
+
+  /**
+   * Build document categories from API response
+   */
+  buildDocumentCategories(documentListResponse: DocumentListResponse[] | null): {
+    documentCategories: DocumentListResponse[];
+    categoryTables: TableData[];
+    categoryCompletionCounts: string[];
+    categorySeverities: ('success' | 'info' | 'warning' | 'danger')[];
+  } {
+    if (!documentListResponse) {
+      return {
+        documentCategories: SHARED.EMPTY_ARRAY,
+        categoryTables: SHARED.EMPTY_ARRAY,
+        categoryCompletionCounts: SHARED.EMPTY_ARRAY,
+        categorySeverities: SHARED.EMPTY_ARRAY
+      };
+    }
+
+    // Handle empty response - create a default category to show "No records found"
+    if (documentListResponse.length === 0) {
+      const defaultCategory = {
+        label: SHARED.EMPTY,
+        categoryDescription: SHARED.NO_DOCUMENTS_FOUND,
+        list: SHARED.EMPTY_ARRAY,
+        totalDocs: 0,
+        acceptedDocs: 0,
+        completed: '0/0'
+      };
+      
+      return {
+        documentCategories: [defaultCategory],
+        categoryTables: [this.documentTableBuilder.buildDocumentTable([])],
+        categoryCompletionCounts: ['0/0'],
+        categorySeverities: ['info']
+      };
+    }
+
+    const documentCategories = [...documentListResponse];
+    const categoryTables = documentListResponse.map(category => 
+      this.documentTableBuilder.buildDocumentTable(category.list)
+    );
+    const categoryCompletionCounts = documentListResponse.map(category => 
+      this.getCompletionCount(category)
+    );
+    
+    // Use the same severity calculation logic as menu items for consistency
+    const categorySeverities = documentListResponse.map(category => {
+      // Create a status object similar to what menu items use
+      const status = {
+        Pending: category.list.filter(doc => doc.status.toLowerCase() === SHARED.PENDING_STATUS).length,
+        Reviewing: category.list.filter(doc => doc.status.toLowerCase() === SHARED.REVIEWING_STATUS).length,
+        Accepted: category.list.filter(doc => doc.status.toLowerCase() === SHARED.APPROVED_STATUS || doc.status.toLowerCase() === SHARED.UPLOADED_STATUS).length,
+        Rejected: category.list.filter(doc => doc.status.toLowerCase() === SHARED.REJECTED_STATUS).length
+      };
+      
+      // Use the same severity calculation as menu items
+      const total = status.Pending + status.Reviewing + status.Accepted + status.Rejected;
+      if (total === 0) return 'info';
+      if (status.Pending > 0) return 'info';
+      if (status.Rejected > 0) return 'danger';
+      if (status.Reviewing > 0) return 'warning';
+      if (status.Accepted === total && total > 0) return 'success';
+      return 'warning';
+    });
+
+    return {
+      documentCategories,
+      categoryTables,
+      categoryCompletionCounts,
+      categorySeverities
+    };
+  }
+
+
+
+  /**
+   * Handle table row click
+   */
+  handleTableRowClick(rowData: any): DocumentListItem {
+    return rowData;
+  }
+
+  /**
+   * Handle delete action
+   */
+  handleDeleteAction(rowData: any, contextId: string): Observable<any> {
+    if (!rowData._id || !contextId) {
+      return throwError(() => new Error('Missing required parameters for delete'));
+    }
+
+    return this.documentHttpService.deleteDocument(rowData._id, contextId);
+  }
+
+  /**
+   * Refresh document list for new context
+   */
+  refreshDocumentListForNewContext(contextId: string): void {
+    if (contextId && contextId !== SHARED.EMPTY) {
+      this.documentStore.setDocumentListResponse(null);
+      this.documentHelperService.refreshDocumentsWithoutFilters(contextId);
+    }
+  }
+
+  /**
+   * Refresh document list after status update
+   */
+  refreshDocumentList(contextId: string): void {
+    if (contextId) {
+      this.documentHelperService.refreshDocumentsWithCurrentSelection(contextId);
+    }
+  }
+
+  /**
+   * Setup subscription to document list response
+   */
+  setupDocumentListSubscription(): Observable<DocumentListResponse[] | null> {
+    return this.documentQuery.selectDocumentListResponse();
+  }
+
+  /**
+   * Refresh all data with current filters
+   */
+  refreshAllDataWithCurrentFilters(contextId: string): void {
+    this.documentHelperService.refreshAllDataWithCurrentFilters(contextId);
+  }
+}