@webtypen/webframez-core 0.2.8 → 0.2.10

package/dist/ConsoleApplication.js

@@ -15,6 +15,7 @@ const Config_1 = require("./Config");
 const BuildFinishCommand_1 = require("./Commands/BuildFinishCommand");
 const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 const QueueRunCommand_1 = require("./Commands/QueueRunCommand");
+const DatatableRegistry_1 = require("./Datatable/DatatableRegistry");
 class ConsoleApplication {
     /**
      * Init the routes and start the http-server
@@ -62,6 +63,9 @@ class ConsoleApplication {
                 program.addCommand(consoleCommand);
             }
         }
+        if (options && options.datatables) {
+            DatatableRegistry_1.DatatableRegistry.registerMany(options.datatables);
+        }
         if (options.jobs && options.jobs.length > 0) {
             QueueJobsRegisty_1.QueueJobsRegisty.registerJob(options.jobs);
         }

package/dist/Datatable/Datatable.d.ts

@@ -0,0 +1,37 @@
+import { Request } from "../Router/Request";
+export declare class Datatable {
+    collection: string | Function;
+    aggregation: {
+        [key: string]: any;
+    } | Function | null;
+    subAggregation: {
+        [key: string]: any;
+    } | Function | null;
+    filter: {
+        [key: string]: any;
+    } | Function | null;
+    columns: {
+        [key: string]: any;
+    } | Function | null;
+    onPressLink: string | Function | null;
+    exports: any | null;
+    perPage: number;
+    onRow?: Function;
+    onAttributes?: Function;
+    getInit(req: Request): Promise<any>;
+    getAggregation(req: Request): Promise<any>;
+    getSubAggregation(req: Request): Promise<any>;
+    getCollection(req: Request): Promise<any>;
+    getData(req: Request): Promise<{
+        page: number;
+        max_entries: any;
+        total_pages: number;
+        entries: any;
+        sums: any;
+    }>;
+    getTotalData(req: Request): Promise<any>;
+    getFilter(req: Request): Promise<any>;
+    getColumns(req: Request): Promise<any>;
+    getOnPressLink(req: Request): Promise<any>;
+    getFilterMatch(req: Request, searchOrFilter: any): Promise<any>;
+}

package/dist/Datatable/Datatable.js

@@ -0,0 +1,312 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Datatable = void 0;
+const DBConnection_1 = require("../Database/DBConnection");
+const NumericFunctions_1 = require("../Functions/NumericFunctions");
+class Datatable {
+    constructor() {
+        this.collection = "";
+        this.aggregation = null;
+        this.subAggregation = null;
+        this.filter = null;
+        this.columns = null;
+        this.onPressLink = null;
+        this.exports = null;
+        this.perPage = 25;
+    }
+    getInit(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const out = { table: req.body._table };
+            const promises = [];
+            promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                out.filter = yield this.getFilter(req);
+                resolve(true);
+            })));
+            promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                const cols = [];
+                const colsData = yield this.getColumns(req);
+                if (colsData && Object.keys(colsData).length > 0) {
+                    for (let i in colsData) {
+                        cols.push(Object.assign(Object.assign({}, colsData[i]), { key: i }));
+                    }
+                }
+                out.columns = cols;
+                resolve(true);
+            })));
+            promises.push(new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                out.onPressLink = yield this.getOnPressLink(req);
+                resolve(true);
+            })));
+            if (this.exports) {
+                out.export_definitions = [];
+                for (let key in this.exports) {
+                    out.export_definitions.push({
+                        key: key,
+                        title: this.exports[key].title,
+                        contentType: this.exports[key].contentType,
+                    });
+                }
+            }
+            yield Promise.all(promises);
+            return out;
+        });
+    }
+    getAggregation(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typeof this.aggregation === "function" ? yield this.aggregation(req) : this.aggregation;
+        });
+    }
+    getSubAggregation(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typeof this.subAggregation === "function" ? yield this.subAggregation(req) : this.subAggregation;
+        });
+    }
+    getCollection(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.collection && typeof this.collection === "function") {
+                return yield this.collection(req);
+            }
+            return this.collection;
+        });
+    }
+    getData(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const page = req.body.page && parseInt(req.body.page) > 0 ? parseInt(req.body.page) : 0;
+            const aggregation = [];
+            const aggregationStats = [];
+            const aggregationDef = yield this.getAggregation(req);
+            const subAggregation = [];
+            const subAggregationDef = yield this.getSubAggregation(req);
+            let hasSkip = false;
+            let hasLimit = false;
+            if (aggregationDef && aggregationDef.length > 0) {
+                for (let entry of aggregationDef) {
+                    if (entry.$skip !== undefined) {
+                        hasSkip = true;
+                    }
+                    if (entry.$limit !== undefined) {
+                        hasLimit = true;
+                    }
+                    if (entry.skipStats) {
+                        delete entry.skipStats;
+                        aggregation.push(entry);
+                    }
+                    else {
+                        aggregation.push(entry);
+                        aggregationStats.push(entry);
+                    }
+                }
+            }
+            if (subAggregationDef && subAggregationDef.length > 0) {
+                for (let entry of subAggregationDef) {
+                    if (entry.$skip !== undefined) {
+                        hasSkip = true;
+                    }
+                    if (entry.$limit !== undefined) {
+                        hasLimit = true;
+                    }
+                    if (entry.skipStats) {
+                        delete entry.skipStats;
+                        subAggregation.push(entry);
+                    }
+                    else {
+                        subAggregation.push(entry);
+                        aggregationStats.push(entry);
+                    }
+                }
+            }
+            const connection = yield DBConnection_1.DBConnection.getConnection();
+            const results = yield connection.client
+                .db(null)
+                .collection(yield this.getCollection(req))
+                .aggregate([
+                ...(aggregation ? aggregation : []),
+                ...(!hasSkip ? [{ $skip: page ? page * this.perPage : 0 }] : []),
+                ...(!hasLimit ? [{ $limit: this.perPage }] : []),
+                ...(subAggregation ? subAggregation : []),
+            ], {
+                collation: {
+                    locale: "de",
+                    strength: 2,
+                },
+            })
+                .toArray();
+            const statsGroup = { $group: { _id: null, count: { $sum: 1 } } };
+            if (req.body.sums && Object.keys(req.body.sums).length > 0) {
+                for (let key in req.body.sums) {
+                    if (req.body.sums[key] && req.body.sums[key].mapping) {
+                        statsGroup.$group["sum_" + req.body.sums[key].mapping] = { $sum: "$" + req.body.sums[key].mapping };
+                    }
+                }
+            }
+            const stats = yield connection.client
+                .db(null)
+                .collection(yield this.getCollection(req))
+                .aggregate([...(aggregationStats ? aggregationStats : []), statsGroup])
+                .toArray();
+            if (this.onRow || this.onAttributes) {
+                for (let i in results) {
+                    if (this.onRow) {
+                        results[i] = yield this.onRow(results[i]);
+                    }
+                    if (this.onAttributes) {
+                        results[i].__cellattr = yield this.onAttributes(results[i]);
+                    }
+                }
+            }
+            const sums = {};
+            if (req.body.sums && Object.keys(req.body.sums).length > 0) {
+                for (let key in req.body.sums) {
+                    if (req.body.sums[key] && req.body.sums[key].mapping) {
+                        sums[req.body.sums[key].mapping] = Object.assign(Object.assign({}, req.body.sums[key]), { value: stats &&
+                                stats[0] &&
+                                stats[0]["sum_" + req.body.sums[key].mapping] !== undefined &&
+                                stats[0]["sum_" + req.body.sums[key].mapping] !== null
+                                ? NumericFunctions_1.NumericFunctions.numberFormat(stats[0]["sum_" + req.body.sums[key].mapping]) +
+                                    (req.body.sums[key].suffix ? req.body.sums[key].suffix : "")
+                                : undefined });
+                    }
+                }
+            }
+            return {
+                page: page,
+                max_entries: stats && stats[0] && stats[0].count ? stats[0].count : 0,
+                total_pages: stats && stats[0] && stats[0].count > 0 ? Math.ceil(stats[0].count / this.perPage) : 0,
+                entries: results,
+                sums: sums,
+            };
+        });
+    }
+    getTotalData(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const aggregation = [];
+            const aggregationDef = yield this.getAggregation(req);
+            if (aggregationDef && aggregationDef.length > 0) {
+                for (let entry of aggregationDef) {
+                    if (entry.skipStats) {
+                        delete entry.skipStats;
+                        aggregation.push(entry);
+                    }
+                }
+            }
+            const connection = yield DBConnection_1.DBConnection.getConnection();
+            return yield connection.client
+                .db(null)
+                .collection(yield this.getCollection(req))
+                .aggregate([...(aggregation ? aggregation : [])])
+                .toArray();
+        });
+    }
+    getFilter(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.filter) {
+                return null;
+            }
+            if (typeof this.filter === "function") {
+                return yield this.filter(req);
+            }
+            return this.filter;
+        });
+    }
+    getColumns(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.columns) {
+                return null;
+            }
+            if (typeof this.columns === "function") {
+                return yield this.columns(req);
+            }
+            return this.columns;
+        });
+    }
+    getOnPressLink(req) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.onPressLink) {
+                return null;
+            }
+            if (typeof this.onPressLink === "function") {
+                return yield this.onPressLink(req);
+            }
+            return this.onPressLink;
+        });
+    }
+    getFilterMatch(req, searchOrFilter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!searchOrFilter || Object.keys(searchOrFilter).length < 1) {
+                return {};
+            }
+            const filterDef = yield this.getFilter(req);
+            const out = {};
+            for (let key in searchOrFilter) {
+                let value = undefined;
+                const entry = searchOrFilter[key];
+                const valueClean = entry.value !== undefined && entry.value !== "" ? entry.value : undefined;
+                const operator = entry.operator && entry.operator.trim() !== ""
+                    ? entry.operator
+                    : entry.mode && entry.mode.trim() !== ""
+                        ? entry.mode
+                        : "==";
+                const filterEl = filterDef && filterDef[key] ? filterDef[key] : null;
+                const entryType = entry.type && entry.type.trim() !== "" ? entry.type : filterEl && filterEl.type ? filterEl.type : null;
+                switch (operator) {
+                    case "empty":
+                        value = null;
+                        break;
+                    case "not_empty":
+                        value = { $ne: null };
+                        break;
+                    case "==":
+                        value = valueClean;
+                        break;
+                    case "!=":
+                        if (valueClean !== undefined) {
+                            value = { $ne: valueClean };
+                        }
+                        break;
+                    case "$gt":
+                    case "$gte":
+                    case "$lt":
+                    case "$lte":
+                        if (valueClean !== undefined) {
+                            value = {
+                                [operator]: entryType === "number" || entryType === "numeric" ? parseFloat(valueClean) : valueClean,
+                            };
+                        }
+                        break;
+                    default:
+                        if (valueClean !== undefined) {
+                            if (entryType === "number" || entryType === "numeric" || entryType === "currency") {
+                                value = parseFloat(valueClean.toString().replace(",", "."));
+                            }
+                            else if (entryType === "boolean") {
+                                if (entry.value === "true") {
+                                    value = true;
+                                }
+                                else if (entry.value === "false") {
+                                    value = false;
+                                }
+                            }
+                            else {
+                                value = new RegExp(valueClean, "i");
+                            }
+                        }
+                        break;
+                }
+                if (value !== undefined) {
+                    out[key] = value;
+                }
+            }
+            return out;
+        });
+    }
+}
+exports.Datatable = Datatable;

package/dist/Datatable/DatatableController.d.ts

@@ -0,0 +1,7 @@
+import { Controller } from "../Controller/Controller";
+import { Request } from "../Router/Request";
+import { Response } from "../Router/Response";
+export declare class DatatableController extends Controller {
+    restApi(req: Request, res: Response): Promise<Response>;
+    tableExport(req: Request, res: Response): Promise<Response>;
+}

package/dist/Datatable/DatatableController.js

@@ -0,0 +1,94 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatatableController = void 0;
+const Controller_1 = require("../Controller/Controller");
+const DatatableRegistry_1 = require("./DatatableRegistry");
+class DatatableController extends Controller_1.Controller {
+    restApi(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!req.body._table || req.body._table.trim() === "") {
+                return res.status(404).send({
+                    status: "error",
+                    message: "Missing table-key ...",
+                });
+            }
+            const tableClass = DatatableRegistry_1.DatatableRegistry.getTable(req.body._table);
+            if (!tableClass) {
+                return res.status(404).send({
+                    status: "error",
+                    message: "Table '" + req.body._table + "' not found ...",
+                });
+            }
+            if (req.body.init_request) {
+                const table = new tableClass();
+                return res.send({
+                    status: "success",
+                    data: yield table.getInit(req),
+                });
+            }
+            if (!req.body._table || req.body._table.trim() === "") {
+                return res.status(404).send({
+                    status: "error",
+                    message: "Missing table-key ...",
+                });
+            }
+            const table = new tableClass();
+            return res.send({
+                status: "success",
+                data: yield table.getData(req),
+            });
+        });
+    }
+    tableExport(req, res) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!req.body._table || req.body._table.trim() === "") {
+                return res.status(404).send({
+                    status: "error",
+                    message: "Missing table-key ...",
+                });
+            }
+            const tableClass = DatatableRegistry_1.DatatableRegistry.getTable(req.body._table);
+            if (!tableClass) {
+                return res.status(404).send({
+                    status: "error",
+                    message: "Table '" + req.body._table + "' not found ...",
+                });
+            }
+            const table = new tableClass();
+            if (!req.body.export || !table.exports || (table.exports && !table.exports[req.body.export])) {
+                return res.status(404).send({
+                    status: "error",
+                    message: "Unknown export-type ...",
+                });
+            }
+            const exp = table.exports[req.body.export];
+            const cols = [];
+            const colsData = yield table.getColumns(req);
+            if (colsData && Object.keys(colsData).length > 0) {
+                for (let i in colsData) {
+                    cols.push(Object.assign(Object.assign({}, colsData[i]), { key: i }));
+                }
+            }
+            const entries = yield table.getTotalData(req);
+            const exportData = yield exp.generate(entries, cols, req);
+            const base64 = Buffer.from("\uFEFF" + exportData).toString("base64");
+            return res.send({
+                status: "success",
+                data: {
+                    filename: exp.filename ? (typeof exp.filename === "function" ? yield exp.filename(req) : exp.filename) : "Export",
+                    base64: (exp.contentType ? exp.contentType + ";base64," : "") + base64,
+                },
+            });
+        });
+    }
+}
+exports.DatatableController = DatatableController;

package/dist/Datatable/DatatableRegistry.d.ts

@@ -0,0 +1,8 @@
+declare class DatatableRegistryWrapper {
+    tables: any;
+    register(key: string, tableClass: any): this;
+    registerMany(data: any): this;
+    getTable(key: string): any;
+}
+export declare const DatatableRegistry: DatatableRegistryWrapper;
+export {};

package/dist/Datatable/DatatableRegistry.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatatableRegistry = void 0;
+class DatatableRegistryWrapper {
+    constructor() {
+        this.tables = {};
+    }
+    register(key, tableClass) {
+        this.tables[key] = tableClass;
+        return this;
+    }
+    registerMany(data) {
+        if (typeof data === "object") {
+            for (let key in data) {
+                this.register(key, data[key]);
+            }
+        }
+        return this;
+    }
+    getTable(key) {
+        return this.tables[key] ? this.tables[key] : null;
+    }
+}
+exports.DatatableRegistry = new DatatableRegistryWrapper();

package/dist/LambdaApplication.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LambdaApplication = void 0;
 const Config_1 = require("./Config");
+const DatatableRegistry_1 = require("./Datatable/DatatableRegistry");
 const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 const Router_1 = require("./Router/Router");
 class LambdaApplication {
@@ -21,6 +22,9 @@ class LambdaApplication {
             routesFunction: options && options.routesFunction ? options.routesFunction : null,
             tempDir: options && options.tempDir ? options.tempDir : null,
         });
+        if (options && options.datatables) {
+            DatatableRegistry_1.DatatableRegistry.registerMany(options.datatables);
+        }
         if (options.jobs && options.jobs.length > 0) {
             QueueJobsRegisty_1.QueueJobsRegisty.registerJob(options.jobs);
         }

package/dist/WebApplication.js

@@ -8,6 +8,7 @@ const http_1 = __importDefault(require("http"));
 const Config_1 = require("./Config");
 const Router_1 = require("./Router/Router");
 const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
+const DatatableRegistry_1 = require("./Datatable/DatatableRegistry");
 class WebApplication {
     /**
      * Init the routes and start the http-server
@@ -25,6 +26,9 @@ class WebApplication {
             routesFunction: options && options.routesFunction ? options.routesFunction : null,
             tempDir: options && options.tempDir ? options.tempDir : null,
         });
+        if (options && options.datatables) {
+            DatatableRegistry_1.DatatableRegistry.registerMany(options.datatables);
+        }
         if (options.jobs && options.jobs.length > 0) {
             QueueJobsRegisty_1.QueueJobsRegisty.registerJob(options.jobs);
         }

package/dist/index.d.ts

@@ -22,6 +22,9 @@ export * from "./Facades/StorageDrivers/BaseStorageDriver";
 export * from "./Facades/Storage";
 export * from "./DataBuilder/DataBuilder";
 export * from "./DataBuilder/DataBuilderController";
+export * from "./Datatable/Datatable";
+export * from "./Datatable/DatatableRegistry";
+export * from "./Datatable/DatatableController";
 export * from "./Queue/BaseQueueJob";
 export * from "./Queue/QueueJob";
 export * from "./Queue/QueueJobsRegisty";

package/dist/index.js

@@ -38,6 +38,9 @@ __exportStar(require("./Facades/StorageDrivers/BaseStorageDriver"), exports);
 __exportStar(require("./Facades/Storage"), exports);
 __exportStar(require("./DataBuilder/DataBuilder"), exports);
 __exportStar(require("./DataBuilder/DataBuilderController"), exports);
+__exportStar(require("./Datatable/Datatable"), exports);
+__exportStar(require("./Datatable/DatatableRegistry"), exports);
+__exportStar(require("./Datatable/DatatableController"), exports);
 __exportStar(require("./Queue/BaseQueueJob"), exports);
 __exportStar(require("./Queue/QueueJob"), exports);
 __exportStar(require("./Queue/QueueJobsRegisty"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.2.8",
+    "version": "0.2.10",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",

package/src/ConsoleApplication.ts

@@ -3,6 +3,7 @@ import { Config } from "./Config";
 import { BuildFinishCommand } from "./Commands/BuildFinishCommand";
 import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
 import { QueueRunCommand } from "./Commands/QueueRunCommand";
+import { DatatableRegistry } from "./Datatable/DatatableRegistry";
 
 export class ConsoleApplication {
     /**
@@ -58,6 +59,10 @@ export class ConsoleApplication {
             }
         }
 
+        if (options && options.datatables) {
+            DatatableRegistry.registerMany(options.datatables);
+        }
+
         if (options.jobs && options.jobs.length > 0) {
             QueueJobsRegisty.registerJob(options.jobs);
         }

package/src/Datatable/Datatable.ts

@@ -0,0 +1,322 @@
+import { DBConnection } from "../Database/DBConnection";
+import { NumericFunctions } from "../Functions/NumericFunctions";
+import { Request } from "../Router/Request";
+
+export class Datatable {
+    collection: string | Function = "";
+    aggregation: { [key: string]: any } | Function | null = null;
+    subAggregation: { [key: string]: any } | Function | null = null;
+    filter: { [key: string]: any } | Function | null = null;
+    columns: { [key: string]: any } | Function | null = null;
+    onPressLink: string | Function | null = null;
+    exports: any | null = null;
+    perPage: number = 25;
+    onRow?: Function;
+    onAttributes?: Function;
+
+    async getInit(req: Request) {
+        const out: any = { table: req.body._table };
+        const promises = [];
+        promises.push(
+            new Promise(async (resolve) => {
+                out.filter = await this.getFilter(req);
+                resolve(true);
+            })
+        );
+        promises.push(
+            new Promise(async (resolve) => {
+                const cols: any = [];
+                const colsData = await this.getColumns(req);
+                if (colsData && Object.keys(colsData).length > 0) {
+                    for (let i in colsData) {
+                        cols.push({ ...colsData[i], key: i });
+                    }
+                }
+                out.columns = cols;
+                resolve(true);
+            })
+        );
+        promises.push(
+            new Promise(async (resolve) => {
+                out.onPressLink = await this.getOnPressLink(req);
+                resolve(true);
+            })
+        );
+
+        if (this.exports) {
+            out.export_definitions = [];
+
+            for (let key in this.exports) {
+                out.export_definitions.push({
+                    key: key,
+                    title: this.exports[key].title,
+                    contentType: this.exports[key].contentType,
+                });
+            }
+        }
+
+        await Promise.all(promises);
+        return out;
+    }
+
+    async getAggregation(req: Request) {
+        return typeof this.aggregation === "function" ? await this.aggregation(req) : this.aggregation;
+    }
+
+    async getSubAggregation(req: Request) {
+        return typeof this.subAggregation === "function" ? await this.subAggregation(req) : this.subAggregation;
+    }
+
+    async getCollection(req: Request) {
+        if (this.collection && typeof this.collection === "function") {
+            return await this.collection(req);
+        }
+        return this.collection;
+    }
+
+    async getData(req: Request) {
+        const page = req.body.page && parseInt(req.body.page) > 0 ? parseInt(req.body.page) : 0;
+        const aggregation: any = [];
+        const aggregationStats: any = [];
+        const aggregationDef = await this.getAggregation(req);
+        const subAggregation: any = [];
+        const subAggregationDef = await this.getSubAggregation(req);
+        let hasSkip = false;
+        let hasLimit = false;
+
+        if (aggregationDef && aggregationDef.length > 0) {
+            for (let entry of aggregationDef) {
+                if (entry.$skip !== undefined) {
+                    hasSkip = true;
+                }
+                if (entry.$limit !== undefined) {
+                    hasLimit = true;
+                }
+
+                if (entry.skipStats) {
+                    delete entry.skipStats;
+                    aggregation.push(entry);
+                } else {
+                    aggregation.push(entry);
+                    aggregationStats.push(entry);
+                }
+            }
+        }
+
+        if (subAggregationDef && subAggregationDef.length > 0) {
+            for (let entry of subAggregationDef) {
+                if (entry.$skip !== undefined) {
+                    hasSkip = true;
+                }
+                if (entry.$limit !== undefined) {
+                    hasLimit = true;
+                }
+
+                if (entry.skipStats) {
+                    delete entry.skipStats;
+                    subAggregation.push(entry);
+                } else {
+                    subAggregation.push(entry);
+                    aggregationStats.push(entry);
+                }
+            }
+        }
+
+        const connection = await DBConnection.getConnection();
+        const results = await connection.client
+            .db(null)
+            .collection(await this.getCollection(req))
+            .aggregate(
+                [
+                    ...(aggregation ? aggregation : []),
+                    ...(!hasSkip ? [{ $skip: page ? page * this.perPage : 0 }] : []),
+                    ...(!hasLimit ? [{ $limit: this.perPage }] : []),
+                    ...(subAggregation ? subAggregation : []),
+                ],
+                {
+                    collation: {
+                        locale: "de",
+                        strength: 2,
+                    },
+                }
+            )
+            .toArray();
+
+        const statsGroup: any = { $group: { _id: null, count: { $sum: 1 } } };
+        if (req.body.sums && Object.keys(req.body.sums).length > 0) {
+            for (let key in req.body.sums) {
+                if (req.body.sums[key] && req.body.sums[key].mapping) {
+                    statsGroup.$group["sum_" + req.body.sums[key].mapping] = { $sum: "$" + req.body.sums[key].mapping };
+                }
+            }
+        }
+
+        const stats = await connection.client
+            .db(null)
+            .collection(await this.getCollection(req))
+            .aggregate([...(aggregationStats ? aggregationStats : []), statsGroup])
+            .toArray();
+
+        if (this.onRow || this.onAttributes) {
+            for (let i in results) {
+                if (this.onRow) {
+                    results[i] = await this.onRow(results[i]);
+                }
+
+                if (this.onAttributes) {
+                    results[i].__cellattr = await this.onAttributes(results[i]);
+                }
+            }
+        }
+
+        const sums: any = {};
+        if (req.body.sums && Object.keys(req.body.sums).length > 0) {
+            for (let key in req.body.sums) {
+                if (req.body.sums[key] && req.body.sums[key].mapping) {
+                    sums[req.body.sums[key].mapping] = {
+                        ...req.body.sums[key],
+                        value:
+                            stats &&
+                            stats[0] &&
+                            stats[0]["sum_" + req.body.sums[key].mapping] !== undefined &&
+                            stats[0]["sum_" + req.body.sums[key].mapping] !== null
+                                ? NumericFunctions.numberFormat(stats[0]["sum_" + req.body.sums[key].mapping]) +
+                                  (req.body.sums[key].suffix ? req.body.sums[key].suffix : "")
+                                : undefined,
+                    };
+                }
+            }
+        }
+
+        return {
+            page: page,
+            max_entries: stats && stats[0] && stats[0].count ? stats[0].count : 0,
+            total_pages: stats && stats[0] && stats[0].count > 0 ? Math.ceil(stats[0].count / this.perPage) : 0,
+            entries: results,
+            sums: sums,
+        };
+    }
+
+    async getTotalData(req: Request) {
+        const aggregation: any = [];
+        const aggregationDef = await this.getAggregation(req);
+
+        if (aggregationDef && aggregationDef.length > 0) {
+            for (let entry of aggregationDef) {
+                if (entry.skipStats) {
+                    delete entry.skipStats;
+                    aggregation.push(entry);
+                }
+            }
+        }
+
+        const connection = await DBConnection.getConnection();
+        return await connection.client
+            .db(null)
+            .collection(await this.getCollection(req))
+            .aggregate([...(aggregation ? aggregation : [])])
+            .toArray();
+    }
+
+    async getFilter(req: Request) {
+        if (!this.filter) {
+            return null;
+        }
+
+        if (typeof this.filter === "function") {
+            return await this.filter(req);
+        }
+        return this.filter;
+    }
+
+    async getColumns(req: Request) {
+        if (!this.columns) {
+            return null;
+        }
+
+        if (typeof this.columns === "function") {
+            return await this.columns(req);
+        }
+        return this.columns;
+    }
+
+    async getOnPressLink(req: Request) {
+        if (!this.onPressLink) {
+            return null;
+        }
+
+        if (typeof this.onPressLink === "function") {
+            return await this.onPressLink(req);
+        }
+        return this.onPressLink;
+    }
+
+    async getFilterMatch(req: Request, searchOrFilter: any) {
+        if (!searchOrFilter || Object.keys(searchOrFilter).length < 1) {
+            return {};
+        }
+
+        const filterDef = await this.getFilter(req);
+        const out: any = {};
+        for (let key in searchOrFilter) {
+            let value: any = undefined;
+
+            const entry = searchOrFilter[key];
+            const valueClean = entry.value !== undefined && entry.value !== "" ? entry.value : undefined;
+            const operator =
+                entry.operator && entry.operator.trim() !== ""
+                    ? entry.operator
+                    : entry.mode && entry.mode.trim() !== ""
+                    ? entry.mode
+                    : "==";
+            const filterEl = filterDef && filterDef[key] ? filterDef[key] : null;
+            const entryType = entry.type && entry.type.trim() !== "" ? entry.type : filterEl && filterEl.type ? filterEl.type : null;
+            switch (operator) {
+                case "empty":
+                    value = null;
+                    break;
+                case "not_empty":
+                    value = { $ne: null };
+                    break;
+                case "==":
+                    value = valueClean;
+                    break;
+                case "!=":
+                    if (valueClean !== undefined) {
+                        value = { $ne: valueClean };
+                    }
+                    break;
+                case "$gt":
+                case "$gte":
+                case "$lt":
+                case "$lte":
+                    if (valueClean !== undefined) {
+                        value = {
+                            [operator]: entryType === "number" || entryType === "numeric" ? parseFloat(valueClean) : valueClean,
+                        };
+                    }
+                    break;
+                default:
+                    if (valueClean !== undefined) {
+                        if (entryType === "number" || entryType === "numeric" || entryType === "currency") {
+                            value = parseFloat(valueClean.toString().replace(",", "."));
+                        } else if (entryType === "boolean") {
+                            if (entry.value === "true") {
+                                value = true;
+                            } else if (entry.value === "false") {
+                                value = false;
+                            }
+                        } else {
+                            value = new RegExp(valueClean, "i");
+                        }
+                    }
+                    break;
+            }
+
+            if (value !== undefined) {
+                out[key] = value;
+            }
+        }
+        return out;
+    }
+}

package/src/Datatable/DatatableController.ts

@@ -0,0 +1,90 @@
+import { Controller } from "../Controller/Controller";
+import { Request } from "../Router/Request";
+import { Response } from "../Router/Response";
+import { DatatableRegistry } from "./DatatableRegistry";
+
+export class DatatableController extends Controller {
+    async restApi(req: Request, res: Response) {
+        if (!req.body._table || req.body._table.trim() === "") {
+            return res.status(404).send({
+                status: "error",
+                message: "Missing table-key ...",
+            });
+        }
+
+        const tableClass = DatatableRegistry.getTable(req.body._table);
+        if (!tableClass) {
+            return res.status(404).send({
+                status: "error",
+                message: "Table '" + req.body._table + "' not found ...",
+            });
+        }
+
+        if (req.body.init_request) {
+            const table = new tableClass();
+            return res.send({
+                status: "success",
+                data: await table.getInit(req),
+            });
+        }
+
+        if (!req.body._table || req.body._table.trim() === "") {
+            return res.status(404).send({
+                status: "error",
+                message: "Missing table-key ...",
+            });
+        }
+
+        const table = new tableClass();
+        return res.send({
+            status: "success",
+            data: await table.getData(req),
+        });
+    }
+
+    async tableExport(req: Request, res: Response) {
+        if (!req.body._table || req.body._table.trim() === "") {
+            return res.status(404).send({
+                status: "error",
+                message: "Missing table-key ...",
+            });
+        }
+
+        const tableClass = DatatableRegistry.getTable(req.body._table);
+        if (!tableClass) {
+            return res.status(404).send({
+                status: "error",
+                message: "Table '" + req.body._table + "' not found ...",
+            });
+        }
+
+        const table = new tableClass();
+        if (!req.body.export || !table.exports || (table.exports && !table.exports[req.body.export])) {
+            return res.status(404).send({
+                status: "error",
+                message: "Unknown export-type ...",
+            });
+        }
+
+        const exp = table.exports[req.body.export];
+        const cols: any = [];
+        const colsData = await table.getColumns(req);
+        if (colsData && Object.keys(colsData).length > 0) {
+            for (let i in colsData) {
+                cols.push({ ...colsData[i], key: i });
+            }
+        }
+
+        const entries = await table.getTotalData(req);
+        const exportData = await exp.generate(entries, cols, req);
+        const base64 = Buffer.from("\uFEFF" + exportData).toString("base64");
+
+        return res.send({
+            status: "success",
+            data: {
+                filename: exp.filename ? (typeof exp.filename === "function" ? await exp.filename(req) : exp.filename) : "Export",
+                base64: (exp.contentType ? exp.contentType + ";base64," : "") + base64,
+            },
+        });
+    }
+}

package/src/Datatable/DatatableRegistry.ts

@@ -0,0 +1,22 @@
+class DatatableRegistryWrapper {
+    tables: any = {};
+
+    register(key: string, tableClass: any) {
+        this.tables[key] = tableClass;
+        return this;
+    }
+
+    registerMany(data: any) {
+        if (typeof data === "object") {
+            for (let key in data) {
+                this.register(key, data[key]);
+            }
+        }
+        return this;
+    }
+
+    getTable(key: string) {
+        return this.tables[key] ? this.tables[key] : null;
+    }
+}
+export const DatatableRegistry = new DatatableRegistryWrapper();

package/src/LambdaApplication.ts

@@ -1,4 +1,5 @@
 import { Config } from "./Config";
+import { DatatableRegistry } from "./Datatable/DatatableRegistry";
 import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
 import { Router } from "./Router/Router";
 
@@ -21,6 +22,10 @@ export class LambdaApplication {
             tempDir: options && options.tempDir ? options.tempDir : null,
         });
 
+        if (options && options.datatables) {
+            DatatableRegistry.registerMany(options.datatables);
+        }
+
         if (options.jobs && options.jobs.length > 0) {
             QueueJobsRegisty.registerJob(options.jobs);
         }

package/src/WebApplication.ts

@@ -2,6 +2,7 @@ import http, { Server } from "http";
 import { Config } from "./Config";
 import { Router } from "./Router/Router";
 import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
+import { DatatableRegistry } from "./Datatable/DatatableRegistry";
 
 export class WebApplication {
     private server!: Server;
@@ -24,6 +25,10 @@ export class WebApplication {
             tempDir: options && options.tempDir ? options.tempDir : null,
         });
 
+        if (options && options.datatables) {
+            DatatableRegistry.registerMany(options.datatables);
+        }
+
         if (options.jobs && options.jobs.length > 0) {
             QueueJobsRegisty.registerJob(options.jobs);
         }

package/src/index.ts

@@ -22,6 +22,9 @@ export * from "./Facades/StorageDrivers/BaseStorageDriver";
 export * from "./Facades/Storage";
 export * from "./DataBuilder/DataBuilder";
 export * from "./DataBuilder/DataBuilderController";
+export * from "./Datatable/Datatable";
+export * from "./Datatable/DatatableRegistry";
+export * from "./Datatable/DatatableController";
 export * from "./Queue/BaseQueueJob";
 export * from "./Queue/QueueJob";
 export * from "./Queue/QueueJobsRegisty";