cat-documents-ng 1.0.6 → 1.0.7

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

@@ -1,483 +0,0 @@
-import { Injectable } from '@angular/core';
-import * as XLSX from 'xlsx';
-import { SHARED } from '../../../Shared/constant/SHARED';
-/**
- * Interface for Excel cell styling information
- */
-export interface ExcelCellStyle {
-  backgroundColor?: string;
-  fontColor?: string;
-  bold?: boolean;
-  italic?: boolean;
-  border?: {
-    top?: string;
-    bottom?: string;
-    left?: string;
-    right?: string;
-  };
-}
-
-/**
- * Interface for Excel cell data with styling
- */
-export interface ExcelCellData {
-  value: any;
-  style?: ExcelCellStyle;
-}
-
-/**
- * Interface for Excel row data
- */
-export interface ExcelRowData {
-  cells: ExcelCellData[];
-}
-
-/**
- * Interface for parsed Excel data
- */
-export interface ParsedExcelData {
-  sheets: string[];
-  currentSheet: string;
-  styledData: ExcelRowData[];
-  tableData: any[][];
-  hasStyling: boolean;
-  workbook: XLSX.WorkBook;
-}
-
-/**
- * Service for parsing Excel files and extracting styling information
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class ExcelParserService {
-
-  private workbookColors: { [key: number]: string } = {};
-
-  /**
-   * Parses Excel data from ArrayBuffer
-   */
-  parseExcelData(data: ArrayBuffer): ParsedExcelData | null {
-    try {
-      const workbook = this.createWorkbook(data);
-      
-      // Extract color palette from workbook
-      this.extractWorkbookColors(workbook);
-      
-      const sheets = this.getSheetNames(workbook);
-      const currentSheet = this.getFirstSheet(sheets);
-      const styledData = this.parseSheetData(workbook, currentSheet);
-      const tableData = this.convertToLegacyFormat(styledData);
-      const hasStyling = this.hasWorkbookStyling(workbook);
-
-      return {
-        sheets,
-        currentSheet,
-        styledData,
-        tableData,
-        hasStyling,
-        workbook
-      };
-    } catch (error) {
-      console.error('Error parsing Excel data:', error);
-      return null;
-    }
-  }
-
-  /**
-   * Creates workbook from ArrayBuffer
-   */
-  private createWorkbook(data: ArrayBuffer): XLSX.WorkBook {
-    return XLSX.read(data, {
-      type: 'array',
-      cellStyles: true,
-      cellDates: true,
-      cellNF: false,
-      cellHTML: false
-    });
-  }
-
-  /**
-   * Gets sheet names from workbook
-   */
-  private getSheetNames(workbook: XLSX.WorkBook): string[] {
-    return workbook.SheetNames;
-  }
-
-  /**
-   * Gets the first sheet name
-   */
-  private getFirstSheet(sheets: string[]): string {
-    return sheets[0] || 'Sheet1';
-  }
-
-  /**
-   * Parses sheet data with styling
-   */
-  parseSheetData(workbook: XLSX.WorkBook, sheetName: string): ExcelRowData[] {
-    try {
-      const worksheet = this.getWorksheet(workbook, sheetName);
-      if (!worksheet) {
-        return this.createNoDataRow();
-      }
-
-      const range = this.getWorksheetRange(worksheet);
-      return this.processWorksheetRows(worksheet, range);
-    } catch (error) {
-      console.error('Error parsing sheet data:', error);
-      return this.createErrorRow();
-    }
-  }
-
-  /**
-   * Gets worksheet from workbook
-   */
-  private getWorksheet(workbook: XLSX.WorkBook, sheetName: string): XLSX.WorkSheet | null {
-    return workbook.Sheets[sheetName] || null;
-  }
-
-  /**
-   * Gets worksheet range
-   */
-  private getWorksheetRange(worksheet: XLSX.WorkSheet): XLSX.Range {
-    return XLSX.utils.decode_range(worksheet['!ref'] || 'A1');
-  }
-
-  /**
-   * Processes worksheet rows
-   */
-  private processWorksheetRows(worksheet: XLSX.WorkSheet, range: XLSX.Range): ExcelRowData[] {
-    const styledData: ExcelRowData[] = [];
-
-    for (let row = range.s.r; row <= range.e.r; row++) {
-      const rowData = this.processRow(worksheet, range, row);
-      if (this.hasRowContent(rowData)) {
-        styledData.push(rowData);
-      }
-    }
-
-    return styledData;
-  }
-
-  /**
-   * Processes a single row
-   */
-  private processRow(worksheet: XLSX.WorkSheet, range: XLSX.Range, rowIndex: number): ExcelRowData {
-    const rowData: ExcelRowData = { cells: [] };
-
-    for (let col = range.s.c; col <= range.e.c; col++) {
-      const cell = this.getCell(worksheet, rowIndex, col);
-      const cellData = this.createCellData(cell);
-      rowData.cells.push(cellData);
-    }
-
-    return rowData;
-  }
-
-  /**
-   * Gets cell from worksheet
-   */
-  private getCell(worksheet: XLSX.WorkSheet, row: number, col: number): XLSX.CellObject | null {
-    const cellAddress = XLSX.utils.encode_cell({ r: row, c: col });
-    return worksheet[cellAddress] || null;
-  }
-
-  /**
-   * Creates cell data with styling
-   */
-  private createCellData(cell: XLSX.CellObject | null): ExcelCellData {
-    if (!cell) {
-      return { value: SHARED.EMPTY };
-    }
-
-    return {
-      value: cell.v || SHARED.EMPTY,
-      style: this.extractCellStyle(cell)
-    };
-  }
-
-  /**
-   * Checks if row has content
-   */
-  private hasRowContent(rowData: ExcelRowData): boolean {
-    return rowData.cells.some(cell => cell.value !== SHARED.EMPTY);
-  }
-
-  /**
-   * Creates no data row
-   */
-  private createNoDataRow(): ExcelRowData[] {
-    return [{ cells: [{ value: SHARED.NO_DATA_FOUND }] }];
-  }
-
-  /**
-   * Creates error row
-   */
-  private createErrorRow(): ExcelRowData[] {
-    return [{ cells: [{ value: SHARED.ERROR_PARSING_SHEET_DATA }] }];
-  }
-
-  /**
-   * Extracts styling from cell
-   */
-  extractCellStyle(cell: XLSX.CellObject): ExcelCellStyle | undefined {
-    if (!cell.s) return undefined;
-
-    const style: ExcelCellStyle = {};
-    
-    this.extractBackgroundColor(cell.s, style);
-    this.extractFontColor(cell.s, style);
-    this.extractFontFormatting(cell.s, style);
-    this.extractBorders(cell.s, style);
-
-    return Object.keys(style).length > 0 ? style : undefined;
-  }
-
-  /**
-   * Extracts background color
-   */
-  private extractBackgroundColor(cellStyle: any, style: ExcelCellStyle): void {
-    if (cellStyle.fgColor) {
-      console.log('Found fgColor:', cellStyle.fgColor);
-      style.backgroundColor = this.getColorValue(cellStyle.fgColor);
-      if (style.backgroundColor) {
-        console.log('Extracted background color from fgColor:', style.backgroundColor);
-      }
-    }
-
-    if (!style.backgroundColor && cellStyle.bgColor) {
-      console.log('Found bgColor:', cellStyle.bgColor);
-      style.backgroundColor = this.getColorValue(cellStyle.bgColor);
-      if (style.backgroundColor) {
-        console.log('Extracted background color from bgColor:', style.backgroundColor);
-      }
-    }
-  }
-
-  /**
-   * Extracts font color
-   */
-  private extractFontColor(cellStyle: any, style: ExcelCellStyle): void {
-    if (cellStyle.font?.color) {
-      console.log('Found font color:', cellStyle.font.color);
-      style.fontColor = this.getColorValue(cellStyle.font.color);
-      if (style.fontColor) {
-        console.log('Extracted font color:', style.fontColor);
-      }
-    }
-  }
-
-  /**
-   * Extracts font formatting
-   */
-  private extractFontFormatting(cellStyle: any, style: ExcelCellStyle): void {
-    if (cellStyle.font?.bold) {
-      style.bold = true;
-    }
-    if (cellStyle.font?.italic) {
-      style.italic = true;
-    }
-  }
-
-  /**
-   * Extracts borders
-   */
-  private extractBorders(cellStyle: any, style: ExcelCellStyle): void {
-    if (!cellStyle.border) return;
-
-    style.border = {};
-    const borders = ['top', 'bottom', 'left', 'right'] as const;
-    
-    borders.forEach(side => {
-      const border = cellStyle.border[side];
-      if (border?.color) {
-        style.border![side] = this.getColorValue(border.color);
-      }
-    });
-  }
-
-  /**
-   * Gets color value from color object
-   */
-  private getColorValue(colorObj: any): string | undefined {
-    
-    if (colorObj.rgb) {
-      const result = this.rgbToHex(colorObj.rgb);
-      return result;
-    }
-    if (colorObj.theme !== undefined) {
-      const result = this.extractThemeColor(colorObj.theme);
-      return result;
-    }
-    if (colorObj.indexed !== undefined) {
-      const result = this.extractIndexedColor(colorObj.indexed);
-      return result;
-    }
-    return undefined;
-  }
-
-  /**
-   * Converts RGB to hex
-   */
-  private rgbToHex(rgb: string): string {
-    if (!rgb) return SHARED.EMPTY;
-
-    if (rgb.length === 8) {
-      // Excel RGB format: AARRGGBB (Alpha, Red, Green, Blue)
-      const red = parseInt(rgb.substring(2, 4), 16);
-      const green = parseInt(rgb.substring(4, 6), 16);
-      const blue = parseInt(rgb.substring(6, 8), 16);
-      return `#${red.toString(16).padStart(2, '0')}${green.toString(16).padStart(2, '0')}${blue.toString(16).padStart(2, '0')}`;
-    } else if (rgb.length === 6) {
-      // Standard hex format: RRGGBB
-      return `#${rgb}`;
-    }
-
-    return SHARED.EMPTY;
-  }
-
-  /**
-   * Extracts theme color dynamically from Excel
-   */
-  private extractThemeColor(theme: number): string {
-    const baseThemeColors: { [key: number]: string } = {
-      0: '#000000', // Black
-      1: '#FFFFFF', // White
-      2: '#FF0000', // Red
-      3: '#00FF00', // Green
-      4: '#0000FF', // Blue
-      5: '#FFFF00', // Yellow
-      6: '#FF00FF', // Magenta
-      7: '#00FFFF', // Cyan
-    };
-    
-    return baseThemeColors[theme] || this.generateThemeColor(theme);
-  }
-
-  /**
-   * Generates a theme color based on index (fallback)
-   */
-  private generateThemeColor(theme: number): string {
-    // Generate a color based on the theme index
-    // This is a fallback when we don't have the actual theme colors
-    const hue = (theme * 137.508) % 360; // Golden angle approximation
-    return `hsl(${hue}, 70%, 50%)`;
-  }
-
-  /**
-   * Extracts indexed color dynamically from Excel
-   */
-  private extractIndexedColor(indexed: number): string {
-    // Instead of hardcoded colors, we'll try to extract the actual color
-    // from the Excel file's color palette
-    if (this.workbookColors && this.workbookColors[indexed]) {
-      return this.rgbToHex(this.workbookColors[indexed]);
-    }
-    
-    // Fallback to a generated color if we don't have the palette
-    return this.generateIndexedColor(indexed);
-  }
-
-  /**
-   * Generates an indexed color based on index (fallback)
-   */
-  private generateIndexedColor(indexed: number): string {
-    // Generate a color based on the indexed number
-    // This ensures we always have a unique color for each index
-    const hue = (indexed * 25) % 360;
-    const saturation = 60 + (indexed % 20);
-    const lightness = 40 + (indexed % 30);
-    return `hsl(${hue}, ${saturation}%, ${lightness}%)`;
-  }
-
-  /**
-   * Extracts color palette from Excel workbook
-   */
-  private extractWorkbookColors(workbook: XLSX.WorkBook): void {
-    this.workbookColors = {};
-    
-    // Try to extract colors from the workbook's color palette
-    const workbookProps = workbook.Workbook as any;
-    if (workbookProps && workbookProps.Colors) {
-      const colors = workbookProps.Colors;
-      if (colors.IndexedColors) {
-        colors.IndexedColors.forEach((color: any, index: number) => {
-          if (color.rgb) {
-            this.workbookColors[index] = color.rgb;
-          }
-        });
-      }
-    }
-    
-    // Also try to extract from theme
-    if (workbookProps && workbookProps.Theme) {
-      const theme = workbookProps.Theme;
-      if (theme.ThemeElements && theme.ThemeElements.ClrScheme) {
-        const clrScheme = theme.ThemeElements.ClrScheme;
-        // Extract theme colors if available
-        Object.keys(clrScheme).forEach((key, index) => {
-          const color = clrScheme[key];
-          if (color && color.SrgbClr) {
-            this.workbookColors[index] = color.SrgbClr.val;
-          }
-        });
-      }
-    }
-    
-    console.log('Extracted workbook colors:', this.workbookColors);
-  }
-
-  /**
-   * Checks if workbook has styling
-   */
-  hasWorkbookStyling(workbook: XLSX.WorkBook): boolean {
-    for (const sheetName of workbook.SheetNames) {
-      const worksheet = workbook.Sheets[sheetName];
-      if (worksheet && this.hasWorksheetStyling(worksheet)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Checks if worksheet has styling
-   */
-  private hasWorksheetStyling(worksheet: XLSX.WorkSheet): boolean {
-    for (const cellAddress in worksheet) {
-      if (cellAddress.startsWith('!')) continue;
-      const cell = worksheet[cellAddress];
-      if (cell?.s) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
-   * Converts styled data to legacy format
-   */
-  convertToLegacyFormat(styledData: ExcelRowData[]): any[][] {
-    return styledData.map(row => row.cells.map(cell => cell.value));
-  }
-
-  /**
-   * Ensures data consistency
-   */
-  ensureDataConsistency(styledData: ExcelRowData[]): ExcelRowData[] {
-    if (styledData.length === 0) {
-      return [{ cells: [{ value: 'No data found' }] }];
-    }
-
-    const maxColumns = Math.max(...styledData.map(row => row.cells.length));
-    const minColumns = Math.max(maxColumns, 3);
-
-    return styledData.map(row => {
-      const normalizedRow: ExcelRowData = { cells: [...row.cells] };
-      while (normalizedRow.cells.length < minColumns) {
-        normalizedRow.cells.push({ value: SHARED.EMPTY });
-      }
-      return normalizedRow;
-    });
-  }
-}

package/src/lib/document/services/file-format.service.spec.ts

@@ -1,16 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-
-import { FileFormatService } from './file-format.service';
-
-describe('FileFormatService', () => {
-  let service: FileFormatService;
-
-  beforeEach(() => {
-    TestBed.configureTestingModule({});
-    service = TestBed.inject(FileFormatService);
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-});

package/src/lib/document/services/file-format.service.ts

@@ -1,63 +0,0 @@
-import { Injectable } from '@angular/core';
-import { SHARED } from '../../../Shared/constant/SHARED';
-import { PrimeNGConfig } from 'primeng/api';
-
-/**
- * Description placeholder
- * @class FileFormatService
- * @typedef {FileFormatService}
- */
-@Injectable({
-  providedIn: 'root'
-})
-export class FileFormatService {
-
-  /**
-   * Creates an instance of FileFormatService.
-   * @constructor
-   */
-  constructor() { }
-
-    /**
-     * Description placeholder
-     * @param {number} bytes
-     * @param {PrimeNGConfig} config
-     * @returns {string}
-     */
-    formatFileSize(bytes: number, config:PrimeNGConfig): string {
-      const kilobyte = 1024;
-      const decimalPlaces = SHARED.ONE;
-      const sizes = config.translation.fileSizeTypes || SHARED.FILE_SIZE_UNITS;
-      if (bytes < kilobyte) {
-        return `${bytes} ${sizes[SHARED.INITIAL_COUNT]}`;
-      } else if (bytes < kilobyte * kilobyte) {
-        const kbSize = bytes / kilobyte;
-        return `${parseFloat(kbSize.toFixed(decimalPlaces))} ${sizes[SHARED.ONE]}`;
-      } else {
-        const mbSize = bytes / (kilobyte * kilobyte);
-        return `${parseFloat(mbSize.toFixed(decimalPlaces))} ${sizes[SHARED.TWO]}`;
-      }
-    }
-
-    /**
-     * Validates if a file has an allowed extension
-     * @param fileName - The name of the file to validate
-     * @returns True if the file extension is allowed, false otherwise
-     */
-    isAllowedFileType(fileName: string): boolean {
-      const allowedExtensions = SHARED.FILE_TYPES;
-      
-      const fileExtension = fileName.toLowerCase().split('.').pop();
-      return fileExtension ? allowedExtensions.includes(fileExtension) : false;
-    }
-
-    /**
-     * Gets the list of allowed file extensions
-     * @returns Array of allowed file extensions
-     */
-    getAllowedFileExtensions(): string[] {
-      return SHARED.FILE_TYPES;
-    }
-
-
-}

package/src/lib/document/services/status-calculator.service.ts

@@ -1,44 +0,0 @@
-import { Injectable } from '@angular/core';
-import { SHARED } from '../../../Shared/constant/SHARED';
-
-export interface StatusData {
-  status: string;
-  count: number;
-  color?: string;
-  icon?: string;
-  _id?: string;
-}
-
-export interface CalculatedStatusData extends StatusData {
-  percentage: number;
-  isSelected: boolean;
-  statusClass: string;
-  iconClass: string;
-}
-
-@Injectable({
-  providedIn: 'root'
-})
-export class StatusCalculatorService {
-
-  calculateTotalCount(statusData: StatusData[]): number {
-    return statusData?.reduce((total, status) => total + (status.count ?? 0), 0) || 0;
-  }
-
-  calculateStatusDataWithPercentages(
-    statusData: StatusData[], 
-    selectedStatus: string | null
-  ): CalculatedStatusData[] {
-    if (!statusData) return [];
-    
-    const totalCount = this.calculateTotalCount(statusData);
-    
-    return statusData.map((status) => ({
-      ...status,
-      percentage: totalCount > 0 ? (status.count ?? 0) / totalCount * 100 : 0,
-      isSelected: selectedStatus === status.status,
-      statusClass: status.status ? SHARED.STATUS_WITH_DASH + status.status.toLowerCase() : SHARED.EMPTY,
-      iconClass: SHARED.ICON_WITH_DASH + (status?.status?.toLowerCase() || SHARED.EMPTY)
-    }));
-  }
-} 

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

@@ -1,77 +0,0 @@
-import { Injectable } from '@angular/core';
-import { UserListModel } from '../models/user-list.model';
-import { SHARED } from '../../../Shared/constant/SHARED'
-import { DocumentStore } from '../state/document.store';
-import { DocumentQuery } from '../state/document.query';
-import { DocumentCategory } from '../models/document-category.model';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class UserListService {
-
-  constructor(
-    private documentStore: DocumentStore,
-    private documentQuery: DocumentQuery
-  ) { }
-
-  getInitials(name: string): string {
-    if (!name || name.trim() === SHARED.EMPTY) {
-      return SHARED.EMPTY;
-    }
-    const words = name.trim().split(SHARED.EMPTY_SPACE).filter(word => word.length > SHARED.INITIAL_COUNT);
-    if (words.length === 1) {
-      return words[0].substring(0, 2).toUpperCase();
-    } else if (words.length >= 2) {
-      const firstWord = words[0];
-      const lastWord = words[words.length - 1];
-      return (firstWord.charAt(0) + lastWord.charAt(0)).toUpperCase();
-    }
-    return SHARED.EMPTY;
-  }
-
-  getColorByIndex(index: number): string {
-    const colors = SHARED.COLORS;
-    return colors[index % colors.length];
-  }
-
-  getColorValue(colorName: string): string {
-    const colorMap: { [key: string]: string } = SHARED.COLOR_MAP;
-    return colorMap[colorName] || SHARED.DEFAULT_COLOR;
-  }
-
-  processUserData(userList: UserListModel[]): UserListModel[] {
-    return userList.map((user, index) => ({
-      ...user,
-      initials: this.getInitials(user.name),
-      color: this.getColorByIndex(index)
-    }));
-  }
-
-  /**
-   * Filters user list based on selected menu item category
-   * @param userList - The complete user list
-   * @param categories - The document categories
-   * @returns Filtered user list
-   */
-  filterUsersByCategory(userList: UserListModel[], categories: DocumentCategory[]): UserListModel[] {
-    return userList;
-  }
-
-  selectUser(userId: string, userData: UserListModel[]): { selectedUser: string | undefined; name: string | undefined } {
-    const user = userData.find(u => u._id === userId);
-    if (user) {
-      this.documentStore.setSelectedUserId(userId);
-      return { selectedUser: user.name, name: user.name };
-    }
-    return { selectedUser: undefined, name: undefined };
-  }
-
-  unselectUser(): void {
-    this.documentStore.setSelectedUserId(null);
-  }
-
-  isUserSelected(userId: string, userData: UserListModel[], selectedUser: string | undefined): boolean {
-    return selectedUser === userData.find(u => u._id === userId)?.name;
-  }
-}