@bit.rhplus/ag-grid 0.0.34 → 0.0.35

package/Aggregations.js

@@ -1,185 +1,321 @@
-import Enumerable from 'linq';
-import moment from 'moment';
-
-const getColumnOrderDirection = (range) => (range.columns[0].colId === range.startColumn.colId) ? 1 : -1;
-
-const getColumnOrderIndex = (range, index) => {
-  if (getColumnOrderDirection(range) === 1) {
-    return range.columns[index];
-  }
-  return range.columns[range.columns.length - 1 - index];
-}
-
-const getDimensionDefinition = (ranges) => {
-  let dimensionColumns = [];
-  let columnIndex = 0;
-  ranges.forEach(range => {
-    let colOf = 0;
-    for (let i = 0; i < range.columns.length; i += 1) {
-      if (columnIndex === 3)
-        break;
-      dimensionColumns = [...dimensionColumns, getColumnOrderIndex(range, colOf).colId];
-      columnIndex += 1;
-      colOf += 1;
-    }
-  });
-  return dimensionColumns;
-}
-
-const rangeContainsRowIndex = (range, row) => {
-  const start = Math.min(range.startRow.rowIndex, range.endRow.rowIndex);
-  const end = Math.max(range.startRow.rowIndex, range.endRow.rowIndex);
-  return (start <= row && end >= row);
-}
-
-const getValue = (gridRef, column, rowIndex) => {
-  const rowModel = gridRef.current.api.getModel();
-  const rowNode = rowModel.getRow(rowIndex);
-  const value = gridRef.current.api.getValue(column, rowNode);
-  return value;
-}
-
-const isValidDate = value => {
-  let typeValid = !(typeof value === 'number' || typeof value === "boolean" || value == null || value === '');
-  if (typeValid) {
-    typeValid = moment(value).isValid();
-  }
-  return typeValid;
-}
-
-export default function Aggregations(gridRef) {
-  const ranges = gridRef.current.api.getCellRanges();
-  let sum = null; let min = null; let max = null; let avg = null; let count = 0; let numberCount = 0;
-  let earliest; let latest;
-  let square = 0;
-  let cubic = 0;
-  let sumRows = [];
-  let sumCols = [];
-
-  if (!ranges[0] || !ranges[0].startRow)
-    return {};
-
-  const startRow = Math.min(ranges[0].startRow.rowIndex, ranges[0].endRow.rowIndex);
-  const domensionRanges = Enumerable.from(ranges).where(w => rangeContainsRowIndex(w, startRow)).toArray();
-  const dimensions = getDimensionDefinition(domensionRanges);
-
-  ranges.forEach(range => {
-    const start = Math.min(range.startRow.rowIndex, range.endRow.rowIndex);
-    const end = Math.max(range.startRow.rowIndex, range.endRow.rowIndex);
-    const rows = Enumerable.range(start, Math.abs(end - start) + 1).toArray();
-    sumRows = new Set([...sumRows, ...rows]);
-
-    const cols = Enumerable.from(range.columns).select(s => s.colId).distinct().toArray();
-    sumCols = new Set([...sumCols, ...cols]);
-
-    for (let rowIndex = start; rowIndex <= end; rowIndex += 1) {
-      let firstDimension = 0;
-      let secondDimension = 0;
-      let thirdDimension = 0;
-      const {columns} = range;
-      for (let i = 0; i < columns.length; i+=1) {
-        const column = columns[i];
-        const value = getValue(gridRef, column, rowIndex);
-
-        const validDate = isValidDate(value);
-        if (validDate) {
-          const dateValue = moment(value);
-          earliest = new Date(Math.min.apply(null, [(earliest || dateValue), dateValue]));
-          latest = new Date(Math.max.apply(null, [(latest || dateValue), dateValue]));
-        }
-        else if (typeof value === 'number') {
-          if (column.colId === dimensions[0]) { // prvni dimenze
-            firstDimension += value;
-          } else if (column.colId === dimensions[1]) {
-            secondDimension += value;
-          } else if (column.colId === dimensions[2]) {
-            thirdDimension += value;
-          }
-          sum += value;
-          min = Math.min(min || value, value);
-          max = Math.max(max || value, value);
-          numberCount += 1;
-        }
-        count += 1;
-      };
-      square += (firstDimension * secondDimension);
-      cubic += (firstDimension * secondDimension * thirdDimension);
-    }
-    avg = (sum / numberCount);
-
-  });
-
-  return {
-    sum,
-    min,
-    max,
-    avg,
-    count,
-    square,
-    cubic,
-    earliest,
-    latest,
-    rows: [...sumRows].length,
-    cols: [...sumCols].length
-  };
-
-
-  // ranges.map(item => {
-  //   var start = Math.min(item.startRow.rowIndex, item.endRow.rowIndex);
-  //   var end = Math.max(item.startRow.rowIndex, item.endRow.rowIndex);
-  //   for (var rowIndex = start; rowIndex <= end; rowIndex++) {
-  //     var dimension = 0;
-  //     rowVolume = 1;
-
-  //     item.columns.forEach(column => {
-  //       var rowModel = gridRef.current.api.getModel();
-  //       var rowNode = rowModel.getRow(rowIndex);
-  //       var value = gridRef.current.api.getValue(column, rowNode);
-
-  //       if (Date.parse(value) && value != 0) {
-  //         dateCount++;
-  //         earliest = new Date(Math.min.apply(null, [(earliest || Date.parse(value)), Date.parse(value)]));
-  //         latest = new Date(Math.max.apply(null, [(latest || Date.parse(value)), Date.parse(value)]));
-  //       }
-
-  //       if (typeof value === "number") {
-  //         dimension++;
-  //         sum += value;
-  //         min = Math.min(min || value, value);
-  //         max = Math.max(max || value, value);
-  //         count++;
-
-  //         if (dimension <= 3) {
-  //           rowVolume = rowVolume * value;
-  //         } else {
-  //           rowVolume = 0;
-  //         }
-  //       }
-  //     })
-  //     if (dimension === 2) {
-  //       volume2d = volume2d + rowVolume;
-  //     } else if (dimension === 3) {
-  //       volume3d = volume3d + rowVolume;
-  //     }
-
-
-  //   }
-  //   length += (Math.abs(item.startRow.rowIndex - item.endRow.rowIndex) + 1) * item.columns.length;
-  //   avg = (sum / count);
-  // });
-
-  // return {
-  //   length,
-  //   sum,
-  //   min,
-  //   max,
-  //   avg,
-  //   count,
-  //   volume2d,
-  //   volume3d,
-  //   earliest,
-  //   latest,
-  //   isDate: dateCount >= 2,
-  //   dateCount
-  // };
+/* eslint-disable */
+import Enumerable from 'linq';
+import moment from 'moment';
+import { currencySymbols } from '@bit.rhplus/ui.grid';
+
+const getColumnOrderDirection = (range) => (range.columns[0].colId === range.startColumn.colId) ? 1 : -1;
+
+const getColumnOrderIndex = (range, index) => {
+  if (getColumnOrderDirection(range) === 1) {
+    return range.columns[index];
+  }
+  return range.columns[range.columns.length - 1 - index];
+}
+
+const getDimensionDefinition = (ranges) => {
+  let dimensionColumns = [];
+  let columnIndex = 0;
+  ranges.forEach(range => {
+    let colOf = 0;
+    for (let i = 0; i < range.columns.length; i += 1) {
+      if (columnIndex === 3)
+        break;
+      dimensionColumns = [...dimensionColumns, getColumnOrderIndex(range, colOf).colId];
+      columnIndex += 1;
+      colOf += 1;
+    }
+  });
+  return dimensionColumns;
+}
+
+const rangeContainsRowIndex = (range, row) => {
+  const start = Math.min(range.startRow.rowIndex, range.endRow.rowIndex);
+  const end = Math.max(range.startRow.rowIndex, range.endRow.rowIndex);
+  return (start <= row && end >= row);
+}
+
+const getValue = (gridRef, column, rowIndex) => {
+  // AG Grid 33+ API - nahrazuje getModel().getRow(rowIndex)
+  const rowNode = gridRef.current.api.getDisplayedRowAtIndex(rowIndex);
+  if (!rowNode) {
+    return null;
+  }
+  // AG Grid 33+ API - použití getCellValue s rowNode a colKey
+  const value = gridRef.current.api.getCellValue({
+    rowNode: rowNode,
+    colKey: column.colId
+  });
+  return value;
+}
+
+const isValidDate = value => {
+  let typeValid = !(typeof value === 'number' || typeof value === "boolean" || value == null || value === '');
+  if (typeValid) {
+    typeValid = moment(value).isValid();
+  }
+  return typeValid;
+}
+
+export default function Aggregations(gridRef) {
+  const ranges = gridRef.current.api.getCellRanges();
+  let sum = 0; let min = null; let max = null; let avg = null; let count = 0; let numberCount = 0;
+  let earliest; let latest;
+  let square = 0;
+  let cubic = 0;
+  let sumRows = [];
+  let sumCols = [];
+  let numberValues = []; // Pro výpočet mediánu
+  let textValues = []; // Pro frekvenční analýzu textových hodnot
+  let dateCount = 0;
+  let currencyMap = {}; // Pro sledování měn
+
+  if (!ranges[0] || !ranges[0].startRow)
+    return {};
+
+  const startRow = Math.min(ranges[0].startRow.rowIndex, ranges[0].endRow.rowIndex);
+  const domensionRanges = Enumerable.from(ranges).where(w => rangeContainsRowIndex(w, startRow)).toArray();
+  const dimensions = getDimensionDefinition(domensionRanges);
+
+  ranges.forEach(range => {
+    const start = Math.min(range.startRow.rowIndex, range.endRow.rowIndex);
+    const end = Math.max(range.startRow.rowIndex, range.endRow.rowIndex);
+    const rows = Enumerable.range(start, Math.abs(end - start) + 1).toArray();
+    sumRows = new Set([...sumRows, ...rows]);
+
+    const cols = Enumerable.from(range.columns).select(s => s.colId).distinct().toArray();
+    sumCols = new Set([...sumCols, ...cols]);
+
+    for (let rowIndex = start; rowIndex <= end; rowIndex += 1) {
+      let firstDimension = 0;
+      let secondDimension = 0;
+      let thirdDimension = 0;
+      const {columns} = range;
+      for (let i = 0; i < columns.length; i+=1) {
+        const column = columns[i];
+        const value = getValue(gridRef, column, rowIndex);
+
+        const validDate = isValidDate(value);
+        
+        if (validDate) {
+          const dateValue = moment(value);
+          const dateValueAsDate = dateValue.toDate();
+          
+          if (!earliest || dateValueAsDate < earliest) {
+            earliest = dateValueAsDate;
+          }
+          if (!latest || dateValueAsDate > latest) {
+            latest = dateValueAsDate;
+          }
+          dateCount += 1;
+        }
+        else {
+          // Pokus o konverzi na číslo (AG Grid často vrací stringy)
+          const numValue = typeof value === 'number' ? value : parseFloat(value);
+          
+          if (!isNaN(numValue) && value !== null && value !== '' && value !== undefined) {
+            if (column.colId === dimensions[0]) { // prvni dimenze
+              firstDimension += numValue;
+            } else if (column.colId === dimensions[1]) {
+              secondDimension += numValue;
+            } else if (column.colId === dimensions[2]) {
+              thirdDimension += numValue;
+            }
+            sum += numValue;
+            min = (min === null) ? numValue : Math.min(min, numValue);
+            max = (max === null) ? numValue : Math.max(max, numValue);
+            numberValues.push(numValue); // Ukládáme pro median
+            numberCount += 1;
+            
+            // Detekce měny pro currency sloupce
+            if (column.colDef && column.colDef.currency) {
+              const rowNode = gridRef.current.api.getDisplayedRowAtIndex(rowIndex);
+              let currencyValue;
+              
+              if (typeof column.colDef.currency === 'function') {
+                // Dynamická měna - vyhodnotit funkci
+                currencyValue = column.colDef.currency({ data: rowNode?.data, node: rowNode });
+              } else {
+                // Statická měna
+                currencyValue = column.colDef.currency;
+              }
+              
+              if (currencyValue) {
+                currencyMap[currencyValue] = (currencyMap[currencyValue] || 0) + 1;
+              }
+            }
+          }
+          else if (value !== null && value !== '' && value !== undefined) {
+            // Textová hodnota - ukládáme pro frekvenční analýzu
+            const textValue = String(value).trim();
+            if (textValue.length > 0) {
+              textValues.push(textValue);
+            }
+          }
+        }
+        count += 1;
+      };
+      square += (firstDimension * secondDimension);
+      cubic += (firstDimension * secondDimension * thirdDimension);
+    }
+  });
+
+  // Vypočítat průměr až po dokončení všech ranges
+  avg = numberCount > 0 ? (sum / numberCount) : null;
+
+  // Vypočítat medián
+  let median = null;
+  if (numberValues.length > 0) {
+    const sorted = [...numberValues].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    median = sorted.length % 2 !== 0 
+      ? sorted[mid] 
+      : (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+
+  // Vypočítat range (rozpětí)
+  const range = (min !== null && max !== null) ? (max - min) : null;
+
+  // Vypočítat rozpětí datumů v dnech
+  const dateRange = (earliest && latest) 
+    ? Math.ceil((latest - earliest) / (1000 * 60 * 60 * 24)) 
+    : null;
+
+  // Frekvenční analýza textových hodnot
+  let valueFrequencies = null;
+  let uniqueTextCount = 0;
+  let textCount = textValues.length;
+  let hasDuplicates = false;
+
+  if (textValues.length > 0) {
+    // Spočítat frekvence
+    const frequencyMap = {};
+    textValues.forEach(val => {
+      frequencyMap[val] = (frequencyMap[val] || 0) + 1;
+    });
+
+    uniqueTextCount = Object.keys(frequencyMap).length;
+    hasDuplicates = uniqueTextCount < textValues.length;
+
+    // Pouze pokud jsou duplicity a není příliš mnoho unikátních hodnot
+    if (hasDuplicates && uniqueTextCount <= 50) {
+      // Převést na pole a seřadit podle frekvence (sestupně)
+      valueFrequencies = Object.entries(frequencyMap)
+        .map(([value, count]) => ({
+          value,
+          count,
+          percentage: (count / textValues.length) * 100
+        }))
+        .sort((a, b) => b.count - a.count);
+    }
+  }
+
+  // Určit hlavní měnu
+  let currency = null;
+  let currencySymbol = null;
+  let hasMixedCurrencies = false;
+  const currencyKeys = Object.keys(currencyMap);
+  
+  if (currencyKeys.length > 0) {
+    if (currencyKeys.length === 1) {
+      // Pouze jedna měna
+      currency = currencyKeys[0];
+      currencySymbol = currencySymbols[currency] || currency;
+    } else {
+      // Více měn - najít nejčastější
+      const sortedCurrencies = Object.entries(currencyMap)
+        .sort((a, b) => b[1] - a[1]);
+      currency = sortedCurrencies[0][0];
+      currencySymbol = currencySymbols[currency] || currency;
+      hasMixedCurrencies = true;
+    }
+  }
+
+  const result = {
+    sum,
+    min,
+    max,
+    avg,
+    median,
+    range,
+    count,
+    numberCount,
+    textCount,
+    uniqueTextCount,
+    hasDuplicates,
+    valueFrequencies,
+    currency,
+    currencySymbol,
+    hasMixedCurrencies,
+    currencyDistribution: currencyMap,
+    square,
+    cubic,
+    earliest,
+    latest,
+    dateRange,
+    dateCount,
+    rows: [...sumRows].length,
+    cols: [...sumCols].length
+  };
+
+  return result;
+
+
+  // ranges.map(item => {
+  //   var start = Math.min(item.startRow.rowIndex, item.endRow.rowIndex);
+  //   var end = Math.max(item.startRow.rowIndex, item.endRow.rowIndex);
+  //   for (var rowIndex = start; rowIndex <= end; rowIndex++) {
+  //     var dimension = 0;
+  //     rowVolume = 1;
+
+  //     item.columns.forEach(column => {
+  //       var rowModel = gridRef.current.api.getModel();
+  //       var rowNode = rowModel.getRow(rowIndex);
+  //       var value = gridRef.current.api.getValue(column, rowNode);
+
+  //       if (Date.parse(value) && value != 0) {
+  //         dateCount++;
+  //         earliest = new Date(Math.min.apply(null, [(earliest || Date.parse(value)), Date.parse(value)]));
+  //         latest = new Date(Math.max.apply(null, [(latest || Date.parse(value)), Date.parse(value)]));
+  //       }
+
+  //       if (typeof value === "number") {
+  //         dimension++;
+  //         sum += value;
+  //         min = Math.min(min || value, value);
+  //         max = Math.max(max || value, value);
+  //         count++;
+
+  //         if (dimension <= 3) {
+  //           rowVolume = rowVolume * value;
+  //         } else {
+  //           rowVolume = 0;
+  //         }
+  //       }
+  //     })
+  //     if (dimension === 2) {
+  //       volume2d = volume2d + rowVolume;
+  //     } else if (dimension === 3) {
+  //       volume3d = volume3d + rowVolume;
+  //     }
+
+
+  //   }
+  //   length += (Math.abs(item.startRow.rowIndex - item.endRow.rowIndex) + 1) * item.columns.length;
+  //   avg = (sum / count);
+  // });
+
+  // return {
+  //   length,
+  //   sum,
+  //   min,
+  //   max,
+  //   avg,
+  //   count,
+  //   volume2d,
+  //   volume3d,
+  //   earliest,
+  //   latest,
+  //   isDate: dateCount >= 2,
+  //   dateCount
+  // };
 }

package/Functions/index.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 import Enumerable from 'linq';
 
 export const getSelectedRowsIndex = gridApi => {
@@ -14,8 +15,15 @@ export const getSelectedRowsIndex = gridApi => {
 }
 
 export const getValue = (gridApi, column, rowIndex) => {
-  const rowModel = gridApi.getModel();
-  const rowNode = rowModel.getRow(rowIndex);
-  const value = gridApi.getValue(column, rowNode);
+  // AG Grid 33+ API - nahrazuje getModel().getRow(rowIndex)
+  const rowNode = gridApi.getDisplayedRowAtIndex(rowIndex);
+  if (!rowNode) {
+    return null;
+  }
+  // AG Grid 33+ API - použití getCellValue s rowNode a colKey
+  const value = gridApi.getCellValue({
+    rowNode: rowNode,
+    colKey: column.colId
+  });
   return value;
 };