cat-documents-ng 1.0.4 → 1.0.6

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

@@ -0,0 +1,444 @@
+import { Injectable } from '@angular/core';
+import { DomSanitizer, SafeHtml } from '@angular/platform-browser';
+import { Observable, throwError } from 'rxjs';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { catchError, map } from 'rxjs/operators';
+
+/**
+ * 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
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class EmlParserService {
+
+  constructor(
+    private sanitizer: DomSanitizer,
+    private http: HttpClient
+  ) { }
+
+  /**
+   * Parses EML file content
+   * @param emlContent - Raw EML file content as string
+   * @returns Parsed email data
+   */
+  parseEmlData(emlContent: string): ParsedEmailData | null {
+    try {
+      const lines = emlContent.split(/\r?\n/);
+      const headers = this.parseHeaders(lines);
+      const body = this.parseBody(lines);
+
+      return {
+        from: this.cleanEmailAddress(headers['from'] || 'Unknown'),
+        to: this.cleanEmailAddress(headers['to'] || 'Unknown'),
+        cc: headers['cc'] ? this.cleanEmailAddress(headers['cc']) : undefined,
+        subject: this.decodeHeader(headers['subject'] || 'No Subject'),
+        date: this.formatDate(headers['date'] || ''),
+        body: body.content,
+        isHtml: body.isHtml,
+        attachments: this.parseAttachments(emlContent)
+      };
+    } catch (error) {
+      console.error('Error parsing EML file:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Parses email headers from EML content
+   * @param lines - Lines of the EML file
+   * @returns Object containing parsed headers
+   */
+  private parseHeaders(lines: string[]): { [key: string]: string } {
+    const headers: { [key: string]: string } = {};
+    let currentHeader = '';
+    let currentValue = '';
+
+    for (const line of lines) {
+      // Empty line indicates end of headers
+      if (line.trim() === '') {
+        if (currentHeader) {
+          headers[currentHeader.toLowerCase()] = currentValue.trim();
+        }
+        break;
+      }
+
+      // Check if line is a new header (starts without whitespace and contains ':')
+      if (line.match(/^[\w-]+:/) && !line.startsWith(' ') && !line.startsWith('\t')) {
+        // Save previous header if exists
+        if (currentHeader) {
+          headers[currentHeader.toLowerCase()] = currentValue.trim();
+        }
+
+        // Parse new header
+        const colonIndex = line.indexOf(':');
+        currentHeader = line.substring(0, colonIndex).trim();
+        currentValue = line.substring(colonIndex + 1).trim();
+      } else if (currentHeader && (line.startsWith(' ') || line.startsWith('\t'))) {
+        // Continuation of previous header (folded header)
+        currentValue += ' ' + line.trim();
+      }
+    }
+
+    return headers;
+  }
+
+  /**
+   * Parses the email body from EML content
+   * @param lines - Lines of the EML file
+   * @returns Object containing body content and format information
+   */
+  private parseBody(lines: string[]): { content: string, isHtml: boolean } {
+    let inBody = false;
+    let bodyLines: string[] = [];
+    let contentType = 'text/plain';
+    let boundary = '';
+    let isBase64 = false;
+    let isQuotedPrintable = false;
+
+    // Find Content-Type and boundary
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (line.toLowerCase().startsWith('content-type:')) {
+        contentType = line.toLowerCase().includes('text/html') ? 'text/html' : 'text/plain';
+        
+        // Check for multipart boundary
+        const boundaryMatch = line.match(/boundary="?([^";\s]+)"?/i);
+        if (boundaryMatch) {
+          boundary = boundaryMatch[1];
+        }
+      }
+
+      if (line.toLowerCase().startsWith('content-transfer-encoding:')) {
+        isBase64 = line.toLowerCase().includes('base64');
+        isQuotedPrintable = line.toLowerCase().includes('quoted-printable');
+      }
+
+      // Empty line marks start of body
+      if (line.trim() === '' && !inBody) {
+        inBody = true;
+        continue;
+      }
+
+      if (inBody) {
+        bodyLines.push(line);
+      }
+    }
+
+    // If multipart, extract the relevant part
+    if (boundary) {
+      bodyLines = this.extractMultipartBody(bodyLines.join('\n'), boundary, contentType);
+    }
+
+    let bodyContent = bodyLines.join('\n').trim();
+
+    // Decode body if necessary
+    if (isBase64) {
+      try {
+        bodyContent = atob(bodyContent.replace(/\s/g, ''));
+      } catch (e) {
+        console.warn('Failed to decode base64 content');
+      }
+    } else if (isQuotedPrintable) {
+      bodyContent = this.decodeQuotedPrintable(bodyContent);
+    }
+
+    // Clean up HTML if present
+    if (contentType === 'text/html') {
+      bodyContent = this.sanitizeHtmlContent(bodyContent);
+    }
+
+    return {
+      content: bodyContent || 'No content available',
+      isHtml: contentType === 'text/html'
+    };
+  }
+
+  /**
+   * 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(content: string, boundary: string, preferredType: string): string[] {
+    const parts = content.split('--' + boundary);
+    
+    for (const part of parts) {
+      const lines = part.split(/\r?\n/);
+      let partContentType = 'text/plain';
+      let isBase64 = false;
+      let isQuotedPrintable = false;
+      let inPartBody = false;
+      const partBodyLines: string[] = [];
+
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+
+        if (line.toLowerCase().startsWith('content-type:')) {
+          partContentType = line.toLowerCase().includes('text/html') ? 'text/html' : 'text/plain';
+        }
+
+        if (line.toLowerCase().startsWith('content-transfer-encoding:')) {
+          isBase64 = line.toLowerCase().includes('base64');
+          isQuotedPrintable = line.toLowerCase().includes('quoted-printable');
+        }
+
+        if (line.trim() === '' && !inPartBody) {
+          inPartBody = true;
+          continue;
+        }
+
+        if (inPartBody) {
+          partBodyLines.push(line);
+        }
+      }
+
+      // If this part matches our preferred content type, use it
+      if (partContentType === preferredType && partBodyLines.length > 0) {
+        let bodyContent = partBodyLines.join('\n');
+
+        if (isBase64) {
+          try {
+            bodyContent = atob(bodyContent.replace(/\s/g, ''));
+          } catch (e) {
+            console.warn('Failed to decode base64 part');
+          }
+        } else if (isQuotedPrintable) {
+          bodyContent = this.decodeQuotedPrintable(bodyContent);
+        }
+
+        return [bodyContent];
+      }
+    }
+
+    // Fallback: return first non-empty part
+    for (const part of parts) {
+      const lines = part.split(/\r?\n/);
+      const bodyLines = lines.filter(line => line.trim() !== '').slice(3); // Skip headers
+      if (bodyLines.length > 0) {
+        return bodyLines;
+      }
+    }
+
+    return [];
+  }
+
+  /**
+   * Decodes quoted-printable encoded content
+   * @param content - Quoted-printable encoded string
+   * @returns Decoded string
+   */
+  private decodeQuotedPrintable(content: string): string {
+    return content
+      .replace(/=\r?\n/g, '') // Remove soft line breaks
+      .replace(/=([0-9A-F]{2})/gi, (match, hex) => {
+        return String.fromCharCode(parseInt(hex, 16));
+      });
+  }
+
+  /**
+   * Sanitizes HTML content for safe display
+   * @param html - Raw HTML content
+   * @returns Sanitized HTML
+   */
+  private sanitizeHtmlContent(html: string): string {
+    // Basic sanitization - remove script tags and dangerous attributes
+    let sanitized = html
+      .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+      .replace(/on\w+\s*=\s*["'][^"']*["']/gi, '')
+      .replace(/javascript:/gi, '');
+
+    return sanitized;
+  }
+
+  /**
+   * Parses attachment information from EML content
+   * @param emlContent - Raw EML content
+   * @returns Array of attachment information
+   */
+  private parseAttachments(emlContent: string): EmailAttachment[] {
+    const attachments: EmailAttachment[] = [];
+    const attachmentRegex = /Content-Disposition:\s*attachment[^;]*;\s*filename="?([^"\r\n]+)"?/gi;
+    let match;
+
+    while ((match = attachmentRegex.exec(emlContent)) !== null) {
+      attachments.push({
+        filename: match[1],
+        contentType: 'application/octet-stream',
+        size: 0
+      });
+    }
+
+    return attachments;
+  }
+
+  /**
+   * Cleans and formats email addresses
+   * @param email - Raw email address string
+   * @returns Cleaned email address
+   */
+  private cleanEmailAddress(email: string): string {
+    // Remove quotes and extra whitespace
+    let cleaned = email.replace(/['"]/g, '').trim();
+    
+    // Extract email from format: "Name <email@example.com>"
+    const emailMatch = cleaned.match(/<([^>]+)>/);
+    if (emailMatch) {
+      const name = cleaned.substring(0, cleaned.indexOf('<')).trim();
+      const address = emailMatch[1];
+      return name ? `${name} <${address}>` : address;
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Decodes encoded email headers (RFC 2047)
+   * @param header - Encoded header string
+   * @returns Decoded header string
+   */
+  private decodeHeader(header: string): string {
+    // Decode RFC 2047 encoded words (=?charset?encoding?text?=)
+    return header.replace(/=\?([^?]+)\?([BQ])\?([^?]+)\?=/gi, (match, charset, encoding, text) => {
+      try {
+        if (encoding.toUpperCase() === 'B') {
+          // Base64 encoding
+          return atob(text);
+        } else if (encoding.toUpperCase() === 'Q') {
+          // Quoted-printable encoding
+          return this.decodeQuotedPrintable(text.replace(/_/g, ' '));
+        }
+      } catch (e) {
+        console.warn('Failed to decode header:', match);
+      }
+      return match;
+    });
+  }
+
+  /**
+   * Formats email date to readable format
+   * @param dateStr - Raw date string from email
+   * @returns Formatted date string
+   */
+  private formatDate(dateStr: string): string {
+    try {
+      const date = new Date(dateStr);
+      if (isNaN(date.getTime())) {
+        return dateStr || 'Unknown date';
+      }
+      return date.toLocaleString('en-GB', {
+        day: '2-digit',
+        month: 'short',
+        year: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit'
+      });
+    } catch (e) {
+      return dateStr || 'Unknown date';
+    }
+  }
+
+  /**
+   * Sanitizes HTML for Angular display
+   * @param html - HTML string
+   * @returns SafeHtml for Angular templates
+   */
+  getSafeHtml(html: string): SafeHtml {
+    return this.sanitizer.sanitize(1, html) || '';
+  }
+
+  /**
+   * 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> {
+    console.log('EmlParserService: Loading email from URL:', documentUrl);
+    
+    return this.downloadEmailFile(documentUrl).pipe(
+      map((emlContent: string) => {
+        console.log('EmlParserService: Email downloaded, size:', emlContent?.length || 0, 'bytes');
+        
+        if (!emlContent || emlContent.trim().length === 0) {
+          throw new Error('Email file is empty or could not be loaded');
+        }
+
+        const parsedData = this.parseEmlData(emlContent);
+        if (!parsedData) {
+          throw new Error('Failed to parse email data');
+        }
+
+        console.log('EmlParserService: Email parsed successfully:', parsedData);
+        return parsedData;
+      }),
+      catchError((error) => {
+        console.error('EmlParserService: Error loading/parsing email:', error);
+        return throwError(() => new Error(error.message || 'Failed to load or parse email file'));
+      })
+    );
+  }
+
+  /**
+   * Downloads an email file with appropriate authentication handling
+   * @param documentUrl - URL of the email file
+   * @returns Observable of file content as text
+   */
+  private downloadEmailFile(documentUrl: string): Observable<string> {
+    // Check if it's Azure Blob Storage URL
+    const isAzureBlobStorage = documentUrl.includes('.blob.core.windows.net');
+    
+    if (isAzureBlobStorage) {
+      // For Azure Blob Storage, don't send Authorization header
+      // The URL should contain a SAS token or the blob should be publicly accessible
+      return this.http.get(documentUrl, {
+        responseType: 'text'
+      }).pipe(
+        catchError((error) => {
+          console.error('Error downloading email from blob storage:', error);
+          return throwError(() => new Error('Failed to download email file. Please check if the file URL is valid and accessible.'));
+        })
+      );
+    } else {
+      // For other storage types, use Bearer token authentication
+      const Authorization = `Bearer d8764575-d713-4e31-aeb0-29ea31057461`;
+      return this.http.get(documentUrl, {
+        headers: new HttpHeaders({
+          'Authorization': Authorization
+        }),
+        responseType: 'text'
+      }).pipe(
+        catchError((error) => {
+          console.error('Error downloading email file:', error);
+          return throwError(() => new Error('Failed to download email file. Please check authentication.'));
+        })
+      );
+    }
+  }
+}
+

package/src/lib/document/services/excel-parser.service.spec.ts

@@ -0,0 +1,66 @@
+import { TestBed } from '@angular/core/testing';
+import { ExcelParserService } from './excel-parser.service';
+
+describe('ExcelParserService', () => {
+  let service: ExcelParserService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ExcelParserService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should convert RGB to hex correctly', () => {
+    // Test 6-character format
+    expect(service['rgbToHex']('ED7D31')).toBe('#ed7d31');
+    
+    // Test 8-character format
+    expect(service['rgbToHex']('FFFF0000')).toBe('#ff0000');
+    
+    // Test invalid input
+    expect(service['rgbToHex']('')).toBe('');
+    expect(service['rgbToHex']('12345')).toBe('');
+  });
+
+  it('should convert theme colors correctly', () => {
+    expect(service['themeToHex'](0)).toBe('#000000'); // Black
+    expect(service['themeToHex'](1)).toBe('#FFFFFF'); // White
+    expect(service['themeToHex'](2)).toBe('#FF0000'); // Red
+  });
+
+  it('should convert indexed colors correctly', () => {
+    expect(service['indexedToHex'](0)).toBe('#000000'); // Black
+    expect(service['indexedToHex'](1)).toBe('#FFFFFF'); // White
+    expect(service['indexedToHex'](64)).toBe('#ED7D31'); // Orange
+  });
+
+  it('should ensure data consistency', () => {
+    const testData = [
+      { cells: [{ value: 'A1' }, { value: 'B1' }] },
+      { cells: [{ value: 'A2' }] }
+    ];
+
+    const result = service.ensureDataConsistency(testData);
+    
+    expect(result.length).toBe(2);
+    expect(result[0].cells.length).toBe(3); // Padded to min 3 columns
+    expect(result[1].cells.length).toBe(3); // Padded to min 3 columns
+  });
+
+  it('should convert to legacy format', () => {
+    const testData = [
+      { cells: [{ value: 'A1' }, { value: 'B1' }] },
+      { cells: [{ value: 'A2' }, { value: 'B2' }] }
+    ];
+
+    const result = service.convertToLegacyFormat(testData);
+    
+    expect(result).toEqual([
+      ['A1', 'B1'],
+      ['A2', 'B2']
+    ]);
+  });
+});