data-grid-workspace 0.0.120

package/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/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();
+  }));
+});

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

@@ -0,0 +1,189 @@
+import { Injectable } from '@angular/core';
+import * as XLSX from 'xlsx-js-style';
+import { saveAs } from 'file-saver';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ExportService {
+
+  constructor() {}
+
+  /**
+   * Exports data to CSV or Excel.
+   * @param columns List of column definitions (each having name/key/is_visible)
+   * @param data The array of data objects
+   * @param fileName Name of the exported file (without extension)
+   * @param format 'csv' | 'xlsx'
+   */
+exportData(
+  columns: any[],
+  data: any[],
+  fileName: string,
+  format: 'csv' | 'xlsx' = 'xlsx',
+  rowSelectedIndexes: Set<number> | null = new Set(),
+  styleConfig: {
+    headerBgColor?: string;
+    headerTextColor?: string;
+    bodyTextColor?: string;
+    fontFamily?: string;
+    fontWeight?: 'normal' | 'bold';
+    zoomScale?: number;
+    headerRowHeight?: number;
+    selectedRowBgColor?: string;
+  } = {}
+) {
+  const {
+    headerBgColor = '#228B22',
+    headerTextColor = '#FFFFFF',
+    bodyTextColor = '#000000',
+    fontFamily = 'Calibri',
+    fontWeight = 'normal',
+    zoomScale = 120,
+    headerRowHeight = 20,
+    selectedRowBgColor = '#8AC5FF',
+  } = styleConfig;
+
+  const visibleColumns = columns.filter(
+    col => col.is_visible && col.type !== 'image' && col.type !== 'logo'
+  );
+
+  const headers = visibleColumns.map(col => col.header || col.headerName || col.name);
+
+  const flattenValue = (value: any): any => {
+    if (value == null) return '';
+    if (Array.isArray(value))
+      return value.map(v => (typeof v === 'object' ? flattenValue(v) : v)).join(', ');
+    if (typeof value === 'object')
+      return Object.entries(value)
+        .map(([k, v]) => `${k}: ${flattenValue(v)}`)
+        .join(', ');
+    return value;
+  };
+
+  const exportData = data.map(row =>
+    visibleColumns.reduce((acc: any, col) => {
+      const header = col.headerName || col.name || col.header;
+      let value = this.getNestedValue(row, col.field);
+
+      switch (col.type) {
+        case 'boolean':
+          value = value ? 'Yes' : 'No';
+          break;
+        case 'date':
+          if (value) {
+            const date = new Date(value);
+            if (!isNaN(date.getTime())) {
+              value = date.toLocaleDateString('en-US', {
+                day: '2-digit',
+                month: 'long',
+                year: 'numeric',
+              });
+            }
+          }
+          break;
+        default:
+          value = flattenValue(value);
+      }
+
+      acc[header] = value;
+      return acc;
+    }, {})
+  );
+
+  const worksheet: XLSX.WorkSheet = XLSX.utils.json_to_sheet(exportData, { header: headers });
+
+  // ✅ Define a reusable border style
+  const borderStyle = {
+    top: { style: 'thin', color: { rgb: 'CCCCCC' } },
+    bottom: { style: 'thin', color: { rgb: 'CCCCCC' } },
+    left: { style: 'thin', color: { rgb: 'CCCCCC' } },
+    right: { style: 'thin', color: { rgb: 'CCCCCC' } },
+  };
+
+  // ✅ Apply header styles
+  headers.forEach((header, index) => {
+    const cellAddress = XLSX.utils.encode_cell({ r: 0, c: index });
+    if (!worksheet[cellAddress]) return;
+
+    worksheet[cellAddress].s = {
+      fill: { fgColor: { rgb: headerBgColor.replace('#', '') } },
+      font: {
+        name: fontFamily,
+        sz: 14,
+        color: { rgb: headerTextColor.replace('#', '') },
+        bold: fontWeight === 'bold',
+      },
+      alignment: { horizontal: 'center', vertical: 'center' },
+      border: borderStyle, // ✅ Added border here
+    };
+  });
+
+  // ✅ Apply body styles + highlight selected rows
+  for (let r = 1; r <= exportData.length; r++) {
+    const isSelected = rowSelectedIndexes?.has(r - 1);
+    const rowBgColor = isSelected ? selectedRowBgColor : '#FFFFFF';
+
+    for (let c = 0; c < headers.length; c++) {
+      const col = visibleColumns[c];
+      const cellAddress = XLSX.utils.encode_cell({ r, c });
+      const cell = worksheet[cellAddress];
+      if (!cell) continue;
+
+      let horizontalAlign = 'left';
+      if (['number', 'boolean', 'date'].includes(col.type)) horizontalAlign = 'center';
+
+      cell.s = {
+        fill: { fgColor: { rgb: rowBgColor.replace('#', '') } },
+        font: {
+          name: fontFamily,
+          sz: 14,
+          color: { rgb: bodyTextColor.replace('#', '') },
+          bold: false,
+        },
+        alignment: { horizontal: horizontalAlign, vertical: 'center', wrapText: true },
+        border: borderStyle, // ✅ Added border here too
+      };
+    }
+  }
+
+  // ✅ Adjust column widths
+  const colWidths = headers.map(header => {
+    let maxLength = header.length;
+    exportData.forEach(row => {
+      const val = row[header];
+      if (val != null) {
+        const len = val.toString().length;
+        if (len > maxLength) maxLength = len;
+      }
+    });
+    return { wch: Math.min(maxLength + 2, 64) };
+  });
+  worksheet['!cols'] = colWidths;
+
+  worksheet['!rows'] = [{ hpt: headerRowHeight }];
+  worksheet['!zoom'] = zoomScale;
+
+  const workbook: XLSX.WorkBook = { Sheets: { Data: worksheet }, SheetNames: ['Data'] };
+
+  if (format === 'csv') {
+    const csv = XLSX.utils.sheet_to_csv(worksheet);
+    const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' });
+    saveAs(blob, `${fileName}.csv`);
+  } else {
+    const excelBuffer: any = XLSX.write(workbook, { bookType: 'xlsx', type: 'array' });
+    const blob = new Blob([excelBuffer], {
+      type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8',
+    });
+    saveAs(blob, `${fileName}.xlsx`);
+  }
+}
+
+
+
+
+private getNestedValue(obj: any, path: string): any {
+  if (!path || typeof obj !== 'object') return obj;
+  return path.split('.').reduce((acc, key) => (acc && acc[key] !== undefined ? acc[key] : ''), obj);
+}
+}

package/projects/data-grid/src/lib/services/row-action.service.ts

@@ -0,0 +1,203 @@
+import { Injectable } from '@angular/core';
+
+export interface ActionContext {
+  tableType?: string;
+  packageData?: boolean;
+  showUnLink?: boolean;
+  currentUserId?: string | number;
+}
+
+interface NormalizedRow {
+  isDeleted: boolean;
+  status: string;
+  availStatus: string;
+  accountStatus: string;
+  assigneeCount: number;
+  assignedToIds: (string | number)[];
+  settlementCompleted: boolean;
+  finalSettlementCompleted: boolean;
+  storeEdit: boolean;
+  isOwner: boolean;
+  isCustomGrade: string;
+  parent: any;
+  offerLetter: any;
+  typename: string;
+}
+
+type ActionRule = (row: NormalizedRow, ctx: ActionContext) => boolean;
+
+@Injectable({ providedIn: 'root' })
+export class RowActionService {
+
+  private readonly STATUS_SETS = {
+    EDIT_BLOCKED: [
+      'expired', 'closed', 'Assigning Stop', 'Evaluation Start',
+      'Evaluation Stop', 'Completed', 'approved', 'rejected',
+      'partially', 'accepted'
+    ],
+    ARCHIVE_BLOCKED: [
+      'approved', 'partially', 'Assigning Start',
+      'Completed', 'Evaluation Start'
+    ],
+    DISPOSED: ['scrap', 'trashed', 'disposed'],
+    SEPARATED: ['termination', 'resignation', 'retirement', 'separated'],
+    UNAVAILABLE: ['unavailable', 'unAvailable']
+  } as const;
+
+  private readonly ACTION_ALIASES: Record<string, string> = {
+    accept: 'view',
+    achive: 'unactive'
+  };
+
+  private readonly rules: Record<string, ActionRule> = {
+    assigningstart: (r) => r.status === 'To be start Assigning' && !r.isDeleted,
+    assigningstop: (r) => r.status === 'Assigning Start' && !r.isDeleted,
+    evaluationstart: (r) => r.status === 'Assigning Stop' && !r.isDeleted,
+    completed: (r) => r.status === 'Evaluation Start' && !r.isDeleted,
+
+    archive: (r) => this.canArchiveOrDelete(r),
+    unactive: (r) => this.canArchiveOrDelete(r),
+    delete: (r) => this.canArchiveOrDelete(r),
+
+    unarchive: (r) => r.isDeleted && r.availStatus !== 'disposed',
+    active: (r) => r.isDeleted && r.availStatus !== 'disposed',
+
+    link: (r) => 
+      !this.STATUS_SETS.UNAVAILABLE.includes((r.status as any)) &&
+      !r.isDeleted &&
+      r.availStatus !== 'disposed' &&
+      r.status !== 'linked',
+    unlink: (r, ctx) => ctx.showUnLink === true && r.status === 'linked',
+
+    rejoin: (r) => this.STATUS_SETS.SEPARATED.includes((r.accountStatus as any)),
+    settlementinfo: (r) => this.STATUS_SETS.SEPARATED.includes((r.accountStatus as any)),
+
+    assign: (r) => r.status !== 'assigned',
+    edit: (r, ctx) => this.canEdit(r, ctx),
+
+    trash: (r) => !this.STATUS_SETS.DISPOSED.includes((r.availStatus as any)),
+    scrap: (r) => !this.STATUS_SETS.DISPOSED.includes((r.availStatus as any)),
+    retain: (r) => !this.STATUS_SETS.DISPOSED.includes((r.availStatus as any)),
+
+    defaultgrade: (r) => r.isCustomGrade !== 'Active',
+
+    subscribe: (r, ctx) => !r.assignedToIds.includes((ctx.currentUserId as any)),
+    unsubscribe: (r, ctx) => r.assignedToIds.includes((ctx.currentUserId as any)),
+
+    changestatus: (r) => !r.isDeleted,
+
+    download: (r) => r.offerLetter !== null,
+    view: (r) => r.offerLetter !== null
+  };
+
+  private normalizeRow(element: any): NormalizedRow {
+    return {
+      isDeleted: element.is_deleted === true || element.is_deleted === 'true',
+      status: element.status || '',
+      availStatus: element.availStatus || '',
+      accountStatus: (element.account_status || '').toLowerCase(),
+      assigneeCount: element.assignee?.length ?? 0,
+      assignedToIds: element.assigned_to?.map((x: any) => x.id) ?? [],
+      settlementCompleted: element.settlement_completed === true,
+      finalSettlementCompleted: element.final_settlement_completed === true,
+      storeEdit: element.store_edit !== false,
+      isOwner: element.is_owner ?? true,
+      isCustomGrade: element.is_custom_grade || '',
+      parent: element.parent,
+      offerLetter: element.offer_letter,
+      typename: element.__typename || ''
+    };
+  }
+
+  private normalizeAction(action: string, ctx: ActionContext): string {
+    let normalized = this.ACTION_ALIASES[action] || action;
+
+    if (ctx.packageData) {
+      if (action === 'unarchive') return 'active';
+      if (action === 'archive') return 'unactive';
+    }
+
+    return normalized.toLowerCase();
+  }
+
+  private canArchiveOrDelete(r: NormalizedRow): boolean {
+    return (
+      !r.isDeleted &&
+      !r.settlementCompleted &&
+      !r.finalSettlementCompleted &&
+      r.availStatus !== 'reserved' &&
+      r.assigneeCount === 0 &&
+      r.availStatus !== 'disposed' &&
+      r.availStatus !== 'maintenance' &&
+      r.availStatus !== 'assigned' &&
+      !this.STATUS_SETS.ARCHIVE_BLOCKED.includes((r.status as any)) &&
+      r.parent !== null
+    );
+  }
+
+  private canEdit(r: NormalizedRow, ctx: ActionContext): boolean {
+    const isBlocked = 
+      this.STATUS_SETS.EDIT_BLOCKED.includes((r.status as any)) ||
+      r.isDeleted ||
+      !r.storeEdit ||
+      r.availStatus === 'disposed' ||
+      r.settlementCompleted ||
+      r.finalSettlementCompleted;
+
+    if (isBlocked) return false;
+
+    if (ctx.tableType === 'BusinessExpenseListing') {
+      return true;
+    }
+
+    return r.status !== 'accepted' && r.isOwner;
+  }
+
+  isActionValid(action: string, element: any, ctx: ActionContext = {}): boolean {
+    const row = this.normalizeRow(element);
+    const normalizedAction = this.normalizeAction(action, ctx);
+    const rule = this.rules[normalizedAction];
+
+    if (rule) {
+      return rule(row, ctx);
+    }
+
+    return row.availStatus !== 'disposed' || row.typename === 'Alert';
+  }
+
+  getValidActions(actions: string[], element: any, ctx: ActionContext = {}): string[] {
+    if (!actions?.length) return [];
+    
+    let validActions = actions.filter(action => 
+      this.isActionValid(action, element, ctx)
+    );
+
+    if (ctx.tableType === 'recruitmentListing') {
+      validActions = this.applyRecruitmentFilters(validActions, element);
+    }
+
+    return validActions;
+  }
+
+  private applyRecruitmentFilters(actions: string[], element: any): string[] {
+    let filtered = [...actions];
+
+    if (element?.status === 'hired' && !element?.is_deleted) {
+      filtered = filtered.filter(action => 
+        !['changestatus', 'unarchive', 'archive', 'edit'].includes(action)
+      );
+    }
+
+    if (element?.is_deleted) {
+      filtered = filtered.filter(action => action !== 'changestatus');
+    }
+
+    if (element?.offer_letter === null) {
+      filtered = filtered.filter(action => 
+        !['download', 'view'].includes(action)
+      );
+    }
+
+    return filtered;
+  }
+}

package/projects/data-grid/src/lib/services/split-columns.service.spec.ts

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

package/projects/data-grid/src/lib/services/split-columns.service.ts

@@ -0,0 +1,168 @@
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SplitColumnsService {
+  prepareColumns(columns: any[], containerWidth: number): any {
+    const left: any[] = [];
+    const center: any[] = [];
+    const right: any[] = [];
+
+    for (const col of columns) {
+      if (col.children?.length) {
+        const leftChildren: any[] = [];
+        const centerChildren: any[] = [];
+        const rightChildren: any[] = [];
+
+        for (const child of col.children) {
+          if (child.is_visible === false) continue;
+
+          const pinned = child.pinned ?? col.pinned ?? null;
+          const childWithPinned = { ...child, pinned };
+
+          if (pinned === 'left') leftChildren.push(childWithPinned);
+          else if (pinned === 'right') rightChildren.push(childWithPinned);
+          else centerChildren.push(childWithPinned);
+        }
+
+        if (leftChildren.length) {
+          left.push({ header: col.header, children: leftChildren, id: col?.id || col?._id });
+        }
+        if (centerChildren.length) {
+          center.push({
+            header: col.header,
+            children: centerChildren,
+            id: col.id || col._id,
+          });
+        }
+        if (rightChildren.length) {
+          right.push({
+            header: col.header,
+            children: rightChildren,
+            id: col.id || col._id,
+          });
+        }
+      } else if (col.is_visible !== false) {
+        const pinned = col.pinned ?? null;
+        if (pinned === 'left') left.push(col);
+        else if (pinned === 'right') right.push(col);
+        else center.push(col);
+      }
+    }
+
+    return { left, center, right };
+  }
+
+  setColumnsQuery(columns: any[]) {
+    for (const col of columns) {
+      // if (col.children?.length) {
+      //   for (const child of col.children) {
+      //     if (!child?.query?.firt_value && !child?.query?._ids?.length) {
+      //       child['query'] = {
+      //         first_condition: 'contain',
+      //         first_value: null,
+      //         condition: 'none',
+      //         second_condition: 'contain',
+      //         second_value: null,
+      //         _ids: [],
+      //       };
+      //     }
+      //   }
+      // }
+      // if (!col?.query?.firt_value && !col?.query?._ids?.length) {
+      //   col.query = {
+      //     first_condition: 'contain',
+      //     first_value: null,
+      //     condition: 'none',
+      //     second_condition: 'contain',
+      //     second_value: null,
+      //     _ids: [],
+      //   };
+      // }
+    }
+
+    console.log('Updated Columns: ', columns);
+
+    return columns;
+  }
+
+  assignDefaultWidths(columns: any[], containerWidth: number): any[] {
+  const visibleLeafCols = this.getVisibleLeafColumns(columns);
+
+  if (!visibleLeafCols.length) return columns;
+
+  // ✅ Columns that already have width
+  const fixedCols = visibleLeafCols.filter(
+    col => col.width && col.width > 0
+  );
+
+  // ✅ Columns that need width
+  const flexibleCols = visibleLeafCols.filter(
+    col => !col.width && col.is_visible !== false
+  );
+
+  // ✅ Total width already consumed
+  const usedWidth = fixedCols.reduce(
+    (sum, col) => sum + col.width,
+    0
+  );
+
+  // ✅ Remaining width after fixed columns
+  let remainingWidth = containerWidth - (usedWidth + 50);
+  if (remainingWidth < 0) remainingWidth = 0;
+
+  // ✅ Average width for columns without width
+  let defaultWidth =
+    flexibleCols.length > 0
+      ? Math.floor(remainingWidth / flexibleCols.length)
+      : 0;
+
+  // ✅ Enforce minimum
+  if (defaultWidth < 150) defaultWidth = 150;
+
+  const cloneColumns = (cols: any[]): any[] =>
+    cols.map(col => {
+      if (col.children?.length) {
+        return {
+          ...col,
+          children: cloneColumns(col.children)
+        };
+      }
+
+      // ✅ Keep existing width
+      if (col.width) {
+        return { ...col };
+      }
+
+      // ✅ Hidden columns → fixed small width
+      if (col.is_visible === false) {
+        return { ...col, width: 150 };
+      }
+
+      // ✅ Assign calculated default width
+      return { ...col, width: defaultWidth };
+    });
+
+  return cloneColumns(columns);
+}
+
+
+
+  private getVisibleLeafColumns(columns: any[]): any[] {
+    const result: any[] = [];
+
+    for (const col of columns) {
+      if (col.children?.length) {
+        const visibleChildren = col.children.filter(
+          (c: any) => c.is_visible !== false
+        );
+        result.push(...visibleChildren);
+      } else if (col.is_visible !== false) {
+        result.push(col);
+      }
+    }
+
+    return result;
+  }
+}

package/projects/data-grid/src/lib/services/swap-columns.service.spec.ts

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