svogv
Version:
A decorator based approach for model driven forms, including an advanced DataGrid and a TreeView component.
203 lines • 24.5 kB
JavaScript
import { EventEmitter } from '@angular/core';
import '../../../utils/object-extensions';
import { DataGridHeaderModel } from './datagridheader.model';
import { Display, Hidden, UiHint } from '../../../decorators';
/**
* Sort direction, controlled by simple string comparision or a callback.
*/
export var Direction;
(function (Direction) {
Direction[Direction["Ascending"] = 0] = "Ascending";
Direction[Direction["Descending"] = 1] = "Descending";
})(Direction || (Direction = {}));
/**
* The controlling class for Grid applications.
*
* This class takes an array of elements and handles:
* - visible headers, managed by @Hidden() decorator
* - create header titles, managed by @Display() decorator
* - sorting
* - filtering
* - count total rows
* - paging
*/
export class DataGridModel {
constructor(items, type, pageSize = 10) {
/**
* The search value filters the rows. Provide the property name and the filter instruction. Search is pure client.
*/
this.searchValue = {};
this.currentPageIndex = 1;
/**
* Event fired if user clicks Edit button.
*/
this.onEdit = new EventEmitter();
/**
* Event fired if user clicks Delete button.
*/
this.onDelete = new EventEmitter();
/**
* Current sort direction per column.
*/
this.sortDirection = {};
this._items = items;
this.pageSize = pageSize;
const typeInstance = new type();
if (typeInstance) {
// make header from decorators, omit if null
this.createHeadersForType(typeInstance);
}
}
/**
* Returns the number of rows regardless the actual filter (the total).
*/
get totalRows() {
return this._items.length;
}
get totalFilteredRows() {
return this.itemsFiltered ? this.itemsFiltered.length : 0;
}
get currentRowStart() {
return this.totalRows > this.pageSize ? this.startRow + 1 : this.totalRows === 0 ? 0 : 1;
}
get currentRowEnd() {
return this.startRow + this.pageSize < this.totalRows ? this.startRow + this.pageSize : this.totalRows;
}
get startRow() {
if (this.currentPageIndex === 0) {
return 0;
}
return (this.currentPageIndex - 1) * this.pageSize;
}
get maxPageIndex() {
const index = Math.ceil(this.totalFilteredRows / this.pageSize);
return index;
}
set items(value) {
this._items = value;
}
get items() {
return this._items;
}
get itemsFiltered() {
// not actually a filter present
if (!this.searchValue || (Object.keys(this.searchValue).length === 0 && this.searchValue.constructor === Object)) {
return this.items;
}
return this.items.filter((item) => {
// tslint:disable-next-line:forin
for (const s in this.searchValue) {
const pattern = new RegExp(this.searchValue[s]);
if (pattern.test(item[s])) {
return true;
}
}
return false;
});
}
get itemsOnCurrentPage() {
return this.itemsFiltered.slice(this.startRow, this.startRow + this.pageSize);
}
/**
* Get all headers (column names) and their properties.
*/
get headers() {
return this._headers.filter((h) => !h.hidden);
}
/**
* Returns the columns currently not shown. {@link addColumn and @see removeColumn for more}information.
*/
get headersNotVisible() {
return this._headers.filter((h) => h.hidden);
}
/**
* Simple sort fucntion that makes a array sort call for the specified column.
* @param colName The column which has to be sorted after.
* // tslint:disable-next-line:max-line-length
* @param dir The order, descended is *desc*, any other string is ascending.
* If nothing is provided, the direction toggles. Initital value is *ascending*.
*/
sortColumn(colName, dir, sortCallback) {
if (!dir) {
// if nothing is provided, toggle current
dir = this.sortDirection[colName] === Direction.Ascending ? Direction.Descending : Direction.Ascending;
}
// remember last and update UI
this.sortDirection[colName] = dir;
if (sortCallback) {
this.items.sort(sortCallback);
}
else {
this.items.sort((a, b) => {
if (dir === Direction.Descending) {
return a[colName] > b[colName] ? 1 : -1;
}
else {
return a[colName] > b[colName] ? -1 : 1;
}
});
}
}
/**
* Make a column invisible. This is just changing the render process, the column is still
* in the headers collection and can be made visible again by calling {@link addColumn}later.
*/
removeColumn(colname) {
const col = this._headers.find((h) => h.prop === colname);
if (col) {
col.hidden = true;
}
}
/**
* Add a column to the current grid, that has been removed recently.
* It's just adding columns that already exists in the headers collection.
* If the column name provided does not exists, the method does nothing.
*/
addColumn(colname) {
const col = this._headers.find((h) => h.prop === colname);
if (col) {
col.hidden = false;
}
}
/**
* Called by infrastructure to inform caller of edit wish
* @param item The item to edit
*/
editItem(item) {
this.onEdit.emit(item);
}
/**
* Called by infrastructure to inform caller of delete wish
* @param item The item to delete
*/
deleteItem(item) {
this.onDelete.emit(item);
}
createHeadersForType(type) {
// assume simple object structure, iterating an array of viewmodels
// has at least one row, so we can read the headers
// first we read the properties
this._headers = new Array();
for (const p in type) {
if (!type.hasOwnProperty(p)) {
continue;
}
const propName = Display.Name(type, p, p);
const propDesc = Display.Desc(type, p, p);
// check if hidden, show if no hidden decorator
const isHidden = Hidden.IsHidden(type, p, false);
const header = new DataGridHeaderModel(propName, propDesc, p, isHidden);
// sorting
header.isSortable = type[`__isSortable__${p}`] === undefined ? true : !!type[`__isSortable__${p}`];
header.sortCallback = type[`__sortCallback__${p}`] || undefined;
// look for templates and pipes provided by user, if none, we have templates for all ES types
header.templateHint = type[`__templatehint__${p}`] || typeof type[p];
header.templateHintParams = type[`__templatehintParams__${p}`];
header.pipe = type[`__uipipe__${p}`];
header.pipeParams = type[`__pipeparams__${p}`];
header.uiHint = UiHint.HintRule(type, p, {});
this._headers.push(header);
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datagrid.model.js","sourceRoot":"../../../projects/svogv/src/","sources":["lib/widgets/datagrid/models/datagrid.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { Type, EventEmitter, Directive } from '@angular/core';\n\nimport '../../../utils/object-extensions';\nimport { DataGridHeaderModel } from './datagridheader.model';\nimport { Display, Hidden, UiHint } from '../../../decorators';\n\n/**\n * Sort direction, controlled by simple string comparision or a callback.\n */\nexport enum Direction {\n  Ascending,\n  Descending\n}\n\n/**\n * The controlling class for Grid applications.\n *\n * This class takes an array of elements and handles:\n * - visible headers, managed by @Hidden() decorator\n * - create header titles, managed by @Display() decorator\n * - sorting\n * - filtering\n * - count total rows\n * - paging\n */\nexport class DataGridModel<T> {\n\n  /**\n   * Returns the number of rows regardless the actual filter (the total).\n   */\n  get totalRows(): number {\n    return this._items.length;\n  }\n\n  get totalFilteredRows(): number {\n    return this.itemsFiltered ? this.itemsFiltered.length : 0;\n  }\n\n  private get currentRowStart(): number {\n    return this.totalRows > this.pageSize ? this.startRow + 1 : this.totalRows === 0 ? 0 : 1;\n  }\n  private get currentRowEnd(): number {\n    return this.startRow + this.pageSize < this.totalRows ? this.startRow + this.pageSize : this.totalRows;\n  }\n\n  get startRow(): number {\n    if (this.currentPageIndex === 0) {\n      return 0;\n    }\n    return (this.currentPageIndex - 1) * this.pageSize;\n  }\n\n  get maxPageIndex(): number {\n    const index = Math.ceil(this.totalFilteredRows / this.pageSize);\n    return index;\n  }\n\n  set items(value: T[]) {\n    this._items = value;\n  }\n  get items(): T[] {\n    return this._items;\n  }\n\n  get itemsFiltered(): T[] {\n    // not actually a filter present\n    if (!this.searchValue || (Object.keys(this.searchValue).length === 0 && this.searchValue.constructor === Object)) {\n      return this.items;\n    }\n    return this.items.filter((item) => {\n      // tslint:disable-next-line:forin\n      for (const s in this.searchValue) {\n        const pattern = new RegExp(this.searchValue[s]);\n        if (pattern.test(item[s])) {\n          return true;\n        }\n      }\n      return false;\n    });\n  }\n\n  get itemsOnCurrentPage(): T[] {\n    return this.itemsFiltered.slice(this.startRow, this.startRow + this.pageSize);\n  }\n\n  /**\n   * Get all headers (column names) and their properties.\n   */\n  public get headers(): DataGridHeaderModel[] {\n    return this._headers.filter((h) => !h.hidden);\n  }\n\n  /**\n   * Returns the columns currently not shown. {@link addColumn and @see removeColumn for more}information.\n   */\n  public get headersNotVisible(): DataGridHeaderModel[] {\n    return this._headers.filter((h) => h.hidden);\n  }\n  /**\n   * The search value filters the rows. Provide the property name and the filter instruction. Search is pure client.\n   */\n  public searchValue: { [prop: string]: any } = {};\n\n  public currentPageIndex = 1;\n  public pageSize: number;\n\n  /**\n   * Event fired if user clicks Edit button.\n   */\n  public onEdit: EventEmitter<T> = new EventEmitter<T>();\n\n  /**\n   * Event fired if user clicks Delete button.\n   */\n  public onDelete: EventEmitter<T> = new EventEmitter<T>();\n\n  /**\n   * Current sort direction per column.\n   */\n  public sortDirection: { [column: string]: Direction } = {};\n  private _items: T[];\n\n  private _headers: DataGridHeaderModel[];\n  constructor(items: T[], type: Type<T>, pageSize = 10) {\n    this._items = items;\n    this.pageSize = pageSize;\n    const typeInstance = new type();\n    if (typeInstance) {\n      // make header from decorators, omit if null\n      this.createHeadersForType(typeInstance);\n    }\n  }\n\n  /**\n   * Simple sort fucntion that makes a array sort call for the specified column.\n   * @param colName The column which has to be sorted after.\n   * // tslint:disable-next-line:max-line-length\n   * @param dir The order, descended is *desc*, any other string is ascending.\n   *            If nothing is provided, the direction toggles. Initital value is *ascending*.\n   */\n  public sortColumn(colName: string, dir: Direction, sortCallback?: (a, b) => 1 | -1 | 0) {\n    if (!dir) {\n      // if nothing is provided, toggle current\n      dir = this.sortDirection[colName] === Direction.Ascending ? Direction.Descending : Direction.Ascending;\n    }\n    // remember last and update UI\n    this.sortDirection[colName] = dir;\n    if (sortCallback) {\n      this.items.sort(sortCallback);\n    } else {\n      this.items.sort((a: any, b: any) => {\n        if (dir === Direction.Descending) {\n          return a[colName] > b[colName] ? 1 : -1;\n        } else {\n          return a[colName] > b[colName] ? -1 : 1;\n        }\n      });\n    }\n  }\n\n  /**\n   * Make a column invisible. This is just changing the render process, the column is still\n   * in the headers collection and can be made visible again by calling {@link addColumn}later.\n   */\n  public removeColumn(colname: string) {\n    const col = this._headers.find((h) => h.prop === colname);\n    if (col) {\n      col.hidden = true;\n    }\n  }\n\n  /**\n   * Add a column to the current grid, that has been removed recently.\n   * It's just adding columns that already exists in the headers collection.\n   * If the column name provided does not exists, the method does nothing.\n   */\n  public addColumn(colname: string) {\n    const col = this._headers.find((h) => h.prop === colname);\n    if (col) {\n      col.hidden = false;\n    }\n  }\n\n  /**\n   * Called by infrastructure to inform caller of edit wish\n   * @param item The item to edit\n   */\n  public editItem(item: T) {\n    this.onEdit.emit(item);\n  }\n\n  /**\n   * Called by infrastructure to inform caller of delete wish\n   * @param item The item to delete\n   */\n  public deleteItem(item: T) {\n    this.onDelete.emit(item);\n  }\n\n  private createHeadersForType(type: any): void {\n    // assume simple object structure, iterating an array of viewmodels\n    // has at least one row, so we can read the headers\n    // first we read the properties\n    this._headers = new Array<DataGridHeaderModel>();\n    for (const p in type) {\n      if (!type.hasOwnProperty(p)) {\n        continue;\n      }\n      const propName = Display.Name(type, p, p);\n      const propDesc = Display.Desc(type, p, p);\n      // check if hidden, show if no hidden decorator\n      const isHidden = Hidden.IsHidden(type, p, false);\n      const header = new DataGridHeaderModel(propName, propDesc, p, isHidden);\n      // sorting\n      header.isSortable = type[`__isSortable__${p}`] === undefined ? true : !!type[`__isSortable__${p}`];\n      header.sortCallback = type[`__sortCallback__${p}`] || undefined;\n      // look for templates and pipes provided by user, if none, we have templates for all ES types\n      header.templateHint = type[`__templatehint__${p}`] || typeof type[p];\n      header.templateHintParams = type[`__templatehintParams__${p}`];\n      header.pipe = type[`__uipipe__${p}`];\n      header.pipeParams = type[`__pipeparams__${p}`];\n      header.uiHint = UiHint.HintRule(type, p, {});\n      this._headers.push(header);\n    }\n  }\n}\n"]}