@universis/ngx-tables 0.6.0

package/esm2015/lib/components/advanced-table-modal/advanced-table-modal-base.component.js

@@ -0,0 +1,379 @@
+import * as tslib_1 from "tslib";
+import { Component, ElementRef, Input, ViewChild } from '@angular/core';
+import { RouterModalOkCancel } from '@universis/common/routing';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AdvancedTableComponent } from '../advanced-table/advanced-table.component';
+import { AngularDataContext } from '@themost/angular';
+import { AdvancedFilterValueProvider } from './../advanced-table/advanced-filter-value-provider.service';
+import { DatePipe } from '@angular/common';
+import { TemplatePipe } from '@universis/common';
+// important: export this const due to AOT compilation errors
+// see more https://angular.io/guide/aot-metadata-errors#only-initialized-variables
+export const AdvancedTableModalBaseTemplate = `
+<div>
+    <!-- search -->
+    <div class="row mt-3">
+      <div class="col-12 col-lg-3">
+        <div class="input-group mb-3">
+          <input spellcheck="false" type="text"
+                 (keyup)="onKeyUp($event)" [(ngModel)]="searchText"
+                 class="form-control bg-gray-100 border-0"
+                 placeholder="{{'Tables.SearchPlaceholder' | translate}}" aria-label="Search" aria-describedby="basic-addon2">
+          <div class="input-group-append">
+            <button class="btn btn-default bg-gray-100 border-0" type="button">
+              <i class="fa fa-search text-secondary"></i>
+            </button>
+          </div>
+        </div>
+      </div>
+      <div #emptyTable class="d-none">
+        <div>
+          <div class="mt-4">
+            <div class="icon-circle bg-gray-300 border-gray-100"></div>
+          </div>
+          <div class="mt-4">
+            <h4 class="font-3xl text-dark" [translate]="'Tables.EmptyTableTitle'"></h4>
+            <p class="font-lg text-dark" [translate]="'Tables.EmptyTableMessage'"></p>
+          </div>
+
+        </div>
+      </div>
+      <div class="col-12 col-lg-5">
+        <div class="btn-toolbar">
+          <button class="btn btn-gray-100">
+            <i class="fa fa-sliders-h pr-2 text-secondary" aria-hidden="true"></i>{{'Tables.Filters' | translate}}
+          </button>
+          <div #dropdownFilter class="dropdown ml-3" dropdown>
+            <button class="btn btn-gray-100 dropdown-toggle"
+                    type="button" id="dropdownDefaultFilters"
+                    data-toggle="dropdown" dropdownToggle>
+              {{ this.defaultFilter.name | translate }}
+            </button>
+            <div class="dropdown-menu" aria-labelledby="dropdownDefaultFilters" *dropdownMenu>
+              <a class="dropdown-item" *ngFor="let filter of defaultFilters" (click)="advancedSearch(filter.filter ? filter : '')">
+                {{ filter.name | translate }}
+              </a>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="col text-lg-right mt-3 mt-lg-0">
+        <button [disabled]="true" class="btn rounded-pill btn-outline-theme">
+          <span class="pr-2 font-lg">+</span><span [translate]="'Tables.AddItem'"></span>
+        </button>
+      </div>
+    </div>
+    <div class="row">
+      <div class="col-12" [ngClass]="{ 'component-loading': loading}">
+        <app-advanced-table #advancedTable (init)="onTableInit($event)"
+                            (load)="onDataLoad($event)"
+                            [selectable]="true"
+                            [multipleSelect]="true"
+                            [scrollX]="false" [scrollY]="320"
+                            [pageLength]="pageLength"
+                            [scrollable]="false" [showFooter]="false"
+                            [showActions]="false" [lengthMenu]="lengthMenu"
+                            [config]="tableConfig" [configSrc]="tableConfigSrc"></app-advanced-table>
+      </div>
+    </div>
+    <div class="row mt-3 table-custom-pager">
+      <div class="col-12 d-flex" *ngIf="recordsTotal">
+        <div class="mt-2 ml-auto mr-3 text-secondary" [translate]="'Tables.RecordsPerPage'"></div>
+        <div #dropdownLength class="dropdown mr-3" dropdown>
+          <button class="btn btn-gray-100 dropdown-toggle"
+                  type="button" id="dropdownPageSize" data-toggle="dropdown"
+                  dropdownToggle>
+            {{pageLength}}
+          </button>
+          <div class="dropdown-menu" aria-labelledby="dropdownPageSize" *dropdownMenu>
+            <button (click)="setLength(item)"
+                    class="dropdown-item dropdown-item-theme"
+                    type="button" *ngFor="let item of lengthMenu">{{item}}</button>
+          </div>
+        </div>
+        <div class="mt-2 mr-2" [translate]="'Tables.PageInfo'" [translateParams]="pageInfo"></div>
+        <button [disabled]="pageInfo && pageInfo.page === 0" class="btn text-nowrap" (click)="firstPage()">
+          <i class="fa fa-chevron-left text-color-theme"></i>
+          <i class="fa fa-chevron-left text-color-theme"></i>
+        </button>
+        <button [disabled]="pageInfo && pageInfo.page===0" class="btn" (click)="previousPage()">
+          <i class="fa fa-chevron-left text-color-theme"></i>
+        </button>
+        <button [disabled]="pageInfo && pageInfo.page===pageInfo.pages-1" class="btn" (click)="nextPage()">
+          <i class="fa fa-chevron-right text-color-theme"></i>
+        </button>
+        <button [disabled]="pageInfo && pageInfo.page===pageInfo.pages-1" class="btn text-nowrap" (click)="lastPage()">
+          <i class="fa fa-chevron-right text-color-theme"></i>
+          <i class="fa fa-chevron-right text-color-theme"></i>
+        </button>
+      </div>
+    </div>
+  </div>
+`;
+export class AdvancedTableModalBaseComponent extends RouterModalOkCancel {
+    constructor(_router, _activatedRoute, _context, advancedFilterValueProvider, datePipe) {
+        super(_router, _activatedRoute);
+        this._context = _context;
+        this.advancedFilterValueProvider = advancedFilterValueProvider;
+        this.datePipe = datePipe;
+        this.pageLength = 25;
+        this.lengthMenu = [5, 10, 25, 50, 100];
+        this.recordsTotal = 0;
+        this.loading = false;
+        this.recordsFiltered = 0;
+        this.defaultFilters = [AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER];
+        this.defaultFilter = AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER;
+        this.pageInfo = {
+            serverSide: true
+        };
+        this.modalClass = 'modal-xl modal-table';
+        this._template = new TemplatePipe();
+    }
+    ngAfterViewInit() {
+        //
+    }
+    _getInputs(componentType) {
+        const props = componentType.__prop__metadata__;
+        const inputs = [];
+        if (props == null) {
+            return inputs;
+        }
+        Object.keys(props).forEach(prop => {
+            const member = props[prop][0];
+            if (member.ngMetadataName === 'Input') {
+                inputs.push(prop);
+            }
+        });
+        return inputs.sort();
+    }
+    hasInputs() {
+        return [];
+    }
+    ngOnInit() {
+        this.okButtonText = 'Tables.Apply';
+        this.cancelButtonText = 'Tables.Cancel';
+        // get route data
+        this.subscription = this.activatedRoute.data.subscribe(data => {
+            // set modal title if any
+            if (data.title) {
+                this.modalTitle = data.title;
+            }
+            if (data.config) {
+                this.tableConfig = data.config;
+            }
+            if (this.tableConfig) {
+                this.defaultFilters.push.apply(this.defaultFilters, this.tableConfig.searches);
+            }
+            // important: use hasInputs due to AOT compilation. Metadata properties cannot be used (e.g. @Input())
+            // because there are empty during runtime
+            // so we need to define manually input properties that are going to be bind through this process
+            // bind all inputs
+            const inputs = this.hasInputs();
+            inputs.forEach(input => {
+                if (Object.prototype.hasOwnProperty.call(data, input)) {
+                    this[input] = data[input];
+                }
+            });
+            this.configChangesSubscription = this.advancedTable.configChanges.subscribe((config) => {
+                if (this.tableConfig) {
+                    // reset default filter
+                    this.defaultFilter = AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER;
+                    // init filter
+                    this.defaultFilters = [AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER];
+                    // add extra filters
+                    this.defaultFilters.push.apply(this.defaultFilters, this.tableConfig.searches);
+                }
+            });
+        });
+    }
+    cancel() {
+        return this.close();
+    }
+    ok() {
+        return this.close();
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    onDataLoad(data) {
+        this.recordsTotal = data.recordsTotal;
+        this.recordsFiltered = data.recordsFiltered;
+        // get first page info (because page is not going to be fired for first page)
+        if (data.recordsTotal > 0 && this.pageInfo.recordsTotal === 0) {
+            this.pageInfo.recordsTotal = data.recordsTotal;
+        }
+        const self = this;
+    }
+    previousPage() {
+        // go to next page
+        // noinspection TypeScriptValidateJSTypes
+        this.advancedTable.dataTable.page('previous').draw('page');
+    }
+    nextPage() {
+        // go to next page
+        // noinspection TypeScriptValidateJSTypes
+        this.advancedTable.dataTable.page('next').draw('page');
+    }
+    onTableInit(dataTable) {
+        const self = this;
+        // get initial page info
+        const initialPageInfo = dataTable.page.info();
+        initialPageInfo.start += 1;
+        self.pageInfo = initialPageInfo;
+        // change emptyTableMessage
+        dataTable.context[0].oLanguage.sEmptyTable = this.emptyTable.nativeElement.innerHTML;
+        // bind page change event
+        dataTable.on('page.dt', function () {
+            const pageInfo = dataTable.page.info();
+            pageInfo.start += 1;
+            self.pageInfo = pageInfo;
+        });
+        // bind draw change event
+        dataTable.on('draw.dt', function () {
+            // for future use
+            self.loading = false;
+            const pageInfo = dataTable.page.info();
+            pageInfo.start += 1;
+            self.pageInfo = pageInfo;
+        });
+    }
+    firstPage() {
+        // go to first page
+        // noinspection TypeScriptValidateJSTypes
+        this.advancedTable.dataTable.page('first').draw('page');
+    }
+    lastPage() {
+        // go to last page
+        // noinspection TypeScriptValidateJSTypes
+        this.advancedTable.dataTable.page('last').draw('page');
+    }
+    setLength(value) {
+        this.pageLength = value;
+        this.advancedTable.dataTable.page.len(value).draw();
+    }
+    onKeyUp(event) {
+        if (event.code === 'Enter') {
+            // loading
+            this.loading = true;
+            this.advancedTable.search(event.target.value);
+        }
+    }
+    /**
+     *
+     * Reads the modal table and returns a list of filters to use in the table
+     * query.
+     *
+     * @param tableConfig {object} The table configuration from json file
+     * @param defaultFilterValues {object} A list of default filters
+     * @param {object} searchItem The searchItem to use
+     *
+     */
+    getFilters(tableConfig, defaultFilterValues = {}, searchItem) {
+        // Do nothing in absence of configuration.
+        if (!tableConfig || !Array.isArray(tableConfig.criteria)) {
+            console.warn('No table configuration available', this.tableConfig);
+            return [];
+        }
+        const matchedCriterion = tableConfig.criteria.find(criterion => Object.prototype.hasOwnProperty.call(searchItem.filter, criterion.name));
+        if (!matchedCriterion) {
+            return [];
+        }
+        const criterionSafeName = matchedCriterion.name !== null
+            ? matchedCriterion.name.toString()
+            : '';
+        let applicableFilter;
+        // Raw dates should be transformed to a specific format
+        if (criterionSafeName.includes('GMT')) {
+            const newDate = this.datePipe.transform(criterionSafeName, 'MM/dd/yyyy');
+            applicableFilter = this._template.transform(matchedCriterion.filter, {
+                value: newDate
+            });
+        }
+        else if (criterionSafeName !== 'undefined') {
+            applicableFilter = (this._template.transform(matchedCriterion.filter, Object.assign({
+                value: matchedCriterion.filter
+            }, defaultFilterValues)));
+        }
+        else {
+            applicableFilter = '';
+        }
+        return [applicableFilter];
+    }
+    /**
+     *
+     * Runs a filter against the modal table
+     *
+     * @param {object} filter The filter to use in the search
+     *
+     */
+    advancedSearch(filter) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // Do nothing in absence of configuration.
+            if (!this.tableConfig && !Array.isArray(this.tableConfig.criteria)) {
+                console.warn('No table configuration available', this.tableConfig);
+                return;
+            }
+            // An advanced table has some filters by default
+            let defaultFilterValues;
+            try {
+                defaultFilterValues = yield this.advancedFilterValueProvider.getValues();
+            }
+            catch (err) {
+                defaultFilterValues = {};
+            }
+            const expressions = [];
+            let predefinedCriteria;
+            if (filter) {
+                this.defaultFilter = filter;
+                predefinedCriteria = this.getFilters(this.tableConfig, defaultFilterValues, filter);
+            }
+            else {
+                // Empty a falsy filter resets the results
+                this.defaultFilter = AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER;
+            }
+            // search filter is applied separately, there is no need to add here.
+            expressions.push(predefinedCriteria);
+            const query = this._context.model(this.advancedTable.config.model).asQueryable();
+            query.setParam('filter', expressions.join(' and ')).prepare();
+            this.advancedTable.query = query;
+            this.advancedTable.fetch();
+        });
+    }
+}
+AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER = {
+    name: 'Tables.All',
+    filter: null
+};
+AdvancedTableModalBaseComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'app-advanced-table-modal',
+                template: AdvancedTableModalBaseTemplate,
+                styles: [`
+
+    `]
+            }] }
+];
+/** @nocollapse */
+AdvancedTableModalBaseComponent.ctorParameters = () => [
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: AngularDataContext },
+    { type: AdvancedFilterValueProvider },
+    { type: DatePipe }
+];
+AdvancedTableModalBaseComponent.propDecorators = {
+    advancedTable: [{ type: ViewChild, args: ['advancedTable',] }],
+    emptyTable: [{ type: ViewChild, args: ['emptyTable',] }],
+    dropdownFilter: [{ type: ViewChild, args: ['dropdownFilter',] }],
+    dropdownLength: [{ type: ViewChild, args: ['dropdownLength',] }],
+    tableConfig: [{ type: Input, args: ['tableConfig',] }],
+    tableConfigSrc: [{ type: Input, args: ['tableConfigSrc',] }],
+    pageLength: [{ type: Input, args: ['pageLength',] }],
+    searchText: [{ type: Input, args: ['searchText',] }],
+    lengthMenu: [{ type: Input, args: ['lengthMenu',] }],
+    defaultFilter: [{ type: Input, args: ['defaultFilter',] }]
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced-table-modal-base.component.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/components/advanced-table-modal/advanced-table-modal-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ComponentDecorator, Directive, ElementRef, Input, OnDestroy, OnInit, ViewChild, ViewEncapsulation, AfterViewInit} from '@angular/core';\nimport {RouterModalOkCancel} from '@universis/common/routing';\nimport {ActivatedRoute, Router} from '@angular/router';\nimport {TableConfiguration} from '../advanced-table/advanced-table.interfaces';\nimport {Subscription} from 'rxjs';\nimport {AdvancedTableComponent, AdvancedTableDataResult} from '../advanced-table/advanced-table.component';\nimport { AngularDataContext } from '@themost/angular';\nimport { AdvancedFilterValueProvider } from './../advanced-table/advanced-filter-value-provider.service';\nimport { DatePipe } from '@angular/common';\nimport { RequestTypesService } from '@universis/common';\nimport { TemplatePipe } from '@universis/common';\nimport { BsModalRef } from 'ngx-bootstrap/modal';\nexport declare interface PageInfo {\n  page: number;\n  pages: number;\n  start: number;\n  end: number;\n  length: number;\n  recordsTotal: number;\n  recordsDisplay: number;\n  serverSide?: boolean;\n}\n\n// important: export this const due to AOT compilation errors\n// see more https://angular.io/guide/aot-metadata-errors#only-initialized-variables\nexport const AdvancedTableModalBaseTemplate = `\n<div>\n    <!-- search -->\n    <div class=\"row mt-3\">\n      <div class=\"col-12 col-lg-3\">\n        <div class=\"input-group mb-3\">\n          <input spellcheck=\"false\" type=\"text\"\n                 (keyup)=\"onKeyUp($event)\" [(ngModel)]=\"searchText\"\n                 class=\"form-control bg-gray-100 border-0\"\n                 placeholder=\"{{'Tables.SearchPlaceholder' | translate}}\" aria-label=\"Search\" aria-describedby=\"basic-addon2\">\n          <div class=\"input-group-append\">\n            <button class=\"btn btn-default bg-gray-100 border-0\" type=\"button\">\n              <i class=\"fa fa-search text-secondary\"></i>\n            </button>\n          </div>\n        </div>\n      </div>\n      <div #emptyTable class=\"d-none\">\n        <div>\n          <div class=\"mt-4\">\n            <div class=\"icon-circle bg-gray-300 border-gray-100\"></div>\n          </div>\n          <div class=\"mt-4\">\n            <h4 class=\"font-3xl text-dark\" [translate]=\"'Tables.EmptyTableTitle'\"></h4>\n            <p class=\"font-lg text-dark\" [translate]=\"'Tables.EmptyTableMessage'\"></p>\n          </div>\n\n        </div>\n      </div>\n      <div class=\"col-12 col-lg-5\">\n        <div class=\"btn-toolbar\">\n          <button class=\"btn btn-gray-100\">\n            <i class=\"fa fa-sliders-h pr-2 text-secondary\" aria-hidden=\"true\"></i>{{'Tables.Filters' | translate}}\n          </button>\n          <div #dropdownFilter class=\"dropdown ml-3\" dropdown>\n            <button class=\"btn btn-gray-100 dropdown-toggle\"\n                    type=\"button\" id=\"dropdownDefaultFilters\"\n                    data-toggle=\"dropdown\" dropdownToggle>\n              {{ this.defaultFilter.name | translate }}\n            </button>\n            <div class=\"dropdown-menu\" aria-labelledby=\"dropdownDefaultFilters\" *dropdownMenu>\n              <a class=\"dropdown-item\" *ngFor=\"let filter of defaultFilters\" (click)=\"advancedSearch(filter.filter ? filter : '')\">\n                {{ filter.name | translate }}\n              </a>\n            </div>\n          </div>\n        </div>\n      </div>\n      <div class=\"col text-lg-right mt-3 mt-lg-0\">\n        <button [disabled]=\"true\" class=\"btn rounded-pill btn-outline-theme\">\n          <span class=\"pr-2 font-lg\">+</span><span [translate]=\"'Tables.AddItem'\"></span>\n        </button>\n      </div>\n    </div>\n    <div class=\"row\">\n      <div class=\"col-12\" [ngClass]=\"{ 'component-loading': loading}\">\n        <app-advanced-table #advancedTable (init)=\"onTableInit($event)\"\n                            (load)=\"onDataLoad($event)\"\n                            [selectable]=\"true\"\n                            [multipleSelect]=\"true\"\n                            [scrollX]=\"false\" [scrollY]=\"320\"\n                            [pageLength]=\"pageLength\"\n                            [scrollable]=\"false\" [showFooter]=\"false\"\n                            [showActions]=\"false\" [lengthMenu]=\"lengthMenu\"\n                            [config]=\"tableConfig\" [configSrc]=\"tableConfigSrc\"></app-advanced-table>\n      </div>\n    </div>\n    <div class=\"row mt-3 table-custom-pager\">\n      <div class=\"col-12 d-flex\" *ngIf=\"recordsTotal\">\n        <div class=\"mt-2 ml-auto mr-3 text-secondary\" [translate]=\"'Tables.RecordsPerPage'\"></div>\n        <div #dropdownLength class=\"dropdown mr-3\" dropdown>\n          <button class=\"btn btn-gray-100 dropdown-toggle\"\n                  type=\"button\" id=\"dropdownPageSize\" data-toggle=\"dropdown\"\n                  dropdownToggle>\n            {{pageLength}}\n          </button>\n          <div class=\"dropdown-menu\" aria-labelledby=\"dropdownPageSize\" *dropdownMenu>\n            <button (click)=\"setLength(item)\"\n                    class=\"dropdown-item dropdown-item-theme\"\n                    type=\"button\" *ngFor=\"let item of lengthMenu\">{{item}}</button>\n          </div>\n        </div>\n        <div class=\"mt-2 mr-2\" [translate]=\"'Tables.PageInfo'\" [translateParams]=\"pageInfo\"></div>\n        <button [disabled]=\"pageInfo && pageInfo.page === 0\" class=\"btn text-nowrap\" (click)=\"firstPage()\">\n          <i class=\"fa fa-chevron-left text-color-theme\"></i>\n          <i class=\"fa fa-chevron-left text-color-theme\"></i>\n        </button>\n        <button [disabled]=\"pageInfo && pageInfo.page===0\" class=\"btn\" (click)=\"previousPage()\">\n          <i class=\"fa fa-chevron-left text-color-theme\"></i>\n        </button>\n        <button [disabled]=\"pageInfo && pageInfo.page===pageInfo.pages-1\" class=\"btn\" (click)=\"nextPage()\">\n          <i class=\"fa fa-chevron-right text-color-theme\"></i>\n        </button>\n        <button [disabled]=\"pageInfo && pageInfo.page===pageInfo.pages-1\" class=\"btn text-nowrap\" (click)=\"lastPage()\">\n          <i class=\"fa fa-chevron-right text-color-theme\"></i>\n          <i class=\"fa fa-chevron-right text-color-theme\"></i>\n        </button>\n      </div>\n    </div>\n  </div>\n`;\n\n/**\n *\n * A specific value for a criterion\n *\n */\ninterface SearchItem {\n  filter: any;\n  name: string;\n}\n\n@Component({\n  selector: 'app-advanced-table-modal',\n  template: AdvancedTableModalBaseTemplate,\n  styles: [\n    `\n\n    `\n  ]\n})\nexport class AdvancedTableModalBaseComponent extends RouterModalOkCancel implements OnInit, OnDestroy, AfterViewInit {\n  ngAfterViewInit(): void {\n    //\n  }\n\n  private static readonly DEFAULT_ALL_FILTER = {\n    name: 'Tables.All',\n    filter: null\n  };\n\n  @ViewChild('advancedTable') advancedTable: AdvancedTableComponent;\n  @ViewChild('emptyTable') emptyTable: ElementRef;\n  @ViewChild('dropdownFilter') dropdownFilter: ElementRef;\n  @ViewChild('dropdownLength') dropdownLength: ElementRef;\n  @Input('tableConfig') tableConfig: TableConfiguration;\n  @Input('tableConfigSrc') tableConfigSrc: string;\n  @Input('pageLength') pageLength = 25;\n  @Input('searchText') searchText: string;\n  @Input('lengthMenu') lengthMenu: Array<number> = [5, 10, 25, 50, 100];\n  private subscription: Subscription;\n  public recordsTotal = 0;\n  public loading = false;\n  public recordsFiltered = 0;\n  public defaultFilters: Array<any> = [AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER];\n  @Input('defaultFilter') defaultFilter = AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER;\n  public pageInfo = <PageInfo> {\n    serverSide: true\n  };\n  private _template: TemplatePipe;\n  configChangesSubscription: Subscription;\n\n  constructor(\n    _router: Router,\n    _activatedRoute: ActivatedRoute,\n    protected _context: AngularDataContext,\n    protected advancedFilterValueProvider: AdvancedFilterValueProvider,\n    protected datePipe: DatePipe\n  ) {\n    super(_router, _activatedRoute);\n    this.modalClass = 'modal-xl modal-table';\n    this._template = new TemplatePipe();\n  }\n\n  private _getInputs(componentType): Array<any> {\n    const props = componentType.__prop__metadata__;\n    const inputs = [];\n    if (props == null) {\n      return inputs;\n    }\n    Object.keys(props).forEach (prop => {\n      const member = props[prop][0];\n      if (member.ngMetadataName === 'Input') {\n        inputs.push(prop);\n      }\n    });\n    return inputs.sort();\n  }\n\n  public hasInputs(): Array<string> {\n    return [];\n  }\n\n  ngOnInit() {\n\n    this.okButtonText = 'Tables.Apply';\n    this.cancelButtonText = 'Tables.Cancel';\n\n    // get route data\n    this.subscription = this.activatedRoute.data.subscribe( data => {\n      // set modal title if any\n      if (data.title) {\n        this.modalTitle = data.title;\n      }\n\n      if (data.config) {\n        this.tableConfig = data.config;\n      }\n      if (this.tableConfig) {\n        this.defaultFilters.push.apply(this.defaultFilters, this.tableConfig.searches);\n      }\n      // important: use hasInputs due to AOT compilation. Metadata properties cannot be used (e.g. @Input())\n      // because there are empty during runtime\n      // so we need to define manually input properties that are going to be bind through this process\n      // bind all inputs\n      const inputs = this.hasInputs();\n      inputs.forEach( input => {\n        if (Object.prototype.hasOwnProperty.call(data, input)) {\n          this[input] = data[input];\n        }\n      });\n\n      this.configChangesSubscription = this.advancedTable.configChanges.subscribe((config) => {\n        if (this.tableConfig) {\n          // reset default filter\n          this.defaultFilter = AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER;\n          // init filter\n          this.defaultFilters = [AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER];\n          // add extra filters\n          this.defaultFilters.push.apply(this.defaultFilters, this.tableConfig.searches);\n        }\n      });\n\n    });\n  }\n\n  cancel(): Promise<any> {\n    return this.close();\n  }\n\n  ok(): Promise<any> {\n    return this.close();\n  }\n\n  ngOnDestroy(): void {\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n    }\n  }\n\n  onDataLoad(data: AdvancedTableDataResult) {\n    this.recordsTotal = data.recordsTotal;\n    this.recordsFiltered = data.recordsFiltered;\n    // get first page info (because page is not going to be fired for first page)\n    if (data.recordsTotal > 0 && this.pageInfo.recordsTotal === 0) {\n      this.pageInfo.recordsTotal = data.recordsTotal;\n    }\n    const self = this;\n  }\n\n  previousPage() {\n    // go to next page\n    // noinspection TypeScriptValidateJSTypes\n    this.advancedTable.dataTable.page('previous').draw('page');\n  }\n\n  nextPage() {\n    // go to next page\n    // noinspection TypeScriptValidateJSTypes\n    this.advancedTable.dataTable.page('next').draw('page');\n  }\n\n  onTableInit(dataTable: any) {\n    const self = this;\n    // get initial page info\n    const initialPageInfo = <PageInfo>dataTable.page.info();\n    initialPageInfo.start += 1;\n    self.pageInfo = initialPageInfo;\n    // change emptyTableMessage\n    dataTable.context[0].oLanguage.sEmptyTable = this.emptyTable.nativeElement.innerHTML;\n    // bind page change event\n    dataTable.on( 'page.dt', function() {\n      const pageInfo = <PageInfo>dataTable.page.info();\n      pageInfo.start += 1;\n      self.pageInfo = pageInfo;\n    });\n    // bind draw change event\n    dataTable.on( 'draw.dt', function() {\n      // for future use\n      self.loading = false;\n      const pageInfo = <PageInfo>dataTable.page.info();\n      pageInfo.start += 1;\n      self.pageInfo = pageInfo;\n    });\n  }\n\n  firstPage() {\n    // go to first page\n    // noinspection TypeScriptValidateJSTypes\n    this.advancedTable.dataTable.page('first').draw('page');\n  }\n\n  lastPage() {\n    // go to last page\n    // noinspection TypeScriptValidateJSTypes\n    this.advancedTable.dataTable.page('last').draw('page');\n  }\n\n    setLength(value: number) {\n      this.pageLength = value;\n      this.advancedTable.dataTable.page.len(value).draw();\n    }\n\n  onKeyUp(event: KeyboardEvent) {\n    if (event.code === 'Enter') {\n      // loading\n      this.loading = true;\n      this.advancedTable.search((<HTMLInputElement>event.target).value);\n    }\n  }\n\n  /**\n   *\n   * Reads the modal table and returns a list of filters to use in the table\n   * query.\n   *\n   * @param tableConfig {object} The table configuration from json file\n   * @param defaultFilterValues {object} A list of default filters\n   * @param {object} searchItem The searchItem to use\n   *\n   */\n  getFilters(\n    tableConfig: any,\n    defaultFilterValues = {},\n    searchItem: any\n  ): Array<string> {\n    // Do nothing in absence of configuration.\n    if (!tableConfig || !Array.isArray(tableConfig.criteria)) {\n      console.warn('No table configuration available', this.tableConfig);\n      return [];\n    }\n\n    const matchedCriterion = tableConfig.criteria.find(criterion =>\n      Object.prototype.hasOwnProperty.call(searchItem.filter, criterion.name)\n    );\n\n    if (!matchedCriterion) {\n      return [];\n    }\n\n    const criterionSafeName = matchedCriterion.name !== null\n      ? matchedCriterion.name.toString()\n      : '';\n\n    let applicableFilter: string;\n\n    // Raw dates should be transformed to a specific format\n    if (criterionSafeName.includes('GMT')) {\n      const newDate = this.datePipe.transform(criterionSafeName, 'MM/dd/yyyy');\n      applicableFilter = this._template.transform(matchedCriterion.filter, {\n        value: newDate\n      });\n\n    } else if (criterionSafeName !== 'undefined') {\n      applicableFilter = (this._template.transform(matchedCriterion.filter, Object.assign({\n        value: matchedCriterion.filter\n      }, defaultFilterValues)));\n    } else {\n      applicableFilter = '';\n    }\n\n    return [applicableFilter];\n  }\n\n  /**\n   *\n   * Runs a filter against the modal table\n   *\n   * @param {object} filter The filter to use in the search\n   *\n   */\n  async advancedSearch(filter): Promise<any> {\n    // Do nothing in absence of configuration.\n    if (!this.tableConfig && !Array.isArray(this.tableConfig.criteria)) {\n      console.warn('No table configuration available', this.tableConfig);\n      return;\n    }\n\n    // An advanced table has some filters by default\n    let defaultFilterValues;\n    try {\n      defaultFilterValues = await this.advancedFilterValueProvider.getValues();\n    } catch (err) {\n      defaultFilterValues = {};\n    }\n\n    const expressions =  [];\n    let predefinedCriteria;\n    if (filter) {\n      this.defaultFilter = filter;\n      predefinedCriteria = this.getFilters(\n        this.tableConfig,\n        defaultFilterValues,\n        filter\n      );\n    } else {\n      // Empty a falsy filter resets the results\n      this.defaultFilter = AdvancedTableModalBaseComponent.DEFAULT_ALL_FILTER;\n    }\n\n    // search filter is applied separately, there is no need to add here.\n    expressions.push(predefinedCriteria);\n\n    const query = this._context.model(this.advancedTable.config.model).asQueryable();\n    query.setParam('filter', expressions.join(' and ')).prepare();\n    this.advancedTable.query = query;\n    this.advancedTable.fetch();\n  }\n}\n\n"]}

package/esm2015/lib/components/table-simple-header/table-simple-header.component.js

@@ -0,0 +1,52 @@
+import { Component, Input } from '@angular/core';
+import { AdvancedTableComponent } from '../advanced-table/advanced-table.component';
+;
+export class SimpleHeaderToolsComponent {
+}
+SimpleHeaderToolsComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'table-simple-header-tools',
+                template: `
+  <ng-content></ng-content>
+  `
+            }] }
+];
+export class TableSimpleHeaderComponent {
+    constructor() { }
+    ngOnChanges(changes) {
+        if (changes.table) {
+            if (changes.table.currentValue == null) {
+                if (this.dataLoadSubscription) {
+                    this.dataLoadSubscription.unsubscribe();
+                    return;
+                }
+            }
+            if (changes.table.currentValue != changes.table.previousValue) {
+                this.dataLoadSubscription = changes.table.currentValue.load.subscribe((data) => {
+                    this.recordsTotal = data.recordsTotal;
+                });
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.dataLoadSubscription) {
+            this.dataLoadSubscription.unsubscribe();
+        }
+    }
+    ngOnInit() {
+        //
+    }
+}
+TableSimpleHeaderComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'app-table-simple-header',
+                template: "<div class=\"row\">\n   <div class=\"col-auto mt-4\">\n     <div class=\"font-xl text-secondary\" *ngIf=\"recordsTotal === 0\">\n        <span>&nbsp;</span>\n      </div>\n      <div class=\"font-xl text-secondary\" *ngIf=\"recordsTotal > 1\">\n        <span>{{recordsTotal}}</span><span>&nbsp;</span><span [translate]=\"'Tables.Items'\"></span>\n      </div>\n      <div class=\"font-xl text-secondary\" *ngIf=\"recordsTotal === 1\">\n        <span>{{recordsTotal}}</span><span>&nbsp;</span><span [translate]=\"'Tables.Item'\"></span>\n      </div>\n    </div>\n    <div class=\"pull-right ml-auto mr-3 mt-3\">\n      <div class=\"font-lg btn-toolbar mt-2\">\n        <ng-content select=\"table-simple-header-tools\"></ng-content>\n      </div>\n    </div>\n</div>\n\n"
+            }] }
+];
+/** @nocollapse */
+TableSimpleHeaderComponent.ctorParameters = () => [];
+TableSimpleHeaderComponent.propDecorators = {
+    table: [{ type: Input }]
+};
+
+//# sourceMappingURL=data:application/json;base64,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