cat-documents-ng 1.0.6 → 1.0.7

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

@@ -1,444 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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']
-    ]);
-  });
-});