@bit.rhplus/ag-grid 0.0.11

package/AgGridAddNewItem.js

@@ -0,0 +1,6 @@
+
+// export const AgGridAddNewItem = (
+//   options) => 
+// {
+
+// }

package/AgGridColumn.js

@@ -0,0 +1,368 @@
+import moment from "moment";
+import get from "lodash/get";
+import set from "lodash/set";
+import { CommonHeaderTemplate } from "./HeaderTemplates/CommonHeaderTemplate";
+import {
+  AG_TEXT_COLUMN_FILTER,
+  AG_TEXT_DATE_COLUMN_FILTER,
+  textDateCutomComparator,
+} from "./AgGridColumnFilter";
+
+export const emptyZero = (value) => {
+  return value === 0 ? null : value;
+};
+
+/* eslint-disable no-param-reassign */
+export const AgGridColumn = (column, options) => {
+
+  if (column.dateRenderer) {
+    column.cellRenderer = (data) =>
+      (data.value && moment(data.value).format(column.dateRenderer)) || "";
+  }
+
+  if (column.booleanRenderer) {
+    column.cellRenderer = "booleanRenderer";
+
+    if (column.booleanRendererParams) {
+      column.cellRendererParams = {
+        booleanRendererParams: column.booleanRendererParams,
+      };
+    }
+  }
+
+  if (column.headerHtmlText) {
+    column.headerComponentParams = {
+      template: CommonHeaderTemplate(column.headerHtmlText),
+    };
+  }
+
+  // empty zero
+  if (column.emptyZero !== undefined) {
+    if (!column.valueGetter) {
+      // nastavim valueGetter, proto musi byt prazdny, jinak bych prepsal existujici hodnoty
+      column.valueGetter = (params) => {
+        if (column.emptyZero) 
+          return emptyZero(get(params.data, column.field));
+        return get(params.data, column.field);
+      };
+    }
+  }
+
+  // override column filter
+  if (column.overrideFilter) {
+    switch (column.overrideFilter) {
+      case AG_TEXT_DATE_COLUMN_FILTER:
+        column.filter = AG_TEXT_COLUMN_FILTER;
+        column.filterParams = {
+          filterOptions: ["contains", "notContains"],
+          textCustomComparator: (filter, value, filterText) =>
+            textDateCutomComparator(
+              filter,
+              value,
+              filterText,
+              column.dateRenderer
+            ),
+        };
+        break;
+
+      default:
+        column.filter = column.overrideFilter;
+    }
+  }
+
+  // // simple editor
+  // if (!!column.cellType && column.cellType === 'rhSelectCellEditor'
+  // && !!column.cellTypeParams) {
+  // if (!column.cellRenderer) {
+  //   column.cellRenderer = 'selectCellRenderer';
+  // }
+  // column.cellEditor = 'agRichSelectCellEditor';
+  // if (!column.cellEditorParams) {
+  //   let emptyRow;
+  //     if (!!column.emptyRow) {
+  //       if (typeof column.emptyRow === 'function') {
+  //         emptyRow = column.emptyRow();
+  //       } else {
+  //         emptyRow = column.emptyRow;
+  //       }
+  //     }
+
+  //     column.cellEditorParams = params => {
+  //       let values;
+  //       if (typeof column.cellTypeParams.values === 'function') {
+  //         values = column.cellTypeParams.values(params);
+  //       } else {
+
+  //         values = column.cellTypeParams.values;
+  //       }
+  //       if (!!emptyRow) {
+  //         values = [emptyRow, ...values];
+  //       }
+  //       return {
+  //         cellRenderer: 'selectCellRenderer',
+  //         values
+  //       }
+  //     };
+  //   }
+
+  //   column.valueGetter = params => {
+
+  //     if (!params.data || !get(params.data, column.field))
+  //       return;
+
+  //       let values;
+  //     if (typeof column.cellTypeParams.values === 'function') {
+  //       values = column.cellTypeParams.values(params);
+  //     } else {
+  //       values = column.cellTypeParams.values;
+  //     }
+  //     return values.find(f => f.id === get(params.data, column.fieldId)).name;
+  //   }
+
+  //   column.valueSetter = params => {
+  //     set(params.data, column.field, params.newValue.id);
+  //     return true;
+  //   };
+  // }
+
+  // country select
+  if (
+    !!column.cellType &&
+    column.cellType === "countrySelect" &&
+    !!column.cellTypeParams
+  ) {
+    if (!column.cellRenderer) {
+      column.cellRenderer = "countrySelectRenderer";
+    }
+    column.cellEditorPopup = true;
+    column.cellEditor = "agRichSelectCellEditor";
+
+    if (!column.cellEditorParams) {
+      let emptyRow;
+      if (column.emptyRow) {
+        if (typeof column.emptyRow === "function") {
+          emptyRow = column.emptyRow();
+        } else {
+          emptyRow = column.emptyRow;
+        }
+      }
+
+      column.cellEditorParams = (params) => {
+        let values;
+        if (typeof column.cellTypeParams.values === "function") {
+          values = column.cellTypeParams.values(params);
+        } else {
+          values = column.cellTypeParams.values;
+        }
+        if (emptyRow) {
+          values = [emptyRow, ...values];
+        }
+        return {
+          cellRenderer: "countrySelectRenderer",
+          values,
+        };
+      };
+    }
+
+    column.valueGetter = (params) => {
+      if (!params) return;
+
+      let value;
+      if (column.overrideValueGetter) {
+        if (typeof column.overrideValueGetter === "function")
+          value = column.overrideValueGetter(params);
+        else value = column.overrideValueGetter;
+      } else {
+        value = get(params.data, column.field);
+      }
+      if (value === undefined || value === null) return;
+
+      let values;
+      if (typeof column.cellTypeParams.values === "function") {
+        values = column.cellTypeParams.values(params);
+      } else {
+        values = column.cellTypeParams.values;
+      }
+      const result = values.find((f) => f.id === value);
+      // eslint-disable-next-line consistent-return
+      return result;
+    };
+
+    column.valueSetter = (params) => {
+      set(params.data, column.field, params.newValue.id);
+      return true;
+    };
+  }
+
+  // boolean renderer
+  if (!!column.cellType && column.cellType === "boolean") {
+    if (!column.cellRenderer) {
+      column.cellRenderer = "booleanRenderer";
+    }
+  }
+
+  // checkbox renderer
+  if (!!column.cellType && column.cellType === "checkbox") {
+    if (!column.cellRenderer) {
+      column.cellRenderer = "checkboxRenderer";
+    }
+  }
+
+  // button renderer
+  if (!!column.cellType && column.cellType === "button") {
+    if (!column.cellRenderer) {
+      column.cellRenderer = "buttonRenderer";
+    }
+  }
+
+  // select
+  if (
+    !!column.cellType &&
+    column.cellType === "select" &&
+    !!column.cellTypeParams
+  ) {
+    if (!column.cellRenderer) {
+      column.cellRenderer = "selectRenderer";
+    }
+    column.cellEditorPopup = true;
+    column.cellEditor = "agRichSelectCellEditor";
+
+    if (!column.cellEditorParams) {
+      let emptyRow;
+      if (column.emptyRow) {
+        if (typeof column.emptyRow === "function") {
+          emptyRow = column.emptyRow();
+        } else {
+          emptyRow = column.emptyRow;
+        }
+      }
+
+      column.cellEditorParams = (params) => {
+        let values;
+        if (typeof column.cellTypeParams.values === "function") {
+          values = column.cellTypeParams.values(params);
+        } else {
+          values = column.cellTypeParams.values;
+        }
+        if (emptyRow) {
+          values = [emptyRow, ...values];
+        }
+        return {
+          cellRenderer: "selectRenderer",
+          values,
+        };
+      };
+    }
+
+    column.valueGetter = (params) => {
+      if (!params) return;
+
+      let value;
+      if (column.overrideValueGetter) {
+        if (typeof column.overrideValueGetter === "function")
+          value = column.overrideValueGetter(params);
+        else value = column.overrideValueGetter;
+      } else {
+        value = get(params.data, column.field);
+      }
+      if (value === undefined || value === null) return;
+
+      let values;
+      if (typeof column.cellTypeParams.values === "function") {
+        values = column.cellTypeParams.values(params);
+      } else {
+        values = column.cellTypeParams.values;
+      }
+      const result = values.find((f) => f.id === value);
+      // eslint-disable-next-line consistent-return
+      return result;
+    };
+
+    column.valueSetter = (params) => {
+      set(params.data, column.field, params.newValue.id);
+      return true;
+    };
+  }
+
+  const baseCellStyle = (params) => {
+    return () => {
+      let retVal = {};
+      if (params.data !== undefined) {
+        if (params.data._rh_plus_ag_grid_row_changed) {
+          if (params.colDef.editable) {
+            retVal = options.defaultColDef.changedCellStyle || {};
+            // } else {
+            //   style = options.defaultColDef.changedCellEditableStyle || undefined;
+          }
+        } else if (params.colDef.editable) {
+            retVal = options.defaultColDef.editableStyle || {};
+        }
+      }
+
+      if (params.colDef.cellRenderer === "hyperModuleRenderer") {
+        return {
+          ...retVal,
+          padding: 0,
+          margin: 0,
+        };
+      }
+      return retVal;
+    };
+  };
+
+  // styling
+  column.cellStyle = function cellStyle(params) {
+    let style = {};
+
+    if (column.overrideCellStyle) {
+      style =
+        column.overrideCellStyle &&
+        column.overrideCellStyle(params, baseCellStyle(params));
+    } else {
+      style = baseCellStyle(params)();
+    }
+
+    return style;
+  };
+
+  // const defaultCellStyle:({} | undefined) = column.cellStyle;
+  // // styling
+  // column.cellStyle = function cellStyle(params: any) {
+  //   var style:({} | CSSProperties | undefined) = defaultCellStyle;
+
+  //   if (params.data !== undefined) {
+  //     if (!!params.data._rh_plus_ag_grid_row_changed) {
+  //       if (params.colDef.editable) {
+  //         style = options.defaultColDef.changedCellStyle || undefined;
+  //       // } else {
+  //       //   style = options.defaultColDef.changedCellEditableStyle || undefined;
+  //       }
+  //     } else {
+  //       if (params.colDef.editable) {
+  //         style = options.defaultColDef.editableStyle || undefined
+  //       }
+  //     }
+  //   }
+
+  //   if (params.colDef.cellRenderer === "hyperModuleRenderer") {
+  //     return {
+  //       ...style,
+  //       'padding': 0,
+  //       'margin': 0
+  //     }
+  //   }
+  //   return style;
+  // }
+  if (column.children) {
+    column.children = column.children && column.children.map(col => AgGridColumn(col, options));
+  }
+
+  return column;
+};
+
+export const AgGridColumns = (columnDefs, options) => {
+  const cols = columnDefs && columnDefs.map(column => AgGridColumn(column, options));
+  return cols;
+}
+
+

package/AgGridColumnFilter.js

@@ -0,0 +1,22 @@
+import moment from 'moment';
+
+export const AG_TEXT_COLUMN_FILTER = "agTextColumnFilter";
+export const AG_TEXT_DATE_COLUMN_FILTER = "agTextDateColumnFilter";
+export const AG_TEXT_DATE_FILTER_FORMAT = "DD.MM.YYYY HH:mm";
+
+export const textDateCutomComparator = (filter, value, filterText, format) => {
+  if (value == null)
+    return false;
+
+  const innerValue = moment(value).format(format || AG_TEXT_DATE_FILTER_FORMAT);
+
+  switch (filter) {
+    case 'contains':
+      return innerValue.includes(filterText);
+    case 'notContains':
+      return !innerValue.includes(filterText);
+    default:
+      // should never happen
+      return false;
+  }
+}

package/AgGridOnGridReady.js

@@ -0,0 +1,9 @@
+
+export const AgGridOnGridReady = (
+  event, 
+  options) => 
+{
+  // call overrided function 
+  if (options.onGridReady)
+    options.onGridReady(event);
+}

package/AgGridOnRowDataChanged.js

@@ -0,0 +1,8 @@
+
+// export const AgGridOnRowDataChanged = (
+//   event, 
+//   options
+//   ) => 
+// {
+  
+// }

package/AgGridOnRowDataUpdated.js

@@ -0,0 +1,32 @@
+
+export const AgGridOnRowDataUpdated = (
+  event,
+  options
+) => {
+  if (options.addNewItem) {
+    const rowData = [];
+    if (event.api)
+      event.api.forEachNode(node => {
+        rowData.push(node.data);
+      });
+
+    let node = rowData.find(f =>
+      f._rh_plus_ag_grid_new_item && f._rh_plus_ag_grid_new_item === true);
+    if (node === undefined) {
+      node = {
+        ...options.initialItem,
+        _rh_plus_ag_grid_new_item: true
+      };
+
+      if (options.newItemPosition && options.newItemPosition === "bottom") {
+        rowData.push(node);
+      } else {
+        rowData.unshift(node);
+      }
+      if (options.onAddNewItem)
+        options.onAddNewItem(node);
+    }
+    event.api.refreshCells({ force: true });
+  }
+  return event;
+}

package/AgGridPostSort.js

@@ -0,0 +1,34 @@
+
+const isNewItem = (node) => {
+  if (node.data === undefined)
+    return false;
+
+  return node.data._rh_plus_ag_grid_new_item && node.data._rh_plus_ag_grid_new_item === true;
+}
+
+const move = (nodes, toIndex, fromIndex) => {
+  nodes.splice(toIndex, 0, nodes.splice(fromIndex, 1)[0]);
+}
+
+/* eslint-disable no-param-reassign */
+export const AgGridPostSort = (nodes, options) => {
+  let row = 1;
+  const {length} = nodes;
+  // TODO: Pridat moznost razeni noveho radku na konec, podle vlastnosti newItemPosition
+  for(let i = 0; i < length; i+=1) {
+    if (nodes[i].data !== undefined) {
+      if (isNewItem(nodes[i])) {
+        nodes[i].data._rh_plus_ag_grid_row_index = "*";
+        if (options.newItemPosition !== "bottom") move(nodes, 0, i);
+      } else {
+        nodes[i].data._rh_plus_ag_grid_row_index = row;
+        nodes[i].data._rh_plus_ag_grid_row_index_desc = length + 1 - row; 
+        row+=1;
+      }
+      // nodes[i].setData(nodes[i].data);
+    }
+  }
+
+    if (options.postSort)
+      options.postSort(nodes);
+}

package/AggregationNotification.js

@@ -0,0 +1,111 @@
+// import React, { useState } from 'react';
+// import PropTypes from 'prop-types';
+// import classnames from 'classnames';
+// import { makeStyles } from '@material-ui/core/styles';
+// import { useSnackbar } from 'notistack';
+// import Collapse from '@material-ui/core/Collapse';
+// import Paper from '@material-ui/core/Paper';
+// import Typography from '@material-ui/core/Typography';
+// import Card from '@material-ui/core/Card';
+// import CardActions from '@material-ui/core/CardActions';
+// import Button from '@material-ui/core/Button';
+// import IconButton from '@material-ui/core/IconButton';
+// import CloseIcon from '@material-ui/icons/Close';
+// import ExpandMoreIcon from '@material-ui/icons/ExpandMore';
+// import CheckCircleIcon from '@material-ui/icons/CheckCircle';
+// import moment from 'moment';
+
+// const useStyles = makeStyles(theme => ({
+//     card: {
+//         display: 'flex',
+//         flexDirection: 'column',
+//         flexWrap: 'wrap',
+//         flexGrow: 1,
+//         backgroundColor: '#fddc6c',
+//         [theme.breakpoints.up('sm')]: {
+//             flexGrow: 'initial',
+//             minWidth: 344,
+//         },
+//     },
+//     // typography: {
+//         // fontWeight: 'bold',
+//     // },
+//     actionRoot: {
+//         padding: '8px 8px 8px 16px',
+//     },
+//     icons: {
+//         marginLeft: 'auto',
+//     },
+//     expand: {
+//         padding: '8px 8px',
+//         transform: 'rotate(0deg)',
+//         transition: theme.transitions.create('transform', {
+//             duration: theme.transitions.duration.shortest,
+//         }),
+//     },
+//     expandOpen: {
+//         transform: 'rotate(180deg)',
+//     },
+//     collapse: {
+//         padding: 16,
+//     },
+//     checkIcon: {
+//         fontSize: 20,
+//         color: '#b3b3b3',
+//         paddingRight: 4,
+//     },
+//     button: {
+//         padding: 0,
+//         textTransform: 'none',
+//     },
+// }));
+
+// const AggregationNotification = React.forwardRef((props, ref) => {
+//     const classes = useStyles();
+//     const { closeSnackbar } = useSnackbar();
+//     const expanded = true;
+//     const {length, count, sum, max, min, avg, volume2d, volume3d, earliest, latest, isDate, dateCount} = props.messageInfo;
+
+//     const handleDismiss = () => {
+//         closeSnackbar(props.id);
+//     };
+//     return (
+//         <Card className={classes.card} ref={ref}>
+//             <CardActions classes={{ root: classes.actionRoot }}>
+//                 <Typography variant="subtitle2">Selected {length} items</Typography>
+//                 <div className={classes.icons}>
+//                     <IconButton className={classes.expand} onClick={handleDismiss}>
+//                         <CloseIcon />
+//                     </IconButton>
+//                 </div>
+//             </CardActions>
+//             <Collapse in={expanded} timeout="auto" unmountOnExit>
+//                 {props.showNumber && count > 0 ? (
+//                     <Paper className={classes.collapse}>
+//                         { !isNaN(parseFloat(count)) ? (<span><b>Count:</b> {parseFloat(count)}</span>) : (<span />) }
+//                         { !isNaN(parseFloat(sum)) ? (<span className="ml-2"><b>Sum:</b> {parseFloat(sum).toFixed(2)}</span>) : (<span />) }
+//                         { !isNaN(parseFloat(min)) ? (<span className="ml-2"><b> Min:</b> {parseFloat(min).toFixed(2)}</span>) : (<span />) }
+//                         { !isNaN(parseFloat(max)) ? (<span className="ml-2"><b> Max:</b> {parseFloat(max).toFixed(2)}</span>) : (<span />) }
+//                         { !isNaN(parseFloat(avg)) ? (<span className="ml-2"><b> Avg:</b> {parseFloat(avg).toFixed(2)}</span>) : (<span />) }
+//                         { !isNaN(parseFloat(volume2d)) ? (<span className="ml-2"><b> 2d:</b> {parseFloat(volume2d).toFixed(2)}</span>) : (<span />) }
+//                         { !isNaN(parseFloat(volume3d)) ? (<span className="ml-2"><b> 3d:</b> {parseFloat(volume3d).toFixed(2)}</span>) : (<span />) }
+//                     </Paper>            
+//                 ) : (<div />)}
+
+//                 {props.showDate && isDate ? (
+//                     <Paper className={classes.collapse}>
+//                         <span><b>Count:</b> {parseFloat(dateCount)}</span>
+//                         <span className="ml-2"><b>Earliest:</b> {moment(Date.parse(earliest)).format("DD.MM.YY HH:mm:SS")}</span>
+//                         <span className="ml-2"><b>Latest:</b> {moment(Date.parse(latest)).format("DD.MM.YY HH:mm:SS")}</span>
+//                     </Paper>
+//                 ) : (<div />)}        
+//             </Collapse>
+//         </Card>
+//     );
+// });
+
+// AggregationNotification.propTypes = {
+//     id: PropTypes.number.isRequired,
+// };
+
+// export default AggregationNotification;