cat-documents-ng 1.0.4 → 1.0.6

package/src/lib/document/services/csv-parser.service.ts

@@ -0,0 +1,303 @@
+import { Injectable } from '@angular/core';
+import { SHARED } from '../../../Shared/constant/SHARED';
+
+export interface CsvRowData {
+  cells: Array<{
+    value: string;
+    isHeader?: boolean;
+    style?: any;
+  }>;
+}
+
+export interface ParsedCsvData {
+  headers: string[];
+  rows: string[][];
+  styledData: CsvRowData[];
+  totalRows: number;
+  totalColumns: number;
+  hasHeaders: boolean;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CsvParserService {
+
+  constructor() { }
+
+  /**
+   * Parses CSV data from a string
+   * @param csvContent - The CSV content as a string
+   * @param options - Parsing options
+   * @returns Parsed CSV data
+   */
+  parseCsvData(csvContent: string, options: {
+    delimiter?: string;
+    hasHeaders?: boolean;
+    maxRows?: number;
+  } = {}): ParsedCsvData {
+    const {
+      delimiter = ',',
+      hasHeaders = true,
+      maxRows = 1000
+    } = options;
+
+    try {
+      // Split content into lines and filter out empty lines
+      const lines = csvContent
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line.length > 0);
+
+      if (lines.length === 0) {
+        return this.createEmptyCsvData();
+      }
+
+      // Parse each line
+      const parsedRows: string[][] = [];
+      let headers: string[] = [];
+
+      lines.forEach((line, index) => {
+        if (index >= maxRows) return;
+
+        const row = this.parseCsvLine(line, delimiter);
+        if (row.length > 0) {
+          parsedRows.push(row);
+        }
+      });
+
+      // Extract headers if specified
+      if (hasHeaders && parsedRows.length > 0) {
+        headers = parsedRows[0];
+        parsedRows.splice(0, 1); // Remove header row from data
+      } else if (parsedRows.length > 0) {
+        // Generate default headers if none provided
+        headers = parsedRows[0].map((_, index) => `Column ${index + 1}`);
+      }
+
+      // Create styled data for display
+      const styledData = this.createStyledData(headers, parsedRows, hasHeaders);
+
+      return {
+        headers,
+        rows: parsedRows,
+        styledData,
+        totalRows: parsedRows.length,
+        totalColumns: headers.length,
+        hasHeaders
+      };
+
+    } catch (error) {
+      console.error('Error parsing CSV data:', error);
+      return this.createEmptyCsvData();
+    }
+  }
+
+  /**
+   * Parses a single CSV line with proper handling of quoted fields
+   * @param line - Single CSV line
+   * @param delimiter - Field delimiter
+   * @returns Array of field values
+   */
+  private parseCsvLine(line: string, delimiter: string): string[] {
+    const result: string[] = [];
+    let current = '';
+    let inQuotes = false;
+    let i = 0;
+
+    while (i < line.length) {
+      const char = line[i];
+
+      if (char === '"') {
+        if (inQuotes && line[i + 1] === '"') {
+          // Escaped quote
+          current += '"';
+          i += 2;
+        } else {
+          // Toggle quote state
+          inQuotes = !inQuotes;
+          i++;
+        }
+      } else if (char === delimiter && !inQuotes) {
+        // End of field
+        result.push(current.trim());
+        current = '';
+        i++;
+      } else {
+        current += char;
+        i++;
+      }
+    }
+
+    // Add the last field
+    result.push(current.trim());
+
+    return result;
+  }
+
+  /**
+   * Creates styled data for display in tables
+   * @param headers - Column headers
+   * @param rows - Data rows
+   * @param hasHeaders - Whether the data has headers
+   * @returns Styled data array
+   */
+  private createStyledData(headers: string[], rows: string[][], hasHeaders: boolean): CsvRowData[] {
+    const styledData: CsvRowData[] = [];
+
+    // Add header row if headers exist
+    if (hasHeaders && headers.length > 0) {
+      styledData.push({
+        cells: headers.map(header => ({
+          value: header,
+          isHeader: true,
+          style: { fontWeight: 'bold', backgroundColor: '#f8f9fa' }
+        }))
+      });
+    }
+
+    // Add data rows
+    rows.forEach(row => {
+      styledData.push({
+        cells: row.map((cell, index) => ({
+          value: cell || '',
+          isHeader: false,
+          style: {}
+        }))
+      });
+    });
+
+    return styledData;
+  }
+
+  /**
+   * Creates empty CSV data structure
+   * @returns Empty CSV data
+   */
+  private createEmptyCsvData(): ParsedCsvData {
+    return {
+      headers: [],
+      rows: [],
+      styledData: [],
+      totalRows: 0,
+      totalColumns: 0,
+      hasHeaders: false
+    };
+  }
+
+  /**
+   * Validates CSV content
+   * @param csvContent - CSV content to validate
+   * @returns Validation result
+   */
+  validateCsvContent(csvContent: string): { isValid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!csvContent || csvContent.trim().length === 0) {
+      errors.push('CSV content is empty');
+      return { isValid: false, errors };
+    }
+
+    const lines = csvContent.split('\n').filter(line => line.trim().length > 0);
+    
+    if (lines.length === 0) {
+      errors.push('No valid lines found in CSV');
+      return { isValid: false, errors };
+    }
+
+    // Check for consistent column count
+    const columnCounts = lines.map(line => this.countColumns(line));
+    const firstColumnCount = columnCounts[0];
+    
+    for (let i = 1; i < columnCounts.length; i++) {
+      if (columnCounts[i] !== firstColumnCount) {
+        errors.push(`Line ${i + 1} has ${columnCounts[i]} columns, expected ${firstColumnCount}`);
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Counts columns in a CSV line
+   * @param line - CSV line
+   * @returns Number of columns
+   */
+  private countColumns(line: string): number {
+    let count = 0;
+    let inQuotes = false;
+    let i = 0;
+
+    while (i < line.length) {
+      const char = line[i];
+
+      if (char === '"') {
+        if (inQuotes && line[i + 1] === '"') {
+          i += 2;
+        } else {
+          inQuotes = !inQuotes;
+          i++;
+        }
+      } else if (char === ',' && !inQuotes) {
+        count++;
+        i++;
+      } else {
+        i++;
+      }
+    }
+
+    return count + 1; // +1 because we count delimiters, not fields
+  }
+
+  /**
+   * Exports data to CSV format
+   * @param data - Data to export
+   * @param headers - Column headers
+   * @param delimiter - Field delimiter
+   * @returns CSV string
+   */
+  exportToCsv(data: string[][], headers: string[], delimiter: string = ','): string {
+    const csvLines: string[] = [];
+
+    // Add headers if provided
+    if (headers && headers.length > 0) {
+      csvLines.push(this.escapeCsvField(headers.join(delimiter)));
+    }
+
+    // Add data rows
+    data.forEach(row => {
+      const escapedRow = row.map(field => this.escapeCsvField(field));
+      csvLines.push(escapedRow.join(delimiter));
+    });
+
+    return csvLines.join('\n');
+  }
+
+  /**
+   * Escapes a CSV field value
+   * @param field - Field value to escape
+   * @returns Escaped field value
+   */
+  private escapeCsvField(field: string): string {
+    if (field.includes(',') || field.includes('"') || field.includes('\n') || field.includes('\r')) {
+      return `"${field.replace(/"/g, '""')}"`;
+    }
+    return field;
+  }
+
+  /**
+   * Gets CSV preview (first few rows)
+   * @param csvContent - Full CSV content
+   * @param maxRows - Maximum number of rows to preview
+   * @returns Preview data
+   */
+  getCsvPreview(csvContent: string, maxRows: number = 10): ParsedCsvData {
+    const lines = csvContent.split('\n').filter(line => line.trim().length > 0);
+    const previewContent = lines.slice(0, maxRows + 1).join('\n'); // +1 for header
+    
+    return this.parseCsvData(previewContent, { maxRows });
+  }
+}

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

@@ -0,0 +1,125 @@
+import { Injectable } from '@angular/core';
+import { SHARED } from '../../../Shared/constant/SHARED';
+
+export interface DocumentAction {
+  type: typeof SHARED.REJECT_ACTION | typeof SHARED.ACCEPT_ACTION | typeof SHARED.DELETE_ACTION;
+  note?: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentActionsService {
+
+  /**
+   * Calculates the card class based on status
+   * @param currentStatus - The current status of the document
+   * @param statusId - The status ID from API
+   * @returns {string} The CSS class for the card
+   */
+  calculateCardClass(currentStatus?: string, statusId?: string): string {
+    // Use statusId if available, otherwise fall back to currentStatus
+    if (statusId) {
+      return `status-${statusId}-card`;
+    }
+    
+    if (!currentStatus) {
+      return SHARED.CARD_PENDING;
+    }
+    
+    const status = currentStatus.toLowerCase();
+    if (status === SHARED.STATUS_ACCEPTED.toLowerCase() || status === SHARED.STATUS_APPROVED.toLowerCase()) {
+      return SHARED.CARD_ACCEPTED;
+    } else if (status === SHARED.STATUS_REJECTED_LOWERCASE.toLowerCase() || status === SHARED.STATUS_REJECTED.toLowerCase()) {
+      return SHARED.CARD_REJECTED;
+    } else {
+      return SHARED.CARD_PENDING;
+    }
+  }
+
+  /**
+   * Calculates the reject button class based on status
+   * @param currentStatus - The current status of the document
+   * @param statusId - The status ID from API
+   * @returns {string} The CSS class for the reject button
+   */
+  calculateRejectButtonClass(currentStatus?: string, statusId?: string): string {
+    // Use statusId if available, otherwise fall back to currentStatus
+    if (statusId) {
+      return `status-${statusId}-reject`;
+    }
+    
+    if (!currentStatus) {
+      return SHARED.BUTTON_DEFAULT_REJECT;
+    }
+    
+    const status = currentStatus.toLowerCase();
+    if (status === SHARED.STATUS_ACCEPTED.toLowerCase() || status === SHARED.STATUS_APPROVED.toLowerCase()) {
+      return SHARED.BUTTON_SECONDARY_REJECT;
+    } else if (status === SHARED.STATUS_REJECTED_LOWERCASE.toLowerCase() || status === SHARED.STATUS_REJECTED.toLowerCase()) {
+      return SHARED.BUTTON_PRIMARY_REJECT;
+    } else {
+      return SHARED.BUTTON_DEFAULT_REJECT;
+    }
+  }
+
+  /**
+   * Calculates the accept button class based on status
+   * @param currentStatus - The current status of the document
+   * @param statusId - The status ID from API
+   * @returns {string} The CSS class for the accept button
+   */
+  calculateAcceptButtonClass(currentStatus?: string, statusId?: string): string {
+    // Use statusId if available, otherwise fall back to currentStatus
+    if (statusId) {
+      return `status-${statusId}-accept`;
+    }
+    
+    if (!currentStatus) {
+      return SHARED.BUTTON_DEFAULT_ACCEPT;
+    }
+    
+    const status = currentStatus.toLowerCase();
+    if (status === SHARED.STATUS_ACCEPTED.toLowerCase() || status === SHARED.STATUS_APPROVED.toLowerCase()) {
+      return SHARED.BUTTON_PRIMARY_ACCEPT;
+    } else if (status === SHARED.STATUS_REJECTED_LOWERCASE.toLowerCase() || status === SHARED.STATUS_REJECTED.toLowerCase()) {
+      return SHARED.BUTTON_SECONDARY_ACCEPT;
+    } else {
+      return SHARED.BUTTON_DEFAULT_ACCEPT;
+    }
+  }
+
+  /**
+   * Creates an accept action
+   * @param note - The acceptance note
+   * @returns {DocumentAction} The accept action
+   */
+  createAcceptAction(note: string): DocumentAction {
+    return {
+      type: SHARED.ACCEPT_ACTION as 'accept',
+      note: note
+    };
+  }
+
+  /**
+   * Creates a reject action
+   * @param note - The rejection note
+   * @returns {DocumentAction} The reject action
+   */
+  createRejectAction(note: string): DocumentAction {
+    return {
+      type: SHARED.REJECT_ACTION as 'reject',
+      note: note
+    };
+  }
+
+  /**
+   * Creates a delete action
+   * @returns {DocumentAction} The delete action
+   */
+  createDeleteAction(): DocumentAction {
+    return {
+      type: SHARED.DELETE_ACTION as 'delete'
+    };
+  }
+} 

package/src/lib/document/services/document-content-type.service.ts

@@ -0,0 +1,193 @@
+import { Injectable } from '@angular/core';
+
+/**
+ * Service for handling document content types and their mappings.
+ * Supports the content types: "xlsx","xls","doc","docx","pdf","jpg","jpeg","odt","csv","png","msg","eml"
+ * @class DocumentContentTypeService
+ * @typedef {DocumentContentTypeService}
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class DocumentContentTypeService {
+
+  /**
+   * Mapping of file extensions to MIME types
+   * @type {Record<string, string>}
+   */
+  private readonly extensionToMimeType: Record<string, string> = {
+    'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'xls': 'application/vnd.ms-excel',
+    'doc': 'application/msword',
+    'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'pdf': 'application/pdf',
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'odt': 'application/vnd.oasis.opendocument.text',
+    'csv': 'text/csv',
+    'png': 'image/png',
+    'msg': 'application/vnd.ms-outlook',
+    'eml': 'message/rfc822'
+  };
+
+  /**
+   * Mapping of MIME types to file extensions
+   * @type {Record<string, string>}
+   */
+  private readonly mimeTypeToExtension: Record<string, string> = {
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+    'application/vnd.ms-excel': 'xls',
+    'application/msword': 'doc',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+    'application/pdf': 'pdf',
+    'image/jpeg': 'jpg',
+    'image/jpg': 'jpg',
+    'application/vnd.oasis.opendocument.text': 'odt',
+    'text/csv': 'csv',
+    'image/png': 'png',
+    'application/vnd.ms-outlook': 'msg',
+    'message/rfc822': 'eml'
+  };
+
+  /**
+   * List of all supported file extensions
+   * @type {string[]}
+   */
+  readonly supportedExtensions: string[] = [
+    'xlsx', 'xls', 'doc', 'docx', 'pdf', 'jpg', 'jpeg', 'odt', 'csv', 'png', 'msg', 'eml'
+  ];
+
+  /**
+   * List of all supported MIME types
+   * @type {string[]}
+   */
+  readonly supportedMimeTypes: string[] = [
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/vnd.ms-excel',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/pdf',
+    'image/jpeg',
+    'image/jpg',
+    'application/vnd.oasis.opendocument.text',
+    'text/csv',
+    'image/png',
+    'application/vnd.ms-outlook',
+    'message/rfc822'
+  ];
+
+  /**
+   * Gets the MIME type for a given file extension
+   * @param {string} extension - The file extension (with or without dot)
+   * @returns {string | undefined} The MIME type or undefined if not supported
+   */
+  getMimeType(extension: string): string | undefined {
+    const cleanExtension = extension.replace('.', '').toLowerCase();
+    return this.extensionToMimeType[cleanExtension];
+  }
+
+  /**
+   * Gets the file extension for a given MIME type
+   * @param {string} mimeType - The MIME type
+   * @returns {string | undefined} The file extension or undefined if not supported
+   */
+  getExtension(mimeType: string): string | undefined {
+    return this.mimeTypeToExtension[mimeType];
+  }
+
+  /**
+   * Checks if a file extension is supported
+   * @param {string} extension - The file extension (with or without dot)
+   * @returns {boolean} True if the extension is supported
+   */
+  isExtensionSupported(extension: string): boolean {
+    const cleanExtension = extension.replace('.', '').toLowerCase();
+    return this.supportedExtensions.includes(cleanExtension);
+  }
+
+  /**
+   * Checks if a MIME type is supported
+   * @param {string} mimeType - The MIME type
+   * @returns {boolean} True if the MIME type is supported
+   */
+  isMimeTypeSupported(mimeType: string): boolean {
+    return this.supportedMimeTypes.includes(mimeType);
+  }
+
+  /**
+   * Gets the file extension from a filename
+   * @param {string} filename - The filename
+   * @returns {string | undefined} The file extension or undefined if no extension found
+   */
+  getExtensionFromFilename(filename: string): string | undefined {
+    if (!filename || !filename.includes('.')) {
+      return undefined;
+    }
+    const parts = filename.split('.');
+    return parts[parts.length - 1].toLowerCase();
+  }
+
+  /**
+   * Gets the MIME type from a filename
+   * @param {string} filename - The filename
+   * @returns {string | undefined} The MIME type or undefined if not supported
+   */
+  getMimeTypeFromFilename(filename: string): string | undefined {
+    const extension = this.getExtensionFromFilename(filename);
+    return extension ? this.getMimeType(extension) : undefined;
+  }
+
+  /**
+   * Validates if a file can be uploaded based on its extension
+   * @param {string} filename - The filename to validate
+   * @returns {boolean} True if the file can be uploaded
+   */
+  canUploadFile(filename: string): boolean {
+    const extension = this.getExtensionFromFilename(filename);
+    return extension ? this.isExtensionSupported(extension) : false;
+  }
+
+  /**
+   * Gets a human-readable description for a content type
+   * @param {string} contentType - The content type (MIME type or extension)
+   * @returns {string} Human-readable description
+   */
+  getContentTypeDescription(contentType: string): string {
+    // Check if it's a MIME type first
+    if (this.isMimeTypeSupported(contentType)) {
+      const extension = this.getExtension(contentType);
+      return this.getExtensionDescription(extension || 'unknown');
+    }
+    
+    // Check if it's an extension
+    if (this.isExtensionSupported(contentType)) {
+      return this.getExtensionDescription(contentType);
+    }
+    
+    return 'Unknown Document Type';
+  }
+
+  /**
+   * Gets a human-readable description for a file extension
+   * @param {string} extension - The file extension
+   * @returns {string} Human-readable description
+   */
+  private getExtensionDescription(extension: string): string {
+    const descriptions: Record<string, string> = {
+      'xlsx': 'Excel Spreadsheet (XLSX)',
+      'xls': 'Excel Spreadsheet (XLS)',
+      'doc': 'Word Document (DOC)',
+      'docx': 'Word Document (DOCX)',
+      'pdf': 'PDF Document',
+      'jpg': 'JPEG Image',
+      'jpeg': 'JPEG Image',
+      'odt': 'OpenDocument Text',
+      'csv': 'CSV File',
+      'png': 'PNG Image',
+      'msg': 'Outlook Message',
+      'eml': 'Email Message'
+    };
+    
+    return descriptions[extension] || 'Unknown File Type';
+  }
+}