@syncfusion/ej2-grids
Version:
Feature-rich JavaScript datagrid (datatable) control with built-in support for editing, filtering, grouping, paging, sorting, and exporting to Excel.
366 lines (365 loc) • 15.6 kB
JavaScript
import { Row } from './../models/row';
import { CellType } from '../base/enum';
import { isNullOrUndefined, Internationalization, getValue, createElement } from '@syncfusion/ej2-base';
import { Cell } from '../models/cell';
import { ValueFormatter } from './../services/value-formatter';
import { Query, DataManager } from '@syncfusion/ej2-data';
import { getForeignData, measureColumnDepth, getUid } from '../base/util';
import { Grid } from '../base/grid';
/**
* @hidden
* `ExportHelper` for `PdfExport` & `ExcelExport`
*/
var ExportHelper = /** @class */ (function () {
function ExportHelper(parent, foreignKeyData) {
this.hideColumnInclude = false;
this.foreignKeyData = {};
this.parent = parent;
if (!parent.parentDetails && foreignKeyData) {
this.foreignKeyData = foreignKeyData;
}
}
ExportHelper.getQuery = function (parent, data) {
var query = data.generateQuery(true).requiresCount();
if (data.isRemote()) {
if (parent.groupSettings.enableLazyLoading && parent.groupSettings.columns.length) {
query.lazyLoad = [];
}
else {
query.take(parent.pageSettings.totalRecordsCount);
}
}
return query;
};
ExportHelper.prototype.getFData = function (value, column) {
var foreignKeyData = getForeignData(column, {}, value, this.foreignKeyData[column.field])[0];
return foreignKeyData;
};
ExportHelper.prototype.getGridRowModel = function (columns, dataSource, gObj, startIndex) {
if (startIndex === void 0) { startIndex = 0; }
var rows = [];
var length = dataSource.length;
if (length) {
for (var i = 0; i < length; i++, startIndex++) {
var options = { isExpand: false };
options.data = dataSource[parseInt(i.toString(), 10)];
options.index = startIndex;
if (gObj.childGrid || gObj.detailTemplate) {
if (gObj.hierarchyPrintMode === 'All') {
options.isExpand = true;
}
else if (gObj.hierarchyPrintMode === 'Expanded' &&
this.parent.expandedRows && this.parent.expandedRows[parseInt(startIndex.toString(), 10)]) {
options.isExpand = gObj.expandedRows[parseInt(startIndex.toString(), 10)].isExpand;
}
}
var row = new Row(options);
row.cells = this.generateCells(columns, gObj);
rows.push(row);
}
this.processColumns(rows);
}
return rows;
};
ExportHelper.prototype.generateCells = function (columns, gObj) {
var cells = [];
if (gObj.childGridLevel) {
var len = gObj.childGridLevel;
for (var i = 0; len > i; i++) {
cells.push(this.generateCell({}, CellType.Indent));
}
}
for (var _i = 0, columns_1 = columns; _i < columns_1.length; _i++) {
var col = columns_1[_i];
cells.push(this.generateCell(col, CellType.Data));
}
return cells;
};
ExportHelper.prototype.getColumnData = function (gridObj) {
var _this = this;
var columnPromise = [];
var promise;
var fColumns = gridObj.getForeignKeyColumns();
if (fColumns.length) {
for (var i = 0; i < fColumns.length; i++) {
var colData = ('result' in fColumns[parseInt(i.toString(), 10)].dataSource) ?
new DataManager(fColumns[parseInt(i.toString(), 10)].dataSource.result) :
fColumns[parseInt(i.toString(), 10)].dataSource;
columnPromise.push(colData.executeQuery(new Query()));
}
promise = Promise.all(columnPromise).then(function (e) {
for (var j = 0; j < fColumns.length; j++) {
_this.foreignKeyData[fColumns[parseInt(j.toString(), 10)].field] = e[parseInt(j.toString(), 10)].result;
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
});
}
return promise;
};
ExportHelper.prototype.getHeaders = function (columns, isHideColumnInclude) {
if (isHideColumnInclude) {
this.hideColumnInclude = true;
}
else {
this.hideColumnInclude = false;
}
this.colDepth = measureColumnDepth(columns);
var rows = [];
for (var i = 0; i < this.colDepth; i++) {
rows[parseInt(i.toString(), 10)] = new Row({});
rows[parseInt(i.toString(), 10)].cells = [];
}
rows = this.processColumns(rows);
rows = this.processHeaderCells(rows, columns);
return { rows: rows, columns: this.generateActualColumns(columns) };
};
ExportHelper.prototype.getConvertedWidth = function (input) {
var value = parseFloat(input);
return (input.indexOf('%') !== -1) ? (this.parent.element.getBoundingClientRect().width * value / 100) : value;
};
ExportHelper.prototype.generateActualColumns = function (columns, actualColumns) {
if (actualColumns === void 0) { actualColumns = []; }
for (var _i = 0, columns_2 = columns; _i < columns_2.length; _i++) {
var column = columns_2[_i];
if (column.commands) {
continue;
}
if (!column.columns) {
if (column.visible || this.hideColumnInclude) {
actualColumns.push(column);
}
}
else {
if (column.visible || this.hideColumnInclude) {
var colSpan = this.getCellCount(column, 0);
if (colSpan !== 0) {
this.generateActualColumns(column.columns, actualColumns);
}
}
}
}
return actualColumns;
};
ExportHelper.prototype.processHeaderCells = function (rows, cols) {
var columns = cols;
for (var i = 0; i < columns.length; i++) {
if (!columns[parseInt(i.toString(), 10)].commands) {
rows = this.appendGridCells(columns[parseInt(i.toString(), 10)], rows, 0);
}
}
return rows;
};
ExportHelper.prototype.appendGridCells = function (cols, gridRows, index) {
if (!cols.columns && (cols.visible !== false || this.hideColumnInclude) && !cols.commands) {
gridRows[parseInt(index.toString(), 10)].cells.push(this.generateCell(cols, CellType.Header, this.colDepth - index, index));
}
else if (cols.columns) {
var colSpan = this.getCellCount(cols, 0);
if (colSpan) {
gridRows[parseInt(index.toString(), 10)].cells.push(new Cell({
cellType: CellType.StackedHeader, column: cols, colSpan: colSpan
}));
}
var isIgnoreFirstCell = void 0;
for (var i = 0, len = cols.columns.length; i < len; i++) {
if (cols.columns[parseInt(i.toString(), 10)].visible && !isIgnoreFirstCell) {
isIgnoreFirstCell = true;
}
gridRows = this.appendGridCells(cols.columns[parseInt(i.toString(), 10)], gridRows, index + 1);
}
}
return gridRows;
};
ExportHelper.prototype.generateCell = function (gridColumn, cellType, rowSpan, rowIndex) {
var option = {
'visible': gridColumn.visible,
'isDataCell': cellType === CellType.Data,
'column': gridColumn,
'cellType': cellType,
'rowSpan': rowSpan,
'index': rowIndex
};
if (!option.rowSpan || option.rowSpan < 2) {
delete option.rowSpan;
}
return new Cell(option);
};
ExportHelper.prototype.processColumns = function (rows) {
//TODO: generate dummy column for group, detail, stacked row here; ensureColumns here
var gridObj = this.parent;
var columnIndexes = [];
if (gridObj.enableColumnVirtualization) {
columnIndexes = gridObj.getColumnIndexesInView();
}
for (var i = 0, len = rows.length; i < len; i++) {
if (gridObj.allowGrouping) {
for (var j = 0, len_1 = gridObj.groupSettings.columns.length - 1; j < len_1; j++) {
if (gridObj.enableColumnVirtualization && columnIndexes.indexOf(j) === -1) {
continue;
}
rows[parseInt(i.toString(), 10)].cells.splice(0, 0, this.generateCell({}, CellType.HeaderIndent));
}
}
}
return rows;
};
ExportHelper.prototype.getCellCount = function (column, count) {
if (column.columns) {
for (var i = 0; i < column.columns.length; i++) {
count = this.getCellCount(column.columns[parseInt(i.toString(), 10)], count);
}
}
else {
if (column.visible || this.hideColumnInclude) {
count++;
}
}
return count;
};
ExportHelper.prototype.checkAndExport = function (gridPool, globalResolve) {
var bool = Object.keys(gridPool).some(function (key) {
return !gridPool["" + key];
});
if (!bool) {
globalResolve();
}
};
ExportHelper.prototype.failureHandler = function (gridPool, childGridObj, resolve) {
var _this = this;
return function () {
gridPool[childGridObj.id] = true;
_this.checkAndExport(gridPool, resolve);
};
};
ExportHelper.prototype.createChildGrid = function (gObj, row, exportType, gridPool) {
var childGridObj = new Grid(this.parent.detailRowModule.getGridModel(gObj, row, exportType));
gObj.isPrinting = false;
var parent = 'parentDetails';
childGridObj["" + parent] = {
parentID: gObj.element.id,
parentPrimaryKeys: gObj.getPrimaryKeyFieldNames(),
parentKeyField: gObj.childGrid.queryString,
parentKeyFieldValue: getValue(childGridObj.queryString, row.data),
parentRowData: row.data
};
var exportId = getUid('child-grid');
var element = createElement('div', { id: exportId });
element.style.display = 'none';
document.body.appendChild(element);
childGridObj.id = exportId;
gridPool["" + exportId] = false;
childGridObj.isExportGrid = true;
return { childGrid: childGridObj, element: element };
};
ExportHelper.prototype.getGridExportColumns = function (columns) {
var actualGridColumns = [];
for (var i = 0, gridColumns = columns; i < gridColumns.length; i++) {
if (gridColumns[parseInt(i.toString(), 10)].type !== 'checkbox') {
actualGridColumns.push(gridColumns[parseInt(i.toString(), 10)]);
}
}
return actualGridColumns;
};
/**
* Gets the foreignkey data.
*
* @returns {ForeignKeyFormat} returns the foreignkey data
* @hidden
*/
ExportHelper.prototype.getForeignKeyData = function () {
return this.foreignKeyData;
};
return ExportHelper;
}());
export { ExportHelper };
/**
* @hidden
* `ExportValueFormatter` for `PdfExport` & `ExcelExport`
*/
var ExportValueFormatter = /** @class */ (function () {
function ExportValueFormatter(culture) {
this.valueFormatter = new ValueFormatter(culture);
this.internationalization = new Internationalization(culture);
}
ExportValueFormatter.prototype.returnFormattedValue = function (args, customFormat) {
if (!isNullOrUndefined(args.value) && args.value) {
return this.valueFormatter.getFormatFunction(customFormat)(args.value);
}
else {
return '';
}
};
/**
* Used to format the exporting cell value
*
* @param {ExportHelperArgs} args - Specifies cell details.
* @returns {string} returns formated value
* @hidden
*/
ExportValueFormatter.prototype.formatCellValue = function (args) {
if (args.isForeignKey) {
args.value = getValue(args.column.foreignKeyValue, getForeignData(args.column, {}, args.value)[0]);
}
if (args.column.type === 'number' && args.column.format !== undefined && args.column.format !== '') {
if (typeof args.column.format === 'string') {
args.column.format = { format: args.column.format };
}
return args.value || args.value === 0 ?
this.internationalization.getNumberFormat(args.column.format)(args.value) : '';
}
else if (args.column.type === 'boolean' && args.value !== '') {
return args.value ? 'true' : 'false';
/* tslint:disable-next-line:max-line-length */
}
else if ((args.column.type === 'date' || args.column.type === 'dateonly' || args.column.type === 'datetime' || args.column.type === 'time') && args.column.format !== undefined) {
if (typeof args.value === 'string') {
args.value = new Date(args.value);
}
if (typeof args.column.format === 'string') {
var format = void 0;
var cFormat = args.column.format;
if (args.column.type === 'date' || args.column.type === 'dateonly') {
format = { type: 'date', skeleton: cFormat };
}
else if (args.column.type === 'time') {
format = { type: 'time', skeleton: cFormat };
}
else {
format = { type: 'dateTime', skeleton: cFormat };
}
return this.returnFormattedValue(args, format);
}
else {
if (args.column.format instanceof Object && args.column.format.type === undefined) {
return (args.value.toString());
}
else {
var customFormat = void 0;
if (args.column.type === 'date' || args.column.type === 'dateonly') {
customFormat = {
type: args.column.format.type,
format: args.column.format.format, skeleton: args.column.format.skeleton
};
}
else if (args.column.type === 'time') {
customFormat = { type: 'time', format: args.column.format.format, skeleton: args.column.format.skeleton };
}
else {
customFormat = { type: 'dateTime', format: args.column.format.format, skeleton: args.column.format.skeleton };
}
return this.returnFormattedValue(args, customFormat);
}
}
}
else {
if ((!isNullOrUndefined(args.column.type) && !isNullOrUndefined(args.value)) || !isNullOrUndefined(args.value)) {
return (args.value).toString();
}
else {
return '';
}
}
};
return ExportValueFormatter;
}());
export { ExportValueFormatter };