data-grid-workspace 0.0.120

package/backup-04112025/projects/data-grid/src/lib/services/common.service.ts

@@ -0,0 +1,278 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CommonService {
+
+  constructor() { }
+  gethasVisibleColumns(columns: any[]): boolean {
+    const checkVisible = (columns: any[]): boolean => {
+      return columns.some((col) => {
+        if (col?.is_visible) return true;
+        if (col?.children?.length) {
+          return checkVisible(col.children);
+        }
+        return false;
+      });
+    };
+    return checkVisible(columns);
+  }
+
+  gethasInVisibleColumns(columns: any[]): boolean {
+    const checkVisible = (columns: any[]): boolean => {
+      return columns.some((col) => {
+        if (!col?.is_visible) return true;
+        if (col?.children?.length) {
+          return checkVisible(col.children);
+        }
+        return false;
+      });
+    };
+    return checkVisible(columns);
+  }
+
+
+  getTotalColumnsLength(columns: any[]): number {
+    let count = 0;
+
+    columns.forEach(col => {
+      if (col.children && Array.isArray(col.children) && col.children.length) {
+        count += col.children.length; // count children instead of parent
+      } else {
+        count += 1; // count parent directly
+      }
+    });
+
+    return count;
+  }
+
+  gethasRightPinnedColumns(columns: any[]): boolean {
+    const checkPinnedRight = (columns: any[]): boolean => {
+      return columns.some((col) => {
+        if (col?.pinned === 'right' && col?.is_visible) return true;
+        if (col?.children?.length) {
+          return checkPinnedRight(col.children);
+        }
+        return false;
+      });
+    };
+    return checkPinnedRight(columns);
+  }
+
+  gethasLeftPinnedColumns(columns: any[]): boolean {
+    const checkPinnedRight = (columns: any[]): boolean => {
+      return columns.some((col) => {
+        if (col?.pinned === 'left' && col?.is_visible) return true;
+        if (col?.children?.length) {
+          return checkPinnedRight(col.children);
+        }
+        return false;
+      });
+    };
+    return checkPinnedRight(columns);
+  }
+
+
+  getExpandedRowCount(data: any[]): number {
+    let groupCount = 0;
+    let rowCount = 0;
+
+    data.forEach(group => {
+      if (group?.isGroup) {
+        groupCount++;
+
+        if (group?.isExpand && Array.isArray(group?.children)) {
+          group.children.forEach((child: any) => {
+            if (child.isGroup) {
+              if (child.isExpand && Array.isArray(child.children)) {
+                rowCount += child.children.length;
+              }
+            } else {
+              rowCount++;
+            }
+          });
+        }
+      }
+    });
+
+    if (groupCount === 0) {
+      return data.length;
+    }
+
+    return groupCount + rowCount;
+  }
+
+
+getFiltersFromColumns(columns: any[], filtersConfig:any []): any[] {
+  const result: any[] = [];
+  
+  const checkColumn = (col: any) => {
+     if (col.query?.condition === 'none') {
+      col.query.second_value = null;
+      col.query.second_condition = null;
+    }
+    const hasFirstValue = col.query?.first_value != null && col.query?.first_value !== "" && filtersConfig.some((ele)=> ele.field == col.field);
+    const hasIds = Array.isArray(col.query?._ids) && col.query._ids.length > 0 && filtersConfig.some((ele)=> ele.field == col.field);
+    if (hasFirstValue || hasIds) {
+      result.push({
+        search: col.search ?? "",
+        field: col.field,
+        type: col.type,
+        _ids: col.type == 'dropdown'? col.query?._ids: [],
+        query: col.type == 'dropdown'? null : (col?.query?.first_value ? col?.query : null)
+      });
+    }
+ 
+    if (Array.isArray(col.children) && col.children.length > 0) {
+      col.children.forEach(checkColumn);
+    }
+  };
+  columns.forEach(checkColumn);
+ 
+  return result;
+}
+
+async applyFiltersToColumns(columns: any[], filters: any[]): Promise<any[]> {
+  for (const col of columns) {
+    if (!col.query) {
+      col.query = {
+        first_value: null,
+        second_value: null,
+        first_condition: col.type !== 'date' ? 'contain' : 'equal',
+        second_condition: null,
+        condition: 'none',
+        _ids: []
+      };
+    }
+
+    const filter = filters.find(f => f.field === col.field);
+
+    if (filter) {
+      if (col.type === 'dropdown') {
+        const selectedIds = filter._ids ?? [];
+        const dropdownValues = col.column_dropdown_value ?? [];
+
+        // ✅ Map depending on dropdown value structure
+        let selectedLabels: string[] = [];
+
+        if (Array.isArray(dropdownValues) && dropdownValues.length > 0) {
+          if (typeof dropdownValues[0] === 'object') {
+            // object-based dropdowns: { id, name/label/value/text }
+            selectedLabels = dropdownValues
+              .filter(opt => selectedIds.includes(opt.id))
+              .map(opt => opt.name ?? opt.label ?? opt.value ?? opt.text ?? '');
+          } else {
+            // string-based dropdowns
+            selectedLabels = dropdownValues.filter(opt => selectedIds.includes(opt));
+          }
+        }
+
+        // ✅ Store readable text in filterValue (comma-separated)
+        col.filterValue = selectedLabels.join(', ');
+
+        // maintain query state
+        col.query._ids = selectedIds;
+        col.search = filter.search ?? '';
+
+      } else {
+        // ✅ Non-dropdown filters (text/date/number)
+        col.filterValue = filter.search || filter.query?.first_value || '';
+        col.search = filter.search ?? '';
+        col.query.first_value = filter.query?.first_value ?? null;
+        col.query.second_value = filter.query?.second_value ?? null;
+        col.query.first_condition =
+          filter.query?.first_condition ??
+          (col.type !== 'date' ? 'contain' : 'equal');
+        col.query.second_condition = filter.query?.second_condition ?? null;
+        col.query.condition = filter.query?.condition ?? 'none';
+      }
+    } else {
+      // Clear filter if not present
+      col.filterValue = null;
+      col.search = '';
+      col.query._ids = [];
+      col.query.first_value = null;
+    }
+
+    // ✅ Recursively apply for children
+    if (Array.isArray(col.children) && col.children.length > 0) {
+      col.children = await this.applyFiltersToColumns(col.children, filters);
+    }
+  }
+
+  return columns;
+}
+
+
+
+
+
+
+activeFilteredColumns: any[] = [];
+updateActiveFilteredColumns(columns: any[]): any[] {
+  const collectFiltered = (cols: any[]): any[] => {
+    let result: any[] = [];
+
+    for (let i = 0; i < cols.length; i++) {
+      const col = cols[i];
+      if (col.children && col.children.length > 0) {
+        result = result.concat(collectFiltered(col.children));
+      }
+
+      if (col.query) {
+        const hasDropdownFilter =
+          Array.isArray(col.query._ids) && col.query._ids.length > 0;
+
+        const hasValueFilter =
+          (col.query.first_value && col.query.first_value !== '') ||
+          (col.query.second_value && col.query.second_value !== '');
+
+        if (hasDropdownFilter || hasValueFilter) {
+          result.push(col);
+        }
+      }
+    }
+    return result;
+  };
+  this.activeFilteredColumns = [...collectFiltered(columns)];
+  return this.activeFilteredColumns;
+}
+
+
+
+hasFieldChanged(current: any, original: any, type: string): boolean {
+    switch (type) {
+      case 'number':
+        return Number(current) !== Number(original);
+
+      case 'string':
+        return String(current || '') !== String(original || '');
+
+      case 'dropdown':
+        if (typeof current === 'object' && typeof original === 'object') {
+          return current?.id !== original?.id || current?.value !== original?.value;
+        }
+        return current !== original;
+
+      case 'boolean':
+        return Boolean(current) !== Boolean(original);
+
+      case 'date':
+        const currentDate = new Date(current).getTime();
+        const originalDate = new Date(original).getTime();
+        return isNaN(currentDate) || isNaN(originalDate)
+          ? current !== original
+          : currentDate !== originalDate;
+
+      default:
+        return JSON.stringify(current) !== JSON.stringify(original);
+    }
+  }
+
+
+}
+
+
+
+

package/backup-04112025/projects/data-grid/src/lib/services/copy-service.service.spec.ts

@@ -0,0 +1,16 @@
+/* tslint:disable:no-unused-variable */
+
+import { TestBed, async, inject } from '@angular/core/testing';
+import { CopyServiceService } from './copy-service.service';
+
+describe('Service: CopyService', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [CopyServiceService]
+    });
+  });
+
+  it('should ...', inject([CopyServiceService], (service: CopyServiceService) => {
+    expect(service).toBeTruthy();
+  }));
+});

package/backup-04112025/projects/data-grid/src/lib/services/copy-service.service.ts

@@ -0,0 +1,252 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CopyServiceService {
+
+  constructor() { }
+  getSelectedDataForCopy(
+    dataSet: any[],
+    columns: any[],
+    rowSelectedIndexes: Set<number>,
+    selectedCells: any[],
+    getNestedValue: (obj: any, path: string) => any
+  ): any[][] {
+    columns = columns.filter(col => col.is_visible);
+    const copiedRows: any[][] = [];
+    const findRowByVirtualIndex = (vIndex: number) =>
+      dataSet.find((r: any) => r.__virtualIndex === vIndex);
+    if (rowSelectedIndexes && rowSelectedIndexes.size > 0) {
+      const sortedIndexes = [...rowSelectedIndexes].sort((a, b) => a - b);
+      for (const vIndex of sortedIndexes) {
+        const row = findRowByVirtualIndex(vIndex);
+        if (!row) continue;
+        const extractValue = (field: string): string => {
+          const nested = getNestedValue(row, field);
+          const value =
+            nested?.value ??
+            nested?.name ??
+            nested ??
+            '-';
+
+          if (Array.isArray(value)) {
+            return value
+              .map(v =>
+                typeof v === 'object'
+                  ? (v.departmentName ?? v.roleName ?? '')
+                  : (v?.toString() ?? '')
+              )
+              .join(', ');
+          }
+          return value ?? '';
+        };
+        const mapped = columns.map(col => {
+          if (col.children && Array.isArray(col.children)) {
+            return col.children.map((c: { field: string }) => extractValue(c.field));
+          }
+          return [extractValue(col.field)];
+        });
+        const rowValues = mapped.reduce<string[]>((acc, curr) => acc.concat(curr), []);
+        copiedRows.push(rowValues);
+      }
+    }
+    if (selectedCells && selectedCells.length > 0) {
+      const rowsMap = new Map<number, any[]>();
+      for (const cell of selectedCells) {
+        const row = findRowByVirtualIndex(cell.rowIndex);
+        if (!row) continue;
+        const col = columns[cell.colIndex];
+        let fieldName = col?.field;
+        if (col?.children && col.children[cell.subColIndex]) {
+          fieldName = col.children[cell.subColIndex].field;
+        }
+        let value = getNestedValue(row, fieldName) || getNestedValue(row, fieldName)?.name || getNestedValue(row, fieldName) || '-';
+        if (Array.isArray(value)) {
+          value = value
+            .map(v =>
+              typeof v === 'object'
+                ? v.departmentName ?? v.roleName ?? v.full_name ?? ''
+                : v?.toString() ?? ''
+            )
+            .join(', ');
+        } else {
+          value = value ?? '';
+        }
+        if (!rowsMap.has(cell.rowIndex)) rowsMap.set(cell.rowIndex, []);
+        rowsMap.get(cell.rowIndex)!.push(value);
+      }
+      const sortedCells = [...rowsMap.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([_, v]) => v);
+      copiedRows.push(...sortedCells);
+    }
+    if (copiedRows.length === 0) {
+      const activeCell = document.querySelector('.active-cell');
+      if (activeCell) return [[activeCell.textContent?.trim() || '']];
+    }
+
+    const maxCols = copiedRows.reduce((max, row) => Math.max(max, row.length), 0);
+    return copiedRows.map(row => {
+      const newRow = [...row];
+      while (newRow.length < maxCols) newRow.push('');
+      return newRow;
+    });
+  }
+
+
+  copyToClipboard(
+    selectedData: any[][],
+    selector = '.selected-cell, .active-cell, .row-selected'
+  ): void {
+    if (!selectedData || selectedData.length === 0) return;
+    const textToCopy = selectedData
+      .map(row => row.map(cell => (cell ?? '').toString()).join('\t'))
+      .join('\n');
+    navigator.clipboard.writeText(textToCopy).catch(err => console.error(err));
+    const selectedEls = document.querySelectorAll(selector);
+    selectedEls.forEach(el => el.classList.add('flash-bg'));
+    setTimeout(() => {
+      selectedEls.forEach(el => el.classList.remove('flash-bg'));
+    }, 1000);
+  }
+
+
+updateRows: any[] = [];
+  currentColums : any = []
+  async pasteFromClipboardText(
+    text: string,
+    dataSet: any[],
+    columns: any[],
+    startRowIndex: number,
+    startColIndex: number,
+    startSubColIndex: number = 0
+  ): Promise<any> {
+    if (!text) return [];
+    this.updateRows = [];
+    const rows = text.split(/\r?\n/).map(r => r.split('\t'));
+    const flattenedColumns: any[] = [];
+    columns.forEach(col => {
+      if (col.children?.length) {
+        col.children.forEach((child: any) => flattenedColumns.push({ parent: col, ...child }));
+      } else {
+        flattenedColumns.push(col);
+      }
+    });
+    let startFlattenedIndex = 0;
+    for (let i = 0; i < startColIndex; i++) {
+      const col = columns[i];
+      startFlattenedIndex += col.children?.length || 1;
+    }
+    const startCol = columns[startColIndex];
+    if (startCol?.children?.length) {
+      startFlattenedIndex += Math.min(startSubColIndex, startCol.children.length - 1);
+    }
+ 
+    rows.forEach((rowValues, rOffset) => {
+      const targetRowIndex = startRowIndex + rOffset;
+      const row = dataSet.find(r => r?.__virtualIndex === targetRowIndex);
+      if (!row) return;
+ 
+      rowValues.forEach((value, cOffset) => {
+        const targetIndex = startFlattenedIndex + cOffset;
+        if (targetIndex < 0 || targetIndex >= flattenedColumns.length) return;
+ 
+        const targetColumn = flattenedColumns[targetIndex];
+        if(!targetColumn || !targetColumn.is_editable) return;
+         if (targetColumn?.type === 'string') {
+          this.currentColums.push(targetColumn);
+            this.setNestedValue(row, targetColumn, value);
+          } else if (targetColumn.type === 'number') {
+            const num = Number(value);
+            if (!isNaN(num) && value !== '') {
+              this.currentColums.push(targetColumn);
+              this.setNestedValue(row, targetColumn, num);
+            }
+          }
+      });
+    });
+ 
+    return {updateRows : this.updateRows, currentColums : this.currentColums};
+  }
+
+
+  setNestedValue(obj: any, column: any, option: any, calledFromInput = false): void {
+    if (column.type === 'date' || column.type === 'image') return;
+    const path = column.field;
+    if (!path) return;
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    const parent = keys.reduce((acc: any, key: string) => (acc[key] ??= {}), obj);
+    if (parent && lastKey) {
+      if (typeof option === 'object' && option !== null) {
+        parent[lastKey] = {
+          id: option.id ?? 1,
+          value: option.value ?? option,
+        };
+      } else {
+        parent[lastKey] = option;
+      }
+    }
+    const sendObj = {
+      data: { ...obj },
+      eventType: 'onCellEdit',
+    };
+    this.updateRows.push(obj);
+  }
+
+
+  cutSelectedSelectedData(
+    dataSet: any[],
+    rowSelectedIndexes: Set<number>,
+    selectedCells: any[],
+    columns: any[],
+    setNestedValue: (obj: any, column: any, value: any) => void
+  ): any {
+    let updatedData = [...dataSet];
+    if (rowSelectedIndexes?.size) {
+      const indexes = [...rowSelectedIndexes];
+      updatedData = updatedData.filter(
+        (row: any) => !indexes.includes(row.__virtualIndex)
+      );
+      // rowSelectedIndexes.clear();
+    }
+    else if (selectedCells?.length) {
+      this.updateRows = [];
+      for (const cell of selectedCells) {
+        const row = updatedData.find(r => r.__virtualIndex === cell.rowIndex);
+        if (!row) continue;
+        let col = columns[cell.colIndex];
+        if (col?.children && col.children[cell.subColIndex]) {
+          col = col.children[cell.subColIndex];
+        }
+        this.setNestedValue(row, col, '');
+      }
+      // selectedCells.length = 0;
+    }
+    return {updatedData: updatedData, updatedRows: this.updateRows};
+  }
+
+
+  cutWithAnimation(
+    selectedData: any[][],
+    selector = '.selected-cell, .active-cell, .row-selected'
+  ): void {
+    if (!selectedData || selectedData.length === 0) return;
+
+    const textToCopy = selectedData
+      .map(row => row.map(cell => (cell ?? '').toString()).join('\t'))
+      .join('\n');
+
+    navigator.clipboard.writeText(textToCopy).catch(err => console.error(err));
+
+    // Apply red cut animation
+    const selectedEls = document.querySelectorAll(selector);
+    selectedEls.forEach(el => el.classList.add('cut-flash-bg'));
+    setTimeout(() => {
+      selectedEls.forEach(el => el.classList.remove('cut-flash-bg'));
+    }, 1000);
+  }
+
+
+}

package/backup-04112025/projects/data-grid/src/lib/services/drag-drp.service.spec.ts

@@ -0,0 +1,16 @@
+/* tslint:disable:no-unused-variable */
+
+import { TestBed, async, inject } from '@angular/core/testing';
+import { DragDrpService } from './drag-drp.service';
+
+describe('Service: DragDrp', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [DragDrpService]
+    });
+  });
+
+  it('should ...', inject([DragDrpService], (service: DragDrpService) => {
+    expect(service).toBeTruthy();
+  }));
+});

package/backup-04112025/projects/data-grid/src/lib/services/drag-drp.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class DragDrpService {
+  constructor() {}
+
+  // sortChildColumnInGroup(
+  //   columns: any[],
+  //   draggedChild: any,
+  //   section: 'leftPinnedColumns' | 'centerColumns' | 'rightPinnedColumns',
+  //   previousIndex: number,
+  //   currentIndex: number
+  // ): any {
+  //   const pinned =
+  //     section === 'leftPinnedColumns'
+  //       ? 'left'
+  //       : section === 'rightPinnedColumns'
+  //       ? 'right'
+  //       : null;
+
+  //   const group = columns.find(
+  //     (col: any) =>
+  //       Array.isArray(col.children) &&
+  //       col.children.some((child: any) => child?.field === draggedChild?.field)
+  //   );
+
+  //   if (!group) return;
+
+  //   const groupIndex = columns.findIndex((col) => col.header === group.header);
+  //   const filteredGroup = group.children.filter(
+  //     (col: any) => col.pinned === pinned
+  //   );
+
+  //   const prevField = filteredGroup[previousIndex]?.field;
+  //   const currField = filteredGroup[currentIndex]?.field;
+
+  //   const visiblePrevIndex = group.children.findIndex(
+  //     (col: any) => col.field === prevField
+  //   );
+  //   const visibleCurrIndex = group.children.findIndex(
+  //     (col: any) => col.field === currField
+  //   );
+
+  //   moveItemInArray(
+  //     columns[groupIndex]?.children,
+  //     visiblePrevIndex,
+  //     visibleCurrIndex
+  //   );
+
+  //   return {
+  //     group,
+  //     movedField: currField,
+  //   };
+  // }
+}

package/backup-04112025/projects/data-grid/src/lib/services/export.service.spec.ts

@@ -0,0 +1,16 @@
+/* tslint:disable:no-unused-variable */
+
+import { TestBed, async, inject } from '@angular/core/testing';
+import { ExportService } from './export.service';
+
+describe('Service: Export', () => {
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [ExportService]
+    });
+  });
+
+  it('should ...', inject([ExportService], (service: ExportService) => {
+    expect(service).toBeTruthy();
+  }));
+});