@universis/ngx-tables 0.6.0

package/esm2015/lib/directives/advanced-table-editor.directive.js

@@ -0,0 +1,157 @@
+import { Directive, Output, EventEmitter } from '@angular/core';
+import { AdvancedTableComponent } from '../components/advanced-table/advanced-table.component';
+export class AdvancedTableNotNullError extends Error {
+    constructor() {
+        super('Advanced table component cannot be empty at this context.');
+    }
+}
+export class AdvancedTableEditorDirective {
+    constructor(table) {
+        this.table = table;
+        this.dirty = false;
+        this.dirtyChange = new EventEmitter(false);
+        //
+    }
+    /**
+     * Add rows to table and mark them as added rows
+     */
+    add(...addItems) {
+        if (this.table == null) {
+            throw new AdvancedTableNotNullError();
+        }
+        // decorate items
+        const key = this.table.config.columns[0].property || this.table.config.columns[0].name;
+        for (let index = 0; index < addItems.length; index++) {
+            const element = addItems[index];
+            let tr = this.table.dataTable.rows(':has(input[data-id="' + element[key] + '"])').nodes().to$();
+            if (tr.hasClass('removed')) {
+                tr.toggleClass('removed text-gray-400 text-decoration-line-through');
+            }
+            else {
+                this.table.dataTable.rows.add([element]);
+                tr = this.table.dataTable.rows(':has(input[data-id="' + element[key] + '"])').nodes().to$();
+                tr.toggleClass('added font-weight-bold text-success');
+            }
+        }
+        this.table.dataTable.draw();
+        // find removed
+        const removedLength = this.table.dataTable.rows('.removed')[0].length;
+        // find added
+        const addedLength = this.table.dataTable.rows('.added')[0].length;
+        // and emit event
+        const items = this.table.dataTable.rows().data();
+        this.table.load.emit({
+            data: items,
+            recordsFiltered: items.length - removedLength,
+            recordsTotal: items.length - removedLength
+        });
+        this.dirty = (removedLength > 0 || addedLength > 0);
+        this.dirtyChange.emit(this.dirty);
+    }
+    /**
+     * Marks rows as removed rows
+     */
+    remove(...removeItems) {
+        if (this.table == null) {
+            throw new AdvancedTableNotNullError();
+        }
+        // get key
+        const key = this.table.config.columns[0].property || this.table.config.columns[0].name;
+        // loop items
+        for (let index = 0; index < removeItems.length; index++) {
+            const element = removeItems[index];
+            const tr = this.table.dataTable.rows(':has(input[data-id="' + element[key] + '"])').nodes().to$();
+            // if row is marked as added
+            if (tr.hasClass('added')) {
+                // remove this dirty row
+                this.table.dataTable.rows(tr).remove();
+            }
+            else {
+                // otherwise unmarked row
+                tr.toggleClass('removed text-gray-400 text-decoration-line-through');
+            }
+            // check if item is selected
+            const selectedIndex = this.table.selected.findIndex((item) => {
+                return item[key] === element[key];
+            });
+            // and remove it from selected collection
+            if (selectedIndex >= 0) {
+                this.table.selected.splice(selectedIndex, 1);
+            }
+        }
+        // re-draw table
+        this.table.dataTable.draw();
+        // get number of table items
+        const items = this.table.dataTable.rows().data();
+        // get number of removed items
+        const removedLength = this.table.dataTable.rows('.removed')[0].length;
+        // get number of added items
+        const addedLength = this.table.dataTable.rows('.added')[0].length;
+        // refresh
+        this.table.load.emit({
+            data: items,
+            recordsFiltered: items.length - removedLength,
+            recordsTotal: items.length - removedLength
+        });
+        this.dirty = (removedLength > 0 || addedLength > 0);
+        this.dirtyChange.emit(this.dirty);
+    }
+    set(items) {
+        if (this.table == null) {
+            throw new AdvancedTableNotNullError();
+        }
+        // clear rows
+        this.table.selected = [];
+        this.table.dataTable.clear();
+        // set items
+        this.table.dataTable.rows.add(items).draw();
+        this.table.load.emit({
+            data: items,
+            recordsFiltered: items.length,
+            recordsTotal: items.length
+        });
+    }
+    /**
+     * Undo changes
+     */
+    undo() {
+        if (this.table == null) {
+            throw new AdvancedTableNotNullError();
+        }
+        // reset removed rows
+        this.table.dataTable.rows('.removed').nodes().to$().toggleClass('removed text-gray-400 text-decoration-line-through');
+        // remove added rows
+        this.table.dataTable.rows('.added').remove();
+        // clear selected items
+        this.table.selected = [];
+        const items = this.table.dataTable.rows().data();
+        this.table.dataTable.draw();
+        this.table.load.emit({
+            data: items,
+            recordsFiltered: items.length,
+            recordsTotal: items.length
+        });
+        this.dirty = false;
+        this.dirtyChange.emit(this.dirty);
+    }
+    rows() {
+        if (this.table == null) {
+            throw new AdvancedTableNotNullError();
+        }
+        return Array.from(this.table.dataTable.rows(':not(.removed)').data());
+    }
+}
+AdvancedTableEditorDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[tableEditor]'
+            },] }
+];
+/** @nocollapse */
+AdvancedTableEditorDirective.ctorParameters = () => [
+    { type: AdvancedTableComponent }
+];
+AdvancedTableEditorDirective.propDecorators = {
+    dirtyChange: [{ type: Output }]
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"advanced-table-editor.directive.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/directives/advanced-table-editor.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ElementRef, Directive, ViewContainerRef, Output, EventEmitter\n} from '@angular/core';\nimport { AdvancedTableComponent } from '../components/advanced-table/advanced-table.component';\n\nexport class AdvancedTableNotNullError extends Error {\n  constructor() {\n    super('Advanced table component cannot be empty at this context.');\n  }\n}\n\n@Directive(\n {\n   selector: '[tableEditor]'\n }\n)\nexport class AdvancedTableEditorDirective {\n\n  public dirty: boolean = false;\n  @Output() dirtyChange: EventEmitter<boolean> = new EventEmitter<boolean>(false);\n\n  constructor(private table: AdvancedTableComponent) {\n    //\n  }\n\n  /**\n   * Add rows to table and mark them as added rows\n   */\n  add(...addItems: any[]) {\n    if (this.table == null) {\n      throw new AdvancedTableNotNullError();\n    }\n    // decorate items\n    const key = this.table.config.columns[0].property || this.table.config.columns[0].name;\n    for (let index = 0; index < addItems.length; index++) {\n      const element = addItems[index];\n      let tr = this.table.dataTable.rows(':has(input[data-id=\"' + element[key] + '\"])').nodes().to$();\n      if (tr.hasClass('removed')) {\n        tr.toggleClass('removed text-gray-400 text-decoration-line-through');\n      } else {\n        this.table.dataTable.rows.add([element]);\n        tr = this.table.dataTable.rows(':has(input[data-id=\"' + element[key] + '\"])').nodes().to$();\n        tr.toggleClass('added font-weight-bold text-success');\n      }\n    }\n    this.table.dataTable.draw();\n    // find removed\n    const removedLength = this.table.dataTable.rows('.removed')[0].length;\n    // find added\n    const addedLength = this.table.dataTable.rows('.added')[0].length;\n    // and emit event\n    const items = this.table.dataTable.rows().data();\n    this.table.load.emit({\n      data: items,\n      recordsFiltered: items.length - removedLength,\n      recordsTotal: items.length - removedLength\n    });\n    this.dirty = (removedLength > 0 || addedLength > 0);\n    this.dirtyChange.emit(this.dirty);\n  }\n\n  /**\n   * Marks rows as removed rows\n   */\n  remove(...removeItems: any[]) {\n    if (this.table == null) {\n      throw new AdvancedTableNotNullError();\n    }\n    // get key\n    const key = this.table.config.columns[0].property || this.table.config.columns[0].name;\n    // loop items\n      for (let index = 0; index < removeItems.length; index++) {\n        const element = removeItems[index];\n        const tr = this.table.dataTable.rows(':has(input[data-id=\"' + element[key] + '\"])').nodes().to$();\n        // if row is marked as added\n        if (tr.hasClass('added')) {\n          // remove this dirty row\n          this.table.dataTable.rows(tr).remove();\n        } else {\n          // otherwise unmarked row\n          tr.toggleClass('removed text-gray-400 text-decoration-line-through');\n        }\n        // check if item is selected\n        const selectedIndex = this.table.selected.findIndex((item) => {\n          return item[key] === element[key];\n        });\n        // and remove it from selected collection\n        if (selectedIndex >= 0) {\n          this.table.selected.splice(selectedIndex, 1);\n        }\n      }\n      // re-draw table\n      this.table.dataTable.draw();\n      // get number of table items\n      const items = this.table.dataTable.rows().data();\n      // get number of removed items\n      const removedLength = this.table.dataTable.rows('.removed')[0].length;\n      // get number of added items\n      const addedLength = this.table.dataTable.rows('.added')[0].length;\n      // refresh\n      this.table.load.emit({\n        data: items,\n        recordsFiltered: items.length - removedLength,\n        recordsTotal: items.length - removedLength\n      });\n      this.dirty = (removedLength > 0 || addedLength > 0);\n      this.dirtyChange.emit(this.dirty);\n  }\n\n  set(items: any[]) {\n    if (this.table == null) {\n      throw new AdvancedTableNotNullError();\n    }\n    // clear rows\n    this.table.selected = [];\n    this.table.dataTable.clear();\n    // set items\n    this.table.dataTable.rows.add(items).draw();\n    this.table.load.emit({\n      data: items,\n      recordsFiltered: items.length,\n      recordsTotal: items.length\n    });\n  }\n\n  /**\n   * Undo changes\n   */\n  undo() {\n    if (this.table == null) {\n      throw new AdvancedTableNotNullError();\n    }\n    // reset removed rows\n    this.table.dataTable.rows('.removed').nodes().to$().toggleClass('removed text-gray-400 text-decoration-line-through');\n    // remove added rows\n    this.table.dataTable.rows('.added').remove();\n    // clear selected items\n    this.table.selected = [];\n    const items = this.table.dataTable.rows().data();\n    this.table.dataTable.draw();\n    this.table.load.emit({\n      data: items,\n      recordsFiltered: items.length,\n      recordsTotal: items.length\n    });\n    this.dirty = false;\n    this.dirtyChange.emit(this.dirty);\n  }\n\n  rows() {\n    if (this.table == null) {\n      throw new AdvancedTableNotNullError();\n    }\n    return Array.from(this.table.dataTable.rows(':not(.removed)').data());\n  }\n\n}\n"]}

package/esm2015/lib/directives/btnexp.directive.js

@@ -0,0 +1,225 @@
+import * as tslib_1 from "tslib";
+import { Directive, HostListener } from '@angular/core';
+import { ActivatedTableService } from '../tables.activated-table.service';
+import { AngularDataContext } from '@themost/angular';
+import { ConfigurationService, ErrorService, LoadingService } from '@universis/common';
+import { TranslateService } from '@ngx-translate/core';
+import { ResponseError } from '@themost/client';
+const MAX_EXPORT_ITEMS = 500;
+export class BtnExpDirective {
+    constructor(_activatedTable, _context, _config, _translate, _loadingService, _errorService) {
+        this._activatedTable = _activatedTable;
+        this._context = _context;
+        this._config = _config;
+        this._translate = _translate;
+        this._loadingService = _loadingService;
+        this._errorService = _errorService;
+    }
+    clickEvent(event) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            event.preventDefault();
+            event.stopPropagation();
+            if (this._activatedTable.activeTable) {
+                const lastQuery = this._activatedTable.activeTable.lastQuery;
+                const tableConfig = this._activatedTable.activeTable.config;
+                const serviceHeaders = this._context.getService().getHeaders();
+                const queryModel = lastQuery.getModel();
+                let query = this._context.model(queryModel).asQueryable();
+                const queryParams = lastQuery.getParams();
+                query = this.constructQuery(query, queryParams, tableConfig, serviceHeaders);
+                const maxExportItems = 1000;
+                if (maxExportItems && typeof maxExportItems === 'number' && maxExportItems > 0) {
+                    query.skip(0).take(maxExportItems);
+                }
+                else {
+                    query.skip(0).take(MAX_EXPORT_ITEMS);
+                }
+                // This constructs the URI based on the way @themost does
+                const url = this.constructURL(query);
+                this.downloadFile(url, query.getService().getHeaders(), query.getModel());
+            }
+        });
+    }
+    /**
+     * Sets the parameters to the query based on
+     * the active filters of the activated table
+     * @param {ClientDataQueryable} query
+     * @param params: The filters of the last query of the activated table
+     * @return ClientDataQueryable
+     */
+    setParams(query, params) {
+        if (params && typeof params === 'object') {
+            Object.keys(params).forEach((key) => {
+                query.setParam(key, params[key]);
+            });
+        }
+        return query;
+    }
+    /**
+     * Sets the headers to the query based on
+     * the default headers of the DataContext
+     * and appending the accept header to get
+     * an xlsx file from the API
+     * @param {ClientDataQueryable} query
+     * @param {Headers} headers: The headers to append to the query
+     * @return ClientDataQueryable
+     */
+    setHeaders(query, headers) {
+        Object.keys(headers).forEach((key) => {
+            if (headers.hasOwnProperty(key)) {
+                query.getService().setHeader(key, headers[key]);
+            }
+        });
+        // sets a header to accept xlsx files
+        query.getService().setHeader('Accept', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
+        return query;
+    }
+    /**
+     * Constructs the select parameter of the
+     * ClientDataQuery by replacing the target name
+     * of the field based on the localized translation
+     * of that property on the advanced tabled
+     * @param {ClientDataQueryable} query
+     * @param tableConfig: The configuration of the activated table
+     * @return ClientDataQueryable
+     */
+    constructQueryParam(query, tableConfig) {
+        let selectQuery = query.getParams().$select;
+        let selectQueryArray = selectQuery.split(',');
+        selectQueryArray = selectQueryArray.map((select) => {
+            const words = select.split(' ');
+            if (words.length === 3) {
+                if (tableConfig && tableConfig.columns) {
+                    for (const column of tableConfig.columns) {
+                        if (column.property === words[2] && column.title) {
+                            words[2] = `"${this._translate.instant(column.title)}"`;
+                        }
+                        else if (column.property === words[2]) {
+                            words[2] = `"${this._translate.instant(words[2])}"`;
+                        }
+                    }
+                }
+            }
+            if (words.length === 1) {
+                if (tableConfig && tableConfig.columns) {
+                    for (const column of tableConfig.columns) {
+                        if (column.name === words[0] && column.title) {
+                            words[0] = `${words[0]} as "${this._translate.instant(column.title)}"`;
+                            break;
+                        }
+                        else if (column.name === words[0] && column.property) {
+                            words[0] = `${words[0]} as "${this._translate.instant(column.property)}"`;
+                            break;
+                        }
+                        else if (words[0] === column.name && words[0] === "id" && column.hidden) {
+                            break;
+                        }
+                        else if (words[0] == column.name || words[0] === column.property) {
+                            words[0] = `${words[0]} as "${this._translate.instant(words[0])}"`;
+                        }
+                    }
+                }
+                return words[0];
+            }
+            return words.join(' ');
+        });
+        selectQuery = selectQueryArray.join(',');
+        query.setParam('$select', selectQuery);
+        return query;
+    }
+    /**
+     * Constructs the fetch URL based the query parameters
+     * @param {ClientDataQueryable} query
+     * @return String
+     */
+    constructURL(query) {
+        const baseURL = query.getService().getBase();
+        let url = baseURL.endsWith('/') ? (baseURL + query.getModel() + '?') : (baseURL + '/' + query.getModel() + '?');
+        Object.keys(query.getParams()).forEach((key, index) => {
+            if (index === 0) {
+                url += key + '=' + query.getParams()[key];
+            }
+            else {
+                url += '&' + key + '=' + query.getParams()[key];
+            }
+        });
+        return url;
+    }
+    /**
+     * Constructs the query by setting the parameters of the
+     * advanced table's active filters, sets the necessary headers
+     * and build the select parameter of the query
+     * @param {ClientDataQueryable} query
+     * @param params: The filters of the last query of the activated table
+     * @param tableConfig: The configuration of the activated table
+     * @param {Headers} headers: The headers to append to the query
+     * @return ClientDataQueryable
+     */
+    constructQuery(query, params, tableConfig, headers) {
+        let _query = this.setParams(query, params);
+        _query = this.setHeaders(_query, headers);
+        _query = this.constructQueryParam(_query, tableConfig);
+        return _query;
+    }
+    /**
+     * Fetches and saves the xlsx file
+     * @param {String} url
+     * @param {Headers} serviceHeaders: The headers to append to the query
+     * @param modelName: The model name of the advanced table
+     */
+    downloadFile(url, serviceHeaders, modelName) {
+        this._loadingService.showLoading();
+        fetch(encodeURI(url), {
+            headers: serviceHeaders,
+            credentials: 'include'
+        }).then(response => {
+            if (response && !response.ok) {
+                throw new ResponseError(response.statusText, response.status);
+            }
+            return response.blob();
+        }).then(blob => {
+            const objectUrl = window.URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            document.body.appendChild(a);
+            a.setAttribute('style', 'display: none');
+            a.href = objectUrl;
+            const downloadName = `${modelName}.xlsx`;
+            a.download = downloadName;
+            // this adds support for IE and MS Edge (up to version 44.19041)
+            if (window.navigator && window.navigator.msSaveOrOpenBlob) {
+                window.navigator.msSaveOrOpenBlob(blob, downloadName);
+            }
+            else {
+                // for all other browsers
+                a.click();
+            }
+            window.URL.revokeObjectURL(objectUrl);
+            a.remove();
+            this._loadingService.hideLoading();
+        }).catch(err => {
+            this._loadingService.hideLoading();
+            this._errorService.showError(err, {
+                continueLink: '.'
+            });
+        });
+    }
+}
+BtnExpDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '.universis-btn-export'
+            },] }
+];
+/** @nocollapse */
+BtnExpDirective.ctorParameters = () => [
+    { type: ActivatedTableService },
+    { type: AngularDataContext },
+    { type: ConfigurationService },
+    { type: TranslateService },
+    { type: LoadingService },
+    { type: ErrorService }
+];
+BtnExpDirective.propDecorators = {
+    clickEvent: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"btnexp.directive.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/directives/btnexp.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, HostListener} from '@angular/core';\nimport {ActivatedTableService} from '../tables.activated-table.service';\nimport {AngularDataContext} from '@themost/angular';\nimport {ConfigurationService, ErrorService, LoadingService} from '@universis/common';\nimport {TranslateService} from '@ngx-translate/core';\nimport {ClientDataQueryable, ResponseError} from '@themost/client';\nimport { TableConfiguration } from '../components/advanced-table/advanced-table.interfaces';\n\nconst MAX_EXPORT_ITEMS = 500;\n\n@Directive({\n  selector: '.universis-btn-export'\n})\nexport class BtnExpDirective {\n  constructor(private _activatedTable: ActivatedTableService,\n              private _context: AngularDataContext,\n              private _config: ConfigurationService,\n              private _translate: TranslateService,\n              private _loadingService: LoadingService,\n              private _errorService: ErrorService) {\n  }\n\n  @HostListener('click', ['$event'])\n  async clickEvent(event) {\n    event.preventDefault();\n    event.stopPropagation();\n    if (this._activatedTable.activeTable) {\n      const lastQuery = this._activatedTable.activeTable.lastQuery;\n      const tableConfig = this._activatedTable.activeTable.config;\n      const serviceHeaders = this._context.getService().getHeaders();\n      const queryModel = lastQuery.getModel();\n      let query = this._context.model(queryModel).asQueryable();\n      const queryParams = lastQuery.getParams();\n      query = this.constructQuery(query, queryParams, tableConfig, serviceHeaders);\n      const maxExportItems = 1000;\n      if (maxExportItems && typeof maxExportItems === 'number' && maxExportItems > 0) {\n        query.skip(0).take(maxExportItems);\n      } else {\n        query.skip(0).take(MAX_EXPORT_ITEMS);\n      }\n      // This constructs the URI based on the way @themost does\n      const url = this.constructURL(query);\n      this.downloadFile(url, query.getService().getHeaders(), query.getModel());\n    }\n  }\n\n  /**\n   * Sets the parameters to the query based on\n   * the active filters of the activated table\n   * @param {ClientDataQueryable} query\n   * @param params: The filters of the last query of the activated table\n   * @return ClientDataQueryable\n   */\n  setParams(query: ClientDataQueryable, params): ClientDataQueryable {\n    if (params && typeof params === 'object') {\n      Object.keys(params).forEach((key) => {\n        query.setParam(key, params[key]);\n      });\n    }\n    return query;\n  }\n\n  /**\n   * Sets the headers to the query based on\n   * the default headers of the DataContext\n   * and appending the accept header to get\n   * an xlsx file from the API\n   * @param {ClientDataQueryable} query\n   * @param {Headers} headers: The headers to append to the query\n   * @return ClientDataQueryable\n   */\n  setHeaders(query: ClientDataQueryable, headers: Headers): ClientDataQueryable {\n    Object.keys(headers).forEach((key) => {\n      if (headers.hasOwnProperty(key)) {\n        query.getService().setHeader(key, headers[key]);\n      }\n    });\n    // sets a header to accept xlsx files\n    query.getService().setHeader('Accept', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');\n    return query;\n  }\n\n  /**\n   * Constructs the select parameter of the\n   * ClientDataQuery by replacing the target name\n   * of the field based on the localized translation\n   * of that property on the advanced tabled\n   * @param {ClientDataQueryable} query\n   * @param tableConfig: The configuration of the activated table\n   * @return ClientDataQueryable\n   */\n  constructQueryParam(query: ClientDataQueryable, tableConfig: TableConfiguration): ClientDataQueryable {\n    let selectQuery = query.getParams().$select;\n    let selectQueryArray = selectQuery.split(',');\n    selectQueryArray = selectQueryArray.map((select) => {\n      const words = select.split(' ');\n      if (words.length === 3) {\n        if (tableConfig && tableConfig.columns) {\n          for(const column of tableConfig.columns) {\n            if (column.property === words[2] && column.title) {\n              words[2] = `\"${this._translate.instant(column.title)}\"`;\n            } else if (column.property === words[2]) {\n              words[2] = `\"${this._translate.instant(words[2])}\"`\n            }\n          }\n        }\n      }\n      if (words.length === 1) {\n        if (tableConfig && tableConfig.columns) {\n          for(const column of tableConfig.columns){\n            if (column.name === words[0] && column.title) {\n              words[0] = `${words[0]} as \"${this._translate.instant(column.title)}\"`;\n              break;\n            } else if (column.name === words[0] && column.property) {\n              words[0] = `${words[0]} as \"${this._translate.instant(column.property)}\"`;\n              break;\n            } else if (words[0] === column.name && words[0]=== \"id\" && column.hidden) {\n              break;\n            } else if(words[0] == column.name || words[0]=== column.property) {\n              words[0] = `${words[0]} as \"${this._translate.instant(words[0])}\"`;\n            }\n          }\n        }\n        return words[0];\n      }\n      return words.join(' ');\n    });\n    selectQuery = selectQueryArray.join(',');\n    query.setParam('$select', selectQuery );\n    return query;\n  }\n\n  /**\n   * Constructs the fetch URL based the query parameters\n   * @param {ClientDataQueryable} query\n   * @return String\n   */\n  constructURL(query): String {\n    const baseURL = query.getService().getBase();\n    let url = baseURL.endsWith('/') ? (baseURL + query.getModel() + '?') : (baseURL + '/' + query.getModel() + '?');\n    Object.keys(query.getParams()).forEach((key, index) => {\n      if (index === 0) {\n        url += key + '=' + query.getParams()[key];\n      } else {\n        url += '&' + key + '=' + query.getParams()[key];\n      }\n    });\n    return url;\n  }\n\n  /**\n   * Constructs the query by setting the parameters of the\n   * advanced table's active filters, sets the necessary headers\n   * and build the select parameter of the query\n   * @param {ClientDataQueryable} query\n   * @param params: The filters of the last query of the activated table\n   * @param tableConfig: The configuration of the activated table\n   * @param {Headers} headers: The headers to append to the query\n   * @return ClientDataQueryable\n   */\n  constructQuery(query, params, tableConfig, headers: Headers) {\n    let _query = this.setParams(query, params);\n    _query = this.setHeaders(_query, headers);\n    _query = this.constructQueryParam(_query, tableConfig);\n    return _query;\n  }\n\n  /**\n   * Fetches and saves the xlsx file\n   * @param {String} url\n   * @param {Headers} serviceHeaders: The headers to append to the query\n   * @param modelName: The model name of the advanced table\n   */\n  downloadFile(url, serviceHeaders: Headers, modelName) {\n    this._loadingService.showLoading();\n    fetch(encodeURI(url), {\n      headers: serviceHeaders,\n      credentials: 'include'\n    }).then(response => {\n      if (response && !response.ok) {\n        throw new ResponseError(response.statusText, response.status);\n      }\n      return response.blob();\n    }).then(blob => {\n      const objectUrl = window.URL.createObjectURL(blob);\n      const a = document.createElement('a');\n      document.body.appendChild(a);\n      a.setAttribute('style', 'display: none');\n      a.href = objectUrl;\n      const downloadName = `${modelName}.xlsx`;\n      a.download = downloadName;\n      // this adds support for IE and MS Edge (up to version 44.19041)\n      if (window.navigator && window.navigator.msSaveOrOpenBlob) {\n        window.navigator.msSaveOrOpenBlob(blob, downloadName);\n      } else {\n        // for all other browsers\n        a.click();\n      }\n      window.URL.revokeObjectURL(objectUrl);\n      a.remove();\n      this._loadingService.hideLoading();\n    }).catch(err => {\n      this._loadingService.hideLoading();\n      this._errorService.showError(err, {\n        continueLink: '.'\n      });\n    });\n  }\n\n}\n"]}

package/esm2015/lib/i18n/tables.el.js

@@ -0,0 +1,104 @@
+export const TABLES_EL = {
+    "Tables": {
+        "Export": "Εξαγωγή",
+        "More": "Περισσότερα",
+        "Search": "Αναζήτηση",
+        "SearchPlaceholder": "Αναζήτηση...",
+        "GroupBy": "Ομαδοποίηση ανά",
+        "DataTable": {
+            "paginate": {
+                "first": "Πρώτη σελίδα",
+                "last": "Τελεταία σελίδα",
+                "next": "Επόμενη",
+                "previous": "Προηγούμενη"
+            },
+            "info": "Εμφάνιση _START_ έως _END_ από _TOTAL_ εγγραφές",
+            "infoEmpty": "Δεν βρέθηκαν εγγραφές",
+            "loading": "Εμφάνιση δεδομένων...",
+            "processing": "Παραλαβή δεδομένων...",
+            "emptyTable": "Δεν βρέθηκαν αποτελέσματα."
+        },
+        "ColumnDisplay": "Επιλογή Εμφάνισης στηλών",
+        "ColumnDisplayInfo": "Επιλέξτε τις στήλες που θέλετε να εμφανίζονται.",
+        "Save": "Εφαρμογή",
+        "Apply": "Εφαρμογή",
+        "Cancel": "Ακύρωση",
+        "RecordsPerPage": "Εγγραφές ανά σελίδα",
+        "PageInfo": "{{start}}-{{end}} από {{recordsTotal}}",
+        "SearchListPlaceholder": "Αναζητήστε στη λίστα...",
+        "Filters": "Φίλτρα",
+        "All": "Όλα",
+        "AddItem": "Προσθήκη στοιχείου",
+        "EmptyTableTitle": "Δεν βρέθηκαν αποτελέσματα.",
+        "EmptyTableMessage": "Προσπαθήστε να χρησιμοποιήσετε άλλες λέξεις κλειδιά.",
+        "RemoveItem": "Διαγραφή στοιχείου",
+        "Items": "στοιχεία",
+        "Item": "στοιχείο",
+        "AddItemMessage": {
+            "title": "Προσθήκη στοιχείων",
+            "one": "Ένα νέο στοιχείο προστέθηκε με επιτυχία.",
+            "many": "{{value}} νέα στοιχεία προστέθηκαν με επιτυχία."
+        },
+        "RemoveItemMessage": {
+            "title": "Αφαίρεση στοιχείων",
+            "one": "Ένα στοιχείο αφαιρέθηκε με επιτυχία.",
+            "many": "{{value}} στοιχεία αφαιρέθηκαν με επιτυχία."
+        },
+        "RemoveItemsTitle": "Διαγραφή στοιχείου",
+        "RemoveItemsMessage": "Πρόκειται να διαγράψετε ένα ή περισσότερα στοιχεία. Θέλετε να προχωρήσετε?",
+        "SelectAll": "Επιλογή όλων",
+        "ClearSelection": "Αναίρεση επιλογής",
+        "Actions": {
+            "Label": "Επεξεργασία",
+            "Start": "Έναρξη",
+            "ActionMessage": {
+                "None": "Δεν έχετε επιλέξει κανένα στοιχείο που να ακολουθεί τις προϋποθέσεις της ενέργειας.",
+                "One": "Έχετε επιλέξει ένα στοιχείο που ακολουθεί τις προϋποθέσεις της ενέργειας. Πατήστε το πλήκτρο Έναρξη για να ξεκινήσει η διαδικασία.",
+                "Many": "Έχετε επιλέξει {{length}} στοιχεία που ακολουθούν τις προϋποθέσεις της ενέργειας. Πατήστε το πλήκτρο Έναρξη για να ξεκινήσει η διαδικασία."
+            },
+            "CompletedWithErrors": {
+                "Title": "Η διαδικασία ολοκληρώθηκε με σφάλματα.",
+                "Description": {
+                    "One": "Ένα στοιχείο δεν ανανεώθηκε λόγω ενός σφάλματος που συνέβη κατά την εκτέλεση της διαδικασίας.",
+                    "Many": "{{errors}} στοιχεία δεν ανανεώθηκαν λόγω ενός σφάλματος που συνέβη κατά την εκτέλεση της διαδικασίας."
+                }
+            },
+            "CompletedWithSuccess": {
+                "Title": "Η διαδικασία ολοκληρώθηκε με επιτυχία."
+            }
+        }
+    },
+    "TrueFalse": {
+        "long": {
+            "Yes": "Ναι",
+            "No": "Όχι"
+        }
+    },
+    "AdvancedSearch": {
+        "Choose": "<Επιλέξτε μια αναζήτηση>",
+        "ChooseDate": "Επιλογή ημερομηνίας",
+        "SavedSearches": "Αποθηκευμένες αναζητήσεις",
+        "ToggleDropdown": "Εμφάνιση λίστας",
+        "SaveCurrentSearch": "Αποθήκευση αναζήτησης",
+        "SaveAs": "Αποθήκευση ως",
+        "Save": "Αποθήκευση",
+        "Delete": "Διαγραφή",
+        "More": "Περισσότερα",
+        "Less": "Λιγότερα",
+        "Modal": {
+            "Title": "Αποθήκευση κριτηρίων αναζήτησης",
+            "Help": "Ορίστε έναν τίτλο για τα επιλεγμένα κριτήρια αναζήτησης. Αυτός ο τίτλος θα σας βοηθήσει να τα χρησιμοποιήσετε ξανά στο μέλλον.",
+            "TitleOnUserError": "Παρακαλώ εισάγετε έναν τίτλο",
+            "TitleOnListAlreadyCreated": "Το όνομα αυτό χρησιμοποιείται ήδη. Διαλέξτε ένα διαφορετικό.",
+            "NoListDefined": "Δεν έχει οριστεί το σημείο αποθήκευσης της λίστας",
+            "EmptyCriteriaList": "Δεν έχετε καθορίσει κανένα κριτήριο για αποθήκευση",
+            "SaveNameLabel": "Ονομασία λίστας",
+            "SaveNamePlaceholder": "Εισάγετε έναν τίτλο",
+            "Accept": "Αποθήκευση",
+            "Decline": "Απόρριψη",
+            "Close": "Κλείσιμο"
+        }
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tables.el.js","sourceRoot":"ng://@universis/ngx-tables/","sources":["lib/i18n/tables.el.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,SAAS,GAAG;IACrB,QAAQ,EAAE;QACN,QAAQ,EAAE,SAAS;QACnB,MAAM,EAAE,aAAa;QACrB,QAAQ,EAAE,WAAW;QACrB,mBAAmB,EAAE,cAAc;QACnC,SAAS,EAAE,iBAAiB;QAC5B,WAAW,EAAE;YACT,UAAU,EAAE;gBACR,OAAO,EAAE,cAAc;gBACvB,MAAM,EAAE,iBAAiB;gBACzB,MAAM,EAAE,SAAS;gBACjB,UAAU,EAAE,aAAa;aAC5B;YACD,MAAM,EAAE,iDAAiD;YACzD,WAAW,EAAE,uBAAuB;YACpC,SAAS,EAAE,uBAAuB;YAClC,YAAY,EAAE,uBAAuB;YACrC,YAAY,EAAE,4BAA4B;SAC7C;QACH,eAAe,EAAE,0BAA0B;QAC3C,mBAAmB,EAAE,iDAAiD;QACtE,MAAM,EAAE,UAAU;QAClB,OAAO,EAAE,UAAU;QACnB,QAAQ,EAAE,SAAS;QACnB,gBAAgB,EAAE,qBAAqB;QACvC,UAAU,EAAE,wCAAwC;QACpD,uBAAuB,EAAE,yBAAyB;QAClD,SAAS,EAAE,QAAQ;QACnB,KAAK,EAAE,KAAK;QACV,SAAS,EAAE,oBAAoB;QAC/B,iBAAiB,EAAE,4BAA4B;QAC/C,mBAAmB,EAAE,sDAAsD;QAC3E,YAAY,EAAE,oBAAoB;QAClC,OAAO,EAAE,UAAU;QACnB,MAAM,EAAE,UAAU;QAClB,gBAAgB,EAAE;YACd,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,0CAA0C;YACjD,MAAM,EAAE,iDAAiD;SAC1D;QACH,mBAAmB,EAAE;YACjB,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,sCAAsC;YAC7C,MAAM,EAAE,6CAA6C;SACxD;QACD,kBAAkB,EAAE,oBAAoB;QACxC,oBAAoB,EAAE,4EAA4E;QAClG,WAAW,EAAE,cAAc;QAC3B,gBAAgB,EAAE,mBAAmB;QACvC,SAAS,EAAE;YACT,OAAO,EAAE,aAAa;YACtB,OAAO,EAAE,QAAQ;YACjB,eAAe,EAAE;gBACf,MAAM,EAAE,qFAAqF;gBAC7F,KAAK,EAAE,oIAAoI;gBAC3I,MAAM,EAAE,4IAA4I;aACrJ;YACD,qBAAqB,EAAE;gBACrB,OAAO,EAAE,wCAAwC;gBACjD,aAAa,EAAE;oBACb,KAAK,EAAE,+FAA+F;oBACtG,MAAM,EAAE,uGAAuG;iBAChH;aACF;YACD,sBAAsB,EAAE;gBACtB,OAAO,EAAE,wCAAwC;aAClD;SACF;KACF;IACD,WAAW,EAAE;QACT,MAAM,EAAE;YACJ,KAAK,EAAE,KAAK;YACZ,IAAI,EAAE,KAAK;SACd;KACJ;IACD,gBAAgB,EAAE;QACd,QAAQ,EAAE,0BAA0B;QACpC,YAAY,EAAE,qBAAqB;QACnC,eAAe,EAAE,2BAA2B;QAC5C,gBAAgB,EAAG,iBAAiB;QACpC,mBAAmB,EAAE,uBAAuB;QAC5C,QAAQ,EAAG,eAAe;QAC1B,MAAM,EAAG,YAAY;QACrB,QAAQ,EAAG,UAAU;QACrB,MAAM,EAAE,aAAa;QACrB,MAAM,EAAE,UAAU;QAClB,OAAO,EAAG;YACN,OAAO,EAAG,iCAAiC;YAC3C,MAAM,EAAG,gIAAgI;YACzI,kBAAkB,EAAG,8BAA8B;YACnD,2BAA2B,EAAG,8DAA8D;YAC5F,eAAe,EAAG,mDAAmD;YACrE,mBAAmB,EAAG,oDAAoD;YAC1E,eAAe,EAAG,iBAAiB;YACnC,qBAAqB,EAAG,qBAAqB;YAC7C,QAAQ,EAAG,YAAY;YACvB,SAAS,EAAG,UAAU;YACtB,OAAO,EAAG,UAAU;SACvB;KACJ;CACJ,CAAA","sourcesContent":["export const TABLES_EL = {\n    \"Tables\": {\n        \"Export\": \"Εξαγωγή\",\n        \"More\": \"Περισσότερα\",\n        \"Search\": \"Αναζήτηση\",\n        \"SearchPlaceholder\": \"Αναζήτηση...\",\n        \"GroupBy\": \"Ομαδοποίηση ανά\",\n        \"DataTable\": {\n            \"paginate\": {\n                \"first\": \"Πρώτη σελίδα\",\n                \"last\": \"Τελεταία σελίδα\",\n                \"next\": \"Επόμενη\",\n                \"previous\": \"Προηγούμενη\"\n            },\n            \"info\": \"Εμφάνιση _START_ έως _END_ από _TOTAL_ εγγραφές\",\n            \"infoEmpty\": \"Δεν βρέθηκαν εγγραφές\",\n            \"loading\": \"Εμφάνιση δεδομένων...\",\n            \"processing\": \"Παραλαβή δεδομένων...\",\n            \"emptyTable\": \"Δεν βρέθηκαν αποτελέσματα.\"\n        },\n      \"ColumnDisplay\": \"Επιλογή Εμφάνισης στηλών\",\n      \"ColumnDisplayInfo\": \"Επιλέξτε τις στήλες που θέλετε να εμφανίζονται.\",\n      \"Save\": \"Εφαρμογή\",\n      \"Apply\": \"Εφαρμογή\",\n      \"Cancel\": \"Ακύρωση\",\n      \"RecordsPerPage\": \"Εγγραφές ανά σελίδα\",\n      \"PageInfo\": \"{{start}}-{{end}} από {{recordsTotal}}\",\n      \"SearchListPlaceholder\": \"Αναζητήστε στη λίστα...\",\n      \"Filters\": \"Φίλτρα\",\n      \"All\": \"Όλα\",\n        \"AddItem\": \"Προσθήκη στοιχείου\",\n        \"EmptyTableTitle\": \"Δεν βρέθηκαν αποτελέσματα.\",\n        \"EmptyTableMessage\": \"Προσπαθήστε να χρησιμοποιήσετε άλλες λέξεις κλειδιά.\",\n        \"RemoveItem\": \"Διαγραφή στοιχείου\",\n        \"Items\": \"στοιχεία\",\n        \"Item\": \"στοιχείο\",\n        \"AddItemMessage\": {\n            \"title\": \"Προσθήκη στοιχείων\",\n            \"one\": \"Ένα νέο στοιχείο προστέθηκε με επιτυχία.\",\n            \"many\": \"{{value}} νέα στοιχεία προστέθηκαν με επιτυχία.\"\n          },\n        \"RemoveItemMessage\": {\n            \"title\": \"Αφαίρεση στοιχείων\",\n            \"one\": \"Ένα στοιχείο αφαιρέθηκε με επιτυχία.\",\n            \"many\": \"{{value}} στοιχεία αφαιρέθηκαν με επιτυχία.\"\n        },\n        \"RemoveItemsTitle\": \"Διαγραφή στοιχείου\",\n        \"RemoveItemsMessage\": \"Πρόκειται να διαγράψετε ένα ή περισσότερα στοιχεία. Θέλετε να προχωρήσετε?\",\n        \"SelectAll\": \"Επιλογή όλων\",\n        \"ClearSelection\": \"Αναίρεση επιλογής\",\n      \"Actions\": {\n        \"Label\": \"Επεξεργασία\",\n        \"Start\": \"Έναρξη\",\n        \"ActionMessage\": {\n          \"None\": \"Δεν έχετε επιλέξει κανένα στοιχείο που να ακολουθεί τις προϋποθέσεις της ενέργειας.\",\n          \"One\": \"Έχετε επιλέξει ένα στοιχείο που ακολουθεί τις προϋποθέσεις της ενέργειας. Πατήστε το πλήκτρο Έναρξη για να ξεκινήσει η διαδικασία.\",\n          \"Many\": \"Έχετε επιλέξει {{length}} στοιχεία που ακολουθούν τις προϋποθέσεις της ενέργειας. Πατήστε το πλήκτρο Έναρξη για να ξεκινήσει η διαδικασία.\"\n        },\n        \"CompletedWithErrors\": {\n          \"Title\": \"Η διαδικασία ολοκληρώθηκε με σφάλματα.\",\n          \"Description\": {\n            \"One\": \"Ένα στοιχείο δεν ανανεώθηκε λόγω ενός σφάλματος που συνέβη κατά την εκτέλεση της διαδικασίας.\",\n            \"Many\": \"{{errors}} στοιχεία δεν ανανεώθηκαν λόγω ενός σφάλματος που συνέβη κατά την εκτέλεση της διαδικασίας.\"\n          }\n        },\n        \"CompletedWithSuccess\": {\n          \"Title\": \"Η διαδικασία ολοκληρώθηκε με επιτυχία.\"\n        }\n      }\n    },\n    \"TrueFalse\": {\n        \"long\": {\n            \"Yes\": \"Ναι\",\n            \"No\": \"Όχι\"\n        }\n    },\n    \"AdvancedSearch\": {\n        \"Choose\": \"<Επιλέξτε μια αναζήτηση>\",\n        \"ChooseDate\": \"Επιλογή ημερομηνίας\",\n        \"SavedSearches\": \"Αποθηκευμένες αναζητήσεις\",\n        \"ToggleDropdown\" : \"Εμφάνιση λίστας\",\n        \"SaveCurrentSearch\": \"Αποθήκευση αναζήτησης\",\n        \"SaveAs\" : \"Αποθήκευση ως\",\n        \"Save\" : \"Αποθήκευση\",\n        \"Delete\" : \"Διαγραφή\",\n        \"More\": \"Περισσότερα\",\n        \"Less\": \"Λιγότερα\",\n        \"Modal\" : {\n            \"Title\" : \"Αποθήκευση κριτηρίων αναζήτησης\",\n            \"Help\" : \"Ορίστε έναν τίτλο για τα επιλεγμένα κριτήρια αναζήτησης. Αυτός ο τίτλος θα σας βοηθήσει να τα χρησιμοποιήσετε ξανά στο μέλλον.\",\n            \"TitleOnUserError\" : \"Παρακαλώ εισάγετε έναν τίτλο\",\n            \"TitleOnListAlreadyCreated\" : \"Το όνομα αυτό χρησιμοποιείται ήδη. Διαλέξτε ένα διαφορετικό.\",\n            \"NoListDefined\" : \"Δεν έχει οριστεί το σημείο αποθήκευσης της λίστας\",\n            \"EmptyCriteriaList\" : \"Δεν έχετε καθορίσει κανένα κριτήριο για αποθήκευση\",\n            \"SaveNameLabel\" : \"Ονομασία λίστας\",\n            \"SaveNamePlaceholder\" : \"Εισάγετε έναν τίτλο\",\n            \"Accept\" : \"Αποθήκευση\",\n            \"Decline\" : \"Απόρριψη\",\n            \"Close\" : \"Κλείσιμο\"\n        }\n    }\n}\n"]}