cat-documents-ng 1.0.3 → 1.0.4

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

@@ -0,0 +1,99 @@
+import { EventEmitter } from '@angular/core';
+import { DocumentService } from '../state/document.service';
+import { DocumentStore } from '../state/document.store';
+import { MessageService } from 'primeng/api';
+import * as i0 from "@angular/core";
+/**
+ * Service for handling document uploads.
+ * @class DocumentUploadService
+ * @typedef {DocumentUploadService}
+ */
+export declare class DocumentUploadService {
+    documentService: DocumentService;
+    documentUploadStore: DocumentStore;
+    messageService: MessageService;
+    /**
+     * Event emitter for upload completion
+     */
+    uploadCompleted: EventEmitter<{
+        file: File;
+        response: any;
+    }>;
+    /**
+     * The file to upload.
+     * @type {*}
+     */
+    uploadedFile: any;
+    /**
+     * Represent contextId
+     * @type {string}
+     */
+    contextId: string;
+    /**
+     * Represent document name
+     * @type {string}
+     */
+    docName: string;
+    /**
+     * Represent document id
+     * @type {string}
+     */
+    docTypeId: string;
+    /**
+     * 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(documentService: DocumentService, documentUploadStore: DocumentStore, messageService: MessageService);
+    /**
+     * Prepares the files for upload by creating a FormData object.
+     * This method appends each file to the FormData for submission.
+     * @returns {Promise<any>} Promise that resolves when upload completes
+     */
+    handleTemplatedUpload(file: File, contextId: string): Promise<any>;
+    /**
+     * Uploads multiple files sequentially using promises
+     * @param files - Array of files to upload
+     * @param contextId - The context ID for upload
+     * @returns {Promise<any[]>} Promise that resolves with all upload responses
+     */
+    uploadFilesSequentially(files: File[], contextId: string): Promise<any[]>;
+    /**
+     * Alternative method to upload files sequentially with progress tracking
+     * @param files - Array of files to upload
+     * @param contextId - The context ID for upload
+     * @param onProgress - Optional callback for progress updates
+     * @returns {Promise<any[]>} Promise that resolves with all upload responses
+     */
+    uploadFilesSequentiallyWithProgress(files: File[], contextId: string, onProgress?: (currentFile: File, currentIndex: number, totalFiles: number) => void): Promise<any[]>;
+    /**
+     * Get the file and contextId
+     * @param file - The file to upload.
+     * @param contextId - The contextId to upload.
+     */
+    getUploadFileData(file: File, contextId: string): void;
+    /**
+     * 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): void;
+    /**
+     * Handle the creation of formdata.
+     * @returns {*} - The formdata object.
+     */
+    handleCreateFormData(uploadedFile?: File, contextId?: string): FormData | null;
+    /**
+     * Generic method to sort any list of objects by a specified property.
+     * Supports fallback properties if the primary property is undefined.
+     * @param list - Array of objects to sort
+     * @param primaryProperty - Primary property to sort by
+     * @param fallbackProperty - Optional fallback property if primary is undefined
+     * @returns Sorted array
+     */
+    sortListByProperty<T>(list: T[], primaryProperty: keyof T, fallbackProperty?: keyof T): T[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentUploadService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentUploadService>;
+}

package/lib/document/services/document-viewer.service.d.ts

@@ -0,0 +1,97 @@
+import { Observable } from 'rxjs';
+import { DocumentHttpService } from './document-http.service';
+import { DocumentHelperService } from './document.service';
+import { DocumentListItem } from '../models/document-list-response.model';
+import { DocumentHistorySection } from '../models/document-history.model';
+import { DocumentAction } from './document-actions.service';
+import { MessageService } from 'primeng/api';
+import { DocumentStore } from '../state/document.store';
+import { DocumentQuery } from '../state/document.query';
+import * as i0 from "@angular/core";
+export interface DocumentViewerState {
+    selectedDocument?: DocumentListItem;
+    documentHistory: DocumentHistorySection[];
+    showDocumentHistory: boolean;
+    isActionLoading: boolean;
+    documentStatus: 'pending' | 'accepted' | 'rejected';
+    documentIsUploaded: boolean;
+    alertData: any;
+    deleteError: any;
+    deleteSuccess: boolean;
+}
+export declare class DocumentViewerService {
+    private documentHttpService;
+    private documentService;
+    private messageService;
+    private documentStore;
+    private documentQuery;
+    constructor(documentHttpService: DocumentHttpService, documentService: DocumentHelperService, messageService: MessageService, documentStore: DocumentStore, documentQuery: DocumentQuery);
+    /**
+     * Gets the current document viewer state as an observable
+     */
+    get state$(): Observable<DocumentViewerState>;
+    /**
+     * Gets the current document viewer state synchronously
+     */
+    getCurrentState(): DocumentViewerState;
+    /**
+     * Updates the selected document and recalculates all computed properties
+     * @param document The selected document
+     */
+    updateSelectedDocument(document: DocumentListItem, skipLoadDocumentHistory?: boolean): void;
+    /**
+     * Loads document history data
+     * @param documentId The document ID
+     */
+    loadDocumentHistory(documentId: string): void;
+    /**
+     * Determines if the given content type is an image
+     * @param contentType The MIME type of the content
+     * @returns True if the content type is an image
+     */
+    isImage(contentType?: string): boolean;
+    /**
+     * Handles document actions and updates status
+     * @param action The action performed
+     * @param contextId The context ID for API calls
+     */
+    handleDocumentAction(action: DocumentAction, contextId?: string): void;
+    /**
+     * Updates the document status via API call and refreshes all related data
+     * @param status The new status (Approved, Rejected)
+     * @param description The status update description
+     * @param contextId The context ID for API calls
+     */
+    private updateDocumentStatus;
+    /**
+     * Deletes a document without immediate refresh - refresh will happen when viewer is closed
+     * @param documentId The ID of the document to delete
+     * @param contextId The context ID for API calls
+     */
+    private deleteDocument;
+    /**
+     * Refreshes all related data after document status update
+     * @param contextId The context ID for API calls
+     */
+    private refreshAllData;
+    /**
+     * Gets alert data for the document
+     * @param document The document
+     * @returns Alert data
+     */
+    private getAlertData;
+    /**
+     * Calculates the current status of the document for the actions component
+     * @param document The document
+     * @returns The current document status
+     */
+    private calculateDocumentStatus;
+    /**
+     * Calculates if the document is uploaded and ready for actions
+     * @param document The document
+     * @returns True if document is uploaded
+     */
+    private calculateIsDocumentUploaded;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentViewerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentViewerService>;
+}

package/lib/document/services/document-zoom.service.d.ts

@@ -0,0 +1,81 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface ZoomConfig {
+    defaultZoom: number;
+    zoomStep: number;
+    minZoom: number;
+    maxZoom: number;
+}
+export declare class DocumentZoomService {
+    private readonly DEFAULT_CONFIG;
+    private zoomLevelSubject;
+    private config;
+    /**
+     * Gets the current zoom level as an observable
+     */
+    get zoomLevel$(): Observable<number>;
+    /**
+     * Gets the current zoom level value
+     */
+    get currentZoom(): number;
+    /**
+     * Gets the current zoom configuration
+     */
+    get zoomConfig(): ZoomConfig;
+    /**
+     * Sets custom zoom configuration
+     */
+    setZoomConfig(config: Partial<ZoomConfig>): void;
+    /**
+     * Zooms in by the configured step
+     */
+    zoomIn(): void;
+    /**
+     * Zooms out by the configured step
+     */
+    zoomOut(): void;
+    /**
+     * Sets zoom to a specific level
+     */
+    setZoom(zoom: number): void;
+    /**
+     * Resets zoom to default level
+     */
+    resetZoom(): void;
+    /**
+     * Handles mouse wheel zoom
+     */
+    handleWheelZoom(event: WheelEvent, zoomFactor?: number): void;
+    /**
+     * Applies zoom transform to an iframe element
+     * @param iframe - The iframe element to apply zoom to
+     * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+     */
+    applyIframeZoom(iframe: HTMLIFrameElement, zoomLevel?: number): void;
+    /**
+     * Applies zoom transform to multiple iframe elements
+     * @param iframes - Array of iframe elements to apply zoom to
+     * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+     */
+    applyIframeZoomToMultiple(iframes: HTMLIFrameElement[], zoomLevel?: number): void;
+    /**
+     * Applies zoom transform to iframes within a container element
+     * @param container - The container element to search for iframes
+     * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+     */
+    applyIframeZoomToContainer(container: HTMLElement, zoomLevel?: number): void;
+    /**
+     * Applies zoom transform to iframes within multiple container elements
+     * @param containers - Array of container elements to search for iframes
+     * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+     */
+    applyIframeZoomToContainers(containers: HTMLElement[], zoomLevel?: number): void;
+    /**
+     * Applies zoom transform to iframes by CSS selector
+     * @param selector - CSS selector to find iframe containers
+     * @param zoomLevel - The zoom level to apply (defaults to current zoom)
+     */
+    applyIframeZoomBySelector(selector: string, zoomLevel?: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentZoomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentZoomService>;
+}

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

@@ -0,0 +1,161 @@
+import { Observable } from "rxjs";
+import { DocumentModel } from "../models/document.model";
+import { DocumentStore } from "../state/document.store";
+import { DocumentQuery } from "../state/document.query";
+import { DocumentHttpService } from "./document-http.service";
+import { DocumentMenuService } from "./document-menu.service";
+import * as i0 from "@angular/core";
+/**
+ * Service to manage the document data and selection state
+ */
+export declare class DocumentHelperService {
+    private documentStore;
+    private documentQuery;
+    private documentHttpService;
+    private documentMenuService;
+    private selectionWatcherSubscription;
+    constructor(documentStore: DocumentStore, documentQuery: DocumentQuery, documentHttpService: DocumentHttpService, documentMenuService: DocumentMenuService);
+    /**
+     * Initialize watcher for selection state changes
+     * @param contextId - The context ID to use for API calls
+     */
+    initializeSelectionWatcher(contextId: string): void;
+    /**
+     * Initialize watcher for selection state changes with initial load
+     * @param contextId - The context ID to use for API calls
+     */
+    initializeSelectionWatcherWithInitialLoad(contextId: string): void;
+    /**
+     * Clean up the selection watcher subscription
+     */
+    cleanupSelectionWatcher(): void;
+    /**
+     * Set the document data
+     * @param document the document data
+     */
+    set(document: DocumentModel | null): void;
+    /**
+     * Get the document data
+     * @returns the document data
+     */
+    get(): Observable<DocumentModel | null>;
+    /**
+     * Get the current document value synchronously
+     * @returns the current document value
+     */
+    getValue(): DocumentModel | null;
+    /**
+     * Set the selected menu item
+     * @param menuItem the selected menu item _id (not the label)
+     */
+    setSelectedMenuItem(menuItem: string | null): void;
+    /**
+     * Set the selected user ID
+     * @param userId the selected user ID
+     */
+    setSelectedUserId(userId: string | null): void;
+    /**
+     * Set the selected status
+     * @param status the selected status
+     */
+    setSelectedStatus(status: string | null): void;
+    /**
+     * Set the search key
+     * @param searchKey the search term
+     */
+    setSearchKey(searchKey: string | null): void;
+    /**
+     * Set all selection state at once
+     * @param menuItem the selected menu item _id (not the label)
+     * @param userId the selected user ID
+     * @param status the selected status
+     * @param searchKey the search term
+     */
+    setSelectionState(menuItem: string | null, userId: string | null, status: string | null, searchKey?: string | null): void;
+    /**
+     * Clear all selection state
+     */
+    clearSelectionState(): void;
+    /**
+     * Set user list visibility
+     * @param show whether to show the user list
+     */
+    setShowUserList(show: boolean): void;
+    /**
+     * Get the current selection state
+     * @returns observable of the current selection state
+     */
+    getSelectionState(): Observable<{
+        menuItem: string | null;
+        userId: string | null;
+        status: string | null;
+    }>;
+    /**
+     * Get the current selection state value synchronously
+     * @returns the current selection state value
+     */
+    getSelectionStateValue(): {
+        menuItem: string | null;
+        userId: string | null;
+        status: string | null;
+    };
+    /**
+     * Set status data in the store
+     * @param statusData the status data to set
+     */
+    setStatusData(statusData: any[]): void;
+    /**
+     * Set user list in the store
+     * @param userList the user list to set
+     */
+    setUserList(userList: any[]): void;
+    /**
+     * Get observable for filtered documents
+     * @returns Observable that emits filtered document responses
+     */
+    getFilteredDocuments(): Observable<any>;
+    /**
+     * Manually trigger API call with current selection state
+     * @param contextId - The context ID to use for the API call
+     */
+    refreshDocumentsWithCurrentSelection(contextId: string): void;
+    /**
+     * Force refresh documents with no filters
+     * @param contextId - The context ID to use for the API call
+     */
+    refreshDocumentsWithoutFilters(contextId: string): void;
+    /**
+     * Refresh status data for a specific context
+     * @param contextId - The context ID to use for the API call
+     * @param statusContextId - The status context ID (usually userId)
+     * @param categoryId - The category ID (usually menuItem)
+     */
+    refreshStatusData(contextId: string, statusContextId: string | null, categoryId: string | null): void;
+    /**
+     * Refresh all data with current filters after accept/reject/delete operations
+     * This includes document categories, status data, user list, and document list
+     *
+     * This method ensures that after a document action (accept/reject/delete):
+     * 1. Document categories are refreshed
+     * 2. Status counts are refreshed with current user filters
+     * 3. User list is refreshed with current filters (if applicable)
+     * 4. Document list is refreshed with current filters (user, status, search)
+     *
+     * Filter application:
+     * - Document categories: Uses base contextId
+     * - Status data: Uses userId as contextId (no category filtering)
+     * - User list: Uses base contextId (can be enhanced with additional filters if API supports)
+     * - Document list: Uses current filters (userId, status, searchKey)
+     *
+     * @param contextId - The context ID to use for the API calls
+     */
+    refreshAllDataWithCurrentFilters(contextId: string): void;
+    /**
+     * Checks if the currently selected menu item's section is visible in the filtered document list
+     * and deselects it if not visible
+     * @param contextId - The context ID to use for API calls
+     */
+    checkAndDeselectMenuItemIfSectionNotVisible(contextId: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DocumentHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DocumentHelperService>;
+}

package/lib/document/services/eml-parser.service.d.ts

@@ -0,0 +1,116 @@
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { Observable } from 'rxjs';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+/**
+ * Interface for parsed email data
+ */
+export interface ParsedEmailData {
+    from: string;
+    to: string;
+    cc?: string;
+    subject: string;
+    date: string;
+    body: string;
+    isHtml: boolean;
+    attachments?: EmailAttachment[];
+}
+/**
+ * Interface for email attachments
+ */
+export interface EmailAttachment {
+    filename: string;
+    contentType: string;
+    size: number;
+}
+/**
+ * Service for parsing EML (email message) files
+ * Handles both plain text and HTML email content
+ */
+export declare class EmlParserService {
+    private sanitizer;
+    private http;
+    constructor(sanitizer: DomSanitizer, http: HttpClient);
+    /**
+     * Parses EML file content
+     * @param emlContent - Raw EML file content as string
+     * @returns Parsed email data
+     */
+    parseEmlData(emlContent: string): ParsedEmailData | null;
+    /**
+     * Parses email headers from EML content
+     * @param lines - Lines of the EML file
+     * @returns Object containing parsed headers
+     */
+    private parseHeaders;
+    /**
+     * Parses the email body from EML content
+     * @param lines - Lines of the EML file
+     * @returns Object containing body content and format information
+     */
+    private parseBody;
+    /**
+     * Extracts body from multipart email
+     * @param content - Email content
+     * @param boundary - Multipart boundary string
+     * @param preferredType - Preferred content type
+     * @returns Array of body lines
+     */
+    private extractMultipartBody;
+    /**
+     * Decodes quoted-printable encoded content
+     * @param content - Quoted-printable encoded string
+     * @returns Decoded string
+     */
+    private decodeQuotedPrintable;
+    /**
+     * Sanitizes HTML content for safe display
+     * @param html - Raw HTML content
+     * @returns Sanitized HTML
+     */
+    private sanitizeHtmlContent;
+    /**
+     * Parses attachment information from EML content
+     * @param emlContent - Raw EML content
+     * @returns Array of attachment information
+     */
+    private parseAttachments;
+    /**
+     * Cleans and formats email addresses
+     * @param email - Raw email address string
+     * @returns Cleaned email address
+     */
+    private cleanEmailAddress;
+    /**
+     * Decodes encoded email headers (RFC 2047)
+     * @param header - Encoded header string
+     * @returns Decoded header string
+     */
+    private decodeHeader;
+    /**
+     * Formats email date to readable format
+     * @param dateStr - Raw date string from email
+     * @returns Formatted date string
+     */
+    private formatDate;
+    /**
+     * Sanitizes HTML for Angular display
+     * @param html - HTML string
+     * @returns SafeHtml for Angular templates
+     */
+    getSafeHtml(html: string): SafeHtml;
+    /**
+     * Downloads and parses an EML file from a URL
+     * @param documentUrl - URL of the EML file
+     * @returns Observable of parsed email data
+     */
+    loadAndParseEmail(documentUrl: string): Observable<ParsedEmailData>;
+    /**
+     * Downloads an email file with appropriate authentication handling
+     * @param documentUrl - URL of the email file
+     * @returns Observable of file content as text
+     */
+    private downloadEmailFile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmlParserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EmlParserService>;
+}