strolch-wc-util-behavior/strolch-wc-util-behavior.html

<link rel="import" href="../polymer/polymer.html">

<script>

    // custom behaviour accessing the configuration above
    StrolchUtilBehaviorImpl = {

        /*
         * Strolch functions
         */
        hasQueryPrivilege: function (privilegeValue) {
            return Strolch.hasRole("StrolchAdmin") || Strolch.hasQueryPrivilege(privilegeValue);
        },
        hasSearchPrivilege: function (privilegeValue) {
            return Strolch.hasRole("StrolchAdmin") || Strolch.hasSearchPrivilege(privilegeValue);
        },
        hasServicePrivilege: function (privilegeValue) {
            return Strolch.hasRole("StrolchAdmin") || Strolch.hasServicePrivilege(privilegeValue);
        },
        hasPrivilege: function (privilege, value) {
            return Strolch.hasRole("StrolchAdmin") || Strolch.hasPrivilege(privilege, value);
        },
        hasRole: function (name) {
            return Strolch.hasRole("StrolchAdmin") || Strolch.hasRole(name);
        },
        hasFeatureRole: function (name) {
            return Strolch.hasRole(name);
        },
        hasAnyFeatureRole: function () {
            for (var i = 0; i < arguments.length; i++) {
                if (Strolch.hasRole(arguments[i]))
                    return true;
            }

            return false;
        },
        hasComponent: function (name) {
            return Strolch.hasComponent(name);
        },

        /*
         * Boolean functions
         */
        isDefined: function (arg0) {
            return arg0 != undefined;
        },
        isNull: function (arg0) {
            return arg0 == undefined || arg0 == null;
        },
        isNotNull: function (arg0) {
            return arg0 != undefined && arg0 != null;
        },
        isNaN: function (arg0) {
            return this.stringEmpty(arg0) || isNaN(arg0);
        },
        equal: function (arg0, arg1) {
            return arg0 == arg1;
        },
        isEqual: function (arg0, arg1) {
            return arg0 == arg1;
        },
        notEqual: function (arg0, arg1) {
            return arg0 != arg1;
        },
        defined: function (arg0) {
            return !!arg0;
        },
        greater: function (arg0, arg1) {
            return arg0 > arg1;
        },
        greaterEqual: function (arg0, arg1) {
            return arg0 >= arg1;
        },
        lesser: function (arg0, arg1) {
            return arg0 < arg1;
        },
        lesserEqual: function (arg0, arg1) {
            return arg0 <= arg1;
        },
        and: function (arg0, arg1) {
            return !!(arg0 && arg1);
        },
        or: function (arg0, arg1) {
            return !!(arg0 || arg1);
        },
        andMulti: function () {
            for (var i = 0; i < arguments.length; i++) {
                if (!arguments[i])
                    return false;
            }
            return true;
        },
        orMulti: function () {
            for (var i = 0; i < arguments.length; i++) {
                if (arguments[i])
                    return true;
            }
            return false;
        },

        //
        // Array functions
        //
        arrayToString: function (array) {
            if (array == null || array.length === 0)
                return "";
            return array.join(", ");
        },
        arrayLength: function (array) {
            return array != null ? array.length : 0;
        },
        arrayFilled: function (array) {
            return array != null && array.length > 0;
        },
        arrayEmpty: function (array) {
            return array == null || array.length === 0;
        },
        arraySizeLessThan: function (array, size) {
            return array != null && array.length < size;
        },
        arraySizeGreaterThanOrEq: function (array, size) {
            return array != null && array.length >= size;
        },
        arrayEquals: function (array1, array2) {
            if (array1 == null && array2 == null)
                return true;
            if (array1 == null && array2 != null)
                return false;
            if (array2 == null && array1 != null)
                return false;
            return (array1.length === array2.length) && array1.every(function (element, index) {
                return element === array2[index];
            });
        },
        stringToArray: function (string) {
            if (string === null || string.length === 0)
                return [];
            var a = [];
            var b = string.split(",");
            for (var i = 0; i < b.length; i++) {
                a.push(b[i].trim());
            }
            return a;
        },
        stringArrayLength: function (string) {
            if (string === null || string.length === 0)
                return 0;
            return string.split(",").length;
        },

        //
        // String functions
        //
        stringOrEmpty: function (e) {
            return e === null || e === undefined ? "" : e;
        },
        stringEmpty: function () {
            for (var i in arguments) {
                var arg = arguments[i];
                if (!arg || arg.length === 0) return true;
            }
            return false;
        },
        isEmptyString: function (val) {
            return typeof val == "undefined" || val == null || val === "";
        },
        isNotEmptyString: function (val) {
            return !this.isEmptyString(val);
        },
        formatVerbatimToHtml: function (s) {
            if (s == null || s.length === 0)
                return "";
            return s.replace(/\n/g, "<br/>").replace(/ /g, "&nbsp;");
        },
        pad10: function (i) {
            if (i < 10) return "0" + i;
            return i;
        },
        pad100: function (i) {
            if (i < 10) return "00" + i;
            if (i < 100) return "0" + i;
            return i;
        },

        //
        // Math functions
        //
        add: function (arg0, arg1) {
            return Number(arg0) + Number(arg1);
        },
        sub: function (arg0, arg1) {
            return Number(arg0) - Number(arg1);
        },
        round: function (value) {
            return Math.round(value * 1000) / 1000;
        },

        /**
         * Decimal adjustment of a number.
         *
         * @param {String}  type  The type of adjustment.
         * @param {Number}  value The number.
         * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
         * @returns {Number} The adjusted value.
         */
        _decimalAdjust: function (type, value, exp) {
            // If the exp is undefined or zero...
            if (typeof exp === "undefined" || +exp === 0) {
                return Math[type](value);
            }
            value = +value;
            exp = +exp;
            // If the value is not a number or the exp is not an integer...
            if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
                return NaN;
            }
            // Shift
            value = value.toString().split("e");
            value = Math[type](+(value[0] + "e" + (value[1] ? (+value[1] - exp) : -exp)));
            // Shift back
            value = value.toString().split("e");
            return +(value[0] + "e" + (value[1] ? (+value[1] + exp) : exp));
        },

        // Decimal round
        round10: function (value, exp) {
            return this._decimalAdjust("round", value, exp);
        },
        // Decimal floor
        floor10: function (value, exp) {
            return this._decimalAdjust("floor", value, exp);
        },
        // Decimal ceil
        ceil10: function (value, exp) {
            return this._decimalAdjust("ceil", value, exp);
        },

        //
        // i18n functions
        //
        hasMsg: function (value) {
            return this.isNotEmptyString(value) && value !== "-";
        },
        localizeJsonMsg: function (jsonMsg) {
            if (jsonMsg == null)
                return jsonMsg;
            if (this.localize == null)
                return jsonMsg.message;
            if (jsonMsg.values == null || jsonMsg.values.length === 0)
                return this.localize(jsonMsg.key);

            var values = [jsonMsg.key];
            var keys = Object.keys(jsonMsg.values);
            for (var i = 0; i < keys.length; i++) {
                var key = keys[i];
                values.push(key);
                values.push(jsonMsg.values[key]);
            }
            return this.localize.apply(null, values);
        },

        //
        // Browser check functions
        //
        isChrome: function () {
            var isChromium = window.chrome, //
                winNav = window.navigator, //
                vendorName = winNav.vendor, //
                isOpera = winNav.userAgent.indexOf("OPR") > -1, //
                isIEedge = winNav.userAgent.indexOf("Edge") > -1, //
                isIOSChrome = winNav.userAgent.match("CriOS");

            if (isIOSChrome) {
                return true;
            } else if (isChromium !== null && //
                typeof isChromium !== "undefined" && //
                vendorName === "Google Inc." && //
                isOpera === false && //
                isIEedge === false) {
                return true;
            } else {
                return false;
            }
        },
        isFirefox: function () {
            return navigator.userAgent.toLowerCase().indexOf("firefox") > -1;
        },
        isIE: function () {
            var isIE = /*@cc_on!@*/false || !!document.documentMode;
            return isIE;
        },
        isEdge: function () {
            return !this.isIE() && !!window.StyleMedia;
        },

        //
        // Date Time functions
        //
        formatDateTimeDashIfEmpty: function (string) {
            if (string == null || string === "" || string === "-" || string === "1970-01-01T01:00:00+01:00")
                return "-";
            return Strolch.toLocalDateTime(string);
        },
        formatDateTime: function (string) {
            return Strolch.toLocalDateTime(string);
        },
        formatDateDashIfEmpty: function (string) {
            if (string == null || string === "" || string === "-" || string === "1970-01-01T01:00:00+01:00")
                return "-";
            return Strolch.toLocalDate(string);
        },
        formatDate: function (string) {
            return Strolch.toLocalDate(string);
        },
        formatDateTimePaddedWithSeconds: function (value) {
            return this.formatDateTime(value, true);
        },
        formatDateTimePadded: function (value, withSeconds) {
            var dateTime;
            if (value == null || value === "" || value === "-" || value === "1970-01-01T01:00:00+01:00")
                return "-";
            if (typeof (value) === "string") {
                dateTime = new Date(value);
            } else if (value instanceof Date) {
                dateTime = value;
            } else {
                throw "Unhandled object type " + typeof (value) + ": " + value;
            }

            return this.getDateString(dateTime, true) + " " + this.getTimeString(dateTime, withSeconds);
        },
        parsePeriodUnit: function (p) {

            // P3M -> months
            // P3W -> weeks
            // P3D -> days
            // PT3H -> hours
            // PT3M -> minutes

            if (p == null || p.length < 3 || p === "PT0S" || p === "P0S")
                return [0, "seconds"];

            var value;
            if (p.charAt(1) === "T") {
                value = Number.parseInt(p.substring(2, p.length - 1));
                switch (p.charAt(p.length - 1)) {
                    case "H":
                        return [value, "hours"];
                    case "M":
                        return [value, "minutes"];
                    case "S":
                        return [value, "seconds"];
                    default:
                        throw "Unhandled Period " + p;
                }
            }

            value = Number.parseInt(p.substring(1, p.length - 1));
            switch (p.charAt(p.length - 1)) {
                case "M":
                    return [value, "months"];
                case "W":
                    return [value, "weeks"];
                case "D":
                    return [value, "days"];
                default:
                    throw "Unhandled Period " + p;
            }
        },
        formatPeriod: function (p) {
            if (p == null || p.length < 3)
                return "-";

            // P1D
            // P1Y2M3DT4H5M6S
            // PT1H1M

            var i = 0;
            if (p.charAt(i) !== "P")
                throw "Illegal ISO8601 Period!";
            i++;

            var result = (this.localize == null ? "every" : this.localize("every")) + " ";

            // period part
            var pos;
            var val;
            if (p.charAt(i) !== "T") {
                var timePartPos = p.indexOf("T");
                if (timePartPos < 0)
                    timePartPos = p.length;

                // year
                pos = p.indexOf("Y", i);
                if (pos > 0) {
                    val = Number.parseFloat(p.substring(i, pos));
                    if (val > 0)
                        result += val + " " + (this.localize == null ? "years" : this.localize("years")) + " ";
                    i = pos + 1;
                }

                // month
                pos = p.indexOf("M", i);
                if (pos > 0 && pos < timePartPos) {
                    val = Number.parseFloat(p.substring(i, pos));
                    if (val > 0)
                        result += val + " " + (this.localize == null ? "months" : this.localize("months")) + " ";
                    i = pos + 1;
                }

                // day
                pos = p.indexOf("D", i);
                if (pos > 0) {
                    val = Number.parseFloat(p.substring(i, pos));
                    if (val > 0)
                        result += val + " " + (this.localize == null ? "days" : this.localize("days")) + " ";
                    i = pos + 1;
                }
            }
            i++;

            // time part

            // hour
            pos = p.indexOf("H", i);
            if (pos > 0) {
                val = Number.parseFloat(p.substring(i, pos));
                if (val > 0)
                    result += val + " " + (this.localize == null ? "hours" : this.localize("hours")) + " ";
                i = pos + 1;
            }

            // minute
            pos = p.indexOf("M", i);
            if (pos > 0) {
                val = Number.parseFloat(p.substring(i, pos));
                if (val > 0)
                    result += val + " " + (this.localize == null ? "minutes" : this.localize("minutes")) + " ";
                i = pos + 1;
            }

            // seconds
            pos = p.indexOf("S", i);
            if (pos > 0) {
                val = Number.parseFloat(p.substring(i, pos));
                if (val > 0)
                    result += val + " " + (this.localize == null ? "seconds" : this.localize("seconds")) + " ";
                i = pos + 1;
            }

            return result;
        },
        // gets the clock time as displayed in the UI
        getTimeString: function (datetime, withSeconds) {
            var hours = datetime.getHours().toString();
            var minutes = datetime.getMinutes().toString();

            hours = hours.length < 2 ? "0" + hours : hours;
            minutes = minutes.length < 2 ? "0" + minutes : minutes;

            if (!withSeconds)
                return hours + ":" + minutes;

            var seconds = datetime.getSeconds().toString();
            seconds = seconds.length < 2 ? "0" + seconds : seconds;
            return hours + ":" + minutes + "." + seconds;
        },
        getDateWithTimeString: function (date, timeString) {
            var hourMin = timeString.split(":");
            if (hourMin.length !== 2)
                throw "TimeString " + timeString + " has invalid format!";

            date.setHours(Number.parseInt(hourMin[0]));
            date.setMinutes(Number.parseInt(hourMin[1]));
            return date;
        },
        // gets the calendar date as displayed in the UI
        getDateString: function (datetime, addCentury) {
            if (datetime == null)
                return "";

            if (typeof (datetime) == "string") {
                datetime = new Date(datetime);
            }

            var day = (datetime.getDate()).toString();
            var month = (datetime.getMonth() + 1).toString();
            var year = (datetime.getFullYear()).toString();

            day = day.length < 2 ? "0" + day : day;
            month = month.length < 2 ? "0" + month : month;
            year = addCentury ? year : year.slice(-2);
            return day + "." + month + "." + year;
        },
        // gets the date of a date string from getDateString()
        getDate: function (datetimeString) {
            if (datetimeString == null || datetimeString.length === "")
                return null;

            if (datetimeString.indexOf("T") === 10) {
                return new Date(datetimeString.substring(0, 10));
            } else if (datetimeString.length === 10 && datetimeString.indexOf("-") === 4) {
                return new Date(datetimeString);
            }

            var splitString = datetimeString.split(".");
            if (splitString.length !== 3) return null;

            var year = Number(splitString[2]);
            var month = Number(splitString[1]) - 1;
            var day = Number(splitString[0]);
            return new Date(year, month, day);
        },
        // gets the clock time of the current time
        getCurrentTimeString: function () {
            return this.getTimeString(new Date());
        },
        toDateTime: function (val) {
            if (this.isEmptyString(val) || val === "-") return "-";
            var date = new Date(val);

            var y = date.getFullYear();
            var m = this.pad10(date.getMonth() + 1);
            var d = this.pad10(date.getDate());
            var h = this.pad10(date.getHours());
            var mi = this.pad10(date.getMinutes());
            var s = this.pad10(date.getSeconds());

            return y + m + d + h + mi + s;
        },
        toDateTimeNoDelim: function (val) {
            return this.toDateTime(val);
        },
        // gets the calendar date of the current time
        getCurrentDateString: function () {
            return this.getDateString(new Date());
        },
        clearTime: function (date) {
            date.setHours(0);
            date.setMinutes(0);
            date.setSeconds(0);
            date.setMilliseconds(0);

            return date;
        },
        dateToJson: function (date) {
            date.setTime(date.getTime() - date.getTimezoneOffset() * 60 * 1000);
            return date.toJSON();
        },
        dateToIso: function (date) {
            if (date == null || date === "") {
                return null;
            }
            var tzo = -date.getTimezoneOffset(),
                dif = tzo >= 0 ? "+" : "-",
                pad = function (num) {
                    var norm = Math.floor(Math.abs(num));
                    return (norm < 10 ? "0" : "") + norm;
                };
            return date.getFullYear() +
                "-" + pad(date.getMonth() + 1) +
                "-" + pad(date.getDate()) +
                "T" + pad(date.getHours()) +
                ":" + pad(date.getMinutes()) +
                ":" + pad(date.getSeconds()) +
                dif + pad(tzo / 60) +
                ":" + pad(tzo % 60);
        },
        truncateTime: function (date) {
            date.setTime(date.getTime() - (-date.getTimezoneOffset() * 60 * 1000));
            date.setHours(0, 0, 0, 0);
            return date;
        },
        // returns true if a datetime has past
        isPast: function (datetime) {
            return Date.now() > datetime.getTime();
        },
        // returns true if a datetime is future
        isFuture: function (datetime) {
            return Date.now() < datetime.getTime();
        },
        // turns hours into milliseconds
        hToMs: function (hour) {
            return hour * 3600000;
        },
        // turns milliseconds into hours
        msToH: function (milliseconds) {
            return milliseconds / 3600000;
        },

        //
        // Cookie functions
        //
        getCookie: function (cname) {
            return Strolch.getCookie(cname);
        },
        setCookie: function (cname, cvalue, expiration) {
            Strolch.setCookie(cname, cvalue, expiration);
        },
        deleteCookie: function (cname) {
            Strolch.deleteCookie(cname);
        },

        //
        // URL query functions
        //
        parseQueryParams: function (queryParamsS) {
            var params = {};
            if (queryParamsS.length === 0)
                return {};

            var queryParams = queryParamsS.split("&");
            for (var i = 0; i < queryParams.length; i++) {
                var queryParam = queryParams[i];
                var parts = queryParam.split("=");
                if (parts.length !== 2) {
                    console.log("Ignoring bad query param " + queryParam);
                    continue;
                }

                var key = parts[0];
                params[key] = parts[1];
            }

            return params;
        },
        removeQueryParamsFromPath: function (path) {
            var queryParamsIndex = path.indexOf("?");
            if (queryParamsIndex < 0) {
                return {
                    path: path,
                    params: null
                };
            }

            var returnPath = path.substring(0, queryParamsIndex);
            var queryParams = this.parseQueryParams(path.substring(queryParamsIndex + 1));

            return {
                path: returnPath,
                params: queryParams
            };
        },
        // finds a path param of the form '/pathParam/{pathParamValue}/' and returns its value
        findUrlPathParam: function (urlPath, pathParam) {
            var regex = new RegExp("\/" + pathParam + "\/([^\/]+)", "i");
            var matches = regex.exec(urlPath);
            return matches && matches[1] ? matches[1] : null;
        },
        // add a sub route to the current path
        pushSubRoutePath: function (route, routePath) {
            var baseUrl = document.URL.substring(0, document.URL.indexOf("#") + 1);
            var pushUrl = baseUrl + route.prefix + routePath;
            history.pushState(null, null, pushUrl);
        },
        getPageId: function () {
            var parts = document.location.hash.split("/");
            if (parts[0] !== "#" || parts.length < 2)
                return "";
            return parts[1];
        },
        clearQueryParams: function () {
            Strolch.clearQueryParams();
        },
        getQueryParamsAsString: function () {
            return Strolch.getQueryParamsAsString();
        },
        getQueryParamsAsObject: function () {
            return Strolch.getQueryParamsAsObject();
        },
        getQueryParamValue: function (paramName) {
            return Strolch.getQueryParamValue(paramName);
        },
        setQueryParamValue: function (paramName, paramValue) {
            Strolch.setQueryParamValue(paramName, paramValue);
        },
        setQueryParamsFromObject: function (object) {
            Object.keys(object).forEach(function (key) {
                this.setQueryParamValue(key, object[key]);
            }.bind(this));
        }
    };

    StrolchUtilBehavior = [StrolchUtilBehaviorImpl];
</script>