mmhglobal-dynamicform 1.2.2 → 1.3.1

package/esm2020/lib/zgrid/zgrid.component.mjs

@@ -0,0 +1,838 @@
+/********** Angular **********/
+import { Component, Input, ViewChild } from "@angular/core";
+import { FormGroup, Validators, FormControl, FormArray } from '@angular/forms';
+/********** Ionic **********/
+/********** Plugin **********/
+import { of, Subject } from "rxjs";
+import { tap, map, switchMap, concatMap } from "rxjs/operators";
+import { process } from "@progress/kendo-data-query";
+import { TooltipDirective } from '@progress/kendo-angular-tooltip';
+import { ZComponentProperties, ZComponentHelper } from 'mmhglobal-zcore';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/forms";
+import * as i3 from "mmhglobal-zcore";
+import * as i4 from "../services/main.service";
+import * as i5 from "@progress/kendo-angular-grid";
+import * as i6 from "./date-range-cell-filter.component";
+import * as i7 from "@progress/kendo-angular-inputs";
+import * as i8 from "@progress/kendo-angular-popup";
+import * as i9 from "@ionic/angular";
+import * as i10 from "../zselectmultiple/zselectmultiple.component";
+import * as i11 from "../ztextarea/ztextarea.component";
+import * as i12 from "../zdatetime/zdatetime.component";
+import * as i13 from "@fortawesome/angular-fontawesome";
+import * as i14 from "@angular/common";
+import * as i15 from "@progress/kendo-angular-tooltip";
+import * as i16 from "./zgrid.binding.directive";
+import * as i17 from "@progress/kendo-angular-buttons";
+export class ZgridComponent {
+    constructor(activatedRoute, router, formBuilder, authService, webApiService, zGridStatePersistingService, toastService, zcoreService, storageService, mainService) {
+        this.activatedRoute = activatedRoute;
+        this.router = router;
+        this.formBuilder = formBuilder;
+        this.authService = authService;
+        this.webApiService = webApiService;
+        this.zGridStatePersistingService = zGridStatePersistingService;
+        this.toastService = toastService;
+        this.zcoreService = zcoreService;
+        this.storageService = storageService;
+        this.mainService = mainService;
+        // @ViewChild(ZGridBindingDirective, { static: false }) zgrid: ZGridBindingDirective;
+        this.zgrid = null;
+        this.oauthUrl = null;
+        this.mySelection = [];
+        this.componentProperties = new ZComponentProperties();
+        // eslint-disable-next-line @typescript-eslint/naming-convention, no-underscore-dangle, id-blacklist, id-match
+        this._state = {
+            skip: 0,
+            take: 10
+        };
+        this.params = {
+            referId: null,
+            pageNo: 0,
+            pageSize: 20,
+            sortColumnName: "",
+            sortOrder: "",
+            sortColumnNames: [],
+            sortOrders: [],
+            filterParams: [],
+            parameters: "",
+            filters: "",
+            columns: "",
+            grantType: 4
+        };
+        this.gridSubject = new Subject();
+        this.gridDefaultStateExist = false;
+        this.isNew = true;
+        this.setData = (gData) => {
+            this.gridData = {
+                data: gData,
+                total: (gData ? gData.length : 0)
+            };
+            this.gData = gData;
+            if (this.zgrid) {
+                this.zgrid.grid['pageSize'] = gData.length; // set grid size
+            }
+            if (!!this.data.ShowRecordNumber) {
+                if (this.gridData.data) {
+                    this.gridData.data.forEach((d, i) => {
+                        d.GridNo = i + 1;
+                    });
+                }
+            }
+            if (this.gData) {
+                this.createFormControls();
+            }
+        };
+        /* Available Functions */
+        this.setEnable = (status) => {
+            this.componentProperties.isReadOnly = !status;
+        };
+        this.setVisible = (status) => {
+            this.componentProperties.isVisible = status;
+            this.data.Visible = status;
+        };
+        this.setRequire = (status) => {
+            this.componentProperties.isRequired = status;
+            ZComponentHelper.changeValidator(status, this.group, this.data.Value, this.componentProperties, Validators.required);
+        };
+        this.oauthUrl = this.zcoreService.getEnvironment().e1OauthUrl + "/";
+        this.allResults = this.allResults.bind(this);
+        this.refreshData = this.refreshData.bind(this);
+        this.clearData = this.clearData.bind(this);
+        this.saveGridSettings = this.saveGridSettings.bind(this);
+        this.restoreGridSettings = this.restoreGridSettings.bind(this);
+    }
+    ngOnInit() {
+        ZComponentHelper.setComponentProperties(this);
+        ZComponentHelper.registerComponent(this);
+        // Grid saved setting key(Used in CookieStore & LocalStorage)
+        this.gridStorageKey = 'ionic-field::' + this.authService.e1Token.userName + '::' + this.data.Name + '::' + this.router.url;
+        of(true)
+            .pipe(
+        //concatMap(() => {
+        //  // try get gridsetting from cookiestore
+        //  return this.mainService.cookieStoreGet(this.gridStorageKey, this.authService.e1Token.access_token);
+        //}),
+        //switchMap(savedGridCache => {
+        //  if (savedGridCache) {  
+        //    // Keep the gridSetting from cookiestore to localStorage
+        //    this.zGridStatePersistingService.set(this.gridStorageKey, savedGridCache);
+        //    return of(true);
+        //  }
+        //  return of(false);
+        //}),
+        switchMap(() => {
+            // Grid default setting
+            this.columns = [];
+            this.widthReduce = this.data.WidthReduce || 60;
+            this.heightReduce = this.data.HeightReduce || 560;
+            this._state.take = this.data.PageSize || 20;
+            this.pageSizes = [20, 50, 100, 200, 500];
+            this.previousNext = this.data['EnablePreviousNextButton'] || false;
+            // [Mobile] Disable PageSize
+            if (this.data.PageSizes === false || ZComponentHelper.isMobileScreen()) {
+                this.pageSizes = false;
+            }
+            // Grid Selection column
+            if (this.data.SelectOptions) {
+                this.selectableSettings = {
+                    // checkboxOnly: this.checkboxOnly,
+                    mode: this.data.SelectOptions === 'single' ? 'single' : 'multiple'
+                };
+            }
+            // bind this to group using Grid value
+            if (this.data.Value.startsWith('group.')) {
+                const gridValue = this.data.Value.slice(6);
+                this.group[gridValue] = this;
+            }
+            // clear any Subscription
+            if (this.subscription) {
+                this.subscription.unsubscribe();
+            }
+            // if no ResourceURL, still generate Column first, then insert grid data using DataSource
+            if (!this.data.ResourceURL) {
+                this.generateGridColumns().subscribe(() => {
+                    if (this.data.DataSource && this.data.SkipDirective) {
+                        const ds = ZComponentHelper.getGroupValue(this.data.DataSource, this.group);
+                        this.setData(ds);
+                    }
+                });
+            }
+            // subscribe to set grid setting from directive to component
+            this.subscription = this.gridSubject.subscribe(grid => {
+                this.zgrid = grid;
+                this._state = this.zgrid.state;
+                this.columns = this.zgrid.gridColumns;
+                if (this.zgrid && this.zgrid.grid.data) {
+                    this.gridData = Object.assign({}, this.zgrid.grid.data);
+                    this.createFormControls();
+                }
+            });
+            // Check Grid setting exist in localstorage
+            this.stateExist();
+            // Set Filter SessionKey
+            if (this.data['SaveFilter']) {
+                this.setGridSessionKey(this.group);
+            }
+            return of(true);
+        }), tap(() => {
+            this.gridCallback(this.group);
+        })).subscribe();
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    /* Start Grid State (pagination, sortable, filter, ordering) */
+    get state() {
+        return this._state;
+    }
+    stateExist() {
+        const userGridState = this.zGridStatePersistingService.get(this.gridStorageKey);
+        if (userGridState) {
+            this.gridDefaultStateExist = true;
+        }
+        else {
+            this.gridDefaultStateExist = false;
+        }
+    }
+    dataStateChange(state) {
+        if (this.zgrid) {
+            this.zgrid.dataStateChange(state);
+        }
+        else {
+            this.gridData = process(this.gData, state);
+            this.createFormControls();
+        }
+    }
+    filterable(value) {
+        if (value === false) {
+            return false;
+        }
+        return true;
+    }
+    sortable(value) {
+        if (value === false) {
+            return false;
+        }
+        return true;
+    }
+    locked(colSetting) {
+        if (colSetting['pinnedLeft'] == true) {
+            return true;
+        }
+        return false;
+    }
+    /* End Grid State (pagination, sortable, filter, ordering) */
+    /* Start Grid Styling, Display */
+    getGridStyle() {
+        return {
+            "height.px": this.getGridHeight(),
+            "width.px": window.innerWidth - this.widthReduce
+        }; // "width.px": this.innerWidth - 35
+    }
+    getGridHeight() {
+        const gridHeight = window.innerHeight - this.heightReduce;
+        return (gridHeight < 250) ? 250 : gridHeight;
+        // const v = ZComponentHelper.isMobileScreen();
+        // if(v){
+        //   const h = window.innerHeight - this.heightReduce;
+        //   return (h < 250) ? 250 : h;
+        // }else{
+        //   return "auto";
+        // } 
+    }
+    /* End Grid Styling, Display */
+    /* Start Grid Columns */
+    isSelectOption() {
+        let selectOptionExist = false;
+        if (this.data.SelectOptions) {
+            this.selectableSettings = {
+                checkboxOnly: false,
+                mode: (this.data.SelectOptions == "multiple") ? "multiple" : "single"
+            };
+            selectOptionExist = true;
+        }
+        return selectOptionExist;
+    }
+    setColumns(columnName, columns) {
+        this.group[columnName] = this.wrapColumnNamesInFieldElement(columns);
+        this.generateGridColumns().subscribe();
+    }
+    wrapColumnNamesInFieldElement(columnList) {
+        return of(columnList.map(c => {
+            const isHidden = c.Hidden;
+            return {
+                Name: c.Name,
+                Value: c.Code,
+                Type: c.Type,
+                gridColVisible: !isHidden,
+                width: 100 + c.Name.length * 4,
+                enableFiltering: false,
+                enableSorting: true,
+                enablePinning: true,
+                DivClass: "col-xs-12 col-sm-6",
+                IsEditableInGrid: c.Editable
+            };
+        }));
+    }
+    generateGridColumns() {
+        const gridSetting = this.getGridSettings();
+        const columnFields$ = ZComponentHelper.getGroupValue(this.data.ColumnFields, this.group);
+        if (!this.data.ColumnFields) {
+            console.warn('Invalid/Empty grid(' + this.data.Name + ') columnField');
+        }
+        return columnFields$.pipe(tap(data => {
+            if (!data) {
+                console.warn('Invalid/Empty grid(' + this.data.Name + ') data to generate column');
+            }
+            const fieldName = this.data['FieldElementName'];
+            this.columns = [];
+            ZComponentHelper.getGridColumns(data, this.columns, this.group, this.authService, fieldName, gridSetting, null, this.data);
+        }));
+    }
+    /* End Grid Columns */
+    editModel(dataItem) {
+        if (this.data.EditClickURL) {
+            // Edit incell field
+            const colFields = ZComponentHelper.getGroupValue(this.data.ColumnFields, this.group);
+            this.group.subject.next({
+                type: "zgrid-cellClick",
+                target: this.data.EditClickURL,
+                data: dataItem,
+                columnFields$: colFields
+            });
+        }
+        else {
+            // When clicked route to page
+            this.router.navigate([this.group.editModelURL, dataItem.Id, 'edit'], {
+                relativeTo: this.activatedRoute
+            });
+        }
+    }
+    gridCallback(group) {
+        if (this.data['AfterloadCallback']) {
+            const me = Object.assign({}, this);
+            this.group.subject.next({
+                type: "zgrid-AfterloadCallback",
+                target: this.data['AfterloadCallback'],
+                data: me
+            });
+        }
+    }
+    getData() {
+        if (this.zgrid) {
+            this.zgrid.getDataBinding();
+        }
+        if (this.data.SkipDirective) {
+            this.gridData = process(this.gData, this.state);
+            this.createFormControls();
+        }
+    }
+    getGridData() {
+        return this.gData;
+    }
+    getFormControl(rowIndex, property) {
+        const formArray = this.inlineEditedFormGroups.get('items');
+        const formItem = formArray.at(rowIndex);
+        if (formItem) {
+            return formItem.get(property);
+        }
+        else {
+            return null;
+        }
+    }
+    createFormControls() {
+        if (this.columns) {
+            // only create if there is at least 1 editable column
+            if (this.columns.find(c => c.isEditableInGrid) === undefined) {
+                return;
+            }
+            this.inlineEditedFormGroups = new FormGroup({ items: new FormArray([]) });
+            if (Array.isArray(this.gridData.data)) {
+                this.gridData.data.forEach(d => {
+                    const items = {};
+                    this.columns.forEach(c => {
+                        items[c.field] = new FormControl(d[c.field]);
+                    });
+                    const formGroup = new FormGroup(items);
+                    this.inlineEditedFormGroups.get("items").push(formGroup);
+                });
+            }
+        }
+    }
+    createFormGroup(dataItem, fieldName) {
+        return this.formBuilder.group({
+            [fieldName]: dataItem[fieldName]
+        });
+    }
+    getGroupValue(value, group) {
+        return ZComponentHelper.getGroupValue(this.data.Value, this.group);
+    }
+    onBtnClick(event, colSetting, rowData, cellData) {
+        this.onNavigateTo(event, colSetting, rowData, cellData);
+    }
+    cellClickHandler(event) {
+        const disableAllColumnCellClickHandler = this.data.DisableCellClickHandler ? this.data.DisableCellClickHandler : false;
+        const isCommandColumn = event.column.constructor.name == 'CommandColumnComponent' ? true : false;
+        if (!disableAllColumnCellClickHandler && !isCommandColumn) {
+            const inCellEditable = this.data.InCellEditable ? this.data.InCellEditable : false;
+            if (inCellEditable) {
+                this.editableColumns = this.columns.filter(s => s.isEditableInDataItem === true);
+                if (!!this.editableColumns) {
+                    this.editableColumns.map(s => event.sender.editCell(event.rowIndex, event.columnIndex, this.createFormGroup(event.dataItem, s.field)));
+                }
+            }
+            else {
+                console.log("cellClick event: ", event);
+                if (this.data.OnItemClick) {
+                    const func = ZComponentHelper.getGroupEvalValue.call(this, this.data.OnItemClick);
+                    if (typeof func === 'function') {
+                        const callFunc = func.bind(this.group.ctrlScope);
+                        callFunc(event);
+                    }
+                    return;
+                }
+                this.editModel(event.dataItem);
+            }
+        }
+    }
+    editCellCloseHandler(args) {
+        const { formGroup, dataItem } = args;
+        if (!formGroup.valid) {
+            args.preventDefault();
+        }
+        else if (formGroup.dirty) {
+            this.editableColumns = this.columns.filter(s => s.isEditableInDataItem === true);
+            this.editableColumns.map(s => Object.assign(dataItem, { [s.field]: formGroup.value[s.field] }));
+            this.mySelection.map(s => (s.Id === dataItem.Id) ? Object.assign(s, dataItem) : null);
+        }
+    }
+    onNavigateTo(event, clickAction, rowData, cellData) {
+        // debugger;
+        // const n = colSetting.navigateTo.replace('/:id', cellData);
+        const n = ZComponentHelper.getGroupEvalValue.call(this, clickAction.Click);
+        if (n) {
+            event.stopPropagation();
+            this.group.subject.next({
+                type: 'zgrid-onNavigateTo',
+                target: clickAction.Click,
+                rowData: rowData,
+                data: cellData
+            });
+        }
+    }
+    showTooltip(e) {
+        const element = e.target;
+        let isCommandColumn = false;
+        element.classList.forEach(data => {
+            if (data == 'k-command-cell') {
+                isCommandColumn = true;
+            }
+        });
+        if (((element.nodeName === 'TD' || element.nodeName === 'TH') && element.offsetWidth < element.scrollWidth) && !isCommandColumn) {
+            this.tooltipDir.toggle(element);
+        }
+        else {
+            this.tooltipDir.hide();
+        }
+    }
+    rowSelectionKey(context) {
+        return context.dataItem;
+    }
+    getSeletectedValues() {
+        return this.mySelection;
+    }
+    refreshGrid(event, group, me) {
+        const _gridOptionSegment = event.target.trim().split('.');
+        const _gridOption = _gridOptionSegment[1];
+        if (_gridOption) {
+            const zgridControl = group[_gridOption];
+            if (zgridControl) {
+                zgridControl.getData();
+            }
+            else {
+                console.log('Unable to find grid value: ' + _gridOption);
+            }
+        }
+        else {
+            console.log('Invalid refreshGrid event: ', event);
+        }
+    }
+    refreshData() {
+        this.getData();
+    }
+    clearData() {
+        this.zgrid.clearData();
+    }
+    allResults() {
+        const _zgridControl = this.zgrid;
+        const _zgridComponent = this.zgrid.grid;
+        const _data = _zgridComponent.data;
+        const paginationApiPostUrl = _zgridControl.paginationApiPostUrl;
+        // Need to clone, if not will affect the grid params.
+        const params = Object.assign({}, this.params);
+        params.pageNo = 0;
+        params.pageSize = _data.total;
+        return this.webApiService.httpPost$(paginationApiPostUrl, params).pipe(map((data) => {
+            const result = {
+                data: process(data.dataSet, {}).data
+            };
+            return result;
+        }));
+    }
+    getClass(dataItem, col) {
+        let ngClass = "gridCell ";
+        if (col.fieldType === 'number' || col.fieldType === 'currency' || col.fieldType === 'znumeric') {
+            ngClass += "rightAligned ";
+        }
+        if (dataItem[col.field + '_Class']) {
+            ngClass += dataItem[col.field + '_Class'] + " ";
+        }
+        if (col.Class) {
+            ngClass += col.Class + " ";
+        }
+        return ngClass;
+    }
+    getFormat(col, defaultFormat) {
+        let format = "";
+        if (col.FormatOptions === undefined) {
+            format = defaultFormat ? defaultFormat : "";
+        }
+        else {
+            const formatArr = col.FormatOptions.split(".");
+            let dp = 0;
+            if (formatArr.length > 1) {
+                dp = formatArr[1].length;
+            }
+            if (dp !== 0) {
+                format = "1." + dp + "-" + dp;
+            }
+        }
+        return format;
+    }
+    setHeaderText(columnName, newHeaderTitle) {
+        const gridColumns = this.columns;
+        gridColumns.forEach((col) => {
+            if (col.Name === columnName) {
+                col.title = newHeaderTitle;
+            }
+        });
+    }
+    setGridIsLoading(triggered) {
+        this.isLoading = triggered;
+    }
+    setGridSessionKey(group) {
+        if (group["GridStorageKey"]) {
+            return;
+        }
+        else {
+            group["GridStorageKey"] = 'zgrid_' + group.resourceURL + '_' + this.data.Value + '::' + this.authService.e1Token.userName;
+        }
+    }
+    trackBy(index, item) {
+        //console.log(item.data['Id'] || index);
+        return index;
+    }
+    /* Grid configuration function */
+    saveGridSettings() {
+        const _zgridComponent = this.zgrid.grid;
+        const _columns = _zgridComponent.columns;
+        of(this.columns)
+            .pipe(switchMap(() => {
+            const configValue = _columns.toArray().map(item => {
+                const _zGridColumnSettings = Object.keys(item)
+                    .filter(propName => {
+                    return !propName.toLowerCase().includes('template');
+                })
+                    .reduce((acc, curr) => ({
+                    ...acc,
+                    ...{ [curr]: item[curr] }
+                }), {});
+                return _zGridColumnSettings;
+            });
+            // remove extra element form array
+            configValue.forEach(item => {
+                delete item['headerStyle'];
+                delete item['__ngContext__'];
+            });
+            const gridSetting = {
+                // state: this.state,
+                columnsConfig: configValue
+            };
+            // Find any setting from localstorage and update, if not just add in.
+            let _arrGridCaching = this.zGridStatePersistingService.get(this.gridStorageKey);
+            let _gridConfig = null;
+            if (_arrGridCaching && _arrGridCaching[0]) {
+                _gridConfig = _arrGridCaching.find(x => x['dataFormFields'] === this.gridStorageKey);
+                if (_gridConfig) {
+                    _gridConfig.gridSettings = gridSetting;
+                }
+            }
+            else {
+                _arrGridCaching = [];
+            }
+            if (!_gridConfig) {
+                _gridConfig = {
+                    dataFormFields: this.gridStorageKey,
+                    gridSettings: gridSetting
+                };
+                _arrGridCaching.push(_gridConfig);
+            }
+            return _arrGridCaching;
+        }), concatMap(gridCache => {
+            // Save grid caching to localstorage
+            this.zGridStatePersistingService.set(this.gridStorageKey, gridCache);
+            // Save to CookieStore
+            return this.mainService.cookieStorePost(this.gridStorageKey, gridCache);
+        }), tap(savedGridCache => {
+            // check is saved state exist to enable/hide restore button
+            this.stateExist();
+        }), tap(() => {
+            // Alert
+            this.toastService.show('Grid Setting Saved', "top", true, 2000, 'success');
+        })).subscribe();
+    }
+    restoreGridSettings() {
+        of(true)
+            .pipe(switchMap(() => {
+            // Clear localstorage grid setting
+            this.zGridStatePersistingService.remove(this.gridStorageKey);
+            return of(true);
+        }), switchMap(() => {
+            // delete cookiestore gridSetting by storagekey as name
+            return this.mainService.cookieStoreDeleteMultiple(this.gridStorageKey);
+        }), concatMap(() => {
+            // Use original column setting
+            return this.generateGridColumns();
+        }), tap(() => {
+            // check is saved state exist
+            this.stateExist();
+            // Alert
+            this.toastService.show('Grid Setting Restored', "top", true, 2000, 'success');
+        })).subscribe();
+    }
+    getGridSettings() {
+        const _storageKey = 'ionic-field::' + this.authService.e1Token.userName + '::' + this.data.Name + '::' + this.router.url;
+        // Find any setting from localstorage..
+        let _arrGridCaching = this.zGridStatePersistingService.get(_storageKey);
+        if (_arrGridCaching) {
+            const _gridCaching = JSON.parse(_arrGridCaching['Value']);
+            if (_gridCaching) {
+                return _gridCaching.gridSettings.columnsConfig.sort((a, b) => a.orderIndex - b.orderIndex);
+            }
+        }
+    }
+    /* Inline setting */
+    getInlineField(value) {
+        return this.columns.find(x => x.Value === value);
+    }
+    getInlineForm(rowIndex) {
+        const formArray = this.inlineEditedFormGroups.get('items');
+        return formArray.at(rowIndex);
+    }
+    getFormControlData(value) {
+        return this.inlineEditedFormGroups.value.items;
+    }
+    /* Event */
+    beforeGridGetData(group, me) {
+        console.warn("beforeDataBinding triggered");
+        if (!group.beforeGridGetData) {
+            console.warn("group.beforeDataBinding is undefined");
+            return of(true);
+        }
+        return group.beforeGridGetData(group, me);
+    }
+    async getGridSessionFilter(group, me) {
+        if (!group["GridStorageKey"]) {
+            return null;
+        }
+        const StorageKey = group["GridStorageKey"];
+        if (this.storageService) {
+            await this.storageService.get(StorageKey)
+                .then(data => {
+                if (!data || !data.value || data.value === "null") {
+                    return null;
+                }
+                else {
+                    const result = JSON.parse(data.value);
+                    this.state.filter = JSON.parse(result["StateFilter"]);
+                    this.params.filterParams = JSON.parse(result["FilterParams"]);
+                    this.state.filter.filters.forEach((stateFilter) => {
+                        if (stateFilter.field.includes('UTC')) {
+                            stateFilter.value = new Date(stateFilter.value);
+                        }
+                    });
+                    return data;
+                }
+            });
+        }
+        else {
+            return null;
+        }
+    }
+    setGridSessionFilter(group, me) {
+        if (!group["GridStorageKey"]) {
+            return null;
+        }
+        const StorageKey = group["GridStorageKey"];
+        let lstGridFilter = {};
+        if (me.state.filter && this.storageService && this.data['SaveFilter']) {
+            //list of data for StateFilter and FilterParams
+            lstGridFilter = { "StateFilter": JSON.stringify(me.state.filter), "FilterParams": JSON.stringify(me.params.filterParams) };
+            //create session storage
+            this.storageService.set(StorageKey, JSON.stringify(lstGridFilter));
+        }
+    }
+    /* onchange Events */
+    filterChange(event) {
+        if (this.zgrid) {
+            this.zgrid.filterChange(event);
+        }
+    }
+    pageChange(event) {
+        if (this.zgrid) {
+            this.zgrid.pageChange(event);
+        }
+    }
+    sortChange(sort) {
+        if (this.zgrid) {
+            this.zgrid.sortChange(sort);
+        }
+    }
+    inCellCheckBoxOnChange(event, rowIndex, column) {
+        const isChecked = event.detail.checked;
+        this.gData[rowIndex][column.Value] = isChecked;
+    }
+    columnsOrderChanged(event) {
+        const _zgridControl = this.zgrid;
+        const _zgridComponent = this.zgrid.grid;
+        const _data = _zgridComponent.data;
+        if (this.zgrid) {
+            const _zgrid = this.zgrid;
+        }
+    }
+    /* grid command handler */
+    addHandler({ sender }) {
+        this.isNew = true;
+        // close any existing editor
+        this.closeEditor(sender);
+        // loop all column to get validation and create form control
+        const colFormControl = {};
+        this.zgrid.gridColumns.forEach(col => {
+            const validators = [];
+            if (col.IsRequired) {
+                validators.push(Validators.required);
+            }
+            if (col.ValidatorPattern) {
+                validators.push(Validators.pattern(col.ValidatorPattern));
+            }
+            colFormControl[col.Value] = new FormControl(null, validators);
+        });
+        // set form control object to form group
+        this.formGroup = new FormGroup(colFormControl);
+        // add to grid row
+        sender.addRow(this.formGroup);
+    }
+    saveHandler({ sender, rowIndex, formGroup, isNew }) {
+        // get grid data.
+        const gridExistingData = this.gData ? this.gData : this.gridData ? this.gridData.data : [];
+        // if valid
+        if (formGroup.valid) {
+            // check for duplicate UniqueKey
+            let uniqueKeyExist;
+            const uniqueKey = this.data['UniqueKey'];
+            if (uniqueKey) {
+                const formUniqueKeyValue = formGroup.value[uniqueKey];
+                if (isNew || (!isNew && (gridExistingData[rowIndex][uniqueKey] != formUniqueKeyValue))) {
+                    // if new...
+                    // if edit... if current field, uniquekey value changed. need to check.  
+                    gridExistingData.forEach(data => {
+                        if (data[uniqueKey] === formUniqueKeyValue) {
+                            uniqueKeyExist = true;
+                            return;
+                        }
+                    });
+                }
+            }
+            if (!uniqueKeyExist) {
+                if (isNew) {
+                    // if new, push to data
+                    gridExistingData.push(formGroup.value);
+                }
+                else {
+                    // if edit, update data
+                    gridExistingData[rowIndex] = formGroup.value;
+                }
+                this.setData(gridExistingData);
+                sender.closeRow(rowIndex);
+            }
+            else {
+                this.toastService.show('Error occur: Duplicated unique field entry.', 'top', true, 3000, 'danger');
+            }
+        }
+    }
+    cancelHandler({ sender, rowIndex }) {
+        // cancel any existing editor
+        sender.closeRow(rowIndex);
+    }
+    editHandler({ sender, rowIndex, dataItem }) {
+        this.isNew = false;
+        // close any existing editor
+        this.closeEditor(sender);
+        // loop all column to get validation and create form control, append current row value
+        const colFormControl = {};
+        this.zgrid.gridColumns.forEach(col => {
+            const validators = [];
+            if (col.IsRequired) {
+                validators.push(Validators.required);
+            }
+            if (col.ValidatorPattern) {
+                validators.push(Validators.pattern(col.ValidatorPattern));
+            }
+            colFormControl[col.Value] = new FormControl(dataItem[col.Value], validators);
+        });
+        // set form control object to form group
+        this.formGroup = new FormGroup(colFormControl);
+        // set grid row to edit
+        this.editedRowIndex = rowIndex;
+        sender.editRow(rowIndex, this.formGroup);
+    }
+    removeHandler({ sender, dataItem }) {
+        const index = this.getItemIndex(dataItem, this.gData, this.data['UniqueKey']);
+        this.gData.splice(index, 1);
+        sender.cancelCell();
+    }
+    closeEditor(grid, rowIndex = this.editedRowIndex) {
+        grid.closeRow(rowIndex);
+        this.editedRowIndex = undefined;
+        this.formGroup = undefined;
+    }
+    getItemIndex(item, data, key) {
+        for (let idx = 0; idx < data.length; idx++) {
+            if (data[idx][key] === item[key]) {
+                return idx;
+            }
+        }
+        return -1;
+    }
+}
+ZgridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ZgridComponent, deps: [{ token: i1.ActivatedRoute }, { token: i1.Router }, { token: i2.FormBuilder }, { token: i3.AuthService }, { token: i3.WebApiService }, { token: i3.ZGridStatePersistingService }, { token: i3.ToastService }, { token: i3.ZCoreService }, { token: i3.StorageSessionService }, { token: i4.MainService }], target: i0.ɵɵFactoryTarget.Component });
+ZgridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: ZgridComponent, selector: "app-zgrid", inputs: { data: "data", group: "group", form: "form" }, viewQueries: [{ propertyName: "tooltipDir", first: true, predicate: TooltipDirective, descendants: true }], ngImport: i0, template: "<!--\r\n<div style=\"margin: 10px\">\r\n  <div class=\"card\">\r\n      <div class=\"card-block k-form\">\r\n          <fieldset>\r\n            <legend>Binding types</legend>\r\n            <div class=\"k-form-field\">\r\n                <span>Bind the data to:</span>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"array\" value=\"array\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"array\">Array object</label>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"gridDataResult\" value=\"gridDataResult\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"gridDataResult\">GridDataResult object</label>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"async\" value=\"async\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"async\">Asynchronous source</label>\r\n            </div>\r\n          </fieldset>\r\n      </div>\r\n  </div>\r\n</div> -->\r\n<div style=\"margin: 10px 0 6px 0;\">\r\n  <div *ngIf=\"data.Title\" class=\"gridTitle\">{{data.Title}}</div>\r\n  <ng-template #template let-anchor>\r\n    <span>{{ anchor.nativeElement.innerText }}</span>\r\n  </ng-template>\r\n  <div kendoTooltip\r\n       showOn=\"none\"\r\n       [tooltipTemplate]=\"template\"\r\n       filter=\".k-grid td\"\r\n       (mouseover)=\"showTooltip($event)\"> \r\n    <kendo-grid [zgridbinding]=\"{data: data, group: group, params: params, gridSubject: gridSubject}\" [ngClass]=\"data.Class\"\r\n                [data]=\"gridData\"\r\n                [pageSize]=\"state.take\"\r\n                [pageable]=\"{responsive: true, buttonCount: 3, pageSizes: pageSizes, previousNext: previousNext}\"\r\n                [skip]=\"state.skip\"\r\n                [sort]=\"state.sort\"\r\n                [sortable]=\"{allowUnsort: true,mode: 'multiple'}\"\r\n                [filter]=\"state.filter\"\r\n                [filterable]=\"data.enableFiltering !== false\"\r\n                [resizable]=\"true\"\r\n                [reorderable]=\"true\"\r\n                [columnMenu]=\"data.DisableGridColumnMenu ? false : { filter: true }\"\r\n                [hidden]=\"!(!!componentProperties.isVisibleField ? group[componentProperties.isVisibleField] : componentProperties.isVisible)\"\r\n                (cellClick)=\"cellClickHandler($event)\"\r\n                (cellClose)=\"editCellCloseHandler($event)\"\r\n                (dataStateChange)=\"dataStateChange($event)\"\r\n                (pageChange)=\"pageChange($event)\"\r\n                (sortChange)=\"sortChange($event)\"\r\n                (filterChange)=\"filterChange($event)\"\r\n                (columnReorder)=\"columnsOrderChanged($event)\"\r\n                [kendoGridSelectBy]=\"rowSelectionKey\"\r\n                [selectable]=\"selectableSettings\"\r\n                [selectedKeys]=\"mySelection\"\r\n                [ngStyle]=\"getGridStyle()\"\r\n                [trackBy]=\"trackBy\"\r\n                (cancel)=\"cancelHandler($event)\"\r\n                (save)=\"saveHandler($event)\"\r\n                (remove)=\"removeHandler($event)\"\r\n                (edit)=\"editHandler($event)\"\r\n                (add)=\"addHandler($event)\">\r\n      <ng-template kendoGridToolbarTemplate *ngIf=\"data.AllowRefreshButton || data.AllowExport || data.AllowSaveState || data.EnableGridCommand\">\r\n        <button type=\"button\" kendoButton (click)=\"refreshData()\" *ngIf=\"data.AllowRefreshButton\"><span class=\"k-icon k-i-refresh-sm\"></span>&nbsp;Refresh</button>\r\n        <button type=\"button\" kendoGridExcelCommand *ngIf=\"data.AllowExport\"><span class=\"k-icon k-i-file-excel\"></span>&nbsp;Export Data to Excel</button>\r\n        <button type=\"button\" kendoButton (click)=\"saveGridSettings()\" *ngIf=\"data.AllowSaveState\"><span class=\"k-icon k-i-star\"></span>&nbsp;Save Setting</button>\r\n        <button type=\"button\" kendoButton (click)=\"restoreGridSettings()\" *ngIf=\"gridDefaultStateExist\"><span class=\"k-icon k-i-star-outline\"></span>&nbsp;Restore Setting</button>\r\n        <button type=\"button\" kendoGridAddCommand *ngIf=\"data.EnableGridCommand \"><span class=\"k-icon k-i-add\"></span>Add New</button>\r\n      </ng-template>\r\n      <kendo-grid-checkbox-column *ngIf=\"!!data.SelectOptions\" [width]=\"60\" showSelectAll=\"true\" [columnMenu]=\"true\"></kendo-grid-checkbox-column>\r\n      <kendo-grid-column *ngFor=\"let col of columns\"\r\n                         [field]=\"col.field\"\r\n                         [title]=\"col.title\"\r\n                         [width]=\"col.width\"\r\n                         [minResizableWidth]=\"col.minResizableWidth\"\r\n                         [filter]=\"col.filter\"\r\n                         [filterable]=\"filterable(col.enableFiltering)\"\r\n                         [sortable]=\"sortable(col.enableSorting)\"\r\n                         [headerStyle]=\"{'white-space': 'initial'}\"\r\n                         [hidden]=\"col.hidden\"\r\n                         [format]=\"col.format\"\r\n                         [class]=\"col.Class\"\r\n                         [locked]=\"locked(col)\"\r\n                         [columnMenu]=\"!col.disableColumnMenu\"\r\n                         [editor]=\"col.editorType\">\r\n        <div [ngSwitch]=\"true\">\r\n          <div *ngSwitchCase=\"col.fieldType === 'number'\r\n               || col.fieldType === 'currency'\r\n               || col.fieldType === 'znumeric'\">\r\n            <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n              <kendo-grid-numeric-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"eq\">\r\n                <kendo-filter-eq-operator></kendo-filter-eq-operator>\r\n                <kendo-filter-neq-operator></kendo-filter-neq-operator>\r\n                <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n              </kendo-grid-numeric-filter-cell>\r\n            </ng-template>\r\n          </div>\r\n          <div *ngSwitchCase=\"col.fieldType == 'zdate'\r\n               || col.fieldType === 'ztime'\r\n               || col.fieldType === 'zdatetime'\r\n               || col.fieldType === 'zuidatetime'\">\r\n            <div *ngIf=\"col.filterByDateRange === true\">\r\n              <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\" operator=\"lte\">\r\n                <date-range-filter-cell class=\"date-range-filter\"\r\n                                        [filter]=\"filter\"\r\n                                        [field]=\"col.field\">\r\n                  <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                  <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                  <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                  <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                  <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                  <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n                </date-range-filter-cell>\r\n              </ng-template>\r\n            </div>\r\n            <div *ngIf=\"col.filterByDateRange === false\">\r\n              <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n                <kendo-grid-date-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"lte\">\r\n                  <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                  <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                  <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                  <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                  <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                  <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n                </kendo-grid-date-filter-cell>\r\n              </ng-template>\r\n            </div>\r\n          </div>\r\n          <div *ngSwitchDefault>\r\n            <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n              <kendo-grid-string-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"contains\">\r\n                <kendo-filter-contains-operator></kendo-filter-contains-operator>\r\n                <kendo-filter-eq-operator></kendo-filter-eq-operator>\r\n                <kendo-filter-neq-operator></kendo-filter-neq-operator>\r\n                <kendo-filter-startswith-operator></kendo-filter-startswith-operator>\r\n                <kendo-filter-endswith-operator></kendo-filter-endswith-operator>\r\n                <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n              </kendo-grid-string-filter-cell>\r\n            </ng-template>\r\n          </div>\r\n        </div>\r\n        <!-- Grid Edit Template -->\r\n        <ng-template kendoGridEditTemplate *ngIf=\"data.EnableGridCommand \" let-dataItem=\"dataItem\" let-column=\"col\" let-formGroup=\"formGroup\" let-isNew=\"isNew\">\r\n          <div [ngSwitch]=\"col.fieldType\">\r\n            <div *ngSwitchCase=\"'number'\">\r\n              <kendo-numerictextbox #cellAnchor [formControl]=\"formGroup.get(col.field)\"></kendo-numerictextbox>\r\n              <kendo-popup [anchor]=\"cellAnchor.numericInput\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !(isNew && formGroup.get(col.field).untouched)\"\r\n                           popupClass=\"k-widget k-tooltip k-tooltip-validation k-invalid-msg\"\r\n                           style=\"padding-left: 2px; opacity: 0.5;\">\r\n                <span class=\"k-icon k-i-warning\"></span>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.required\">\r\n                  {{ col.Name }} required.\r\n                </ion-label>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.pattern\">\r\n                  {{ col.ValidatorMessage ? col.ValidatorMessage : \"Please check the input value.\" }}\r\n                </ion-label>\r\n              </kendo-popup>\r\n            </div>\r\n            <div *ngSwitchDefault>\r\n              <kendo-textbox #cellAnchor [formControl]=\"formGroup.get(col.field)\"></kendo-textbox>\r\n              <kendo-popup [anchor]=\"cellAnchor.input\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !(isNew && formGroup.get(col.field).untouched)\"\r\n                           popupClass=\"k-widget k-tooltip k-tooltip-validation k-invalid-msg\"\r\n                           style=\"padding-left: 2px; opacity: 0.5;\">\r\n                <span class=\"k-icon k-i-warning\"></span>\r\n                <!--<ion-label style=\"padding-top: 1px; padding-left: 3px;\">{{ col.Name }} is required.</ion-label>-->\r\n\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.required\">\r\n                  {{ col.Name }} required.\r\n                </ion-label>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.pattern\">\r\n                  {{ col.ValidatorMessage ? col.ValidatorMessage : \"Please check the input value.\" }}\r\n                </ion-label>\r\n              </kendo-popup>\r\n            </div>\r\n          </div>\r\n        </ng-template>\r\n        <ng-template kendoGridCellTemplate let-dataItem let-rowIndex=\"rowIndex\">\r\n          <div style=\"margin: 1px 0;\" *ngIf=\"!col.clickableIcons && col.isEditableInGrid !== true\" [ngSwitch]=\"col.fieldType\"\r\n               [ngClass]=\"getClass(dataItem, col)\">\r\n            <span *ngSwitchCase=\"'zdate'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'ztime'\">\r\n              {{ dataItem[col.field] | date: 'HH:mm' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zshortdate'\">\r\n              {{ dataItem[col.field] | date: 'MMM yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zdatetime'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuidatetime'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'number'\">\r\n              {{ dataItem[col.field] | number }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'currency'\">\r\n              {{ dataItem[col.field] | number: getFormat(col, '1.2-2') }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'znumeric'\">\r\n              {{ dataItem[col.field] | number: getFormat(col) }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'url'\" style=\"color: blue; cursor: pointer; text-decoration:underline;\">\r\n              {{ dataItem[col.field] }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ dataItem[col.field]}}\r\n            </span>\r\n          </div>\r\n          <!-- <span *ngIf=\"!!col.navigateTo\" (click)=\"onNavigateTo($event, col, dataItem, dataItem[col.field])\">\r\n      <ion-button color=\"light\" size=\"small\">\r\n      {{ col.ClickableIcons }}\r\n      <ion-icon slot= \"end\" name=\"arrow-forward\"></ion-icon>\r\n      </ion-button>\r\n      </span> -->\r\n          <div style=\"margin: 5px 0;\" *ngIf=\"col.isEditableInGrid === true && inlineEditedFormGroups\" [ngSwitch]=\"col.fieldType\" [formGroup]=\"inlineEditedFormGroups\"\r\n               [ngClass]=\"getClass(dataItem, col)\">\r\n            <span *ngSwitchCase=\"'number'\">\r\n              <input type=\"number\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" />\r\n            </span>\r\n            <span *ngSwitchCase=\"'checkbox'\">\r\n              <ion-checkbox [disabled]=\"(!!col.ReadOnly ? col.ReadOnly : false)\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" color=\"primary\" (ionChange)=\"inCellCheckBoxOnChange($event, rowIndex, col)\"></ion-checkbox>\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuiselectmultiple'\">\r\n              <app-zselectmultiple style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-zselectmultiple>\r\n            </span>\r\n            <span *ngSwitchCase=\"'textarea'\">\r\n              <app-ztextarea style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-ztextarea>\r\n            </span>\r\n            <span *ngSwitchCase=\"['zuidatetime','zdate', 'ztime','zdatetime','zshortdate'].includes(col.fieldType) ? col.fieldType : ''\">\r\n              <app-zdatetime style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-zdatetime>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              <input style=\"width: 100%;\" type=\"text\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" />\r\n            </span>\r\n          </div>\r\n          <span style=\"margin-top: 10px;\" *ngFor=\"let icon of col.clickableIcons\">\r\n            <span [ngClass]=\"icon.Class ? icon.Class : ''\" *ngIf=\"!!icon && (!!dataItem.WFS_StatusCode && !!icon)\r\n              ? dataItem.WFS_StatusCode !== icon.WFS_StatusCode\r\n              : true;\r\n            else disabledButton\" (click)=\"onBtnClick($event, icon, dataItem, dataItem[col.field])\">\r\n              {{icon.Name || dataItem[col.field]}} <fa-icon [icon]=\"icon.Icon\" style=\"padding: 4px 6px;\">\r\n              </fa-icon>\r\n            </span>\r\n            <ng-template #disabledButton>\r\n            </ng-template>\r\n          </span>\r\n          <!-- <strong>{{ dataItem[col.field] }}</strong> -->\r\n          <!-- <span class=\"{{dataItem.Discontinued ? 'discontinued' : 'active'}}\">\r\n        {{dataItem.Discontinued ? \"discontinued\" : \"active\"}}\r\n      </span> -->\r\n        </ng-template>\r\n        <ng-template kendoGridFooterTemplate let-column let-columnIndex=\"columnIndex\" *ngIf=\"data.EnableAggregate\">\r\n          <div style=\"margin: 5px 0;\" [ngSwitch]=\"col.fieldType\">\r\n            {{col.aggregateType}}\r\n            <span *ngSwitchCase=\"'zdate'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'ztime'\">\r\n              {{ col.aggregateValue | date: 'HH:mm' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zshortdate'\">\r\n              {{ col.aggregateValue | date: 'MMM yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zdatetime'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuidatetime'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'number'\">\r\n              {{ col.aggregateValue | number }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'currency'\">\r\n              {{ col.aggregateValue | number: getFormat(col, '1.2.2') }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'znumeric'\">\r\n              {{ col.aggregateValue | number: getFormat(col) }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'url'\" style=\"color: blue; cursor: pointer; text-decoration:underline;\">\r\n              {{ col.aggregateValue }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ col.aggregateValue }}\r\n            </span>\r\n          </div>\r\n        </ng-template>\r\n      </kendo-grid-column>\r\n      <kendo-grid-command-column *ngIf=\"data.EnableGridCommand\" width=\"180\" [columnMenu]=\"false\">\r\n        <ng-template kendoGridCellTemplate let-isNew=\"isNew\">\r\n          <button kendoGridSaveCommand>\r\n            {{ isNew ? 'Save' : 'Update' }}\r\n          </button>\r\n          <button kendoGridCancelCommand [primary]=\"true\">\r\n            {{ isNew ? 'Discard changes' : 'Cancel' }}\r\n          </button>\r\n          <button kendoGridEditCommand>\r\n            {{ \"Edit\" }}\r\n          </button>\r\n          <button kendoGridRemoveCommand>\r\n            {{ \"Remove\" }}\r\n          </button>\r\n        </ng-template>\r\n      </kendo-grid-command-column>\r\n      <kendo-grid-excel fileName=\"Export.xlsx\" [fetchData]=\"allResults\"></kendo-grid-excel>\r\n    </kendo-grid>\r\n    <div *ngIf=\"isLoading\" class=\"k-i-loading\"></div>\r\n  </div>\r\n</div>\r\n", styles: [":host ::ng-deep kendo-grid .k-grid-content{white-space:nowrap}:host ::ng-deep kendo-grid .k-toolbar{background-color:#e3ecf8}:host ::ng-deep kendo-grid .k-grid-header{background-color:#e3ecf8;font-weight:600}:host ::ng-deep kendo-grid .k-button{border-radius:5px;box-shadow:0 2px 2px #0000001a;background-color:#c9daf2}:host ::ng-deep kendo-grid .k-grid-header .k-grid-filter:hover,:host ::ng-deep kendo-grid .k-grid-header .k-header-column-menu:hover,:host ::ng-deep kendo-grid .k-grid-header .k-hierarchy-cell .k-icon:hover{background-color:#c9daf2}:host ::ng-deep kendo-grid .k-grid .k-grid-filter,:host ::ng-deep kendo-grid .k-grid .k-header-column-menu,:host ::ng-deep kendo-grid .k-grid .k-hierarchy-cell .k-icon{color:#132842}:host ::ng-deep kendo-grid .k-dropdown .k-dropdown-wrap,:host ::ng-deep kendo-grid .k-dropdowntree .k-dropdown-wrap{border-radius:2px;background-color:#d6e0ef80}:host ::ng-deep kendo-grid tr.k-alt{background-color:#e8eef680}:host ::ng-deep kendo-grid tbody tr:hover,:host ::ng-deep kendo-grid tbody tr.k-state-hover{background-color:#d6e0ef80}:host ::ng-deep kendo-grid .k-pager-wrap{background-color:#e3ecf8}:host ::ng-deep kendo-grid .k-pager-numbers .k-link.k-state-selected{color:#ff5e5b;background-color:#ff5e5b66}:host ::ng-deep kendo-grid .k-pager-numbers .k-link:hover,:host ::ng-deep kendo-grid .k-pager-numbers .k-link.k-state-hover{color:#ff5e5b;background-color:#ff5e5b26}.cellWrapText .gridCell{white-space:pre-line!important}.rightAligned{text-align:right}.centerAligned{text-align:center}.gridTitle{margin:20px 10px 5px;font-size:18px;font-weight:700}.gridCell.primary{color:var(--ion-color-primary)}.gridCell.secondary{color:var(--ion-color-secondary)}.gridCell.tertiary{color:var(--ion-color-tertiary)}.gridCell.success{color:var(--ion-color-success-shade)}.gridCell.warning{color:var(--ion-color-warning)}.gridCell.danger{color:var(--ion-color-danger)}.gridCell.dark{color:var(--ion-color-dark)}.gridCell.medium{color:var(--ion-color-medium)}.gridCell.light{color:var(--ion-color-light)}.k-i-loading{position:absolute;top:100px;left:0;right:0;bottom:0;font-size:45px;background-color:#ffffff4d;color:#0f4800}\n"], components: [{ type: i5.GridComponent, selector: "kendo-grid", inputs: ["data", "pageSize", "height", "rowHeight", "detailRowHeight", "skip", "scrollable", "selectable", "sort", "trackBy", "filter", "group", "virtualColumns", "filterable", "sortable", "pageable", "groupable", "navigable", "navigatable", "autoSize", "rowClass", "rowSticky", "rowSelected", "cellSelected", "resizable", "reorderable", "loading", "columnMenu", "hideHeader", "isDetailExpanded", "isGroupExpanded"], outputs: ["filterChange", "pageChange", "groupChange", "sortChange", "selectionChange", "dataStateChange", "groupExpand", "groupCollapse", "detailExpand", "detailCollapse", "edit", "cancel", "save", "remove", "add", "cellClose", "cellClick", "pdfExport", "excelExport", "columnResize", "columnReorder", "columnVisibilityChange", "columnLockedChange", "columnStickyChange", "scrollBottom", "contentScroll"], exportAs: ["kendoGrid"] }, { type: i5.CheckboxColumnComponent, selector: "kendo-grid-checkbox-column", inputs: ["showSelectAll"] }, { type: i5.ColumnComponent, selector: "kendo-grid-column", inputs: ["field", "format", "sortable", "groupable", "editor", "filter", "filterable", "editable"] }, { type: i5.NumericFilterCellComponent, selector: "kendo-grid-numeric-filter-cell", inputs: ["filterDelay", "showOperators"] }, { type: i5.EqualFilterOperatorComponent, selector: "kendo-filter-eq-operator" }, { type: i5.NotEqualFilterOperatorComponent, selector: "kendo-filter-neq-operator" }, { type: i5.LessFilterOperatorComponent, selector: "kendo-filter-lt-operator" }, { type: i5.LessOrEqualToFilterOperatorComponent, selector: "kendo-filter-lte-operator" }, { type: i5.GreaterFilterOperatorComponent, selector: "kendo-filter-gt-operator" }, { type: i5.GreaterOrEqualToFilterOperatorComponent, selector: "kendo-filter-gte-operator" }, { type: i5.IsNullFilterOperatorComponent, selector: "kendo-filter-isnull-operator" }, { type: i5.IsNotNullFilterOperatorComponent, selector: "kendo-filter-isnotnull-operator" }, { type: i6.DateRangeFilterCellComponent, selector: "date-range-filter-cell", inputs: ["filter", "field"] }, { type: i5.DateFilterCellComponent, selector: "kendo-grid-date-filter-cell", inputs: ["showOperators"] }, { type: i5.StringFilterCellComponent, selector: "kendo-grid-string-filter-cell", inputs: ["filterDelay", "showOperators"] }, { type: i5.ContainsFilterOperatorComponent, selector: "kendo-filter-contains-operator" }, { type: i5.StartsWithFilterOperatorComponent, selector: "kendo-filter-startswith-operator" }, { type: i5.EndsWithFilterOperatorComponent, selector: "kendo-filter-endswith-operator" }, { type: i7.NumericTextBoxComponent, selector: "kendo-numerictextbox", inputs: ["focusableId", "disabled", "readonly", "title", "autoCorrect", "format", "max", "min", "decimals", "placeholder", "step", "spinners", "rangeValidation", "tabindex", "tabIndex", "changeValueOnScroll", "selectOnFocus", "value", "maxlength", "size", "rounded", "fillMode"], outputs: ["valueChange", "focus", "blur"], exportAs: ["kendoNumericTextBox"] }, { type: i8.PopupComponent, selector: "kendo-popup", inputs: ["animate", "anchor", "anchorAlign", "collision", "popupAlign", "copyAnchorStyles", "popupClass", "positionMode", "offset", "margin"], outputs: ["anchorViewportLeave", "close", "open", "positionChange"], exportAs: ["kendo-popup"] }, { type: i9.IonLabel, selector: "ion-label", inputs: ["color", "mode", "position"] }, { type: i7.TextBoxComponent, selector: "kendo-textbox", inputs: ["focusableId", "title", "disabled", "readonly", "tabindex", "value", "selectOnFocus", "showSuccessIcon", "showErrorIcon", "clearButton", "successIcon", "errorIcon", "clearButtonIcon", "size", "rounded", "fillMode", "tabIndex", "placeholder", "maxlength"], outputs: ["valueChange", "inputFocus", "inputBlur", "focus", "blur"], exportAs: ["kendoTextBox"] }, { type: i9.IonCheckbox, selector: "ion-checkbox", inputs: ["checked", "color", "disabled", "indeterminate", "mode", "name", "value"] }, { type: i10.ZselectmultipleComponent, selector: "app-zselectmultiple", inputs: ["data", "group", "form", "iconList", "buttonList"] }, { type: i11.ZtextareaComponent, selector: "app-ztextarea", inputs: ["data", "group", "form"] }, { type: i12.ZdatetimeComponent, selector: "app-zdatetime", inputs: ["data", "group", "form"] }, { type: i13.FaIconComponent, selector: "fa-icon", inputs: ["icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "classes", "transform", "a11yRole"] }, { type: i5.CommandColumnComponent, selector: "kendo-grid-command-column" }, { type: i5.ExcelComponent, selector: "kendo-grid-excel", inputs: ["fileName", "filterable", "creator", "date", "forceProxy", "proxyURL", "fetchData", "paddingCellOptions", "headerPaddingCellOptions", "collapsible"] }], directives: [{ type: i14.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i15.TooltipDirective, selector: "[kendoTooltip]", inputs: ["filter", "position", "titleTemplate", "showOn", "showAfter", "callout", "closable", "offset", "tooltipWidth", "tooltipHeight", "tooltipClass", "collision", "closeTitle", "tooltipTemplate"], exportAs: ["kendoTooltip"] }, { type: i16.ZGridBindingDirective, selector: "[zgridbinding]", inputs: ["zgridbinding"] }, { type: i14.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i5.SelectionDirective, selector: "[kendoGridSelectBy]" }, { type: i14.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i5.ToolbarTemplateDirective, selector: "[kendoGridToolbarTemplate]", inputs: ["position"] }, { type: i17.ButtonDirective, selector: "button[kendoButton], span[kendoButton]", inputs: ["toggleable", "togglable", "selected", "tabIndex", "icon", "iconClass", "imageUrl", "disabled", "size", "rounded", "fillMode", "themeColor", "role", "primary", "look"], outputs: ["selectedChange", "click"], exportAs: ["kendoButton"] }, { type: i5.ExcelCommandDirective, selector: "[kendoGridExcelCommand]" }, { type: i5.AddCommandDirective, selector: "[kendoGridAddCommand]" }, { type: i14.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i14.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i14.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i5.FilterCellTemplateDirective, selector: "[kendoGridFilterCellTemplate]" }, { type: i14.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { type: i5.EditTemplateDirective, selector: "[kendoGridEditTemplate]" }, { type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { type: i5.CellTemplateDirective, selector: "[kendoGridCellTemplate]" }, { type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i2.NumberValueAccessor, selector: "input[type=number][formControlName],input[type=number][formControl],input[type=number][ngModel]" }, { type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { type: i9.BooleanValueAccessor, selector: "ion-checkbox,ion-toggle" }, { type: i5.FooterTemplateDirective, selector: "[kendoGridFooterTemplate]" }, { type: i5.FocusableDirective, selector: "[kendoGridFocusable],        [kendoGridEditCommand],        [kendoGridRemoveCommand],        [kendoGridSaveCommand],        [kendoGridCancelCommand],        [kendoGridSelectionCheckbox]    ", inputs: ["kendoGridFocusable"] }, { type: i5.SaveCommandDirective, selector: "[kendoGridSaveCommand]" }, { type: i5.CancelCommandDirective, selector: "[kendoGridCancelCommand]" }, { type: i5.EditCommandDirective, selector: "[kendoGridEditCommand]" }, { type: i5.RemoveCommandDirective, selector: "[kendoGridRemoveCommand]" }], pipes: { "date": i14.DatePipe, "number": i14.DecimalPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: ZgridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "app-zgrid", template: "<!--\r\n<div style=\"margin: 10px\">\r\n  <div class=\"card\">\r\n      <div class=\"card-block k-form\">\r\n          <fieldset>\r\n            <legend>Binding types</legend>\r\n            <div class=\"k-form-field\">\r\n                <span>Bind the data to:</span>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"array\" value=\"array\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"array\">Array object</label>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"gridDataResult\" value=\"gridDataResult\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"gridDataResult\">GridDataResult object</label>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"async\" value=\"async\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"async\">Asynchronous source</label>\r\n            </div>\r\n          </fieldset>\r\n      </div>\r\n  </div>\r\n</div> -->\r\n<div style=\"margin: 10px 0 6px 0;\">\r\n  <div *ngIf=\"data.Title\" class=\"gridTitle\">{{data.Title}}</div>\r\n  <ng-template #template let-anchor>\r\n    <span>{{ anchor.nativeElement.innerText }}</span>\r\n  </ng-template>\r\n  <div kendoTooltip\r\n       showOn=\"none\"\r\n       [tooltipTemplate]=\"template\"\r\n       filter=\".k-grid td\"\r\n       (mouseover)=\"showTooltip($event)\"> \r\n    <kendo-grid [zgridbinding]=\"{data: data, group: group, params: params, gridSubject: gridSubject}\" [ngClass]=\"data.Class\"\r\n                [data]=\"gridData\"\r\n                [pageSize]=\"state.take\"\r\n                [pageable]=\"{responsive: true, buttonCount: 3, pageSizes: pageSizes, previousNext: previousNext}\"\r\n                [skip]=\"state.skip\"\r\n                [sort]=\"state.sort\"\r\n                [sortable]=\"{allowUnsort: true,mode: 'multiple'}\"\r\n                [filter]=\"state.filter\"\r\n                [filterable]=\"data.enableFiltering !== false\"\r\n                [resizable]=\"true\"\r\n                [reorderable]=\"true\"\r\n                [columnMenu]=\"data.DisableGridColumnMenu ? false : { filter: true }\"\r\n                [hidden]=\"!(!!componentProperties.isVisibleField ? group[componentProperties.isVisibleField] : componentProperties.isVisible)\"\r\n                (cellClick)=\"cellClickHandler($event)\"\r\n                (cellClose)=\"editCellCloseHandler($event)\"\r\n                (dataStateChange)=\"dataStateChange($event)\"\r\n                (pageChange)=\"pageChange($event)\"\r\n                (sortChange)=\"sortChange($event)\"\r\n                (filterChange)=\"filterChange($event)\"\r\n                (columnReorder)=\"columnsOrderChanged($event)\"\r\n                [kendoGridSelectBy]=\"rowSelectionKey\"\r\n                [selectable]=\"selectableSettings\"\r\n                [selectedKeys]=\"mySelection\"\r\n                [ngStyle]=\"getGridStyle()\"\r\n                [trackBy]=\"trackBy\"\r\n                (cancel)=\"cancelHandler($event)\"\r\n                (save)=\"saveHandler($event)\"\r\n                (remove)=\"removeHandler($event)\"\r\n                (edit)=\"editHandler($event)\"\r\n                (add)=\"addHandler($event)\">\r\n      <ng-template kendoGridToolbarTemplate *ngIf=\"data.AllowRefreshButton || data.AllowExport || data.AllowSaveState || data.EnableGridCommand\">\r\n        <button type=\"button\" kendoButton (click)=\"refreshData()\" *ngIf=\"data.AllowRefreshButton\"><span class=\"k-icon k-i-refresh-sm\"></span>&nbsp;Refresh</button>\r\n        <button type=\"button\" kendoGridExcelCommand *ngIf=\"data.AllowExport\"><span class=\"k-icon k-i-file-excel\"></span>&nbsp;Export Data to Excel</button>\r\n        <button type=\"button\" kendoButton (click)=\"saveGridSettings()\" *ngIf=\"data.AllowSaveState\"><span class=\"k-icon k-i-star\"></span>&nbsp;Save Setting</button>\r\n        <button type=\"button\" kendoButton (click)=\"restoreGridSettings()\" *ngIf=\"gridDefaultStateExist\"><span class=\"k-icon k-i-star-outline\"></span>&nbsp;Restore Setting</button>\r\n        <button type=\"button\" kendoGridAddCommand *ngIf=\"data.EnableGridCommand \"><span class=\"k-icon k-i-add\"></span>Add New</button>\r\n      </ng-template>\r\n      <kendo-grid-checkbox-column *ngIf=\"!!data.SelectOptions\" [width]=\"60\" showSelectAll=\"true\" [columnMenu]=\"true\"></kendo-grid-checkbox-column>\r\n      <kendo-grid-column *ngFor=\"let col of columns\"\r\n                         [field]=\"col.field\"\r\n                         [title]=\"col.title\"\r\n                         [width]=\"col.width\"\r\n                         [minResizableWidth]=\"col.minResizableWidth\"\r\n                         [filter]=\"col.filter\"\r\n                         [filterable]=\"filterable(col.enableFiltering)\"\r\n                         [sortable]=\"sortable(col.enableSorting)\"\r\n                         [headerStyle]=\"{'white-space': 'initial'}\"\r\n                         [hidden]=\"col.hidden\"\r\n                         [format]=\"col.format\"\r\n                         [class]=\"col.Class\"\r\n                         [locked]=\"locked(col)\"\r\n                         [columnMenu]=\"!col.disableColumnMenu\"\r\n                         [editor]=\"col.editorType\">\r\n        <div [ngSwitch]=\"true\">\r\n          <div *ngSwitchCase=\"col.fieldType === 'number'\r\n               || col.fieldType === 'currency'\r\n               || col.fieldType === 'znumeric'\">\r\n            <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n              <kendo-grid-numeric-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"eq\">\r\n                <kendo-filter-eq-operator></kendo-filter-eq-operator>\r\n                <kendo-filter-neq-operator></kendo-filter-neq-operator>\r\n                <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n              </kendo-grid-numeric-filter-cell>\r\n            </ng-template>\r\n          </div>\r\n          <div *ngSwitchCase=\"col.fieldType == 'zdate'\r\n               || col.fieldType === 'ztime'\r\n               || col.fieldType === 'zdatetime'\r\n               || col.fieldType === 'zuidatetime'\">\r\n            <div *ngIf=\"col.filterByDateRange === true\">\r\n              <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\" operator=\"lte\">\r\n                <date-range-filter-cell class=\"date-range-filter\"\r\n                                        [filter]=\"filter\"\r\n                                        [field]=\"col.field\">\r\n                  <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                  <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                  <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                  <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                  <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                  <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n                </date-range-filter-cell>\r\n              </ng-template>\r\n            </div>\r\n            <div *ngIf=\"col.filterByDateRange === false\">\r\n              <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n                <kendo-grid-date-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"lte\">\r\n                  <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                  <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                  <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                  <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                  <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                  <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n                </kendo-grid-date-filter-cell>\r\n              </ng-template>\r\n            </div>\r\n          </div>\r\n          <div *ngSwitchDefault>\r\n            <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n              <kendo-grid-string-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"contains\">\r\n                <kendo-filter-contains-operator></kendo-filter-contains-operator>\r\n                <kendo-filter-eq-operator></kendo-filter-eq-operator>\r\n                <kendo-filter-neq-operator></kendo-filter-neq-operator>\r\n                <kendo-filter-startswith-operator></kendo-filter-startswith-operator>\r\n                <kendo-filter-endswith-operator></kendo-filter-endswith-operator>\r\n                <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n              </kendo-grid-string-filter-cell>\r\n            </ng-template>\r\n          </div>\r\n        </div>\r\n        <!-- Grid Edit Template -->\r\n        <ng-template kendoGridEditTemplate *ngIf=\"data.EnableGridCommand \" let-dataItem=\"dataItem\" let-column=\"col\" let-formGroup=\"formGroup\" let-isNew=\"isNew\">\r\n          <div [ngSwitch]=\"col.fieldType\">\r\n            <div *ngSwitchCase=\"'number'\">\r\n              <kendo-numerictextbox #cellAnchor [formControl]=\"formGroup.get(col.field)\"></kendo-numerictextbox>\r\n              <kendo-popup [anchor]=\"cellAnchor.numericInput\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !(isNew && formGroup.get(col.field).untouched)\"\r\n                           popupClass=\"k-widget k-tooltip k-tooltip-validation k-invalid-msg\"\r\n                           style=\"padding-left: 2px; opacity: 0.5;\">\r\n                <span class=\"k-icon k-i-warning\"></span>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.required\">\r\n                  {{ col.Name }} required.\r\n                </ion-label>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.pattern\">\r\n                  {{ col.ValidatorMessage ? col.ValidatorMessage : \"Please check the input value.\" }}\r\n                </ion-label>\r\n              </kendo-popup>\r\n            </div>\r\n            <div *ngSwitchDefault>\r\n              <kendo-textbox #cellAnchor [formControl]=\"formGroup.get(col.field)\"></kendo-textbox>\r\n              <kendo-popup [anchor]=\"cellAnchor.input\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !(isNew && formGroup.get(col.field).untouched)\"\r\n                           popupClass=\"k-widget k-tooltip k-tooltip-validation k-invalid-msg\"\r\n                           style=\"padding-left: 2px; opacity: 0.5;\">\r\n                <span class=\"k-icon k-i-warning\"></span>\r\n                <!--<ion-label style=\"padding-top: 1px; padding-left: 3px;\">{{ col.Name }} is required.</ion-label>-->\r\n\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.required\">\r\n                  {{ col.Name }} required.\r\n                </ion-label>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.pattern\">\r\n                  {{ col.ValidatorMessage ? col.ValidatorMessage : \"Please check the input value.\" }}\r\n                </ion-label>\r\n              </kendo-popup>\r\n            </div>\r\n          </div>\r\n        </ng-template>\r\n        <ng-template kendoGridCellTemplate let-dataItem let-rowIndex=\"rowIndex\">\r\n          <div style=\"margin: 1px 0;\" *ngIf=\"!col.clickableIcons && col.isEditableInGrid !== true\" [ngSwitch]=\"col.fieldType\"\r\n               [ngClass]=\"getClass(dataItem, col)\">\r\n            <span *ngSwitchCase=\"'zdate'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'ztime'\">\r\n              {{ dataItem[col.field] | date: 'HH:mm' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zshortdate'\">\r\n              {{ dataItem[col.field] | date: 'MMM yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zdatetime'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuidatetime'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'number'\">\r\n              {{ dataItem[col.field] | number }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'currency'\">\r\n              {{ dataItem[col.field] | number: getFormat(col, '1.2-2') }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'znumeric'\">\r\n              {{ dataItem[col.field] | number: getFormat(col) }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'url'\" style=\"color: blue; cursor: pointer; text-decoration:underline;\">\r\n              {{ dataItem[col.field] }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ dataItem[col.field]}}\r\n            </span>\r\n          </div>\r\n          <!-- <span *ngIf=\"!!col.navigateTo\" (click)=\"onNavigateTo($event, col, dataItem, dataItem[col.field])\">\r\n      <ion-button color=\"light\" size=\"small\">\r\n      {{ col.ClickableIcons }}\r\n      <ion-icon slot= \"end\" name=\"arrow-forward\"></ion-icon>\r\n      </ion-button>\r\n      </span> -->\r\n          <div style=\"margin: 5px 0;\" *ngIf=\"col.isEditableInGrid === true && inlineEditedFormGroups\" [ngSwitch]=\"col.fieldType\" [formGroup]=\"inlineEditedFormGroups\"\r\n               [ngClass]=\"getClass(dataItem, col)\">\r\n            <span *ngSwitchCase=\"'number'\">\r\n              <input type=\"number\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" />\r\n            </span>\r\n            <span *ngSwitchCase=\"'checkbox'\">\r\n              <ion-checkbox [disabled]=\"(!!col.ReadOnly ? col.ReadOnly : false)\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" color=\"primary\" (ionChange)=\"inCellCheckBoxOnChange($event, rowIndex, col)\"></ion-checkbox>\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuiselectmultiple'\">\r\n              <app-zselectmultiple style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-zselectmultiple>\r\n            </span>\r\n            <span *ngSwitchCase=\"'textarea'\">\r\n              <app-ztextarea style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-ztextarea>\r\n            </span>\r\n            <span *ngSwitchCase=\"['zuidatetime','zdate', 'ztime','zdatetime','zshortdate'].includes(col.fieldType) ? col.fieldType : ''\">\r\n              <app-zdatetime style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-zdatetime>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              <input style=\"width: 100%;\" type=\"text\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" />\r\n            </span>\r\n          </div>\r\n          <span style=\"margin-top: 10px;\" *ngFor=\"let icon of col.clickableIcons\">\r\n            <span [ngClass]=\"icon.Class ? icon.Class : ''\" *ngIf=\"!!icon && (!!dataItem.WFS_StatusCode && !!icon)\r\n              ? dataItem.WFS_StatusCode !== icon.WFS_StatusCode\r\n              : true;\r\n            else disabledButton\" (click)=\"onBtnClick($event, icon, dataItem, dataItem[col.field])\">\r\n              {{icon.Name || dataItem[col.field]}} <fa-icon [icon]=\"icon.Icon\" style=\"padding: 4px 6px;\">\r\n              </fa-icon>\r\n            </span>\r\n            <ng-template #disabledButton>\r\n            </ng-template>\r\n          </span>\r\n          <!-- <strong>{{ dataItem[col.field] }}</strong> -->\r\n          <!-- <span class=\"{{dataItem.Discontinued ? 'discontinued' : 'active'}}\">\r\n        {{dataItem.Discontinued ? \"discontinued\" : \"active\"}}\r\n      </span> -->\r\n        </ng-template>\r\n        <ng-template kendoGridFooterTemplate let-column let-columnIndex=\"columnIndex\" *ngIf=\"data.EnableAggregate\">\r\n          <div style=\"margin: 5px 0;\" [ngSwitch]=\"col.fieldType\">\r\n            {{col.aggregateType}}\r\n            <span *ngSwitchCase=\"'zdate'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'ztime'\">\r\n              {{ col.aggregateValue | date: 'HH:mm' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zshortdate'\">\r\n              {{ col.aggregateValue | date: 'MMM yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zdatetime'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuidatetime'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'number'\">\r\n              {{ col.aggregateValue | number }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'currency'\">\r\n              {{ col.aggregateValue | number: getFormat(col, '1.2.2') }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'znumeric'\">\r\n              {{ col.aggregateValue | number: getFormat(col) }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'url'\" style=\"color: blue; cursor: pointer; text-decoration:underline;\">\r\n              {{ col.aggregateValue }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ col.aggregateValue }}\r\n            </span>\r\n          </div>\r\n        </ng-template>\r\n      </kendo-grid-column>\r\n      <kendo-grid-command-column *ngIf=\"data.EnableGridCommand\" width=\"180\" [columnMenu]=\"false\">\r\n        <ng-template kendoGridCellTemplate let-isNew=\"isNew\">\r\n          <button kendoGridSaveCommand>\r\n            {{ isNew ? 'Save' : 'Update' }}\r\n          </button>\r\n          <button kendoGridCancelCommand [primary]=\"true\">\r\n            {{ isNew ? 'Discard changes' : 'Cancel' }}\r\n          </button>\r\n          <button kendoGridEditCommand>\r\n            {{ \"Edit\" }}\r\n          </button>\r\n          <button kendoGridRemoveCommand>\r\n            {{ \"Remove\" }}\r\n          </button>\r\n        </ng-template>\r\n      </kendo-grid-command-column>\r\n      <kendo-grid-excel fileName=\"Export.xlsx\" [fetchData]=\"allResults\"></kendo-grid-excel>\r\n    </kendo-grid>\r\n    <div *ngIf=\"isLoading\" class=\"k-i-loading\"></div>\r\n  </div>\r\n</div>\r\n", styles: [":host ::ng-deep kendo-grid .k-grid-content{white-space:nowrap}:host ::ng-deep kendo-grid .k-toolbar{background-color:#e3ecf8}:host ::ng-deep kendo-grid .k-grid-header{background-color:#e3ecf8;font-weight:600}:host ::ng-deep kendo-grid .k-button{border-radius:5px;box-shadow:0 2px 2px #0000001a;background-color:#c9daf2}:host ::ng-deep kendo-grid .k-grid-header .k-grid-filter:hover,:host ::ng-deep kendo-grid .k-grid-header .k-header-column-menu:hover,:host ::ng-deep kendo-grid .k-grid-header .k-hierarchy-cell .k-icon:hover{background-color:#c9daf2}:host ::ng-deep kendo-grid .k-grid .k-grid-filter,:host ::ng-deep kendo-grid .k-grid .k-header-column-menu,:host ::ng-deep kendo-grid .k-grid .k-hierarchy-cell .k-icon{color:#132842}:host ::ng-deep kendo-grid .k-dropdown .k-dropdown-wrap,:host ::ng-deep kendo-grid .k-dropdowntree .k-dropdown-wrap{border-radius:2px;background-color:#d6e0ef80}:host ::ng-deep kendo-grid tr.k-alt{background-color:#e8eef680}:host ::ng-deep kendo-grid tbody tr:hover,:host ::ng-deep kendo-grid tbody tr.k-state-hover{background-color:#d6e0ef80}:host ::ng-deep kendo-grid .k-pager-wrap{background-color:#e3ecf8}:host ::ng-deep kendo-grid .k-pager-numbers .k-link.k-state-selected{color:#ff5e5b;background-color:#ff5e5b66}:host ::ng-deep kendo-grid .k-pager-numbers .k-link:hover,:host ::ng-deep kendo-grid .k-pager-numbers .k-link.k-state-hover{color:#ff5e5b;background-color:#ff5e5b26}.cellWrapText .gridCell{white-space:pre-line!important}.rightAligned{text-align:right}.centerAligned{text-align:center}.gridTitle{margin:20px 10px 5px;font-size:18px;font-weight:700}.gridCell.primary{color:var(--ion-color-primary)}.gridCell.secondary{color:var(--ion-color-secondary)}.gridCell.tertiary{color:var(--ion-color-tertiary)}.gridCell.success{color:var(--ion-color-success-shade)}.gridCell.warning{color:var(--ion-color-warning)}.gridCell.danger{color:var(--ion-color-danger)}.gridCell.dark{color:var(--ion-color-dark)}.gridCell.medium{color:var(--ion-color-medium)}.gridCell.light{color:var(--ion-color-light)}.k-i-loading{position:absolute;top:100px;left:0;right:0;bottom:0;font-size:45px;background-color:#ffffff4d;color:#0f4800}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ActivatedRoute }, { type: i1.Router }, { type: i2.FormBuilder }, { type: i3.AuthService }, { type: i3.WebApiService }, { type: i3.ZGridStatePersistingService }, { type: i3.ToastService }, { type: i3.ZCoreService }, { type: i3.StorageSessionService }, { type: i4.MainService }]; }, propDecorators: { data: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }], tooltipDir: [{
+                type: ViewChild,
+                args: [TooltipDirective]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zgrid.component.js","sourceRoot":"","sources":["../../../../../projects/mmhglobal-dynamicform/src/lib/zgrid/zgrid.component.ts","../../../../../projects/mmhglobal-dynamicform/src/lib/zgrid/zgrid.component.html"],"names":[],"mappings":"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","sourcesContent":["/********** Angular **********/\r\nimport { Component, OnInit, Input, OnDestroy, ViewChild } from \"@angular/core\";\r\nimport { FormGroup, FormBuilder, Validators, FormControl, FormArray, ValidatorFn } from '@angular/forms';\r\nimport { ActivatedRoute, Router } from \"@angular/router\";\r\n\r\n/********** Ionic **********/\r\n\r\n/********** Plugin **********/\r\nimport { Observable, of, Subject, Subscription } from \"rxjs\";\r\nimport { tap, delay, map, switchMap, concatMap } from \"rxjs/operators\";\r\nimport { ExcelExportData } from '@progress/kendo-angular-excel-export';\r\nimport { GridItem, SelectableSettings } from '@progress/kendo-angular-grid';\r\nimport { SortDescriptor, State, process } from \"@progress/kendo-data-query\";\r\nimport { TooltipDirective } from '@progress/kendo-angular-tooltip';\r\nimport {\r\n  GridDataResult,\r\n  DataStateChangeEvent,\r\n  PageChangeEvent,\r\n  CellClickEvent,\r\n  GridComponent,\r\n  RowArgs,\r\n  ColumnReorderEvent\r\n} from \"@progress/kendo-angular-grid\";\r\n\r\n/********** Component & Service **********/\r\n// import { environment } from \"src/environments/environment\";\r\nimport { MainService } from \"../services/main.service\";\r\nimport { ZGridBindingDirective } from \"./zgrid.binding.directive\";\r\nimport {\r\n  AuthService, WebApiService, ToastService, GridCaching,\r\n  ZField, ZGroup, ZComponent, ZComponentProperties, ZComponentHelper, ZComponentOutputEvent, ZCoreService,\r\n  ZGridStatePersistingService, ZGridPostApiParams, ZGridSettings, ZGridColumnSettings, ZGridCustomColumn, StorageSessionService\r\n} from 'mmhglobal-zcore';\r\n\r\n\r\nexport interface ZGrid {\r\n  params: ZGridPostApiParams;\r\n  state: State;\r\n  columns: any[];\r\n  paginationApiPostUrl: string;\r\n  data: ZField;\r\n  group: ZGroup;\r\n  zgrid: ZGridBindingDirective;\r\n  inlineEditedFormGroups: FormGroup;\r\n  getGridData: () => any[];\r\n  getData: () => void;\r\n  clearData: () => void;\r\n  setData: (data: any) => void;\r\n  setColumns: (columnFieldsName: string, columns: Array<ZGridCustomColumn>) => void;\r\n}\r\n\r\n@Component({\r\n  selector: \"app-zgrid\",\r\n  templateUrl: \"./zgrid.component.html\",\r\n  styleUrls: [\"./zgrid.component.scss\"]\r\n})\r\nexport class ZgridComponent implements ZComponent, OnInit, OnDestroy {\r\n  @Input() data: ZField;\r\n  @Input() group: ZGroup;\r\n  @Input() form: FormGroup;\r\n  @ViewChild(TooltipDirective) public tooltipDir: TooltipDirective;\r\n  // @ViewChild(ZGridBindingDirective, { static: false }) zgrid: ZGridBindingDirective;\r\n  zgrid: any = null;\r\n  oauthUrl: string = null;\r\n\r\n  gridData: GridDataResult;\r\n  selectableSettings: SelectableSettings;\r\n  mySelection: any[] = [];\r\n  inlineEditedFormGroups: FormGroup;\r\n  public formGroup: FormGroup; // for kendo grid built-in\r\n  public previousNext: boolean;\r\n\r\n  componentProperties = new ZComponentProperties();\r\n\r\n  // eslint-disable-next-line @typescript-eslint/naming-convention, no-underscore-dangle, id-blacklist, id-match\r\n  _state: State = {\r\n    skip: 0,\r\n    take: 10\r\n  };\r\n\r\n  params: ZGridPostApiParams = {\r\n    referId: null,\r\n    pageNo: 0,\r\n    pageSize: 20,\r\n    sortColumnName: \"\",\r\n    sortOrder: \"\",\r\n    sortColumnNames: [],\r\n    sortOrders: [],\r\n    filterParams: [],\r\n    parameters: \"\",\r\n    filters: \"\",\r\n    columns: \"\",\r\n    grantType: 4\r\n  };\r\n\r\n  gridSubject: Subject<any> = new Subject<any>();\r\n\r\n  private widthReduce: number;\r\n  private heightReduce: number;\r\n  private gData: any;\r\n\r\n  columns: any[];\r\n  editableColumns: any[];\r\n  subscription: Subscription;\r\n  pageSizes: boolean | any[];\r\n  isLoading: boolean;\r\n  gridStorageKey: string;\r\n  gridDefaultStateExist: boolean = false;\r\n  isNew: boolean = true;\r\n  private editedRowIndex: number;\r\n\r\n  constructor(\r\n    private activatedRoute: ActivatedRoute,\r\n    private router: Router,\r\n    private formBuilder: FormBuilder,\r\n    private authService: AuthService,\r\n    private webApiService: WebApiService,\r\n    private zGridStatePersistingService: ZGridStatePersistingService,\r\n    private toastService: ToastService,\r\n    private zcoreService: ZCoreService,\r\n    private storageService: StorageSessionService,\r\n    private mainService: MainService\r\n  ) {\r\n    this.oauthUrl = this.zcoreService.getEnvironment().e1OauthUrl + \"/\";\r\n    this.allResults = this.allResults.bind(this);\r\n    this.refreshData = this.refreshData.bind(this);\r\n    this.clearData = this.clearData.bind(this);\r\n    this.saveGridSettings = this.saveGridSettings.bind(this);\r\n    this.restoreGridSettings = this.restoreGridSettings.bind(this);\r\n  }\r\n\r\n\r\n  ngOnInit() {\r\n    ZComponentHelper.setComponentProperties(this);\r\n    ZComponentHelper.registerComponent(this);\r\n\r\n    // Grid saved setting key(Used in CookieStore & LocalStorage)\r\n    this.gridStorageKey = 'ionic-field::' + this.authService.e1Token.userName + '::' + this.data.Name + '::' + this.router.url;\r\n\r\n    of(true)\r\n      .pipe(\r\n        //concatMap(() => {\r\n        //  // try get gridsetting from cookiestore\r\n        //  return this.mainService.cookieStoreGet(this.gridStorageKey, this.authService.e1Token.access_token);\r\n        //}),\r\n        //switchMap(savedGridCache => {\r\n        //  if (savedGridCache) {  \r\n        //    // Keep the gridSetting from cookiestore to localStorage\r\n        //    this.zGridStatePersistingService.set(this.gridStorageKey, savedGridCache);\r\n        //    return of(true);\r\n        //  }\r\n        //  return of(false);\r\n        //}),\r\n        switchMap(() => {\r\n          // Grid default setting\r\n          this.columns = [];\r\n          this.widthReduce = this.data.WidthReduce || 60;\r\n          this.heightReduce = this.data.HeightReduce || 560;\r\n          this._state.take = this.data.PageSize || 20;\r\n          this.pageSizes = [20, 50, 100, 200, 500];\r\n          this.previousNext = this.data['EnablePreviousNextButton'] || false;\r\n\r\n          // [Mobile] Disable PageSize\r\n          if (this.data.PageSizes === false || ZComponentHelper.isMobileScreen()) {\r\n            this.pageSizes = false;\r\n          }\r\n\r\n          // Grid Selection column\r\n          if (this.data.SelectOptions) {\r\n            this.selectableSettings = {\r\n              // checkboxOnly: this.checkboxOnly,\r\n              mode: this.data.SelectOptions === 'single' ? 'single' : 'multiple'\r\n            };\r\n          }\r\n\r\n          // bind this to group using Grid value\r\n          if (this.data.Value.startsWith('group.')) {\r\n            const gridValue = this.data.Value.slice(6);\r\n            this.group[gridValue] = this;\r\n          }\r\n\r\n          // clear any Subscription\r\n          if (this.subscription) {\r\n            this.subscription.unsubscribe();\r\n          }\r\n\r\n          // if no ResourceURL, still generate Column first, then insert grid data using DataSource\r\n          if (!this.data.ResourceURL) {\r\n            this.generateGridColumns().subscribe(() => {\r\n              if (this.data.DataSource && this.data.SkipDirective) {\r\n                const ds = ZComponentHelper.getGroupValue(\r\n                  this.data.DataSource,\r\n                  this.group\r\n                );\r\n                this.setData(ds);\r\n              }\r\n            });\r\n          }\r\n\r\n          // subscribe to set grid setting from directive to component\r\n          this.subscription = this.gridSubject.subscribe(grid => {\r\n            this.zgrid = grid;\r\n            this._state = this.zgrid.state;\r\n            this.columns = this.zgrid.gridColumns;\r\n            if (this.zgrid && this.zgrid.grid.data) {\r\n              this.gridData = Object.assign({}, this.zgrid.grid.data);\r\n              this.createFormControls();\r\n            }\r\n          });\r\n\r\n          // Check Grid setting exist in localstorage\r\n          this.stateExist();\r\n\r\n          // Set Filter SessionKey\r\n          if (this.data['SaveFilter']) {\r\n            this.setGridSessionKey(this.group);\r\n          }\r\n          return of(true);\r\n        }),\r\n        tap(() => {\r\n          this.gridCallback(this.group);\r\n        }),\r\n      ).subscribe();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    if (this.subscription) {\r\n      this.subscription.unsubscribe();\r\n    }\r\n  }\r\n\r\n  /* Start Grid State (pagination, sortable, filter, ordering) */\r\n  get state() {\r\n    return this._state;\r\n  }\r\n\r\n  private stateExist() {\r\n    const userGridState = this.zGridStatePersistingService.get(this.gridStorageKey);\r\n\r\n    if (userGridState) {\r\n      this.gridDefaultStateExist = true;\r\n    }\r\n    else {\r\n      this.gridDefaultStateExist = false;\r\n    }\r\n  }\r\n\r\n  public dataStateChange(state: DataStateChangeEvent): void {\r\n    if (this.zgrid) {\r\n      this.zgrid.dataStateChange(state);\r\n    } else {\r\n      this.gridData = process(this.gData, state);\r\n      this.createFormControls();\r\n    }\r\n  }\r\n\r\n  public filterable(value: any) {\r\n    if (value === false) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  public sortable(value: any) {\r\n    if (value === false) {\r\n      return false;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  public locked(colSetting: any) {\r\n    if (colSetting['pinnedLeft'] == true) {\r\n      return true;\r\n    }\r\n    return false;\r\n  }\r\n\r\n  /* End Grid State (pagination, sortable, filter, ordering) */\r\n\r\n  /* Start Grid Styling, Display */\r\n  public getGridStyle() {\r\n    return {\r\n      \"height.px\": this.getGridHeight(), // window.innerHeight - this.heightReduce, // 450,\r\n      \"width.px\": window.innerWidth - this.widthReduce\r\n    }; // \"width.px\": this.innerWidth - 35\r\n  }\r\n\r\n  private getGridHeight() {\r\n    const gridHeight = window.innerHeight - this.heightReduce;\r\n    return (gridHeight < 250) ? 250 : gridHeight;\r\n    // const v = ZComponentHelper.isMobileScreen();\r\n    // if(v){\r\n    //   const h = window.innerHeight - this.heightReduce;\r\n    //   return (h < 250) ? 250 : h;\r\n    // }else{\r\n    //   return \"auto\";\r\n    // } \r\n  }\r\n  /* End Grid Styling, Display */\r\n\r\n\r\n  /* Start Grid Columns */\r\n  public isSelectOption() {\r\n    let selectOptionExist = false;\r\n    if (this.data.SelectOptions) {\r\n      this.selectableSettings = {\r\n        checkboxOnly: false,\r\n        mode: (this.data.SelectOptions == \"multiple\") ? \"multiple\" : \"single\"\r\n      };\r\n      selectOptionExist = true;\r\n    }\r\n    return selectOptionExist;\r\n  }\r\n\r\n  public setColumns(columnName: string, columns: Array<ZGridCustomColumn>) {\r\n    this.group[columnName] = this.wrapColumnNamesInFieldElement(columns);\r\n    this.generateGridColumns().subscribe();\r\n  }\r\n\r\n  private wrapColumnNamesInFieldElement(columnList: Array<ZGridCustomColumn>) {\r\n    return of(columnList.map(c => {\r\n      const isHidden: boolean = c.Hidden;\r\n      return {\r\n        Name: c.Name,\r\n        Value: c.Code,\r\n        Type: c.Type,\r\n        gridColVisible: !isHidden,\r\n        width: 100 + c.Name.length * 4,\r\n        enableFiltering: false,\r\n        enableSorting: true,\r\n        enablePinning: true,\r\n        DivClass: \"col-xs-12 col-sm-6\",\r\n        IsEditableInGrid: c.Editable\r\n      };\r\n    }));\r\n  }\r\n\r\n  private generateGridColumns(): Observable<any> {\r\n    const gridSetting = this.getGridSettings();\r\n\r\n    const columnFields$: Observable<any> = ZComponentHelper.getGroupValue(\r\n      this.data.ColumnFields,\r\n      this.group\r\n    );\r\n    if (!this.data.ColumnFields) {\r\n      console.warn('Invalid/Empty grid(' + this.data.Name + ') columnField');\r\n    }\r\n    return columnFields$.pipe(\r\n      tap(data => {\r\n        if (!data) {\r\n          console.warn('Invalid/Empty grid(' + this.data.Name + ') data to generate column');\r\n        }\r\n        const fieldName = this.data['FieldElementName'];\r\n        this.columns = [];\r\n        ZComponentHelper.getGridColumns(data,\r\n          this.columns,\r\n          this.group,\r\n          this.authService,\r\n          fieldName,\r\n          gridSetting,\r\n          null,\r\n          this.data);\r\n      }),\r\n      //switchMap(() => {\r\n      //  //Get Session\r\n      //  return this.getGridSessionFilter(this.grp, this);\r\n      //}),\r\n      //switchMap(() => {\r\n      //  //Before get grid data\r\n      //  return this.beforeGridGetData(this.grp, this);\r\n      //}),\r\n      //switchMap(() => {\r\n      //  //Set grid data\r\n      //  return this.setGridSessionFilter(this.grp, this);\r\n      //})\r\n    );\r\n  }\r\n\r\n  /* End Grid Columns */\r\n\r\n  private editModel(dataItem: any) {\r\n    if (this.data.EditClickURL) {\r\n      // Edit incell field\r\n      const colFields = ZComponentHelper.getGroupValue(this.data.ColumnFields, this.group);\r\n      this.group.subject.next({\r\n        type: \"zgrid-cellClick\",\r\n        target: this.data.EditClickURL,\r\n        data: dataItem,\r\n        columnFields$: colFields\r\n      } as ZComponentOutputEvent);\r\n    }\r\n    else {\r\n      // When clicked route to page\r\n      this.router.navigate([this.group.editModelURL, dataItem.Id, 'edit'], {\r\n        relativeTo: this.activatedRoute\r\n      });\r\n    }\r\n  }\r\n\r\n  public gridCallback(group: ZGroup) {\r\n    if (this.data['AfterloadCallback']) {\r\n      const me = Object.assign({}, this);\r\n\r\n      this.group.subject.next({\r\n        type: \"zgrid-AfterloadCallback\",\r\n        target: this.data['AfterloadCallback'],\r\n        data: me\r\n      } as ZComponentOutputEvent);\r\n    }\r\n  }\r\n\r\n  public setData = (gData: any) => {\r\n    this.gridData = {\r\n      data: gData,\r\n      total: (gData ? gData.length : 0)\r\n    };\r\n    this.gData = gData;\r\n\r\n    if (this.zgrid) {\r\n      this.zgrid.grid['pageSize'] = gData.length; // set grid size\r\n    }\r\n\r\n    if (!!this.data.ShowRecordNumber) {\r\n      if (this.gridData.data) {\r\n        this.gridData.data.forEach((d, i) => {\r\n          d.GridNo = i + 1;\r\n        });\r\n      }\r\n    }\r\n\r\n    if (this.gData) {\r\n      this.createFormControls();\r\n    }\r\n  }\r\n\r\n  public getData() {\r\n    if (this.zgrid) {\r\n      this.zgrid.getDataBinding();\r\n    }\r\n\r\n    if (this.data.SkipDirective) {\r\n      this.gridData = process(this.gData, this.state);\r\n      this.createFormControls();\r\n    }\r\n  }\r\n\r\n  public getGridData() {\r\n    return this.gData;\r\n  }\r\n\r\n\r\n  public getFormControl(rowIndex: number, property: string) {\r\n    const formArray: FormArray = this.inlineEditedFormGroups.get('items') as FormArray;\r\n    const formItem = formArray.at(rowIndex);\r\n\r\n    if (formItem) {\r\n      return formItem.get(property);\r\n    }\r\n    else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  private createFormControls() {\r\n    if (this.columns) {\r\n      // only create if there is at least 1 editable column\r\n      if (this.columns.find(c => c.isEditableInGrid) === undefined) {\r\n        return;\r\n      }\r\n\r\n      this.inlineEditedFormGroups = new FormGroup({ items: new FormArray([]) });\r\n\r\n      if (Array.isArray(this.gridData.data)) {\r\n        this.gridData.data.forEach(d => {\r\n          const items = {};\r\n          this.columns.forEach(c => {\r\n            items[c.field] = new FormControl(d[c.field]);\r\n          });\r\n          const formGroup = new FormGroup(items);\r\n          (<FormArray>this.inlineEditedFormGroups.get(\"items\")).push(formGroup);\r\n        });\r\n      }\r\n    }\r\n  }\r\n\r\n  public createFormGroup(dataItem: any, fieldName: any): FormGroup {\r\n    return this.formBuilder.group({\r\n      [fieldName]: dataItem[fieldName]\r\n    });\r\n  }\r\n\r\n  public getGroupValue(value: string, group: ZGroup) {\r\n    return ZComponentHelper.getGroupValue(this.data.Value, this.group);\r\n  }\r\n\r\n\r\n\r\n  public onBtnClick(event: any, colSetting: any, rowData: any, cellData: string) {\r\n    this.onNavigateTo(event, colSetting, rowData, cellData);\r\n  }\r\n\r\n  public cellClickHandler(event: CellClickEvent) {\r\n    const disableAllColumnCellClickHandler = this.data.DisableCellClickHandler ? this.data.DisableCellClickHandler : false;\r\n    const isCommandColumn = event.column.constructor.name == 'CommandColumnComponent' ? true : false;\r\n\r\n    if (!disableAllColumnCellClickHandler && !isCommandColumn) {\r\n      const inCellEditable = this.data.InCellEditable ? this.data.InCellEditable : false;\r\n      if (inCellEditable) {\r\n        this.editableColumns = this.columns.filter(s => s.isEditableInDataItem === true);\r\n        if (!!this.editableColumns) {\r\n          this.editableColumns.map(s => event.sender.editCell(event.rowIndex, event.columnIndex, this.createFormGroup(event.dataItem, s.field)));\r\n        }\r\n      } else {\r\n        console.log(\"cellClick event: \", event);\r\n        if (this.data.OnItemClick) {\r\n          const func = ZComponentHelper.getGroupEvalValue.call(this, this.data.OnItemClick);\r\n          if (typeof func === 'function') {\r\n            const callFunc = func.bind(this.group.ctrlScope);\r\n            callFunc(event);\r\n          }\r\n          return;\r\n        }\r\n\r\n        this.editModel(event.dataItem);\r\n      }\r\n    }\r\n  }\r\n\r\n  public editCellCloseHandler(args: any) {\r\n    const { formGroup, dataItem } = args;\r\n    if (!formGroup.valid) {\r\n      args.preventDefault();\r\n    } else if (formGroup.dirty) {\r\n      this.editableColumns = this.columns.filter(s => s.isEditableInDataItem === true);\r\n      this.editableColumns.map(s =>\r\n        Object.assign(dataItem, { [s.field]: formGroup.value[s.field] }));\r\n      this.mySelection.map(s => (s.Id === dataItem.Id) ? Object.assign(s, dataItem) : null);\r\n    }\r\n  }\r\n\r\n\r\n  public onNavigateTo(event: any, clickAction: any, rowData: any, cellData: string) {\r\n    // debugger;\r\n    // const n = colSetting.navigateTo.replace('/:id', cellData);\r\n    const n = ZComponentHelper.getGroupEvalValue.call(this, clickAction.Click);\r\n    if (n) {\r\n      event.stopPropagation();\r\n      this.group.subject.next({\r\n        type: 'zgrid-onNavigateTo',\r\n        target: clickAction.Click,\r\n        rowData: rowData,\r\n        data: cellData\r\n      } as ZComponentOutputEvent);\r\n    }\r\n  }\r\n\r\n  public showTooltip(e: MouseEvent): void {\r\n    const element = e.target as HTMLElement;\r\n\r\n    let isCommandColumn = false;\r\n    element.classList.forEach(data => {\r\n      if (data == 'k-command-cell') {\r\n        isCommandColumn = true;\r\n      }\r\n    });\r\n\r\n    if (((element.nodeName === 'TD' || element.nodeName === 'TH') && element.offsetWidth < element.scrollWidth) && !isCommandColumn) {\r\n      this.tooltipDir.toggle(element);\r\n    }\r\n    else {\r\n      this.tooltipDir.hide();\r\n    }\r\n  }\r\n\r\n  public rowSelectionKey(context: RowArgs): any {\r\n    return context.dataItem;\r\n  }\r\n\r\n  public getSeletectedValues(): any {\r\n    return this.mySelection;\r\n  }\r\n\r\n  public refreshGrid(event: ZComponentOutputEvent, group: ZGroup, me: any) {\r\n    const _gridOptionSegment = event.target.trim().split('.');\r\n    const _gridOption = _gridOptionSegment[1];\r\n    if (_gridOption) {\r\n      const zgridControl = group[_gridOption] as ZGrid;\r\n      if (zgridControl) {\r\n        zgridControl.getData();\r\n      } else {\r\n        console.log('Unable to find grid value: ' + _gridOption);\r\n      }\r\n    } else {\r\n      console.log('Invalid refreshGrid event: ', event);\r\n    }\r\n  }\r\n\r\n  public refreshData() {\r\n    this.getData();\r\n  }\r\n\r\n  public clearData() {\r\n    this.zgrid.clearData();\r\n  }\r\n\r\n\r\n  public allResults(): Observable<ExcelExportData> {\r\n    const _zgridControl = this.zgrid as ZGrid;\r\n    const _zgridComponent = this.zgrid.grid as GridComponent;\r\n    const _data = _zgridComponent.data as GridDataResult;\r\n\r\n    const paginationApiPostUrl = _zgridControl.paginationApiPostUrl;\r\n\r\n    // Need to clone, if not will affect the grid params.\r\n    const params = Object.assign({}, this.params);\r\n    params.pageNo = 0;\r\n    params.pageSize = _data.total;\r\n\r\n    return this.webApiService.httpPost$(paginationApiPostUrl, params).pipe(\r\n      map((data: any) => {\r\n        const result: ExcelExportData = {\r\n          data: process(data.dataSet, {}).data\r\n        };\r\n\r\n        return result;\r\n      })\r\n    );\r\n  }\r\n\r\n  public getClass(dataItem: any, col: any) {\r\n    let ngClass = \"gridCell \";\r\n    if (col.fieldType === 'number' || col.fieldType === 'currency' || col.fieldType === 'znumeric') {\r\n      ngClass += \"rightAligned \";\r\n    }\r\n\r\n    if (dataItem[col.field + '_Class']) {\r\n      ngClass += dataItem[col.field + '_Class'] + \" \";\r\n    }\r\n\r\n    if (col.Class) {\r\n      ngClass += col.Class + \" \";\r\n    }\r\n\r\n    return ngClass;\r\n  }\r\n\r\n  public getFormat(col: any, defaultFormat?: any) {\r\n    let format = \"\";\r\n    if (col.FormatOptions === undefined) {\r\n      format = defaultFormat ? defaultFormat : \"\";\r\n    } else {\r\n      const formatArr = col.FormatOptions.split(\".\")\r\n      let dp = 0;\r\n\r\n      if (formatArr.length > 1) {\r\n        dp = formatArr[1].length;\r\n      }\r\n\r\n      if (dp !== 0) {\r\n        format = \"1.\" + dp + \"-\" + dp;\r\n      }\r\n    }\r\n    return format;\r\n  }\r\n\r\n\r\n  public setHeaderText(columnName: string, newHeaderTitle: string) {\r\n    const gridColumns = this.columns;\r\n    gridColumns.forEach((col: any) => {\r\n      if (col.Name === columnName) {\r\n        col.title = newHeaderTitle;\r\n      }\r\n    });\r\n  }\r\n\r\n  public setGridIsLoading(triggered: boolean) {\r\n    this.isLoading = triggered;\r\n  }\r\n\r\n  public setGridSessionKey(group: ZGroup) {\r\n    if (group[\"GridStorageKey\"]) {\r\n      return;\r\n    }\r\n    else {\r\n      group[\"GridStorageKey\"] = 'zgrid_' + group.resourceURL + '_' + this.data.Value + '::' + this.authService.e1Token.userName;\r\n    }\r\n\r\n  }\r\n\r\n  public trackBy(index: number, item: GridItem): any {\r\n    //console.log(item.data['Id'] || index);\r\n    return index;\r\n  }\r\n\r\n  /* Grid configuration function */\r\n  public saveGridSettings(): void {\r\n    const _zgridComponent = this.zgrid.grid as GridComponent;\r\n    const _columns = _zgridComponent.columns;\r\n\r\n    of(this.columns)\r\n      .pipe(\r\n        switchMap(() => {\r\n          const configValue: ZGridColumnSettings[] = _columns.toArray().map(item => {\r\n            const _zGridColumnSettings: ZGridColumnSettings = Object.keys(item)\r\n              .filter(propName => {\r\n                return !propName.toLowerCase().includes('template')\r\n              })\r\n              .reduce((acc, curr) => (\r\n                {\r\n                  ...acc,\r\n                  ...{ [curr]: item[curr] }\r\n                })\r\n                , {} as ZGridColumnSettings);\r\n            return _zGridColumnSettings;\r\n          });\r\n\r\n          // remove extra element form array\r\n          configValue.forEach(item => {\r\n            delete item['headerStyle'];\r\n            delete item['__ngContext__'];\r\n          });\r\n\r\n          const gridSetting: ZGridSettings = {\r\n            // state: this.state,\r\n            columnsConfig: configValue\r\n          };\r\n\r\n          // Find any setting from localstorage and update, if not just add in.\r\n          let _arrGridCaching: GridCaching[] = this.zGridStatePersistingService.get(this.gridStorageKey);\r\n          let _gridConfig: GridCaching = null;\r\n          if (_arrGridCaching && _arrGridCaching[0]) {\r\n            _gridConfig = _arrGridCaching.find(x => x['dataFormFields'] === this.gridStorageKey);\r\n\r\n            if (_gridConfig) {\r\n              _gridConfig.gridSettings = gridSetting;\r\n            }\r\n          }\r\n          else {\r\n            _arrGridCaching = [];\r\n          }\r\n\r\n          if (!_gridConfig) {\r\n            _gridConfig = {\r\n              dataFormFields: this.gridStorageKey,\r\n              gridSettings: gridSetting\r\n            };\r\n\r\n            _arrGridCaching.push(_gridConfig);\r\n          }\r\n          return _arrGridCaching;\r\n        }),\r\n        concatMap(gridCache => {\r\n          // Save grid caching to localstorage\r\n          this.zGridStatePersistingService.set(this.gridStorageKey, gridCache);\r\n          // Save to CookieStore\r\n          return this.mainService.cookieStorePost(this.gridStorageKey, gridCache);\r\n        }),\r\n        tap(savedGridCache => {\r\n          // check is saved state exist to enable/hide restore button\r\n          this.stateExist();\r\n        }),\r\n        tap(() => {\r\n          // Alert\r\n          this.toastService.show('Grid Setting Saved', \"top\", true, 2000, 'success');\r\n        })\r\n      ).subscribe();\r\n  }\r\n\r\n  public restoreGridSettings() {\r\n    of(true)\r\n      .pipe(\r\n        switchMap(() => {\r\n          // Clear localstorage grid setting\r\n          this.zGridStatePersistingService.remove(this.gridStorageKey);\r\n          return of(true)\r\n        }),\r\n        switchMap(() => {\r\n          // delete cookiestore gridSetting by storagekey as name\r\n          return this.mainService.cookieStoreDeleteMultiple(this.gridStorageKey);\r\n        }),\r\n        concatMap(() => {\r\n          // Use original column setting\r\n          return this.generateGridColumns();\r\n        }),\r\n        tap(() => {\r\n          // check is saved state exist\r\n          this.stateExist();\r\n          // Alert\r\n          this.toastService.show('Grid Setting Restored', \"top\", true, 2000, 'success');\r\n        })\r\n      ).subscribe();\r\n  }\r\n\r\n  private getGridSettings(): ZGridColumnSettings[] {\r\n    const _storageKey = 'ionic-field::' + this.authService.e1Token.userName + '::' + this.data.Name + '::' + this.router.url;\r\n\r\n    // Find any setting from localstorage..\r\n    let _arrGridCaching: GridCaching[] = this.zGridStatePersistingService.get(_storageKey);\r\n    if (_arrGridCaching) {\r\n      const _gridCaching: GridCaching = JSON.parse(_arrGridCaching['Value']);\r\n      if (_gridCaching) {\r\n        return _gridCaching.gridSettings.columnsConfig.sort((a, b) => a.orderIndex - b.orderIndex);\r\n      }\r\n    }\r\n  }\r\n\r\n  /* Inline setting */\r\n  public getInlineField(value: any) {\r\n    return this.columns.find(x => x.Value === value);\r\n  }\r\n\r\n  public getInlineForm(rowIndex: number) {\r\n    const formArray: FormArray = this.inlineEditedFormGroups.get('items') as FormArray;\r\n    return formArray.at(rowIndex)\r\n  }\r\n\r\n  public getFormControlData(value: any) {\r\n    return this.inlineEditedFormGroups.value.items;\r\n  }\r\n\r\n\r\n  /* Event */\r\n  public beforeGridGetData(group: ZGroup, me: any) {\r\n    console.warn(\"beforeDataBinding triggered\");\r\n    if (!group.beforeGridGetData) {\r\n      console.warn(\"group.beforeDataBinding is undefined\");\r\n      return of(true);\r\n    }\r\n    return group.beforeGridGetData(group, me);\r\n  }\r\n\r\n  public async getGridSessionFilter(group: ZGroup, me: any) {\r\n    if (!group[\"GridStorageKey\"]) {\r\n      return null;\r\n    }\r\n    const StorageKey = group[\"GridStorageKey\"];\r\n\r\n    if (this.storageService) {\r\n      await this.storageService.get(StorageKey)\r\n        .then(data => {\r\n          if (!data || !data.value || data.value === \"null\") {\r\n            return null;\r\n          }\r\n          else {\r\n            const result = JSON.parse(data.value);\r\n            this.state.filter = JSON.parse(result[\"StateFilter\"]);\r\n            this.params.filterParams = JSON.parse(result[\"FilterParams\"]);\r\n\r\n            this.state.filter.filters.forEach((stateFilter: any) => {\r\n              if (stateFilter.field.includes('UTC')) {\r\n                stateFilter.value = new Date(stateFilter.value);\r\n              }\r\n            });\r\n\r\n            return data;\r\n          }\r\n        });\r\n    }\r\n    else {\r\n      return null;\r\n    }\r\n  }\r\n\r\n  public setGridSessionFilter(group: ZGroup, me: any) {\r\n    if (!group[\"GridStorageKey\"]) {\r\n      return null;\r\n    }\r\n    const StorageKey = group[\"GridStorageKey\"];\r\n\r\n    let lstGridFilter: { [key: string]: string } = {};\r\n\r\n    if (me.state.filter && this.storageService && this.data['SaveFilter']) {\r\n      //list of data for StateFilter and FilterParams\r\n      lstGridFilter = { \"StateFilter\": JSON.stringify(me.state.filter), \"FilterParams\": JSON.stringify(me.params.filterParams) }\r\n      //create session storage\r\n      this.storageService.set(StorageKey, JSON.stringify(lstGridFilter));\r\n    }\r\n  }\r\n\r\n  /* Available Functions */\r\n  public setEnable = (status: boolean) => {\r\n    this.componentProperties.isReadOnly = !status;\r\n  }\r\n\r\n  public setVisible = (status: boolean) => {\r\n    this.componentProperties.isVisible = status;\r\n    this.data.Visible = status;\r\n  }\r\n\r\n  public setRequire = (status: boolean) => {\r\n    this.componentProperties.isRequired = status;\r\n    ZComponentHelper.changeValidator(status, this.group, this.data.Value, this.componentProperties, Validators.required);\r\n  }\r\n\r\n\r\n  /* onchange Events */\r\n  public filterChange(event: any): void {\r\n    if (this.zgrid) {\r\n      this.zgrid.filterChange(event);\r\n    }\r\n  }\r\n\r\n  public pageChange(event: PageChangeEvent): void { \r\n    if (this.zgrid) {\r\n      this.zgrid.pageChange(event);\r\n    }\r\n  }\r\n\r\n  public sortChange(sort: SortDescriptor[]): void {\r\n    if (this.zgrid) {\r\n      this.zgrid.sortChange(sort);\r\n    }\r\n  }\r\n\r\n  public inCellCheckBoxOnChange(event: any, rowIndex: any, column: any) {\r\n    const isChecked = event.detail.checked;\r\n    this.gData[rowIndex][column.Value] = isChecked;\r\n  }\r\n\r\n  public columnsOrderChanged(event: ColumnReorderEvent): void {\r\n    const _zgridControl = this.zgrid as ZGrid;\r\n    const _zgridComponent = this.zgrid.grid as GridComponent;\r\n    const _data = _zgridComponent.data as GridDataResult;\r\n\r\n    if (this.zgrid) {\r\n      const _zgrid = this.zgrid;\r\n    }\r\n  }\r\n\r\n\r\n  /* grid command handler */\r\n  public addHandler({ sender }) {\r\n    this.isNew = true;\r\n\r\n    // close any existing editor\r\n    this.closeEditor(sender);\r\n\r\n    // loop all column to get validation and create form control\r\n    const colFormControl = {};\r\n    this.zgrid.gridColumns.forEach(col => {\r\n      const validators: ValidatorFn[] = [];\r\n      if (col.IsRequired) {\r\n        validators.push(Validators.required);\r\n      }\r\n      if (col.ValidatorPattern) {\r\n        validators.push(Validators.pattern(col.ValidatorPattern));\r\n      } \r\n\r\n      colFormControl[col.Value] = new FormControl(null, validators); \r\n    });\r\n\r\n    // set form control object to form group\r\n    this.formGroup = new FormGroup(colFormControl);\r\n\r\n    // add to grid row\r\n    sender.addRow(this.formGroup);\r\n  }\r\n\r\n  public saveHandler({ sender, rowIndex, formGroup, isNew }): void {\r\n    // get grid data.\r\n    const gridExistingData = this.gData ? this.gData : this.gridData ? this.gridData.data : [];\r\n\r\n    // if valid\r\n    if (formGroup.valid) {\r\n      // check for duplicate UniqueKey\r\n      let uniqueKeyExist: boolean;\r\n      const uniqueKey = this.data['UniqueKey'];\r\n      if (uniqueKey) { \r\n        const formUniqueKeyValue = formGroup.value[uniqueKey];\r\n\r\n        if (isNew || (!isNew && (gridExistingData[rowIndex][uniqueKey] != formUniqueKeyValue))) {\r\n          // if new...\r\n          // if edit... if current field, uniquekey value changed. need to check.  \r\n          gridExistingData.forEach(data => {\r\n            if (data[uniqueKey] === formUniqueKeyValue) {\r\n              uniqueKeyExist = true;\r\n              return;\r\n            }\r\n          });\r\n        }\r\n      }\r\n\r\n      if (!uniqueKeyExist) {\r\n        if (isNew) {\r\n          // if new, push to data\r\n          gridExistingData.push(formGroup.value);\r\n        }\r\n        else {\r\n          // if edit, update data\r\n          gridExistingData[rowIndex] = formGroup.value;\r\n        }\r\n\r\n        this.setData(gridExistingData);\r\n\r\n        sender.closeRow(rowIndex);\r\n      }\r\n      else {\r\n        this.toastService.show('Error occur: Duplicated unique field entry.', 'top', true, 3000, 'danger');\r\n      }\r\n    }\r\n  }\r\n\r\n  public cancelHandler({ sender, rowIndex }) {\r\n    // cancel any existing editor\r\n    sender.closeRow(rowIndex);\r\n  }\r\n\r\n  public editHandler({ sender, rowIndex, dataItem }) {\r\n    this.isNew = false;\r\n\r\n    // close any existing editor\r\n    this.closeEditor(sender);\r\n     \r\n    // loop all column to get validation and create form control, append current row value\r\n    const colFormControl = {};\r\n    this.zgrid.gridColumns.forEach(col => {\r\n      const validators: ValidatorFn[] = [];\r\n      if (col.IsRequired) {\r\n        validators.push(Validators.required);\r\n      }\r\n      if (col.ValidatorPattern) {\r\n        validators.push(Validators.pattern(col.ValidatorPattern));\r\n      }\r\n       \r\n      colFormControl[col.Value] = new FormControl(dataItem[col.Value], validators);\r\n    });\r\n\r\n    // set form control object to form group\r\n    this.formGroup = new FormGroup(colFormControl);\r\n\r\n    // set grid row to edit\r\n    this.editedRowIndex = rowIndex; \r\n    sender.editRow(rowIndex, this.formGroup);\r\n  }\r\n\r\n  public removeHandler({ sender, dataItem }) {\r\n    const index = this.getItemIndex(dataItem, this.gData, this.data['UniqueKey']);\r\n    this.gData.splice(index, 1);\r\n\r\n    sender.cancelCell();\r\n  }\r\n\r\n  private closeEditor(grid, rowIndex = this.editedRowIndex) {\r\n    grid.closeRow(rowIndex);\r\n    this.editedRowIndex = undefined;\r\n    this.formGroup = undefined;\r\n  }\r\n\r\n  private getItemIndex(item: any, data: any[], key: string): number {\r\n    for (let idx = 0; idx < data.length; idx++) {\r\n      if (data[idx][key] === item[key]) {\r\n        return idx;\r\n      }\r\n    }\r\n\r\n    return -1;\r\n  }\r\n}\r\n","<!--\r\n<div style=\"margin: 10px\">\r\n  <div class=\"card\">\r\n      <div class=\"card-block k-form\">\r\n          <fieldset>\r\n            <legend>Binding types</legend>\r\n            <div class=\"k-form-field\">\r\n                <span>Bind the data to:</span>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"array\" value=\"array\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"array\">Array object</label>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"gridDataResult\" value=\"gridDataResult\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"gridDataResult\">GridDataResult object</label>\r\n                <input [(ngModel)]=\"bindingType\" type=\"radio\" name=\"mode\" id=\"async\" value=\"async\" class=\"k-radio\"\r\n                (change)=\"changeBindingType($event)\">\r\n                <label class=\"k-radio-label\" for=\"async\">Asynchronous source</label>\r\n            </div>\r\n          </fieldset>\r\n      </div>\r\n  </div>\r\n</div> -->\r\n<div style=\"margin: 10px 0 6px 0;\">\r\n  <div *ngIf=\"data.Title\" class=\"gridTitle\">{{data.Title}}</div>\r\n  <ng-template #template let-anchor>\r\n    <span>{{ anchor.nativeElement.innerText }}</span>\r\n  </ng-template>\r\n  <div kendoTooltip\r\n       showOn=\"none\"\r\n       [tooltipTemplate]=\"template\"\r\n       filter=\".k-grid td\"\r\n       (mouseover)=\"showTooltip($event)\"> \r\n    <kendo-grid [zgridbinding]=\"{data: data, group: group, params: params, gridSubject: gridSubject}\" [ngClass]=\"data.Class\"\r\n                [data]=\"gridData\"\r\n                [pageSize]=\"state.take\"\r\n                [pageable]=\"{responsive: true, buttonCount: 3, pageSizes: pageSizes, previousNext: previousNext}\"\r\n                [skip]=\"state.skip\"\r\n                [sort]=\"state.sort\"\r\n                [sortable]=\"{allowUnsort: true,mode: 'multiple'}\"\r\n                [filter]=\"state.filter\"\r\n                [filterable]=\"data.enableFiltering !== false\"\r\n                [resizable]=\"true\"\r\n                [reorderable]=\"true\"\r\n                [columnMenu]=\"data.DisableGridColumnMenu ? false : { filter: true }\"\r\n                [hidden]=\"!(!!componentProperties.isVisibleField ? group[componentProperties.isVisibleField] : componentProperties.isVisible)\"\r\n                (cellClick)=\"cellClickHandler($event)\"\r\n                (cellClose)=\"editCellCloseHandler($event)\"\r\n                (dataStateChange)=\"dataStateChange($event)\"\r\n                (pageChange)=\"pageChange($event)\"\r\n                (sortChange)=\"sortChange($event)\"\r\n                (filterChange)=\"filterChange($event)\"\r\n                (columnReorder)=\"columnsOrderChanged($event)\"\r\n                [kendoGridSelectBy]=\"rowSelectionKey\"\r\n                [selectable]=\"selectableSettings\"\r\n                [selectedKeys]=\"mySelection\"\r\n                [ngStyle]=\"getGridStyle()\"\r\n                [trackBy]=\"trackBy\"\r\n                (cancel)=\"cancelHandler($event)\"\r\n                (save)=\"saveHandler($event)\"\r\n                (remove)=\"removeHandler($event)\"\r\n                (edit)=\"editHandler($event)\"\r\n                (add)=\"addHandler($event)\">\r\n      <ng-template kendoGridToolbarTemplate *ngIf=\"data.AllowRefreshButton || data.AllowExport || data.AllowSaveState || data.EnableGridCommand\">\r\n        <button type=\"button\" kendoButton (click)=\"refreshData()\" *ngIf=\"data.AllowRefreshButton\"><span class=\"k-icon k-i-refresh-sm\"></span>&nbsp;Refresh</button>\r\n        <button type=\"button\" kendoGridExcelCommand *ngIf=\"data.AllowExport\"><span class=\"k-icon k-i-file-excel\"></span>&nbsp;Export Data to Excel</button>\r\n        <button type=\"button\" kendoButton (click)=\"saveGridSettings()\" *ngIf=\"data.AllowSaveState\"><span class=\"k-icon k-i-star\"></span>&nbsp;Save Setting</button>\r\n        <button type=\"button\" kendoButton (click)=\"restoreGridSettings()\" *ngIf=\"gridDefaultStateExist\"><span class=\"k-icon k-i-star-outline\"></span>&nbsp;Restore Setting</button>\r\n        <button type=\"button\" kendoGridAddCommand *ngIf=\"data.EnableGridCommand \"><span class=\"k-icon k-i-add\"></span>Add New</button>\r\n      </ng-template>\r\n      <kendo-grid-checkbox-column *ngIf=\"!!data.SelectOptions\" [width]=\"60\" showSelectAll=\"true\" [columnMenu]=\"true\"></kendo-grid-checkbox-column>\r\n      <kendo-grid-column *ngFor=\"let col of columns\"\r\n                         [field]=\"col.field\"\r\n                         [title]=\"col.title\"\r\n                         [width]=\"col.width\"\r\n                         [minResizableWidth]=\"col.minResizableWidth\"\r\n                         [filter]=\"col.filter\"\r\n                         [filterable]=\"filterable(col.enableFiltering)\"\r\n                         [sortable]=\"sortable(col.enableSorting)\"\r\n                         [headerStyle]=\"{'white-space': 'initial'}\"\r\n                         [hidden]=\"col.hidden\"\r\n                         [format]=\"col.format\"\r\n                         [class]=\"col.Class\"\r\n                         [locked]=\"locked(col)\"\r\n                         [columnMenu]=\"!col.disableColumnMenu\"\r\n                         [editor]=\"col.editorType\">\r\n        <div [ngSwitch]=\"true\">\r\n          <div *ngSwitchCase=\"col.fieldType === 'number'\r\n               || col.fieldType === 'currency'\r\n               || col.fieldType === 'znumeric'\">\r\n            <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n              <kendo-grid-numeric-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"eq\">\r\n                <kendo-filter-eq-operator></kendo-filter-eq-operator>\r\n                <kendo-filter-neq-operator></kendo-filter-neq-operator>\r\n                <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n              </kendo-grid-numeric-filter-cell>\r\n            </ng-template>\r\n          </div>\r\n          <div *ngSwitchCase=\"col.fieldType == 'zdate'\r\n               || col.fieldType === 'ztime'\r\n               || col.fieldType === 'zdatetime'\r\n               || col.fieldType === 'zuidatetime'\">\r\n            <div *ngIf=\"col.filterByDateRange === true\">\r\n              <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\" operator=\"lte\">\r\n                <date-range-filter-cell class=\"date-range-filter\"\r\n                                        [filter]=\"filter\"\r\n                                        [field]=\"col.field\">\r\n                  <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                  <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                  <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                  <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                  <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                  <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n                </date-range-filter-cell>\r\n              </ng-template>\r\n            </div>\r\n            <div *ngIf=\"col.filterByDateRange === false\">\r\n              <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n                <kendo-grid-date-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"lte\">\r\n                  <kendo-filter-lt-operator></kendo-filter-lt-operator>\r\n                  <kendo-filter-lte-operator></kendo-filter-lte-operator>\r\n                  <kendo-filter-gt-operator></kendo-filter-gt-operator>\r\n                  <kendo-filter-gte-operator></kendo-filter-gte-operator>\r\n                  <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                  <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n                </kendo-grid-date-filter-cell>\r\n              </ng-template>\r\n            </div>\r\n          </div>\r\n          <div *ngSwitchDefault>\r\n            <ng-template kendoGridFilterCellTemplate let-filter let-column=\"column\">\r\n              <kendo-grid-string-filter-cell [column]=\"column\" [filter]=\"filter\" operator=\"contains\">\r\n                <kendo-filter-contains-operator></kendo-filter-contains-operator>\r\n                <kendo-filter-eq-operator></kendo-filter-eq-operator>\r\n                <kendo-filter-neq-operator></kendo-filter-neq-operator>\r\n                <kendo-filter-startswith-operator></kendo-filter-startswith-operator>\r\n                <kendo-filter-endswith-operator></kendo-filter-endswith-operator>\r\n                <kendo-filter-isnull-operator></kendo-filter-isnull-operator>\r\n                <kendo-filter-isnotnull-operator></kendo-filter-isnotnull-operator>\r\n              </kendo-grid-string-filter-cell>\r\n            </ng-template>\r\n          </div>\r\n        </div>\r\n        <!-- Grid Edit Template -->\r\n        <ng-template kendoGridEditTemplate *ngIf=\"data.EnableGridCommand \" let-dataItem=\"dataItem\" let-column=\"col\" let-formGroup=\"formGroup\" let-isNew=\"isNew\">\r\n          <div [ngSwitch]=\"col.fieldType\">\r\n            <div *ngSwitchCase=\"'number'\">\r\n              <kendo-numerictextbox #cellAnchor [formControl]=\"formGroup.get(col.field)\"></kendo-numerictextbox>\r\n              <kendo-popup [anchor]=\"cellAnchor.numericInput\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !(isNew && formGroup.get(col.field).untouched)\"\r\n                           popupClass=\"k-widget k-tooltip k-tooltip-validation k-invalid-msg\"\r\n                           style=\"padding-left: 2px; opacity: 0.5;\">\r\n                <span class=\"k-icon k-i-warning\"></span>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.required\">\r\n                  {{ col.Name }} required.\r\n                </ion-label>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.pattern\">\r\n                  {{ col.ValidatorMessage ? col.ValidatorMessage : \"Please check the input value.\" }}\r\n                </ion-label>\r\n              </kendo-popup>\r\n            </div>\r\n            <div *ngSwitchDefault>\r\n              <kendo-textbox #cellAnchor [formControl]=\"formGroup.get(col.field)\"></kendo-textbox>\r\n              <kendo-popup [anchor]=\"cellAnchor.input\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !(isNew && formGroup.get(col.field).untouched)\"\r\n                           popupClass=\"k-widget k-tooltip k-tooltip-validation k-invalid-msg\"\r\n                           style=\"padding-left: 2px; opacity: 0.5;\">\r\n                <span class=\"k-icon k-i-warning\"></span>\r\n                <!--<ion-label style=\"padding-top: 1px; padding-left: 3px;\">{{ col.Name }} is required.</ion-label>-->\r\n\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.required\">\r\n                  {{ col.Name }} required.\r\n                </ion-label>\r\n                <ion-label style=\"padding-top: 1px; padding-left: 3px;\"\r\n                           *ngIf=\"formGroup.get(col.field).invalid && !formGroup.get(col.field).untouched && formGroup.get(col.field).errors?.pattern\">\r\n                  {{ col.ValidatorMessage ? col.ValidatorMessage : \"Please check the input value.\" }}\r\n                </ion-label>\r\n              </kendo-popup>\r\n            </div>\r\n          </div>\r\n        </ng-template>\r\n        <ng-template kendoGridCellTemplate let-dataItem let-rowIndex=\"rowIndex\">\r\n          <div style=\"margin: 1px 0;\" *ngIf=\"!col.clickableIcons && col.isEditableInGrid !== true\" [ngSwitch]=\"col.fieldType\"\r\n               [ngClass]=\"getClass(dataItem, col)\">\r\n            <span *ngSwitchCase=\"'zdate'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'ztime'\">\r\n              {{ dataItem[col.field] | date: 'HH:mm' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zshortdate'\">\r\n              {{ dataItem[col.field] | date: 'MMM yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zdatetime'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuidatetime'\">\r\n              {{ dataItem[col.field] | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'number'\">\r\n              {{ dataItem[col.field] | number }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'currency'\">\r\n              {{ dataItem[col.field] | number: getFormat(col, '1.2-2') }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'znumeric'\">\r\n              {{ dataItem[col.field] | number: getFormat(col) }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'url'\" style=\"color: blue; cursor: pointer; text-decoration:underline;\">\r\n              {{ dataItem[col.field] }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ dataItem[col.field]}}\r\n            </span>\r\n          </div>\r\n          <!-- <span *ngIf=\"!!col.navigateTo\" (click)=\"onNavigateTo($event, col, dataItem, dataItem[col.field])\">\r\n      <ion-button color=\"light\" size=\"small\">\r\n      {{ col.ClickableIcons }}\r\n      <ion-icon slot= \"end\" name=\"arrow-forward\"></ion-icon>\r\n      </ion-button>\r\n      </span> -->\r\n          <div style=\"margin: 5px 0;\" *ngIf=\"col.isEditableInGrid === true && inlineEditedFormGroups\" [ngSwitch]=\"col.fieldType\" [formGroup]=\"inlineEditedFormGroups\"\r\n               [ngClass]=\"getClass(dataItem, col)\">\r\n            <span *ngSwitchCase=\"'number'\">\r\n              <input type=\"number\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" />\r\n            </span>\r\n            <span *ngSwitchCase=\"'checkbox'\">\r\n              <ion-checkbox [disabled]=\"(!!col.ReadOnly ? col.ReadOnly : false)\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" color=\"primary\" (ionChange)=\"inCellCheckBoxOnChange($event, rowIndex, col)\"></ion-checkbox>\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuiselectmultiple'\">\r\n              <app-zselectmultiple style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-zselectmultiple>\r\n            </span>\r\n            <span *ngSwitchCase=\"'textarea'\">\r\n              <app-ztextarea style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-ztextarea>\r\n            </span>\r\n            <span *ngSwitchCase=\"['zuidatetime','zdate', 'ztime','zdatetime','zshortdate'].includes(col.fieldType) ? col.fieldType : ''\">\r\n              <app-zdatetime style=\"width: 100%;\" [data]=\"getInlineField(col.Value)\" [group]=\"group\" [form]=\"getInlineForm(rowIndex)\"></app-zdatetime>\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              <input style=\"width: 100%;\" type=\"text\" [formControl]=\"this.getFormControl(rowIndex, col.field)\" />\r\n            </span>\r\n          </div>\r\n          <span style=\"margin-top: 10px;\" *ngFor=\"let icon of col.clickableIcons\">\r\n            <span [ngClass]=\"icon.Class ? icon.Class : ''\" *ngIf=\"!!icon && (!!dataItem.WFS_StatusCode && !!icon)\r\n              ? dataItem.WFS_StatusCode !== icon.WFS_StatusCode\r\n              : true;\r\n            else disabledButton\" (click)=\"onBtnClick($event, icon, dataItem, dataItem[col.field])\">\r\n              {{icon.Name || dataItem[col.field]}} <fa-icon [icon]=\"icon.Icon\" style=\"padding: 4px 6px;\">\r\n              </fa-icon>\r\n            </span>\r\n            <ng-template #disabledButton>\r\n            </ng-template>\r\n          </span>\r\n          <!-- <strong>{{ dataItem[col.field] }}</strong> -->\r\n          <!-- <span class=\"{{dataItem.Discontinued ? 'discontinued' : 'active'}}\">\r\n        {{dataItem.Discontinued ? \"discontinued\" : \"active\"}}\r\n      </span> -->\r\n        </ng-template>\r\n        <ng-template kendoGridFooterTemplate let-column let-columnIndex=\"columnIndex\" *ngIf=\"data.EnableAggregate\">\r\n          <div style=\"margin: 5px 0;\" [ngSwitch]=\"col.fieldType\">\r\n            {{col.aggregateType}}\r\n            <span *ngSwitchCase=\"'zdate'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'ztime'\">\r\n              {{ col.aggregateValue | date: 'HH:mm' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zshortdate'\">\r\n              {{ col.aggregateValue | date: 'MMM yyyy' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zdatetime'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'zuidatetime'\">\r\n              {{ col.aggregateValue | date: 'dd/MM/yyyy hh:mm:ss aa' }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'number'\">\r\n              {{ col.aggregateValue | number }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'currency'\">\r\n              {{ col.aggregateValue | number: getFormat(col, '1.2.2') }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'znumeric'\">\r\n              {{ col.aggregateValue | number: getFormat(col) }}\r\n            </span>\r\n            <span *ngSwitchCase=\"'url'\" style=\"color: blue; cursor: pointer; text-decoration:underline;\">\r\n              {{ col.aggregateValue }}\r\n            </span>\r\n            <span *ngSwitchDefault>\r\n              {{ col.aggregateValue }}\r\n            </span>\r\n          </div>\r\n        </ng-template>\r\n      </kendo-grid-column>\r\n      <kendo-grid-command-column *ngIf=\"data.EnableGridCommand\" width=\"180\" [columnMenu]=\"false\">\r\n        <ng-template kendoGridCellTemplate let-isNew=\"isNew\">\r\n          <button kendoGridSaveCommand>\r\n            {{ isNew ? 'Save' : 'Update' }}\r\n          </button>\r\n          <button kendoGridCancelCommand [primary]=\"true\">\r\n            {{ isNew ? 'Discard changes' : 'Cancel' }}\r\n          </button>\r\n          <button kendoGridEditCommand>\r\n            {{ \"Edit\" }}\r\n          </button>\r\n          <button kendoGridRemoveCommand>\r\n            {{ \"Remove\" }}\r\n          </button>\r\n        </ng-template>\r\n      </kendo-grid-command-column>\r\n      <kendo-grid-excel fileName=\"Export.xlsx\" [fetchData]=\"allResults\"></kendo-grid-excel>\r\n    </kendo-grid>\r\n    <div *ngIf=\"isLoading\" class=\"k-i-loading\"></div>\r\n  </div>\r\n</div>\r\n"]}