lynx-framework/dist/datatables.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatatableConfiguration = exports.PaginationConfiguration = exports.TableConfiguration = exports.Element = void 0;
var Element = /** @class */ (function () {
    function Element() {
    }
    return Element;
}());
exports.Element = Element;
var TableConfiguration = /** @class */ (function () {
    function TableConfiguration() {
        this._class = "";
        this.ordersBy = [];
        this.header = [];
        this.data = [];
    }
    TableConfiguration.prototype.addClass = function (_class) {
        this._class += _class + " ";
        return this;
    };
    TableConfiguration.prototype.addHeader = function (text, _class) {
        this.header.push({ text: text, _class: _class ? _class : "" });
        this.ordersBy.push(0);
        return this;
    };
    TableConfiguration.prototype.addData = function (texts, _classes) {
        var c = [];
        for (var i = 0; i < texts.length; i++) {
            c.push({
                text: texts[i],
                _class: _classes && _classes[i] ? _classes[i] : ""
            });
        }
        this.data.push(c);
        return this;
    };
    return TableConfiguration;
}());
exports.TableConfiguration = TableConfiguration;
var PaginationConfiguration = /** @class */ (function () {
    function PaginationConfiguration() {
        this.total = 0;
        this.pageSize = 10;
        this.pageCount = 0;
        this.currentPage = 0;
        this.left = 0;
        this.right = 0;
        this.maxPages = 2;
        this._class = "";
    }
    PaginationConfiguration.prototype.calculate = function () {
        this.pageCount = Math.ceil(this.total / this.pageSize);
        this.left = Math.max(0, this.currentPage - this.maxPages);
        this.right = Math.min(this.pageCount, this.currentPage + 1 + this.maxPages);
    };
    PaginationConfiguration.prototype.addClass = function (_class) {
        this._class += _class + " ";
        return this;
    };
    return PaginationConfiguration;
}());
exports.PaginationConfiguration = PaginationConfiguration;
var DatatableConfiguration = /** @class */ (function () {
    function DatatableConfiguration(repository, req, alias) {
        this.table = new TableConfiguration();
        this._classes = [];
        this.mapTransformers = {};
        this.pagination = new PaginationConfiguration();
        this.alias = "e";
        this.repository = repository;
        this.req = req;
        this.setupPageRequested();
        this.urlNoPage = getUrlWithoutPage(this.req);
        this.urlNoOrder = getUrlWithoutOrder(this.req);
        this.urlNoPageNoOrder = getUrlWithoutPageOrOrder(this.req);
        this.urlNoFilter = getUrlWithoutFilter(this.req);
        if (alias) {
            this.alias = alias;
        }
    }
    DatatableConfiguration.prototype.setPageSize = function (size) {
        this.pagination.pageSize = size;
    };
    DatatableConfiguration.prototype.addTableClass = function (_class) {
        this.table.addClass(_class);
        return this;
    };
    DatatableConfiguration.prototype.addTableHeader = function (text, _class) {
        this.table.addHeader(text, _class);
        return this;
    };
    DatatableConfiguration.prototype.addDataMap = function (map, _classes) {
        this.map = map;
        if (_classes) {
            this._classes = _classes;
        }
        else {
            this._classes = [];
            for (var i = 0; i < this.map.length; i++) {
                this._classes.push("");
            }
        }
        return this;
    };
    DatatableConfiguration.prototype.addDataTransformer = function (label, exe) {
        this.mapTransformers[label] = exe;
        return this;
    };
    DatatableConfiguration.prototype.addPaginationClass = function (_class) {
        this.pagination.addClass(_class);
        return this;
    };
    DatatableConfiguration.prototype.setupPageRequested = function () {
        this.pagination.currentPage = 0;
        if (this.req.query.page) {
            this.pagination.currentPage = Number(this.req.query.page);
            if (this.pagination.currentPage > 0) {
                this.pagination.currentPage -= 1;
            }
        }
    };
    DatatableConfiguration.prototype.getQueryValue = function (key) {
        for (var q in this.req.query) {
            if (q.toLowerCase() !== key) {
                continue;
            }
            if (this.req.query[q] instanceof Array) {
                return this.req.query[q];
            }
            return [this.req.query[q]];
        }
        return [];
    };
    DatatableConfiguration.prototype.addOrderBy = function (query) {
        var ordersBy = this.getQueryValue("orderby");
        if (ordersBy.length > 0) {
            var order = ordersBy[0].split(":");
            this.setOrderBy(order[0], order[1]);
            query = query.orderBy(this.alias + "." + order[0], order[1] == "desc" ? "DESC" : "ASC");
            for (var i = 1; i < ordersBy.length; i++) {
                var order_1 = ordersBy[i].split(":");
                this.setOrderBy(order_1[0], order_1[1]);
                query = query.addOrderBy(this.alias + "." + order_1[0], order_1[1] == "desc" ? "DESC" : "ASC");
            }
        }
        return query;
    };
    DatatableConfiguration.prototype.setOrderBy = function (column, order) {
        for (var i = 0; i < this.map.length; i++) {
            if (this.map[i] == column) {
                this.table.ordersBy[i] = order == "desc" ? -1 : 1;
            }
        }
    };
    DatatableConfiguration.prototype.addFilterBy = function (query) {
        var filtersBy = this.getQueryValue("filterby");
        if (filtersBy.length) {
            var f = filtersBy[0].split(":");
            var o = {};
            o[f[0] + "_" + 0] = f[1];
            query = query.where(this.alias + "." + f[0] + " = :" + f[0] + "_" + 0, o);
            for (var i = 1; i < filtersBy.length; i++) {
                var f_1 = filtersBy[i].split(":");
                var o_1 = {};
                o_1[f_1[0] + "_" + i] = f_1[1];
                query = query.andWhere(this.alias + "." + f_1[0] + " = :" + f_1[0] + "_" + i, o_1);
            }
        }
        return query;
    };
    DatatableConfiguration.prototype.fetchData = function (query) {
        return __awaiter(this, void 0, void 0, function () {
            var select_1, _a, skip, result, _i, result_1, r, line, _b, _c, label, cell;
            var _this = this;
            return __generator(this, function (_d) {
                switch (_d.label) {
                    case 0:
                        if (!query) {
                            select_1 = [];
                            this.map.forEach(function (v) {
                                if (!v.startsWith(":")) {
                                    select_1.push(_this.alias + "." + v.replace("-", ""));
                                }
                            });
                            query = this.repository.createQueryBuilder(this.alias).select(select_1);
                        }
                        query = this.addFilterBy(query);
                        _a = this.pagination;
                        return [4 /*yield*/, query.getCount()];
                    case 1:
                        _a.total = _d.sent();
                        this.pagination.calculate();
                        query = this.addOrderBy(query);
                        skip = this.pagination.currentPage * this.pagination.pageSize;
                        query = query.skip(skip).take(this.pagination.pageSize);
                        return [4 /*yield*/, query.getMany()];
                    case 2:
                        result = _d.sent();
                        for (_i = 0, result_1 = result; _i < result_1.length; _i++) {
                            r = result_1[_i];
                            line = [];
                            for (_b = 0, _c = this.map; _b < _c.length; _b++) {
                                label = _c[_b];
                                if (label.startsWith("-"))
                                    continue;
                                cell = r[label];
                                if (this.mapTransformers[label]) {
                                    cell = this.mapTransformers[label](cell, r);
                                }
                                line.push(cell);
                            }
                            this.table.addData(line, this._classes);
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    return DatatableConfiguration;
}());
exports.DatatableConfiguration = DatatableConfiguration;
function getUrlWithoutPage(req) {
    return getUrlWithoutParameter(req, ["page"]);
}
function getUrlWithoutOrder(req) {
    return getUrlWithoutParameter(req, ["orderby"]);
}
function getUrlWithoutPageOrOrder(req) {
    return getUrlWithoutParameter(req, ["orderby", "page"]);
}
function getUrlWithoutFilter(req) {
    return getUrlWithoutParameter(req, ["filter", "filterby"]);
}
function getUrlWithoutParameter(req, parameters) {
    var u = (req.baseUrl + req.path).replace(/\/$/, "") + "?";
    for (var key in req.query) {
        var found = false;
        for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
            var p = parameters_1[_i];
            if (key.toLowerCase() == p) {
                found = true;
                break;
            }
        }
        if (found) {
            continue;
        }
        u += generateQueryValue(key, req.query[key]);
    }
    return u;
}
function generateQueryValue(key, q) {
    var m = key + "=";
    if (q instanceof Array) {
        m += q[0] + "&";
        for (var i = 1; i < q.length; i++) {
            m += key + "=" + q[i] + "&";
        }
        return m;
    }
    return m + q + "&";
}