@rosoftlab/ionic 1.0.0-alpha-0

package/esm2022/lib/components/rsl-ionic-data-table/rsl-ionic-data-table.component.mjs

@@ -0,0 +1,292 @@
+import { Location } from '@angular/common';
+import { Component, ElementRef, Injector, Input, TemplateRef, ViewChild } from '@angular/core';
+import { ActivatedRoute, NavigationStart, Router, UrlSegment } from '@angular/router';
+import { NavController } from '@ionic/angular';
+import { TranslateService } from '@ngx-translate/core';
+import { ColumnMode, SelectionType } from '@swimlane/ngx-datatable';
+import * as jsonLogic from 'json-logic-js/logic.js';
+import { IonicDialogService } from '../../ionic-dialog.service';
+import { RslIonicModuleModule } from '../../rsl-ionic-module.module';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "@angular/common";
+import * as i4 from "@ionic/angular";
+import * as i5 from "../../ionic-dialog.service";
+import * as i6 from "@swimlane/ngx-datatable";
+export class RslIonicDataTableComponent {
+    constructor(router, route, translate, location, injector, navCtrl, dialogService, el) {
+        this.router = router;
+        this.route = route;
+        this.translate = translate;
+        this.location = location;
+        this.injector = injector;
+        this.navCtrl = navCtrl;
+        this.dialogService = dialogService;
+        this.el = el;
+        this.data = [];
+        this.pageIndex = 1;
+        this.pageSize = 30;
+        this.columns = [];
+        this.allColumns = [];
+        this.ColumnMode = ColumnMode;
+        this.SelectionType = SelectionType;
+        this.headerHeight = 50;
+        this.rowHeight = 50;
+    }
+    ngOnInit() {
+        this.setValueFromSnapshot(this, this.route.snapshot, 'showSerach', false);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'searchFields', null);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'customInclude', null);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'defaultSort', null);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'defaultSortDirection', '');
+        this.setValueFromSnapshot(this, this.route.snapshot, 'deletePropertyName', 'name');
+        this.setValueFromSnapshot(this, this.route.snapshot, 'defaultFilter', null);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'showHeader', true);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'deleteDisableRule', null);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'hasAdd', true);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'canDelete', true);
+        this.setValueFromSnapshot(this, this.route.snapshot, 'canEdit', true);
+        if (!this.modelService) {
+            const SERVICE_TOKEN = this.route.snapshot.data['requiredService'];
+            this.modelService = this.injector.get(SERVICE_TOKEN);
+        }
+        this.model = this.modelService.newModel();
+        this.title = this.model.modelConfig.formTitle;
+        this.getListLayout();
+        const currentUrlSegments = this.router.url.split('/').map(segment => new UrlSegment(segment, {}));
+        this.basePath = currentUrlSegments.map(segment => segment.path).join('/');
+        this.router.events.subscribe(event => {
+            if (event instanceof NavigationStart) {
+                // Navigation to another page is about to occur
+                this.data = [];
+                this.pageIndex = 1;
+                // Perform actions or update component as needed
+            }
+        });
+        // this.isLoading = true;
+        // this.onScroll(0);
+    }
+    setValueFromSnapshot(component, snapshot, key, defaultValue) {
+        if (component[key] === undefined) {
+            let dataFromSnapshot = snapshot.data[key];
+            if (dataFromSnapshot === null || dataFromSnapshot === undefined) {
+                dataFromSnapshot = snapshot.params[key];
+            }
+            component[key] = dataFromSnapshot !== undefined ? dataFromSnapshot : defaultValue;
+        }
+    }
+    onScroll(offsetY) {
+        if (offsetY) {
+            if (this.oldOffsetY !== offsetY) {
+                this.oldOffsetY = offsetY;
+                const viewHeight = this.el.nativeElement.getBoundingClientRect().height - this.headerHeight;
+                if (!this.isLoading && offsetY + viewHeight >= this.data.length * this.rowHeight) {
+                    // total number of results to load
+                    let limit = this.pageSize;
+                    // check if we haven't fetched any results yet
+                    if (this.data.length === 0) {
+                        // calculate the number of rows that fit within viewport
+                        const pageSize = Math.ceil(viewHeight / this.rowHeight);
+                        // change the limit to pageSize such that we fill the first page entirely
+                        // (otherwise, we won't be able to scroll past it)
+                        limit = Math.max(pageSize, this.pageSize);
+                    }
+                    // this.pageIndex
+                    this.pageSize = limit;
+                    this.loadData();
+                    // this.loadPage(limit);
+                }
+            }
+        }
+    }
+    async ionViewWillEnter() {
+        this.data = [];
+        this.loadData();
+    }
+    async handleChange(event) {
+        this.filterValue = event.target.value.toLowerCase();
+        this.data = [];
+        this.pageIndex = 1;
+        this.loadData();
+    }
+    loadData(event = null) {
+        const filters = [];
+        let sorts = '';
+        this.isLoading = true;
+        if (this.defaultSort) {
+            if (this.defaultSortDirection === 'desc') {
+                sorts = '-' + this.defaultSort;
+            }
+            else {
+                sorts = this.defaultSort;
+            }
+        }
+        if (this.showSerach) {
+            if (this.filterValue) {
+                const y = '(' + this.searchFields.replace(',', '|') + ')';
+                filters.push(y + '@=*' + this.filterValue);
+            }
+        }
+        if (this.defaultFilter) {
+            filters.push(this.defaultFilter);
+        }
+        setTimeout(() => {
+            const filtersValue = filters.join(', ');
+            this.modelService.getAll(this.pageIndex, this.pageSize, sorts, filtersValue, this.customInclude).subscribe((response) => {
+                if (this.pageIndex !== response.getMeta().meta.count) {
+                    this.pageIndex++;
+                }
+                else {
+                    if (event)
+                        event.target.disabled = true;
+                }
+                // if (this.filterValue)
+                //   this.data = response.getModels();
+                // else
+                const rows = [...this.data, ...response.getModels()];
+                this.data = rows;
+                // this.data = this.data.concat();
+                if (event)
+                    event.target.complete();
+                this.isLoading = false;
+            });
+        }, 700);
+    }
+    async handleRefresh(event) {
+        this.pageIndex = 1;
+        this.data = [];
+        this.loadData();
+        event.target.complete();
+    }
+    onAdd() {
+        console.log(this.basePath);
+        this.router.navigate([this.basePath + '/add']);
+        // this.navCtrl.navigateForward(this.basePath + '/add');
+    }
+    editModel(model) {
+        if (this.canEdit)
+            this.router.navigate([this.basePath + '/edit/', model.id]);
+        // this.navCtrl.navigateForward(this.basePath + '/edit/' + model.id);
+    }
+    getListLayout() {
+        if (!this.model) {
+            this.model = this.modelService.newModel();
+        }
+        this.allColumns = [];
+        this.columns = [];
+        this.allColumns = Reflect.getMetadata('IonicDataTableLayout', this.model).map((item) => {
+            if (!item.isTranslated) {
+                item.name = this.translate.instant(item.name);
+                item.isTranslated = true;
+            }
+            return item;
+        });
+        this.allColumns.sort((a, b) => a.order - b.order);
+        if (this.canDelete || this.canEdit) {
+            this.allColumns.push({
+                cellTemplate: this.actionsTmpl,
+                name: '',
+                cellClass: 'actions-cell',
+                draggable: false,
+                sortable: false,
+                visible: true
+                // width: 100,
+                // maxWidth: 100,
+                // minWidth: 100
+            });
+        }
+        this.columns = this.allColumns.filter((item) => item.visible);
+        // Sort the columns array by the order property
+    }
+    deleteModel(model) {
+        const msg = 'Do you want to delete ' + model[this.deletePropertyName] + '?';
+        this.dialogService.confirm(msg).then((value) => {
+            if (value.data) {
+                this.modelService.delete(model.id).subscribe(() => {
+                    const tempData = [];
+                    // this.selectedObject.emit(null);
+                    this.data.map((item) => {
+                        if (item.id !== model.id) {
+                            tempData.push(item);
+                        }
+                    });
+                    this.data = tempData;
+                });
+            }
+        });
+    }
+    deleteEnabled(model) {
+        if (this.canDelete) {
+            if (this.deleteDisableRule) {
+                return this.evaluateRule(this.deleteDisableRule, model);
+            }
+            else {
+                return true;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    evaluateRule(rules, model) {
+        let result = true;
+        rules.forEach(rule => {
+            let jsonRule;
+            if (typeof rule.rule === 'string') {
+                jsonRule = JSON.parse(rule.rule);
+            }
+            else {
+                jsonRule = rule.rule;
+            }
+            if (rule.parameters) {
+                const data = '{' + rule.parameters.map((item) => {
+                    return '"' + item + '":"' + model[item] + '"';
+                }).join(',') + '}';
+                result = jsonLogic.apply(jsonRule, JSON.parse(data));
+            }
+            else {
+                result = jsonLogic.apply(jsonRule);
+            }
+        });
+        return result;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: RslIonicDataTableComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.TranslateService }, { token: i3.Location }, { token: i0.Injector }, { token: i4.NavController }, { token: i5.IonicDialogService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.1", type: RslIonicDataTableComponent, isStandalone: true, selector: "app-rsl-ionic-data-table", inputs: { showSerach: "showSerach", searchFields: "searchFields", customInclude: "customInclude", defaultSort: "defaultSort", defaultSortDirection: "defaultSortDirection", deletePropertyName: "deletePropertyName", defaultFilter: "defaultFilter", showHeader: "showHeader", deleteDisableRule: "deleteDisableRule", hasAdd: "hasAdd", canDelete: "canDelete", canEdit: "canEdit", model: "model", modelService: "modelService" }, viewQueries: [{ propertyName: "actionsTmpl", first: true, predicate: ["actionsTmpl"], descendants: true, static: true }], ngImport: i0, template: "<ion-header *ngIf=\"showHeader\">\n  <ion-toolbar>\n    <ion-buttons slot=\"start\">\n      <ion-menu-button></ion-menu-button>\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n    <ng-container [ngTemplateOutlet]=\"header\"></ng-container>\n  </ion-toolbar>\n  <ng-container [ngTemplateOutlet]=\"search\"></ng-container>\n</ion-header>\n\n<ion-content [fullscreen]=\"true\">\n\n  <ion-refresher slot=\"fixed\" (ionRefresh)=\"handleRefresh($event)\">\n    <ion-refresher-content></ion-refresher-content>\n  </ion-refresher>\n\n  <ngx-datatable class=\"material fullscreen rls-server-scrolling\" style=\"top: 115px\" [rows]=\"data\" [columns]=\"columns\"\n    [columnMode]=\"ColumnMode.standard\" [headerHeight]=\"headerHeight\" [rowHeight]=\"rowHeight\" [scrollbarV]=\"true\"\n    [loadingIndicator]=\"isLoading\" [scrollbarH]=\"true\" (scroll)=\"onScroll($event.offsetY)\"\n   >\n  </ngx-datatable>\n  \n  <ng-template #actionsTmpl let-row=\"row\" let-value=\"value\">\n    <ion-button  fill=\"clear\" *ngIf=\"canEdit\" (click)='editModel(row)'>\n      <ion-icon slot=\"icon-only\" name=\"create\" (click)='editModel(row)'></ion-icon>\n    </ion-button>\n    <ion-button fill=\"clear\" *ngIf=\"deleteEnabled(row)\" (click)='deleteModel(row)'>\n      <ion-icon color=\"danger\" slot=\"icon-only\" name=\"trash\" (click)='deleteModel(row)'></ion-icon>\n    </ion-button>\n  </ng-template>\n\n</ion-content>\n\n<ng-template #header>\n  <ion-title class=\"ion-text-center\">{{title}}</ion-title>\n  <ion-button slot=\"end\" (click)=\"onAdd()\" fill=\"clear\" *ngIf=\"hasAdd\">\n    <ion-icon size=\"large\" name=\"add\"></ion-icon>\n  </ion-button>\n</ng-template>\n\n<ng-template #search>\n  <ion-toolbar *ngIf=\"showSerach\">\n    <ion-searchbar [debounce]=\"1000\" (ionChange)=\"handleChange($event)\"></ion-searchbar>\n  </ion-toolbar>\n</ng-template>", styles: [".rls-server-scrolling{height:calc(100vh - 110px)}::ng-deep .progress-linear{position:fixed!important;bottom:0}::ng-deep .actions-cell{padding:5px 0 0 .9rem!important}::ng-deep .align-right{text-align:right!important}\n"], dependencies: [{ kind: "ngmodule", type: RslIonicModuleModule }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i3.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i4.IonBackButton, selector: "ion-back-button", inputs: ["color", "defaultHref", "disabled", "icon", "mode", "routerAnimation", "text", "type"] }, { kind: "component", type: i4.IonButton, selector: "ion-button", inputs: ["buttonType", "color", "disabled", "download", "expand", "fill", "form", "href", "mode", "rel", "routerAnimation", "routerDirection", "shape", "size", "strong", "target", "type"] }, { kind: "component", type: i4.IonButtons, selector: "ion-buttons", inputs: ["collapse"] }, { kind: "component", type: i4.IonContent, selector: "ion-content", inputs: ["color", "forceOverscroll", "fullscreen", "scrollEvents", "scrollX", "scrollY"] }, { kind: "component", type: i4.IonHeader, selector: "ion-header", inputs: ["collapse", "mode", "translucent"] }, { kind: "component", type: i4.IonIcon, selector: "ion-icon", inputs: ["color", "flipRtl", "icon", "ios", "lazy", "md", "mode", "name", "sanitize", "size", "src"] }, { kind: "component", type: i4.IonMenuButton, selector: "ion-menu-button", inputs: ["autoHide", "color", "disabled", "menu", "mode", "type"] }, { kind: "component", type: i4.IonRefresher, selector: "ion-refresher", inputs: ["closeDuration", "disabled", "pullFactor", "pullMax", "pullMin", "snapbackDuration"] }, { kind: "component", type: i4.IonRefresherContent, selector: "ion-refresher-content", inputs: ["pullingIcon", "pullingText", "refreshingSpinner", "refreshingText"] }, { kind: "component", type: i4.IonSearchbar, selector: "ion-searchbar", inputs: ["animated", "autocomplete", "autocorrect", "cancelButtonIcon", "cancelButtonText", "clearIcon", "color", "debounce", "disabled", "enterkeyhint", "inputmode", "mode", "placeholder", "searchIcon", "showCancelButton", "showClearButton", "spellcheck", "type", "value"] }, { kind: "component", type: i4.IonTitle, selector: "ion-title", inputs: ["color", "size"] }, { kind: "component", type: i4.IonToolbar, selector: "ion-toolbar", inputs: ["color", "mode"] }, { kind: "directive", type: i4.TextValueAccessor, selector: "ion-input:not([type=number]),ion-textarea,ion-searchbar" }, { kind: "directive", type: i4.IonBackButtonDelegate, selector: "ion-back-button", inputs: ["defaultHref", "routerAnimation"] }, { kind: "component", type: i6.DatatableComponent, selector: "ngx-datatable", inputs: ["targetMarkerTemplate", "rows", "groupRowsBy", "groupedRows", "columns", "selected", "scrollbarV", "scrollbarH", "rowHeight", "columnMode", "headerHeight", "footerHeight", "externalPaging", "externalSorting", "limit", "count", "offset", "loadingIndicator", "selectionType", "reorderable", "swapColumns", "sortType", "sorts", "cssClasses", "messages", "rowClass", "selectCheck", "displayCheck", "groupExpansionDefault", "trackByProp", "selectAllRowsOnPage", "virtualization", "treeFromRelation", "treeToRelation", "summaryRow", "summaryHeight", "summaryPosition", "rowIdentity"], outputs: ["scroll", "activate", "select", "sort", "page", "reorder", "resize", "tableContextmenu", "treeAction"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: RslIonicDataTableComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'app-rsl-ionic-data-table', imports: [RslIonicModuleModule], template: "<ion-header *ngIf=\"showHeader\">\n  <ion-toolbar>\n    <ion-buttons slot=\"start\">\n      <ion-menu-button></ion-menu-button>\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n    <ng-container [ngTemplateOutlet]=\"header\"></ng-container>\n  </ion-toolbar>\n  <ng-container [ngTemplateOutlet]=\"search\"></ng-container>\n</ion-header>\n\n<ion-content [fullscreen]=\"true\">\n\n  <ion-refresher slot=\"fixed\" (ionRefresh)=\"handleRefresh($event)\">\n    <ion-refresher-content></ion-refresher-content>\n  </ion-refresher>\n\n  <ngx-datatable class=\"material fullscreen rls-server-scrolling\" style=\"top: 115px\" [rows]=\"data\" [columns]=\"columns\"\n    [columnMode]=\"ColumnMode.standard\" [headerHeight]=\"headerHeight\" [rowHeight]=\"rowHeight\" [scrollbarV]=\"true\"\n    [loadingIndicator]=\"isLoading\" [scrollbarH]=\"true\" (scroll)=\"onScroll($event.offsetY)\"\n   >\n  </ngx-datatable>\n  \n  <ng-template #actionsTmpl let-row=\"row\" let-value=\"value\">\n    <ion-button  fill=\"clear\" *ngIf=\"canEdit\" (click)='editModel(row)'>\n      <ion-icon slot=\"icon-only\" name=\"create\" (click)='editModel(row)'></ion-icon>\n    </ion-button>\n    <ion-button fill=\"clear\" *ngIf=\"deleteEnabled(row)\" (click)='deleteModel(row)'>\n      <ion-icon color=\"danger\" slot=\"icon-only\" name=\"trash\" (click)='deleteModel(row)'></ion-icon>\n    </ion-button>\n  </ng-template>\n\n</ion-content>\n\n<ng-template #header>\n  <ion-title class=\"ion-text-center\">{{title}}</ion-title>\n  <ion-button slot=\"end\" (click)=\"onAdd()\" fill=\"clear\" *ngIf=\"hasAdd\">\n    <ion-icon size=\"large\" name=\"add\"></ion-icon>\n  </ion-button>\n</ng-template>\n\n<ng-template #search>\n  <ion-toolbar *ngIf=\"showSerach\">\n    <ion-searchbar [debounce]=\"1000\" (ionChange)=\"handleChange($event)\"></ion-searchbar>\n  </ion-toolbar>\n</ng-template>", styles: [".rls-server-scrolling{height:calc(100vh - 110px)}::ng-deep .progress-linear{position:fixed!important;bottom:0}::ng-deep .actions-cell{padding:5px 0 0 .9rem!important}::ng-deep .align-right{text-align:right!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.TranslateService }, { type: i3.Location }, { type: i0.Injector }, { type: i4.NavController }, { type: i5.IonicDialogService }, { type: i0.ElementRef }]; }, propDecorators: { actionsTmpl: [{
+                type: ViewChild,
+                args: ['actionsTmpl', { static: true }]
+            }], showSerach: [{
+                type: Input
+            }], searchFields: [{
+                type: Input
+            }], customInclude: [{
+                type: Input
+            }], defaultSort: [{
+                type: Input
+            }], defaultSortDirection: [{
+                type: Input
+            }], deletePropertyName: [{
+                type: Input
+            }], defaultFilter: [{
+                type: Input
+            }], showHeader: [{
+                type: Input
+            }], deleteDisableRule: [{
+                type: Input
+            }], hasAdd: [{
+                type: Input
+            }], canDelete: [{
+                type: Input
+            }], canEdit: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], modelService: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rsl-ionic-data-table.component.js","sourceRoot":"","sources":["../../../../../../../projects/rosoftlab/ionic/src/lib/components/rsl-ionic-data-table/rsl-ionic-data-table.component.ts","../../../../../../../projects/rosoftlab/ionic/src/lib/components/rsl-ionic-data-table/rsl-ionic-data-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Location } from '@angular/common';\nimport { Component, ElementRef, Injector, Input, OnInit, TemplateRef, ViewChild } from '@angular/core';\nimport { ActivatedRoute, ActivatedRouteSnapshot, NavigationStart, Router, UrlSegment } from '@angular/router';\nimport { NavController } from '@ionic/angular';\nimport { TranslateService } from '@ngx-translate/core';\nimport { BaseQueryData, BaseService, Rule } from '@rosoftlab/core';\nimport { BaseModelFormly } from '@rosoftlab/formly';\nimport { ColumnMode, SelectionType } from '@swimlane/ngx-datatable';\nimport * as jsonLogic from 'json-logic-js/logic.js';\nimport { IonicDataTableLayoutConfig } from '../../decorators/ionic-datatable-layout';\nimport { IonicDialogService } from '../../ionic-dialog.service';\nimport { RslIonicModuleModule } from '../../rsl-ionic-module.module';\nexport declare type SortDirection = 'asc' | 'desc' | '';\n@Component({\n  standalone: true,\n  selector: 'app-rsl-ionic-data-table',\n  templateUrl: './rsl-ionic-data-table.component.html',\n  styleUrls: ['./rsl-ionic-data-table.component.scss'],\n  imports: [RslIonicModuleModule],\n})\nexport class RslIonicDataTableComponent<T extends BaseModelFormly, U extends BaseService<T>> implements OnInit {\n  @ViewChild('actionsTmpl', { static: true }) actionsTmpl: TemplateRef<any>;\n  public title: string;\n  @Input() showSerach: boolean;\n  @Input() searchFields: string;\n  @Input() customInclude: string;\n  @Input() defaultSort: string;\n  @Input() defaultSortDirection: SortDirection;\n  @Input() deletePropertyName: string;\n  @Input() defaultFilter: string;\n  @Input() showHeader: boolean;\n  @Input() deleteDisableRule: Rule[];\n  @Input() hasAdd: boolean;\n  @Input() canDelete: boolean;\n  @Input() canEdit: boolean;\n\n  @Input() model: T;\n  @Input() modelService: U\n\n  data: any[] = [];\n  pageIndex: number = 1;\n  pageSize: number = 30\n\n  basePath: string;\n\n  columns = [];\n  allColumns = [];\n  ColumnMode = ColumnMode;\n  SelectionType = SelectionType;\n\n  readonly headerHeight = 50;\n  readonly rowHeight = 50;\n  isLoading: boolean;\n  filterValue: string;\n  oldOffsetY: number;\n  constructor(\n    public router: Router,\n    public route: ActivatedRoute,\n    public translate: TranslateService,\n    public location: Location,\n    private injector: Injector,\n    private navCtrl: NavController,\n    public dialogService: IonicDialogService,\n    private el: ElementRef) {\n\n  }\n  ngOnInit() {\n    this.setValueFromSnapshot(this, this.route.snapshot, 'showSerach', false);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'searchFields', null);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'customInclude', null);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'defaultSort', null);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'defaultSortDirection', '');\n    this.setValueFromSnapshot(this, this.route.snapshot, 'deletePropertyName', 'name');\n    this.setValueFromSnapshot(this, this.route.snapshot, 'defaultFilter', null);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'showHeader', true);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'deleteDisableRule', null);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'hasAdd', true);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'canDelete', true);\n    this.setValueFromSnapshot(this, this.route.snapshot, 'canEdit', true);\n    if (!this.modelService) {\n      const SERVICE_TOKEN = this.route.snapshot.data['requiredService'];\n      this.modelService = this.injector.get<U>(<any>SERVICE_TOKEN);\n    }\n    this.model = this.modelService.newModel()\n    this.title = this.model.modelConfig.formTitle\n    this.getListLayout()\n\n    const currentUrlSegments: UrlSegment[] = this.router.url.split('/').map(segment => new UrlSegment(segment, {}));\n    this.basePath = currentUrlSegments.map(segment => segment.path).join('/');\n    this.router.events.subscribe(event => {\n      if (event instanceof NavigationStart) {\n        // Navigation to another page is about to occur\n        this.data = [];\n        this.pageIndex = 1\n        // Perform actions or update component as needed\n      }\n    });\n    // this.isLoading = true;\n    // this.onScroll(0);\n  }\n  setValueFromSnapshot<T>(component: any, snapshot: ActivatedRouteSnapshot, key: string, defaultValue: T): void {\n    if (component[key] === undefined) {\n      let dataFromSnapshot = snapshot.data[key];\n      if (dataFromSnapshot === null || dataFromSnapshot === undefined) {\n        dataFromSnapshot = snapshot.params[key];\n      }\n      component[key] = dataFromSnapshot !== undefined ? dataFromSnapshot : defaultValue;\n    }\n  }\n  onScroll(offsetY: number) {\n    if (offsetY) {\n      if (this.oldOffsetY !== offsetY) {\n        this.oldOffsetY = offsetY;\n        const viewHeight = this.el.nativeElement.getBoundingClientRect().height - this.headerHeight;\n        if (!this.isLoading && offsetY + viewHeight >= this.data.length * this.rowHeight) {\n          // total number of results to load\n          let limit = this.pageSize;\n\n          // check if we haven't fetched any results yet\n          if (this.data.length === 0) {\n            // calculate the number of rows that fit within viewport\n            const pageSize = Math.ceil(viewHeight / this.rowHeight);\n\n            // change the limit to pageSize such that we fill the first page entirely\n            // (otherwise, we won't be able to scroll past it)\n            limit = Math.max(pageSize, this.pageSize);\n          }\n          // this.pageIndex\n          this.pageSize = limit\n          this.loadData();\n          // this.loadPage(limit);\n        }\n      }\n    }\n  }\n  async ionViewWillEnter() {\n    this.data = [];\n    this.loadData();\n  }\n  async handleChange(event) {\n    this.filterValue = event.target.value.toLowerCase();\n    this.data = [];\n    this.pageIndex = 1\n    this.loadData();\n  }\n  loadData(event = null) {\n    const filters = [];\n    let sorts = '';\n    this.isLoading = true;\n    if (this.defaultSort) {\n      if (this.defaultSortDirection === 'desc') {\n        sorts = '-' + this.defaultSort;\n      } else {\n        sorts = this.defaultSort;\n      }\n    }\n    if (this.showSerach) {\n      if (this.filterValue) {\n        const y = '(' + this.searchFields.replace(',', '|') + ')';\n        filters.push(y + '@=*' + this.filterValue);\n      }\n    }\n    if (this.defaultFilter) {\n      filters.push(this.defaultFilter)\n    }\n    setTimeout(() => {\n      const filtersValue = filters.join(', ');\n      this.modelService.getAll(this.pageIndex, this.pageSize, sorts, filtersValue, this.customInclude).subscribe(\n        (response: BaseQueryData<T>) => {\n          if (this.pageIndex !== response.getMeta().meta.count) {\n            this.pageIndex++\n          } else {\n            if (event) event.target.disabled = true;\n          }\n          // if (this.filterValue)\n          //   this.data = response.getModels();\n          // else\n          const rows = [...this.data, ...response.getModels()];\n          this.data = rows;\n          // this.data = this.data.concat();\n\n          if (event) event.target.complete();\n          this.isLoading = false;\n        })\n    }, 700);\n  }\n  async handleRefresh(event) {\n    this.pageIndex = 1\n    this.data = [];\n    this.loadData();\n    event.target.complete();\n  }\n  onAdd() {\n    console.log(this.basePath)\n    this.router.navigate([this.basePath + '/add'])\n    // this.navCtrl.navigateForward(this.basePath + '/add');\n  }\n  editModel(model: BaseModelFormly) {\n    if (this.canEdit)\n      this.router.navigate([this.basePath + '/edit/', model.id]);\n    // this.navCtrl.navigateForward(this.basePath + '/edit/' + model.id);\n  }\n  getListLayout() {\n    if (!this.model) {\n      this.model = this.modelService.newModel();    \n    }\n    this.allColumns=[];\n    this.columns=[];\n    this.allColumns = Reflect.getMetadata('IonicDataTableLayout', this.model).map((item: IonicDataTableLayoutConfig) => {\n      if (!item.isTranslated) {\n        item.name = this.translate.instant(item.name);\n        item.isTranslated = true\n      }\n      return item;\n    });\n\n    this.allColumns.sort((a, b) => a.order - b.order);\n\n    if (this.canDelete || this.canEdit) {\n      this.allColumns.push({\n        cellTemplate: this.actionsTmpl,\n        name: '',\n        cellClass: 'actions-cell',\n        draggable: false,\n        sortable: false,\n        visible: true\n        // width: 100,\n        // maxWidth: 100,\n        // minWidth: 100\n      })\n    }\n    this.columns = this.allColumns.filter((item: IonicDataTableLayoutConfig) => item.visible);\n    // Sort the columns array by the order property\n\n  }\n  deleteModel(model) {\n    const msg = 'Do you want to delete ' + model[this.deletePropertyName] + '?';\n    this.dialogService.confirm(msg).then(\n      (value: any) => {\n        if (value.data) {\n          this.modelService.delete(model.id).subscribe(() => {\n            const tempData = [];\n            // this.selectedObject.emit(null);\n            this.data.map((item) => {\n              if (item.id !== model.id) {\n                tempData.push(item);\n              }\n            });\n            this.data = tempData;\n          });\n        }\n      }\n    )\n  }\n\n  deleteEnabled(model: T) {\n    if (this.canDelete) {\n      if (this.deleteDisableRule) {\n        return this.evaluateRule(this.deleteDisableRule, model);\n      } else {\n        return true;\n      }\n    } else {\n      return false;\n    }\n  }\n  private evaluateRule(rules: Rule[], model: T): boolean {\n    let result = true;\n    rules.forEach(rule => {\n      let jsonRule: any;\n      if (typeof rule.rule === 'string') {\n        jsonRule = JSON.parse(rule.rule);\n      } else {\n        jsonRule = rule.rule;\n      }\n      if (rule.parameters) {\n        const data = '{' + rule.parameters.map((item: string) => {\n          return '\"' + item + '\":\"' + model[item] + '\"';\n        }).join(',') + '}';\n        result = jsonLogic.apply(jsonRule, JSON.parse(data));\n      } else {\n        result = jsonLogic.apply(jsonRule);\n      }\n    });\n    return result;\n  }\n\n\n}\n","<ion-header *ngIf=\"showHeader\">\n  <ion-toolbar>\n    <ion-buttons slot=\"start\">\n      <ion-menu-button></ion-menu-button>\n      <ion-back-button></ion-back-button>\n    </ion-buttons>\n    <ng-container [ngTemplateOutlet]=\"header\"></ng-container>\n  </ion-toolbar>\n  <ng-container [ngTemplateOutlet]=\"search\"></ng-container>\n</ion-header>\n\n<ion-content [fullscreen]=\"true\">\n\n  <ion-refresher slot=\"fixed\" (ionRefresh)=\"handleRefresh($event)\">\n    <ion-refresher-content></ion-refresher-content>\n  </ion-refresher>\n\n  <ngx-datatable class=\"material fullscreen rls-server-scrolling\" style=\"top: 115px\" [rows]=\"data\" [columns]=\"columns\"\n    [columnMode]=\"ColumnMode.standard\" [headerHeight]=\"headerHeight\" [rowHeight]=\"rowHeight\" [scrollbarV]=\"true\"\n    [loadingIndicator]=\"isLoading\" [scrollbarH]=\"true\" (scroll)=\"onScroll($event.offsetY)\"\n   >\n  </ngx-datatable>\n  \n  <ng-template #actionsTmpl let-row=\"row\" let-value=\"value\">\n    <ion-button  fill=\"clear\" *ngIf=\"canEdit\" (click)='editModel(row)'>\n      <ion-icon slot=\"icon-only\" name=\"create\" (click)='editModel(row)'></ion-icon>\n    </ion-button>\n    <ion-button fill=\"clear\" *ngIf=\"deleteEnabled(row)\" (click)='deleteModel(row)'>\n      <ion-icon color=\"danger\" slot=\"icon-only\" name=\"trash\" (click)='deleteModel(row)'></ion-icon>\n    </ion-button>\n  </ng-template>\n\n</ion-content>\n\n<ng-template #header>\n  <ion-title class=\"ion-text-center\">{{title}}</ion-title>\n  <ion-button slot=\"end\" (click)=\"onAdd()\" fill=\"clear\" *ngIf=\"hasAdd\">\n    <ion-icon size=\"large\" name=\"add\"></ion-icon>\n  </ion-button>\n</ng-template>\n\n<ng-template #search>\n  <ion-toolbar *ngIf=\"showSerach\">\n    <ion-searchbar [debounce]=\"1000\" (ionChange)=\"handleChange($event)\"></ion-searchbar>\n  </ion-toolbar>\n</ng-template>"]}