@michalrakus/x-react-web-lib 1.28.0 → 1.30.0

package/lib/serverApi/FindParam.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XAggregateType = exports.ResultType = void 0;
+exports.XAggregateFunction = exports.ResultType = void 0;
 // TODO - replaced with DataTableFilterMetaData
 // export interface FilterValue {
 //     value : string;
@@ -22,10 +22,10 @@ var ResultType;
     ResultType[ResultType["RowCountAndPagedRows"] = 2] = "RowCountAndPagedRows";
     ResultType[ResultType["AllRows"] = 3] = "AllRows";
 })(ResultType = exports.ResultType || (exports.ResultType = {}));
-var XAggregateType;
-(function (XAggregateType) {
-    XAggregateType["Min"] = "MIN";
-    XAggregateType["Max"] = "MAX";
-    XAggregateType["Sum"] = "SUM";
-    XAggregateType["Avg"] = "AVG";
-})(XAggregateType = exports.XAggregateType || (exports.XAggregateType = {}));
+var XAggregateFunction;
+(function (XAggregateFunction) {
+    XAggregateFunction["Min"] = "MIN";
+    XAggregateFunction["Max"] = "MAX";
+    XAggregateFunction["Sum"] = "SUM";
+    XAggregateFunction["Avg"] = "AVG";
+})(XAggregateFunction = exports.XAggregateFunction || (exports.XAggregateFunction = {}));

package/lib/serverApi/XUtilsCommon.d.ts

@@ -1,4 +1,6 @@
 import { XEntity, XField } from "./XEntityMetadata";
+import { XCustomFilter, XCustomFilterItem } from "./FindParam";
+import { DataTableSortMeta } from "primereact/datatable";
 export declare class XUtilsCommon {
     static newLine: string;
     static getValueByPath(object: any, path: string): any;
@@ -15,6 +17,33 @@ export declare class XUtilsCommon {
     static displayValueAsUI(prefix: string | null, value: any, xField: XField | undefined): string;
     static objectAsJSON(value: any): string;
     static arrayCreateMap<ID, T>(array: T[], idField: string): Map<ID, T>;
+    static arrayMoveElement(array: any[], position: number, offset: number): void;
+    static arraySort(array: any[], fieldOrValueFunction: string | ((item: any) => any)): any[];
+    /**
+     * returns true, if param item is member of the array
+     * remark: null/undefined items in array are ignored, item = null/undefined is ignored
+     *
+     * @param array
+     * @param item
+     * @param idField
+     */
+    static arrayIncludes<T>(array: T[], item: T, idField: string): boolean;
+    /**
+     * returns intersection of 2 row lists
+     * remark: null/undefined items in both array1 and array2 are ignored
+     *
+     * @param array1
+     * @param array2
+     * @param idField
+     */
+    static arrayIntersect<T>(array1: T[], array2: T[], idField: string): T[];
+    static createCustomFilter(filter: string | undefined | null): XCustomFilterItem | undefined;
+    static createCustomFilterItems(customFilter: XCustomFilter | undefined): XCustomFilterItem[] | undefined;
+    static createMultiSortMeta(sortField: string | DataTableSortMeta[] | undefined): DataTableSortMeta[] | undefined;
+    static filterAnd(...filters: (XCustomFilter | undefined)[]): XCustomFilterItem[] | undefined;
+    static filterIdIn(idField: string, idList: number[]): XCustomFilter;
+    static createPathFieldExp(pathFieldOrPathFieldExp: string): string;
+    static isPathField(pathFieldOrPathFieldExp: string): boolean;
     static getDayName(date: Date | null | undefined): string | undefined;
     static dateAddDays(date: Date | null, days: number): Date | null;
     static dateAddMonths(date: Date | null, months: number): Date | null;

package/lib/serverApi/XUtilsCommon.js

@@ -292,6 +292,171 @@ var XUtilsCommon = /** @class */ (function () {
         }
         return idRowMap;
     };
+    XUtilsCommon.arrayMoveElement = function (array, position, offset) {
+        var element = array[position];
+        array.splice(position, 1);
+        var positionNew = position + offset;
+        if (positionNew > array.length) {
+            positionNew = positionNew - array.length - 1; // element goes to the begin
+        }
+        else if (positionNew < 0) {
+            positionNew = array.length + positionNew + 1; // element goes to the end
+        }
+        if (positionNew >= 0 && positionNew <= array.length) {
+            array.splice(positionNew, 0, element);
+        }
+    };
+    XUtilsCommon.arraySort = function (array, fieldOrValueFunction) {
+        var valueFunction;
+        if (typeof fieldOrValueFunction === 'string') {
+            valueFunction = function (item) { return item[fieldOrValueFunction]; };
+        }
+        else {
+            valueFunction = fieldOrValueFunction;
+        }
+        return array.sort(function (suggestion1, suggestion2) {
+            var value1 = valueFunction(suggestion1);
+            var value2 = valueFunction(suggestion2);
+            if (value1 > value2) {
+                return 1;
+            }
+            else if (value1 < value2) {
+                return -1;
+            }
+            else {
+                return 0;
+            }
+        });
+    };
+    /**
+     * returns true, if param item is member of the array
+     * remark: null/undefined items in array are ignored, item = null/undefined is ignored
+     *
+     * @param array
+     * @param item
+     * @param idField
+     */
+    XUtilsCommon.arrayIncludes = function (array, item, idField) {
+        return item && array.some(function (arrayItem) { return arrayItem && arrayItem[idField] === item[idField]; });
+    };
+    /**
+     * returns intersection of 2 row lists
+     * remark: null/undefined items in both array1 and array2 are ignored
+     *
+     * @param array1
+     * @param array2
+     * @param idField
+     */
+    XUtilsCommon.arrayIntersect = function (array1, array2, idField) {
+        var e_5, _a;
+        var array2IdSet = new Set();
+        try {
+            for (var array2_1 = __values(array2), array2_1_1 = array2_1.next(); !array2_1_1.done; array2_1_1 = array2_1.next()) {
+                var item = array2_1_1.value;
+                if (item) {
+                    array2IdSet.add(item[idField]);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (array2_1_1 && !array2_1_1.done && (_a = array2_1.return)) _a.call(array2_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return array1.filter(function (item) { return item && array2IdSet.has(item[idField]); });
+    };
+    // ************* XCustomFilter/XCustomFilterItem/DataTableSortMeta **************
+    // pomocna metodka - aby sme nemuseli v kode vypisovat {where: <filter>, params: {}}
+    XUtilsCommon.createCustomFilter = function (filter) {
+        var customFilterItem = undefined;
+        if (filter) {
+            customFilterItem = { where: filter, params: {} };
+        }
+        return customFilterItem;
+    };
+    // pomocna metodka - konvertuje XCustomFilter -> XCustomFilterItem[]
+    XUtilsCommon.createCustomFilterItems = function (customFilter) {
+        var customFilterItems = undefined;
+        if (customFilter) {
+            if (Array.isArray(customFilter)) {
+                customFilterItems = customFilter;
+            }
+            else {
+                customFilterItems = [customFilter];
+            }
+        }
+        return customFilterItems;
+    };
+    // pomocna metodka - konvertuje sortField -> DataTableSortMeta[]
+    XUtilsCommon.createMultiSortMeta = function (sortField) {
+        var multiSortMeta = undefined;
+        if (sortField) {
+            if (Array.isArray(sortField)) {
+                multiSortMeta = sortField;
+            }
+            else {
+                // default order is asc, supported is also value in form "<column name> desc"
+                var order = 1;
+                var fieldAndOrder = sortField.split(' ');
+                if (fieldAndOrder.length === 2) {
+                    sortField = fieldAndOrder[0];
+                    if (fieldAndOrder[1].toLowerCase() === "desc") {
+                        order = -1;
+                    }
+                }
+                multiSortMeta = [{ field: sortField, order: order }];
+            }
+        }
+        return multiSortMeta;
+    };
+    // pomocna metodka
+    XUtilsCommon.filterAnd = function () {
+        var e_6, _a;
+        var filters = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            filters[_i] = arguments[_i];
+        }
+        var customFilterItemsResult = undefined;
+        if (filters.length > 0) {
+            customFilterItemsResult = [];
+            try {
+                for (var filters_1 = __values(filters), filters_1_1 = filters_1.next(); !filters_1_1.done; filters_1_1 = filters_1.next()) {
+                    var filter = filters_1_1.value;
+                    var customFilterItems = XUtilsCommon.createCustomFilterItems(filter);
+                    if (customFilterItems) {
+                        customFilterItemsResult.push.apply(customFilterItemsResult, __spreadArray([], __read(customFilterItems), false));
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (filters_1_1 && !filters_1_1.done && (_a = filters_1.return)) _a.call(filters_1);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+        return customFilterItemsResult;
+    };
+    // pomocna metodka
+    // ak je idList prazdny, vytvori podmienku id IN (0) a nevrati ziadne zaznamy
+    XUtilsCommon.filterIdIn = function (idField, idList) {
+        return { where: "[".concat(idField, "] IN (:...idList)"), params: { "idList": idList.length > 0 ? idList : [0] } };
+    };
+    // helper
+    XUtilsCommon.createPathFieldExp = function (pathFieldOrPathFieldExp) {
+        // if fieldOrPathFieldExp is only pathField (e.g. attrX or assocA.attrB) then make path field expression (enclose field into [])
+        if (XUtilsCommon.isPathField(pathFieldOrPathFieldExp)) {
+            pathFieldOrPathFieldExp = "[".concat(pathFieldOrPathFieldExp, "]");
+        }
+        return pathFieldOrPathFieldExp;
+    };
+    // helper
+    XUtilsCommon.isPathField = function (pathFieldOrPathFieldExp) {
+        return /^[a-zA-Z0-9_.]+$/.test(pathFieldOrPathFieldExp);
+    };
     XUtilsCommon.getDayName = function (date) {
         var days = ['nedeľa', 'pondelok', 'utorok', 'streda', 'štvrtok', 'piatok', 'sobota'];
         return date ? days[date.getDay()] : undefined;

package/lib/serverApi/XUtilsConversions.js

@@ -471,6 +471,12 @@ function convertValueBase(fieldType, scale, value, fromModel, asUI) {
             value = booleanAsUIText(value);
         }
     }
+    else if (fieldType === "jsonb") {
+        // konverziu z modelu (json objekt-u) netreba
+        if (asUI) {
+            value = XUtilsCommon_1.XUtilsCommon.objectAsJSON(value);
+        }
+    }
     else {
         // vsetko ostatne
         if (asUI && asUI !== AsUIType.Excel) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michalrakus/x-react-web-lib",
-  "version": "1.28.0",
+  "version": "1.30.0",
   "description": "",
   "scripts": {
     "clean": "rimraf lib",