// DYMICO_TRANSPILER_V=v2-cleanroom1 source=gs-in-dymico runtime=dymicoAsset cacheTier=mem
console.log("[DYMICO_TRANSPILER_V=v2-cleanroom1 source=gs-in-dymico runtime=dymicoAsset cacheTier=mem]");
if (typeof gs === "undefined" || typeof gs.mc !== "function") {
/*
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
(function() {
    var gs = function(obj) {
        if (obj instanceof gs) return obj;
        if (!(this instanceof gs)) return new gs(obj);
    };
    var root = this;

    if (typeof exports !== 'undefined') {
        if (typeof module !== 'undefined' && module.exports) {
            exports = module.exports = gs;
        }
        exports.gs = gs;
    } else {
        root.gs = gs;
    }

    //Fails
    gs.fails = false;
    //Local console
    gs.consoleData = '';
    //If true and console is available, all output will go through console
    gs.consoleOutput = true;
    //If true and console is available, some methods will show info on console
    gs.consoleInfo = false;

    var globalMetaClass = {};

    //Categories
    var categories = [];

    // Mixins
    var mixins = [];
    var mixinsObjects = [];

    //Delegate
    var delegates = [];

    //Static this
    var aStT = null;

    //@Delegate
    var mapAddDelegate = {};

    gs.myCategories = {};

    /////////////////////////////////////////////////////////////////
    // assert and println
    /////////////////////////////////////////////////////////////////
    gs.assert = function(value) {
        if(value === false) {
            gs.fails = true;
            var message = 'Assert Fails! - ';
            if (arguments.length == 2 && arguments[1] !== null) {
                message = arguments[1] + ' - ';
            }
            gs.println(message + value);
        }
    };

    //Function that used for print and println in groovy
    gs.println = function(value) {
        if (gs.consoleOutput) {
            console.log(value);
        } else {
            if (gs.consoleData !== "") {
                gs.consoleData = gs.consoleData + "\n";
            }
            gs.consoleData = gs.consoleData + value;
        }
    };

    gs.printNashorn = function(value) {
        print(value);
    };

    //TODO We don't know if a function is constructor, atm if function name starts with uppercase, it is
    function isConstructor(name, func) {
        return name[0] == name[0].toUpperCase();
    }

    function isFunction(f) {
        return typeof(f) === "function";
    }

    function getterSetterRemove(name) {
        return name.charAt(3).toLowerCase() + name.slice(4);
    }

    /////////////////////////////////////////////////////////////////
    // Class functions
    /////////////////////////////////////////////////////////////////
    function BaseClass() { };
    gs.BaseClass = BaseClass;
    //gs.baseClass = {
        //The with function, with is a reserved word in JavaScript
    BaseClass.prototype.clazz = {};
    BaseClass.prototype.withz = function(closure) { return closure.apply(this, closure.arguments); },
    BaseClass.prototype.getProperties = function() {
            var result = gs.map(), ob;
            for (ob in this) {
                if (isFunction(this[ob]) && ob.startsWith('get') &&
                    this[ob].length == 0 && ob !== 'getProperties' && ob !== 'getMethods' &&
                    ob !== 'getMetaClass') {
                    result.add(getterSetterRemove(ob), this[ob]());
                } else if (!isFunction(this[ob]) && ob != 'clazz' && ob.indexOf('__') < 0) {
                    result.add(ob, this[ob]);
                }
            }
            return result;
        };
    BaseClass.prototype.getMethods = function() {
            var result = gs.list([]), ob;
            for (ob in this) {
                if (isFunction(this[ob])) {
                    if (!isObjectProperty(ob) && !(isConstructor(ob, this[ob]))) {
                        var item = {
                            name: ob
                        };
                        result.add(item);
                    }
                }
            }
            return result;
        };
    BaseClass.prototype.invokeMethod = function(name, values) {
            var i, newArgs = [];
            if (values) {
                for (i=0; i < values.length; i++) {
                    newArgs[i] = values[i];
                }
            }
            var f = this[name];
            return f.apply(this, newArgs);
        };
    BaseClass.prototype.constructor = function() {
            return this;
        };
    BaseClass.prototype.asType = function(type) {
            if (hasFunc(type, 'gSaT')) {
                type.gSaT(this);
            }
            return this;
        };
    BaseClass.prototype.withTraits = function() {
            var i;
            for (i = 0; i < arguments.length; i++) {
                arguments[i].gSaT(this);
            }
            return this;
        };
    BaseClass.prototype.getClass = function() {
            return this.clazz;
        };
    BaseClass.prototype.getMetaClass = function() {
            return gs.metaClass(this);
        };

    function applyBaseClassFunctions(item) {
        item.asType = BaseClass.prototype.asType;
    }

    function isObjectProperty(name) {
        return ['clazz','gSdefaultValue','leftShift',
            'minus','plus','equals','toString',
            'clone','withz','getProperties','getStatic', 'getClass', 'getMetaClass',
            'getMethods','invokeMethod','constructor', 'asType', 'withTraits'].indexOf(name) >= 0;
    }

    function isJsArray(array) {
        return array['clazz'] === undefined
    }

    gs.expando = function() {
        var object = gs.init('Expando');

        object.constructorWithMap = function(map) { gs.passMapToObject(map, this); return this;};
        if (arguments.length == 1) {object.constructorWithMap(arguments[0]); }

        return object;
    };

    gs.expandoMetaClass = function() {
        var object = gs.init('ExpandoMetaClass');
        object.initialize = function() {
            return this;
        };
        return object;
    };

    function expandWithMetaClass(item, objectName) {
        if (globalMetaClass && globalMetaClass[objectName]) {
            var obj, map = globalMetaClass[objectName];
            for (obj in map) {

                //Static methods
                var staticMap = map.getStatic();
                if (staticMap) {
                    var objStatic;
                    for (objStatic in staticMap) {
                        if (objStatic != 'gSparent') {
                            //console.log('Adding static->'+objStatic);
                            item[obj] = staticMap[objStatic];
                        }
                    }
                }
                //Non static methods and properties
                item[obj] = map[obj];
            }
        }
        return item;
    }

    gs.init = function(name) {
        return expandWithMetaClass(new BaseClass(), name);
    };

    function createClassNames(item, items) {
        var number = items.length, i, container;
        for (i = 0; i < number ; i++) {
            if (i === 0) {
                container = {};
                item.clazz = container;
            }
            container.name = items[i];
            container.simpleName = getSimpleName(items[i]);
            if (i < number) {
                container.superclass = {};
                container = container.superclass;
            }
        }
    }

    function getSimpleName(name) {
        var pos = name.indexOf(".");
        while (pos >= 0) {
            name = name.substring(pos + 1);
            pos = name.indexOf(".");
        }
        return name;
    }

    /////////////////////////////////////////////////////////////////
    // set - as Set and HashSet from groovy
    /////////////////////////////////////////////////////////////////
    gs.set = function(value) {
        var object;

        if (arguments.length === 0) {
            object = gs.list([]);
        } else {
            object = value;
        }

        createClassNames(object, ['java.util.HashSet']);

        object.isSet = true;

        object.withz = function(closure) {
            return interceptClosureCall(closure, this);
        };

        object.add = function(item) {
            if (!(this.contains(item))) {
                this.push(item);
                return this;
            } else {
                return false;
            }
        };

        object.addAll = function(elements) {
            if (elements instanceof Array) {
                var i, fails = false;

                //Check if items not in set
                for (i = 0; !fails && i < elements.length; i++) {
                    if (this.contains(elements[i])) {
                        fails = true;
                    }
                }
                if (fails) {
                    return false;
                } else {
                    //All ok, we add items to the set
                    for (i = 0; i < elements.length; i++) {
                        this.add(elements[i]);
                    }
                }
            }
            return this;
        };

        object.equals = function(other) {
            if (!(other instanceof Array) || other.length != this.length || !(other.isSet)) {
                return false;
            } else {
                var i, result = true;
                for (i = 0; i < this.length && result; i++) {
                    if (!(other.contains(this[i]))) {
                        result = false;
                    }
                }
                return result;
            }
        };

        object.toList = function() {
            var i, list = [];
            for (i = 0; i < this.length; i++) {
                list[i] = this[i];
            }
            return gs.list(list);
        };

        object.plus = function(other) {
            var result = gs.set();
            result.addAll(this);
            if (other instanceof Array) {
                var i;
                for (i = 0; i < other.length; i++) {
                    if (!(result.contains(other[i]))) {
                        result.add(other[i]);
                    }
                }
            }
            return result;
        };

        object.minus = function(other) {
            var result = gs.set();
            result.addAll(this);
            if (other instanceof Array) {
                var i;
                for (i = 0;i < other.length; i++) {
                    if (result.contains(other[i])) {
                        result.remove(other[i]);
                    }
                }
            }
            return result;
        };

        object.remove = function(value) {
            var index = this.indexOf(value);
            if (index >= 0) {
                this.splice(index, 1);
                return true;
            } else {
                return false;
            }
        };

        return object;
    };

    /////////////////////////////////////////////////////////////////
    // map - [:] from groovy
    /////////////////////////////////////////////////////////////////
    function isMapProperty(name) {
        return isObjectProperty(name) || ['any','collect',
            'collectEntries','collectMany','countBy','dropWhile',
            'each','eachWithIndex','every','find','findAll',
            'findResult','findResults','get','getAt','groupBy',
            'inject','intersect','max','min',
            'putAll','putAt','reverseEach', 'clear',
            'sort','spread','subMap','add','take','takeWhile',
            'withDefault','count','drop','keySet',
            'put','size','isEmpty','remove','containsKey',
            'containsValue','values'].indexOf(name) >= 0;
    }

    gs.map = function() {
        var gSobject = new GsGroovyMap();
        expandWithMetaClass(gSobject, 'LinkedHashMap');
        applyBaseClassFunctions(gSobject);
        if (arguments.length == 1 && arguments[0] instanceof Object) {
            gs.passMapToObject(arguments[0], gSobject);
        }

        return gSobject;
    };

    function GsGroovyMap() {}

    GsGroovyMap.prototype.clazz = { name: 'java.util.LinkedHashMap', simpleName: 'LinkedHashMap',
        superclass: { name: 'java.util.HashMap', simpleName: 'HashMap'}};
    GsGroovyMap.prototype.gSdefaultValue = null;
    GsGroovyMap.prototype.withz = BaseClass.prototype.withz;
    GsGroovyMap.prototype.add = function(key, value) {
        if (key == "spreadMap") {
            //We insert items of the map, from spread operator
            var ob;
            for (ob in value) {
                if (!isMapProperty(ob)) {
                    this[ob] = value[ob];
                }
            }
        } else {
            this[key] = value;
        }
        return this;
    };
    GsGroovyMap.prototype.put = function(key,value) {
        return this.add(key,value);
    };
    GsGroovyMap.prototype.leftShift = function(key,value) {
        if (arguments.length == 1) {
            return this.plus(arguments[0]);
        } else {
            return this.add(key,value);
        }
    };
    GsGroovyMap.prototype.putAt = function(key,value) {
        this.put(key,value);
    };
    GsGroovyMap.prototype.size = function() {
        var number = 0,ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                number++;
            }
        }
        return number;
    };
    GsGroovyMap.prototype.isEmpty = function() {
        return (this.size() === 0);
    };
    GsGroovyMap.prototype.remove = function(key) {
        if (this[key]) {
            delete this[key];
        }
    };
    GsGroovyMap.prototype.each = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                //Nice, number of arguments in length property
                if (f.length == 1) {
                    closure({key: ob, value: this[ob]});
                }
                if (f.length == 2) {
                    closure(ob,this[ob]);
                }
            }
        }
    };

    GsGroovyMap.prototype.count = function(closure) {
        var number = 0, ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (closure.length == 1) {
                    if (closure({key: ob, value: this[ob]})) {
                        number++;
                    }
                }
                if (closure.length == 2) {
                    if (closure(ob, this[ob])) {
                        number++;
                    }
                }
            }
        }
        return number;
    };

    GsGroovyMap.prototype.any = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    if (closure({key:ob, value: this[ob]})) {
                        return true;
                    }
                }
                if (f.length == 2) {
                    if (closure(ob, this[ob])) {
                        return true;
                    }
                }
            }
        }
        return false;
    };

    GsGroovyMap.prototype.every = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    if (!closure({key: ob, value: this[ob]})) {
                        return false;
                    }
                }
                if (f.length == 2) {
                    if (!closure(ob, this[ob])) {
                        return false;
                    }
                }
            }
        }
        return true;
    };

    GsGroovyMap.prototype.find = function(closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    var entry = {key: ob, value: this[ob]};
                    if (closure(entry)) {
                        return entry;
                    }
                }
                if (f.length == 2) {
                    if (closure(ob, this[ob])) {
                        return {key: ob, value: this[ob]};
                    }
                }
            }
        }
        return null;
    };

    GsGroovyMap.prototype.dropWhile = function(closure) {
        var result = gs.map(), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var entry = {key: ob, value: this[ob]};

                var f = arguments[0];
                if (f.length == 1) {
                    if (!closure(entry)) {
                        result.add(entry.key, entry.value);
                    }
                }
                if (f.length == 2) {
                    if (!closure(entry.key, entry.value)) {
                        result.add(entry.key, entry.value);
                    }
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.drop = function(number) {
        var result = gs.map(), ob, count = 0;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                count ++;
                if (count > number) {
                    result.add(ob, this[ob]);
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.findAll = function(closure) {
        var result = gs.map(), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length == 1) {
                    var entry = {key: ob, value: this[ob]};
                    if (closure(entry)) {
                        result.add(entry.key, entry.value);
                    }
                }
                if (f.length == 2) {
                    if (closure(ob, this[ob])) {
                        result.add(ob, this[ob]);
                    }
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.collect = function(closure) {
        var result = gs.list([]), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                var f = arguments[0];
                if (f.length==1) {
                    result.add(closure({key:ob, value:this[ob]}));
                }
                if (f.length==2) {
                    result.add(closure(ob,this[ob]));
                }
            }
        }
        if (result.size()>0) {
            return result;
        } else {
            return null;
        }
    };

    GsGroovyMap.prototype.containsKey = function(key) {
        if (this[key] === undefined || this[key] === null) {
            return false;
        } else {
            return true;
        }
    };

    GsGroovyMap.prototype.containsValue = function(value) {
        var ob, gotIt = false;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (gs.equals(this[ob],value)) {
                    gotIt = true;
                    break;
                }
            }
        }
        return gotIt;
    };

    GsGroovyMap.prototype.get = function(key, defaultValue) {
        if (!this.containsKey(key)) {
            this[key] = defaultValue;
        }
        return this[key];
    };

    GsGroovyMap.prototype.toString = function() {
        var items = '';
        this.each (function(key,value) {
            items = items + key+': '+value+' ,';
        });
        return '[' + items + ']';
    };

    GsGroovyMap.prototype.equals = function(otherMap) {
        var result = true, ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (!gs.equals(this[ob],otherMap[ob])) {
                    result = false;
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.keySet = function() {
        var result = gs.list([]), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                result.add(ob);
            }
        }
        return result;
    };

    GsGroovyMap.prototype.values = function() {
        var result = gs.list([]), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                result.add(this[ob]);
            }
        }
        return result;
    };

    GsGroovyMap.prototype.withDefault = function(closure) {
        this.gSdefaultValue = closure;
        return this;
    };

    GsGroovyMap.prototype.inject = function(initial,closure) {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                if (closure.length == 2) {
                    var entry = {key:ob, value:this[ob]};
                    initial = closure(initial, entry);
                }
                if (closure.length == 3) {
                    initial = closure(initial, ob, this[ob]);
                }
            }
        }
        return initial;
    };

    GsGroovyMap.prototype.putAll = function (items) {
        if (items instanceof Array) {
            var i;
            for (i=0;i<items.length;i++) {
                var item = items[i];
                this.add(item.key,item.value);
            }
        } else {
            var ob;
            for (ob in items) {
                if (!isMapProperty(ob)) {
                    this.add(ob,items[ob]);
                }
            }
        }
        return this;
    };

    GsGroovyMap.prototype.plus = function(other) {
        var result = this.clone();
        if (other instanceof Array) {
            result.putAll(other);
        } else {
            var ob;
            for (ob in other) {
                if (!isMapProperty(ob)) {
                    result.add(ob,other[ob]);
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.clone = function() {
        var result = gs.map(), ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                result.add(ob, this[ob]);
            }
        }
        return result;
    };

    GsGroovyMap.prototype.minus = function(other) {
        var result = this.clone(), ob;
        for (ob in other) {
            if (!isMapProperty(ob)) {
                if (result[ob] !== null && result[ob] !==undefined && gs.equals(result[ob],other[ob])) {
                    delete result[ob];
                }
            }
        }
        return result;
    };

    GsGroovyMap.prototype.clear = function() {
        var ob;
        for (ob in this) {
            if (!isMapProperty(ob)) {
                delete this[ob];
            }
        }
    };

    /////////////////////////////////////////////////////////////////
    // Array prototype changes
    /////////////////////////////////////////////////////////////////
    Array.prototype.get = function(pos) {

        //Maybe comes a second parameter with default value
        if (arguments.length == 2) {
            if (this[pos] === null || this[pos] === undefined) {
                return arguments[1];
            } else {
                return this[pos];
            }
        } else {
            return this[pos];
        }
    };

    Array.prototype.getAt = function(pos) {
        return this[pos];
    };

    Array.prototype.withz = function(closure) {
        return interceptClosureCall(closure, this);
    };

    Array.prototype.size = function() {
        return this.length;
    };

    Array.prototype.isEmpty = function() {
        return this.length === 0;
    };

    Array.prototype.add = function(pos, element) {
        if (element === undefined) {
            this.push(pos);
        } else {
            this[pos] = element;
        }
        return this;
    };

    Array.prototype.addAll = function(elements) {
        var i;
        if (arguments.length == 1) {
            if (elements instanceof Array) {
                for (i = 0; i < elements.length; i++) {
                    this.add(elements[i]);
                }
            } else {
                this.push(elements);
            }
        } else {
            //Two parameters index and collection
            var index = arguments[0];
            var data = arguments[1];
            for (i=0; i < data.length; i++) {
                this.splice(index+i, 0, data[i]);
            }
        }
        return true;
    };

    Array.prototype.clone = function() {
        var result = gs.list([]);
        result.addAll(this);
        return result;
    };

    Array.prototype.plus = function(other) {
        var result = this.clone();
        result.addAll(other);
        return result;
    };

    Array.prototype.minus = function(other) {
        var result = this.clone();
        result.removeAll(other);
        return result;
    };

    Array.prototype.leftShift = function(element) {
        return this.add(element);
    };

    Array.prototype.contains = function(object) {
        var gotIt, i;
        for (i=0; !gotIt && i < this.length; i++) {
            if (gs.equals(this[i], object)) {
                gotIt = true;
            }
        }
        return gotIt;
    };

    Array.prototype.containsAll = function(list) {
        var i, numberEq = 0;
        for (i = 0; i < list.length; i++) {
            if (this.contains(list[i])) {
                numberEq++;
            }
        }
        if (numberEq == list.length) {
            return true;
        } else {
            return false;
        }
    };

    Array.prototype.each = function(closure) {
        var i;
        for (i = 0; i < this.length; i++) {
            //TODO Beware this change, have to apply to all closure calls
            interceptClosureCall(closure, this[i]);
        }
        return this;
    };

    Array.prototype.reverseEach = function(closure) {
        var i;
        for (i = this.length - 1; i >= 0; i--) {
            interceptClosureCall(closure, this[i]);
        }
        return this;
    };

    Array.prototype.eachWithIndex = function(closure,index) {
        for (index=0; index < this.length; index++) {
            closure(this[index], index);
        }
        return this;
    };

    Array.prototype.any = function(closure) {
        var i;
        for (i = 0;i < this.length; i++) {
            if (closure(this[i])) {
                return true;
            }
        }
        return false;
    };

    Array.prototype.oldValues = Array.prototype.values;

    Array.prototype.values = function() {
        if (isJsArray(this) && Array.prototype.oldValues) {
            return this.oldValues();
        } else {
            var i, result = [];
            for (i = 0; i < this.length; i++) {
                result[i] = this[i];
            }
            return result;
        }
    };
    //Remove only 1 item from the list
    Array.prototype.remove = function(indexOrValue) {
        var result = false,index = -1;
        if (typeof indexOrValue == 'number') {
            index = indexOrValue;
            result = this[index];
        } else {
            index = this.indexOf(indexOrValue);
            if (index >= 0) {
                result = true;
            }
        }
        if (index >= 0) {
            this.splice(index, 1);
        }
        return result;
    };

    //Maybe too much complex, not much inspired
    Array.prototype.removeAll = function(data) {
        if (data instanceof Array) {
            var result = [];
            this.forEach(function(v, i, a) {
                if (data.contains(v)) {
                    result.push(i);
                }
            });
            //Now in result we have index of items to delete
            if (result.length>0) {
                var decremental = 0;
                var thisList = this;
                result.forEach(function(v, i, a) {
                    //Had tho change this for thisList, other scope on this here
                    thisList.splice(v-decremental,1);
                    decremental=decremental+1;
                });
            }
        } else if (isFunction(data)) {
            var i;
            for (i = this.length - 1; i >= 0; i--) {
                if (data(this[i])) {
                    this.remove(i);
                }
            }
        }
        return this;
    };

    Array.prototype.collect = function(closure) {
        var i, result = gs.list([]);
        for (i = 0; i < this.length; i++) {
            result[i] = closure(this[i]);
        }
        return result;
    };

    Array.prototype.collectMany = function(closure) {
        var i, result = gs.list([]);
        for (i = 0;i < this.length; i++) {
            result.addAll(closure(this[i]));
        }
        return result;
    };

    Array.prototype.takeWhile = function(closure) {
        var i, result = gs.list([]);
        for (i = 0; i < this.length; i++) {
            if (closure(this[i])) {
                result[i] = this[i];
            } else {
                break;
            }
        }
        return result;
    };

    Array.prototype.dropWhile = function(closure) {
        var result = gs.list([]);
        var i, j=0, insert = false;
        for (i = 0; i < this.length; i++) {
            if (!closure(this[i])) {
                insert=true;
            }
            if (insert) {
                result[j++] = this[i];
            }
        }
        return result;
    };

    Array.prototype.drop = function(number) {
        var i, result = gs.list([]);
        for (i = number; i < this.length; i++) {
            result.push(this[i]);
        }
        return result;
    };

    Array.prototype.findAll = function(closure) {
        var values = this.filter(closure);
        return gs.list(values);
    };

    if (!Array.prototype.find) {
        Array.prototype.find = function (closure) {
            var result, i;
            for (i = 0; !result && i < this.length; i++) {
                if (closure(this[i])) {
                    result = this[i];
                }
            }
            return result;
        };
    }

    Array.prototype.first = function() {
        return this[0];
    };

    Array.prototype.head = function() {
        return this.first();
    };

    Array.prototype.last = function() {
        return this[this.length - 1];
    };

    Array.prototype.sum = function() {

        var i, result = 0;
        //can pass a closure to sum
        if (arguments.length == 1) {
            for (i = 0; i < this.length; i++) {
                result = result + arguments[0](this[i]);
            }
        } else {
            if (this.length > 0 && this[0].plus) {
                var item = this[0];
                for (i = 0; i + 1 < this.length; i++) {
                    item = item.plus(this[i + 1]);
                }
                return item;
            } else {
                for (i = 0; i < this.length; i++) {
                    result = result + this[i];
                }
            }
        }
        return result;
    };

    Array.prototype.inject = function() {

        var acc;
        //only 1 argument, just the closure
        if (arguments.length == 1) {
            acc = this[0];
            var i;
            for (i=1;i<this.length;i++) {
                acc = arguments[0](acc,this[i]);
            }

        } else {
            //We suppose arguments = 2
            acc = arguments[0];
            var j;
            for (j=0;j<this.length;j++) {
                acc = arguments[1](acc,this[j]);
            }
        }
        return acc;
    };

    Array.prototype.toList = function() {
        return this;
    };

    Array.prototype.intersect = function(otherList) {
        var i, result = gs.list([]);
        for (i = 0;i < this.length; i++) {
            if (otherList.contains(this[i])) {
                result.add(this[i]);
            }
        }
        return result;
    };

    Array.prototype.max = function() {
        var i, result = null;
        for (i = 0; i < this.length; i++) {
            if (result === null || this[i] > result) {
                result = this[i];
            }
        }
        return result;
    };

    Array.prototype.min = function() {
        var i, result = null;
        for (i = 0; i < this.length; i++) {
            if (result === null || this[i] < result) {
                result = this[i];
            }
        }
        return result;
    };

    Array.prototype.oldToString = Array.prototype.toString;

    Array.prototype.toString = function() {
        if (isJsArray(this)) {
            return this.oldToString();
        } else if (this.length > 0) {
            return '[' + this.join(', ') + ']';
        } else {
            return '[]';
        }
    };

    Array.prototype.grep = function(param) {
        var i, result = gs.list([]);
        if (param instanceof RegExp) {
            for (i = 0; i < this.length; i++) {
                if (gs.match(this[i],param)) {
                    result.add(this[i]);
                }
            }
            return result;
        } else if (param instanceof Array) {
            return this.intersect(param);
        } else if (isFunction(param)) {
            for (i = 0; i < this.length; i++) {
                if (param(this[i])) {
                    result.add(this[i]);
                }
            }
            return result;
        } else {
            for (i = 0; i < this.length ;i++) {
                if (this[i]==param) {
                    result.add(this[i]);
                }
            }
            return result;
        }
    };

    Array.prototype.equals = function(other) {
        if (!(other instanceof Array) || other.length!=this.length) {
            return false;
        } else {
            var i, result = true;
            for (i = 0;i < this.length && result; i++) {
                if (!gs.equals(this[i],other[i])) {
                    result = false;
                }
            }
            return result;
        }
    };

    Array.prototype.gSjoin = function() {
        var separator = '';
        if (arguments.length == 1) {
            separator = arguments[0];
        }
        var i, result = '';
        for (i = 0; i < this.length; i++) {
            result = result + this[i];
            if ((i + 1) < this.length) {
                result = result + separator;
            }
        }
        return result;
    };

    Array.prototype.oldSort = Array.prototype.sort;

    Array.prototype.sort = function() {
        var modify = true;
        if (arguments.length > 0 && arguments[0] === false) {
            modify = false;
        }
        var i,copy = [];
        //Maybe some closure as last parameter
        var tempFunction = null;
        if (arguments.length == 2 && isFunction(arguments[1])) {
            tempFunction = arguments[1];
        }
        if (arguments.length == 1 && isFunction(arguments[0])) {
            tempFunction = arguments[0];
        }
        //Copy all items
        for (i=0;i<this.length;i++) {
            copy[i] = this[i];
        }
        //If function has 2 parameter, inside compare both and return a number
        if (tempFunction !== null && tempFunction.length == 2) {
            copy.oldSort(tempFunction);
        }
        //If function has 1 parameter, we have to compare transformed items
        if (tempFunction !== null && tempFunction.length == 1) {
            copy.oldSort(function(a, b) {
                return gs.spaceShip(tempFunction(a),tempFunction(b));
            });
        }
        if (tempFunction === null) {
            copy.oldSort();
        }
        if (modify) {
            for (i=0;i<this.length;i++) {
                this[i] = copy[i];
            }
            return this;
        } else {
            return gs.list(copy);
        }
    };

    Array.prototype.unique = function() {
        var modify = true;
        if (arguments.length > 0 && arguments[0] === false) {
            modify = false;
        }
        var i, copy = [];
        //Copy all items
        for (i = 0; i < this.length; i++) {
            if (!copy.contains(this[i])) {
                copy.push(this[i]);
            }
        }

        if (modify) {
            this.length = 0;
            for (i = 0; i < copy.length; i++) {
                this[i] = copy[i];
            }
            return this;
        } else {
            return gs.list(copy);
        }
    };

    Array.prototype.oldReverse = Array.prototype.reverse;

    Array.prototype.reverse = function() {
        var i, count = 0;
        if (isJsArray(this)) {
            return this.oldReverse();
        } else if (arguments.length == 1 && arguments[0] === true) {
            for (i = this.length - 1; i > count; i--) {
                var temp = this[count];
                this[count++] = this[i];
                this[i] = temp;
            }
            return this;
        } else {
            var result = [];
            for (i = this.length - 1; i >= 0; i--) {
                result[count++] = this[i];
            }
            return gs.list(result);
        }
    };

    Array.prototype.take = function(number) {
        var i, result = [];
        for (i = 0; i < number; i++) {
            if (i < this.length) {
                result[i] = this[i];
            }
        }
        return gs.list(result);
    };

    Array.prototype.takeWhile = function(closure) {
        var result = [], i, exit=false;
        for (i = 0; !exit && i < this.length; i++) {
            if (closure(this[i])) {
                result[i] = this[i];
            } else {
                exit = true;
            }
        }
        return gs.list(result);
    };

    Array.prototype.multiply = function(number) {
        if (number === 0) {
            return gs.list([]);
        } else {
            var i, result = gs.list([]);
            for (i=0;i<number;i++) {
                var j;
                for (j=0;j<this.length;j++) {
                    result.add(this[j]);
                }
            }
            return result;
        }
    };

    Array.prototype.flatten = function() {
        var result = gs.list([]);
        gs.flatten(result, this);

        return result;
    };

    Array.prototype.collate = function(number) {
        var step = number,times = 0;
        if (arguments.length == 2) {
            step = arguments[1];
        }
        var result = gs.list([]);
        while (step * times < this.length) {
            var items = gs.list([]);
            var pos = step * times;
            while (pos < this.length && items.size() < number) {
                items.add(this[pos++]);
            }
            result.add(items);
            times++;
        }
        return result;
    };

    Array.prototype.groupBy = function(closure) {
        var i, result = gs.map();
        for (i=0;i<this.length;i++) {
            var r = closure(this[i]);
            var l = result[r];
            if (l) {
                l.add(this[i]);
            } else {
                result.add(r, gs.list().add(this[i]));
            }
        }
        return result;
    };

    Array.prototype.putAt = function(position, value) {
        this[position] = value;
    };

    Array.prototype.clear = function() {
        this.splice(0, this.length)
    };

    Array.prototype.count = function(value) {
        var i, result = 0;
        if (isFunction(value)) {
            for (i = 0; i < this.length; i++) {
                if (gs.bool(value(this[i]))) {
                    result++;
                }
            }
        } else {
            for (i = 0; i < this.length; i++) {
                if (gs.equals(value, this[i])) {
                    result++;
                }
            }
        }
        return result;
    };

    Array.prototype.tail = function() {
        var i, result = [];
        for (i = 1; i < this.length; i++) {
            result.push(this[i]);
        }
        return gs.list(result);
    };

    Array.prototype.init = function() {
        var i, result = [];
        for (i = 0; i < this.length - 1; i++) {
            result.push(this[i]);
        }
        return gs.list(result);
    };

    /////////////////////////////////////////////////////////////////
    //list - [] from groovy
    /////////////////////////////////////////////////////////////////
    gs.list = function(value) {
        var data = [];
        if (value && value.length > 0) {
            var i;
            for (i = 0; i < value.length; i++) {
                if (value[i] instanceof gs.spread) {
                    var values = value[i].values;
                    if (values.length > 0) {
                        var j;
                        for (j = 0; j < values.length; j++) {
                            data.push(values[j]);
                        }
                    }
                } else {
                    data.push(value[i]);
                }
            }
        }
        var object = data;
        object.clazz = {name: 'java.util.ArrayList', simpleName: 'ArrayList'};
        applyBaseClassFunctions(object);
        return object;
    };

    gs.flatten = function(result, list) {
        list.each(function (it) {
            if (it instanceof Array) {
                if (it.length>0) {
                    gs.flatten(result, it);
                }
            } else {
                result.add(it);
            }
        });
    };

    /////////////////////////////////////////////////////////////////
    //range - [x..y] from groovy
    /////////////////////////////////////////////////////////////////
    gs.range = function(begin, end, inclusive) {
        var start = begin;
        var finish = end;
        var areChars = (typeof(begin) == 'string');
        if (areChars) {
            start = start.charCodeAt(0);
            finish = finish.charCodeAt(0);
        }
        var reverse = false;
        if (finish < start) {
            var oldStart = start;
            start = finish;
            finish = oldStart;
            reverse = true;
            if (!inclusive) {
                start = start + 1;
            }
        } else {
            if (!inclusive) {
                finish = finish - 1;
            }
        }

        var result,number,count;
        for (result=[], number = start, count = 0 ; number <= finish ; number++, count++) {
            if (areChars) {
                result[count] = String.fromCharCode(number);
            } else {
                result[count] = number;
            }
        }
        if (reverse) {
            result = result.reverse();
        }
        var object = gs.list(result);
        object.toList = function() {
            return gs.list(this.values());
        };
        return object;
    };

    /////////////////////////////////////////////////////////////////
    //date - Date() object from groovy / java
    /////////////////////////////////////////////////////////////////
    gs.date = function() {

        var gSobject;
        if (arguments.length == 1) {
            gSobject = new Date(arguments[0]);
        } else {
            gSobject = new Date();
        }

        createClassNames(gSobject, ['java.util.Date']);
        gSobject.withz = BaseClass.prototype.withz;

        gSobject.time = gSobject.getTime();
        gSobject.setTime = function(milis) {
            gSobject.time = milis;
        };

        gSobject.year = gSobject.getFullYear();
        gSobject.month = gSobject.getMonth();
        gSobject.date = gSobject.getDay();
        gSobject.plus = function(other) {
            if (typeof other == 'number') {
                return gs.date(gSobject.time + (other * 1440000));
            } else {
                return gSobject + other;
            }
        };
        gSobject.minus = function(other) {
            if (typeof other == 'number') {
                return gs.date(gSobject.time - (other * 1440000));
            } else {
                return gSobject - other;
            }
        };
        gSobject.format = function(rule) {
            //TODO complete
            var exit = '';
            if (rule) {
                exit = rule;
                exit = exit.replaceAll('yyyy', gSobject.getFullYear());
                exit = exit.replaceAll('MM', fillZerosLeft(gSobject.getMonth() + 1, 2));
                exit = exit.replaceAll('dd', fillZerosLeft(gSobject.getUTCDate(), 2));
                exit = exit.replaceAll('HH', fillZerosLeft(gSobject.getHours(), 2));
                exit = exit.replaceAll('mm', fillZerosLeft(gSobject.getMinutes(), 2));
                exit = exit.replaceAll('ss', fillZerosLeft(gSobject.getSeconds(), 2));
                exit = exit.replaceAll('yy', lastChars(gSobject.getFullYear(), 2));
            }
            return exit;
        };
        gSobject.parse = function(rule, text) {
            //TODO complete
            var pos = rule.indexOf('MM');
            if (pos >= 0) {
                var newMonth = text.substr(pos, 2) - 1;
                while (gSobject.getMonth() != newMonth) {
                    gSobject.setMonth(newMonth);
                }
            }
            pos = rule.indexOf('dd');
            if (pos >= 0) {
                var newDay = text.substr(pos, 2);
                while (gSobject.getUTCDate() != newDay) {
                    gSobject.setUTCDate(newDay);
                }
            }
            pos = rule.indexOf('yyyy');
            if (pos >= 0) {
                gSobject.setFullYear(text.substr(pos, 4));
            } else {
                pos = rule.indexOf('yy');
                if (pos >= 0) {
                    gSobject.setFullYear(text.substr(pos, 2));
                }
            }
            pos = rule.indexOf('HH');
            if (pos >= 0) {
                gSobject.setHours(text.substr(pos, 2));
            }
            pos = rule.indexOf('mm');
            if (pos >= 0) {
                gSobject.setMinutes(text.substr(pos, 2));
            }
            pos = rule.indexOf('ss');
            if (pos >= 0) {
                gSobject.setSeconds(text.substr(pos, 2));
            }

            return gSobject;
        };
        gSobject.clearTime = function() {
            gSobject.setHours(0, 0, 0, 0);
            return gSobject;
        };
        gSobject.equals = function(other) {
            return gSobject.time == other.time;
        };
        gSobject.before = function(other) {
            return gSobject.time < other.time;
        };
        gSobject.after = function(other) {
            return gSobject.time > other.time;
        };
        return gSobject;
    };

    gs.rangeFromList = function(list, begin, end) {
        return list.slice(begin, end + 1);
    };

    function fillZerosLeft(item, size) {
        var value = item + '';
        while (value.length < size) {
            value = '0' + value;
        }
        return value;
    }

    function lastChars(item, number) {
        var value = item + '';
        value = value.substring(value.length - number);
        return value;
    }

    /////////////////////////////////////////////////////////////////
    //exactMatch - For regular expressions
    /////////////////////////////////////////////////////////////////
    gs.exactMatch = function(text, regExp) {
        var mock = text;
        if (regExp instanceof RegExp) {
            mock = mock.replace(regExp, "#");
        } else {
            mock = mock.replace(new RegExp(regExp), "#");
        }
        return mock == "#";
    };

    gs.match = function(text, regExp) {
        var pos;
        if (regExp instanceof RegExp) {
            pos = text.search(regExp);
        }
        return (pos>=0);
    };

    /////////////////////////////////////////////////////////////////
    //regExp - For regular expressions
    /////////////////////////////////////////////////////////////////
    gs.regExp = function(text, ppattern) {

        var patt;
        if (ppattern instanceof RegExp) {
            patt = new RegExp(ppattern.source, 'g');
        } else {
            //g for search all occurences
            patt = new RegExp(ppattern, 'g');
        }

        var object;

        var data = patt.exec(text);
        if (data === null || data === undefined) {
            return null;
        } else {
            var list = gs.list([]);
            var i = 0;

            while (data) {
                if (data instanceof Array && data.length < 2) {
                    list[i] = data[0];
                } else {
                    list[i] = gs.list(data);
                }
                i = i + 1;
                data = patt.exec(text);
            }
            object = expandWithMetaClass(list, 'RegExp');
        }

        createClassNames(object, ['java.util.regex.Matcher']);

        object.pattern = patt;
        object.text = text;

        object.replaceFirst = function(data) {
            return this.text.replaceFirst(this[0], data);
        };

        object.replaceAll = function(data) {
            return this.text.replaceAll(this.pattern, data);
        };

        object.reset = function() {
            return this;
        };

        return object;
    };

    /////////////////////////////////////////////////////////////////
    //Pattern
    /////////////////////////////////////////////////////////////////
    gs.pattern = function(pattern) {
        var object = gs.init('Pattern');

        createClassNames(object, ['java.util.regex.Pattern']);

        object.value = pattern;
        return object;
    };

    /////////////////////////////////////////////////////////////////
    // Regular Expresions
    /////////////////////////////////////////////////////////////////
    gs.matcher = function(item, regExpression) {

        var object = gs.init('Matcher');
        createClassNames(object, ['java.util.regex.Matcher']);

        object.data = item;
        object.regExp = regExpression;
        object.matches = function() {
            return gs.exactMatch(this.data, this.regExp);
        };

        return object;
    };

    RegExp.prototype.matcher = function(item) {
        return gs.matcher(item, this);
    };

    /////////////////////////////////////////////////////////////////
    //Number functions
    /////////////////////////////////////////////////////////////////
    Number.prototype.times = function(closure) {
        var i;
        for (i = 0; i < this; i++) {
            closure(i);
        }
    };

    Number.prototype.upto = function(number, closure) {
        var i;
        for (i = this.value; i <= number; i++) {
            closure(i);
        }
    };

    Number.prototype.step = function(number, jump, closure) {
        var i;
        for (i = this.value; i < number;) {
            closure(i);
            i = i + jump;
        }
    };

    Number.prototype.multiply = function(number) {
        return this * number;
    };

    Number.prototype.power = function(number) {
        return Math.pow(this,number);
    };

    Number.prototype.byteValue = Number.prototype.doubleValue = Number.prototype.shortValue =
        Number.prototype.floatValue = Number.prototype.longValue = function() {
        return this;
    };

    Number.prototype.intValue = function() {
        return Math.floor(this);
    };

    /////////////////////////////////////////////////////////////////
    //String functions
    /////////////////////////////////////////////////////////////////
    String.prototype.contains = function(value) {
        return this.indexOf(value) >= 0;
    };

    String.prototype.startsWith = function(value) {
        return this.indexOf(value) === 0;
    };

    String.prototype.endsWith = function(value) {
        return this.indexOf(value) > -1 && this.indexOf(value) == (this.length - value.length);
    };

    String.prototype.count = function(value) {
        var reg = new RegExp(value, 'g');
        var result = this.match(reg);
        if (result) {
            return result.length;
        } else {
            return 0;
        }
    };

    String.prototype.size = function() {
        return this.length;
    };

    String.prototype.replaceAll = function(oldValue, newValue) {
        var reg;
        if (oldValue instanceof RegExp) {
            reg = new RegExp(oldValue.source, 'g');
        } else {
            reg = new RegExp(oldValue, 'g');
        }
        return this.replace(reg, newValue);
    };

    String.prototype.replaceFirst = function(oldValue, newValue) {
        return this.replace(oldValue, newValue);
    };


    String.prototype.reverse = function() {
        return this.split("").reverse().join("");
    };

    String.prototype.tokenize = function() {
        var str = " ";
        if (arguments.length == 1 && arguments[0]) {
            str = arguments[0];
        }
        var list = this.split(str);
        return gs.list(list);
    };

    String.prototype.multiply = function(value) {
        if (typeof(value) == 'number') {
            var result = '';
            var i;
            for (i=0; i < (value | 0); i++) {
                result = result + this;
            }
            return result;
        }
    };

    String.prototype.capitalize = function() {
        return this.charAt(0).toUpperCase() + this.slice(1);
    };

    String.prototype.each = function(closure) {
        var list = gs.list(this.split(''));
        list.each(closure);
    };

    String.prototype.inject = function(initial, closure) {
        var list = gs.list(this.split(''));
        return list.inject(initial, closure);
    };

    function getItemsMultiline(text) {
        var items = text.split('\n');
        if (items.length > 1 && items[items.length - 1] === '') {
            items.splice(items.length - 1, 1);
        }
        return items;
    }

    String.prototype.eachLine = function(closure) {
        var i, items = getItemsMultiline(this);
        for (i = 0; i < items.length; i++) {
            var item = items[i];
            //Closure with 2 arguments, line and count
            if (closure.length == 2) {
                closure(item, i);
            } else {
                closure(item);
            }
        }
    };

    String.prototype.readLines = function() {
        var items = getItemsMultiline(this);
        return gs.list(items);
    };

    String.prototype.padRight = function(number) {
        var sep = ' ';
        if (arguments.length==2) {
            sep = arguments[1];
        }
        var item = this;
        while (item.length < number) {
            item = item + sep;
        }
        return item;
    };

    String.prototype.padLeft = function(number) {
        var sep = ' ';
        if (arguments.length == 2) {
            sep = arguments[1];
        }
        var item = this;
        while (item.length < number) {
            item = sep + item;
        }
        return item;
    };

    String.prototype.isNumber = function() {
        if (this.trim() === '') {
            return false;
        } else {
            var res = Number(this);
            if (isNaN(res)) {
                return false;
            } else {
                return true;
            }
        }
    };

    String.prototype.plus = function(other) {
        var addText = 'null';
        if (other !== undefined && other !== null) {
            if (other['toString'] !== undefined) {
                addText = other.toString();
            } else {
                addText = other;
            }
        }
        return this + addText;
    };

    String.prototype.toInteger = function() {
        return parseInt(this);
    };

    /////////////////////////////////////////////////////////////////
    // Misc Functions
    /////////////////////////////////////////////////////////////////
    gs.classForName = function(name, obj) {
        var result = null;
        try {
            var pos = name.indexOf(".");
            while (pos >= 0) {
                name = name.substring(pos + 1);
                pos = name.indexOf(".");
            }
            result = (typeof globalThis!=="undefined"&&globalThis[name]!==undefined?globalThis[name]:undefined);
        } catch (err) {
            result = obj;
        }
        return result;
    };

    function StaticMethods(item) {
        this.gSparent = item;
    }

    gs.metaClass = function(item) {
        var type = typeof item;

        if (type == "string") {
            item = new String(item);
        } else if (type == "number") {
            item = new Number(item);
            //If type is a function, it's metaClass from a Class
        } else if (type === "function") {
            if (!globalMetaClass[item.name]) {
                globalMetaClass[item.name] = {
                    gSstatic: new StaticMethods(item),
                    getStatic : function() {
                        return this.gSstatic;
                    }
                };
            }
            item = globalMetaClass[item.name];
        }
        return item;
    };

    gs.passMapToObject = function(source, destination) {
        var prop;
        for (prop in source) {
            if (isFunction(source[prop])) continue;
            if (!isMapProperty(prop)) {
                gs.sp(destination, prop, source[prop]);
            }
        }
    };

    gs.equals = function(value1, value2) {
        if (!hasFunc(value1, 'equals')) {
            if (hasFunc(value2, 'equals')) {
                return value2.equals(value1);
            } else {
                return value1==value2;
            }
        } else {
            return value1.equals(value2);
        }
    };

    gs.is = function(value1, value2) {
        if (value1 !== null && hasFunc(value1, 'is')) {
            var count, params = gs.list([value2]);
            for (count = 2; count < arguments.length; count++) {
                params.add(arguments[count]);
            }
            return gs.mc(value1, 'is', params);
        } else {
            return value1 == value2;
        }
    };

    function interceptClosureCall(func, param) {
        if ((param instanceof Array) && func.length > 1) {
            return func.apply(func, param);
        } else {
            return func(param);
        }
    }

    gs.random = function() {
        var object = gs.init('Random');
        object.nextInt = function(number) {
            var ran = Math.ceil(Math.random()*number);
            return ran - 1;
        };
        object.nextBoolean = function() {
            var ran = Math.random();
            return ran < 0.5;
        };
        return object;
    };

    gs.bool = function(item) {
        if (item && item.isEmpty !== undefined) {
            return !item.isEmpty();
        } else {
            if (item) {
                if (item['asBoolean']) {
                    return item['asBoolean']();
                } else if (typeof(item) == 'number' && item === 0) {
                    return false;
                } else if (typeof(item) == 'string') {
                    return item !== '';
                }
            }
            return item;
        }
    };

    gs.less = function(itemLeft, itemRight) {
        return itemLeft < itemRight;
    };

    gs.greater = function(itemLeft, itemRight) {
        return itemLeft > itemRight;
    };

    // Operator <=>
    gs.spaceShip = function(itemLeft, itemRight) {
        if (gs.equals(itemLeft, itemRight)) {
            return 0;
        }
        if (gs.less(itemLeft, itemRight)) {
            return -1;
        }
        if (gs.greater(itemLeft, itemRight)) {
            return 1;
        }
    };

    //InstanceOf function
    gs.instanceOf = function(item, name) {
        var gotIt = false;

        if (name == "String")  {
            return typeof(item) == 'string';
        } else if (name == "Number") {
            return typeof(item) == 'number';
        } else if (item.clazz) {
            var classInfo;
            classInfo = item.clazz;
            while (classInfo && !gotIt) {
                if (classInfoContainsName(classInfo, name)) {
                    gotIt = true;
                } else {
                    classInfo = classInfo.superclass;
                }
            }
            if (!gotIt && item.clazz.interfaces) {
                var i;
                for (i = 0; i < item.clazz.interfaces.length && !gotIt; i++) {
                    if (classInfoContainsName(item.clazz.interfaces[i], name)) {
                        gotIt = true;
                    }
                }
            }
        } else if (isFunction(item) && name == 'Closure') {
            gotIt = true;
        }
        return gotIt;
    };

    function classInfoContainsName(classInfo, name) {
        return classInfo.name == name || classInfo.simpleName == name;
    }

    //Elvis operator
    gs.elvis = function(booleanExpression, trueExpression, falseExpression) {
        if (gs.bool(booleanExpression)) {
            return trueExpression;
        } else {
            return falseExpression;
        }
    };

    // * operator
    gs.multiply = function(a, b) {
        if (!hasFunc(a, 'multiply')) {
            return a * b;
        } else {
            return a.multiply(b);
        }
    };

    // / operator
    gs.div = function(a, b) {
        if (!hasFunc(a, 'div')) {
            return a / b;
        } else {
            return a.div(b);
        }
    };

    // ** operator
    gs.power = function(a, b) {
        if (!hasFunc(a, 'power')) {
            return Math.pow(a, b);
        } else {
            return a.power(b);
        }
    };

    // mod operator
    gs.mod = function(a, b) {
        if (!hasFunc(a, 'mod')) {
            return a % b;
        } else {
            return a.mod(b);
        }
    };

    // + operator
    gs.plus = function(a, b) {
        if (!hasFunc(a, 'plus')) {
            if ((typeof a == 'number') && (typeof b == 'number') && (a + b < 1)) {
                return ((a * 1000) + (b * 1000)) / 1000;
            } else {
                return a + b;
            }
        } else {
            return a.plus(b);
        }
    };

    // - operator
    gs.minus = function(a, b) {
        if (!hasFunc(a, 'minus')) {
            return a - b;
        } else {
            return a.minus(b);
        }
    };

    // in operator
    gs.gSin = function(item, group) {
        if (group && (isFunction(group.contains))) {
            return group.contains(item);
        } else {
            return false;
        }
    };

    //For some special cases where access a property with this."${name}"
    //This can be a closure
    gs.thisOrObject = function(thisItem, objectItem) {
        return objectItem || thisItem;
    };

    // spread operator (*)
    gs.spread = function(item) {
        if (item && item instanceof Array) {
            this.values = item;
        }
    };

    /////////////////////////////////////////////////////////////////
    // Beans functions - From groovy beans
    /////////////////////////////////////////////////////////////////
    //If an object has a function by name
    function hasFunc(item, name) {
        if (item === null || item === undefined || item[name] === undefined ||
            (!isFunction(item[name]))) {
            return false;
        } else {
            return true;
        }
    }

    //Set a property of a class
    gs.sp = function(item, nameProperty, value) {

        if (nameProperty == 'setProperty') {
            item[nameProperty] = value;
        } else if (nameProperty == 'getProperty') {
            item[nameProperty] = value;
        } else if (item !== null && item instanceof StaticMethods) {
            item[nameProperty] = value;
            item.gSparent[nameProperty] = value;
        } else {
            if (nameProperty === 'methodMissing' && value) {
                item[nameProperty] = value;
            } else if (!item['setProperty']) {
                var nameFunction = 'set' + nameProperty.charAt(0).toUpperCase() + nameProperty.slice(1);

                if (!item[nameFunction]) {
                    if (item[nameProperty] === undefined &&
                        item.setPropertyMissing !== undefined &&
                        isFunction(item.setPropertyMissing)) {
                        item.setPropertyMissing(nameProperty, value);
                    } else {
                        item[nameProperty] = value;
                    }
                } else {
                    item[nameFunction](value);
                }
            } else {
                item.setProperty(nameProperty,value);
            }
        }
    };

    //Get a property of a class
    gs.gp = function(item, nameProperty, inDelegates) {

        //It's a get with safe operator as item?.data
        if (arguments.length == 3) {
            if (item === null || item === undefined) {
                return null;
            }
        } else if (item == null || item === undefined) {
            throw 'gs.gp Get property: ' + nameProperty + ' on null or undefined object.'
        }

        if (!item['getProperty']) {
            return propFromObject(item, nameProperty, inDelegates);
        } else {
            var res = item.getProperty(nameProperty);
            return (res !== undefined ? res : propFromObject(item, nameProperty, inDelegates))
        }
    };

    function propFromObject(item, nameProperty, inDelegates) {
        var nameFunction = 'get' + nameProperty.charAt(0).toUpperCase() + nameProperty.slice(1);
        if (!item[nameFunction]) {
            if (nameProperty == 'size' && isFunction(item[nameProperty])) {
                return item[nameProperty]();
            } else {
                if (item[nameProperty] !== undefined) {
                    return item[nameProperty];
                } else {
                    //Lets check gp in @Delegate
                    if (item.clazz !== undefined) {
                        var addDelegate = mapAddDelegate[item.clazz.simpleName];
                        if (addDelegate !== null && addDelegate !== undefined) {
                            var i;
                            for (i = 0; i < addDelegate.length; i++) {
                                var prop = addDelegate[i];
                                var target = item[prop][nameProperty];
                                if (target !== undefined) {
                                    return item[prop][nameProperty];
                                }
                            }
                        }
                    }
                    //Default value of a map
                    if (item.gSdefaultValue !== undefined && (isFunction(item.gSdefaultValue))) {
                        item[nameProperty] = item.gSdefaultValue();
                    }
                    //Maybe in categories
                    if (categories.length > 0 && item[nameProperty] === undefined) {
                        var whereExecutes = categorySearching(nameFunction);
                        if (whereExecutes !== null) {
                            return whereExecutes[nameFunction].apply(item, [item]);
                        }
                    }

                    if (item.propertyMissing !== undefined && isFunction(item.propertyMissing)) {
                        return item.propertyMissing(nameProperty);
                    } else {
                        if (!inDelegates && delegates.length > 0) {
                            return findPropertyInDelegates(nameProperty, item);
                        } else {
                            return item[nameProperty];
                        }
                    }
                }
            }
        } else {
            return item[nameFunction]();
        }
    }

    function findPropertyInDelegates(nameProperty, item) {
        var i = delegates.length;
        var found = false;
        var result;
        while (i > 0 && !found && item ) {
            i = i - 1;
            result = gs.gp(delegates[i], nameProperty, true);
            if (result !== undefined) {
                found = true;
            }
        }
        return result;
    }

    //Control property changes with ++,--
    gs.plusPlus = function(item, nameProperty, plus, before) {
        var value = gs.gp(item, nameProperty);
        var newValue = value;
        if (plus) {
            gs.sp(item, nameProperty, value + 1);
            newValue++;
        } else {
            gs.sp(item, nameProperty, value - 1);
            newValue--;
        }
        if (before) {
            return newValue;
        } else {
            return value;
        }
    };

    function exFn(we, mn, it, val) {
        return we[mn].apply(it, joinParameters(it, val));
    }

    //Control all method calls
    gs.mc = function(item, methodName, values, objectVar, isSafe) {

        if (gs.consoleInfo && console) {
            console.log('[INFO] gs.mc (' + item + ').' + methodName + ' params:' + values);
        }

        if (item === null || item === undefined) {
            if (isSafe) {
                return null;
            } else {
                throw 'gs.mc Calling method: ' + methodName + ' on null or undefined object.';
            }
        }

        if (methodName == 'split' && typeof(item) == 'string') {
            return item.tokenize(values[0]);
        }
        if (methodName == 'length' && typeof(item) == 'string') {
            return item.length;
        }
        if (methodName == 'join' && (item instanceof Array)) {
            if (values.size() > 0) {
                return item.gSjoin(values[0]);
            } else {
                return item.gSjoin();
            }
        }

        if (objectVar) {
            try {
                //First, try to execute function in object
                return gs.mc(objectVar, methodName, values);
            } catch(e) {}
        }

        if (!item[methodName]) {

            if (methodName.startsWith('get') || methodName.startsWith('set')) {
                var varName = getterSetterRemove(methodName);
                if (item[varName] !== undefined && !hasFunc(item, varName)) {
                    if (methodName.startsWith('get')) {
                        return gs.gp(item, varName);
                    } else {
                        return gs.sp(item, varName, values[0]);
                    }
                }
            }

            if (methodName.startsWith('is')) {
                var varName = methodName.charAt(2).toLowerCase() + methodName.slice(3);
                if (item[varName] !== undefined && !hasFunc(item, varName)) {
                    return gs.gp(item, varName);
                }
            }

            //Check newInstance
            if (methodName=='newInstance') {
                return item();
            } else {
                var whereExecutes;
                //Lets check if in any category we have the static method
                if (categories.length > 0) {
                    whereExecutes = categorySearching(methodName);
                    if (whereExecutes !== null) {
                        return exFn(whereExecutes, methodName, item, values);
                    }
                }

                //In @Category
                var ob;
                for (ob in annotatedCategories) {
                    if (annotatedCategories[ob] == item.clazz.simpleName) {
                        var categoryItem = gs.myCategories[ob]();
                        if (categoryItem[methodName] && isFunction(categoryItem[methodName])) {
                            return exFn(categoryItem, methodName, item, values);
                        }
                    }
                }

                //Lets check in mixins classes
                if (mixins.length > 0) {
                    whereExecutes = mixinSearching(item, methodName);
                    if (whereExecutes !== null) {
                        return exFn(whereExecutes, methodName, item, values);
                    }
                }

                //Lets check in mixins objects
                if (mixinsObjects.length > 0) {
                    whereExecutes = mixinObjectsSearching(item, methodName);
                    if (whereExecutes !== null) {
                        return exFn(whereExecutes, methodName, item, values);
                    }
                }
                //Lets check mc in @Delegate
                if (item.clazz !== undefined) {
                    var addDelegate = mapAddDelegate[item.clazz.simpleName];
                    if (addDelegate) {
                        var i;
                        for (i = 0; i < addDelegate.length; i++) {
                            var prop = addDelegate[i];
                            var target = item[prop][methodName];
                            if (target !== undefined) {
                                return exFn(item[prop], methodName, item[prop], values);
                            }
                        }
                    }
                }

                //Lets check in delegate
                if (delegates.length > 0) {
                    var delegateFunc = delegatesFunc(methodName);
                    if (delegateFunc) {
                        return delegateFunc[methodName].apply(item, values);
                    }
                }

                if (item.methodMissing) {
                    return item.methodMissing(methodName, values);
                } else if (delegates.length > 0 && delegatesFunc('methodMissing')) {
                    return gs.mc(delegatesFunc('methodMissing'), methodName, values);
                } else {
                    if (item.invokeMethod && item.invokeMethod !== BaseClass.prototype.invokeMethod) {
                        return item.invokeMethod(methodName, values);
                    } else {
                        //Maybe there is a function in the script with the name of the method
                        //In Node.js 'this.xxFunction()' in the main context fails
                        if (isFunction((typeof globalThis!=="undefined"&&typeof globalThis[methodName]==="function"?globalThis[methodName]:undefined))) {
                            return (typeof globalThis!=="undefined"&&typeof globalThis[methodName]==="function"?globalThis[methodName]:undefined).apply(this, values);
                        }

                        //Not exist the method, throw exception
                        throw 'gs.mc Method ' + methodName + ' not exist in ' + item;
                    }
                }
            }

        } else {
            var f = item[methodName];
            if (f['apply']) {
                return f.apply(item, values);
            } else {
                return gs.execCall(f, item, values);
            }
        }
    };

    function delegatesFunc(nameMethod) {
        var result = null;
        if (delegates.length > 0) {
            var i;
            for (i = delegates.length - 1; i >= 0 && !result; i--) {
                if (delegates[i][nameMethod]) {
                    result = delegates[i];
                }
            }
        }
        return result;
    }

    function joinParameters(item, items) {
        var listParameters = [item],i;
        for (i=0; i < items.size(); i++) {
            listParameters.push(items[i]);
        }
        return listParameters;
    }

    ////////////////////////////////////////////////////////////
    // Categories
    ////////////////////////////////////////////////////////////
    gs.categoryUse = function(item, itemClass, closure) {
        var ob, categoryCreated;
        if (existAnnotatedCategory(item)) {
            categoryCreated = gs.myCategories[item]();
            for (ob in categoryCreated) {
                if (!isObjectProperty(ob) && !isConstructor(ob, categoryCreated[ob]) &&
                    isFunction(categoryCreated[ob])) {
                    addFunctionToClassIfPrototyped(ob, categoryCreated[ob], annotatedCategories[item]);
                }
            }
        } else {
            categories.push(itemClass);
        }
        closure();
        if (existAnnotatedCategory(item)) {
            categoryCreated = gs.myCategories[item]();
            for (ob in categoryCreated) {
                if (!isObjectProperty(ob) && !isConstructor(ob, categoryCreated[ob]) &&
                    isFunction(categoryCreated[ob])) {
                    removeFunctionToClass(ob, categoryCreated[ob], annotatedCategories[item]);
                }
            }
        } else {
            categories.splice(categories.length - 1, 1);
        }
    };

    function getPrototypeOfClass(className) {
        if (className == 'String') {
            return String.prototype;
        }
        if (className == 'Number') {
            return Number.prototype;
        }
        if (className == 'ArrayList') {
            return Array.prototype;
        }
        return null;
    }

    function addFunctionToClassIfPrototyped(name, func, className) {
        var proto = getPrototypeOfClass(className);
        if  (proto !== null) {
            if (proto[name] === undefined) {
                proto[name] = func;
            }
        }
    }

    function removeFunctionToClass(name, func, className) {
        var proto = getPrototypeOfClass(className);
        if  (proto !== null) {
            if (proto[name] == func) {
                proto[name] = null;
            }
        }
    }

    function categorySearching(methodName) {
        var i, result = null;
        for (i = categories.length - 1; i >= 0 && result === null; i--) {
            var itemClass = categories[i];
            if (itemClass[methodName]) {
                result = itemClass;
            }
        }
        return result;
    }

    function existAnnotatedCategory(name) {
        return (annotatedCategories[name] !== null && annotatedCategories[name] !== undefined);
    }

    var annotatedCategories = {};
    gs.addAnnotatedCategory = function(nameCategory, nameClass) {
        annotatedCategories[nameCategory] = nameClass;
    };

    ////////////////////////////////////////////////////////////
    // Mixins
    ////////////////////////////////////////////////////////////
    gs.mixinClass = function(item, classes) {

        //First check in that class has mixins
        var gotIt = false;
        if (mixins.length > 0) {
            var i;
            for (i = 0; i < mixins.length && !gotIt; i++) {
                if (mixins[i].name == item) {
                    var j;
                    for (j=0; j < classes.length; j++) {
                        mixins[i].items.push(classes[j]);
                    }
                    gotIt = true;
                }
            }
        }
        if (!gotIt) {
            mixins.push({ name: item, items: classes});
        }
    };

    gs.mixinObject = function(item, classes) {

        var gotIt = false;
        if (mixinsObjects.length > 0) {
            var i;
            for (i = 0; i < mixinsObjects.length && !gotIt; i++) {
                if (mixinsObjects[i].item == item) {
                    var j;
                    for (j = 0; j < classes.length; j++) {
                        mixinsObjects[i].items.push(classes[j]);
                    }
                    gotIt = true;
                }
            }
        }
        if (!gotIt) {
            mixinsObjects.push({ item: item, items: classes});
        }
        //TODO make any kinda cleanup if mixinsObjects growing
    };

    function mixinSearching(item, methodName) {
        var result = null, className = null;
        if (typeof(item) == 'string') {
            className = 'String';
        }
        if (item.clazz && item.clazz.simpleName && typeof(item) == 'object') {
            className = item.clazz.simpleName;
        }
        if (className !== null) {
            var i, ourMixin=null;
            for (i = mixins.length - 1; i >= 0 && ourMixin === null; i--) {
                var data = mixins[i];
                if (data.name == className) {
                    ourMixin = data.items;
                }
            }
            if (ourMixin !== null) {
                for (i = 0; i < ourMixin.length && result === null; i++) {
                    if (ourMixin[i][methodName]) {
                        result = ourMixin[i];
                    } else {
                        var classItem = ourMixin[i]();
                        if (classItem) {
                            var notStatic = classItem[methodName];
                            if (notStatic !== null && isFunction(notStatic)) {
                                result = classItem;
                            }
                        }
                    }
                }
            }
        }

        return result;
    }

    function mixinObjectsSearching(item, methodName) {

        var result = null, i, ourMixin = null;
        for (i = mixinsObjects.length - 1; i >= 0 && ourMixin === null; i--) {
            var data = mixinsObjects[i];
            if (data.item == item) {
                ourMixin = data.items;
            }
        }
        if (ourMixin !== null) {
            for (i=0 ; i < ourMixin.length && result === null; i++) {
                if (ourMixin[i][methodName]) {
                    result = ourMixin[i];
                }
            }
        }

        return result;
    }

    ////////////////////////////////////////////////////////////
    // StringBuffer - very basic support, for add with <<
    ////////////////////////////////////////////////////////////
    gs.stringBuffer = function() {

        var object = gs.init('StringBuffer');
        object.value = '';

        if (arguments.length == 1 && typeof arguments[0] === 'string') {
            object.value = arguments[0];
        }

        object.toString = function() {
            return this.value;
        };

        object.leftShift = function(value) {
            return this.append(value);
        };

        object.plus = function(value) {
            return this.append(value);
        };

        object.size = function() {
            return this.value.length;
        };

        object.append = function(value) {
            this.value = this.value + value;
            return this;
        };
        return object;
    };

    ////////////////////////////////////////////////////////////
    // @Delegate
    ////////////////////////////////////////////////////////////
    gs.astDelegate = function (baseClass, nameField) {
        var currentDelegate = mapAddDelegate[baseClass];
        if (currentDelegate === null || currentDelegate === undefined) {
            currentDelegate = [];
        }
        currentDelegate.push(nameField);
        mapAddDelegate[baseClass] = currentDelegate;
    };

    ////////////////////////////////////////////////////////////
    // Delegate
    ////////////////////////////////////////////////////////////
    function applyDelegate (func, delegate, params) {
        delegates.push(delegate);
        var result = func.apply(delegate, params);
        delegates.pop();
        return result;
    }

    gs.execCall = function (func, thisObject, params) {
        if (func.delegate !== undefined) {
            return applyDelegate(func, func.delegate, params);
        } else {
            if (func['call'] !== undefined && typeof func === 'object') {
                return func['call'].apply(func, params);
            } else {
                return func.apply(thisObject, params);
            }
        }
    };

    ////////////////////////////////////////////////////////////
    // Functional
    ////////////////////////////////////////////////////////////
    Function.prototype.curry = function () {
        var slice = Array.prototype.slice,
            args = slice.apply(arguments),
            that = this;
        return function () {
            return that.apply(null, args.concat(slice.apply(arguments)));
        };
    };

    Function.prototype.rcurry = function () {
        var slice = Array.prototype.slice,
            args = slice.apply(arguments),
            that = this;
        return function () {
            return that.apply(null, (slice.apply(arguments)).concat(args));
        };
    };

    Function.prototype.ncurry = function () {
        var slice = Array.prototype.slice,
            args = slice.apply(arguments, [1]),
            begin = arguments[0],
            that = this;
        return function () {
            return that.apply(null, slice.apply(arguments, [0, begin]).concat(args).concat(slice.apply(arguments, [begin])));
        };
    };

    Function.prototype.leftShift = function () {
        var func = arguments[0],
            that = this;
        return function () {
            return that(func.apply(null, arguments));
        };
    };

    Function.prototype.rightShift = function () {
        var func = arguments[0],
            that = this;
        return function () {
            return func(that.apply(null, arguments));
        };
    };

    Function.prototype.run = function() {
        return this();
    };

    Function.prototype.memoize = function() {
        var that = this;
        that._input = [];
        that._output = [];
        return function() {
            var i, result, foundPos = -1, inputs = Array.prototype.slice.call(arguments);
            for (i = 0; i < that._input.length && foundPos < 0; i++) {
                if (gs.equals(inputs, that._input[i])) {
                    foundPos = i;
                }
            }
            if (foundPos > -1) {
                result = that._output[foundPos];
            } else {
                that._input.push(inputs);
                result = that.apply(null, inputs);
                that._output.push(result);
            }
            return result;
        };
    };

    //MISC Find scope of a var
    gs.fs = function(name, thisScope, objScope) {
        if (objScope && objScope[name] !== undefined) {
            return objScope[name];
        } else if (thisScope && thisScope[name] !== undefined) {
            return thisScope[name];
        } else {
            var value = gs.gp(thisScope, name);
            if (value === undefined) {
                if (aStT && aStT[name] !== undefined) {
                    return aStT[name];
                } else {
                    var func = new Function("return " + name);
                    return func();
                }
            } else {
                return value;
            }
        }
    };

    //Convert a groovy object to javascript, but only properties
    gs.toJavascript = function(obj) {
        if (obj && gs.isGroovyObj(obj)) {
            var result;
            if (obj && !isFunction(obj)) {
                if (obj instanceof Array) {
                    result = [];
                    var i;
                    for (i = 0; i < obj.length; i++) {
                        result.push(gs.toJavascript(obj[i]));
                    }
                } else {
                    if (obj instanceof Object) {
                        result = {};
                        var ob;
                        for (ob in obj) {
                            if (!isMapProperty(ob) && !isFunction(obj[ob])) {
                                result[ob] = gs.toJavascript(obj[ob]);
                            }
                        }
                    } else {
                        result = obj;
                    }
                }
            }
            return result;
        } else {
            return obj;
        }
    };

    //Convert a javascript object to 'groovy', if you define groovy type, will use it, and not a map
    gs.toGroovy = function(obj, objClass) {
        var result;
        if (obj !== undefined && !isFunction(obj)) {
            if (obj instanceof Array) {
                result = gs.list([]);
                var i;
                for (i = 0; i < obj.length; i++) {
                    result.add(gs.toGroovy(obj[i], objClass));
                }
            } else {
                if (obj instanceof Object) {
                    var ob;
                    result = (objClass ? objClass() : gs.map());
                    for (ob in obj) {
                        result[ob] = gs.toGroovy(obj[ob]);
                    }
                } else {
                    result = obj;
                }
            }
        }
        return result;
    };

    gs.toNumber = function(number) {
        if (number) {
            if (typeof(number) == 'string') {
                return parseFloat(number);
            } else {
                return number;
            }
        }
    };

    gs.isGroovyObj = function(maybeGroovyObject) {
        return maybeGroovyObject !== null && maybeGroovyObject !== undefined && maybeGroovyObject.clazz !== undefined;
    };

    gs.execStatic = function(obj, methodName, thisObject, params) {
        var old = aStT;
        aStT = thisObject;
        var res = obj[methodName].apply(thisObject, params);
        aStT = old;
        return res;
    };

    gs.asChar = function(value) {
        return value.charCodeAt(0);
    };

    //Convert a groovy map to javascript object, including functions in the map
    gs.toJsObj = function(obj) {
        if (gs.isGroovyObj(obj)) {
            var ob, result = {};
            for (ob in obj) {
                if (!isMapProperty(ob)) {
                    if (isFunction(obj[ob])) {
                        result[ob] = obj[ob];
                    } else {
                        result[ob] = gs.toJsObj(obj[ob]);
                    }
                }
            }
            return result;
        } else {
            return obj;
        }
    };

}).call(this);function HtmlBuilder() {
  var gSobject = gs.init('HtmlBuilder');
  gSobject.clazz = { name: 'org.grooscript.builder.HtmlBuilder', simpleName: 'HtmlBuilder'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.tagSolver = function(name, args) {
    gSobject.htmCd += "<" + (name) + "";
    if ((((gs.bool(args)) && (gs.mc(args,"size",[]) > 0)) && (!gs.bool(gs.instanceOf((args[0]), "String")))) && (!gs.bool(gs.instanceOf((args[0]), "Closure")))) {
      gs.mc(args[0],"each",[function(key, value) {
        return gSobject.htmCd += " " + (key) + "='" + (value) + "'";
      }]);
    };
    gSobject.htmCd += (!gs.bool(args) ? "/>" : ">");
    if (gs.bool(args)) {
      if ((gs.equals(gs.mc(args,"size",[]), 1)) && (gs.instanceOf((args[0]), "String"))) {
        gs.mc(gSobject,"yield",[args[0]]);
      } else {
        var lastArg = gs.mc(args,"last",[]);
        if (gs.instanceOf(lastArg, "Closure")) {
          gs.sp(lastArg,"delegate",this);
          gs.execCall(lastArg, this, []);
        };
        if ((gs.instanceOf(lastArg, "String")) && (gs.mc(args,"size",[]) > 1)) {
          gs.mc(gSobject,"yield",[lastArg]);
        };
      };
      return gSobject.htmCd += "</" + (name) + ">";
    };
  };
  gSobject.htmCd = null;
  gSobject.build = function(x0) { return HtmlBuilder.build(x0); }
  gSobject['yield'] = function(text) {
    return gs.mc(text,"each",[function(ch) {
      var gSswitch0 = ch;
      if (gs.equals(gSswitch0, "&")) {
        gSobject.htmCd += "&amp;";
        ;
      } else if (gs.equals(gSswitch0, "<")) {
        gSobject.htmCd += "&lt;";
        ;
      } else if (gs.equals(gSswitch0, ">")) {
        gSobject.htmCd += "&gt;";
        ;
      } else if (gs.equals(gSswitch0, "\"")) {
        gSobject.htmCd += "&quot;";
        ;
      } else if (gs.equals(gSswitch0, "'")) {
        gSobject.htmCd += "&apos;";
        ;
      } else {
        gSobject.htmCd += ch;
        ;
      };
    }]);
  }
  gSobject['yieldUnescaped'] = function(text) {
    return gSobject.htmCd += text;
  }
  gSobject['comment'] = function(text) {
    return gSobject.htmCd += (gs.plus((gs.plus("<!--", text)), "-->"));
  }
  gSobject['newLine'] = function(it) {
    return gSobject.htmCd += "\n";
  }
  gSobject['methodMissing'] = function(name, args) {
    gs.sp(this,"" + (name) + "",function(ars) {
      if (arguments.length == 1 && arguments[0] instanceof Array) { ars=gs.list(arguments[0]); } else 
      if (arguments.length == 1) { ars=gs.list([arguments[1 - 1]]); } else 
      if (arguments.length < 1) { ars=gs.list([]); } else 
      if (arguments.length > 1) {
        ars=gs.list([ars]);
        for (gScount=1;gScount < arguments.length; gScount++) {
          ars.add(arguments[gScount]);
        }
      }
      return gs.mc(gSobject,"tagSolver",[name, ars]);
    });
    return gs.mc(this,"invokeMethod",[name, args], gSobject);
  }
  gSobject['HtmlBuilder0'] = function(it) {
    gSobject.htmCd = "";
    return this;
  }
  if (arguments.length==0) {gSobject.HtmlBuilder0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
HtmlBuilder.build = function(closure) {
  var mc = gs.expandoMetaClass(HtmlBuilder, false, true);
  gs.mc(mc,"initialize",[]);
  var builder = HtmlBuilder();
  gs.sp(builder,"metaClass",mc);
  gs.sp(closure,"delegate",builder);
  gs.execCall(closure, this, []);
  return gs.gp(builder,"htmCd");
}

function Observable() {
  var gSobject = gs.init('Observable');
  gSobject.clazz = { name: 'org.grooscript.rx.Observable', simpleName: 'Observable'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.subscribers = gs.list([]);
  gSobject.sourceList = null;
  gSobject.chain = gs.list([]);
  gSobject.listen = function() { return Observable.listen(); }
  gSobject.from = function(x0) { return Observable.from(x0); }
  gSobject['produce'] = function(event) {
    return gs.mc(gSobject.subscribers,"each",[function(it) {
      return gs.mc(gSobject,"processFunction",[event, it]);
    }]);
  }
  gSobject['map'] = function(cl) {
    gs.mc(gSobject.chain,'leftShift', gs.list([cl]));
    return this;
  }
  gSobject['filter'] = function(cl) {
    gs.mc(gSobject.chain,'leftShift', gs.list([function(it) {
      if (gs.execCall(cl, this, [it])) {
        return it;
      } else {
        throw "Exception";
      };
    }]));
    return this;
  }
  gSobject['subscribe'] = function(cl) {
    while (gs.bool(gSobject.chain)) {
      cl = (gs.mc(cl,'leftShift', gs.list([gs.mc(gSobject.chain,"pop",[])])));
    };
    gs.mc(gSobject.subscribers,'leftShift', gs.list([cl]));
    if (gs.bool(gSobject.sourceList)) {
      return gs.mc(gSobject.sourceList,"each",[function(it) {
        return gs.mc(gSobject,"processFunction",[it, cl]);
      }]);
    };
  }
  gSobject['removeSubscribers'] = function(it) {
    return gSobject.subscribers = gs.list([]);
  }
  gSobject['processFunction'] = function(data, cl) {
    try {
      gs.execCall(cl, this, [data]);
    }
    catch (e) {
    }
    ;
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
Observable.listen = function(it) {
  return Observable();
}
Observable.from = function(list) {
  return Observable(gs.map().add("sourceList",list));
}

function GQueryImpl() {
  var gSobject = gs.init('GQueryImpl');
  gSobject.clazz = { name: 'org.grooscript.jquery.GQueryImpl', simpleName: 'GQueryImpl'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.clazz.interfaces = [{ name: 'org.grooscript.jquery.GQuery', simpleName: 'GQuery'}];
  gSobject['bind'] = function(selector, target, nameProperty, closure) {
    if (closure === undefined) closure = null;
    return gs.mc(gs.execStatic(GQueryList,'of', this,[selector]),"bind",[target, nameProperty, closure]);
  }
  gSobject['bindProperty'] = function(selector, target, nameProperty, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"bind",[target, nameProperty]);
  }
  gSobject['existsSelector'] = function(selector, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"hasResults",[]);
  }
  gSobject['existsId'] = function(id, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",["#" + (id) + "", parent]),"hasResults",[]);
  }
  gSobject['existsName'] = function(name, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",["[name='" + (name) + "']", parent]),"hasResults",[]);
  }
  gSobject['existsGroup'] = function(name, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",["input:radio[name='" + (name) + "']", parent]),"hasResults",[]);
  }
  gSobject['onEvent'] = function(selector, nameEvent, func, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"onEvent",[nameEvent, func]);
  }
  gSobject.doRemoteCall = function(url, type, params, onSuccess, onFailure, objectResult) {
    if (objectResult === undefined) objectResult = null;
    $.ajax({
            type: type, //GET or POST
            data: gs.toJavascript(params),
            url: url,
            dataType: 'text'
        }).done(function(newData) {
            if (onSuccess) {
                onSuccess(gs.toGroovy(jQuery.parseJSON(newData), objectResult));
            }
        })
        .fail(function(error) {
            if (onFailure) {
                onFailure(error);
            }
        });
  }
  gSobject.onReady = function(func) {
    $(document).ready(func);
  }
  gSobject['attachMethodsToDomEvents'] = function(obj, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.gp((obj = gs.metaClass(obj)),"methods"),"each",[function(method) {
      if (gs.mc(gs.gp(method,"name"),"endsWith",["Click"])) {
        var shortName = gs.mc(gs.gp(method,"name"),"substring",[0, gs.minus(gs.mc(gs.gp(method,"name"),"length",[]), 5)]);
        if (gs.mc(gSobject,"existsId",[shortName, parent])) {
          gs.mc(gSobject,"onEvent",[gs.plus("#", shortName), "click", obj["" + (gs.gp(method,"name")) + ""], parent]);
        };
      };
      if (gs.mc(gs.gp(method,"name"),"endsWith",["Submit"])) {
        var shortName = gs.mc(gs.gp(method,"name"),"substring",[0, gs.minus(gs.mc(gs.gp(method,"name"),"length",[]), 6)]);
        if (gs.mc(gSobject,"existsId",[shortName, parent])) {
          gs.mc(gSobject,"onEvent",[gs.plus("#", shortName), "submit", gs.mc(obj["" + (gs.gp(method,"name")) + ""],'leftShift', gs.list([function(it) {
            return gs.mc(it,"preventDefault",[]);
          }])), parent]);
        };
      };
      if (gs.mc(gs.gp(method,"name"),"endsWith",["Change"])) {
        var shortName = gs.mc(gs.gp(method,"name"),"substring",[0, gs.minus(gs.mc(gs.gp(method,"name"),"length",[]), 6)]);
        if (gs.mc(gSobject,"existsId",[shortName, parent])) {
          return gs.mc(gSobject,"onChange",[gs.plus("#", shortName), obj["" + (gs.gp(method,"name")) + ""], parent]);
        };
      };
    }]);
  }
  gSobject['onChange'] = function(selector, closure, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"onChange",[closure]);
  }
  gSobject['focusEnd'] = function(selector, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.mc(gSobject,"resolveSelector",[selector, parent]),"focusEnd",[]);
  }
  gSobject['bindAllProperties'] = function(target, parent) {
    if (parent === undefined) parent = null;
    return gs.mc(gs.gp(target,"properties"),"each",[function(name, value) {
      if (gs.mc(gSobject,"existsId",[name, parent])) {
        gs.mc(gSobject,"bindProperty",["#" + (name) + "", target, name, parent]);
      };
      if (gs.mc(gSobject,"existsName",[name, parent])) {
        gs.mc(gSobject,"bindProperty",["[name='" + (name) + "']", target, name, parent]);
      };
      if (gs.mc(gSobject,"existsGroup",[name, parent])) {
        return gs.mc(gSobject,"bindProperty",["input:radio[name='" + (name) + "']", target, name, parent]);
      };
    }]);
  }
  gSobject['bindAll'] = function(target, parent) {
    if (parent === undefined) parent = null;
    gs.mc(gSobject,"bindAllProperties",[target, parent]);
    return gs.mc(gSobject,"attachMethodsToDomEvents",[target, parent]);
  }
  gSobject['observeEvent'] = function(selector, nameEvent, data) {
    if (data === undefined) data = gs.map();
    var observable = gs.execStatic(Observable,'listen', this,[]);
    gs.mc(gs.execCall(this, this, [selector]),"on",[nameEvent, data, function(event) {
      return gs.mc(observable,"produce",[event]);
    }]);
    return observable;
  }
  gSobject['call'] = function(selector) {
    return gs.execStatic(GQueryList,'of', this,[selector]);
  }
  gSobject['resolveSelector'] = function(selector, parent) {
    return gs.execStatic(GQueryList,'of', this,[(parent != null ? gs.mc(parent,"find",[selector]) : selector)]);
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};

function GQueryList() {
  var gSobject = gs.init('GQueryList');
  gSobject.clazz = { name: 'org.grooscript.jquery.GQueryList', simpleName: 'GQueryList'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.list = null;
  gSobject.of = function(x0) { return GQueryList.of(x0); }
  gSobject.methodMissing = function(name, args) {
    return gSobject.list[name].apply(gSobject.list, args);
  }
  gSobject.withResultList = function(cl) {
    if (gSobject.list.length) {
            cl(gSobject.list.toArray());
        }
        return gSobject;
  }
  gSobject.hasResults = function() {
    return gSobject.list.length > 0;
  }
  gSobject.onEvent = function(nameEvent, cl) {
    gSobject.list.on(nameEvent, cl);
        return gSobject;
  }
  gSobject.onChange = function(cl) {
    var jq = gSobject.list;

        if (jq.is(":text")) {
            jq.bind('input', function() {
                cl($(this).val());
            });
        } else if (jq.is('textarea')) {
            jq.bind('input propertychange', function() {
                cl($(this).val());
            });
        } else if (jq.is(":checkbox")) {
            jq.change(function() {
                cl($(this).is(':checked'));
            });
        } else if (jq.is(":radio")) {
            jq.change(function() {
                cl($(this).val());
            });
        } else if (jq.is("select")) {
            jq.bind('change', function() {
                cl($(this).val());
            });
        } else {
            console.log('Not supporting onChange for jquery element');
            console.log(jq);
        }
        return gSobject;
  }
  gSobject.focusEnd = function() {
    var jq = gSobject.list;

        if (jq.length) {
            if (jq.is(":text") || jq.is('textarea')) {
                var originalValue = jq.val();
                jq.val('');
                jq.blur().focus().val(originalValue);
            } else {
                jq.focus();
            }
        }
        return gSobject;
  }
  gSobject.bind = function(target, nameProperty, closure) {
    if (closure === undefined) closure = null;
    var jq = gSobject.list;
        //Create set method
        var nameSetMethod = 'set'+nameProperty.capitalize();

        if (jq.is(":text")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.val(newValue);
                if (closure) { closure(newValue); };
            };
            jq.bind('input', function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is('textarea')) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.val(newValue);
                if (closure) { closure(newValue); };
            };
            jq.bind('input propertychange', function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is(":checkbox")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.prop('checked', newValue);
                if (closure) { closure(newValue); };
            };
            jq.change(function() {
                var currentVal = $(this).is(':checked');
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is(":radio")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.each(function(idx, elem) {
                    if (elem.value == newValue) { $(elem).prop('checked', true) }
                });
                if (closure) { closure(newValue); };
            };
            jq.change(function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else if (jq.is("select")) {
            target[nameSetMethod] = function(newValue) {
                this[nameProperty] = newValue;
                jq.val(newValue);
                if (closure) { closure(newValue); };
            };
            jq.bind('change', function() {
                var currentVal = $(this).val();
                target[nameProperty] = currentVal;
                if (closure) { closure(currentVal); };
            });
        } else {
            console.log('Not supporting bind for jquery element');
            console.log(jq);
        }
        return gSobject;
  }
  gSobject.jqueryList = function(selec) {
    return $(selec);
  }
  gSobject['GQueryList1'] = function(selecOrJq) {
    gSobject.list = (gs.instanceOf(selecOrJq, "String") ? gs.mc(gSobject,"jqueryList",[selecOrJq]) : selecOrJq);
    return this;
  }
  if (arguments.length==1) {gSobject.GQueryList1(arguments[0]); }
  
  return gSobject;
};
GQueryList.of = function(selecOrJq) {
  return GQueryList(selecOrJq);
}

function GrooscriptGrails() {
  var gSobject = gs.init('GrooscriptGrails');
  gSobject.clazz = { name: 'org.grooscript.grails.util.GrooscriptGrails', simpleName: 'GrooscriptGrails'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'remoteUrl', { get: function() { return GrooscriptGrails.remoteUrl; }, set: function(gSval) { GrooscriptGrails.remoteUrl = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'controllerRemoteDomain', { get: function() { return GrooscriptGrails.controllerRemoteDomain; }, set: function(gSval) { GrooscriptGrails.controllerRemoteDomain = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'actionRemoteDomain', { get: function() { return GrooscriptGrails.actionRemoteDomain; }, set: function(gSval) { GrooscriptGrails.actionRemoteDomain = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'count', { get: function() { return GrooscriptGrails.count; }, set: function(gSval) { GrooscriptGrails.count = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'components', { get: function() { return GrooscriptGrails.components; }, set: function(gSval) { GrooscriptGrails.components = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GRAILS_PROPERTIES', { get: function() { return GrooscriptGrails.GRAILS_PROPERTIES; }, set: function(gSval) { GrooscriptGrails.GRAILS_PROPERTIES = gSval; }, enumerable: true });
  gSobject.register = function(x0) { return GrooscriptGrails.register(x0); }
  gSobject.recover = function(x0) { return GrooscriptGrails.recover(x0); }
  gSobject.getRemoteDomainClassProperties = function(x0) { return GrooscriptGrails.getRemoteDomainClassProperties(x0); }
  gSobject.sendClientMessage = function(x0,x1) { return GrooscriptGrails.sendClientMessage(x0,x1); }
  gSobject.sendWebsocketMessage = function(x0,x1) { return GrooscriptGrails.sendWebsocketMessage(x0,x1); }
  gSobject.doRemoteCall = function(x0,x1,x2,x3,x4) { return GrooscriptGrails.doRemoteCall(x0,x1,x2,x3,x4); }
  gSobject.remoteDomainAction = function(x0,x1,x2,x3) { return GrooscriptGrails.remoteDomainAction(x0,x1,x2,x3); }
  gSobject.createComponent = function(x0,x1) { return GrooscriptGrails.createComponent(x0,x1); }
  gSobject.findComponentById = function(x0) { return GrooscriptGrails.findComponentById(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
GrooscriptGrails.register = function(component) {
  var number = GrooscriptGrails.count++;
  gs.sp(component,"cId",number);
  (GrooscriptGrails.components["id" + (number) + ""]) = component;
  return component;
}
GrooscriptGrails.recover = function(cId) {
  return GrooscriptGrails.components["id" + (cId) + ""];
}
GrooscriptGrails.getRemoteDomainClassProperties = function(remoteDomainClass) {
  var data;
        var result = gs.map();
        for (data in remoteDomainClass) {
            if ((typeof remoteDomainClass[data] !== "function") && !GrooscriptGrails.GRAILS_PROPERTIES.contains(data)) {
                result.add(data, remoteDomainClass[data]);
            }
        }
        return result;
}
GrooscriptGrails.sendClientMessage = function(channel, message) {
  var sendMessage = message;
        if (!gs.isGroovyObj(message)) {
            sendMessage = gs.toGroovy(message);
        }
        gsEvents.sendMessage(channel, sendMessage);
}
GrooscriptGrails.sendWebsocketMessage = function(channel, message) {
  var sendMessage = message;
        if (gs.isGroovyObj(message)) {
            sendMessage = gs.toJavascript(message);
        }
        websocketClient.send(channel, {}, JSON.stringify(sendMessage));
}
GrooscriptGrails.doRemoteCall = function(controller, action, params, onSuccess, onFailure) {
  var url = GrooscriptGrails.remoteUrl;
        url = url + '/' + controller;
        if (action !== null) {
            url = url + '/' + action;
        }
        $.ajax({
            type: "POST",
            data: (gs.isGroovyObj(params) ? gs.toJavascript(params) : params),
            url: url
        }).done(function(newData) {
            if (onSuccess !== null && onSuccess !== undefined) {
                var successData = gs.toGroovy(newData);
                onSuccess(successData);
            }
        })
        .fail(function(error) {
            if (onFailure !== null && onFailure !== undefined) {
                onFailure(error);
            }
        });
}
GrooscriptGrails.remoteDomainAction = function(params, onSuccess, onFailure, name) {
  var url = GrooscriptGrails.remoteUrl + params.url;
        var data = (gs.isGroovyObj(params.data) ? gs.toJavascript(params.data) : params.data);
        var type = 'GET';
        if (params.action == 'create') {
            type = 'POST';
        }
        if (params.action == 'update') {
            type = 'PUT';
        }
        if (params.action == 'delete') {
            type = 'DELETE';
        }
        if (params.action == 'read' || params.action == 'delete') {
            data = null;
            url = url + '/' + params.data.id;
        }
        $.ajax({
            type: type,
            data: data,
            url: url,
            accepts: 'application/json'
        }).done(function(newData) {
            var successData = gs.toGroovy(newData, (typeof globalThis!=="undefined"&&globalThis[name]!==undefined?globalThis[name]:undefined));
            if (onSuccess !== null && onSuccess !== undefined) {
                onSuccess(successData);
            }
        })
        .fail(function(error) {
            if (onFailure !== null && onFailure !== undefined) {
                onFailure(error);
            }
        });
}
GrooscriptGrails.createComponent = function(componentClass, name) {
  var component = Object.create(HTMLElement.prototype);
        component.createdCallback = function() {
            var shadow = this.createShadowRoot();
            var content = this.textContent;
            var attrs = this.attributes; //name and value
            var map = {shadowRoot: shadow, content: content};
            if (attrs && attrs.length > 0) {
                for (var i = 0; i < attrs.length; i++) {
                    var element = attrs[i];
                    map[element.name] = element.value;
                }
            }
            GrooscriptGrails.register(componentClass(map)).render();
        };
        document.registerElement(name, {prototype: component});
}
GrooscriptGrails.findComponentById = function(id) {
  return gs.gp(gs.mc(GrooscriptGrails.components,"find",[function(key, value) {
    return gs.equals(gs.gp(value,"id"), id);
  }]),"value",true);
}
GrooscriptGrails.remoteUrl = null;
GrooscriptGrails.controllerRemoteDomain = "remoteDomain";
GrooscriptGrails.actionRemoteDomain = "doAction";
GrooscriptGrails.count = 0;
GrooscriptGrails.components = gs.map();
GrooscriptGrails.GRAILS_PROPERTIES = gs.list(["url" , "class" , "clazz" , "gsName" , "transients" , "constraints" , "mapping" , "hasMany" , "belongsTo" , "validationSkipMap" , "gormPersistentEntity" , "properties" , "gormDynamicFinders" , "all" , "domainClass" , "attached" , "validationErrorsMap" , "dirtyPropertyNames" , "errors" , "dirty" , "count"]);
function RemoteDomain() {
  var gSobject = gs.init('RemoteDomain');
  gSobject.clazz = { name: 'org.grooscript.grails.promise.RemoteDomain', simpleName: 'RemoteDomain'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.clazz.interfaces = [{ name: 'org.grooscript.grails.promise.GsPromise', simpleName: 'GsPromise'}];
  gSobject.action = null;
  gSobject.url = null;
  gSobject.data = null;
  gSobject.onSuccess = null;
  gSobject.onFail = null;
  gSobject.name = null;
  gSobject.closure = function(it) {
    var remoteData = gs.map().add("action",gSobject.action).add("url",gSobject.url).add("data",gSobject.data);
    return gs.execStatic(GrooscriptGrails,'remoteDomainAction', this,[remoteData, gSobject.onSuccess, gSobject.onFail, gSobject.name]);
  };
  gSobject['then'] = function(success, fail) {
    gSobject.onSuccess = success;
    gSobject.onFail = fail;
    gs.sp(gSobject.closure,"delegate",this);
    return gs.mc(gSobject,"closure",[]);
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};
function ClientEventHandler() {
  var gSobject = gs.init('ClientEventHandler');
  gSobject.clazz = { name: 'org.grooscript.grails.event.ClientEventHandler', simpleName: 'ClientEventHandler'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.clazz.interfaces = [{ name: 'org.grooscript.grails.event.EventHandler', simpleName: 'EventHandler'}];
  gSobject.mapHandlers = gs.map();
  gSobject['sendMessage'] = function(channel, data) {
    if (gSobject.mapHandlers[channel]) {
      return gs.mc(gSobject.mapHandlers[channel],"each",[function(action) {
        return gs.execCall(action, this, [data]);
      }]);
    };
  }
  gSobject['onEvent'] = function(channel, action) {
    if (!gs.bool(gSobject.mapHandlers[channel])) {
      (gSobject.mapHandlers[channel]) = gs.list([]);
    };
    return gs.mc((gSobject.mapHandlers[channel]),'leftShift', gs.list([action]));
  }
  gSobject['close'] = function(it) {
    return gSobject.mapHandlers = gs.map();
  }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
};

var gsEvents = ClientEventHandler();
}
// __DYMICO_V1_USER_CODE__
function BootstrapBase() {
  var gSobject = gs.init('BootstrapBase');
  gSobject.clazz = { name: 'BootstrapBase', simpleName: 'BootstrapBase'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.completed = false;
  gSobject.callbacks = gs.list([]);
  gSobject['callback'] = function(callback) {
    if (gs.bool(gSobject.completed)) {
      return gs.execCall(callback, this, []);
     };
    return gs.mc(gSobject.callbacks,"add",[callback]);
   }
  gSobject['runCallbacks'] = function(it) {
    gSobject.completed = true;
    return gs.mc(gSobject.callbacks,"each",[function(callback) {
      return gs.execCall(callback, this, []);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function Transmission() {
  var gSobject = gs.init('Transmission');
  gSobject.clazz = { name: 'Transmission', simpleName: 'Transmission'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'onReady', { get: function() { return Transmission.onReady; }, set: function(gSval) { Transmission.onReady = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onAuthReady', { get: function() { return Transmission.onAuthReady; }, set: function(gSval) { Transmission.onAuthReady = gSval; }, enumerable: true });
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Transmission.onReady = BootstrapBase();
Transmission.onAuthReady = BootstrapBase();

function StartupParams() {
  var gSobject = gs.init('StartupParams');
  gSobject.clazz = { name: 'StartupParams', simpleName: 'StartupParams'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.session = gs.execStatic(Session,'instance', this,[]);
  Object.defineProperty(gSobject, 'deviceReadyListers', { get: function() { return StartupParams.deviceReadyListers; }, set: function(gSval) { StartupParams.deviceReadyListers = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'bootstrapComplete', { get: function() { return StartupParams.bootstrapComplete; }, set: function(gSval) { StartupParams.bootstrapComplete = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'deviceReady', { get: function() { return StartupParams.deviceReady; }, set: function(gSval) { StartupParams.deviceReady = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'doAuthToken', { get: function() { return StartupParams.doAuthToken; }, set: function(gSval) { StartupParams.doAuthToken = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'supportOfflineStart', { get: function() { return StartupParams.supportOfflineStart; }, set: function(gSval) { StartupParams.supportOfflineStart = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'websocketClientDebug', { get: function() { return StartupParams.websocketClientDebug; }, set: function(gSval) { StartupParams.websocketClientDebug = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'offlineStartFunction', { get: function() { return StartupParams.offlineStartFunction; }, set: function(gSval) { StartupParams.offlineStartFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onlineStartNoAuthFunction', { get: function() { return StartupParams.onlineStartNoAuthFunction; }, set: function(gSval) { StartupParams.onlineStartNoAuthFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onlineStartAuthSuccessFunction', { get: function() { return StartupParams.onlineStartAuthSuccessFunction; }, set: function(gSval) { StartupParams.onlineStartAuthSuccessFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'onlineStartTokenAuthFailedFunction', { get: function() { return StartupParams.onlineStartTokenAuthFailedFunction; }, set: function(gSval) { StartupParams.onlineStartTokenAuthFailedFunction = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'beforeSocketInit', { get: function() { return StartupParams.beforeSocketInit; }, set: function(gSval) { StartupParams.beforeSocketInit = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'afterSocketInit', { get: function() { return StartupParams.afterSocketInit; }, set: function(gSval) { StartupParams.afterSocketInit = gSval; }, enumerable: true });
  gSobject.shouldCheckStartupAuth = function() {
    if (typeof checkStartupAuth !== 'undefined') {
            return checkStartupAuth
        }
        return true
   }
  gSobject['checkStartupAuth'] = function(it) {
    if (gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"AUTH_TOKEN")])) {
      gs.println(gs.plus("Writing session auth to local storage:", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"AUTH_TOKEN")])));
      gs.mc(gs.fs('localStorage', this, gSobject),"setItem",["authToken", gs.plus((gs.plus("\"", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"AUTH_TOKEN")]))), "\"")]);
     };
    if (gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"DEVICE_TOKEN")])) {
      gs.println(gs.plus("Writing device token to local storage:", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"DEVICE_TOKEN")])));
      gs.mc(gs.fs('localStorage', this, gSobject),"setItem",["deviceToken", gs.plus((gs.plus("\"", gs.execStatic(Utils,'getCookie', this,[gs.gp(Socket,"DEVICE_TOKEN")]))), "\"")]);
     };
    if ((gs.mc(gSobject,"shouldCheckStartupAuth",[])) && (gs.bool(StartupParams.doAuthToken))) {
      gs.println("Checking tokens...");
      if ((!gs.bool(gs.gp(gSobject.session,"authToken"))) || (!gs.bool(gs.gp(gSobject.session,"deviceToken")))) {
        gs.println("Token NOT found");
        return null;
       };
      return gs.println("Tokens good");
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
StartupParams.deviceReadyListers = gs.list([]);
StartupParams.bootstrapComplete = false;
StartupParams.deviceReady = true;
StartupParams.doAuthToken = true;
StartupParams.supportOfflineStart = false;
StartupParams.websocketClientDebug = false;
StartupParams.offlineStartFunction = null;
StartupParams.onlineStartNoAuthFunction = function(it) {
 };
StartupParams.onlineStartAuthSuccessFunction = function(it) {
  return gs.println("NB: onlineStartAuthSuccessFunction NOT SET!");
 };
StartupParams.onlineStartTokenAuthFailedFunction = function(it) {
  gs.println("onlineStartTokenAuthFailedFunction");
  return gs.execStatic(Utils,'logout', this,[]);
 };
StartupParams.beforeSocketInit = function(it) {
  gs.println(gs.plus("beforeSocketInit:", StartupParams.supportOfflineStart));
  if (gs.bool(StartupParams.supportOfflineStart)) {
    gs.println(gs.plus("beforeSocketInit:session.firstStartupCompleted:", gs.gp(this.session,"firstStartupCompleted")));
    gs.println("startupParams.onlineStartFunction:3");
    gs.mc(StartupParams,"offlineStartFunction",[]);
    StartupParams.bootstrapComplete = true;
    return gs.sp(this.session,"firstStartupCompleted",true);
   };
 };
StartupParams.afterSocketInit = function(it) {
  gs.println("afterSocketInit");
  if (!gs.bool(StartupParams.doAuthToken)) {
    gs.println("onlineStartNoAuthFunction:0");
    gs.mc(StartupParams,"onlineStartNoAuthFunction",[]);
    StartupParams.bootstrapComplete = true;
    return null;
   };
  return gs.execStatic(Utils,'tokenAuth', this,[function(it) {
    gs.println("onlineStartAuthSuccessFunction:1");
    gs.mc(StartupParams,"onlineStartAuthSuccessFunction",[]);
    StartupParams.bootstrapComplete = true;
    return gs.mc(gs.gp(gs.fs('transmission', this),"onAuthReady"),"runCallbacks",[]);
   }, function(it) {
    gs.println("onlineStartTokenAuthFailedFunction:2");
    gs.mc(StartupParams,"onlineStartTokenAuthFailedFunction",[]);
    StartupParams.bootstrapComplete = true;
    return gs.mc(gs.gp(gs.fs('transmission', this),"onAuthReady"),"runCallbacks",[]);
   }]);
 };

function Session() {
  var gSobject = gs.init('Session');
  gSobject.clazz = { name: 'Session', simpleName: 'Session'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'sessionMap', { get: function() { return Session.sessionMap; }, set: function(gSval) { Session.sessionMap = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'self', { get: function() { return Session.self; }, set: function(gSval) { Session.self = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'zoner', { get: function() { return Session.zoner; }, set: function(gSval) { Session.zoner = gSval; }, enumerable: true });
  gSobject.zonerRoleMap = gs.map();
  gSobject.instance = function() { return Session.instance(); }
  gSobject.toJs = function() { return Session.toJs(); }
  gSobject.setSessionStorage = function(x0,x1) { return Session.setSessionStorage(x0,x1); }
  gSobject.getSessionStorage = function(x0) { return Session.getSessionStorage(x0); }
  gSobject.clear = function() {
    var remember_me = localStorage.getItem('remember_me');
       
       localStorage.clear();
       
       localStorage.setItem('remember_me', remember_me);
   }
  gSobject['setProperty'] = function(name, value) {
    (Session.sessionMap[name]) = value;
    Session.setSessionStorage(name, value);
    if (gs.equals(name, "zoner")) {
      Session.zoner = null;
      return gSobject.zonerRoleMap = gs.map();
     };
   }
  gSobject['getProperty'] = function(name) {
    if (!gs.bool(Session.sessionMap[name])) {
      var value = Session.getSessionStorage(name);
      (Session.sessionMap[name]) = value;
     };
    return Session.sessionMap[name];
   }
  gSobject['hasRole'] = function(roles) {
    if (!gs.bool(roles)) {
      return true;
     };
    var result = gSobject.zonerRoleMap[roles];
    if (result != null) {
      return result;
     };
    if (!gs.bool(Session.zoner)) {
      Session.zoner = gs.mc(gSobject,"getProperty",["zoner"]);
     };
    if (!gs.bool(Session.zoner)) {
      return false;
     };
    if (gs.instanceOf(roles, "String")) {
      result = (gs.gSin(roles, gs.gp(Session.zoner,"roles")));
      (gSobject.zonerRoleMap[roles]) = result;
      return result;
     };
    for (_i0 = 0, role = roles[0]; _i0 < roles.length; role = roles[++_i0]) {
      if (gs.gSin(role, gs.gp(Session.zoner,"roles"))) {
        (gSobject.zonerRoleMap[roles]) = true;
        return true;
       };
     };
    (gSobject.zonerRoleMap[roles]) = false;
    return false;
   }
  gSobject['toString'] = function(it) {
    return gs.mc(Session.sessionMap,"toString",[]);
   }
  gSobject['Session0'] = function(it) {
    return this;
  }
  if (arguments.length==0) {gSobject.Session0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Session.instance = function(it) {
  if (!gs.bool(Session.self)) {
    Session.self = Session();
   };
  return Session.self;
 }
Session.toJs = function(it) {
  return Session.sessionMap;
 }
Session.setSessionStorage = function(name, value) {
  value = JSON.stringify(value)
       localStorage.setItem(name, value)
       return value
 }
Session.getSessionStorage = function(name) {
  var value = localStorage.getItem(name)
        try{
            return gs.toGroovy(jQuery.parseJSON(value))
        }catch(all){}
        return null
 }
Session.sessionMap = gs.map();
Session.self = null;
Session.zoner = null;

function Modals() {
  var gSobject = gs.init('Modals');
  gSobject.clazz = { name: 'Modals', simpleName: 'Modals'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.showModalCustom = function(x0,x1) { return Modals.showModalCustom(x0,x1); }
  gSobject.showModal = function(x0) { return Modals.showModal(x0); }
  gSobject.hideModal = function(x0) { return Modals.hideModal(x0); }
  gSobject.closeModal = function(x0) { return Modals.closeModal(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Modals.showModalCustom = function(id, type) {
  $(id).css("display", type);
        $(id).css("pointer-events", "initial");
 }
Modals.showModal = function(id) {
  $(id).css("display", "block");
        $(id).css("pointer-events", "initial");
 }
Modals.hideModal = function(id) {
  $(id).css("display", "none");
        $(id).css("pointer-events", "none");
 }
Modals.closeModal = function(id) {
  $(id).trigger( "click" );
 }

function Socket() {
  var gSobject = gs.init('Socket');
  gSobject.clazz = { name: 'Socket', simpleName: 'Socket'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'SOCKET_URL', { get: function() { return Socket.SOCKET_URL; }, set: function(gSval) { Socket.SOCKET_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_USER_URL', { get: function() { return Socket.SOCKET_USER_URL; }, set: function(gSval) { Socket.SOCKET_USER_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_OBJECT_URL', { get: function() { return Socket.SOCKET_OBJECT_URL; }, set: function(gSval) { Socket.SOCKET_OBJECT_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_TOPIC_URL', { get: function() { return Socket.SOCKET_TOPIC_URL; }, set: function(gSval) { Socket.SOCKET_TOPIC_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_OVER_HTTP_SYNCHRONOUS_URL', { get: function() { return Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL; }, set: function(gSval) { Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_OVER_HTTP_ASYNCHRONOUS_URL', { get: function() { return Socket.SOCKET_OVER_HTTP_ASYNCHRONOUS_URL; }, set: function(gSval) { Socket.SOCKET_OVER_HTTP_ASYNCHRONOUS_URL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SESSION_REFRESH_MINS', { get: function() { return Socket.SESSION_REFRESH_MINS; }, set: function(gSval) { Socket.SESSION_REFRESH_MINS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_CHECK_MSG_RECEIVED_SEC', { get: function() { return Socket.SOCKET_CHECK_MSG_RECEIVED_SEC; }, set: function(gSval) { Socket.SOCKET_CHECK_MSG_RECEIVED_SEC = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_RUNNER_RETRY_MS', { get: function() { return Socket.SOCKET_RUNNER_RETRY_MS; }, set: function(gSval) { Socket.SOCKET_RUNNER_RETRY_MS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_QUEUE_TIMEOUT_MIN', { get: function() { return Socket.SOCKET_QUEUE_TIMEOUT_MIN; }, set: function(gSval) { Socket.SOCKET_QUEUE_TIMEOUT_MIN = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'AUTH_TOKEN', { get: function() { return Socket.AUTH_TOKEN; }, set: function(gSval) { Socket.AUTH_TOKEN = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DEVICE_TOKEN', { get: function() { return Socket.DEVICE_TOKEN; }, set: function(gSval) { Socket.DEVICE_TOKEN = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'window', { get: function() { return Socket.window; }, set: function(gSval) { Socket.window = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'navigator', { get: function() { return Socket.navigator; }, set: function(gSval) { Socket.navigator = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'sendProtocol', { get: function() { return Socket.sendProtocol; }, set: function(gSval) { Socket.sendProtocol = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'queue', { get: function() { return Socket.queue; }, set: function(gSval) { Socket.queue = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'socketHeadersMap', { get: function() { return Socket.socketHeadersMap; }, set: function(gSval) { Socket.socketHeadersMap = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'userDataPipe', { get: function() { return Socket.userDataPipe; }, set: function(gSval) { Socket.userDataPipe = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'session', { get: function() { return Socket.session; }, set: function(gSval) { Socket.session = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'connected', { get: function() { return Socket.connected; }, set: function(gSval) { Socket.connected = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'socket', { get: function() { return Socket.socket; }, set: function(gSval) { Socket.socket = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'websocketClient', { get: function() { return Socket.websocketClient; }, set: function(gSval) { Socket.websocketClient = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'subscriptions', { get: function() { return Socket.subscriptions; }, set: function(gSval) { Socket.subscriptions = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'sessionRefresherThreads', { get: function() { return Socket.sessionRefresherThreads; }, set: function(gSval) { Socket.sessionRefresherThreads = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'socketReadyQueue', { get: function() { return Socket.socketReadyQueue; }, set: function(gSval) { Socket.socketReadyQueue = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'intervalRunner', { get: function() { return Socket.intervalRunner; }, set: function(gSval) { Socket.intervalRunner = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'reconnectMutex', { get: function() { return Socket.reconnectMutex; }, set: function(gSval) { Socket.reconnectMutex = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'SOCKET_PING_TIMEOUT_MS', { get: function() { return Socket.SOCKET_PING_TIMEOUT_MS; }, set: function(gSval) { Socket.SOCKET_PING_TIMEOUT_MS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'websocketPingCount', { get: function() { return Socket.websocketPingCount; }, set: function(gSval) { Socket.websocketPingCount = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'nextQueueClean', { get: function() { return Socket.nextQueueClean; }, set: function(gSval) { Socket.nextQueueClean = gSval; }, enumerable: true });
  gSobject.init = function() { return Socket.init(); }
  gSobject.socketHeaders = function() { return Socket.socketHeaders(); }
  gSobject.initSocket = function(x0,x1) { return Socket.initSocket(x0,x1); }
  gSobject.socketReady = function(x0) { return Socket.socketReady(x0); }
  gSobject.socketReadyQueueCallAll = function() { return Socket.socketReadyQueueCallAll(); }
  gSobject.addUserDataPipe = function() { return Socket.addUserDataPipe(); }
  gSobject.startSessionRefresher = function() { return Socket.startSessionRefresher(); }
  gSobject.sessionRefresher = function(x0,x1) { return Socket.sessionRefresher(x0,x1); }
  gSobject.reconnect = function(x0) { return Socket.reconnect(x0); }
  gSobject.socketConnectionInterval = function(x0) { return Socket.socketConnectionInterval(x0); }
  gSobject.socketConnect = function(x0,x1,x2) { return Socket.socketConnect(x0,x1,x2); }
  gSobject.pingHttp = function(callback) {
    if (!this.inUse) {
            this.status = 'unchecked';
            this.inUse = true;
            this.callback = callback;
            this.ip = ip;
            var _that = this;
            this.img = new Image();
            this.img.onload = function () {
                _that.inUse = false;
                _that.callback('responded');
    
            };
            this.img.onerror = function (e) {
                if (_that.inUse) {
                    _that.inUse = false;
                    _that.callback('responded', e);
                }
    
            };
            this.start = new Date().getTime();
            this.img.src = 'http://'+ window.location.hostname + '/index/ping';
            this.timer = setTimeout(function () {
                if (_that.inUse) {
                    _that.inUse = false;
                    _that.callback('timeout');
                }
            }, 1500);
        }
   }
  gSobject.pingWebSocket = function(x0) { return Socket.pingWebSocket(x0); }
  gSobject.remote = function(x0,x1,x2,x3) { return Socket.remote(x0,x1,x2,x3); }
  gSobject.callChain = function(x0,x1,x2) { return Socket.callChain(x0,x1,x2); }
  gSobject.callObject = function(x0,x1,x2,x3,x4) { return Socket.callObject(x0,x1,x2,x3,x4); }
  gSobject.isDymicoSystemUpdating = function() { return Socket.isDymicoSystemUpdating(); }
  gSobject.send = function(x0,x1,x2,x3) { return Socket.send(x0,x1,x2,x3); }
  gSobject.doSend = function(x0,x1) { return Socket.doSend(x0,x1); }
  gSobject.doSendNativeHttp = function(x0,x1) { return Socket.doSendNativeHttp(x0,x1); }
  gSobject.doSendNative = function(x0,x1) { return Socket.doSendNative(x0,x1); }
  gSobject.checkMessageReceived = function(x0) { return Socket.checkMessageReceived(x0); }
  gSobject.resendMessageQueue = function() { return Socket.resendMessageQueue(); }
  gSobject.cleanQueue = function() { return Socket.cleanQueue(); }
  gSobject.receive = function(x0) { return Socket.receive(x0); }
  gSobject.processException = function(x0) { return Socket.processException(x0); }
  gSobject.subscribe = function(x0,x1,x2) { return Socket.subscribe(x0,x1,x2); }
  gSobject.subscribeTopic = function(x0,x1) { return Socket.subscribeTopic(x0,x1); }
  gSobject.unsubscribeTopic = function(x0) { return Socket.unsubscribeTopic(x0); }
  gSobject.addSubscription = function(x0,x1,x2) { return Socket.addSubscription(x0,x1,x2); }
  gSobject.subscribeJs = function(x0,x1,x2) { return Socket.subscribeJs(x0,x1,x2); }
  gSobject.doReceiveNative = function(x0,x1) { return Socket.doReceiveNative(x0,x1); }
  gSobject.resubscribeAll = function() { return Socket.resubscribeAll(); }
  gSobject.unsubscribe = function(x0,x1) { return Socket.unsubscribe(x0,x1); }
  gSobject.post = function(x0,x1,x2,x3,x4) { return Socket.post(x0,x1,x2,x3,x4); }
  gSobject.postJson = function(x0,x1,x2,x3) { return Socket.postJson(x0,x1,x2,x3); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Socket.init = function(it) {
  gs.sp(Socket.session,"domain",gs.gp(gs.gp(Socket.window,"location"),"hostname"));
  gs.sp(Socket.session,"incomingUrl",(gs.plus((gs.plus(gs.gp(gs.gp(Socket.window,"location"),"protocol"), "//")), gs.gp(gs.gp(Socket.window,"location"),"hostname"))));
  return gs.sp(GrooscriptGrails,"remoteUrl",gs.gp(Socket.session,"incomingUrl"));
 }
Socket.socketHeaders = function(it) {
  gs.sp(Socket.socketHeadersMap,"domain",gs.gp(gs.gp(Socket.window,"location"),"hostname"));
  gs.sp(Socket.socketHeadersMap,"" + (Socket.AUTH_TOKEN) + "",gs.execStatic(Utils,'getAuthToken', this,[]));
  gs.sp(Socket.socketHeadersMap,"" + (Socket.DEVICE_TOKEN) + "",gs.execStatic(Utils,'getDeviceToken', this,[]));
  if (gs.bool(gs.gp(Socket.session,"jwt"))) {
    gs.sp(Socket.socketHeadersMap,"jwt",gs.gp(Socket.session,"jwt"));
   };
  return Socket.socketHeadersMap;
 }
Socket.initSocket = function(success, failure) {
  if (success === undefined) success = null;
  if (failure === undefined) failure = null;
  return gs.execStatic(Socket,'socketConnectionInterval', this,[success, failure]);
 }
Socket.socketReady = function(callback) {
  if (gs.bool(Socket.connected)) {
    gs.execCall(callback, this, []);
    return null;
   };
  return gs.mc(Socket.socketReadyQueue,"add",[callback]);
 }
Socket.socketReadyQueueCallAll = function(it) {
  var socketReadyQueueLocal = Socket.socketReadyQueue;
  Socket.socketReadyQueue = gs.list([]);
  return gs.mc(socketReadyQueueLocal,"each",[function(callback) {
    try {
      gs.execCall(callback, this, []);
     }
    catch (all) {
      gs.println(gs.fs('all', this));
     }
    ;
   }]);
 }
Socket.addUserDataPipe = function(it) {
  return Socket.addSubscription(gs.execStatic(Utils,'getDeviceToken', this,[]), Socket.SOCKET_USER_URL, Socket.userDataPipe);
 }
Socket.startSessionRefresher = function(it) {
  if (gs.bool(gs.gp(Socket.session,"authToken"))) {
    var sessionRefresherCallback = function(data) {
      if (data != "authed") {
        gs.println("NOT AUTHED");
        return gs.execStatic(Utils,'logout', this,[]);
       };
     };
    Socket.sessionRefresher(gs.gp(Socket.session,"authToken"), sessionRefresherCallback);
    for (_i1 = 0, sessionRefresherThread = Socket.sessionRefresherThreads[0]; _i1 < Socket.sessionRefresherThreads.length; sessionRefresherThread = Socket.sessionRefresherThreads[++_i1]) {
      gs.execStatic(Utils,'clearInterval', this,[sessionRefresherThread]);
      gs.mc(Socket.sessionRefresherThreads,"remove",[sessionRefresherThread]);
     };
    return gs.mc(Socket.sessionRefresherThreads,"add",[gs.execStatic(Utils,'setInterval', this,[function(it) {
      return gs.mc(Socket,"sessionRefresher",[gs.gp(Socket.session,"authToken"), sessionRefresherCallback]);
     }, gs.multiply((gs.multiply(1000, 60)), Socket.SESSION_REFRESH_MINS)])]);
   };
 }
Socket.sessionRefresher = function(token, sessionRefresherCallback) {
  console.log("refreshing:" + token +':'+new Date());
        $.ajax({
            url : '/login/tokenAuth?token='+token,
            type : 'GET',
            processData: false,
            contentType: false, 
            success : function(data) {
                console.log("grails session re-auth:"+data);
                sessionRefresherCallback(data)
            }
        });
 }
Socket.reconnect = function(retryInMs) {
  if (retryInMs === undefined) retryInMs = 0;
  if (gs.bool(retryInMs)) {
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(Socket,"reconnect",[]);
     }, retryInMs]);
   };
  if ((gs.bool(Socket.reconnectMutex)) || (!gs.bool(Socket.intervalRunner))) {
    return Socket.reconnect(500);
   };
  Socket.reconnectMutex = true;
  return gs.mc(Socket,"intervalRunner",[function(it) {
    return Socket.reconnectMutex = false;
   }]);
 }
Socket.socketConnectionInterval = function(success) {
  var reconnectCallback = function(it) {
    gs.println("Socket reconnected");
    Socket.connected = true;
    gs.mc(Socket,"addUserDataPipe",[]);
    gs.mc(Socket,"resubscribeAll",[]);
    gs.mc(Socket,"resendMessageQueue",[]);
    gs.mc(Socket,"startSessionRefresher",[]);
    gs.execCall(success, this, []);
    success = function(it) {
     };
    return gs.mc(Socket,"socketReadyQueueCallAll",[]);
   };
  var disconnectSockets = function(it) {
    gs.println("Socket disconnect");
    Socket.connected = false;
    try {
      gs.mc(gs.gp(Socket,"websocketClient"),"disconnect",[]);
     }
    catch (all) {
     }
    ;
   };
  Socket.intervalRunner = function(done) {
    gs.println(gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("navigator.onLine:", gs.gp(Socket.navigator,"onLine"))), ":")), gs.gp(gs.gp(Socket,"websocketClient"),"connected"))), ":")), Socket.connected));
    if (!gs.bool(gs.gp(gs.gp(Socket,"websocketClient"),"connected"))) {
      gs.println("Socket.websocketClient.connected:false:reconnecting...");
      gs.mc(Socket,"socketConnect",[gs.map().add("domain",gs.gp(Socket.session,"domain")), function(it) {
        gs.println(gs.plus("Socket.websocketClient.connected:", gs.gp(gs.gp(Socket,"websocketClient"),"connected")));
        Socket.connected = true;
        gs.execCall(reconnectCallback, this, []);
        return gs.execCall(done, this, []);
       }, function(it) {
        gs.println("Socket.websocketClient.connected:connection down");
        gs.execCall(disconnectSockets, this, []);
        gs.execCall(done, this, []);
        if (gs.bool(Socket.queue)) {
          return gs.mc(Socket,"reconnect",[Socket.SOCKET_RUNNER_RETRY_MS]);
         };
       }]);
      return null;
     };
    gs.println("Sockets believed to be online.  Pinging socket connection...");
    gs.mc(Socket,"pingWebSocket",[function(pingResponse) {
      gs.println(gs.plus("pingWebSocket:", pingResponse));
      if (gs.equals(pingResponse, "timeout")) {
        gs.println("Connection timed out, reconnecting...");
        gs.execCall(disconnectSockets, this, []);
        gs.mc(Socket,"reconnect",[]);
        return gs.execCall(done, this, []);
       };
      gs.println("Connection good, false alarm.");
      return gs.execCall(done, this, []);
     }]);
    return gs.println(gs.plus("intervalRunner:Socket.websocketClient.connected:", gs.gp(gs.gp(Socket,"websocketClient"),"connected")));
   };
  return Socket.reconnect();
 }
Socket.socketConnect = function(headers, success, failed) {
  try{
            Socket.socket = new SockJS('/stomp');
            Socket.websocketClient = Stomp.over(Socket.socket);
            
            if (!StartupParams.websocketClientDebug){
                //switch off debuggging
                Socket.websocketClient.debug = function () {}  
            }
            
            Socket.websocketClient.connect(gs.toJavascript(headers), success, failed);
        }catch(error) {
            console.info(error);
        }
 }
Socket.pingWebSocket = function(callback) {
  var websocketPingCountNow = Socket.websocketPingCount;
  var wrapper = gs.mc(gs.map().add("uuid","ping").add("call","callChain").add("data",gs.list([gs.map().add("property","transmissionService") , gs.map().add("method","ping")])),'leftShift', gs.list([Socket.socketHeaders()]));
  Socket.doSendNative(Socket.SOCKET_URL, wrapper);
  return gs.execStatic(Utils,'setTimeout', this,[function(it) {
    if (gs.equals(websocketPingCountNow, Socket.websocketPingCount)) {
      gs.execCall(callback, this, ["timeout"]);
      return null;
     };
    return gs.execCall(callback, this, ["responded"]);
   }, Socket.SOCKET_PING_TIMEOUT_MS]);
 }
Socket.remote = function(closure, data, success, fail) {
  if (success === undefined) success = null;
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'send', this,["remoteExec", closure, data, success, fail]);
 }
Socket.callChain = function(callChain, success, fail) {
  if (success === undefined) success = null;
  if (fail === undefined) fail = null;
  if (Socket.isDymicoSystemUpdating()) {
    return null;
   };
  gs.println(gs.plus("callChain:", callChain));
  return gs.execStatic(Socket,'send', this,["callChain", callChain, success, fail]);
 }
Socket.callObject = function(self, method, args, success, fail) {
  if (fail === undefined) fail = null;
  if (Socket.isDymicoSystemUpdating()) {
    return null;
   };
  gs.println(gs.plus("callObject:OObject:", self));
  gs.println(gs.plus("callObject:method:", method));
  return gs.execStatic(Socket,'send', this,["callObject", gs.map().add("self",self).add("method",method).add("args",args), success, fail]);
 }
Socket.isDymicoSystemUpdating = function() {
  try{
            if (typeof dymicoVersionUpdater !== 'undefined') { 
                return dymicoVersionUpdater.dymicoSystemUpdating;
            }
        }catch(all){ }
        return false;
 }
Socket.send = function(call, data, success, fail) {
  if (fail === undefined) fail = function(it) {
    return false;
   };
  var uuid = gs.execStatic(Utils,'uuid', this,[]);
  var wrapper = gs.map().add("uuid",uuid).add("call",call).add("data",data);
  var queueItem = gs.map().add("success",success).add("fail",fail).add("dataStr",gs.mc(data,"toString",[])).add("date",gs.gp(gs.date(),"time")).add("wrapper",wrapper);
  (Socket.queue[uuid]) = queueItem;
  Socket.doSend(Socket.SOCKET_URL, queueItem);
  return uuid;
 }
Socket.doSend = function(channel, queueItem) {
  if (gs.equals(Socket.sendProtocol, "websocket")) {
    Socket.doSendNative(channel, gs.mc(gs.gp(queueItem,"wrapper"),'leftShift', gs.list([Socket.socketHeaders()])));
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(Socket,"checkMessageReceived",[queueItem]);
     }, gs.multiply(Socket.SOCKET_CHECK_MSG_RECEIVED_SEC, 1000)]);
    if (!gs.bool(Socket.connected)) {
      return Socket.reconnect();
     };
   } else {
    if (gs.equals(Socket.sendProtocol, "http")) {
      return Socket.doSendNativeHttp(gs.mc(gs.gp(queueItem,"wrapper"),'leftShift', gs.list([Socket.socketHeaders()])), function(it) {
        gs.println("HTTP TIMEOUT");
        return gs.mc(Socket,"reconnect",[]);
       });
     } else {
      throw "Exception";
     };
   };
 }
Socket.doSendNativeHttp = function(map, timeoutCallback) {
  var sendMessage = map;

        sendMessage = Utils.mapToJsonString(sendMessage);
        // sendMessage = LZString.compressToBase64(sendMessage); //no compression needed, cause the browser will gzip it anyway
        sendMessage = "message="+encodeURIComponent(sendMessage)
            
        var xhr = new XMLHttpRequest();
        xhr.ontimeout = timeoutCallback
        xhr.open('POST', Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL, true);
        xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");

        xhr.onreadystatechange = function(e) {
            if (this.status == 404) {
                console.log('AJAX FAILED');
            }
            if (this.readyState == 4 && this.status == 200) {
                Socket.receive(Socket.doReceiveNative(this.responseText, false))
            }
        };
        xhr.send(sendMessage);
 }
Socket.doSendNative = function(channel, map) {
  try{
            var sendMessage = map;
            sendMessage = Utils.mapToJsonString(sendMessage)
            sendMessage = LZString.compressToBase64(sendMessage)
            return Socket.websocketClient.send(channel, {}, sendMessage);
        }catch(all){ }
 }
Socket.checkMessageReceived = function(queueItem) {
  if (Socket.queue[gs.gp(gs.gp(queueItem,"wrapper"),"uuid")]) {
    Socket.reconnect();
    return Socket.cleanQueue();
   };
 }
Socket.resendMessageQueue = function(it) {
  return gs.mc(gs.mc(gs.mc(Socket.queue,"values",[]),"sort",[function(it) {
    return gs.gp(it,"date",true);
   }]),"each",[function(queueItem) {
    return gs.mc(Socket,"doSend",[Socket.SOCKET_URL, queueItem]);
   }]);
 }
Socket.cleanQueue = function(it) {
  if (Socket.nextQueueClean < gs.gp(gs.date(),"time")) {
    var timeoutMs = gs.multiply((gs.multiply(Socket.SOCKET_QUEUE_TIMEOUT_MIN, 60)), 1000);
    Socket.nextQueueClean = (gs.plus(gs.gp(gs.date(),"time"), timeoutMs));
    gs.println(gs.plus("nextQueueClean:", Socket.nextQueueClean));
    gs.println("cleanQueue.start");
    var timeout = gs.minus(gs.gp(gs.date(),"time"), timeoutMs);
    gs.println(gs.plus("cleanQueue.queue.size:", gs.mc(Socket.queue,"size",[])));
    gs.mc(Socket.queue,"each",[function(key, queueItem) {
      if (gs.gp(queueItem,"date") < timeout) {
        gs.println("REMOVED");
        gs.mc(Socket.queue,"remove",[key]);
        return gs.mc(queueItem,"fail",[]);
       };
     }]);
    return gs.println("cleanQueue.end");
   };
 }
Socket.receive = function(wrapper) {
  Socket.websocketPingCount++;
  if (gs.equals(gs.gp(wrapper,"uuid"), "ping")) {
    return null;
   };
  var queueItem = Socket.queue[gs.gp(wrapper,"uuid")];
  gs.mc(Socket.queue,"remove",[gs.gp(wrapper,"uuid")]);
  if (gs.bool(queueItem)) {
    if (gs.bool(gs.gp(wrapper,"error"))) {
      gs.mc(queueItem,"fail",[gs.gp(wrapper,"data")]);
      Socket.processException(gs.gp(wrapper,"data"));
      return null;
     };
    var object = gs.execStatic(ObjectRegistry,'register', this,[gs.gp(wrapper,"data")]);
    return gs.mc(queueItem,"success",[object]);
   };
 }
Socket.processException = function(ex) {
  gs.execStatic(Utils,'logExceptionStack', this,[gs.plus((gs.plus(ex.clazz, ":")), gs.gp(ex,"message"))]);
  return gs.execStatic(Utils,'logExceptionStack', this,[gs.gp(ex,"stackTrace")]);
 }
Socket.subscribe = function(objectId, success, topic) {
  if (topic === undefined) topic = Socket.SOCKET_OBJECT_URL;
  return Socket.socketReady(function(it) {
    gs.mc(Socket,"unsubscribe",[objectId, topic]);
    gs.println(gs.plus("subscribe:", objectId));
    var successWrapper = function(messageObject) {
      return gs.execCall(success, this, [messageObject]);
     };
    gs.mc(Socket,"addSubscription",[objectId, topic, success]);
    try {
      gs.mc(Socket,"subscribeJs",[objectId, gs.plus(topic, objectId), successWrapper]);
     }
    catch (all) {
      gs.println("subscribeJs failed");
      gs.println(gs.fs('all', this));
     }
    ;
   });
 }
Socket.subscribeTopic = function(topicId, success) {
  return Socket.subscribe(topicId, success, Socket.SOCKET_TOPIC_URL);
 }
Socket.unsubscribeTopic = function(topicId) {
  return Socket.unsubscribe(topicId, Socket.SOCKET_TOPIC_URL);
 }
Socket.addSubscription = function(objectId, topic, success) {
  return (Socket.subscriptions[objectId]) = gs.map().add("objectId",objectId).add("success",success).add("topic",topic);
 }
Socket.subscribeJs = function(objectId, subId, success) {
  console.log('subscribeJs:'+subId)
        
        return Socket.websocketClient.subscribe(subId, function(message){
            success(Socket.doReceiveNative(message.body))
        }, {id:objectId})
 }
Socket.doReceiveNative = function(message, compressed) {
  if (compressed === undefined) compressed = true;
  if (compressed) message = LZString.decompressFromBase64(message)
        
        // console.log('message', message)
        
        return Utils.stringToJson(message)
 }
Socket.resubscribeAll = function(it) {
  var oldSubscriptions = Socket.subscriptions;
  Socket.subscriptions = gs.map();
  return gs.mc(oldSubscriptions,"each",[function(key, subscription) {
    return gs.mc(Socket,"subscribe",[gs.gp(subscription,"objectId"), gs.gp(subscription,"success"), gs.gp(subscription,"topic")]);
   }]);
 }
Socket.unsubscribe = function(objectId, topic) {
  if (topic === undefined) topic = Socket.SOCKET_OBJECT_URL;
  gs.println(gs.plus("unsubscribe:", objectId));
  try {
    gs.mc(gs.gp(Socket,"websocketClient"),"unsubscribe",[objectId]);
    gs.mc(Socket.subscriptions,"remove",[objectId]);
   }
  catch (all) {
    gs.println(all);
   }
  ;
 }
Socket.post = function(file, parameter, objectName, id, callback) {
  var postUrl = "/post/upload";
        var formData = new FormData();
        
        formData.append('file', file);
        formData.append('id', id);
        formData.append('parameter', parameter);
        formData.append('objectName', objectName);

        $.ajax({
            url : postUrl,
            type : 'POST',
            data : formData,
            processData: false,  // tell jQuery not to process the data
            contentType: false,  // tell jQuery not to set contentType
            success : function(data) {
                console.log(data);
                callback(data);
            }
        });
 }
Socket.postJson = function(url, map, success, failed) {
  if (success === undefined) success = function(it) {
   };
  if (failed === undefined) failed = function(it) {
   };
  
 }
Socket.SOCKET_URL = "/app/api4WebSocketForPublic";
Socket.SOCKET_USER_URL = "/topic/api4WebSocketForUser/";
Socket.SOCKET_OBJECT_URL = "/topic/api4WebSocketForObject/";
Socket.SOCKET_TOPIC_URL = "/topic/api4WebSocketForTopic/";
Socket.SOCKET_OVER_HTTP_SYNCHRONOUS_URL = "/api4WebSocket/synchronous";
Socket.SOCKET_OVER_HTTP_ASYNCHRONOUS_URL = "/api4WebSocket/asynchronous";
Socket.SESSION_REFRESH_MINS = 10;
Socket.SOCKET_CHECK_MSG_RECEIVED_SEC = 7;
Socket.SOCKET_RUNNER_RETRY_MS = 5000;
Socket.SOCKET_QUEUE_TIMEOUT_MIN = 2;
Socket.AUTH_TOKEN = "secToken2";
Socket.DEVICE_TOKEN = "deviceToken1";
Socket.window = null;
Socket.navigator = null;
Socket.sendProtocol = "http";
Socket.queue = gs.map();
Socket.socketHeadersMap = gs.map();
Socket.userDataPipe = function(data) {
  return gs.mc(Socket,"receive",[data]);
 };
Socket.session = gs.execStatic(Session,'instance', this,[]);
Socket.connected = false;
Socket.socket = null;
Socket.websocketClient = gs.map().add("connected",false).add("disconnect",function(it) {
 }).add("subscriptions",function(it) {
 });
Socket.subscriptions = gs.map();
Socket.sessionRefresherThreads = gs.list([]);
Socket.socketReadyQueue = gs.list([]);
Socket.intervalRunner = null;
Socket.reconnectMutex = false;
Socket.SOCKET_PING_TIMEOUT_MS = 3000;
Socket.websocketPingCount = 0;
Socket.nextQueueClean = 0;

function Utils() {
  var gSobject = gs.init('Utils');
  gSobject.clazz = { name: 'Utils', simpleName: 'Utils'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'session', { get: function() { return Utils.session; }, set: function(gSval) { Utils.session = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'window', { get: function() { return Utils.window; }, set: function(gSval) { Utils.window = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'document', { get: function() { return Utils.document; }, set: function(gSval) { Utils.document = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DeviceTypes', { get: function() { return Utils.DeviceTypes; }, set: function(gSval) { Utils.DeviceTypes = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'AUTH_FAILED', { get: function() { return Utils.AUTH_FAILED; }, set: function(gSval) { Utils.AUTH_FAILED = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'NO_AUTH', { get: function() { return Utils.NO_AUTH; }, set: function(gSval) { Utils.NO_AUTH = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'REMEMBER_FALLBACK_DAYS', { get: function() { return Utils.REMEMBER_FALLBACK_DAYS; }, set: function(gSval) { Utils.REMEMBER_FALLBACK_DAYS = gSval; }, enumerable: true });
  gSobject.getAuthToken = function() { return Utils.getAuthToken(); }
  gSobject.getDeviceToken = function() { return Utils.getDeviceToken(); }
  gSobject.setTimeout = function(x0,x1) { return Utils.setTimeout(x0,x1); }
  gSobject.setInterval = function(x0,x1) { return Utils.setInterval(x0,x1); }
  gSobject.clearInterval = function(x0) { return Utils.clearInterval(x0); }
  gSobject.localDateString = function(x0) { return Utils.localDateString(x0); }
  gSobject.utcDateString = function(x0) { return Utils.utcDateString(x0); }
  gSobject.newDate = function(x0,x1,x2) { return Utils.newDate(x0,x1,x2); }
  gSobject.documentReady = function(x0) { return Utils.documentReady(x0); }
  gSobject.uniqueList = function(x0,x1) { return Utils.uniqueList(x0,x1); }
  gSobject.listsEqual = function(x0,x1) { return Utils.listsEqual(x0,x1); }
  gSobject.uuid = function() { return Utils.uuid(); }
  gSobject.guid = function() { return Utils.guid(); }
  gSobject.callChain = function(x0,x1,x2) { return Utils.callChain(x0,x1,x2); }
  gSobject.callObject = function(x0,x1,x2,x3,x4) { return Utils.callObject(x0,x1,x2,x3,x4); }
  gSobject.send = function(x0,x1,x2,x3) { return Utils.send(x0,x1,x2,x3); }
  gSobject.subscribe = function(x0,x1,x2) { return Utils.subscribe(x0,x1,x2); }
  gSobject.unsubscribe = function(x0) { return Utils.unsubscribe(x0); }
  gSobject.subscribeTopic = function(x0,x1) { return Utils.subscribeTopic(x0,x1); }
  gSobject.unsubscribeTopic = function(x0) { return Utils.unsubscribeTopic(x0); }
  gSobject.rememberDays = function() { return Utils.rememberDays(); }
  gSobject.rememberWindowExpired = function() { return Utils.rememberWindowExpired(); }
  gSobject.clearRememberedLogin = function() { return Utils.clearRememberedLogin(); }
  gSobject.parseDays = function(x0) { return Utils.parseDays(x0); }
  gSobject.toWholeNumber = function(x0) { return Utils.toWholeNumber(x0); }
  gSobject.nowMillis = function() { return Utils.nowMillis(); }
  gSobject.toMillis = function(x0) { return Utils.toMillis(x0); }
  gSobject.launchMarkerPresent = function() { return Utils.launchMarkerPresent(); }
  gSobject.markLaunch = function() { return Utils.markLaunch(); }
  gSobject.clearLaunchMarker = function() { return Utils.clearLaunchMarker(); }
  gSobject.tokenAuth = function(x0,x1) { return Utils.tokenAuth(x0,x1); }
  gSobject.userAgent = function() { return Utils.userAgent(); }
  gSobject.login = function(x0,x1,x2,x3) { return Utils.login(x0,x1,x2,x3); }
  gSobject.updateAuthTokenToSession = function(x0,x1) { return Utils.updateAuthTokenToSession(x0,x1); }
  gSobject.roleSignature = function(x0) { return Utils.roleSignature(x0); }
  gSobject.triggerLoginRerenderCheck = function(x0) { return Utils.triggerLoginRerenderCheck(x0); }
  gSobject.logout = function(x0,x1) { return Utils.logout(x0,x1); }
  gSobject.urlSafeBase64Encode = function(x0) { return Utils.urlSafeBase64Encode(x0); }
  gSobject.open = function(x0,x1,x2) { return Utils.open(x0,x1,x2); }
  gSobject.inAppBrowser = function(x0,x1,x2) { return Utils.inAppBrowser(x0,x1,x2); }
  gSobject.loadPage = function(x0) { return Utils.loadPage(x0); }
  gSobject.reloadPage = function() { return Utils.reloadPage(); }
  gSobject.setCookie = function(x0,x1) { return Utils.setCookie(x0,x1); }
  gSobject.getCookie = function(x0) { return Utils.getCookie(x0); }
  gSobject.deviceType = function() { return Utils.deviceType(); }
  gSobject.isBrowser = function() { return Utils.isBrowser(); }
  gSobject.isAndroid = function() { return Utils.isAndroid(); }
  gSobject.isIos = function() { return Utils.isIos(); }
  gSobject.isCordova = function() { return Utils.isCordova(); }
  gSobject.cordovaDevice = function() { return Utils.cordovaDevice(); }
  gSobject.isOnline = function() { return Utils.isOnline(); }
  gSobject.userAgent = function() { return Utils.userAgent(); }
  gSobject.toast = function(x0,x1) { return Utils.toast(x0,x1); }
  gSobject.post = function(x0,x1,x2,x3,x4) { return Utils.post(x0,x1,x2,x3,x4); }
  gSobject.validateEmail = function(x0) { return Utils.validateEmail(x0); }
  gSobject.validateCellphone = function(x0) { return Utils.validateCellphone(x0); }
  gSobject.getType = function(x0) { return Utils.getType(x0); }
  gSobject.dateString = function(x0) { return Utils.dateString(x0); }
  gSobject.clearTime = function(x0) { return Utils.clearTime(x0); }
  gSobject.utc = function(x0) { return Utils.utc(x0); }
  gSobject.appendAppVersion = function(x0) { return Utils.appendAppVersion(x0); }
  gSobject.logExceptionStack = function(x0) { return Utils.logExceptionStack(x0); }
  gSobject.getIp = function(x0) { return Utils.getIp(x0); }
  gSobject.preloadImage = function(x0) { return Utils.preloadImage(x0); }
  gSobject.loadScript = function(x0,x1,x2) { return Utils.loadScript(x0,x1,x2); }
  gSobject.mapToJsonString = function(x0) { return Utils.mapToJsonString(x0); }
  gSobject.stringToJson = function(x0,x1) { return Utils.stringToJson(x0,x1); }
  gSobject.stringToDate = function(x0) { return Utils.stringToDate(x0); }
  gSobject.isDate = function(x0) { return Utils.isDate(x0); }
  gSobject.deepCopyMap = function(x0) { return Utils.deepCopyMap(x0); }
  gSobject.findDeep = function(x0,x1) { return Utils.findDeep(x0,x1); }
  gSobject.removeMapKey = function(x0,x1,x2) { return Utils.removeMapKey(x0,x1,x2); }
  gSobject.formatNumber = function(x0,x1,x2,x3) { return Utils.formatNumber(x0,x1,x2,x3); }
  gSobject.iFrameById = function(x0) { return Utils.iFrameById(x0); }
  gSobject.decodeJWT = function(x0) { return Utils.decodeJWT(x0); }
  gSobject.embedTextInBlob = function(x0,x1,x2) { return Utils.embedTextInBlob(x0,x1,x2); }
  gSobject.embedTextInBlobNative = function(x0,x1,x2) { return Utils.embedTextInBlobNative(x0,x1,x2); }
  gSobject.blobToDataUrl = function(x0,x1) { return Utils.blobToDataUrl(x0,x1); }
  gSobject.dataUrlToBlob = function(x0,x1) { return Utils.dataUrlToBlob(x0,x1); }
  gSobject.take = function(x0,x1) { return Utils.take(x0,x1); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
Utils.getAuthToken = function(it) {
  return gs.gp(Utils.session,"authToken");
 }
Utils.getDeviceToken = function(it) {
  return gs.gp(Utils.session,"deviceToken");
 }
Utils.setTimeout = function(callback, timeout) {
  return setTimeout(callback, timeout);
 }
Utils.setInterval = function(callback, timeout) {
  return setInterval(callback, timeout);
 }
Utils.clearInterval = function(interval) {
  return clearInterval(interval);
 }
Utils.localDateString = function(date) {
  return gs.mc(gs.mc(gs.mc(Utils,"moment",[date]),"utcOffset",[0, true]),"toISOString",[]);
 }
Utils.utcDateString = function(date) {
  return gs.mc(gs.mc(gs.mc(Utils,"moment",[date]),"utc",[]),"toISOString",[]);
 }
Utils.newDate = function(year, month, day) {
  return new Date(year, month, day)
 }
Utils.documentReady = function(callback) {
  if ((gs.gp(Utils.document,"readyState") === "complete") || ((gs.gp(Utils.document,"readyState") !== "loading") && (!gs.bool(gs.gp(gs.gp(Utils.document,"documentElement"),"doScroll"))))) {
    return gs.execCall(callback, this, []);
   } else {
    return gs.mc(Utils.document,"addEventListener",["DOMContentLoaded", callback]);
   };
 }
Utils.uniqueList = function(list, closure) {
  var newList = gs.list([]);
  gs.mc(gs.mc(list,"reverse",[]),"each",[function(listItem) {
    if (!gs.bool(gs.mc(newList,"find",[function(it) {
      return gs.equals(gs.execCall(closure, this, [listItem]), gs.execCall(closure, this, [it]));
     }]))) {
      return gs.mc(newList,"add",[listItem]);
     };
   }]);
  return gs.mc(newList,"reverse",[]);
 }
Utils.listsEqual = function(a, b) {
  if (gs.mc(a,"size",[]) != gs.mc(b,"size",[])) {
    return false;
   };
  for (var i = 0 ; i < gs.mc(a,"size",[]) ; i++) {
    if ((a[i]) != (b[i])) {
      return false;
     };
   };
  return true;
 }
Utils.uuid = function(it) {
  return gs.mc(Utils.guid(),"replaceAll",["-", ""]);
 }
Utils.guid = function() {
  const UNIX_TS_MS_BITS = 48;
        const VER_DIGIT = "7";
        const SEQ_BITS = 12;
        const VAR = 0b10;
        const VAR_BITS = 2;
        const RAND_BITS = 62;
        
        let prevTimestamp = -1;
        let seq = 0;
    
        const timestamp = Math.max(Date.now(), prevTimestamp);
        seq = timestamp === prevTimestamp ? seq + 1 : 0;
        prevTimestamp = timestamp;
        
        const var_rand = new Uint32Array(2);
        crypto.getRandomValues(var_rand);
        var_rand[0] = (VAR << (32 - VAR_BITS)) | (var_rand[0] >>> VAR_BITS);
        
        const digits = timestamp.toString(16).padStart(UNIX_TS_MS_BITS / 4, "0") + VER_DIGIT +
            seq.toString(16).padStart(SEQ_BITS / 4, "0") +
            var_rand[0].toString(16).padStart((VAR_BITS + RAND_BITS) / 2 / 4, "0") +
            var_rand[1].toString(16).padStart((VAR_BITS + RAND_BITS) / 2 / 4, "0");
        
        return (digits.slice(0, 8) + "-" + digits.slice(8, 12) + "-" + digits.slice(12, 16) + "-" + 
            digits.slice(16, 20) + "-" + digits.slice(20));
 }
Utils.callChain = function(callChain, success, fail) {
  if (success === undefined) success = null;
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'callChain', this,[callChain, success, fail]);
 }
Utils.callObject = function(self, method, args, success, fail) {
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'callObject', this,[self, method, args, success, fail]);
 }
Utils.send = function(call, data, success, fail) {
  if (fail === undefined) fail = null;
  return gs.execStatic(Socket,'send', this,[call, data, success, fail]);
 }
Utils.subscribe = function(objectId, success, topic) {
  if (topic === undefined) topic = gs.gp(Socket,"SOCKET_OBJECT_URL");
  return gs.execStatic(Socket,'subscribe', this,[objectId, success, topic]);
 }
Utils.unsubscribe = function(objectId) {
  return gs.execStatic(Socket,'unsubscribe', this,[objectId]);
 }
Utils.subscribeTopic = function(topicId, success) {
  return gs.execStatic(Socket,'subscribeTopic', this,[topicId, success]);
 }
Utils.unsubscribeTopic = function(topicId) {
  return gs.execStatic(Socket,'unsubscribeTopic', this,[topicId]);
 }
Utils.rememberDays = function(it) {
  var days = Utils.parseDays(gs.gp(Utils.session,"rememberDays"));
  return (gs.equals(days, null) ? Utils.REMEMBER_FALLBACK_DAYS : days);
 }
Utils.rememberWindowExpired = function(it) {
  var days = Utils.rememberDays();
  if (gs.equals(days, 0)) {
    return !Utils.launchMarkerPresent();
   };
  var loginAt = gs.gp(Utils.session,"loginAt");
  if (!gs.bool(loginAt)) {
    return true;
   };
  return (gs.minus(Utils.nowMillis(), Utils.toMillis(loginAt))) > (gs.multiply((gs.multiply((gs.multiply((gs.multiply(days, 24)), 60)), 60)), 1000));
 }
Utils.clearRememberedLogin = function(it) {
  gs.sp(Utils.session,"zoner",null);
  gs.sp(Utils.session,"zonerId",null);
  gs.sp(Utils.session,"jwt",null);
  gs.sp(Utils.session,"loginAt",null);
  gs.sp(Utils.session,"rememberDays",null);
  return Utils.clearLaunchMarker();
 }
Utils.parseDays = function(raw) {
  if (gs.equals(raw, null)) {
    return null;
   };
  return Utils.toWholeNumber(raw);
 }
Utils.toWholeNumber = function(raw) {
  var s = ('' + raw).trim();
        if (!/^[0-9]+$/.test(s)) return null;
        var n = parseInt(s, 10);
        return isNaN(n) ? null : n;
 }
Utils.nowMillis = function() {
  return new Date().getTime();
 }
Utils.toMillis = function(value) {
  if (value == null) return 0;
        if (value instanceof Date) return value.getTime();
        var n = parseInt('' + value, 10);
        return isNaN(n) ? 0 : n;
 }
Utils.launchMarkerPresent = function() {
  try { return sessionStorage.getItem('dymicoLoginLaunch') === 'true'; } catch(e){ return false; }
 }
Utils.markLaunch = function() {
  try { sessionStorage.setItem('dymicoLoginLaunch', 'true'); } catch(e){}
 }
Utils.clearLaunchMarker = function() {
  try { sessionStorage.removeItem('dymicoLoginLaunch'); } catch(e){}
 }
Utils.tokenAuth = function(success, fail) {
  if (fail === undefined) fail = function(it) {
   };
  gs.println(gs.plus("Utils:tokenAuth:", gs.gp(StartupParams,"doAuthToken")));
  if ((gs.bool(gs.gp(Utils.session,"zoner"))) && (!gs.bool(Utils.rememberWindowExpired()))) {
    gs.println("Utils:tokenAuth:zoner cached");
    gs.execCall(success, this, []);
    success = null;
    return null;
   };
  if (gs.bool(gs.gp(Utils.session,"zoner"))) {
    gs.println("Utils:tokenAuth:remember window expired");
    Utils.clearRememberedLogin();
   };
  gs.println("Utils:tokenAuth:loading zoner");
  var callback = function(authMap) {
    gs.println(gs.plus("tokenAuth:callback:authMap:", authMap));
    if (gs.bool(gs.gp(authMap,"authenticated",true))) {
      gs.mc(Utils,"updateAuthTokenToSession",[authMap, false]);
      if (gs.bool(success)) {
        gs.execCall(success, this, []);
       };
      return null;
     };
    return gs.execCall(fail, this, []);
   };
  gs.println(gs.plus("getDeviceToken():", Utils.getDeviceToken()));
  return gs.execStatic(Utils,'send', this,["authenticationToken", gs.map().add("deviceId",Utils.getDeviceToken()), callback]);
 }
Utils.userAgent = function() {
  return navigator.userAgent.toLowerCase()
 }
Utils.login = function(username, password, success, fail) {
  if (fail === undefined) fail = function(it) {
   };
  var callback = function(authMap) {
    if (gs.bool(gs.gp(authMap,"authenticated",true))) {
      gs.mc(Utils,"updateAuthTokenToSession",[authMap]);
      gs.execCall(success, this, []);
      return null;
     };
    gs.sp(Utils.session,"zoner",null);
    gs.println("Login failed");
    return gs.execCall(fail, this, []);
   };
  return gs.execStatic(Utils,'send', this,["authentication", gs.map().add("username",username).add("password",password).add("deviceId",Utils.getDeviceToken()).add("userAgent",Utils.userAgent()), callback, fail]);
 }
Utils.updateAuthTokenToSession = function(authMap, freshLogin) {
  if (freshLogin === undefined) freshLogin = true;
  Utils.setCookie(gs.gp(Socket,"AUTH_TOKEN"), gs.gp(gs.gp(authMap,"zoner"),"token"));
  gs.sp(Utils.session,"zoner",gs.gp(authMap,"zoner"));
  gs.sp(Utils.session,"zonerId",gs.gp(gs.gp(authMap,"zoner"),"id"));
  if (gs.gp(authMap,"rememberDays") != null) {
    gs.sp(Utils.session,"rememberDays",gs.gp(authMap,"rememberDays"));
   };
  if ((gs.bool(freshLogin)) || (!gs.bool(gs.gp(Utils.session,"loginAt")))) {
    gs.sp(Utils.session,"loginAt",Utils.nowMillis());
   };
  Utils.markLaunch();
  if (gs.bool(gs.gp(authMap,"jwt"))) {
    gs.sp(Utils.session,"jwt",gs.gp(authMap,"jwt"));
   };
  return Utils.triggerLoginRerenderCheck(Utils.roleSignature(gs.gp(gs.gp(authMap,"zoner"),"roles")));
 }
Utils.roleSignature = function(roles) {
  return gs.mc(gs.mc(gs.mc(gs.elvis(gs.bool(roles) , roles , gs.list([])),"collect",[function(it) {
    return gs.mc(it,"toString",[], null, true);
   }]),"sort",[]),"join",[","]);
 }
Utils.triggerLoginRerenderCheck = function(zonerId) {
  try {
            if (window.dymicoVersionUpdater && window.dymicoVersionUpdater.checkAfterLogin){
                window.dymicoVersionUpdater.checkAfterLogin(zonerId);
            }
        } catch(e){ console.log('triggerLoginRerenderCheck failed', e); }
 }
Utils.logout = function(pathAfterLogout, dropDatabase) {
  if (pathAfterLogout === undefined) pathAfterLogout = "/login/logout";
  if (dropDatabase === undefined) dropDatabase = true;
  if (!gs.bool(pathAfterLogout)) {
    pathAfterLogout = "/login/logout";
   };
  gs.println("Utils.logout");
  gs.sp(Utils.session,"zoner",null);
  gs.sp(Utils.session,"redirectAfterLogin",null);
  gs.sp(Utils.session,"authToken",null);
  gs.sp(Utils.session,"deviceToken",null);
  gs.mc(Utils.session,"clear",[]);
  if (gs.bool(dropDatabase)) {
    gs.execStatic(LocalDB,'getInstance', this,[function(it) {
      return gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"dropDatabase",[]);
     }]);
   };
  gs.println(gs.plus("Utils.logout:redirect to ", pathAfterLogout));
  return Utils.loadPage(pathAfterLogout);
 }
Utils.urlSafeBase64Encode = function(str) {
  // 1. Encode to standard Base64
      let base64 = btoa(str);
      
      // 2. Modify to be URL-safe (RFC 4648 Section 5)
      return base64
        .replace(/\+/g, '-')   // Replace + with -
        .replace(/\//g, '_')   // Replace / with _
        .replace(/=+$/, '');    // Remove trailing = padding
 }
Utils.open = function(url, target, options) {
  if (target === undefined) target = "_system";
  if (options === undefined) options = "";
  if (Utils.isCordova()) {
    return Utils.inAppBrowser(gs.mc(Utils,"encodeURI",[url]), target, options);
   };
  return gs.mc(Utils.window,"open",[url, target, options]);
 }
Utils.inAppBrowser = function(url, target, options) {
  return cordova.InAppBrowser.open(encodeURI(url), target, options)
 }
Utils.loadPage = function(url) {
  window.location = url
 }
Utils.reloadPage = function() {
  var url = window.location.href;   
            var seperator = '?'
            if (url.indexOf('?') > -1){ seperator = '&' }
            window.location.href = url+seperator+'v='+ new Date().getTime(); 
            window.location.reload(true);
 }
Utils.setCookie = function(name, value) {
  Cookies.set(name, JSON.stringify(value));
 }
Utils.getCookie = function(name) {
  try{
            return JSON.parse(Cookies.get(name));
            // return gs.toGroovy(jQuery.parseJSON(unescape(Cookies.get(name)))); 
        }catch(all){
            return null
        }
 }
Utils.deviceType = function(it) {
  if (gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["electron"])) {
    return gs.gp(gs.gp(Utils,"DeviceTypes"),"ELECTRON");
   };
  if ((gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["iphone"])) || (gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["ipad"]))) {
    return gs.gp(gs.gp(Utils,"DeviceTypes"),"IOS");
   };
  if (gs.mc(gs.mc(Utils.userAgent(),"toLowerCase",[]),"contains",["android"])) {
    return gs.gp(gs.gp(Utils,"DeviceTypes"),"ANDROID");
   };
  return gs.gp(gs.gp(Utils,"DeviceTypes"),"BROWSER");
 }
Utils.isBrowser = function(it) {
  return gs.equals(Utils.deviceType(), gs.gp(Utils.DeviceTypes,"BROWSER"));
 }
Utils.isAndroid = function(it) {
  return gs.equals(Utils.deviceType(), gs.gp(gs.gp(Utils,"DeviceTypes"),"ANDROID"));
 }
Utils.isIos = function(it) {
  return gs.equals(Utils.deviceType(), gs.gp(gs.gp(Utils,"DeviceTypes"),"IOS"));
 }
Utils.isCordova = function(it) {
  return gs.mc(Utils.userAgent(),"contains",["cordova"]);
 }
Utils.cordovaDevice = function(it) {
  return Utils.isCordova();
 }
Utils.isOnline = function() {
  return window.navigator.onLine
 }
Utils.userAgent = function() {
  return navigator.userAgent.toLowerCase()
 }
Utils.toast = function(message, showDuration) {
  if (showDuration === undefined) showDuration = 300;
  toastr.options = {
            "closeButton": false,
            "debug": false,
            "newestOnTop": false,
            "progressBar": false,
            "positionClass": "toast-bottom-center",
            "preventDuplicates": false,
            "onclick": null,
            "showDuration": showDuration,
            "hideDuration": "1000",
            "timeOut": "5000",
            "extendedTimeOut": "1000",
            "showEasing": "swing",
            "hideEasing": "linear",
            "showMethod": "fadeIn",
            "hideMethod": "fadeOut"
        }
        toastr.info(message);
 }
Utils.post = function(file, parameter, objectName, id, callback) {
  return gs.execStatic(Socket,'post', this,[file, parameter, objectName, id, callback]);
 }
Utils.validateEmail = function(text) {
  return gs.exactMatch(text,/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[A-Za-z.]{2,}$/);
 }
Utils.validateCellphone = function(text) {
  var cleaned = gs.mc(gs.mc(gs.mc(text,"toString",[], null, true),"trim",[], null, true),"replaceAll",["[\s\-\(\)]", ""], null, true);
  if (!gs.bool(cleaned)) {
    return false;
   };
  if (gs.mc(cleaned,"startsWith",["+"])) {
    return gs.exactMatch(cleaned,/^\+[0-9]{7,15}$/);
   };
  return gs.exactMatch(cleaned,/^0[0-9]{9}$/);
 }
Utils.getType = function(value) {
  return typeof value
 }
Utils.dateString = function(date) {
  return gs.plus((gs.plus((gs.plus((gs.plus(gs.mc(date,"getDate",[]), "/")), (gs.plus(gs.mc(date,"getMonth",[]), 1)))), "/")), gs.mc(date,"getFullYear",[]));
 }
Utils.clearTime = function(date) {
  if (date === undefined) date = gs.date();
  return gs.mc(gs.mc(Utils,"moment",[date]),"startOf",["day"]);
 }
Utils.utc = function(date) {
  if (date === undefined) date = gs.date();
  return gs.mc(gs.mc(Utils,"moment",[date]),"utc",[]);
 }
Utils.appendAppVersion = function(url) {
  if (gs.bool(gs.gp(Utils.session,"branchRevision"))) {
    var appender = "?";
    if (gs.mc(url,"contains",["?"])) {
      appender = "&";
     };
    url += (gs.plus((gs.plus(appender, "branchRevision=")), gs.gp(Utils.session,"branchRevision")));
   };
  return url;
 }
Utils.logExceptionStack = function(msg) {
  console.log('%c ' + msg + ' ', 'color: #cc0000');
 }
Utils.getIp = function(callback) {
  Utils.documentReady(function () {
            $.getJSON("http://jsonip.com/?callback=?", function (data) {
                callback(data.ip)
            });
        });
 }
Utils.preloadImage = function(path) {
  new Image().src = path
 }
Utils.loadScript = function(scriptUrl, type, callback) {
  if (type === undefined) type = "text/javascript";
  if (callback === undefined) callback = function(it) {
   };
  
 }
Utils.mapToJsonString = function(map) {
  return JSON.stringify(map)
 }
Utils.stringToJson = function(message, parseDate) {
  if (parseDate === undefined) parseDate = true;
  var jsonMessage = JSON.parse(message, function(key, value) {
              return Utils.stringToDate(value);
            }
        )
        return gs.toGroovy(jsonMessage)
 }
Utils.stringToDate = function(value) {
  if (typeof value === 'string') {
            //var a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
            var a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})?\.(\d*)?Z$/.exec(value);
            if (a) {
                // console.log('stringToDate:value', value)
                const date = new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6], +a[7]));
                // console.log('stringToDate:date', date)
                return date
            }
        }
        return value;
 }
Utils.isDate = function(date) {
  return date instanceof Date
 }
Utils.deepCopyMap = function(map) {
  return Utils.removeMapKey(gs.toGroovy(Utils.stringToJson(Utils.mapToJsonString(map))),'clazz')
 }
Utils.findDeep = function(m, key) {
  if (m[key]) {
    return m[key];
   };
  var foundValue = null;
  gs.mc(m,"each",[function(k, v) {
    if (gs.bool(foundValue)) {
      return null;
     };
    if (gs.instanceOf(v, "HashMap")) {
      return foundValue = gs.mc(Utils,"findDeep",[v, key]);
     } else {
      if (gs.instanceOf(v, "ArrayList")) {
        return gs.mc(v,"each",[function(item) {
          if (gs.bool(foundValue)) {
            return null;
           };
          if (gs.instanceOf(item, "HashMap")) {
            return foundValue = gs.mc(Utils,"findDeep",[item, key]);
           };
         }]);
       };
     };
   }]);
  return foundValue;
 }
Utils.removeMapKey = function(value, removeKey, list) {
  if (removeKey === undefined) removeKey = "clazz";
  if (list === undefined) list = gs.list([]);
  if (!gs.bool(value)) {
    return value;
   };
  if (((gs.instanceOf(value, "Map")) || (gs.instanceOf(value, "LinkedHashMap"))) || (gs.instanceOf(value, "HashMap"))) {
    gs.mc(value,"remove",[removeKey]);
    if (gs.mc(list,"includes",[value])) {
      return value;
     };
    gs.mc(list,"add",[value]);
    gs.mc(value,"each",[function(key, mapValue) {
      return gs.mc(Utils,"removeMapKey",[mapValue, removeKey, list]);
     }]);
   };
  if ((gs.instanceOf(value, "List")) || (gs.instanceOf(value, "ArrayList"))) {
    for (_i0 = 0, listValue = value[0]; _i0 < value.length; listValue = value[++_i0]) {
      Utils.removeMapKey(listValue, removeKey, list);
     };
   };
  return value;
 }
Utils.formatNumber = function(number, decimals, dec, sep) {
  if (decimals === undefined) decimals = 0;
  if (dec === undefined) dec = ".";
  if (sep === undefined) sep = " ";
  var n = !isFinite(+number) ? 0 : +number, 
            prec = Math.abs(decimals),
            toFixedFix = function (n, prec) {
                // Fix for IE parseFloat(0.55).toFixed(0) = 0;
                var k = Math.pow(10, prec);
                return Math.round(n * k) / k;
            },
            s = (prec ? toFixedFix(n, prec) : Math.round(n)).toString().split('.');
        if (s[0].length > 3) {
            s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
        }
        if ((s[1] || '').length < prec) {
            s[1] = s[1] || '';
            s[1] += new Array(prec - s[1].length + 1).join('0');
        }
        return s.join(dec);
 }
Utils.iFrameById = function(id) {
  var x = gs.mc(Utils.document,"getElementById",[id]);
  return gs.elvis(gs.bool(gs.gp(x,"contentWindow")) , gs.gp(x,"contentWindow") , gs.gp(x,"contentDocument"));
 }
Utils.decodeJWT = function(token) {
  var base64Url = token.split('.')[1];
        var base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
        var jsonPayload = decodeURIComponent(atob(base64).split('').map(function(c) {
            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
        }).join(''));
    
        return JSON.parse(jsonPayload);
 }
Utils.embedTextInBlob = function(fileOrBlob, textToEmbed, callback) {
  gs.println("textToEmbed");
  gs.println(textToEmbed);
  if (!gs.bool(textToEmbed)) {
    return gs.execCall(callback, this, [fileOrBlob]);
   };
  return Utils.embedTextInBlobNative(fileOrBlob, textToEmbed, callback);
 }
Utils.embedTextInBlobNative = function(fileOrBlob, text, callback) {
  const reader = new FileReader();
    
      reader.onload = function (e) {
        const img = new Image();
        img.onload = function () {
          const canvas = document.createElement("canvas");
          const ctx = canvas.getContext("2d");
    
          canvas.width = img.width;
          canvas.height = img.height;
          
          var fontSize = canvas.width * 0.025
          
          console.log('fontSize1', fontSize)
          
          if (fontSize < 5 ) fontSize = 5
          
          console.log('fontSize2', fontSize)
    
          // Draw the image
          ctx.drawImage(img, 0, 0);
    
          // Draw text bottom-right
          ctx.font = fontSize+"px Sans-serif";
          ctx.fillStyle = "White";
          ctx.textAlign = "right";
          ctx.textBaseline = "bottom";
    
          const padding = 2;
          ctx.fillText(text, canvas.width - padding, canvas.height - padding);
    
          // Return result as a Blob
          canvas.toBlob(function (blob) {
            callback(blob);
          }, "image/png");
        };
    
        img.onerror = function (err) {
          callback("Image failed to load: " + err);
        };
    
        img.src = e.target.result;
      };
    
      reader.onerror = function (err) {
        callback("FileReader error: " + err);
      };
    
      // Read the file/blob as Data URL
      reader.readAsDataURL(fileOrBlob);
 }
Utils.blobToDataUrl = function(blob, callback) {
  const fileReader = new FileReader();
  
        fileReader.onload = function() {
            callback(fileReader.result)
        }
    
        fileReader.readAsDataURL(blob);
 }
Utils.dataUrlToBlob = function(dataUrl, callback) {
  return gs.mc(gs.mc(gs.mc(Utils.window,"fetch",[dataUrl]),"then",[function(res) {
    return gs.mc(res,"blob",[]);
   }]),"then",[function(blob) {
    return gs.execCall(callback, this, [blob]);
   }]);
 }
Utils.take = function(string, len) {
  if (len === undefined) len = 40;
  if ((!gs.bool(string)) || (gs.mc(string,"size",[]) < len)) {
    return string;
   };
  return gs.rangeFromList(string, 0, len);
 }
Utils.session = gs.execStatic(Session,'instance', this,[]);
Utils.window = null;
Utils.document = null;
Utils.DeviceTypes = gs.map().add("ANDROID","android").add("IOS","ios").add("ELECTRON","electron").add("BROWSER","browser");
Utils.AUTH_FAILED = "AUTH_FAILED";
Utils.NO_AUTH = "NO_AUTH";
Utils.REMEMBER_FALLBACK_DAYS = 30;

function ObjectRegistry() {
  var gSobject = gs.init('ObjectRegistry');
  gSobject.clazz = { name: 'ObjectRegistry', simpleName: 'ObjectRegistry'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'objectRegistry', { get: function() { return ObjectRegistry.objectRegistry; }, set: function(gSval) { ObjectRegistry.objectRegistry = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'enabled', { get: function() { return ObjectRegistry.enabled; }, set: function(gSval) { ObjectRegistry.enabled = gSval; }, enumerable: true });
  gSobject.object = function(x0) { return ObjectRegistry.object(x0); }
  gSobject.register = function(x0) { return ObjectRegistry.register(x0); }
  gSobject.registerSingle = function(x0,x1) { return ObjectRegistry.registerSingle(x0,x1); }
  gSobject.isDatabaseObject = function(x0) { return ObjectRegistry.isDatabaseObject(x0); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
ObjectRegistry.object = function(id) {
  return ObjectRegistry.objectRegistry[id];
 }
ObjectRegistry.register = function(objects) {
  if (!gs.bool(ObjectRegistry.enabled)) {
    return objects;
   };
  if (gs.instanceOf(objects, "ArrayList")) {
    var oObjectList = gs.list([]);
    gs.mc(objects,"eachWithIndex",[function(object, index) {
      return gs.mc(oObjectList,"add",[gs.mc(ObjectRegistry,"registerSingle",[object])]);
     }]);
    return oObjectList;
   } else {
    return ObjectRegistry.registerSingle(objects);
   };
 }
ObjectRegistry.registerSingle = function(object, flatCopy) {
  if (flatCopy === undefined) flatCopy = true;
  if (!gs.bool(ObjectRegistry.isDatabaseObject(object))) {
    return object;
   };
  var oObject = ObjectRegistry.objectRegistry[gs.gp(object,"_id")];
  if (!gs.bool(oObject)) {
    oObject = OObject(object);
    (ObjectRegistry.objectRegistry[gs.gp(object,"_id")]) = oObject;
   } else {
    gs.mc(oObject,"merge",[object, flatCopy]);
   };
  gs.mc(object,"each",[function(key, value) {
    if (gs.mc(ObjectRegistry,"isDatabaseObject",[value])) {
      var newValue = gs.mc(ObjectRegistry,"registerSingle",[value, false]);
      return (gs.gp(oObject,"internalMap")[key]) = gs.mc(newValue,"toJs",[]);
     } else {
      if ((value != null) && (gs.instanceOf(value, "ArrayList"))) {
        var oObjectList = gs.list([]);
        gs.mc(value,"eachWithIndex",[function(objectVal, index) {
          if (gs.mc(ObjectRegistry,"isDatabaseObject",[objectVal])) {
            return gs.mc(oObjectList,"add",[gs.mc(gs.mc(ObjectRegistry,"registerSingle",[objectVal]),"toJs",[])]);
           } else {
            return gs.mc(oObjectList,"add",[objectVal]);
           };
         }]);
        return (gs.gp(oObject,"internalMap")[key]) = oObjectList;
       };
     };
   }]);
  gs.execStatic(Utils,'setTimeout', this,[function(it) {
    return gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"updateIfExists",[oObject]);
   }, 100]);
  return oObject;
 }
ObjectRegistry.isDatabaseObject = function(object) {
  return ((object != null) && (gs.instanceOf(object, "HashMap"))) && (gs.bool(gs.gp(object,"_id")));
 }
ObjectRegistry.objectRegistry = gs.map();
ObjectRegistry.enabled = false;

function OObject() {
  var gSobject = gs.init('OObject');
  gSobject.clazz = { name: 'OObject', simpleName: 'OObject'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.internalMap = gs.map();
  gSobject.methodMissingName = null;
  gSobject.methodMissingArgs = null;
  gs.astDelegate('OObject', 'internalMap');
  gSobject.refresher = null;
  gSobject.updateCallback = function(it) {
   };
  gSobject['subscribe'] = function(it) {
    return gs.execStatic(Utils,'subscribe', this,[gs.gp(gSobject.internalMap,"_id"), gSobject.updateCallback]);
   }
  gSobject['unsubscribe'] = function(it) {
    return gs.execStatic(Utils,'unsubscribe', this,[gs.gp(gSobject.internalMap,"_id")]);
   }
  gSobject['setRefresher'] = function(closure, update) {
    if (update === undefined) update = true;
    gs.mc(gSobject,"subscribe",[]);
    if ((!gs.bool(gSobject.refresher)) || ((gs.bool(gSobject.refresher)) && (gs.bool(update)))) {
      return gSobject.refresher = closure;
     };
   }
  gSobject['merge'] = function(object, flatCopy) {
    if (flatCopy === undefined) flatCopy = true;
    if ((gs.bool(object)) && (gs.instanceOf(object, "OObject"))) {
      object = gs.gp(object,"internalMap");
     };
    gs.mc(object,"each",[function(key, value) {
      if (gs.bool(flatCopy)) {
        (gSobject.internalMap[key]) = value;
        return null;
       };
      if (!gs.bool(((value != null) && (gs.instanceOf(value, "String"))) && (gs.execStatic(ObjectRegistry,'isDatabaseObject', this,[gSobject.internalMap[key]])))) {
        return (gSobject.internalMap[key]) = value;
       } else {
        gs.println("WARNING: skip overwrite of DatabaseObject with String");
        gs.println(gs.plus("Key:", key));
        gs.println(gs.plus("String:", value));
        gs.println("internalMap[key]:");
        gs.println(gSobject.internalMap[key]);
        gs.println("Object:");
        return gs.println(gSobject.internalMap);
       };
     }]);
    if (gs.bool(gSobject.refresher)) {
      return gs.mc(gSobject,"refresher",[this]);
     };
   }
  gSobject['toJs'] = function(it) {
    return gSobject.internalMap;
   }
  gSobject['toString'] = function(it) {
    return gs.mc(gSobject.internalMap,"toString",[]);
   }
  gSobject['setProperty'] = function(name, value) {
    return (gSobject.internalMap[name]) = value;
   }
  gSobject['getProperty'] = function(name) {
    return gSobject.internalMap[name];
   }
  gSobject['methodMissing'] = function(name, args) {
    gSobject.methodMissingName = name;
    gSobject.methodMissingArgs = args;
    if (gs.bool(args)) {
      var successClosure = gs.mc(args,"last",[]);
      if (gs.instanceOf(successClosure, "Closure")) {
        if (gs.equals(gs.mc(args,"size",[]), 1)) {
          args = null;
         } else {
          args = (gs.rangeFromList(args, 0, -2));
         };
        gSobject.methodMissingArgs = args;
        return gs.mc(gSobject,"then",[successClosure]);
       };
     };
   }
  gSobject['then'] = function(successClosure, fail) {
    if (successClosure === undefined) successClosure = function(it) {
     };
    if (fail === undefined) fail = function(it) {
     };
    return gs.execStatic(Utils,'callObject', this,[gSobject.internalMap, gSobject.methodMissingName, gSobject.methodMissingArgs, successClosure, fail]);
   }
  gSobject['do'] = function(success) {
    if (success === undefined) success = function(it) {
     };
    return gs.mc(gSobject,"then",[success, null]);
   }
  gSobject.await = function() {
    
   }
  gSobject.promise = function() {
    var self = this;
        return new Promise(function(resolve, reject) {
            self.then(resolve, function(err) { reject(err); });
        });
   }
  gSobject['OObject1'] = function(self) {
    gs.mc(gSobject,"merge",[self]);
    return this;
  }
  if (arguments.length==1) {gSobject.OObject1(arguments[0]); }
  
  return gSobject;
 };

function ObjectFinder() {
  var gSobject = gs.init('ObjectFinder');
  gSobject.clazz = { name: 'ObjectFinder', simpleName: 'ObjectFinder'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'singleO', { get: function() { return ObjectFinder.singleO; }, set: function(gSval) { ObjectFinder.singleO = gSval; }, enumerable: true });
  gSobject.log = RemoteLog("Transmission");
  gSobject.getInstance = function() { return ObjectFinder.getInstance(); }
  gSobject['propertyMissing'] = function(name) {
    var argList = gs.list([gs.map().add("property",name)]);
    return NestedO(argList, CacheCallTracker(0, false, false));
   }
  gSobject['local'] = function(ttl, remoteOnce) {
    if (remoteOnce === undefined) remoteOnce = false;
    var argList = gs.list([]);
    return NestedO(argList, CacheCallTracker(ttl, remoteOnce));
   }
  gSobject['localAndRemote'] = function(ttl) {
    if (ttl === undefined) ttl = -1;
    gs.println("localAndRemote");
    return gs.mc(gSobject,"local",[ttl]);
   }
  gSobject['localAndRemoteOnce'] = function(ttl) {
    if (ttl === undefined) ttl = -1;
    return gs.mc(gSobject,"local",[ttl, true]);
   }
  gSobject['post'] = function(file, parameter, objectName, id, callback) {
    if (objectName === undefined) objectName = null;
    if (id === undefined) id = null;
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(file)) {
      gs.println("No file selected");
      return null;
     };
    gs.println(gs.plus("file: ", file));
    gs.println(gs.plus("parameter: ", parameter));
    gs.println(gs.plus("objectName: ", objectName));
    gs.println(gs.plus("id: ", id));
    return gs.execStatic(Utils,'post', this,[file, parameter, objectName, id, callback]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
ObjectFinder.getInstance = function(it) {
  if (gs.bool(ObjectFinder.singleO)) {
    return ObjectFinder.singleO;
   };
  ObjectFinder.singleO = ObjectFinder();
  return ObjectFinder.singleO;
 }
ObjectFinder.singleO = null;

function RemoteLog() {
  var gSobject = gs.init('RemoteLog');
  gSobject.clazz = { name: 'RemoteLog', simpleName: 'RemoteLog'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.className = null;
  gSobject['info'] = function(message) {
    return gs.mc(gSobject,"generic",["info", message]);
   }
  gSobject['debug'] = function(message) {
    return gs.mc(gSobject,"generic",["debug", message]);
   }
  gSobject['warn'] = function(message) {
    return gs.mc(gSobject,"generic",["warn", message]);
   }
  gSobject['error'] = function(message) {
    return gs.mc(gSobject,"generic",["error", message]);
   }
  gSobject['off'] = function(message) {
    return gs.mc(gSobject,"generic",["off", message]);
   }
  gSobject['trace'] = function(message) {
    return gs.mc(gSobject,"generic",["trace", message]);
   }
  gSobject['generic'] = function(callName, message) {
    try {
      gs.println(gs.plus((gs.plus(gSobject.className, ":")), message));
     }
    catch (all) {
     }
    ;
    return gs.mc(gs.mc(gs.mc(gs.execStatic(ObjectFinder,'getInstance', this,[]),"propertyMissing",["log"]),"" + (callName) + "",[message, gSobject.className]),"do",[]);
   }
  gSobject['RemoteLog1'] = function(className) {
    gs.sp(this,"className",className);
    return this;
  }
  if (arguments.length==1) {gSobject.RemoteLog1(arguments[0]); }
  
  return gSobject;
 };

function NestedO() {
  var gSobject = gs.init('NestedO');
  gSobject.clazz = { name: 'NestedO', simpleName: 'NestedO'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.cacheCallTracker = null;
  gSobject.successClosure = null;
  gSobject.failClosure = function(it) {
   };
  gSobject.argList = gs.list([]);
  gSobject['methodMissing'] = function(name, args) {
    if (gs.mc(gSobject.argList,"size",[]) > 16) {
      throw {message: "Maximum call stack size 16 exceeded"};
     };
    if (gs.bool(args)) {
      var successClosure = gs.mc(args,"last",[]);
      var failClosure = function(it) {
       };
      if ((gs.bool(successClosure)) && (gs.instanceOf(successClosure, "Closure"))) {
        if (gs.equals(gs.mc(args,"size",[]), 1)) {
          args = null;
         } else {
          args = (gs.rangeFromList(args, 0, -2));
          if ((gs.mc(args,"last",[])) && (gs.instanceOf(gs.mc(args,"last",[]), "Closure"))) {
            failClosure = successClosure;
            successClosure = gs.mc(args,"last",[]);
            if (gs.equals(gs.mc(args,"size",[]), 1)) {
              args = null;
             } else {
              args = (gs.rangeFromList(args, 0, -2));
             };
           };
         };
        gs.mc(gSobject.argList,"add",[gs.map().add("method",name).add("args",args)]);
        gs.sp(this,"successClosure",successClosure);
        gs.sp(this,"failClosure",failClosure);
        gs.mc(gSobject,"then",[successClosure, failClosure]);
        return null;
       };
     };
    gs.mc(gSobject.argList,"add",[gs.map().add("method",name).add("args",args)]);
    return NestedO(gSobject.argList, gSobject.cacheCallTracker);
   }
  gSobject.isUndefined = function(val) {
    return val === undefined
   }
  gSobject['propertyMissing'] = function(name) {
    if (gs.mc(gSobject.argList,"size",[]) > 16) {
      throw {message: "Maximum call stack size 16 exceeded"};
     };
    gs.mc(gSobject.argList,"add",[gs.map().add("property",name)]);
    return NestedO(gSobject.argList, gSobject.cacheCallTracker);
   }
  gSobject['then'] = function(success, fail) {
    if (fail === undefined) fail = function(it) {
     };
    return gs.mc(gSobject.cacheCallTracker,"callAndCache",[gSobject.argList, success, fail]);
   }
  gSobject['do'] = function(it) {
    return gs.mc(gSobject,"then",[function(it) {
     }]);
   }
  gSobject.await = function() {
    
   }
  gSobject.promise = function() {
    var self = this;
        return new Promise(function(resolve, reject) {
            self.then(resolve, function(err) { reject(err); });
        });
   }
  gSobject['NestedO2'] = function(argList, cacheCallTracker) {
    gs.sp(this,"cacheCallTracker",cacheCallTracker);
    gs.sp(this,"argList",argList);
    return this;
  }
  if (arguments.length==2) {gSobject.NestedO2(arguments[0], arguments[1]); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function LocalDB() {
  var gSobject = gs.init('LocalDB');
  gSobject.clazz = { name: 'LocalDB', simpleName: 'LocalDB'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'DB_VERSION_NO', { get: function() { return LocalDB.DB_VERSION_NO; }, set: function(gSval) { LocalDB.DB_VERSION_NO = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DB_NAME', { get: function() { return LocalDB.DB_NAME; }, set: function(gSval) { LocalDB.DB_NAME = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_ROWS_PER_BATCH', { get: function() { return LocalDB.MAX_ROWS_PER_BATCH; }, set: function(gSval) { LocalDB.MAX_ROWS_PER_BATCH = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'ASYNC_DB', { get: function() { return LocalDB.ASYNC_DB; }, set: function(gSval) { LocalDB.ASYNC_DB = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DB_COMPRESS', { get: function() { return LocalDB.DB_COMPRESS; }, set: function(gSval) { LocalDB.DB_COMPRESS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DB_ENCRYPT', { get: function() { return LocalDB.DB_ENCRYPT; }, set: function(gSval) { LocalDB.DB_ENCRYPT = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'startupCompleted', { get: function() { return LocalDB.startupCompleted; }, set: function(gSval) { LocalDB.startupCompleted = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'instance', { get: function() { return LocalDB.instance; }, set: function(gSval) { LocalDB.instance = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'jsDbInstance', { get: function() { return LocalDB.jsDbInstance; }, set: function(gSval) { LocalDB.jsDbInstance = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'db', { get: function() { return LocalDB.db; }, set: function(gSval) { LocalDB.db = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'objectMaps', { get: function() { return LocalDB.objectMaps; }, set: function(gSval) { LocalDB.objectMaps = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'callbacks', { get: function() { return LocalDB.callbacks; }, set: function(gSval) { LocalDB.callbacks = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'checkVersion', { get: function() { return LocalDB.checkVersion; }, set: function(gSval) { LocalDB.checkVersion = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'cleanupStaleData', { get: function() { return LocalDB.cleanupStaleData; }, set: function(gSval) { LocalDB.cleanupStaleData = gSval; }, enumerable: true });
  gSobject.localO = LocalDB$LocalO(this);
  gSobject.getInstance = function(x0) { return LocalDB.getInstance(x0); }
  gSobject.initDb = function(x0,x1) { return LocalDB.initDb(x0,x1); }
  gSobject.dropDatabase = function(x0) { return LocalDB.dropDatabase(x0); }
  gSobject['cacheObjects'] = function(key, objectsIn, ttl, callback) {
    var ttlInMs = (gs.equals(ttl, -1) ? null : gs.plus(gs.gp(gs.date(),"time"), (gs.multiply(ttl, 1000))));
    key = (gs.plus("c:", key));
    return gs.mc(LocalDB.db,"upsert",[gs.map().add("_id",key).add("_ttl",ttlInMs).add("stringValue",gs.execStatic(Utils,'mapToJsonString', this,[objectsIn])), function(it) {
      var callbackTmp = callback;
      callback = null;
      if (gs.bool(callbackTmp)) {
        return gs.execCall(callbackTmp, this, []);
       };
     }]);
   }
  gSobject['readCache'] = function(key) {
    key = (gs.plus("c:", key));
    var keyObject = gs.mc(LocalDB.db,"find",[gs.map().add("_id",key)]);
    gs.println(keyObject);
    if (gs.equals(gs.gp(keyObject,"length"), 0)) {
      return null;
     };
    keyObject = (keyObject[0]);
    if ((gs.bool(gs.gp(keyObject,"_ttl"))) && (gs.gp(keyObject,"_ttl") <= gs.gp(gs.date(),"time"))) {
      gs.mc(LocalDB.db,"remove",[gs.map().add("_id",key)]);
      gs.mc(LocalDB.db,"save",[]);
      return null;
     };
    return gs.execStatic(Utils,'stringToJson', this,[gs.gp(keyObject,"stringValue")]);
   }
  gSobject['registerPath'] = function(objectName, objectMap) {
    return (LocalDB.objectMaps[objectName]) = objectMap;
   }
  gSobject['insert'] = function(object, callback) {
    if (callback === undefined) callback = null;
    object = (gs.mc(gs.map(),'leftShift', gs.list([object])));
    gs.mc(gSobject,"fixDatesToDb",[object]);
    if (gs.bool(callback)) {
      return gs.mc(LocalDB.db,"upsert",[object, function(it) {
        var callbackTmp = callback;
        callback = null;
        if (gs.bool(callbackTmp)) {
          return gs.execCall(callbackTmp, this, [object]);
         };
       }]);
     };
    gs.mc(LocalDB.db,"upsert",[object]);
    gs.mc(LocalDB.db,"save",[]);
    return object;
   }
  gSobject['save'] = function(object, callback) {
    if (callback === undefined) callback = null;
    gs.sp(object,"_dateCreated",gs.elvis(gs.bool(gs.gp(object,"_dateCreated")) , gs.gp(object,"_dateCreated") , gs.date()));
    gs.sp(object,"_lastUpdated",gs.date());
    gs.sp(object,"_remoteChange",true);
    return gs.mc(gSobject,"insert",[object, callback]);
   }
  gSobject['insertAll'] = function(objects, callback) {
    if (callback === undefined) callback = function(it) {
     };
    for (_i3 = 0, object = objects[0]; _i3 < objects.length; object = objects[++_i3]) {
      gs.mc(this,"fixDatesToDb",[object], gSobject);
     };
    return gs.mc(LocalDB.db,"upsert",[objects, callback]);
   }
  gSobject['saveAll'] = function(objects, callback) {
    if (callback === undefined) callback = function(it) {
     };
    for (_i4 = 0, object = objects[0]; _i4 < objects.length; object = objects[++_i4]) {
      gs.sp(object,"_dateCreated",gs.elvis(gs.bool(gs.gp(object,"_dateCreated")) , gs.gp(object,"_dateCreated") , gs.date()));
      gs.sp(object,"_lastUpdated",gs.date());
      gs.sp(object,"_remoteChange",true);
     };
    return gs.mc(gSobject,"insertAll",[objects, callback]);
   }
  gSobject['commit'] = function(errorCallback) {
    if (errorCallback === undefined) errorCallback = function(it) {
     };
    return gs.mc(LocalDB.db,"save",[errorCallback]);
   }
  gSobject['updateIfExists'] = function(object) {
    var keyObject = gs.mc(LocalDB.db,"find",[gs.toJavascript(gs.map().add("_id",gs.gp(object,"_id")))]);
    if (gs.bool(keyObject)) {
      return gs.mc(gSobject,"insert",[object]);
     };
   }
  gSobject['getO'] = function(it) {
    return gSobject.localO;
   }
  gSobject['objectCallWrapper'] = function(objectName) {
    var staticFilter = LocalDB.objectMaps[objectName];
    return gs.map().add("getOne",function(id, callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"getOne",[id, callback]);
     }).add("findOne",function(filter, callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"findOne",[gs.mc(filter,'leftShift', gs.list([staticFilter])), callback]);
     }).add("findOrCreate",function(filter, mapToSave, callback) {
      if (mapToSave === undefined) mapToSave = gs.map();
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"findOrCreate",[gs.mc(filter,'leftShift', gs.list([staticFilter])), mapToSave, callback]);
     }).add("find",function(filter, params) {
      if (params === undefined) params = gs.map();
      return gs.mc(LocalDB.instance,"find",[gs.mc(filter,'leftShift', gs.list([staticFilter])), params]);
     }).add("findAll",function(params) {
      if (params === undefined) params = gs.map();
      return gs.mc(LocalDB.instance,"find",[staticFilter, params]);
     }).add("new",function(initParams) {
      if (initParams === undefined) initParams = gs.map();
      var item = gs.mc(initParams,'leftShift', gs.list([staticFilter]));
      gs.sp(item,"_id",gs.execStatic(Utils,'uuid', this,[]));
      return gs.mc(gSobject,"decorate",[item]);
     });
   }
  gSobject['findOrCreate'] = function(filter, mapToSave, callback) {
    if (mapToSave === undefined) mapToSave = gs.map();
    if (callback === undefined) callback = null;
    var item = gs.mc(gSobject,"findOne",[filter]);
    if (gs.bool(item)) {
      if (gs.bool(callback)) {
        return gs.execCall(callback, this, [item]);
       };
      return item;
     };
    mapToSave = (gs.mc(gs.mc(mapToSave,"clone",[]),'leftShift', gs.list([filter])));
    gs.sp(mapToSave,"_id",gs.execStatic(Utils,'uuid', this,[]));
    if (gs.bool(callback)) {
      return gs.mc(LocalDB.instance,"save",[mapToSave, function(savedItem) {
        return gs.mc(gSobject,"getOne",[gs.gp(savedItem,"_id"), callback]);
       }]);
     };
    item = gs.mc(LocalDB.instance,"save",[mapToSave]);
    return gs.mc(gSobject,"getOne",[gs.gp(item,"_id")]);
   }
  gSobject['getOne'] = function(id, expandableFields, level) {
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    return gs.mc(gSobject,"getOne",[id, null, expandableFields, level]);
   }
  gSobject['getOne'] = function(id, callback, expandableFields, level) {
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    if (gs.bool(expandableFields)) {
      return gs.mc(gSobject,"findOne",[gs.map().add("_id",id), callback, expandableFields, level]);
     } else {
      return gs.mc(gSobject,"findOne",[gs.map().add("_id",id), callback]);
     };
   }
  gSobject['findOne'] = function(filter, callback, expandableFields, level) {
    if (callback === undefined) callback = null;
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    return gs.mc(gSobject,"findOne",[filter, null, expandableFields, level]);
   }
  gSobject['findOne'] = function(filter, callback, expandableFields, level) {
    if (callback === undefined) callback = null;
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    var item = null;
    if (gs.bool(expandableFields)) {
      item = gs.mc(gSobject,"find",[filter, gs.map().add("limit",1), expandableFields, level]);
     } else {
      item = gs.mc(gSobject,"find",[filter, gs.map().add("limit",1)]);
     };
    if (!gs.bool(item)) {
      if (gs.bool(callback)) {
        gs.execCall(callback, this, [gs.map()]);
       };
      return gs.map();
     };
    item = (item[0]);
    gs.mc(gSobject,"decorate",[item]);
    if (gs.bool(callback)) {
      gs.execCall(callback, this, [item]);
     };
    return item;
   }
  gSobject['delete'] = function(id, callback) {
    if (callback === undefined) callback = function(it) {
     };
    gs.mc(LocalDB.db,"remove",[gs.map().add("_id",id)]);
    return gs.mc(LocalDB.db,"save",[callback]);
   }
  gSobject['find'] = function(filter, params, expandableFields, level) {
    if (params === undefined) params = gs.map();
    if (expandableFields === undefined) expandableFields = null;
    if (level === undefined) level = 1;
    var dbList = gs.mc(LocalDB.db,"find",[gs.toJavascript(filter), gs.toJavascript(gs.mc((gs.mc(gs.mc(gSobject,"getLimit",[params]),'leftShift', gs.list([gs.mc(gSobject,"getSkip",[params])]))),'leftShift', gs.list([gs.mc(gSobject,"getSort",[params])])))]);
    var objectList = gs.list([]);
    gs.mc(dbList,"each",[function(dbItem) {
      var item = gs.mc(gs.map(),'leftShift', gs.list([dbItem]));
      gs.mc(gSobject,"fixDatesFromDb",[item]);
      gs.mc(gSobject,"decorate",[item]);
      if (gs.bool(expandableFields)) {
        item = gs.mc(gSobject,"expandItem",[item, expandableFields, level]);
       };
      return gs.mc(objectList,"add",[item]);
     }]);
    return objectList;
   }
  gSobject['remove'] = function(filter, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(LocalDB.db,"remove",[gs.toJavascript(filter)]);
   }
  gSobject['count'] = function(filter) {
    return gs.mc(LocalDB.db,"count",[gs.toJavascript(filter)]);
   }
  gSobject['expandItem'] = function(item, expandableFields, level) {
    if (level === undefined) level = 1;
    var fields = gs.mc(expandableFields,"collect",[function(it) {
      return gs.gp(it,"field");
     }]);
    gs.mc(item,"each",[function(k, v) {
      if (gs.mc(fields,"contains",[k])) {
        if (((gs.equals(v, null)) || (gs.equals(v, gs.fs('undefined', this, gSobject)))) || (gs.equals(v, ""))) {
          return null;
         };
        var currentField = gs.mc(expandableFields,"find",[function(it) {
          return gs.equals(gs.gp(it,"field"), k);
         }]);
        if (gs.instanceOf(v, "List")) {
          var expandResult = gs.mc(LocalDB.db,"find",[gs.toJavascript(gs.map().add("_id",gs.map().add("$in",v)).add("_path",gs.gp(currentField,"_path")))]);
          var expandResultObjects = gs.list([]);
          gs.mc(expandResult,"each",[function(expandResultItem) {
            var expandedItem = gs.mc(gs.map(),'leftShift', gs.list([expandResultItem]));
            gs.mc(gSobject,"fixDatesFromDb",[expandedItem]);
            if (level > 1) {
              expandedItem = gs.mc(gSobject,"expandItem",[expandedItem, expandableFields, gs.minus(level, 1)]);
             };
            return gs.mc(expandResultObjects,"add",[expandedItem]);
           }]);
          return (item[k]) = gs.elvis(gs.bool(expandResultObjects) , expandResultObjects , gs.list([]));
         } else {
          var expandResult = gs.mc(LocalDB.db,"find",[gs.toJavascript(gs.map().add("_id",v).add("_path",gs.gp(currentField,"_path"))), gs.toJavascript(gs.mc(gSobject,"getLimit",[gs.map().add("limit",1)]))])[0];
          var expandedItem = gs.mc(gs.map(),'leftShift', gs.list([expandResult]));
          gs.mc(gSobject,"fixDatesFromDb",[expandedItem]);
          if (level > 1) {
            expandedItem = gs.mc(gSobject,"expandItem",[expandedItem, expandableFields, gs.minus(level, 1)]);
           };
          return (item[k]) = gs.elvis(gs.bool(expandedItem) , expandedItem , null);
         };
       };
     }]);
    return item;
   }
  gSobject['getLimit'] = function(params) {
    return gs.map().add("$limit",gs.elvis(gs.bool(params["limit"]) , params["limit"] , gs.elvis(gs.bool(gs.gp(params,"max")) , gs.gp(params,"max") , LocalDB.MAX_ROWS_PER_BATCH)));
   }
  gSobject['getSkip'] = function(params) {
    return gs.map().add("$skip",gs.elvis(gs.bool(gs.gp(params,"offset")) , gs.gp(params,"offset") , gs.elvis(gs.bool(params["skip"]) , params["skip"] , 0)));
   }
  gSobject['getSort'] = function(params) {
    var order = 1;
    if (gs.equals(gs.gp(params,"order"), "desc")) {
      order = -1;
     };
    if (gs.bool(params["sort"])) {
      return gs.map().add("$orderBy",gs.map().add(params["sort"],order));
     };
    return gs.map();
   }
  gSobject['fixDatesToDb'] = function(object) {
    gs.mc(object,"each",[function(key, value) {
      if ((gs.bool(value)) && (gs.instanceOf(value, "HashMap"))) {
        gs.mc(gSobject,"fixDatesToDb",[value]);
       };
      if (gs.execStatic(Utils,'isDate', this,[value])) {
        return (object[key]) = gs.mc(LocalDB.db,"make",[value]);
       };
     }]);
    return object;
   }
  gSobject['fixDatesFromDb'] = function(object) {
    gs.mc(object,"each",[function(key, value) {
      if ((gs.bool(value)) && (gs.instanceOf(value, "HashMap"))) {
        gs.mc(gSobject,"fixDatesFromDb",[value]);
       };
      if (gs.execStatic(Utils,'isDate', this,[value])) {
        return (object[key]) = gs.date(value);
       };
     }]);
    return object;
   }
  gSobject['decorate'] = function(item) {
    gs.sp(item,"merge",function(map) {
      gs.mc(item,"putAll",[map]);
      return item;
     });
    gs.sp(item,"save",function(callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"save",[item, callback]);
     });
    gs.sp(item,"delete",function(callback) {
      if (callback === undefined) callback = null;
      return gs.mc(LocalDB.instance,"delete",[gs.gp(item,"_id"), callback]);
     });
    return item;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
LocalDB.getInstance = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  if (!gs.bool(LocalDB.instance)) {
    LocalDB.instance = LocalDB();
    if (!gs.bool(LocalDB.db)) {
      LocalDB.initDb(LocalDB.DB_NAME, function(it) {
        return gs.mc(LocalDB,"checkVersion",[function(it) {
          return gs.mc(LocalDB,"cleanupStaleData",[function(it) {
            LocalDB.startupCompleted = true;
            gs.execCall(callback, this, [LocalDB.instance]);
            gs.mc(LocalDB.callbacks,"each",[function(it) {
              return gs.execCall(it, this, [LocalDB.instance]);
             }]);
            return LocalDB.callbacks = gs.list([]);
           }]);
         }]);
       });
     };
   } else {
    if (!gs.bool(LocalDB.startupCompleted)) {
      gs.mc(LocalDB.callbacks,"add",[callback]);
      return LocalDB.instance;
     };
    gs.execCall(callback, this, [LocalDB.instance]);
   };
  return LocalDB.instance;
 }
LocalDB.initDb = function(dbName, callback) {
  var fdb = new ForerunnerDB();
        var forerunnerdb = fdb.db(dbName);
        
        // if (LocalDB.DB_COMPRESS) forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCompress());
        // if (LocalDB.DB_ENCRYPT) forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCrypto({
        //       pass: "dbStoreCode"
        // }));


        forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCompress());
        forerunnerdb.persist.addStep(new forerunnerdb.shared.plugins.FdbCrypto({
              pass: "dbStoreCode"
        }));
        
        var collection = forerunnerdb.collection("appCollection")
        // collection.deferredCalls(LocalDB.ASYNC_DB)
        collection.deferredCalls(false)
        collection.load(function (err, tableStats, metaStats) {
        	if (err) {
        		console.error('forerunnerdb error')
        	}else{
        	    console.log('forerunnerdb started')
        	}
        	
        	LocalDB.jsDbInstance = forerunnerdb
        	LocalDB.db = collection
        	
        	callback()
        });
 }
LocalDB.dropDatabase = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  return gs.mc(LocalDB.jsDbInstance,"drop",[true, function(it) {
    return gs.mc(LocalDB,"initDb",[LocalDB.DB_NAME, function(it) {
      return gs.mc(LocalDB.db,"upsert",[gs.map().add("_id","dbVersionNumber").add("version",LocalDB.DB_VERSION_NO), callback]);
     }]);
   }]);
 }
LocalDB.DB_VERSION_NO = "1.2";
LocalDB.DB_NAME = "1";
LocalDB.MAX_ROWS_PER_BATCH = 1000;
LocalDB.ASYNC_DB = false;
LocalDB.DB_COMPRESS = true;
LocalDB.DB_ENCRYPT = true;
LocalDB.startupCompleted = false;
LocalDB.instance = null;
LocalDB.jsDbInstance = null;
LocalDB.db = null;
LocalDB.objectMaps = gs.map();
LocalDB.callbacks = gs.list([]);
LocalDB.checkVersion = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  gs.println("LocalDB.checkVersion");
  var version = gs.mc(LocalDB.db,"find",[gs.map().add("_id","dbVersionNumber")]);
  if ((gs.equals(gs.gp(version,"length"), 0)) || (gs.gp(version[0],"version") != LocalDB.DB_VERSION_NO)) {
    gs.println("FOUND OLD DB:DROP DB");
    gs.mc(LocalDB,"dropDatabase",[callback]);
    return null;
   };
  return gs.execCall(callback, this, []);
 };
LocalDB.cleanupStaleData = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  gs.println("LocalDB.cleanupStaleData");
  var nowMs = gs.gp(gs.date(),"time");
  return gs.execCall(callback, this, []);
 };

function LocalDB$LocalO() {
  var gSobject = gs.init('LocalDB$LocalO');
  gSobject.clazz = { name: 'LocalDB$LocalO', simpleName: 'LocalDB$LocalO'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.this$0 = null;
  gSobject['propertyMissing'] = function(objectName) {
    return gs.mc(gs.gp(LocalDB,"instance"),"objectCallWrapper",[objectName]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CacheCallTracker() {
  var gSobject = gs.init('CacheCallTracker');
  gSobject.clazz = { name: 'CacheCallTracker', simpleName: 'CacheCallTracker'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'remoteOnceMap', { get: function() { return CacheCallTracker.remoteOnceMap; }, set: function(gSval) { CacheCallTracker.remoteOnceMap = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'resultCache', { get: function() { return CacheCallTracker.resultCache; }, set: function(gSval) { CacheCallTracker.resultCache = gSval; }, enumerable: true });
  gSobject.ttl = 0;
  gSobject.remoteOnce = false;
  gSobject['callAndCache'] = function(argList, successClosure, fail) {
    if (successClosure === undefined) successClosure = function(it) {
     };
    if (fail === undefined) fail = null;
    var argListString = gs.mc(argList,"toString",[]);
    if (!gs.bool(gSobject.ttl)) {
      return gs.execStatic(Socket,'callChain', this,[argList, function(result) {
        return gs.execCall(successClosure, this, [result]);
       }, fail]);
     };
    var objects = CacheCallTracker.resultCache[argListString];
    return gs.execStatic(LocalDB,'getInstance', this,[function(localDB) {
      if (!gs.bool(objects)) {
        objects = gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"readCache",[argListString]);
       };
      if (gs.bool(objects)) {
        gs.execStatic(ObjectRegistry,'register', this,[objects]);
        gs.execCall(successClosure, this, [objects]);
       };
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        if (gs.bool(objects)) {
          (CacheCallTracker.remoteOnceMap[argListString]) = (CacheCallTracker.remoteOnceMap[argListString] ? gs.plus((CacheCallTracker.remoteOnceMap[argListString]), 1) : 1);
          if ((gs.bool(gSobject.remoteOnce)) && ((CacheCallTracker.remoteOnceMap[argListString]) > 1)) {
            return null;
           };
         };
        return gs.execStatic(Socket,'callChain', this,[argList, function(result) {
          (CacheCallTracker.resultCache[argListString]) = result;
          gs.execCall(successClosure, this, [result]);
          return gs.execStatic(Utils,'setTimeout', this,[function(it) {
            return gs.mc(gSobject,"syncCache",[argListString, result, function(it) {
              return gs.println("syncCache:done");
             }]);
           }, 0]);
         }, fail]);
       }, 0]);
     }]);
   }
  gSobject['syncCache'] = function(argListString, objects, callback) {
    if (gs.bool(gSobject.ttl)) {
      return gs.execStatic(LocalDB,'getInstance', this,[function(it) {
        return gs.mc(gs.execStatic(LocalDB,'getInstance', this,[]),"cacheObjects",[argListString, objects, gSobject.ttl, callback]);
       }]);
     };
   }
  gSobject['CacheCallTracker2'] = function(ttl, remoteOnce) {
    gs.sp(this,"ttl",ttl);
    gs.sp(this,"remoteOnce",remoteOnce);
    return this;
  }
  if (arguments.length==2) {gSobject.CacheCallTracker2(arguments[0], arguments[1]); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CacheCallTracker.remoteOnceMap = gs.map();
CacheCallTracker.resultCache = gs.map();

function GpsLocationTracker() {
  var gSobject = gs.init('GpsLocationTracker');
  gSobject.clazz = { name: 'GpsLocationTracker', simpleName: 'GpsLocationTracker'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'HIGH_ACCURACY', { get: function() { return GpsLocationTracker.HIGH_ACCURACY; }, set: function(gSval) { GpsLocationTracker.HIGH_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MEDIUM_ACCURACY', { get: function() { return GpsLocationTracker.MEDIUM_ACCURACY; }, set: function(gSval) { GpsLocationTracker.MEDIUM_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'LOW_ACCURACY', { get: function() { return GpsLocationTracker.LOW_ACCURACY; }, set: function(gSval) { GpsLocationTracker.LOW_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'PASSIVE_ACCURACY', { get: function() { return GpsLocationTracker.PASSIVE_ACCURACY; }, set: function(gSval) { GpsLocationTracker.PASSIVE_ACCURACY = gSval; }, enumerable: true });
  gSobject.gpsService = null;
  gSobject.lastLocation = null;
  Object.defineProperty(gSobject, 'singletonInstance', { get: function() { return GpsLocationTracker.singletonInstance; }, set: function(gSval) { GpsLocationTracker.singletonInstance = gSval; }, enumerable: true });
  gSobject.desiredAccuracy = GpsLocationTracker.HIGH_ACCURACY;
  gSobject.instance = function() { return GpsLocationTracker.instance(); }
  gSobject['config'] = function(config) {
    gs.mc(gSobject.gpsService,"setConfig",[config]);
    return this;
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    if (config === undefined) config = gs.map();
    var callbackWrapper = function(location) {
      gSobject.lastLocation = location;
      gs.execCall(successCallback, this, [location]);
      return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userLocation",[location]),"do",[]);
     };
    gs.mc(gSobject.gpsService,"getCurrentLocation",[callbackWrapper, failedCallback]);
    return this;
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    var callbackWrapper = function(location) {
      gSobject.lastLocation = location;
      gs.execCall(successCallback, this, [location]);
      return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userLocation",[location]),"do",[]);
     };
    gs.mc(gSobject.gpsService,"onLocation",[callbackWrapper, failedCallback]);
    return this;
   }
  gSobject['onStationary'] = function(stationaryCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    gs.mc(gSobject.gpsService,"onStationary",[stationaryCallback, failedCallback]);
    return this;
   }
  gSobject['start'] = function(it) {
    gs.mc(gSobject.gpsService,"start",[]);
    return this;
   }
  gSobject['stop'] = function(it) {
    gs.mc(gSobject.gpsService,"stop",[]);
    return this;
   }
  gSobject['sync'] = function(it) {
    gs.mc(gSobject.gpsService,"sync",[]);
    return this;
   }
  gSobject['getName'] = function(it) {
    gs.mc(gSobject.gpsService,"getName",[]);
    return this;
   }
  gSobject.backgroundGeoLocationDefined = function() {
    return typeof BackgroundGeolocation !== 'undefined';
   }
  gSobject['GpsLocationTracker0'] = function(it) {
    if (gs.mc(gSobject,"backgroundGeoLocationDefined",[])) {
      gSobject.gpsService = GpsLocationTracker$CordovaBackgroundGeolocation(this);
     } else {
      if (gs.bool(gs.gp(navigator,"geolocation"))) {
        gSobject.gpsService = GpsLocationTracker$Html5Gps(this);
       } else {
        throw {message: "GPS not supported"};
       };
     };
    return this;
  }
  if (arguments.length==0) {gSobject.GpsLocationTracker0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
GpsLocationTracker.instance = function(it) {
  if (!gs.bool(GpsLocationTracker.singletonInstance)) {
    GpsLocationTracker.singletonInstance = GpsLocationTracker();
   };
  return GpsLocationTracker.singletonInstance;
 }
GpsLocationTracker.HIGH_ACCURACY = 0;
GpsLocationTracker.MEDIUM_ACCURACY = 10;
GpsLocationTracker.LOW_ACCURACY = 1000;
GpsLocationTracker.PASSIVE_ACCURACY = 10000;
GpsLocationTracker.singletonInstance = null;

function GpsLocationTracker$Html5Gps() {
  var gSobject = gs.init('GpsLocationTracker$Html5Gps');
  gSobject.clazz = { name: 'GpsLocationTracker$Html5Gps', simpleName: 'GpsLocationTracker$Html5Gps'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.watchPositionId = null;
  gSobject.onLocationSuccessCallback = function(it) {
   };
  gSobject.onLocationFailedCallback = function(it) {
   };
  gSobject.config = gs.map().add("desiredAccuracy",gs.gp(GpsLocationTracker,"HIGH_ACCURACY")).add("backgroundDesiredAccuracy",gs.gp(GpsLocationTracker,"LOW_ACCURACY")).add("enableHighAccuracy",true).add("maximumAge",30000).add("timeout",30000);
  gSobject.this$0 = null;
  gSobject['getName'] = function(it) {
    return "Html5Gps";
   }
  gSobject['setConfig'] = function(config) {
    return gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"config"),'leftShift', gs.list([config]));
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"getCurrentPosition",[function(location) {
      return gs.execCall(successCallback, this, [gs.gp(location,"coords")]);
     }, failedCallback, gs.map().add("enableHighAccuracy",gs.gp(config,"desiredAccuracy") <= gs.gp(GpsLocationTracker,"MEDIUM_ACCURACY")).add("maximumAge",gs.gp(config,"maximumAge")).add("timeout",gs.gp(config,"timeout"))]);
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    gSobject.onLocationSuccessCallback = successCallback;
    return gSobject.onLocationFailedCallback = failedCallback;
   }
  gSobject['setDesiredAccuracy'] = function(desiredAccuracy) {
    return gs.sp(gSobject.config,"desiredAccuracy",desiredAccuracy);
   }
  gSobject['onStationary'] = function(stationaryCallback) {
   }
  gSobject['sync'] = function(it) {
   }
  gSobject['start'] = function(it) {
    return gSobject.watchPositionId = gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"watchPosition",[function(location) {
      var gpsMap = gs.mc(gs.map().add("fixId",gs.execStatic(Utils,'uuid', this,[])).add("provider",gs.mc(gSobject,"getName",[])).add("unixTimeMs",gs.gp(location,"timestamp")).add("accuracy",null).add("speed",null).add("altitude",null).add("latitude",null).add("longitude",null).add("bearing",gs.gp(gs.gp(location,"coords"),"heading")).add("service","Html5Gps").add("user",gs.gp(gs.fs('session', this, gSobject),"userId")).add("uuid",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid")),'leftShift', gs.list([gs.gp(location,"coords")]));
      return gs.mc(gSobject,"onLocationSuccessCallback",[gs.mc(gs.fs('gs', this, gSobject),"toJavascript",[gpsMap])]);
     }, gSobject.onLocationFailedCallback, gs.map().add("enableHighAccuracy",gs.gp(gSobject.config,"backgroundDesiredAccuracy") <= gs.gp(GpsLocationTracker,"MEDIUM_ACCURACY")).add("maximumAge",gs.gp(gSobject.config,"maximumAge")).add("timeout",gs.gp(gSobject.config,"timeout"))]);
   }
  gSobject['stop'] = function(it) {
    if (gs.bool(gSobject.watchPositionId)) {
      return gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"clearWatch",[gSobject.watchPositionId]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function GpsLocationTracker$CordovaBackgroundGeolocation() {
  var gSobject = gs.init('GpsLocationTracker$CordovaBackgroundGeolocation');
  gSobject.clazz = { name: 'GpsLocationTracker$CordovaBackgroundGeolocation', simpleName: 'GpsLocationTracker$CordovaBackgroundGeolocation'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.config = gs.map().add("debug",false).add("locationProvider",gs.gp(BackgroundGeolocation,"DISTANCE_FILTER_PROVIDER")).add("backgroundLocationProvider",gs.gp(BackgroundGeolocation,"DISTANCE_FILTER_PROVIDER")).add("desiredAccuracy",gs.gp(GpsLocationTracker,"HIGH_ACCURACY")).add("backgroundDesiredAccuracy",gs.gp(GpsLocationTracker,"HIGH_ACCURACY")).add("activityType","OtherNavigation").add("stationaryRadius",10).add("distanceFilter",10).add("notificationTitle","GPS tracking").add("notificationText","enabled").add("enableHighAccuracy",true).add("startForeground",true).add("stopOnTerminate",false).add("interval",5000).add("fastestInterval",5000).add("activitiesInterval",5000).add("autoSync",true).add("syncThreshold",100).add("maxLocations",gs.multiply(10, 1000)).add("url","" + (gs.gp(session,"incomingUrl")) + "/cordovaWrapper/gps").add("syncUrl","" + (gs.gp(session,"incomingUrl")) + "/cordovaWrapper/gps").add("httpHeaders",gs.map()).add("postTemplate",gs.map().add("fixId","@id").add("provider","@provider").add("unixTimeMs","@time").add("accuracy","@accuracy").add("speed","@speed").add("altitude","@altitude").add("latitude","@latitude").add("longitude","@longitude").add("bearing","@bearing").add("service","BackgroundGeolocation").add("user",gs.gp(session,"userId")).add("uuid",gs.gp(gs.gp(cordovaDevice,"device"),"uuid")));
  gSobject.this$0 = null;
  gSobject['getName'] = function(it) {
    return "CordovaBackgroundGeolocation";
   }
  gSobject['setConfig'] = function(config) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("BackgroundGeolocation:setConfig:", config)]);
    gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"config"),'leftShift', gs.list([config]));
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[gs.gp(gs.thisOrObject(this,gSobject),"config")]);
    return this;
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getCurrentLocation",[successCallback, failedCallback, gs.mc(gs.map().add("enableHighAccuracy",true).add("maximumAge",gs.multiply((gs.multiply(4, 60)), 1000)).add("timeout",gs.multiply(60, 1000)),'leftShift', gs.list([config]))]);
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["location", function(location) {
      return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"startTask",[function(taskKey) {
        gs.execCall(successCallback, this, [location]);
        return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"endTask",[taskKey]);
       }]);
     }]);
   }
  gSobject['onStationary'] = function(stationaryCallback) {
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["stationary", stationaryCallback]);
   }
  gSobject['sync'] = function(it) {
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"forceSync",[]);
   }
  gSobject['start'] = function(it) {
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"start",[]);
    gs.mc(gSobject,"sync",[]);
    return this;
   }
  gSobject['stop'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("BackgroundGeolocation:stop:", gs.gp(gs.fs('session', this, gSobject),"userId"))]);
   }
  gSobject['GpsLocationTracker$CordovaBackgroundGeolocation0'] = function(it) {
    gs.mc(BackgroundGeolocation,"on",["background", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["BackgroundGeolocation:background"]);
      appStatus = "background";
      return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[function(it) {
        return gs.gp(gSobject.config,"backgroundDesiredAccuracy");
       }]);
     }]);
    gs.mc(BackgroundGeolocation,"on",["foreground", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["BackgroundGeolocation:foreground"]);
      appStatus = "foreground";
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[function(it) {
        return gs.gp(gSobject.config,"desiredAccuracy");
       }]);
      return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"forceSync",[]);
     }]);
    gs.mc(BackgroundGeolocation,"on",["authorization", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("BackgroundGeolocation:authorization:status: ", status)]);
      if (status !== gs.gp(gs.fs('BackgroundGeolocation', this, gSobject),"AUTHORIZED")) {
        return gs.execStatic(Utils,'setTimeout', this,[function(it) {
          var showSettings = gs.mc(this,"confirm",["App requires location tracking permission. Would you like to open app settings?"], gSobject);
          if (gs.bool(showSettings)) {
            return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"showAppSettings",[]);
           };
         }, 500]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.GpsLocationTracker$CordovaBackgroundGeolocation0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaAppleSignIn() {
  var gSobject = gs.init('CordovaAppleSignIn');
  gSobject.clazz = { name: 'CordovaAppleSignIn', simpleName: 'CordovaAppleSignIn'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.AppleSignIn = function(onSuccess, onError) {
    window.cordova.plugins.SignInWithApple.signin({ 
                requestedScopes: [FullName, Email] },
                function(succ){
                    console.log(succ)
                    alert(JSON.stringify(succ))
                },  
                function(err){
                    console.error(err)  
                    console.log(JSON.stringify(err))
                    onError(err)
                }
            )
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function QRScanner() {
  var gSobject = gs.init('QRScanner');
  gSobject.clazz = { name: 'QRScanner', simpleName: 'QRScanner'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['scan'] = function(success, failure) {
    var options = gs.map().add("preferFrontCamera",false).add("showFlipCameraButton",true).add("prompt","Place a barcode inside the scan area");
    return gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"barcodeScanner"),"scan",[success, failure, options]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaCamera() {
  var gSobject = gs.init('CordovaCamera');
  gSobject.clazz = { name: 'CordovaCamera', simpleName: 'CordovaCamera'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['takePhotoAndUpload'] = function(objectName, property, objectId, onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["takePhotoAndUpload"]);
    var success = function(tempImageUrl) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["takePhotoAndUpload:success1"]);
      gs.println(tempImageUrl);
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[tempImageUrl, objectName, property, objectId, onSuccess, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['takePhotoBlob'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    var success = function(imageUri) {
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[imageUri, function(blob) {
        gs.execCall(onSuccess, this, [blob]);
        return gs.mc(gSobject,"clearCache",[]);
       }, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['takePhoto'] = function(onSuccess, onFail, config) {
    if (config === undefined) config = gs.map();
    CordovaCamera.hasCameraPermission("android.permission.CAMERA", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.CAMERA:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.ACTION_CREATE_DOCUMENT", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.ACTION_CREATE_DOCUMENT:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.ACTION_OPEN_DOCUMENT", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.ACTION_OPEN_DOCUMENT:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.READ_EXTERNAL_STORAGE", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.READ_EXTERNAL_STORAGE:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.READ_MEDIA_IMAGES", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.READ_MEDIA_IMAGES:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    CordovaCamera.hasCameraPermission("android.permission.READ_MEDIA_VIDEO", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("android.permission.READ_MEDIA_IMAGES:", gs.gp(status,"hasPermission"))]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[status]);
     });
    gs.mc(gs.fs('camera', this, gSobject),"getPicture",[onSuccess, onFail, gs.mc(gs.map().add("destinationType",gs.gp(gs.gp(gs.fs('camera', this, gSobject),"DestinationType"),"FILE_URI")).add("sourceType",gs.gp(gs.gp(gs.fs('camera', this, gSobject),"PictureSourceType"),"CAMERA")).add("encodingType",gs.gp(gs.gp(gs.fs('cameraConst', this, gSobject),"EncodingType"),"JPEG")).add("correctOrientation",true).add("saveToPhotoAlbum",false).add("targetHeight",1024).add("targetWidth",1024),'leftShift', gs.list([config]))]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["takePhoto2"]);
   }
  gSobject.hasCameraPermission = function(x0,x1) { return CordovaCamera.hasCameraPermission(x0,x1); }
  gSobject.verifyCameraPlugin = function() { return CordovaCamera.verifyCameraPlugin(); }
  gSobject['clearCache'] = function(it) {
    return gs.mc(gs.fs('camera', this, gSobject),"cleanup",[]);
   }
  gSobject.getCamera = function() { return CordovaCamera.getCamera(); }
  gSobject.getCameraConst = function() { return CordovaCamera.getCameraConst(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaCamera.hasCameraPermission = function(permission, callback) {
  if (!Utils.isCordova()) return false;
        var permissions = cordova.plugins.permissions;
        if (!permissions) return false
        
        console.log('permission', permission)
        
        permissions.checkPermission(permission, function( status ){
            if ( status.hasPermission ) {
                return callback(status);
            } else {
                permissions.requestPermission(permissions.CAMERA, function( result ){
                    return callback(result)
                });
            }
        });
 }
CordovaCamera.verifyCameraPlugin = function() {
  return ( typeof navigator !== 'undefined' && typeof navigator.camera !== 'undefined' )
 }
CordovaCamera.getCamera = function() {
  return navigator.camera
 }
CordovaCamera.getCameraConst = function() {
  return Camera
 }

function VueApp() {
  var gSobject = gs.init('VueApp');
  gSobject.clazz = { name: 'VueApp', simpleName: 'VueApp'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.componentList = gs.list([]);
  gSobject.authComponentPath = null;
  gSobject.vue = null;
  gSobject.router = null;
  gSobject.scope = gs.map().add("topHeading","").add("backStack",gs.list([]));
  gSobject.data = function(it) {
    return gSobject.scope = gs.mc(gs.fs('Vue', this, gSobject),"reactive",[gSobject.scope]);
   };
  gSobject.methods = gs.map();
  gSobject.watch = gs.map();
  gSobject.compute = gs.map();
  gSobject.events = gs.map();
  gSobject.filters = gs.map();
  gSobject.mixins = gs.list([]);
  gSobject.toggleDarkMode = function(it) {
    gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"toggle",[]);
    return gs.sp(gs.fs('session', this, gSobject),"darkMode",gs.gp(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"isActive"));
   };
  gSobject.initialised = false;
  gSobject['init'] = function(mountElement) {
    if (mountElement === undefined) mountElement = "#vue-app";
    gs.println("VueApp.init");
    if (gs.bool(gSobject.initialised)) {
      return null;
     };
    gSobject.initialised = true;
    gs.mc(gSobject.componentList,"each",[function(component) {
      return gs.mc(gSobject,"registerVueComponent",[gs.gp(component,"vueComponentName"), component]);
     }]);
    var routes = gs.list([]);
    var childComponents = gs.set();
    gs.mc(gSobject.componentList,"each",[function(component) {
      return gs.mc(gs.gp(component,"children"),"each",[function(child) {
        return gs.mc(childComponents,"add",[gs.gp(child,"vueComponentName")]);
       }], null, true);
     }]);
    var buildRoute = null;
    buildRoute = function(component) {
      var route = gs.map().add("path",gs.gp(component,"path")).add("component",gs.mc(gSobject.componentList,"find",[function(it) {
        return gs.equals(gs.gp(it,"vueComponentName"), gs.gp(component,"vueComponentName"));
       }]));
      if (gs.bool(gs.gp(component,"children"))) {
        gs.sp(route,"children",gs.mc(gs.gp(component,"children"),"collect",[function(child) {
          return gs.execCall(buildRoute, this, [child]);
         }]));
       };
      return route;
     };
    gs.mc(gSobject.componentList,"each",[function(component) {
      if (!gs.bool(gs.mc(childComponents,"contains",[gs.gp(component,"vueComponentName")]))) {
        if (gs.instanceOf(gs.gp(component,"path"), "ArrayList")) {
          return gs.mc(gs.gp(component,"path"),"each",[function(it) {
            if (gs.bool(it)) {
              var cloned = gs.execStatic(Utils,'deepCopyMap', this,[component]);
              gs.sp(cloned,"path",it);
              return gs.mc(routes,"add",[gs.execCall(buildRoute, this, [cloned])]);
             };
           }]);
         } else {
          if (gs.bool(gs.gp(component,"path"))) {
            return gs.mc(routes,"add",[gs.execCall(buildRoute, this, [component])]);
           };
         };
       };
     }]);
    gs.println("routes");
    gs.println(routes);
    gs.mc(gSobject.filters,"each",[function(key, filterFunction) {
      return gs.mc(gSobject,"addVueFilter",[key, filterFunction]);
     }]);
    gSobject.router = gs.mc(gSobject,"newVueRouter",[routes]);
    gs.mc(gSobject.vue,"use",[gs.fs('Quasar', this, gSobject)]);
    gs.mc(gSobject.vue,"use",[gSobject.router]);
    gs.mc(gSobject,"setQuasarTheme",[]);
    gs.mc(gSobject.vue,"mount",[mountElement]);
    return this;
   }
  gSobject['registerComponent'] = function(component) {
    return gs.mc(gSobject.componentList,"add",[component]);
   }
  gSobject['registerAuthComponent'] = function(component) {
    var path = gs.gp(component,"path");
    if (gs.instanceOf(gs.gp(component,"path"), "ArrayList")) {
      path = (path[0]);
     };
    return gSobject.authComponentPath = path;
   }
  gSobject['setQuasarTheme'] = function(it) {
    gs.sp(gs.fs('session', this, gSobject),"darkMode",gs.elvis(gs.bool(gs.gp(gs.fs('session', this, gSobject),"darkMode")) , gs.gp(gs.fs('session', this, gSobject),"darkMode") , gs.gp(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"isActive")));
    return gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Dark"),"set",[gs.gp(gs.fs('session', this, gSobject),"darkMode")]);
   }
  gSobject['registerVueComponent'] = function(name, component) {
    return gs.mc(gSobject,"registerVueComponentNative",[gSobject.vue, name, component]);
   }
  gSobject.addVueFilter = function(name, filter) {
    Vue.filter(name, filter)
   }
  gSobject.registerVueComponentNative = function(vue, name, component) {
    return vue.component(name, component)
   }
  gSobject.newVue = function(router, data, methods, watch, compute, events, mixins) {
    return Vue.createApp({
            router   : router, 
            data     : data,
            methods  : methods,
            watch    : watch,
            computed : compute,
            events   : events,
            mixins   : mixins
        });
   }
  gSobject.newVueRouter = function(routes) {
    return VueRouter.createRouter({routes:routes, history: VueRouter.createWebHashHistory()})
   }
  gSobject['VueApp0'] = function(it) {
    gSobject.vue = gs.mc(gSobject,"newVue",[gSobject.router, gs.toJsObj(gSobject.data), gs.toJsObj(gSobject.methods), gs.toJsObj(gSobject.watch), gs.toJsObj(gSobject.compute), gs.toJsObj(gSobject.events), gSobject.mixins]);
    return this;
  }
  if (arguments.length==0) {gSobject.VueApp0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueComponent() {
  var gSobject = gs.init('VueComponent');
  gSobject.clazz = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.vueComponentName = null;
  gSobject.path = "";
  gSobject.template = "";
  gSobject.props = gs.list([]);
  gSobject.vueMeta = gs.map();
  gSobject.route = null;
  gSobject.q = null;
  gSobject.refs = null;
  gSobject.options = gs.map();
  gSobject.emit = null;
  gSobject.scope = gs.map();
  gSobject.methods = null;
  gSobject.watch = null;
  gSobject.compute = null;
  gSobject.events = null;
  gSobject.roles = gs.list([]);
  gSobject.self = null;
  gSobject.beforeCreate = function(it) {
    gSobject.self = this;
    gSobject.route = gs.gp(gSobject.self,"$route");
    gSobject.q = gs.gp(gSobject.self,"$q");
    gSobject.options = gs.gp(gSobject.self,"$options");
    gSobject.nextTick = gs.gp(gSobject.self,"$nextTick");
    gSobject.emit = gs.gp(gSobject.self,"$emit");
    return gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"scrollTo",[0, 0]);
   };
  gSobject.nextTick = function(callback) {
    return gs.execCall(callback, this, []);
   };
  Object.defineProperty(gSobject, 'notifyParams', { get: function() { return VueComponent.notifyParams; }, set: function(gSval) { VueComponent.notifyParams = gSval; }, enumerable: true });
  gSobject.notify = function(message, type, map) {
    if (type === undefined) type = "positive";
    if (map === undefined) map = gs.map();
    gs.sp(map,"message",message);
    gs.sp(map,"type",type);
    return gs.mc(gSobject.q,"notify",[gs.mc(gs.mc(VueComponent.notifyParams,"clone",[]),'leftShift', gs.list([map]))]);
   };
  Object.defineProperty(gSobject, 'dialogParams', { get: function() { return VueComponent.dialogParams; }, set: function(gSval) { VueComponent.dialogParams = gSval; }, enumerable: true });
  gSobject.dialog = function(title, message, map) {
    if (map === undefined) map = gs.map();
    gs.sp(map,"title",title);
    gs.sp(map,"message",message);
    return gs.mc(gSobject.q,"dialog",[gs.mc(gs.mc(VueComponent.dialogParams,"clone",[]),'leftShift', gs.list([map]))]);
   };
  gSobject.data = function(it) {
    gSobject.scope = gs.map();
    return gSobject.scope = gs.mc(gs.fs('Vue', this, gSobject),"reactive",[gSobject.scope]);
   };
  gSobject.meta = function(it) {
    return gSobject.vueMeta;
   };
  Object.defineProperty(gSobject, 'METHOD_EXCLUDE_LIST', { get: function() { return VueComponent.METHOD_EXCLUDE_LIST; }, set: function(gSval) { VueComponent.METHOD_EXCLUDE_LIST = gSval; }, enumerable: true });
  gSobject['register'] = function(templateName, componentName) {
    if (templateName === undefined) templateName = "";
    if (componentName === undefined) componentName = "";
    gSobject.vueComponentName = gs.elvis(gs.bool(componentName) , componentName , gs.mc(gs.mc(this,"getClass",[], gSobject),"getSimpleName",[]));
    if (!gs.bool(gSobject.template)) {
      gSobject.template = (gs.bool(templateName) ? gs.plus("#", templateName) : gs.plus((gs.plus("#", gs.mc(gs.mc(this,"getClass",[], gSobject),"getSimpleName",[]))), "View"));
     };
    gs.println("VueComponent.register:" + (gSobject.vueComponentName) + ":" + (gSobject.template) + ":" + (gSobject.path) + "");
    var methodsMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      var name = gs.gp(method,"name");
      return (((!gs.bool(gs.mc(name,"startsWith",["set"]))) && (!gs.bool(gs.mc(name,"startsWith",["get"])))) && (!gs.bool(gs.mc(name,"contains",["$"])))) && (!gs.bool(gs.gSin(name, VueComponent.METHOD_EXCLUDE_LIST)));
     }]),"each",[function(it) {
      return (methodsMap[gs.gp(it,"name")]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(it,"name")) + "");
     }]);
    gSobject.methods = gs.toJsObj(methodsMap);
    var watchMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      return gs.mc(gs.gp(method,"name"),"startsWith",["watch"]);
     }]),"each",[function(method) {
      var watchVar = gs.mc(gs.gp(method,"name"),"substring",[5]);
      watchVar = (gs.plus(gs.mc(watchVar[0],"toLowerCase",[]), gs.mc(watchVar,"substring",[1])));
      return (watchMap[watchVar]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(method,"name")) + "");
     }]);
    gSobject.watch = gs.toJsObj(watchMap);
    var computeMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      return gs.mc(gs.gp(method,"name"),"startsWith",["computed"]);
     }]),"each",[function(it) {
      return (computeMap[gs.gp(it,"name")]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(it,"name")) + "");
     }]);
    gSobject.compute = gs.toJsObj(computeMap);
    var eventsMap = gs.map();
    gs.mc(gs.mc(gs.gp(this,"methods"),"findAll",[function(method) {
      return gs.mc(gs.gp(method,"name"),"startsWith",["event"]);
     }]),"each",[function(it) {
      return (eventsMap[gs.gp(it,"name")]) = gs.gp(gs.thisOrObject(this,gSobject),"" + (gs.gp(it,"name")) + "");
     }]);
    gSobject.events = gs.toJsObj(eventsMap);
    gs.mc(gs.fs('vue', this, gSobject),"registerComponent",[this]);
    return this;
   }
  gSobject['registerAsAuthComponent'] = function(it) {
    gs.mc(gs.fs('vue', this, gSobject),"registerAuthComponent",[this]);
    return this;
   }
  gSobject['getRefs'] = function(it) {
    gs.sp(this,"refs",gs.gp(gSobject.self,"$refs"));
    return gs.gp(gSobject.self,"$refs");
   }
  gSobject['beforeMount'] = function(it) {
    return gs.mc(gSobject,"enforceComponentRoles",[]);
   }
  gSobject['created'] = function(it) {
   }
  gSobject['mounted'] = function(it) {
    return gs.mc(gSobject,"nextTick",[function(it) {
      gs.mc(gSobject,"getRefs",[]);
      return gs.mc(gSobject,"afterMounted",[]);
     }]);
   }
  gSobject['afterMounted'] = function(it) {
   }
  gSobject['unmounted'] = function(it) {
    return gs.mc(gSobject,"destroyed",[]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"topHeading","");
   }
  gSobject['toggleDarkMode'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"scope"),"toggleDarkMode",[]);
   }
  gSobject['showLoading'] = function(text, spinnerColor) {
    if (text === undefined) text = "Loading...";
    if (spinnerColor === undefined) spinnerColor = "primary";
    return gs.mc(gs.gp(gSobject.q,"loading"),"show",[gs.map().add("group",text).add("message",text).add("delay",250).add("spinnerColor",spinnerColor).add("backgroundColor","transparent")]);
   }
  gSobject['hideLoading'] = function(text) {
    if (text === undefined) text = "";
    if (!gs.bool(text)) {
      return gs.mc(gs.gp(gSobject.q,"loading"),"hide",[]);
     };
    return gs.mc(gs.gp(gSobject.q,"loading"),"hide",[gs.map().add("group",text)]);
   }
  gSobject.moment = function(date) {
    return moment(date)
   }
  gSobject['placeholder'] = function(value, placeholder) {
    return gs.elvis(gs.bool(value) , value , placeholder);
   }
  gSobject['onPaste'] = function(evt, reference) {
    var text = "";
    var elem = (gs.mc(gSobject,"getRefs",[])[reference])[0];
    if (!gs.bool(elem)) {
      elem = (gs.mc(gSobject,"getRefs",[])[reference]);
     };
    if ((gs.bool(gs.gp(elem,"originalEvent"))) && (gs.bool(gs.gp(gs.gp(gs.gp(evt,"originalEvent"),"clipboardData"),"getData")))) {
      text = gs.mc(gs.gp(gs.gp(evt,"originalEvent"),"clipboardData"),"getData",["text/plain"]);
     };
    if ((gs.bool(gs.gp(evt,"clipboardData"))) && (gs.bool(gs.gp(gs.gp(evt,"clipboardData"),"getData")))) {
      text = gs.mc(gs.gp(evt,"clipboardData"),"getData",["text/plain"]);
     };
    return gs.mc(elem,"runCmd",["insertText", text]);
   }
  gSobject['filterOptions'] = function(val, update, options, filteredOptions, object, excludeSelected) {
    if (object === undefined) object = gs.map();
    if (excludeSelected === undefined) excludeSelected = false;
    return gs.execCall(update, this, [function(it) {
      return (gSobject.scope[filteredOptions]) = gs.mc(gs.mc(gSobject.scope[options],"findAll",[function(option) {
        if ((gs.bool(excludeSelected)) && (gs.equals(gs.gp(option,"_id"), gs.gp(object,"_id")))) {
          return false;
         };
        if (!gs.bool(val)) {
          return true;
         };
        return gs.mc(gs.mc(gs.gp(option,"name"),"toLowerCase",[], null, true),"contains",[gs.mc(val,"toLowerCase",[], null, true)], null, true);
       }]),"sort",[]);
     }]);
   }
  gSobject['enforceComponentRoles'] = function(it) {
    if (gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"embedded"))) {
      gs.println("enforceComponentRoles skipped for embedded mode");
      return true;
     };
    if ((!gs.bool(gSobject.roles)) || (gs.mc(gs.fs('session', this, gSobject),"hasRole",[gSobject.roles]))) {
      return true;
     };
    if (gs.bool(gs.gp(gs.fs('vue', this, gSobject),"authComponentPath"))) {
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.gp(gs.fs('vue', this, gSobject),"authComponentPath")]);
     };
    throw {message: "" + (gSobject.vueComponentName) + " roles required: " + (gSobject.roles) + ""};
   }
  gSobject['formatCurrency'] = function(value) {
    try {
      gs.mc(value,"split",["."]);
      gs.mc(this,"parseFloat",[value], gSobject);
     }
    catch (all) {
      value = "0.00";
     }
    ;
    if (!gs.bool(gs.mc(value,"contains",["."]))) {
      value = (gs.plus("0.0", value));
     };
    var newValue = null;
    var decPartSize = gs.mc(gs.mc(value,"split",["."])[1],"size",[]);
    if (decPartSize > 2) {
      newValue = gs.mc(gs.multiply(gs.mc(this,"parseFloat",[value], gSobject), 10),"toFixed",[2]);
     } else {
      if (gs.equals(decPartSize, 1)) {
        newValue = gs.mc(gs.div(gs.mc(this,"parseFloat",[value], gSobject), 10),"toFixed",[2]);
       } else {
        newValue = gs.mc(gs.mc(this,"parseFloat",[value], gSobject),"toFixed",[2]);
       };
     };
    return newValue;
   }
  gSobject['formatNumberInput'] = function(scopeName, size, decimals, parent) {
    if (size === undefined) size = 0;
    if (decimals === undefined) decimals = 0;
    if (parent === undefined) parent = gSobject.scope;
    var oldVal = gs.mc(gs.gp(parent,"" + (scopeName) + ""),"toString",[]);
    var newVal = "";
    if ((gs.equals((oldVal[0]), ".")) || (gs.equals((oldVal[0]), ","))) {
      newVal = "0";
     };
    var index = 0;
    var dotCount = 0;
    var afterDotCount = 0;
    gs.mc(oldVal,"each",[function(character) {
      index++;
      if (gs.equals(decimals, 0)) {
        if ((gs.mc(character,"isNumber",[])) && ((gs.equals(size, 0)) || (index <= size))) {
          newVal += character;
         };
        return null;
       };
      if (gs.equals(character, ",")) {
        character = ".";
       };
      if (gs.equals(character, ".")) {
        dotCount++;
       };
      if (dotCount > 1) {
        return null;
       };
      if (gs.equals(dotCount, 1)) {
        afterDotCount++;
        if (afterDotCount > (gs.plus(decimals, 1))) {
          return null;
         };
       };
      if (((gs.mc(character,"isNumber",[])) || (gs.equals(character, "."))) && ((gs.equals(size, 0)) || (index <= size))) {
        return newVal += character;
       };
     }]);
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(parent,"" + (scopeName) + "",newVal);
     }]);
   }
  gSobject['formatNumberInputOnBlur'] = function(scopeName, size, decimals, parent) {
    if (size === undefined) size = 0;
    if (decimals === undefined) decimals = 0;
    if (parent === undefined) parent = gSobject.scope;
    gs.mc(gSobject,"formatNumberInput",[scopeName, size, decimals, parent]);
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(parent,"" + (scopeName) + "",gs.mc(this,"Number",[gs.mc(gs.gp(parent,"" + (scopeName) + ""),"toString",[])], gSobject));
     }]);
   }
  gSobject['formatCurrencyInput'] = function(scopeName, parent) {
    if (parent === undefined) parent = gSobject.scope;
    return gs.mc(gSobject,"formatNumberInput",[scopeName, 15, 2, parent]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
VueComponent.notifyParams = gs.map().add("type","positive").add("position","bottom").add("avatar","").add("timeout",3000).add("actions",null).add("spinner",false).add("multiLine",false).add("progress",false);
VueComponent.dialogParams = gs.map().add("ok",gs.map().add("push",true).add("color","primary")).add("cancel",gs.map().add("push",true).add("color","negative")).add("persistent",true);
VueComponent.METHOD_EXCLUDE_LIST = gs.list(["equals" , "hashCode" , "notify" , "notifyAll" , "toString" , "wait" , "register" , "invokeMethod" , "data" , "beforeCreate" , "created" , "mounted" , "destroyed"]);

function LegionLoginComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'LegionLoginComponent', simpleName: 'LegionLoginComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/login";
  gSobject.appleAuth = gs.map();
  gSobject['created'] = function(it) {
    gs.println("LegionLoginComponent.created()");
    gs.sp(gSobject.scope,"showFooter",false);
    gs.sp(gSobject.scope,"showApple",gs.execStatic(Utils,'isIos', this,[]));
    gs.sp(gSobject.scope,"showAndroid",gs.execStatic(Utils,'isAndroid', this,[]));
    gs.sp(gSobject.scope,"email","");
    return gs.sp(gSobject.scope,"phoneNumber","");
   }
  gSobject['login'] = function(it) {
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username",gs.elvis(gs.bool(gs.gp(gSobject.scope,"email")) , gs.gp(gSobject.scope,"email") , gs.gp(gSobject.scope,"phoneNumber")));
    if (!gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"))) {
      gs.mc(gSobject,"notify",["Please enter details", "negative"]);
      return null;
     };
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"generatePinForExistingUser",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), (gs.bool(gs.gp(gSobject.scope,"phoneNumber")) ? true : false)]),"then",[function(it) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/legionPin"]);
      return gs.mc(gSobject,"notify",["Pin Sent"]);
     }, function(error) {
      return gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
     }]);
   }
  gSobject['googleSignIn'] = function(it) {
    if (!gs.bool(gs.execStatic(Utils,'isCordova', this,[]))) {
      return gs.mc(gSobject,"notify",["Could not complete sign in", "negative"]);
     };
    return gs.mc(gs.fs('cordovaGoogleSignIn', this, gSobject),"googleSignIn",[function(success) {
      gs.println("cordovaGoogleSignIn");
      gs.println(success);
      var object = gs.mc(gSobject,"toObject",[success]);
      gs.println(object);
      return gs.mc(gSobject,"signInWith",[gs.gp(gs.gp(object,"message"),"email"), gs.gp(gs.gp(object,"message"),"id"), function(it) {
        return gs.mc(gs.fs('legionUserService', this, gSobject),"loadLegionUser",[function(user) {
          return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
         }]);
       }, function(error) {
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/login"]);
        return gs.mc(gSobject,"errorNotification",[error]);
       }]);
     }, function(error) {
      gs.println(error);
      return gs.mc(gSobject,"notify",["Error Signing in with Google", "negative"]);
     }]);
   }
  gSobject['signInWithApple'] = function(it) {
    if (!gs.bool(gs.execStatic(Utils,'isCordova', this,[]))) {
      return gs.mc(gSobject,"notify",["Could not complete sign in", "negative"]);
     };
    return LegionLoginComponent.signInWithAppleAuth(function(result) {
      gs.println("signInWithAppleAuth result:");
      gs.println(result);
      var jwt = gs.execStatic(Utils,'decodeJWT', this,[gs.gp(result,"identityToken")]);
      var email = gs.gp(jwt,"email");
      var password = gs.gp(jwt,"sub");
      gSobject.appleAuth = result;
      return gs.mc(gSobject,"signInWith",[email, password, function(it) {
        return gs.mc(gs.fs('legionUserService', this, gSobject),"loadLegionUser",[function(user) {
          gs.mc(gSobject,"saveAppleCustomer",[gs.gp(user,"_id")]);
          return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
         }]);
       }, function(error) {
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/login"]);
        return gs.mc(gSobject,"errorNotification",[error]);
       }]);
     });
   }
  gSobject.signInWithAppleAuth = function(x0) { return LegionLoginComponent.signInWithAppleAuth(x0); }
  gSobject['saveAppleCustomer'] = function(userId) {
    var user = gs.map();
    if (gs.bool(gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"familyName"))) {
      gs.sp(user,"surname",gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"familyName"));
     };
    if (gs.bool(gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"givenName"))) {
      gs.sp(user,"name",gs.gp(gs.gp(gSobject.appleAuth,"fullName"),"givenName"));
     };
    return gs.mc(gs.fs('legionUserService', this, gSobject),"updateUserDetails",[userId, gs.gp(user,"name"), gs.gp(user,"surname")]);
   }
  gSobject['signInWith'] = function(email, password, successCallback, failCallback) {
    return gs.mc(gs.fs('legionUserService', this, gSobject),"auth",[email, password, function(authenticated) {
      if (gs.bool(authenticated)) {
        return gs.execCall(successCallback, this, [authenticated]);
       };
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"repairUser",[email, password, function(result) {
        if (!gs.bool(gs.gp(result,"success"))) {
          gs.execCall(failCallback, this, ["Registration Failed"]);
         };
        return gs.mc(gs.fs('legionUserService', this, gSobject),"auth",[email, password, function(isAuthenticated) {
          if (gs.bool(isAuthenticated)) {
            return gs.execCall(successCallback, this, [isAuthenticated]);
           };
          return gs.execCall(failCallback, this, ["Login Failed"]);
         }]);
       }]);
     }]);
   }
  gSobject['errorNotification'] = function(notification) {
    return gs.mc(this,"alert",[notification], gSobject);
   }
  gSobject['differentLogin'] = function(it) {
    return gs.mc(gSobject,"notify",["WIP"]);
   }
  gSobject.toObject = function(data) {
    return JSON.parse(data)
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
LegionLoginComponent.signInWithAppleAuth = function(callback) {
  var value
        window.cordova.plugins.SignInWithApple.signin(
            { requestedScopes: [0,1] },
            function(succ){
                value = succ
                console.log("signInWithAppleAuth----------------------------------")
                console.log(JSON.stringify(value))
                callback(value)
            },
            function(err){
                if(err.code == "1001" || err.code == "1003"){
                    alert('Authentication failed: User cancelled sign in.');
                }else if(err.code == "1002"){
                    alert('Error: Sign in response received an invalid response');
                }else{
                    alert('Error: Authentication failed');
                }
            }
        )
 }

function LegionUserService() {
  var gSobject = gs.init('LegionUserService');
  gSobject.clazz = { name: 'LegionUserService', simpleName: 'LegionUserService'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.legionUser = null;
  gSobject.country = null;
  gSobject['lookupCountry'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionLocaleService"),"fetchCountry",[function(countryIn) {
      return gSobject.country = countryIn;
     }]);
   }
  gSobject['auth'] = function(username, password, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"authenticate",[username, password, function(authData) {
      gs.println("LegionUserService.auth1");
      gs.println(authData);
      if (!gs.bool(authData)) {
        return gs.execCall(callback, this, [false]);
       };
      if (gs.bool(gs.gp(authData,"authenticated"))) {
        gs.execStatic(Utils,'updateAuthTokenToSession', this,[authData]);
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("User authdata:", authData)]);
        gs.mc(gSobject,"updateSession",[authData]);
        gs.mc(gSobject,"loadLegionUser",[function(it) {
          return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
         }]);
        return null;
       };
      return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
     }]);
   }
  gSobject['updateSession'] = function(authData) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("User authdata:", authData)]);
    gs.sp(gs.fs('session', this, gSobject),"legionUser",gs.gp(authData,"legionUser"));
    gs.sp(gs.fs('session', this, gSobject),"user",gs.gp(authData,"legionUser"));
    gs.sp(gs.fs('session', this, gSobject),"legionUserId",gs.gp(gs.gp(authData,"legionUser"),"_id",true));
    gs.sp(gs.fs('session', this, gSobject),"userId",gs.gp(gs.gp(authData,"legionUser"),"_id",true));
    if (gs.bool(gs.gp(authData,"zoner"))) {
      gs.sp(gs.fs('session', this, gSobject),"zoner",gs.gp(authData,"zoner"));
      gs.sp(gs.fs('session', this, gSobject),"zonerId",gs.gp(gs.gp(authData,"zoner"),"id"));
      return gs.sp(gs.fs('session', this, gSobject),"authToken",gs.gp(gs.gp(authData,"zoner"),"token"));
     };
   }
  gSobject['authWithPin'] = function(username, pin, callback, failCallback) {
    if (callback === undefined) callback = function(it) {
     };
    if (failCallback === undefined) failCallback = function(it) {
     };
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"authenticateWithPin",[username, pin]),"then",[function(authData) {
      if (!gs.bool(authData)) {
        return gs.execCall(callback, this, [false]);
       };
      if (gs.bool(gs.gp(authData,"authenticated"))) {
        gs.execStatic(Utils,'updateAuthTokenToSession', this,[authData]);
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("User authdata:", authData)]);
        gs.mc(gSobject,"updateSession",[authData]);
        gs.mc(gSobject,"loadLegionUser",[function(it) {
          return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
         }]);
        return null;
       };
      return gs.mc(this,"success",[gs.gp(authData,"authenticated")], gSobject);
     }, function(error) {
      return gs.execCall(failCallback, this, [error]);
     }]);
   }
  gSobject['loadLegionUserFromServer'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gs.gp(gs.fs('transmission', this, gSobject),"onAuthReady"),"callback",[function(it) {
      if (gs.bool(gs.gp(gs.fs('session', this, gSobject),"legionUserId"))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"loadLegionUser",[gs.gp(gs.fs('session', this, gSobject),"legionUserId"), function(legionUser) {
          gs.mc(gSobject,"updateSession",[gs.map().add("legionUser",legionUser)]);
          return gs.execCall(callback, this, [gs.gp(gs.fs('session', this, gSobject),"legionUser")]);
         }]);
        return null;
       };
      if (gs.bool(gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id",true))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"loadLegionUserFromZonerId",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), function(legionUser) {
          gs.println("legionUser2");
          gs.println(legionUser);
          gs.mc(gSobject,"updateSession",[gs.map().add("legionUser",legionUser)]);
          return gs.execCall(callback, this, [gs.gp(gs.fs('session', this, gSobject),"legionUser")]);
         }]);
       };
      return gs.execCall(callback, this, []);
     }]);
   }
  gSobject['loadLegionUser'] = function(callback, failCallback, resetCache) {
    if (callback === undefined) callback = function(it) {
     };
    if (failCallback === undefined) failCallback = function(it) {
     };
    if (resetCache === undefined) resetCache = false;
    if ((gs.bool(gSobject.legionUser)) && (!gs.bool(resetCache))) {
      return gs.execCall(callback, this, [gSobject.legionUser]);
     };
    if (gs.bool(gs.gp(gs.fs('session', this, gSobject),"authToken"))) {
      gs.mc(gs.gp(gs.fs('transmission', this, gSobject),"onAuthReady"),"callback",[function(it) {
        if (!gs.bool(gs.gp(gs.fs('session', this, gSobject),"legionUser"))) {
          throw {message: "Auth is authenticated, but legionUser not found"};
         };
        gSobject.legionUser = gs.gp(gs.fs('session', this, gSobject),"legionUser");
        gs.execStatic(Utils,'subscribe', this,[gs.gp(gSobject.legionUser,"_id"), function(updatedlegionUser) {
          return gSobject.legionUser = updatedlegionUser;
         }]);
        return gs.execCall(callback, this, [gSobject.legionUser]);
       }]);
      return null;
     };
    return gs.execCall(failCallback, this, []);
   }
  gSobject['registerPushDevice'] = function(data) {
    return gs.mc(gSobject,"loadLegionUser",[function(user) {
      gs.println(">>>>>>>>>>> Register Push Device");
      gs.println(gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("Data: ", gs.gp(user,"_id"))), " ")), gs.gp(data,"registrationId"))), " ")), gs.execStatic(Utils,'deviceType', this,[])));
      gs.println(data);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionPushService"),"registerDevice",[gs.gp(user,"_id"), gs.gp(data,"registrationId"), gs.execStatic(Utils,'deviceType', this,[]), function(it) {
        return gs.println(">>>>>>>>>>> Register Push Device - SUCCESS");
       }]);
     }]);
   }
  gSobject['getSetting'] = function(key, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"loadLegionUser",[function(user) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionService"),"getUserSetting",[gs.gp(user,"_id"), key, function(result) {
        return gs.execCall(callback, this, [result]);
       }]);
     }]);
   }
  gSobject['setSetting'] = function(key, value, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"loadLegionUser",[function(user) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionService"),"getUserSetting",[gs.gp(user,"_id"), key, value, function(result) {
        return gs.execCall(callback, this, [result]);
       }]);
     }]);
   }
  gSobject['updateUserDetails'] = function(userId, name, surname) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"loadLegionUser",[userId, function(user) {
      gs.sp(user,"name",name);
      gs.sp(user,"surname",surname);
      return gs.mc(user,"save",[]);
     }]);
   }
  gSobject['LegionUserService0'] = function(it) {
    gs.mc(gSobject,"loadLegionUserFromServer",[]);
    gs.mc(gSobject,"lookupCountry",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.LegionUserService0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaDevice() {
  var gSobject = gs.init('CordovaDevice');
  gSobject.clazz = { name: 'CordovaDevice', simpleName: 'CordovaDevice'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.network = gs.map().add("type","NONE").add("status","online");
  gSobject.battery = gs.map().add("level",50).add("isPlugged",false).add("state","normal").add("date",gs.date());
  gSobject.device = gs.map().add("network",gSobject.network).add("battery",gSobject.battery).add("orientation","portrait").add("keyboard","hide");
  gSobject.onKeyboardListeners = gs.list([]);
  gSobject.appEventListeners = gs.list([]);
  gSobject.onBackKeyDown = function(it) {
   };
  gSobject.userId = null;
  gSobject['splashScreenHide'] = function(it) {
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      try {
        gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"splashscreen"),"hide",[], null, true);
        if (CordovaDevice.cordovaPluginStatusBarInstalled()) {
          gs.mc(gs.fs('StatusBar', this, gSobject),"overlaysWebView",[false]);
          gs.mc(gs.fs('StatusBar', this, gSobject),"backgroundColorByName",["black"]);
         };
        try {
          var p = gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["portrait"]);
          if ((gs.bool(p)) && (gs.bool(gs.gp(p,"catch")))) {
            gs.mc(p,"catch",[gs.mc(this,"function",[function(it) {
             }], gSobject)]);
           };
         }
        catch (e) {
         }
        ;
       }
      catch (all) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["splashScreenHide:" + (gs.fs('all', this, gSobject)) + ""]);
       }
      ;
     };
   }
  gSobject['disableBackButton'] = function(it) {
    return gs.mc(gs.fs('document', this, gSobject),"addEventListener",["backbutton", gSobject.onBackKeyDown, false]);
   }
  gSobject['setupCordovaAppEvents'] = function(it) {
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["pause", function(it) {
      return gs.mc(gSobject,"emitEvent",["app.pause"]);
     }, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["resume", function(it) {
      return gs.mc(gSobject,"emitEvent",["app.resume"]);
     }, false]);
    return gs.mc(gs.fs('document', this, gSobject),"addEventListener",["menubutton", function(it) {
      return gs.mc(gSobject,"emitEvent",["app.menubutton"]);
     }, false]);
   }
  gSobject['preventScreenshots'] = function(it) {
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.fs('OurCodeWorldpreventscreenshots', this, gSobject),"enable",[]);
     }, 1]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"preventscreenshot"),"enable",[function(it) {
       }, function(it) {
       }]);
     }, 1]);
   }
  gSobject['allowScreenshots'] = function(it) {
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.fs('OurCodeWorldpreventscreenshots', this, gSobject),"disable",[]);
     }, 1]);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"preventscreenshot"),"disable",[function(it) {
       }, function(it) {
       }]);
     }, 1]);
   }
  gSobject['setupCordovaPluginKeyboard'] = function(it) {
    var initialViewportHeight = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"height");
    var initialViewportWidth = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"width");
    return gs.mc(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"addEventListener",["resize", function(it) {
      if (initialViewportWidth != gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"width")) {
        gs.execStatic(Utils,'setTimeout', this,[function(it) {
          initialViewportHeight = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"height");
          initialViewportWidth = gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"width");
          gs.mc(gSobject,"emitEvent",["orientation." + (gs.mc(gSobject,"getOrientation",[])) + ""]);
          gs.sp(gSobject.device,"orientation",gs.mc(gSobject,"getOrientation",[]));
          return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["setupCordovaPluginKeyboard:orientation." + (gs.mc(gSobject,"getOrientation",[])) + ""]);
         }, 100]);
        return null;
       };
      if (gs.equals(gs.gp(gs.gp(gs.fs('window', this, gSobject),"visualViewport"),"height"), initialViewportHeight)) {
        gs.sp(gSobject.device,"keyboard","hide");
        gs.mc(gSobject,"emitEvent",["keyboard.hide"]);
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["setupCordovaPluginKeyboard:keyboard.hide"]);
       } else {
        gs.sp(gSobject.device,"keyboard","show");
        gs.mc(gSobject,"emitEvent",["keyboard.show"]);
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["setupCordovaPluginKeyboard:keyboard.show"]);
       };
     }]);
   }
  gSobject['getOrientation'] = function(it) {
    return gs.gp(gs.fs('screen', this, gSobject)["orientation"],"type");
   }
  gSobject['setupCordovaPluginDevice'] = function(it) {
    gs.mc(gSobject.device,"putAll",[gs.gp(gs.fs('window', this, gSobject),"device")]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userDevice",[gSobject.userId, gSobject.device]),"do",[]);
   }
  gSobject['setupCordovaPluginBatteryStatus'] = function(it) {
    var batteryUpdate = function(status, state) {
      if (gs.bool(gs.gp(state,"level"))) {
        gSobject.battery = gs.map().add("level",gs.gp(state,"level")).add("isPlugged",gs.gp(state,"isPlugged")).add("isTrusted",gs.gp(state,"isTrusted")).add("status",status).add("date",gs.date());
        gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userDeviceBattery",[gSobject.userId, gs.gp(gSobject.device,"uuid"), gSobject.battery]),"do",[]);
       };
      gs.sp(gSobject.network,"bettery",status);
      return gs.mc(gSobject,"emitEvent",["bettery." + (status) + ""]);
     };
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterystatus", function(state) {
      return gs.execCall(batteryUpdate, this, ["normal", state]);
     }, false]);
    gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterylow", function(state) {
      return gs.execCall(batteryUpdate, this, ["low", state]);
     }, false]);
    return gs.mc(gs.fs('window', this, gSobject),"addEventListener",["batterycritical", function(state) {
      return gs.execCall(batteryUpdate, this, ["critical", state]);
     }, false]);
   }
  gSobject['setupCordovaPluginNetworkInformation'] = function(it) {
    var networkUpdate = function(status) {
      gs.sp(gSobject.network,"status",status);
      gs.sp(gSobject.network,"type",gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"connection"),"type"));
      gs.sp(gSobject.network,"date",gs.date());
      gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userNetwork",[gSobject.userId, gs.gp(gSobject.device,"uuid"), gSobject.network]),"do",[]);
      return gs.mc(gSobject,"emitEvent",["network." + (status) + ""]);
     };
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["offline", function(it) {
      return gs.execCall(networkUpdate, this, ["offline"]);
     }, false]);
    gs.mc(gs.fs('document', this, gSobject),"addEventListener",["online", function(it) {
      return gs.execCall(networkUpdate, this, ["online"]);
     }, false]);
    return gs.execCall(networkUpdate, this, ["online"]);
   }
  gSobject['addAppEventListeners'] = function(callback) {
    return gs.mc(gSobject.appEventListeners,"add",[callback]);
   }
  gSobject['emitEvent'] = function(event) {
    return gs.mc(gSobject.appEventListeners,"each",[function(listner) {
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.execCall(listner, this, [event]);
       }, 0]);
     }]);
   }
  gSobject['vibrate'] = function(timeMs) {
    return gs.mc(gs.fs('navigator', this, gSobject),"vibrate",[timeMs]);
   }
  gSobject.spinnerInstalled = function() { return CordovaDevice.spinnerInstalled(); }
  gSobject['statusBarShow'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"show",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarShow error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarHide'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"hide",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarHide error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarColor'] = function(hex) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"backgroundColorByHexString",[hex]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarColor error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarStyleLight'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"styleLightContent",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarStyleLight error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarStyleDark'] = function(it) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"styleDefault",[]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarStyleDark error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['statusBarOverlay'] = function(overlay) {
    if (!gs.bool(CordovaDevice.cordovaPluginStatusBarInstalled())) {
      return null;
     };
    try {
      gs.mc(gs.fs('StatusBar', this, gSobject),"overlaysWebView",[overlay]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["statusBarOverlay error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['lockPortrait'] = function(it) {
    return gs.mc(gSobject,"doLockOrientation",["portrait"]);
   }
  gSobject['lockLandscape'] = function(it) {
    return gs.mc(gSobject,"doLockOrientation",["landscape"]);
   }
  gSobject['unlockOrientation'] = function(it) {
    try {
      gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"unlock",[], null, true);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["unlockOrientation: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject.doLockOrientation = function(orientation) {
    try {
            var result = screen.orientation.lock(orientation);
            // iOS 16+ returns a Promise — handle rejection silently
            if (result && result.then) {
                result.catch(function(e) { console.log('orientation lock rejected:', e); });
            }
            return 'ok';
        } catch (e) {
            console.log('orientation lock error:', e);
            return 'Not supported: ' + (e.message || e);
        }
   }
  gSobject['hasPermission'] = function(name, callback) {
    if (!gs.bool(CordovaDevice.permissionsInstalled())) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",true)]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"checkPermission",[name, callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",e)]);
       }]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",gs.fs('e', this, gSobject))]);
     }
    ;
   }
  gSobject['requestPermission'] = function(name, callback) {
    if (!gs.bool(CordovaDevice.permissionsInstalled())) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",true)]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"requestPermission",[name, callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",e)]);
       }]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",gs.fs('e', this, gSobject))]);
     }
    ;
   }
  gSobject['hasPermissions'] = function(names, callback) {
    if (!gs.bool(CordovaDevice.permissionsInstalled())) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",true)]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('cordova', this, gSobject),"plugins"),"permissions"),"checkPermission",[names, callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",e)]);
       }]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("hasPermission",false).add("error",gs.fs('e', this, gSobject))]);
     }
    ;
   }
  gSobject.permissionsInstalled = function() { return CordovaDevice.permissionsInstalled(); }
  gSobject.cordovaPluginStatusBarInstalled = function() { return CordovaDevice.cordovaPluginStatusBarInstalled(); }
  gSobject.cordovaPluginDeviceInstalled = function() { return CordovaDevice.cordovaPluginDeviceInstalled(); }
  gSobject.crdovaPluginNetworkInformationInstalled = function() { return CordovaDevice.crdovaPluginNetworkInformationInstalled(); }
  gSobject['showSpinner'] = function(message, cancelable) {
    if (message === undefined) message = "";
    if (cancelable === undefined) cancelable = false;
    return gs.mc(gSobject,"nativeSpinnerShow",[gs.map().add("message",message).add("cancelable",cancelable), function(it) {
     }, function(it) {
     }]);
   }
  gSobject['hideSpinner'] = function(it) {
    return gs.mc(gSobject,"nativeSpinnerHide",[function(it) {
     }, function(it) {
     }]);
   }
  gSobject.nativeSpinnerShow = function(options, success, error) {
    if (typeof window.dymicoSpinner !== 'undefined') {
            window.dymicoSpinner.show(options, success, error);
        } else if (typeof SpinnerDialog !== 'undefined') {
            SpinnerDialog.show(null, options.message || '', options.cancelable || false);
            if (success) success();
        } else { if (error) error('Spinner not available'); }
   }
  gSobject.nativeSpinnerHide = function(success, error) {
    if (typeof window.dymicoSpinner !== 'undefined') {
            window.dymicoSpinner.hide(success, error);
        } else if (typeof SpinnerDialog !== 'undefined') {
            SpinnerDialog.hide();
            if (success) success();
        } else { if (error) error('Spinner not available'); }
   }
  gSobject['preventCapture'] = function(enabled, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativePreventCapture",[enabled, success, error]);
   }
  gSobject['onScreenshot'] = function(callback) {
    return gs.mc(gSobject,"nativeOnScreenshot",[callback]);
   }
  gSobject['onScreenRecording'] = function(callback) {
    return gs.mc(gSobject,"nativeOnScreenRecording",[callback]);
   }
  gSobject.nativePreventCapture = function(enabled, success, error) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.preventCapture(enabled, success, error);
        } else { if (error) error('dymicoScreenshot not available'); }
   }
  gSobject.nativeOnScreenshot = function(callback) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.onScreenshot(callback);
        }
   }
  gSobject.nativeOnScreenRecording = function(callback) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.dymicoScreenshot) {
            cordova.plugins.dymicoScreenshot.onScreenRecording(callback);
        }
   }
  gSobject['getAppInfo'] = function(callback, error) {
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeGetAppInfo",[callback, error]);
   }
  gSobject['setBadge'] = function(count, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeSetBadge",[count, success, error]);
   }
  gSobject['clearBadge'] = function(success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeSetBadge",[0, success, error]);
   }
  gSobject.nativeGetAppInfo = function(success, error) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.dymicoApp) {
            cordova.plugins.dymicoApp.getInfo(success, error);
        } else { if (error) error('dymicoApp not available'); }
   }
  gSobject.nativeSetBadge = function(count, success, error) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.dymicoApp) {
            cordova.plugins.dymicoApp.setBadge(count, success, error);
        } else { if (error) error('dymicoApp not available'); }
   }
  gSobject['print'] = function(content, options, callback) {
    if (options === undefined) options = gs.map();
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativePrint",[content, options, callback]);
   }
  gSobject.nativePrint = function(content, options, callback) {
    if (typeof cordova !== 'undefined' && cordova.plugins && cordova.plugins.printer) {
            cordova.plugins.printer.print(content, options, callback);
        } else { if (callback) callback(false); }
   }
  gSobject['installErrorCapture'] = function(it) {
    gs.mc(gSobject,"nativeInstallErrorCapture",[]);
    gs.mc(gSobject,"nativeInstallConsoleTail",[]);
    return gs.mc(gSobject,"nativeInstallRouteHistory",[]);
   }
  gSobject['enableErrorFlush'] = function(it) {
    gs.mc(gSobject,"nativePrimeErrorContext",[gs.map().add("userId",gs.elvis(gs.bool(gSobject.userId) , gSobject.userId , "")).add("uuid",gs.elvis(gs.bool(gs.gp(gSobject.device,"uuid")) , gs.gp(gSobject.device,"uuid") , "")).add("platform",gs.elvis(gs.bool(gs.gp(gSobject.device,"platform")) , gs.gp(gSobject.device,"platform") , "browser")).add("appVersion",gs.elvis(gs.bool(gs.gp(gSobject.device,"version")) , gs.gp(gSobject.device,"version") , "")).add("appBuild",gs.elvis(gs.bool(gs.gp(gSobject.device,"cordova")) , gs.gp(gSobject.device,"cordova") , ""))]);
    return gs.mc(gSobject,"nativeFlushErrors",[]);
   }
  gSobject.nativeInstallErrorCapture = function() {
    if (window._cwErr) return; // idempotent

        var BUF_KEY = 'cw.errBuf';
        var BUF_CAP = 50;
        var DEDUP_MS = 60000;

        var dedup = {};
        var ctx = { userId: '', uuid: '', platform: 'browser', appVersion: '', appBuild: '' };
        var flushing = false;
        var buf;

        function readBuf() {
            try { var s = window.localStorage.getItem(BUF_KEY); return s ? JSON.parse(s) : []; }
            catch(e) { return []; }
        }
        function writeBuf(arr) {
            try {
                if (arr.length > BUF_CAP) arr = arr.slice(arr.length - BUF_CAP);
                window.localStorage.setItem(BUF_KEY, JSON.stringify(arr));
            } catch(e) {}
        }
        buf = readBuf();

        function fingerprint(type, msg, stack) {
            var first = (stack || '').split('\n')[0] || '';
            var s = (type || '') + ':' + (msg || '').substring(0, 80) + ':' + first.substring(0, 120);
            var h = 0;
            for (var i = 0; i < s.length; i++) { h = ((h << 5) - h) + s.charCodeAt(i); h |= 0; }
            return ('00000000' + (h >>> 0).toString(16)).slice(-8);
        }

        function capture(rec) {
            try {
                if (!rec.fingerprint) rec.fingerprint = fingerprint(rec.type, rec.message, rec.stack);
                if (!rec.clientReportedAt) rec.clientReportedAt = Date.now();
                if (!rec.userAgent && typeof navigator !== 'undefined') rec.userAgent = navigator.userAgent || '';
                rec.count = rec.count || 1;

                var now = Date.now();
                var d = dedup[rec.fingerprint];
                if (d && (now - d.lastTs) < DEDUP_MS && buf[d.idx] && buf[d.idx].fingerprint === rec.fingerprint) {
                    buf[d.idx].count = (buf[d.idx].count || 1) + 1;
                    d.lastTs = now;
                    writeBuf(buf);
                    return;
                }

                buf.push(rec);
                if (buf.length > BUF_CAP) {
                    buf = buf.slice(buf.length - BUF_CAP);
                    dedup = {};
                }
                dedup[rec.fingerprint] = { idx: buf.length - 1, lastTs: now };
                writeBuf(buf);

                if (typeof navigator !== 'undefined' && navigator.onLine !== false) flush();
            } catch(e) { try { console.log('[cwErr] capture failed:', e); } catch(_) {} }
        }

        function buildUrl() {
            try {
                var p = window.location.pathname.split('/').filter(function(s){ return s; });
                if (p.length >= 2) return '/' + p[0] + '/' + p[1] + '/cordova/errors';
            } catch(e) {}
            return '/cordova/errors';
        }

        function flush() {
            if (flushing || buf.length === 0) return;
            if (typeof navigator !== 'undefined' && navigator.onLine === false) return;

            flushing = true;
            var sent = buf.length;
            var batch = buf.slice();

            for (var i = 0; i < batch.length; i++) {
                if (!batch[i].user && ctx.userId) batch[i].user = ctx.userId;
                if (!batch[i].uuid && ctx.uuid) batch[i].uuid = ctx.uuid;
                if (!batch[i].platform && ctx.platform) batch[i].platform = ctx.platform;
                if (!batch[i].appVersion && ctx.appVersion) batch[i].appVersion = ctx.appVersion;
                if (!batch[i].appBuild && ctx.appBuild) batch[i].appBuild = ctx.appBuild;
            }

            var done = function(ok) {
                flushing = false;
                if (ok) {
                    buf = buf.slice(sent);
                    dedup = {};
                    writeBuf(buf);
                }
            };

            try {
                var xhr = new XMLHttpRequest();
                xhr.open('POST', buildUrl(), true);
                xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
                xhr.timeout = 5000;
                xhr.onload = function() { done(xhr.status >= 200 && xhr.status < 300); };
                xhr.onerror = function() { done(false); };
                xhr.ontimeout = function() { done(false); };
                xhr.send('json=' + encodeURIComponent(JSON.stringify(batch)));
            } catch(e) { done(false); }
        }

        window.onerror = function(message, source, line, col, error) {
            capture({
                type: 'js_error',
                message: message ? String(message) : '',
                stack: error && error.stack ? String(error.stack) : '',
                source: source || '',
                line: line || 0,
                col: col || 0
            });
        };

        window.addEventListener('unhandledrejection', function(event) {
            var reason = event.reason || {};
            var msg;
            if (reason && reason.message) { msg = String(reason.message); }
            else { try { msg = String(reason); } catch(e) { msg = ''; } }
            capture({
                type: 'unhandled_rejection',
                message: msg,
                stack: reason && reason.stack ? String(reason.stack) : '',
                source: '',
                line: 0,
                col: 0
            });
        });

        function installExecInterceptor() {
            if (!(window.cordova && window.cordova.exec) || window.cordova.exec.__cwWrapped) return false;
            var orig = window.cordova.exec;
            var wrapped = function(success, fail, service, action, args) {
                var wrappedFail = function(err) {
                    try {
                        var emsg;
                        if (typeof err === 'string') emsg = err;
                        else if (err && err.message) emsg = String(err.message);
                        else { try { emsg = JSON.stringify(err); } catch(e) { emsg = String(err); } }
                        capture({
                            type: 'plugin_error',
                            message: emsg,
                            stack: '',
                            source: service + '.' + action,
                            line: 0,
                            col: 0
                        });
                    } catch(_) {}
                    if (fail) fail(err);
                };
                return orig(success, wrappedFail, service, action, args);
            };
            wrapped.__cwWrapped = true;
            window.cordova.exec = wrapped;
            return true;
        }
        if (!installExecInterceptor()) {
            var tries = 0;
            var iv = setInterval(function() {
                tries++;
                if (installExecInterceptor() || tries > 50) clearInterval(iv);
            }, 100);
        }

        window.addEventListener('online', flush);
        document.addEventListener('resume', flush, false);
        document.addEventListener('deviceready', flush, false);

        window._cwErr = {
            capture: capture,
            flush: flush,
            setContext: function(c) { for (var k in c) ctx[k] = c[k]; },
            _ctx: ctx,
            _buf: function() { return buf.slice(); }
        };

        try { console.log('[CordovaDevice] error capture installed (offline-aware)'); } catch(_) {}
   }
  gSobject.nativePrimeErrorContext = function(ctx) {
    if (window._cwErr) window._cwErr.setContext(ctx);
   }
  gSobject.nativeFlushErrors = function() {
    if (window._cwErr) window._cwErr.flush();
   }
  gSobject['reportProblem'] = function(userMessage, opts, success, error) {
    if (opts === undefined) opts = gs.map();
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (!gs.bool(gs.mc(userMessage,"trim",[], null, true))) {
      return gs.execCall(error, this, ["userMessage is required"]);
     };
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"reportProblem",[userMessage, opts, success, error]);
   }
  gSobject.nativeInstallConsoleTail = function() {
    if (window._cwConsoleTailInstalled) return;
        window._cwConsoleTailInstalled = true;
        window._cwConsoleTail = window._cwConsoleTail || [];
        var CAP = 50;
        var levels = ['log', 'info', 'warn', 'error'];
        for (var i = 0; i < levels.length; i++) {
            (function(level) {
                var orig = console[level];
                console[level] = function() {
                    try {
                        var parts = [];
                        for (var j = 0; j < arguments.length; j++) {
                            var a = arguments[j];
                            if (a == null) { parts.push(String(a)); continue; }
                            if (typeof a === 'string') { parts.push(a); continue; }
                            try { parts.push(JSON.stringify(a)); }
                            catch(e) { parts.push(String(a)); }
                        }
                        var line = '[' + new Date().toISOString().substr(11,12) + '] ' + level.toUpperCase() + ' ' + parts.join(' ');
                        if (line.length > 500) line = line.substring(0, 500) + '...';
                        window._cwConsoleTail.push(line);
                        if (window._cwConsoleTail.length > CAP) {
                            window._cwConsoleTail = window._cwConsoleTail.slice(-CAP);
                        }
                    } catch(_) {}
                    if (orig && orig.apply) orig.apply(console, arguments);
                };
            })(levels[i]);
        }
   }
  gSobject.nativeInstallRouteHistory = function() {
    if (window._cwRouteHistoryInstalled) return;
        var CAP = 10;
        window._cwRouteHistory = window._cwRouteHistory || [];
        var tries = 0;
        var iv = setInterval(function() {
            tries++;
            try {
                if (window.vue && window.vue.router && window.vue.router.afterEach) {
                    window.vue.router.afterEach(function(to) {
                        try {
                            var path = to && (to.fullPath || to.path) ? (to.fullPath || to.path) : '';
                            if (path) {
                                window._cwRouteHistory.push(path);
                                if (window._cwRouteHistory.length > CAP) {
                                    window._cwRouteHistory = window._cwRouteHistory.slice(-CAP);
                                }
                            }
                        } catch(_) {}
                    });
                    window._cwRouteHistoryInstalled = true;
                    clearInterval(iv);
                }
            } catch(_) {}
            if (tries > 100) clearInterval(iv);
        }, 200);
   }
  gSobject['CordovaDevice0'] = function(it) {
    gs.mc(gSobject,"installErrorCapture",[]);
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaDevice:deviceready"]);
      gs.mc(gSobject,"splashScreenHide",[]);
      gs.mc(gSobject,"setupCordovaPluginKeyboard",[]);
      if (!gs.bool(gs.mc(this,"cordovaPluginDeviceInstalled",[], gSobject))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaDevice:NOT INSTALLED"]);
        gs.mc(gSobject,"enableErrorFlush",[]);
        return null;
       };
      if (!gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId"))) {
        gs.mc(gSobject,"enableErrorFlush",[]);
        return null;
       };
      gSobject.userId = gs.gp(gs.fs('session', this, gSobject),"userId");
      try {
        gs.mc(gSobject,"setupCordovaPluginDevice",[]);
        gs.mc(gSobject,"setupCordovaPluginBatteryStatus",[]);
        gs.mc(gSobject,"setupCordovaPluginNetworkInformation",[]);
        gs.mc(gSobject,"disableBackButton",[]);
       }
      catch (all) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",[gs.plus("CordovaDevice:init:ERROR:", gs.fs('all', this, gSobject))]);
       }
      ;
      return gs.mc(gSobject,"enableErrorFlush",[]);
     }]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"splashScreenHide",[]);
     }, 1000]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaDevice0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaDevice.spinnerInstalled = function() {
  return typeof window.dymicoSpinner !== 'undefined';
 }
CordovaDevice.permissionsInstalled = function() {
  return typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.permissions !== 'undefined';
 }
CordovaDevice.cordovaPluginStatusBarInstalled = function() {
  return ( typeof StatusBar !== 'undefined' )
 }
CordovaDevice.cordovaPluginDeviceInstalled = function() {
  return ( typeof device !== 'undefined' || typeof window.device !== 'undefined')
 }
CordovaDevice.crdovaPluginNetworkInformationInstalled = function() {
  return ( typeof navigator.connection !== 'undefined')
 }

function CordovaDeepLink() {
  var gSobject = gs.init('CordovaDeepLink');
  gSobject.clazz = { name: 'CordovaDeepLink', simpleName: 'CordovaDeepLink'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.callbackList = gs.list([]);
  gSobject['registerCallback'] = function(callback) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["================CordovaDeepLink registerCallback"]);
    return gs.mc(gSobject.callbackList,"add",[callback]);
   }
  gSobject['openDeepLink'] = function(eventData) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["=====================CordovaDeepLink openDeepLink"]);
    return gs.mc(gSobject.callbackList,"each",[function(callback) {
      return gs.execCall(callback, this, [eventData]);
     }]);
   }
  gSobject['CordovaDeepLink0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["======================CordovaDeepLink eventlistener"]);
      return gs.mc(gs.fs('universalLinks', this, gSobject),"subscribe",["openDeepLink", gs.gp(gs.thisOrObject(this,gSobject),"openDeepLink")]);
     }, false]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaDeepLink0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueDateComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueDateComponent', simpleName: 'VueDateComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.toJavascript(gs.list(["modelValue" , "label" , "onSelect" , "outlined" , "filled" , "standout" , "borderless" , "square" , "dark" , "clearable" , "required" , "autoClose" , "format" , "time"]));
  gSobject.data = function(it) {
    return gs.map().add("dateString","").add("selectedDate","").add("selectedTime","").add("hasTime",false).add("showDate",false).add("showTime",false).add("rules",gs.list(["val => false"])).add("autoCloseData",true).add("formatData","DD MMM YYYY");
   };
  gSobject['mounted'] = function(it) {
    var self = this;
    gs.sp(self,"hasTime",(gs.equals(gs.gp(self,"time"), "")));
    if (gs.bool(gs.gp(self,"hasTime"))) {
      gs.sp(self,"formatData","DD MMM YYYY HH:mm");
     };
    if (gs.bool(gs.gp(self,"required"))) {
      gs.sp(self,"rules",gs.list(["date"]));
     };
    if (gs.equals(gs.gp(self,"autoClose"), "false")) {
      gs.sp(self,"autoCloseData",false);
     };
    if (gs.bool(gs.gp(self,"format"))) {
      gs.sp(self,"formatData",gs.gp(self,"format"));
     };
    return gs.mc(gSobject,"updateDate",[self, gs.gp(self,"modelValue")]);
   }
  gSobject['updateDate'] = function(self, date) {
    gs.sp(this,"modelValue",date);
    gs.sp(self,"dateString",(gs.bool(date) ? gs.mc(gs.mc(gSobject,"moment",[date]),"format",[gs.gp(self,"formatData")]) : null));
    return gs.mc(self,"$emit",["update:modelValue", date]);
   }
  gSobject['clearDate'] = function(it) {
    gs.sp(this,"modelValue",null);
    gs.sp(this,"dateString",null);
    return gs.mc(gSobject.self,"$emit",["update:modelValue", gs.fs('date', this, gSobject)]);
   }
  gSobject['openDate'] = function(it) {
    return gs.sp(this,"showDate",true);
   }
  gSobject['closeAll'] = function(it) {
    gs.sp(this,"showDate",false);
    return gs.sp(this,"showTime",false);
   }
  gSobject['selectedDateString'] = function(dateStringValue) {
    if (!gs.bool(dateStringValue)) {
      return null;
     };
    gs.mc(gSobject,"updateDate",[this, gs.date(dateStringValue)]);
    var self = this;
    gs.sp(this,"showDate",false);
    if (gs.bool(gs.gp(self,"hasTime"))) {
      return gs.sp(this,"showTime",true);
     };
   }
  gSobject['selectedTimeString'] = function(timeStringValue) {
    if (!gs.bool(timeStringValue)) {
      return null;
     };
    gs.sp(this,"showTime",false);
    var timeParts = gs.mc(timeStringValue,"split",[":"]);
    gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"modelValue"),"setHours",[timeParts[0]]);
    gs.mc(gs.gp(gs.thisOrObject(this,gSobject),"modelValue"),"setMinutes",[timeParts[1]]);
    return gs.mc(gSobject,"updateDate",[this, gs.gp(gs.thisOrObject(this,gSobject),"modelValue")]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3MenuButton() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3MenuButton', simpleName: 'I3MenuButton'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list([]);
  gSobject.defaults = gs.map().add("type","button").add("label","Button").add("color","primary").add("textColor","").add("size","xs").add("noCaps",true).add("outline",false).add("flat",false).add("unelevated",true).add("rounded",false).add("push",false).add("square",false).add("glossy",false).add("dense",false);
  gSobject['created'] = function(it) {
    var self = this;
    var appConfig = gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig")) , gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig") , gs.map());
    var config = (gs.gp(appConfig,"menubutton") != null ? gs.gp(appConfig,"menubutton") : gs.map());
    var attrs = (gs.gp(self,"$attrs") != null ? gs.gp(self,"$attrs") : gs.map());
    gs.sp(self,"btnProps",gs.toJavascript(gs.plus((gs.plus(gSobject.defaults, config)), attrs)));
    return gs.sp(gs.gp(self,"btnProps"),"size",gs.elvis(attrs["size"] , attrs["size"] , gs.elvis(config["size"] , config["size"] , gSobject.defaults["size"])));
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitDetailsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitDetailsTab', simpleName: 'UnitDetailsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("id",String);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"unit",gs.map());
    gs.sp(gSobject.scope,"latestFix",gs.map());
    gs.sp(gSobject.scope,"digitalIOColumns",gs.list([gs.map().add("name","sensorProfile").add("label","Sensor Profile").add("field","sensorProfile").add("align","left") , gs.map().add("name","label").add("label","Label").add("field","label").add("align","left") , gs.map().add("name","reading").add("label","Reading").add("field","reading").add("align","left") , gs.map().add("name","message").add("label","Message").add("field","message").add("align","left")]));
    gs.sp(gSobject.scope,"digitalIOReadings",gs.list([]));
    gs.sp(gSobject.scope,"activeEvents",gs.list([]));
    gs.sp(gSobject.scope,"highestTemp",null);
    gs.sp(gSobject.scope,"lowestTemp",null);
    gs.sp(gSobject.scope,"lastUpdated",null);
    gs.sp(gSobject.scope,"status",null);
    gs.sp(gSobject.scope,"fromDate",null);
    gs.sp(gSobject.scope,"toDate",null);
    gs.sp(gSobject.scope,"fromTime","00:00");
    gs.sp(gSobject.scope,"toTime","23:59");
    gs.sp(gSobject.scope,"sensorProfileOptions",gs.list([]));
    gs.sp(gSobject.scope,"selectedProfileIds",gs.list([]));
    gs.sp(gSobject.scope,"reportTemplates",gs.list([gs.map().add("value","operational").add("label","Operational Summary").add("description","Charts and a current alert summary for day to day monitoring. No full reading history.") , gs.map().add("value","compliance").add("label","Compliance / Audit").add("description","Full record of every reading and alert (active and resolved) for audits.") , gs.map().add("value","incident").add("label","Incident Report").add("description","Focused on alerts: charts plus active and resolved alerts with logs.")]));
    gs.sp(gSobject.scope,"selectedTemplate","operational");
    gs.sp(gSobject.scope,"generatingPdf",false);
    return gs.mc(gSobject,"loadOverview",[]);
   }
  gSobject['configureUnit'] = function(it) {
    var orgId = gs.elvis(gs.bool(gs.gp(gs.gp(gs.gp(gSobject.scope,"unit"),"org",true),"_id",true)) , gs.gp(gs.gp(gs.gp(gSobject.scope,"unit"),"org",true),"_id",true) , gs.gp(gs.gp(gSobject.scope,"unit"),"org",true));
    var unitId = gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"_id",true)) , gs.gp(gs.gp(gSobject.scope,"unit"),"_id",true) , gs.gp(gs.gp(gSobject.route,"params"),"id"));
    if ((!gs.bool(orgId)) || (!gs.bool(unitId))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/organisation/" + (orgId) + "/unit/" + (unitId) + ""]);
   }
  gSobject['loadOverview'] = function(it) {
    var unitId = gs.gp(gs.gp(gSobject.route,"params"),"id");
    if (!gs.bool(unitId)) {
      gs.mc(gSobject,"notify",["No unit ID provided", "negative"]);
      return null;
     };
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchUnitOverview",[unitId]),"then",[function(payload) {
      gs.sp(gSobject.scope,"unit",gs.elvis(gs.bool(gs.gp(payload,"unit",true)) , gs.gp(payload,"unit",true) , gs.map()));
      gs.sp(gSobject.scope,"latestFix",gs.elvis(gs.bool(gs.gp(payload,"latestFix",true)) , gs.gp(payload,"latestFix",true) , gs.map()));
      gs.sp(gSobject.scope,"lastUpdated",gs.gp(payload,"lastUpdated",true));
      gs.sp(gSobject.scope,"status",gs.gp(payload,"status",true));
      gs.sp(gSobject.scope,"highestTemp",gs.gp(payload,"highestTemp",true));
      gs.sp(gSobject.scope,"lowestTemp",gs.gp(payload,"lowestTemp",true));
      gs.sp(gSobject.scope,"activeEvents",gs.list([]));
      gs.sp(gSobject.scope,"digitalIOReadings",gs.list([]));
      return gs.mc(gSobject,"loadSensorProfiles",[unitId]);
     }, function(error) {
      gs.println("Failed to load unit overview: " + (error) + "");
      gs.mc(gSobject,"notify",["Failed to load unit overview", "negative"]);
      gs.sp(gSobject.scope,"unit",gs.map());
      return gs.sp(gSobject.scope,"latestFix",gs.map());
     }]);
   }
  gSobject['loadSensorProfiles'] = function(unitId) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"fetchMany",[gs.map().add("unit",unitId), function(profiles) {
      var list = gs.elvis(gs.bool(profiles) , profiles , gs.list([]));
      gs.sp(gSobject.scope,"sensorProfileOptions",gs.mc(list,"collect",[function(it) {
        return gs.map().add("label",gs.elvis(gs.bool(gs.gp(it,"name",true)) , gs.gp(it,"name",true) , gs.elvis(gs.bool(gs.gp(gs.gp(it,"sensor",true),"name",true)) , gs.gp(gs.gp(it,"sensor",true),"name",true) , "Unknown"))).add("value",gs.gp(it,"_id",true));
       }]));
      return gs.sp(gSobject.scope,"selectedProfileIds",gs.mc(gs.gp(gSobject.scope,"sensorProfileOptions"),"collect",[function(it) {
        return gs.gp(it,"value");
       }]));
     }]);
   }
  gSobject['selectAllProfiles'] = function(it) {
    return gs.sp(gSobject.scope,"selectedProfileIds",gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.scope,"sensorProfileOptions")) , gs.gp(gSobject.scope,"sensorProfileOptions") , gs.list([])),"collect",[function(it) {
      return gs.gp(it,"value");
     }]));
   }
  gSobject['deselectAllProfiles'] = function(it) {
    return gs.sp(gSobject.scope,"selectedProfileIds",gs.list([]));
   }
  gSobject['loadUnitData'] = function(unitId) {
    gs.sp(gSobject.scope,"lastUpdated",null);
    gs.sp(gSobject.scope,"status",null);
    gs.sp(gSobject.scope,"highestTemp",null);
    gs.sp(gSobject.scope,"lowestTemp",null);
    gs.sp(gSobject.scope,"activeEvents",gs.list([]));
    return gs.sp(gSobject.scope,"digitalIOReadings",gs.list([]));
   }
  gSobject['validateDateFilter'] = function(it) {
    if ((!gs.bool(gs.gp(gSobject.scope,"fromDate"))) || (!gs.bool(gs.gp(gSobject.scope,"toDate")))) {
      gs.mc(gSobject,"notify",["Please select both From and To dates", "warning"]);
      return false;
     };
    var from = gs.date(gs.gp(gSobject.scope,"fromDate"));
    var to = gs.date(gs.gp(gSobject.scope,"toDate"));
    var diffMs = gs.minus(gs.mc(to,"getTime",[]), gs.mc(from,"getTime",[]));
    var diffDays = Math.floor(gs.div(diffMs, (gs.multiply((gs.multiply((gs.multiply(1000, 60)), 60)), 24))));
    if (diffDays > 31) {
      gs.mc(gSobject,"notify",["Date range cannot exceed 31 days", "warning"]);
      return false;
     };
    if (diffDays < 0) {
      gs.mc(gSobject,"notify",["To date must be after From date", "warning"]);
      return false;
     };
    return true;
   }
  gSobject['exportTempHumidityPdf'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"generatingPdf"))) {
      return null;
     };
    if (!gs.bool(gs.mc(gSobject,"validateDateFilter",[]))) {
      return null;
     };
    if ((!gs.bool(gs.gp(gSobject.scope,"selectedProfileIds"))) || (gs.equals(gs.mc(gs.gp(gSobject.scope,"selectedProfileIds"),"size",[]), 0))) {
      gs.mc(gSobject,"notify",["Please select at least one sensor profile", "warning"]);
      return null;
     };
    var profileIds = gs.mc(gs.gp(gSobject.scope,"selectedProfileIds"),"join",[","]);
    var url = gs.plus((gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("/cwExportPdfReport/generatePdfReport/" + (gs.gp(gs.gp(gSobject.scope,"unit"),"_id")) + "", "?fromDate=" + (gs.gp(gSobject.scope,"fromDate")) + "")), "&toDate=" + (gs.gp(gSobject.scope,"toDate")) + "")), "&fromTime=" + (gs.gp(gSobject.scope,"fromTime")) + "")), "&toTime=" + (gs.gp(gSobject.scope,"toTime")) + "")), "&profileIds=" + (profileIds) + "")), "&template=" + (gs.elvis(gs.bool(gs.gp(gSobject.scope,"selectedTemplate")) , gs.gp(gSobject.scope,"selectedTemplate") , "operational")) + "");
    var fileName = "report_" + (gs.gp(gs.gp(gSobject.scope,"unit"),"name")) + ".pdf";
    gs.sp(gSobject.scope,"generatingPdf",true);
    return gs.mc(gSobject,"downloadPdfBlob",[url, fileName]);
   }
  gSobject['onPdfDone'] = function(it) {
    return gs.sp(gSobject.scope,"generatingPdf",false);
   }
  gSobject['onPdfError'] = function(message) {
    gs.sp(gSobject.scope,"generatingPdf",false);
    return gs.mc(gSobject,"notify",[gs.elvis(gs.bool(message) , message , "Failed to generate PDF report"), "negative"]);
   }
  gSobject.downloadPdfBlob = function(url, fileName) {
    var component = this;
        fetch(url, { credentials: 'same-origin' })
            .then(function(response) {
                if (!response.ok) {
                    throw new Error('HTTP ' + response.status);
                }
                return response.blob();
            })
            .then(function(blob) {
                var blobUrl = window.URL.createObjectURL(blob);
                var a = document.createElement('a');
                a.href = blobUrl;
                a.download = fileName;
                a.style.display = 'none';
                document.body.appendChild(a);
                a.click();
                document.body.removeChild(a);
                window.URL.revokeObjectURL(blobUrl);
                component.onPdfDone();
            })
            .catch(function(err) {
                console.error('PDF generation failed:', err);
                component.onPdfError('Failed to generate PDF report');
            });
   }
  gSobject['exportTempHumidityCsv'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"validateDateFilter",[]))) {
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"_id",true))) {
      gs.mc(gSobject,"notify",["No unit loaded", "warning"]);
      return null;
     };
    gs.sp(gSobject.scope,"loading",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwExportService"),"exportUnitHistoryCsv",[gs.gp(gs.gp(gSobject.scope,"unit"),"_id"), gs.gp(gSobject.scope,"fromDate"), gs.gp(gSobject.scope,"toDate"), gs.gp(gSobject.scope,"fromTime"), gs.gp(gSobject.scope,"toTime"), function(payload) {
      gs.sp(gSobject.scope,"loading",false);
      if (!gs.bool(gs.gp(payload,"content",true))) {
        gs.mc(gSobject,"notify",["No export data was returned", "warning"]);
        return null;
       };
      gs.mc(gSobject,"downloadCsv",[gs.elvis(gs.bool(gs.gp(payload,"fileName")) , gs.gp(payload,"fileName") , "UnitHistory.csv"), gs.gp(payload,"content")]);
      return gs.mc(gSobject,"notify",["CSV exported" + ((gs.gp(payload,"rowCount") != null ? " (" + (gs.gp(payload,"rowCount")) + " rows)" : "")) + "", "positive"]);
     }]);
   }
  gSobject['downloadCsv'] = function(fileName, content) {
    var link = gs.mc(gs.fs('document', this, gSobject),"createElement",["a"]);
    var url = gs.plus("data:text/csv;charset=utf-8,", gs.mc(this,"encodeURIComponent",[gs.elvis(gs.bool(content) , content , "")], gSobject));
    gs.sp(link,"href",url);
    gs.sp(link,"download",fileName);
    gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"appendChild",[link]);
    gs.mc(link,"click",[]);
    return gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"removeChild",[link]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaSimBridge() {
  var gSobject = gs.init('CordovaSimBridge');
  gSobject.clazz = { name: 'CordovaSimBridge', simpleName: 'CordovaSimBridge'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.active = false;
  gSobject.pendingCallbacks = gs.map();
  gSobject.eventListeners = gs.map();
  gSobject.shouldActivate = function() { return CordovaSimBridge.shouldActivate(); }
  gSobject['activate'] = function(it) {
    gSobject.active = true;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaSimBridge: ACTIVE — running in simulator mode"]);
    gs.mc(gSobject,"setupFakeCordova",[]);
    gs.mc(gSobject,"setupMessageListener",[]);
    return gs.mc(gSobject,"fireDeviceReady",[]);
   }
  gSobject['setupFakeCordova'] = function(it) {
    gs.mc(gSobject,"createFakePlugins",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaSimBridge: fake plugin globals created"]);
   }
  gSobject.createFakePlugins = function() {
    var bridge = this;

        // Core cordova object
        window.cordova = window.cordova || {};
        window.cordova.plugins = window.cordova.plugins || {};

        // --- Scanner ---
        window.cordova.plugins.barcodeScanner = {
            scan: function(success, error, config) {
                bridge._storePending('scanner', 'scan', success, error);
                console.log('[SimBridge] Scanner: waiting for simulated scan...');
                // Notify parent we're waiting
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'scanner', action:'scan'}, '*');
            }
        };

        // --- BackgroundGeolocation (cordova-plugin-i3-bggeo) ---
        window.BackgroundGeolocation = {
            events: ['location','stationary','activity','start','stop','error','authorization','foreground','background','abort_requested','http_authorization','geofence'],
            AUTHORIZED: 1, NOT_AUTHORIZED: 0, AUTHORIZED_FOREGROUND: 2,
            HIGH_ACCURACY: 0, MEDIUM_ACCURACY: 100, LOW_ACCURACY: 1000, PASSIVE_ACCURACY: 10000,
            BACKGROUND_MODE: 0, FOREGROUND_MODE: 1,
            GEOFENCE_TRANSITION_ENTER: 1, GEOFENCE_TRANSITION_EXIT: 2, GEOFENCE_TRANSITION_DWELL: 4,
            PERMISSION_DENIED: 1, LOCATION_UNAVAILABLE: 2, TIMEOUT: 3,
            DISTANCE_FILTER_PROVIDER: 0, ACTIVITY_PROVIDER: 1, RAW_PROVIDER: 2,
            LOG_ERROR: 'ERROR', LOG_WARN: 'WARN', LOG_INFO: 'INFO', LOG_DEBUG: 'DEBUG', LOG_TRACE: 'TRACE',
            _listeners: {},
            _config: {},
            _geofences: [],
            _geofenceQueue: [],
            _status: { isRunning: false, locationServicesEnabled: true, authorization: 1 },
            configure: function(config, success, failure) {
                var bg = window.BackgroundGeolocation;
                for (var k in (config || {})) bg._config[k] = config[k];
                console.log('[SimBridge] BgGeo configured', config);
                if(success) success();
            },
            getConfig: function(success, failure) { if(success) success(window.BackgroundGeolocation._config || {}); },
            start: function(s,f) { window.BackgroundGeolocation._status.isRunning = true; console.log('[SimBridge] BgGeo started'); if(s) s(); },
            stop: function(s,f) { window.BackgroundGeolocation._status.isRunning = false; console.log('[SimBridge] BgGeo stopped'); if(s) s(); },
            switchMode: function(m,s,f) { console.log('[SimBridge] BgGeo switchMode', m); if(s) s(); },
            getCurrentLocation: function(success, failure, options) {
                bridge._storePending('gps', 'currentLocation', success, failure);
                console.log('[SimBridge] GPS: waiting for simulated location...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'gps', action:'currentLocation'}, '*');
            },
            on: function(event, fn) {
                var bg = window.BackgroundGeolocation;
                if (!bg._listeners[event]) bg._listeners[event] = [];
                bg._listeners[event].push(fn);
                return { remove: function() {
                    var arr = bg._listeners[event] || [];
                    for (var i = arr.length - 1; i >= 0; i--) if (arr[i] === fn) arr.splice(i, 1);
                }};
            },
            removeAllListeners: function(event) {
                var bg = window.BackgroundGeolocation;
                if(event) bg._listeners[event] = []; else bg._listeners = {};
            },
            checkStatus: function(cb) {
                var s = window.BackgroundGeolocation._status;
                if(cb) cb({isRunning: s.isRunning, locationServicesEnabled: s.locationServicesEnabled, authorization: s.authorization});
            },
            showAppSettings: function() { console.log('[SimBridge] BgGeo showAppSettings'); },
            showLocationSettings: function() { console.log('[SimBridge] BgGeo showLocationSettings'); },
            addGeofence: function(fence, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                for (var i = fences.length - 1; i >= 0; i--) if (fence && fences[i].id === fence.id) fences.splice(i, 1);
                if (fence) fences.push(fence);
                console.log('[SimBridge] BgGeo addGeofence', fence);
                if(s) s();
            },
            addGeofences: function(arr, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                arr = arr || [];
                for (var j = 0; j < arr.length; j++) {
                    var fence = arr[j];
                    for (var i = fences.length - 1; i >= 0; i--) if (fences[i].id === fence.id) fences.splice(i, 1);
                    fences.push(fence);
                }
                console.log('[SimBridge] BgGeo addGeofences count=' + arr.length);
                if(s) s();
            },
            removeGeofence: function(id, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                for (var i = fences.length - 1; i >= 0; i--) if (fences[i].id === id) fences.splice(i, 1);
                console.log('[SimBridge] BgGeo removeGeofence', id);
                if(s) s();
            },
            removeGeofences: function(ids, s, e) {
                var fences = window.BackgroundGeolocation._geofences;
                ids = ids || [];
                var idSet = {};
                for (var k = 0; k < ids.length; k++) idSet[ids[k]] = true;
                for (var i = fences.length - 1; i >= 0; i--) if (idSet[fences[i].id]) fences.splice(i, 1);
                console.log('[SimBridge] BgGeo removeGeofences count=' + ids.length);
                if(s) s();
            },
            removeAllGeofences: function(s, e) {
                window.BackgroundGeolocation._geofences = [];
                console.log('[SimBridge] BgGeo removeAllGeofences');
                if(s) s();
            },
            getGeofences: function(cb) { if(cb) cb((window.BackgroundGeolocation._geofences || []).slice()); },
            getGeofenceEvents: function(cb) {
                var bg = window.BackgroundGeolocation;
                var q = (bg._geofenceQueue || []).slice();
                bg._geofenceQueue = [];
                if(cb) cb(q);
            },
            getStationaryLocation: function(s, f) { if(s) s(null); },
            // Backward-compat no-ops (matched to plugin's own stubs)
            getLocations:       function(s, f) { if(s) s([]); },
            getValidLocations:  function(s, f) { if(s) s([]); },
            deleteLocation:     function(id, s, f) { if(s) s(); },
            deleteAllLocations: function(s, f) { if(s) s(); },
            getLogEntries: function() {
                var args = arguments;
                for (var i = 0; i < args.length; i++) if (typeof args[i] === 'function') { args[i]([]); return; }
            },
            startTask:    function(s, f) { if(s) s(0); },
            endTask:      function(k, s, f) { if(s) s(); },
            headlessTask: function(fn, s, f) { if(s) s(); },
            forceSync:    function(s, f) { if(s) s(); },
            isLocationEnabled: function(s, f) { if(s) s(window.BackgroundGeolocation._status.locationServicesEnabled ? 1 : 0); },
        };

        // --- Bluetooth LE ---
        window.bluetoothle = {
            _scanCallback: null,
            initialize: function(success, params) {
                if(success) success({status: 'enabled'});
            },
            isInitialized: function(cb) { if(cb) cb({isInitialized: true}); },
            isEnabled: function(cb) { if(cb) cb({isEnabled: true}); },
            enable: function(s,e) { if(s) s(); },
            startScan: function(success, error, params) {
                window.bluetoothle._scanCallback = success;
                if(success) success({status: 'scanStarted'});
                console.log('[SimBridge] BLE: scanning, waiting for simulated devices...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'ble', action:'scan'}, '*');
            },
            stopScan: function(success, error) {
                window.bluetoothle._scanCallback = null;
                if(success) success({status: 'scanStopped'});
            },
            isScanning: function(cb) { if(cb) cb({isScanning: !!window.bluetoothle._scanCallback}); },
            getAdapterInfo: function(cb) {
                if(cb) cb({name:'Simulated Adapter', address:'00:00:00:00:00:00', isInitialized:true, isEnabled:true, isScanning:false, isDiscoverable:false});
            },
            connect: function(s,e,p) { if(s) s({status:'connected', address:p.address}); },
            disconnect: function(s,e,p) { if(s) s({status:'disconnected', address:p.address}); },
            close: function(s,e,p) { if(s) s({status:'closed'}); },
            discover: function(s,e,p) { if(s) s({status:'discovered', services:[]}); },
            read: function(s,e,p) { if(s) s({status:'read', value:'AAAA'}); },
            write: function(s,e,p) { if(s) s({status:'written'}); },
            subscribe: function(s,e,p) { if(s) s({status:'subscribed'}); },
            unsubscribe: function(s,e,p) { if(s) s({status:'unsubscribed'}); },
        };

        // --- Social Sharing ---
        window.plugins = window.plugins || {};
        window.plugins.socialsharing = {
            share: function(msg, subj, files, url, success, failure) {
                console.log('[SimBridge] Share:', msg, subj, url);
                if(success) success();
            },
            shareViaEmail: function(msg, subj, to, cc, bcc, files, success, failure) {
                console.log('[SimBridge] Email:', msg, subj, to);
                if(success) success();
            },
            shareViaSMS: function(opts, phone, success, failure) {
                console.log('[SimBridge] SMS:', opts, phone);
                if(success) success();
            },
            shareViaWhatsApp: function(msg, files, url, success, failure) {
                console.log('[SimBridge] WhatsApp:', msg);
                if(success) success();
            },
            canShareVia: function(via, msg, subj, files, url, success, failure) {
                if(success) success();
            },
            available: function(cb) { if(cb) cb(true); },
            saveToPhotoAlbum: function(files, s, e) { if(s) s(); },
        };

        // --- InAppBrowser ---
        window.cordova.InAppBrowser = {
            open: function(url, target, options) {
                console.log('[SimBridge] Browser:', url, target);
                if (target === '_system' || target === '_blank') {
                    window.parent.postMessage({type:'cordova-sim-event', plugin:'browser', action:'open', data:{url:url, target:target}}, '*');
                }
                return {
                    addEventListener: function(e,cb) {},
                    removeEventListener: function(e,cb) {},
                    close: function() {},
                    show: function() {},
                    hide: function() {},
                    executeScript: function(d,cb) { if(cb) cb([]); },
                };
            }
        };

        // --- Contacts ---
        window.navigator.contacts = window.navigator.contacts || {
            find: function(fields, success, error, options) {
                bridge._storePending('contacts', 'find', success, error);
                console.log('[SimBridge] Contacts: waiting for simulated contacts...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'contacts', action:'find', data:{filter: options ? options.filter : ''}}, '*');
            },
            pickContact: function(success, error) {
                bridge._storePending('contacts', 'pick', success, error);
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'contacts', action:'pick'}, '*');
            },
            create: function(props) { return props || {}; },
            fieldType: { displayName:'displayName', phoneNumbers:'phoneNumbers', emails:'emails', name:'name' },
        };

        // --- Deep Links ---
        window.universalLinks = {
            _callbacks: {},
            subscribe: function(event, cb) { this._callbacks[event] = cb; },
            unsubscribe: function(event) { delete this._callbacks[event]; },
            checkDeepLink: function(ms) {
                return { then: function(cb) { return { catch: function(e) {} }; } };
            },
        };

        // --- Camera ---
        window.navigator.camera = {
            getPicture: function(success, failure, opts) {
                bridge._storePending('camera', 'photo', success, failure);
                console.log('[SimBridge] Camera: waiting for simulated photo...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'camera', action:'photo'}, '*');
            },
            cleanup: function() {},
            DestinationType: { FILE_URI: 1, DATA_URL: 0 },
            PictureSourceType: { CAMERA: 1, PHOTOLIBRARY: 0 },
        };
        window.Camera = { EncodingType: { JPEG: 0, PNG: 1 } };

        // --- i3 Spinner ---
        window.i3Spinner = {
            show: function(opts, success, error) {
                console.log('[SimBridge] Spinner show:', opts);
                window.parent.postMessage({type:'cordova-sim-event', plugin:'spinner', action:'show', data:opts}, '*');
                if(success) success();
            },
            hide: function(success, error) {
                console.log('[SimBridge] Spinner hide');
                window.parent.postMessage({type:'cordova-sim-event', plugin:'spinner', action:'hide'}, '*');
                if(success) success();
            },
        };

        // --- Fingerprint / Biometrics ---
        window.Fingerprint = {
            isAvailable: function(success, error) {
                bridge._storePending('biometrics', 'available', success, error);
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'biometrics', action:'available'}, '*');
            },
            show: function(params, success, error) {
                bridge._storePending('biometrics', 'auth', success, error);
                console.log('[SimBridge] Biometrics: waiting for simulated auth...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'biometrics', action:'auth'}, '*');
            },
            registerBiometricSecret: function(params, success, error) { if(success) success('registered'); },
            loadBiometricSecret: function(params, success, error) { if(success) success('sim-secret-123'); },
        };

        // --- Device ---
        window.device = {
            platform: 'Simulator', model: 'Desktop Browser', version: '1.0',
            manufacturer: 'Dymico', uuid: 'sim-' + Date.now(), serial: 'SIM000',
            cordova: '12.0.0', isVirtual: true,
        };

        // --- StatusBar ---
        window.StatusBar = {
            show: function() { console.log('[SimBridge] StatusBar show'); },
            hide: function() { console.log('[SimBridge] StatusBar hide'); },
            overlaysWebView: function(v) { console.log('[SimBridge] StatusBar overlay', v); },
            styleDefault: function() {},
            styleLightContent: function() {},
            backgroundColorByName: function(n) {},
            backgroundColorByHexString: function(h) {},
        };

        // --- Battery (navigator.battery is set by cordova-plugin-battery-status) ---
        window.navigator.battery = { level: 75, isPlugged: false };

        // --- Permissions ---
        window.cordova.plugins.permissions = {
            checkPermission: function(perm, success, error) {
                if(success) success({hasPermission: true});
            },
            requestPermission: function(perm, success, error) {
                if(success) success({hasPermission: true});
            },
        };

        // --- Push ---
        window.PushNotification = {
            init: function(opts) {
                var _handlers = {};
                var pushObj = {
                    on: function(event, cb) { _handlers[event] = cb; },
                    _handlers: _handlers,
                };
                // Fire registration after a tick
                setTimeout(function() {
                    if(_handlers.registration) _handlers.registration({registrationId: 'sim-push-token-' + Date.now()});
                }, 500);
                bridge._simPush = pushObj;
                return pushObj;
            }
        };

        // --- Screen Orientation ---
        // screen.orientation is already available in browsers

        // --- SpinnerDialog (legacy fallback) ---
        window.SpinnerDialog = {
            show: function(t,m,c) { window.i3Spinner.show({message: m || t || '', cancelable: !!c}); },
            hide: function() { window.i3Spinner.hide(); },
        };

        // --- Media ---
        window.Media = function(src, onSuccess, onError, onStatus) {
            return {
                startRecord: function() { console.log('[SimBridge] Media record:', src); },
                stopRecord: function() { console.log('[SimBridge] Media stop record'); if(onSuccess) onSuccess(); },
                play: function() { console.log('[SimBridge] Media play:', src); },
                stop: function() { console.log('[SimBridge] Media stop'); },
                release: function() {},
                getDuration: function() { return 0; },
                getCurrentPosition: function(cb) { if(cb) cb(0); },
            };
        };

        console.log('[SimBridge] All fake Cordova plugins registered');
   }
  gSobject['setupMessageListener'] = function(it) {
    return gs.mc(gSobject,"listenForMessages",[]);
   }
  gSobject.listenForMessages = function() {
    var bridge = this;
        window.addEventListener('message', function(event) {
            var msg = event.data;
            if (!msg || msg.type !== 'cordova-sim') return;

            console.log('[SimBridge] Received:', msg.plugin, msg.action, msg.data);

            switch(msg.plugin) {
                case 'scanner':
                    if (msg.action === 'result') bridge._firePending('scanner', 'scan', msg.data);
                    if (msg.action === 'cancel') bridge._firePending('scanner', 'scan', {text:'', format:'', cancelled:true});
                    break;

                case 'gps':
                    if (msg.action === 'location') {
                        bridge._firePending('gps', 'currentLocation', msg.data);
                        var listeners = window.BackgroundGeolocation._listeners['location'] || [];
                        for (var i = 0; i < listeners.length; i++) { listeners[i](msg.data); }
                    }
                    if (msg.action === 'stationary') {
                        var sListeners = window.BackgroundGeolocation._listeners['stationary'] || [];
                        for (var i = 0; i < sListeners.length; i++) { sListeners[i](msg.data); }
                    }
                    if (msg.action === 'activity') {
                        var aListeners = window.BackgroundGeolocation._listeners['activity'] || [];
                        for (var i = 0; i < aListeners.length; i++) { aListeners[i](msg.data); }
                    }
                    if (msg.action === 'geofence') {
                        var fenceEvent = {
                            fenceId:    msg.data.fenceId || msg.data.id,
                            transition: msg.data.transition,
                            location:   msg.data.location || null,
                            data:       msg.data.data || null,
                            timestamp:  msg.data.timestamp || Date.now()
                        };
                        var bgGf = window.BackgroundGeolocation;
                        bgGf._geofenceQueue = bgGf._geofenceQueue || [];
                        bgGf._geofenceQueue.push(fenceEvent);
                        var gListeners = bgGf._listeners['geofence'] || [];
                        for (var i = 0; i < gListeners.length; i++) { gListeners[i](fenceEvent); }
                    }
                    if (msg.action === 'start' || msg.action === 'stop' ||
                        msg.action === 'foreground' || msg.action === 'background' ||
                        msg.action === 'abort_requested') {
                        if (msg.action === 'start') window.BackgroundGeolocation._status.isRunning = true;
                        if (msg.action === 'stop')  window.BackgroundGeolocation._status.isRunning = false;
                        var lListeners = window.BackgroundGeolocation._listeners[msg.action] || [];
                        for (var i = 0; i < lListeners.length; i++) { lListeners[i](msg.data || {}); }
                    }
                    if (msg.action === 'error') {
                        var eListeners = window.BackgroundGeolocation._listeners['error'] || [];
                        for (var i = 0; i < eListeners.length; i++) { eListeners[i](msg.data); }
                    }
                    if (msg.action === 'authorization') {
                        if (msg.data && typeof msg.data.code !== 'undefined') {
                            window.BackgroundGeolocation._status.authorization = msg.data.code;
                        }
                        var auListeners = window.BackgroundGeolocation._listeners['authorization'] || [];
                        for (var i = 0; i < auListeners.length; i++) { auListeners[i](msg.data); }
                    }
                    if (msg.action === 'http_authorization') {
                        var hListeners = window.BackgroundGeolocation._listeners['http_authorization'] || [];
                        for (var i = 0; i < hListeners.length; i++) { hListeners[i](msg.data || {}); }
                    }
                    if (msg.action === 'status') {
                        if (msg.data && typeof msg.data === 'object') {
                            var st = window.BackgroundGeolocation._status;
                            for (var k in msg.data) st[k] = msg.data[k];
                        }
                    }
                    break;

                case 'ble':
                    if (msg.action === 'device' && window.bluetoothle._scanCallback) {
                        window.bluetoothle._scanCallback({status:'scanResult', name:msg.data.name, address:msg.data.address, rssi:msg.data.rssi});
                    }
                    break;

                case 'camera':
                    if (msg.action === 'photo') bridge._firePending('camera', 'photo', msg.data.uri || msg.data);
                    break;

                case 'contacts':
                    if (msg.action === 'results') bridge._firePending('contacts', 'find', msg.data);
                    if (msg.action === 'picked') bridge._firePending('contacts', 'pick', msg.data);
                    break;

                case 'deeplink':
                    if (msg.action === 'trigger') {
                        var dl = window.universalLinks._callbacks;
                        for (var key in dl) { if (dl[key]) dl[key](msg.data); }
                    }
                    break;

                case 'battery':
                    if (msg.action === 'status') {
                        window.navigator.battery = msg.data;
                        var evt = new CustomEvent('batterystatus', {detail: msg.data});
                        window.dispatchEvent(evt);
                    }
                    break;

                case 'network':
                    if (msg.action === 'status') {
                        var evtName = msg.data.online ? 'online' : 'offline';
                        document.dispatchEvent(new Event(evtName));
                    }
                    break;

                case 'biometrics':
                    if (msg.action === 'available') bridge._firePending('biometrics', 'available', msg.data.result || {biometryType:'face'});
                    if (msg.action === 'pass') bridge._firePending('biometrics', 'auth', msg.data || 'success');
                    if (msg.action === 'fail') bridge._firePendingError('biometrics', 'auth', msg.data || 'cancelled');
                    break;

                case 'push':
                    if (msg.action === 'notification' && bridge._simPush && bridge._simPush._handlers.notification) {
                        bridge._simPush._handlers.notification(msg.data);
                    }
                    break;
            }
        });
        console.log('[SimBridge] postMessage listener registered');
   }
  gSobject['fireDeviceReady'] = function(it) {
    return gs.mc(gSobject,"fireDeviceReadyEvent",[]);
   }
  gSobject.fireDeviceReadyEvent = function() {
    // Fire deviceready after a short delay so all plugins are set up
        setTimeout(function() {
            document.dispatchEvent(new Event('deviceready'));
            console.log('[SimBridge] deviceready fired');
        }, 500);
   }
  gSobject._storePending = function(plugin, action, success, error) {
    var key = plugin + ':' + action;
        this.pendingCallbacks[key] = { success: success, error: error };
   }
  gSobject._firePending = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.success) {
            pending.success(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject._firePendingError = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.error) {
            pending.error(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject['CordovaSimBridge0'] = function(it) {
    if (CordovaSimBridge.shouldActivate()) {
      gs.mc(gSobject,"activate",[]);
     };
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaSimBridge0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaSimBridge.shouldActivate = function() {
  // Activate in iframe without real Cordova, or when simulator flag is set by /cordova/header
        return (window.parent !== window) && ((typeof window.cordova === 'undefined') || window.__dymicoSimulator === true);
 }

function I3QrCode() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3QrCode', simpleName: 'I3QrCode'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("text",gs.map().add("default","")).add("width",gs.map().add("default",300)).add("height",gs.map().add("default",300));
  gSobject.qRCodeObject = null;
  gSobject['created'] = function(it) {
    return gSobject.self = this;
   }
  gSobject['afterMounted'] = function(it) {
    if (gs.bool(gs.gp(gSobject.self,"text"))) {
      return gs.mc(gSobject,"generateQrCode",[]);
     };
   }
  gSobject['watchText'] = function(it) {
    if ((gs.bool(gs.gp(gSobject.self,"text"))) && (gs.bool(gs.gp(gSobject.refs,"qrCodeRef")))) {
      return gs.mc(gSobject,"generateQrCode",[]);
     };
   }
  gSobject['generateQrCode'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.refs,"qrCodeRef"))) {
      return null;
     };
    if (gs.bool(gSobject.qRCodeObject)) {
      gs.mc(gSobject.qRCodeObject,"clear",[]);
     };
    gSobject.qRCodeObject = gs.mc(gSobject,"newQrCode",[gs.gp(gSobject.refs,"qrCodeRef"), gs.gp(gSobject.self,"text"), gs.gp(gSobject.self,"width"), gs.gp(gSobject.self,"height")]);
    return gs.mc(gSobject.qRCodeObject,"makeCode",[gs.gp(gSobject.self,"text")]);
   }
  gSobject.newQrCode = function(element, text, width, height) {
    return new QRCode(element, {
            text: text,
            width: width,
            height: height,
            colorDark: '#000000',
            colorLight: '#ffffff',
            correctLevel: QRCode.CorrectLevel.H
        })
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitTemperatureSensorsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitTemperatureSensorsTab', simpleName: 'UnitTemperatureSensorsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaErrorViewer() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CordovaErrorViewer', simpleName: 'CordovaErrorViewer'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/cordovaErrors";
  gSobject.roles = gs.list(["ROLE_DEV_I3"]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"errors",gs.list([]));
    gs.sp(gSobject.scope,"filter",gs.map().add("uuid","").add("user","").add("type",""));
    gs.sp(gSobject.scope,"loading",false);
    gs.sp(gSobject.scope,"total",0);
    gs.sp(gSobject.scope,"selectedError",null);
    return gs.mc(gSobject,"loadErrors",[]);
   }
  gSobject['loadErrors'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    var query = gs.map();
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"filter"),"uuid"))) {
      gs.sp(query,"uuid",gs.gp(gs.gp(gSobject.scope,"filter"),"uuid"));
     };
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"filter"),"user"))) {
      gs.sp(query,"user",gs.gp(gs.gp(gSobject.scope,"filter"),"user"));
     };
    if (gs.bool(gs.gp(gs.gp(gSobject.scope,"filter"),"type"))) {
      gs.sp(query,"type",gs.gp(gs.gp(gSobject.scope,"filter"),"type"));
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"userError"),"find",[query, gs.map().add("sort","_dateCreated").add("order","desc").add("limit",100), function(results) {
      gs.sp(gSobject.scope,"errors",gs.elvis(gs.bool(results) , results , gs.list([])));
      gs.sp(gSobject.scope,"total",gs.mc(gs.gp(gSobject.scope,"errors"),"size",[]));
      return gs.sp(gSobject.scope,"loading",false);
     }]);
   }
  gSobject['clearFilter'] = function(it) {
    gs.sp(gSobject.scope,"filter",gs.map().add("uuid","").add("user","").add("type",""));
    return gs.mc(gSobject,"loadErrors",[]);
   }
  gSobject['selectError'] = function(error) {
    return gs.sp(gSobject.scope,"selectedError",error);
   }
  gSobject['closeDetail'] = function(it) {
    return gs.sp(gSobject.scope,"selectedError",null);
   }
  gSobject['deleteError'] = function(error) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"userError"),"delete",[gs.gp(error,"_id"), function(it) {
      gs.sp(gSobject.scope,"selectedError",null);
      return gs.mc(gSobject,"loadErrors",[]);
     }]);
   }
  gSobject['deleteAll'] = function(it) {
    gs.mc(gs.gp(gSobject.scope,"errors"),"each",[function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"userError"),"delete",[gs.gp(it,"_id")]);
     }]);
    gs.sp(gSobject.scope,"selectedError",null);
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"loadErrors",[]);
     }, 500]);
   }
  gSobject['screenshotUrl'] = function(error) {
    if (!gs.bool(gs.gp(error,"_id",true))) {
      return "";
     };
    return "/media/userError/screenshot/" + (gs.gp(error,"_id")) + "";
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaPhoto() {
  var gSobject = gs.init('CordovaPhoto');
  gSobject.clazz = { name: 'CordovaPhoto', simpleName: 'CordovaPhoto'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['takePhoto'] = function(onSuccess, onFail, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gSobject,"capture",["camera", onSuccess, onFail, config]);
   }
  gSobject['pickFromLibrary'] = function(onSuccess, onFail, config) {
    if (config === undefined) config = gs.map();
    return gs.mc(gSobject,"capture",["library", onSuccess, onFail, config]);
   }
  gSobject['takePhotoBlob'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    var success = function(imageUri) {
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[imageUri, function(blob) {
        gs.execCall(onSuccess, this, [blob]);
        return gs.mc(gSobject,"clearCache",[]);
       }, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['takePhotoAndUpload'] = function(objectName, property, objectId, onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    var success = function(tempImageUrl) {
      return gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[tempImageUrl, objectName, property, objectId, onSuccess, onError]);
     };
    return gs.mc(gSobject,"takePhoto",[success, onError]);
   }
  gSobject['clearCache'] = function(it) {
   }
  gSobject['capture'] = function(source, onSuccess, onFail, config) {
    var opts = gs.mc(gs.map().add("source",source).add("output","fileUri").add("maxWidth",1024).add("maxHeight",1024),'leftShift', gs.list([config]));
    return CordovaPhoto.pick(opts, function(result) {
      return gs.execCall(onSuccess, this, [gs.gp(result,"data")]);
     }, onFail);
   }
  gSobject.pick = function(x0,x1,x2) { return CordovaPhoto.pick(x0,x1,x2); }
  gSobject.isAvailable = function() { return CordovaPhoto.isAvailable(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaPhoto.pick = function(options, onSuccess, onFail) {
  if (typeof cordova === 'undefined' || !cordova.plugins || !cordova.plugins.dymicoPhoto) {
            return onFail('dymico-photo plugin not available');
        }
        cordova.plugins.dymicoPhoto.pick(options, onSuccess, onFail);
 }
CordovaPhoto.isAvailable = function() {
  return ( typeof cordova !== 'undefined' && cordova.plugins && typeof cordova.plugins.dymicoPhoto !== 'undefined' );
 }

function UnitFixHistoryTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitFixHistoryTab', simpleName: 'UnitFixHistoryTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject.self = null;
  gSobject.data = function(it) {
    return gs.map().add("fromDate",null).add("toDate",null).add("fixHistoryRows",gs.list([])).add("loading",false).add("unit",gs.map()).add("totalDistanceText","0").add("showRawJson",false).add("rawJsonContent","").add("rawJsonLoading",false).add("exporting",false).add("pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","recordedAtText").add("descending",true)).add("columns",gs.list([]));
   };
  gSobject['created'] = function(it) {
    gSobject.self = this;
    gs.sp(gSobject.self,"columns",gs.list([gs.map().add("name","actions").add("label","").add("field","actions").add("align","center").add("sortable",false) , gs.map().add("name","recordedAtText").add("label","Date / Time").add("field","recordedAtText").add("align","left").add("sortable",false) , gs.map().add("name","latLngText").add("label","Lat / Lng").add("field","latLngText").add("align","left").add("sortable",false) , gs.map().add("name","distanceText").add("label","Distance (m)").add("field","distanceText").add("align","left").add("sortable",false) , gs.map().add("name","cumulativeDistanceText").add("label","Cumulative dist. (m)").add("field","cumulativeDistanceText").add("align","left").add("sortable",false) , gs.map().add("name","voltageText").add("label","Voltage").add("field","voltageText").add("align","left").add("sortable",false) , gs.map().add("name","tempText").add("label","Temp").add("field","tempText").add("align","left").add("sortable",false) , gs.map().add("name","humidText").add("label","Humid").add("field","humidText").add("align","left").add("sortable",false) , gs.map().add("name","co2Text").add("label","CO2").add("field","co2Text").add("align","left").add("sortable",false) , gs.map().add("name","speedText").add("label","Speed (km/h)").add("field","speedText").add("align","left").add("sortable",false) , gs.map().add("name","geofenceText").add("label","Geofence").add("field","geofenceText").add("align","left").add("sortable",false)]));
    gs.mc(gSobject,"initializeDefaultDateRange",[]);
    gs.mc(gSobject,"loadUnit",[]);
    return gs.mc(gSobject,"loadFixHistory",[]);
   }
  gSobject['resetFilters'] = function(it) {
    gs.mc(gSobject,"initializeDefaultDateRange",[]);
    gs.sp(gs.gp(gSobject.self,"pagination"),"page",1);
    return gs.mc(gSobject,"loadFixHistory",[]);
   }
  gSobject['applyFilters'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"validateDateRange",[]))) {
      return null;
     };
    gs.sp(gs.gp(gSobject.self,"pagination"),"page",1);
    return gs.mc(gSobject,"loadFixHistory",[]);
   }
  gSobject['formatFixDate'] = function(value) {
    if (!gs.bool(value)) {
      return "-";
     };
    var date = (gs.instanceOf(value, "Date") ? value : gs.date(gs.mc(value,"toString",[])));
    return gs.mc(date,"format",["dd/MM/yyyy HH:mm"]);
   }
  gSobject['loadFixHistory'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.sp(gSobject.self,"fixHistoryRows",gs.list([]));
      gs.sp(gSobject.self,"totalDistanceText","0");
      return null;
     };
    gs.sp(gSobject.self,"loading",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"paginatedUnitFixHistory",[gs.gp(gSobject.self,"unitId"), gs.gp(gSobject.self,"fromDate"), gs.gp(gSobject.self,"toDate"), gs.gp(gSobject.self,"pagination"), function(data) {
      var rows = gs.elvis(gs.bool(gs.gp(data,"rows",true)) , gs.gp(data,"rows",true) , gs.list([]));
      gs.sp(gSobject.self,"fixHistoryRows",gs.mc(rows,"collect",[function(row) {
        return gs.mc(gSobject,"mapTableRow",[row]);
       }]));
      gs.sp(gs.gp(gSobject.self,"pagination"),"rowsNumber",gs.elvis(gs.bool(gs.gp(data,"totalRows",true)) , gs.gp(data,"totalRows",true) , 0));
      gs.sp(gSobject.self,"totalDistanceText",gs.mc(gSobject,"formatDistance",[gs.gp(data,"totalDistance",true)]));
      return gs.sp(gSobject.self,"loading",false);
     }]);
   }
  gSobject['onRequest'] = function(props) {
    return gs.mc(gSobject.self,"updatePagination",[gs.gp(props,"pagination")]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.self,"pagination",pagination);
    return gs.mc(gSobject,"loadFixHistory",[]);
   }
  gSobject['loadUnit'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.sp(gSobject.self,"unit",gs.map());
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchOneById",[gs.gp(gSobject.self,"unitId"), function(data) {
      return gs.sp(gSobject.self,"unit",gs.elvis(gs.bool(data) , data , gs.map()));
     }]);
   }
  gSobject['validateDateRange'] = function(it) {
    if ((!gs.bool(gs.gp(gSobject.self,"fromDate"))) || (!gs.bool(gs.gp(gSobject.self,"toDate")))) {
      gs.mc(gSobject,"notify",["Please select both From and To dates", "warning"]);
      return false;
     };
    var from = gs.date(gs.gp(gSobject.self,"fromDate"));
    var to = gs.date(gs.gp(gSobject.self,"toDate"));
    if (gs.mc(to,"before",[from])) {
      gs.mc(gSobject,"notify",["To date must be after From date", "warning"]);
      return false;
     };
    return true;
   }
  gSobject['initializeDefaultDateRange'] = function(it) {
    var today = gs.date();
    var sevenDaysAgo = gs.date(gs.minus(gs.gp(today,"time"), (gs.multiply((gs.multiply((gs.multiply((gs.multiply(6, 24)), 60)), 60)), 1000))));
    gs.sp(gSobject.self,"fromDate",gs.mc(sevenDaysAgo,"format",["yyyy-MM-dd"]));
    return gs.sp(gSobject.self,"toDate",gs.mc(today,"format",["yyyy-MM-dd"]));
   }
  gSobject['formatCoordinate'] = function(value) {
    if (gs.equals(value, null)) {
      return "-";
     };
    var numericValue = value;
    return gs.mc(numericValue,"toFixed",[4]);
   }
  gSobject['formatDistance'] = function(value) {
    if (gs.equals(value, null)) {
      return "-";
     };
    return gs.mc(Math.round(value),"toString",[]);
   }
  gSobject['formatSensorValues'] = function(values) {
    if ((!gs.bool(values)) || (gs.equals(gs.mc(values,"size",[]), 0))) {
      return "-";
     };
    return gs.mc(gs.mc(gs.mc(values,"collect",[function(it) {
      return gs.mc(it,"toString",[], null, true);
     }]),"findAll",[function(it) {
      return (gs.bool(it)) && (gs.mc(it,"trim",[]));
     }]),"join",[", "]);
   }
  gSobject['mapTableRow'] = function(row) {
    return gs.map().add("_id",gs.gp(row,"_id")).add("recordedAtText",gs.mc(gSobject,"formatFixDate",[gs.gp(row,"recordedAt")])).add("latLngText",((gs.gp(row,"lat") != null) && (gs.gp(row,"lng") != null) ? gs.plus((gs.plus(gs.mc(gSobject,"formatCoordinate",[gs.gp(row,"lat")]), " / ")), gs.mc(gSobject,"formatCoordinate",[gs.gp(row,"lng")])) : "-")).add("distanceText",gs.mc(gSobject,"formatDistance",[gs.gp(row,"distance")])).add("cumulativeDistanceText",gs.mc(gSobject,"formatDistance",[gs.gp(row,"cumulativeDistance")])).add("voltageText",((gs.gp(row,"vBat") != null) || (gs.gp(row,"vIn") != null) ? gs.plus((gs.plus((gs.gp(row,"vBat") != null ? gs.gp(row,"vBat") : "-"), " / ")), (gs.gp(row,"vIn") != null ? gs.gp(row,"vIn") : "-")) : "-")).add("tempText",gs.mc(gSobject,"formatSensorValues",[gs.gp(row,"temps")])).add("humidText",gs.mc(gSobject,"formatSensorValues",[gs.gp(row,"humids")])).add("co2Text",gs.mc(gSobject,"formatSensorValues",[gs.gp(row,"co2s")])).add("speedText",(gs.gp(row,"speed") != null ? gs.mc(gs.gp(row,"speed"),"toString",[]) : "-")).add("geofenceText",(gs.bool(gs.gp(row,"geofence"))) || ("n/a"));
   }
  gSobject['exportCsv'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"validateDateRange",[]))) {
      return null;
     };
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.mc(gSobject,"notify",["No unit selected", "warning"]);
      return null;
     };
    gs.sp(gSobject.self,"exporting",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwExportService"),"exportUnitHistoryCsv",[gs.gp(gSobject.self,"unitId"), gs.gp(gSobject.self,"fromDate"), gs.gp(gSobject.self,"toDate"), function(payload) {
      gs.sp(gSobject.self,"exporting",false);
      if (!gs.bool(gs.gp(payload,"content",true))) {
        gs.mc(gSobject,"notify",["No export data was returned", "warning"]);
        return null;
       };
      gs.mc(gSobject,"downloadCsv",[gs.elvis(gs.bool(gs.gp(payload,"fileName")) , gs.gp(payload,"fileName") , "UnitHistory.csv"), gs.gp(payload,"content")]);
      return gs.mc(gSobject,"notify",["CSV exported" + ((gs.gp(payload,"rowCount") != null ? " (" + (gs.gp(payload,"rowCount")) + " rows)" : "")) + "", "positive"]);
     }]);
   }
  gSobject['downloadCsv'] = function(fileName, content) {
    var link = gs.mc(gs.fs('document', this, gSobject),"createElement",["a"]);
    var url = gs.plus("data:text/csv;charset=utf-8,", gs.mc(this,"encodeURIComponent",[gs.elvis(gs.bool(content) , content , "")], gSobject));
    gs.sp(link,"href",url);
    gs.sp(link,"download",fileName);
    gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"appendChild",[link]);
    gs.mc(link,"click",[]);
    return gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"removeChild",[link]);
   }
  gSobject['viewRawJson'] = function(row) {
    gs.sp(gSobject.self,"rawJsonLoading",true);
    gs.sp(gSobject.self,"showRawJson",true);
    gs.sp(gSobject.self,"rawJsonContent","");
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchFixRawData",[gs.gp(row,"_id"), function(data) {
      gs.sp(gSobject.self,"rawJsonLoading",false);
      if (gs.bool(data)) {
        return gs.sp(gSobject.self,"rawJsonContent",gs.mc(gs.fs('JSON', this, gSobject),"stringify",[data, null, 2]));
       } else {
        return gs.sp(gSobject.self,"rawJsonContent","No raw data found for this fix.");
       };
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function PinchToZoomHandler() {
  var gSobject = gs.init('PinchToZoomHandler');
  gSobject.clazz = { name: 'PinchToZoomHandler', simpleName: 'PinchToZoomHandler'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.addPinchToZoomById = function(x0) { return PinchToZoomHandler.addPinchToZoomById(x0); }
  gSobject.addPinchToZoomByElement = function(x0) { return PinchToZoomHandler.addPinchToZoomByElement(x0); }
  gSobject.addPinchToZoomToPdf = function(x0) { return PinchToZoomHandler.addPinchToZoomToPdf(x0); }
  gSobject['PinchToZoomHandler2'] = function(id, type) {
    if (gs.equals(type, "pdf")) {
      return PinchToZoomHandler.addPinchToZoomToPdf(id);
     };
    PinchToZoomHandler.addPinchToZoomById(id);
    return this;
  }
  if (arguments.length==2) {gSobject.PinchToZoomHandler2(arguments[0], arguments[1]); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
PinchToZoomHandler.addPinchToZoomById = function(id) {
  new PinchZoom(document.getElementById(id));
 }
PinchToZoomHandler.addPinchToZoomByElement = function(element) {
  new PinchZoom(element);
 }
PinchToZoomHandler.addPinchToZoomToPdf = function(id) {
  let canvasList = document.getElementById(id).children
        for (let canvas of canvasList) {
            PinchToZoomHandler.addPinchToZoomByElement(canvas);
        }
 }

function CordovaBle() {
  var gSobject = gs.init('CordovaBle');
  gSobject.clazz = { name: 'CordovaBle', simpleName: 'CordovaBle'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'singletonInstance', { get: function() { return CordovaBle.singletonInstance; }, set: function(gSval) { CordovaBle.singletonInstance = gSval; }, enumerable: true });
  gSobject.initialized = false;
  gSobject.scanning = false;
  gSobject.discoveredDevices = gs.map();
  gSobject.connectedDevices = gs.map();
  gSobject.instance = function() { return CordovaBle.instance(); }
  gSobject['initialize'] = function(callback, params) {
    if (callback === undefined) callback = function(it) {
     };
    if (params === undefined) params = gs.map().add("request",true).add("statusReceiver",false);
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBle: bluetoothle not installed"]);
      gs.execCall(callback, this, [gs.map().add("status","unavailable")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"initialize",[function(result) {
        gSobject.initialized = (gs.equals(gs.gp(result,"status"), "enabled"));
        return gs.execCall(callback, this, [result]);
       }, params]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBle.initialize error: " + (gs.fs('e', this, gSobject)) + ""]);
      gs.execCall(callback, this, [gs.map().add("status","error").add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['isEnabled'] = function(callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map().add("isEnabled",false)]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"isEnabled",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("isEnabled",false)]);
     }
    ;
    return this;
   }
  gSobject['enable'] = function(success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(error, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"enable",[success, error]);
     }
    catch (e) {
      gs.execCall(error, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['startScan'] = function(onDevice, onError, params) {
    if (onDevice === undefined) onDevice = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("services",gs.list([])).add("allowDuplicates",false);
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(onError, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    gSobject.discoveredDevices = gs.map();
    gSobject.scanning = true;
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"startScan",[function(result) {
        if (gs.equals(gs.gp(result,"status"), "scanStarted")) {
          return null;
         };
        if (gs.equals(gs.gp(result,"status"), "scanResult")) {
          if (!gs.bool(gs.mc(gSobject.discoveredDevices,"containsKey",[gs.gp(result,"address")]))) {
            var dev = gs.map().add("name",gs.elvis(gs.bool(gs.gp(result,"name")) , gs.gp(result,"name") , "Unknown")).add("address",gs.gp(result,"address")).add("rssi",gs.gp(result,"rssi"));
            (gSobject.discoveredDevices[gs.gp(result,"address")]) = dev;
            return gs.execCall(onDevice, this, [dev]);
           };
         };
       }, function(e) {
        gSobject.scanning = false;
        return gs.execCall(onError, this, [e]);
       }, params]);
     }
    catch (e) {
      gSobject.scanning = false;
      gs.execCall(onError, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['stopScan'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"stopScan",[function(r) {
        gSobject.scanning = false;
        return gs.execCall(callback, this, [r]);
       }, function(e) {
        gSobject.scanning = false;
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }]);
     }
    catch (e) {
      gSobject.scanning = false;
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['isScanning'] = function(callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map().add("isScanning",false)]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"isScanning",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("isScanning",gSobject.scanning)]);
     }
    ;
    return this;
   }
  gSobject['getAdapterInfo'] = function(callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"getAdapterInfo",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['connect'] = function(address, onStatus, onError) {
    if (onStatus === undefined) onStatus = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(onError, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"connect",[function(result) {
        if (gs.equals(gs.gp(result,"status"), "connected")) {
          (gSobject.connectedDevices[address]) = result;
         };
        if (gs.equals(gs.gp(result,"status"), "disconnected")) {
          gs.mc(gSobject.connectedDevices,"remove",[address]);
         };
        return gs.execCall(onStatus, this, [result]);
       }, onError, gs.map().add("address",address)]);
     }
    catch (e) {
      gs.execCall(onError, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['disconnect'] = function(address, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(error, this, [gs.map().add("message","BLE not installed")]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"disconnect",[function(r) {
        gs.mc(gSobject.connectedDevices,"remove",[address]);
        gs.mc(gs.fs('bluetoothle', this, gSobject),"close",[function(it) {
         }, function(it) {
         }, gs.map().add("address",address)]);
        return gs.execCall(success, this, [r]);
       }, error, gs.map().add("address",address)]);
     }
    catch (e) {
      gs.execCall(error, this, [gs.map().add("message","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['discoverServices'] = function(address, callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"discover",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['read'] = function(address, service, characteristic, callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"read",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['write'] = function(address, service, characteristic, value, callback) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"write",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic).add("value",value)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject['subscribe'] = function(address, service, characteristic, onNotify) {
    if (!gs.bool(CordovaBle.bleInstalled())) {
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"subscribe",[onNotify, function(e) {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["subscribe error: " + (e) + ""]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic)]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["subscribe: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
    return this;
   }
  gSobject['unsubscribe'] = function(address, service, characteristic, callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(CordovaBle.bleInstalled())) {
      gs.execCall(callback, this, [gs.map()]);
      return this;
     };
    try {
      gs.mc(gs.fs('bluetoothle', this, gSobject),"unsubscribe",[callback, function(e) {
        return gs.execCall(callback, this, [gs.map().add("error",e)]);
       }, gs.map().add("address",address).add("service",service).add("characteristic",characteristic)]);
     }
    catch (e) {
      gs.execCall(callback, this, [gs.map().add("error","" + (gs.fs('e', this, gSobject)) + "")]);
     }
    ;
    return this;
   }
  gSobject.bleInstalled = function() { return CordovaBle.bleInstalled(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBle.instance = function(it) {
  if (!gs.bool(CordovaBle.singletonInstance)) {
    CordovaBle.singletonInstance = CordovaBle();
   };
  return CordovaBle.singletonInstance;
 }
CordovaBle.bleInstalled = function() {
  return typeof window.bluetoothle !== 'undefined';
 }
CordovaBle.singletonInstance = null;

function CordovaBiometrics() {
  var gSobject = gs.init('CordovaBiometrics');
  gSobject.clazz = { name: 'CordovaBiometrics', simpleName: 'CordovaBiometrics'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.disableBackup = false;
  gSobject.requireStrongBiometrics = false;
  gSobject.storeKeyName = "com.i3";
  gSobject['deviceHasBiometrics'] = function(onSuccess, onError, opts) {
    if (onError === undefined) onError = function(it) {
     };
    if (opts === undefined) opts = gs.map().add("requireStrongBiometrics",gSobject.requireStrongBiometrics);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"isAvailable",[onSuccess, onError, opts]);
   }
  gSobject['showBiometricDialog'] = function(onSuccess, onError, params) {
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("title","Biometric Sign On").add("description","Authenticate").add("subtitle","").add("disableBackup",gSobject.disableBackup).add("requireStrongBiometrics",gSobject.requireStrongBiometrics).add("keyName",gSobject.storeKeyName);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"show",[params, onSuccess, onError]);
   }
  gSobject['registerSecret'] = function(secret, onSuccess, onError, params) {
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("description","Register new biometric").add("invalidateOnEnrollment",true).add("disableBackup",gSobject.disableBackup).add("keyName",gSobject.storeKeyName);
    gs.sp(params,"secret",secret);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"registerBiometricSecret",[params, onSuccess, onError]);
   }
  gSobject['loadSecret'] = function(onSuccess, onError, params) {
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("description","Load biometrics").add("disableBackup",gSobject.disableBackup).add("keyName",gSobject.storeKeyName);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"loadBiometricSecret",[params, onSuccess, onError]);
   }
  gSobject['deleteSecret'] = function(onSuccess, onError, params) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (params === undefined) params = gs.map().add("keyName",gSobject.storeKeyName);
    return gs.mc(gs.fs('Fingerprint', this, gSobject),"deleteBiometricSecret",[params, onSuccess, onError]);
   }
  gSobject.verifyBiometricsPlugin = function() { return CordovaBiometrics.verifyBiometricsPlugin(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBiometrics.verifyBiometricsPlugin = function() {
  return ( window?.Fingerprint !== undefined)
 }

function I3Input() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Input', simpleName: 'I3Input'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("modelValue",gs.map().add("type",String).add("default","")).add("rules",gs.map().add("type",Array).add("default",gs.list([]))).add("mask",gs.map().add("type",String).add("default","")).add("beforeIcon",gs.map().add("type",String).add("default","")).add("prependIcon",gs.map().add("type",String).add("default","")).add("appendIcon",gs.map().add("type",String).add("default","")).add("afterIcon",gs.map().add("type",String).add("default","")).add("prependBtn",gs.map().add("type",String).add("default","")).add("appendBtn",gs.map().add("type",String).add("default",""));
  gSobject.defaults = gs.map().add("filled",true).add("dense",false).add("outlined",false).add("rounded",false).add("borderless",false).add("square",false).add("dense",true).add("debounce","500");
  gSobject.validationRules = gs.map().add("ruleRequired",function(val) {
    return gs.mc(gSobject,"ruleRequired",[val]);
   }).add("ruleEmail",function(val) {
    return gs.mc(gSobject,"ruleEmail",[val]);
   }).add("rulePassword",function(val) {
    return gs.mc(gSobject,"rulePassword",[val]);
   }).add("rulePhone",function(val) {
    return gs.mc(gSobject,"rulePhone",[val]);
   });
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
    var appConfig = gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig")) , gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig") , gs.map());
    var config = (gs.gp(appConfig,"input") != null ? gs.gp(appConfig,"input") : gs.map());
    var attrs = (gs.gp(self,"$attrs") != null ? gs.gp(self,"$attrs") : gs.map());
    return gs.sp(self,"inputProps",gs.toJavascript(gs.plus((gs.plus(gSobject.defaults, config)), attrs)));
   }
  gSobject['update'] = function(val) {
    var self = this;
    gs.mc(self,"$emit",["update:modelValue", val]);
    return gs.mc(self,"$emit",["change"]);
   }
  gSobject['onAppendBtnClick'] = function(it) {
    var self = this;
    return gs.mc(self,"$emit",["append:click"]);
   }
  gSobject['onPrependBtnClick'] = function(it) {
    var self = this;
    return gs.mc(self,"$emit",["prepend:click"]);
   }
  gSobject['ruleRequired'] = function(val) {
    return (gs.mc(gs.mc(val,"toString",[], null, true),"trim",[], null, true) ? true : "Field Required");
   }
  gSobject['ruleEmail'] = function(val) {
    var emailPattern = "^(?=[a-zA-Z0-9@._%+-]{6,254}$)[a-zA-Z0-9._%+-]{1,64}@(?:[a-zA-Z0-9-]{1,63}\.){1,8}[a-zA-Z]{2,63}$";
    return (gs.exactMatch(val,emailPattern) ? true : "Invalid Email");
   }
  gSobject['rulePassword'] = function(val) {
    return (gs.mc(gs.mc(gs.mc(val,"toString",[]),"trim",[]),"size",[]) >= 6 ? true : "Password Error Message");
   }
  gSobject['rulePhone'] = function(val) {
    if (!gs.bool(gs.mc(gs.mc(val,"toString",[], null, true),"trim",[], null, true))) {
      return true;
     };
    var cleaned = gs.mc(gs.mc(gs.mc(gs.mc(gs.mc(gs.mc(val,"toString",[]),"trim",[]),"replace",[" ", ""]),"replace",["-", ""]),"replace",["(", ""]),"replace",[")", ""]);
    if (gs.mc(cleaned,"startsWith",["+"])) {
      var digits = gs.mc(cleaned,"substring",[1]);
      return (gs.exactMatch(digits,/^[0-9]{7,15}$/) ? true : "Invalid Phone Number");
     };
    if (gs.mc(cleaned,"startsWith",["0"])) {
      return (gs.exactMatch(cleaned,/^[0-9]{10}$/) ? true : "Invalid Phone Number");
     };
    return "Invalid Phone Number";
   }
  gSobject['calcRules'] = function(rules) {
    return (gs.bool(rules) ? gs.mc(rules,"collect",[function(ruleName) {
      return gSobject.validationRules[ruleName];
     }]) : gs.list([]));
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitCarbonDioxideReadingsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitCarbonDioxideReadingsTab', simpleName: 'UnitCarbonDioxideReadingsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject.self = null;
  gSobject.data = function(it) {
    return gs.map().add("sensorReadings",gs.list([])).add("highestCo2",null).add("lowestCo2",null).add("selectedTimeframe","5min").add("historyLabels",gs.list([])).add("historyDatasets",gs.list([]));
   };
  gSobject['created'] = function(it) {
    gSobject.self = this;
    gs.mc(gSobject,"loadMeasurements",[]);
    return gs.mc(gSobject,"loadSampleHistoryData",[]);
   }
  gSobject['loadHistoryTimeframe'] = function(timeframe) {
    gs.sp(gSobject.self,"selectedTimeframe",timeframe);
    return gs.mc(gSobject,"loadSampleHistoryData",[]);
   }
  gSobject['loadSampleHistoryData'] = function(it) {
    var sampleByTimeframe = gs.map().add("5min",gs.map().add("labels",gs.list(["-5m" , "-4m" , "-3m" , "-2m" , "-1m" , "Now"])).add("datasets",gs.list([gs.list([620.0 , 622.0 , 619.0 , 621.0 , 623.0 , 621.0]) , gs.list([855.0 , 857.0 , 860.0 , 858.0 , 856.0 , 859.0]) , gs.list([510.0 , 512.0 , 511.0 , 513.0 , 510.0 , 512.0])]))).add("1hour",gs.map().add("labels",gs.list(["-60m" , "-50m" , "-40m" , "-30m" , "-20m" , "-10m" , "Now"])).add("datasets",gs.list([gs.list([610.0 , 613.0 , 616.0 , 618.0 , 620.0 , 621.0 , 621.0]) , gs.list([840.0 , 845.0 , 849.0 , 852.0 , 855.0 , 857.0 , 859.0]) , gs.list([500.0 , 503.0 , 506.0 , 508.0 , 510.0 , 511.0 , 512.0])]))).add("8hours",gs.map().add("labels",gs.list(["-8h" , "-7h" , "-6h" , "-5h" , "-4h" , "-3h" , "-2h" , "-1h" , "Now"])).add("datasets",gs.list([gs.list([580.0 , 588.0 , 595.0 , 601.0 , 607.0 , 612.0 , 616.0 , 619.0 , 621.0]) , gs.list([800.0 , 812.0 , 820.0 , 829.0 , 836.0 , 843.0 , 849.0 , 854.0 , 859.0]) , gs.list([476.0 , 483.0 , 489.0 , 494.0 , 499.0 , 504.0 , 507.0 , 510.0 , 512.0])]))).add("24hours",gs.map().add("labels",gs.list(["-24h" , "-21h" , "-18h" , "-15h" , "-12h" , "-9h" , "-6h" , "-3h" , "Now"])).add("datasets",gs.list([gs.list([540.0 , 552.0 , 562.0 , 571.0 , 579.0 , 588.0 , 597.0 , 610.0 , 621.0]) , gs.list([750.0 , 765.0 , 778.0 , 790.0 , 803.0 , 817.0 , 830.0 , 845.0 , 859.0]) , gs.list([445.0 , 455.0 , 463.0 , 471.0 , 479.0 , 487.0 , 495.0 , 503.0 , 512.0])])));
    var selected = gs.elvis(sampleByTimeframe[gs.gp(gSobject.self,"selectedTimeframe")] , sampleByTimeframe[gs.gp(gSobject.self,"selectedTimeframe")] , sampleByTimeframe["5min"]);
    gs.sp(gSobject.self,"historyLabels",gs.gp(selected,"labels"));
    return gs.sp(gSobject.self,"historyDatasets",gs.gp(selected,"datasets"));
   }
  gSobject['loadMeasurements'] = function(it) {
    gs.println("CO2 unitId=" + (gs.gp(gSobject.self,"unitId")) + "");
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwMeasurementService"),"fetchLatestMeasurementsByType",[gs.gp(gSobject.self,"unitId"), "co2", function(result) {
      gs.println("CO2 result");
      gs.println(result);
      var list = gs.elvis(gs.bool(result) , result , gs.list([]));
      var co2Values = gs.mc(gs.mc(list,"collect",[function(it) {
        return gs.gp(gs.gp(it,"data",true),"currentCo2",true);
       }]),"findAll",[function(value) {
        return value != null;
       }]);
      gs.sp(gSobject.self,"highestCo2",(gs.bool(co2Values) ? gs.mc(co2Values,"max",[]) : null));
      gs.sp(gSobject.self,"lowestCo2",(gs.bool(co2Values) ? gs.mc(co2Values,"min",[]) : null));
      gs.sp(gSobject.self,"sensorReadings",gs.mc(list,"collect",[function(it) {
        return gs.map().add("id",gs.gp(it,"_id",true)).add("sensorId",gs.gp(gs.gp(it,"sensor",true),"_id",true)).add("snoozed",gs.elvis(gs.bool(gs.gp(it,"snoozed",true)) , gs.gp(it,"snoozed",true) , false)).add("sensorName",gs.elvis(gs.bool(gs.gp(gs.gp(it,"sensor",true),"name",true)) , gs.gp(gs.gp(it,"sensor",true),"name",true) , "-")).add("currentCo2",gs.gp(gs.gp(it,"data",true),"currentCo2",true)).add("low",gs.gp(gs.gp(gs.gp(it,"sensorProfile",true),"profile",true),"low",true)).add("high",gs.gp(gs.gp(gs.gp(it,"sensorProfile",true),"profile",true),"high",true)).add("lowWarn",gs.gp(gs.gp(gs.gp(it,"sensorProfile",true),"profile",true),"lowWarn",true)).add("highWarn",gs.gp(gs.gp(gs.gp(it,"sensorProfile",true),"profile",true),"highWarn",true));
       }]));
      gs.println("CO2 sensorReadings");
      return gs.println(gs.gp(gSobject.self,"sensorReadings"));
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwBrowser() {
  var gSobject = gs.init('CwBrowser');
  gSobject.clazz = { name: 'CwBrowser', simpleName: 'CwBrowser'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.reloadToRoot = function() { return CwBrowser.reloadToRoot(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CwBrowser.reloadToRoot = function() {
  console.log('[CwBrowser] reloadToRoot running, pathname=' + window.location.pathname);
        if (window.location.pathname === '/') {
            window.location.reload();
        } else {
            window.location.href = '/';
        }
 }

function VueListSearchComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueListSearchComponent', simpleName: 'VueListSearchComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.toJavascript(gs.list(["value" , "onFilter" , "onSelect" , "label" , "options" , "outlined" , "filled" , "standout" , "borderless" , "square" , "dark" , "clearable" , "required" , "style" , "onLabel" , "optionLabel"]));
  gSobject.data = function(it) {
    var self = this;
    return gs.map().add("objectValue",gs.gp(self,"value")).add("optionsList",gs.list([])).add("initOptions",gs.gp(self,"options")).add("optionLabelValue",gs.elvis(gs.bool(gs.gp(self,"optionLabel")) , gs.gp(self,"optionLabel") , "name"));
   };
  gSobject['mounted'] = function(it) {
    var self = this;
   }
  gSobject['watchValue'] = function(newValue, oldValue) {
    var self = this;
    return gs.sp(self,"objectValue",newValue);
   }
  gSobject['lookupObjects'] = function(val, update, abort) {
    if (val === undefined) val = null;
    if (update === undefined) update = function(it) {
      return gs.execCall(it, this, []);
     };
    if (abort === undefined) abort = null;
    var self = this;
    if (gs.bool(gs.gp(self,"options"))) {
      gs.execCall(update, this, [function(it) {
        gs.sp(self,"optionsList",gs.gp(self,"options"));
        return gs.mc(gSobject,"configLabel",[self]);
       }]);
      return null;
     };
    return gs.mc(self,"onFilter",[val, function(dbOptionsList) {
      return gs.execCall(update, this, [function(it) {
        gs.sp(self,"optionsList",dbOptionsList);
        return gs.mc(gSobject,"configLabel",[self]);
       }]);
     }]);
   }
  gSobject['configLabel'] = function(self) {
    if (gs.bool(gs.gp(self,"onLabel"))) {
      return gs.sp(self,"optionLabel",gs.gp(self,"onLabel"));
     };
   }
  gSobject['objectSelected'] = function(it) {
    var self = this;
    gs.mc(self,"$emit",["input", gs.gp(self,"objectValue")]);
    if (gs.bool(gs.gp(self,"onSelect"))) {
      return gs.mc(self,"onSelect",[gs.gp(self,"objectValue")]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3SidePanel() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3SidePanel', simpleName: 'I3SidePanel'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("modelValue",gs.map().add("type",String)).add("position",gs.map().add("type",String).add("default","right"));
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitEventsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitEventsTab', simpleName: 'UnitEventsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["unitId"]);
  gSobject.self = null;
  gSobject.pollingTimer = null;
  gSobject.data = function(it) {
    return gs.map().add("activeEvents",gs.list([])).add("activeEventsExpanded",true).add("eventExpandedMap",gs.map()).add("eventSearch","").add("selectedSeverity","all").add("selectedStatus","active").add("selectedSensorProfile","all").add("severityFilterOptions",gs.list([gs.map().add("label","All Severities").add("value","all") , gs.map().add("label","Alarms Only").add("value","alarm") , gs.map().add("label","Warnings Only").add("value","warning")])).add("statusFilterOptions",gs.list([gs.map().add("label","All Statuses").add("value","all") , gs.map().add("label","Active").add("value","active") , gs.map().add("label","Acknowledged").add("value","acknowledged") , gs.map().add("label","Snoozed").add("value","snoozed") , gs.map().add("label","Resolved").add("value","resolved") , gs.map().add("label","Auto-Resolved").add("value","system-auto-resolved")])).add("statusOptions",gs.list([gs.map().add("label","Acknowledged").add("value","acknowledged") , gs.map().add("label","Snoozed").add("value","snoozed") , gs.map().add("label","Resolved").add("value","resolved")])).add("resolvedEvents",gs.list([])).add("resolvedEventsExpanded",true).add("resolvedEventExpandedMap",gs.map()).add("resolvedEventLimit",25).add("resolvedEventLimitOptions",gs.list([gs.map().add("label","25 Events").add("value",25) , gs.map().add("label","50 Events").add("value",50) , gs.map().add("label","100 Events").add("value",100)])).add("skeletonRows",gs.list([1 , 2 , 3])).add("isLoading",false).add("canEdit",false);
   };
  gSobject['created'] = function(it) {
    gSobject.self = this;
    if (gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"])) {
      gs.sp(gSobject.self,"canEdit",true);
     } else {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"isUnitOrgAdmin",[gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.self,"unitId"), function(admin) {
        return gs.sp(gSobject.self,"canEdit",admin);
       }]);
     };
    gs.mc(gSobject,"loadEvents",[]);
    return gSobject.pollingTimer = gs.execStatic(Utils,'setInterval', this,[function(it) {
      return gs.mc(gSobject,"loadEvents",[]);
     }, 60000]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
   }
  gSobject['loadEvents'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.mc(gSobject,"clearEvents",[]);
      gs.sp(gSobject.self,"isLoading",false);
      return null;
     };
    gs.sp(gSobject.self,"isLoading",true);
    gs.mc(gSobject,"clearEvents",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAlertService"),"fetchUnitEvents",[gs.gp(gSobject.self,"unitId"), gs.gp(gSobject.self,"resolvedEventLimit"), function(payload) {
      gs.sp(gSobject.self,"activeEvents",gs.elvis(gs.bool(gs.gp(payload,"activeEvents",true)) , gs.gp(payload,"activeEvents",true) , gs.list([])));
      gs.sp(gSobject.self,"resolvedEvents",gs.elvis(gs.bool(gs.gp(payload,"resolvedEvents",true)) , gs.gp(payload,"resolvedEvents",true) , gs.list([])));
      gs.mc(gSobject,"rebuildExpandedMaps",[]);
      return gs.sp(gSobject.self,"isLoading",false);
     }]);
   }
  gSobject['rebuildExpandedMaps'] = function(it) {
    var activeMap = gs.map();
    gs.mc(gs.gp(gSobject.self,"activeEvents"),"each",[function(event) {
      return (activeMap[gs.gp(event,"_id")]) = gs.elvis(gs.gp(gSobject.self,"eventExpandedMap")[gs.gp(event,"_id")] , gs.gp(gSobject.self,"eventExpandedMap")[gs.gp(event,"_id")] , false);
     }]);
    gs.sp(gSobject.self,"eventExpandedMap",activeMap);
    var resolvedMap = gs.map();
    gs.mc(gs.gp(gSobject.self,"resolvedEvents"),"each",[function(event) {
      return (resolvedMap[gs.gp(event,"_id")]) = (gs.mc(gs.gp(gSobject.self,"resolvedEventExpandedMap"),"containsKey",[gs.gp(event,"_id")]) ? gs.gp(gSobject.self,"resolvedEventExpandedMap")[gs.gp(event,"_id")] : false);
     }]);
    return gs.sp(gSobject.self,"resolvedEventExpandedMap",resolvedMap);
   }
  gSobject['clearEvents'] = function(it) {
    gs.sp(gSobject.self,"activeEvents",gs.list([]));
    gs.sp(gSobject.self,"eventExpandedMap",gs.map());
    gs.sp(gSobject.self,"resolvedEvents",gs.list([]));
    return gs.sp(gSobject.self,"resolvedEventExpandedMap",gs.map());
   }
  gSobject['formatEventDate'] = function(dateValue) {
    if (!gs.bool(dateValue)) {
      return "";
     };
    var date = (gs.instanceOf(dateValue, "Date") ? dateValue : gs.date(gs.mc(dateValue,"toString",[])));
    return gs.mc(date,"format",["dd/MM/yyyy HH:mm"]);
   }
  gSobject['refreshEvents'] = function(it) {
    return gs.mc(gSobject,"loadEvents",[]);
   }
  gSobject['joinedEventSummary'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"filteredActiveEvents",[]))) {
      return "";
     };
    return gs.mc(gs.mc(gs.mc(gSobject,"filteredActiveEvents",[]),"collect",[function(it) {
      return gs.gp(it,"summary");
     }]),"join",["; "]);
   }
  gSobject['activeSeverityCount'] = function(severity) {
    return gs.mc(gs.mc(gSobject,"filteredActiveEvents",[]),"count",[function(it) {
      return gs.equals(gs.mc(gSobject,"normalizedSeverity",[gs.gp(it,"severity",true)]), gs.mc(gSobject,"normalizedSeverity",[severity]));
     }]);
   }
  gSobject['activeLatestTimestamp'] = function(it) {
    var events = gs.mc(gs.mc(gSobject,"filteredActiveEvents",[]),"findAll",[function(it) {
      return gs.gp(it,"startedAt",true);
     }]);
    if (!gs.bool(events)) {
      return "";
     };
    var latestEvent = gs.mc(events,"max",[function(it) {
      return gs.gp(it,"startedAt");
     }]);
    return (gs.bool(gs.gp(latestEvent,"startedAt",true)) ? gs.mc(gSobject,"formatEventDate",[gs.gp(latestEvent,"startedAt")]) : "");
   }
  gSobject['filteredActiveEvents'] = function(it) {
    return gs.mc(gSobject,"applyEventFilters",[gs.elvis(gs.bool(gs.gp(gSobject.self,"activeEvents")) , gs.gp(gSobject.self,"activeEvents") , gs.list([])), false]);
   }
  gSobject['filteredAllEvents'] = function(it) {
    var actives = gs.mc(gs.mc(gSobject,"applyEventFilters",[gs.elvis(gs.bool(gs.gp(gSobject.self,"activeEvents")) , gs.gp(gSobject.self,"activeEvents") , gs.list([])), false]),"sort",[function(a, b) {
      var aDate = gs.elvis(gs.bool(gs.gp(a,"lastTriggeredAt",true)) , gs.gp(a,"lastTriggeredAt",true) , gs.elvis(gs.bool(gs.gp(a,"startedAt",true)) , gs.gp(a,"startedAt",true) , gs.date(0)));
      var bDate = gs.elvis(gs.bool(gs.gp(b,"lastTriggeredAt",true)) , gs.gp(b,"lastTriggeredAt",true) , gs.elvis(gs.bool(gs.gp(b,"startedAt",true)) , gs.gp(b,"startedAt",true) , gs.date(0)));
      return gs.mc(bDate,"compareTo",[aDate]);
     }]);
    var resolveds = gs.mc(gs.mc(gSobject,"applyEventFilters",[gs.elvis(gs.bool(gs.gp(gSobject.self,"resolvedEvents")) , gs.gp(gSobject.self,"resolvedEvents") , gs.list([])), false]),"sort",[function(a, b) {
      var aDate = gs.elvis(gs.bool(gs.gp(a,"resolvedAt",true)) , gs.gp(a,"resolvedAt",true) , gs.elvis(gs.bool(gs.gp(a,"startedAt",true)) , gs.gp(a,"startedAt",true) , gs.date(0)));
      var bDate = gs.elvis(gs.bool(gs.gp(b,"resolvedAt",true)) , gs.gp(b,"resolvedAt",true) , gs.elvis(gs.bool(gs.gp(b,"startedAt",true)) , gs.gp(b,"startedAt",true) , gs.date(0)));
      return gs.mc(bDate,"compareTo",[aDate]);
     }]);
    return gs.plus(actives, resolveds);
   }
  gSobject['filteredActiveCount'] = function(it) {
    return gs.mc(gs.mc(gSobject,"filteredActiveEvents",[]),"size",[]);
   }
  gSobject['sensorProfileFilterOptions'] = function(it) {
    var options = gs.list([gs.map().add("label","All Sensor Profiles").add("value","all")]);
    var seen = gs.set(gs.list([]));
    gs.mc(gs.plus(gs.elvis(gs.bool(gs.gp(gSobject.self,"activeEvents")) , gs.gp(gSobject.self,"activeEvents") , gs.list([])), gs.elvis(gs.bool(gs.gp(gSobject.self,"resolvedEvents")) , gs.gp(gSobject.self,"resolvedEvents") , gs.list([]))),"each",[function(event) {
      var name = gs.mc(gs.mc(gs.gp(gs.gp(event,"sensorProfile",true),"name",true),"toString",[], null, true),"trim",[], null, true);
      if ((!gs.bool(name)) || (gs.mc(seen,"contains",[name]))) {
        return null;
       };
      gs.mc(seen,'leftShift', gs.list([name]));
      return gs.mc(options,'leftShift', gs.list([gs.map().add("label",name).add("value",name)]));
     }]);
    return gs.mc(options,"sort",[function(a, b) {
      if (gs.equals(gs.gp(a,"value"), "all")) {
        return -1;
       };
      if (gs.equals(gs.gp(b,"value"), "all")) {
        return 1;
       };
      return gs.spaceShip(gs.gp(a,"label"), gs.gp(b,"label"));
     }]);
   }
  gSobject['filteredResolvedCount'] = function(it) {
    return gs.mc(gs.mc(gSobject,"applyEventFilters",[gs.elvis(gs.bool(gs.gp(gSobject.self,"resolvedEvents")) , gs.gp(gSobject.self,"resolvedEvents") , gs.list([])), false]),"size",[]);
   }
  gSobject['isSensorProfileFilterActive'] = function(it) {
    return (gs.bool(gs.gp(gSobject.self,"selectedSensorProfile"))) && (gs.gp(gSobject.self,"selectedSensorProfile") != "all");
   }
  gSobject['everyLastUpdatedBySystem'] = function(it) {
    var events = gs.mc(gSobject,"filteredAllEvents",[]);
    if (!gs.bool(events)) {
      return true;
     };
    return gs.mc(events,"every",[function(event) {
      var actor = gs.mc(gs.mc(gs.mc(gs.elvis(gs.mc(gSobject,"latestLogSummary",[event]) , gs.mc(gSobject,"latestLogSummary",[event]) , ""),"toString",[]),"trim",[]),"toLowerCase",[]);
      return (!gs.bool(actor)) || (gs.equals(actor, "system"));
     }]);
   }
  gSobject['formatOpenFor'] = function(fromDate) {
    if (!gs.bool(fromDate)) {
      return "";
     };
    var from = (gs.instanceOf(fromDate, "Date") ? fromDate : gs.date(gs.mc(fromDate,"toString",[])));
    var diffMs = gs.minus(gs.gp(gs.date(),"time"), gs.gp(from,"time"));
    if (diffMs < 0) {
      diffMs = 0;
     };
    var mins = Math.floor(gs.div(diffMs, 60000));
    var days = Math.floor(gs.div(mins, 1440));
    var hours = Math.floor(gs.div((gs.mod(mins, 1440)), 60));
    var remMins = Math.floor(gs.mod(mins, 60));
    if (days > 0) {
      return gs.mc("Open " + (days) + "d " + (hours) + "h","toString",[]);
     };
    if (hours > 0) {
      return gs.mc("Open " + (hours) + "h " + (remMins) + "m","toString",[]);
     };
    return gs.mc("Open " + (remMins) + "m","toString",[]);
   }
  gSobject['oldestActiveOpenFor'] = function(it) {
    var actives = gs.mc(gSobject,"filteredActiveEvents",[]);
    if (!gs.bool(actives)) {
      return "";
     };
    var oldest = gs.mc(gs.mc(actives,"findAll",[function(it) {
      return gs.gp(it,"startedAt",true);
     }]),"sort",[function(a, b) {
      return gs.spaceShip(gs.gp(a,"startedAt"), gs.gp(b,"startedAt"));
     }])[0];
    return (gs.bool(oldest) ? gs.mc(gSobject,"formatOpenFor",[gs.gp(oldest,"startedAt")]) : "");
   }
  gSobject['openForLabel'] = function(event) {
    if ((!gs.bool(event)) || (gs.bool(gs.gp(event,"isResolved")))) {
      return "";
     };
    return gs.mc(gSobject,"formatOpenFor",[gs.elvis(gs.bool(gs.gp(event,"startedAt")) , gs.gp(event,"startedAt") , gs.gp(event,"lastTriggeredAt"))]);
   }
  gSobject['isRecovering'] = function(event) {
    return ((gs.bool(event)) && (!gs.bool(gs.gp(event,"isResolved")))) && (gs.bool(gs.gp(event,"recoveringSince")));
   }
  gSobject['recoveringLabel'] = function(event) {
    if (!gs.bool(gs.mc(gSobject,"isRecovering",[event]))) {
      return "";
     };
    var from = (gs.instanceOf(gs.gp(event,"recoveringSince"), "Date") ? gs.gp(event,"recoveringSince") : gs.date(gs.mc(gs.gp(event,"recoveringSince"),"toString",[])));
    var diffMs = gs.minus(gs.gp(gs.date(),"time"), gs.gp(from,"time"));
    if (diffMs < 0) {
      diffMs = 0;
     };
    var mins = Math.floor(gs.div(diffMs, 60000));
    if (mins < 60) {
      return gs.mc("Recovering " + (mins) + "m","toString",[]);
     };
    var hours = Math.floor(gs.div(mins, 60));
    var remMins = Math.floor(gs.mod(mins, 60));
    return gs.mc("Recovering " + (hours) + "h " + (remMins) + "m","toString",[]);
   }
  gSobject['filteredEventCount'] = function(it) {
    return gs.mc(gs.mc(gSobject,"filteredAllEvents",[]),"size",[]);
   }
  gSobject['visibleEvents'] = function(it) {
    return gs.mc(gSobject,"filteredAllEvents",[]);
   }
  gSobject['hasAnyEvents'] = function(it) {
    return (gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.self,"activeEvents")) , gs.gp(gSobject.self,"activeEvents") , gs.list([])),"size",[]) > 0) || (gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.self,"resolvedEvents")) , gs.gp(gSobject.self,"resolvedEvents") , gs.list([])),"size",[]) > 0);
   }
  gSobject['isEventExpanded'] = function(event) {
    if (!gs.bool(gs.gp(event,"_id",true))) {
      return false;
     };
    return (gs.bool(gs.gp(event,"isResolved")) ? gs.elvis(gs.gp(gSobject.self,"resolvedEventExpandedMap")[gs.gp(event,"_id")] , gs.gp(gSobject.self,"resolvedEventExpandedMap")[gs.gp(event,"_id")] , false) : gs.elvis(gs.gp(gSobject.self,"eventExpandedMap")[gs.gp(event,"_id")] , gs.gp(gSobject.self,"eventExpandedMap")[gs.gp(event,"_id")] , false));
   }
  gSobject['setEventExpanded'] = function(event, expanded) {
    if (!gs.bool(gs.gp(event,"_id",true))) {
      return null;
     };
    if (gs.bool(gs.gp(event,"isResolved"))) {
      return gs.sp(gSobject.self,"resolvedEventExpandedMap",(gs.plus(gs.gp(gSobject.self,"resolvedEventExpandedMap"), gs.map().add(gs.gp(event,"_id"),expanded))));
     } else {
      return gs.sp(gSobject.self,"eventExpandedMap",(gs.plus(gs.gp(gSobject.self,"eventExpandedMap"), gs.map().add(gs.gp(event,"_id"),expanded))));
     };
   }
  gSobject['hasActiveFilters'] = function(it) {
    return (((gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.self,"eventSearch")) , gs.gp(gSobject.self,"eventSearch") , ""),"trim",[])) || (gs.gp(gSobject.self,"selectedSeverity") != "all")) || (gs.gp(gSobject.self,"selectedStatus") != "all")) || (gs.gp(gSobject.self,"selectedSensorProfile") != "all");
   }
  gSobject['resetFilters'] = function(it) {
    gs.sp(gSobject.self,"eventSearch","");
    gs.sp(gSobject.self,"selectedSeverity","all");
    gs.sp(gSobject.self,"selectedStatus","all");
    return gs.sp(gSobject.self,"selectedSensorProfile","all");
   }
  gSobject['applyEventFilters'] = function(events, resolvedView) {
    var searchText = gs.mc(gs.mc(gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.self,"eventSearch")) , gs.gp(gSobject.self,"eventSearch") , ""),"toString",[]),"trim",[]),"toLowerCase",[]);
    return gs.mc(gs.elvis(gs.bool(events) , events , gs.list([])),"findAll",[function(event) {
      var severity = gs.mc(gSobject,"normalizedSeverity",[gs.gp(event,"severity",true)]);
      var status = gs.mc(gSobject,"normalizedStatus",[event, resolvedView]);
      var sensorProfileName = gs.elvis(gs.mc(gs.mc(gs.gp(gs.gp(event,"sensorProfile",true),"name",true),"toString",[], null, true),"trim",[], null, true) , gs.mc(gs.mc(gs.gp(gs.gp(event,"sensorProfile",true),"name",true),"toString",[], null, true),"trim",[], null, true) , "");
      var haystack = gs.mc(gs.mc(gs.mc(gs.list([gs.gp(event,"summary",true) , gs.gp(gs.gp(event,"sensorProfile",true),"name",true) , gs.gp(event,"status",true) , gs.gp(event,"severity",true) , gs.gp(gs.mc(gs.gp(event,"eventLogs",true),"find",[function(it) {
        return gs.gp(it,"comment",true);
       }], null, true),"comment",true)]),"findAll",[function(it) {
        return it != null;
       }]),"collect",[function(it) {
        return gs.mc(gs.mc(it,"toString",[]),"toLowerCase",[]);
       }]),"join",[" "]);
      var matchesSearch = (!gs.bool(searchText)) || (gs.mc(haystack,"contains",[searchText]));
      var matchesSeverity = (gs.equals(gs.gp(gSobject.self,"selectedSeverity"), "all")) || (gs.equals(severity, gs.gp(gSobject.self,"selectedSeverity")));
      var matchesStatus = (gs.equals(gs.gp(gSobject.self,"selectedStatus"), "all")) || (gs.equals(status, gs.gp(gSobject.self,"selectedStatus")));
      var matchesSensorProfile = (gs.equals(gs.gp(gSobject.self,"selectedSensorProfile"), "all")) || (gs.equals(sensorProfileName, gs.gp(gSobject.self,"selectedSensorProfile")));
      return (((gs.bool(matchesSearch)) && (gs.bool(matchesSeverity))) && (gs.bool(matchesStatus))) && (gs.bool(matchesSensorProfile));
     }]);
   }
  gSobject['normalizedSeverity'] = function(severity) {
    return gs.mc(gs.mc(gs.elvis(gs.bool(severity) , severity , "warning"),"toString",[]),"toLowerCase",[]);
   }
  gSobject['normalizedStatus'] = function(event, resolvedView) {
    if (resolvedView === undefined) resolvedView = false;
    var raw = gs.mc(gs.mc(gs.elvis(gs.bool(gs.gp(event,"status",true)) , gs.gp(event,"status",true) , ""),"toString",[]),"toLowerCase",[]);
    if (gs.equals(raw, "system-auto-resolved")) {
      return "system-auto-resolved";
     };
    if ((gs.bool(resolvedView)) || (gs.bool(gs.gp(event,"isResolved",true)))) {
      return "resolved";
     };
    return gs.elvis(gs.bool(raw) , raw , "active");
   }
  gSobject['severityChipColor'] = function(severity) {
    var gSswitch0 = gs.mc(gs.mc(gs.elvis(gs.bool(severity) , severity , ""),"toString",[]),"toLowerCase",[]);
    if (gs.equals(gSswitch0, "alarm")) {
      return "negative";
     } else if (gs.equals(gSswitch0, "warning")) {
      return "warning";
     } else {
      return "grey-7";
     };
   }
  gSobject['severityChipTextColor'] = function(severity, resolved) {
    if (resolved === undefined) resolved = false;
    if (gs.bool(resolved)) {
      return "white";
     };
    var gSswitch0 = gs.mc(gs.mc(gs.elvis(gs.bool(severity) , severity , ""),"toString",[]),"toLowerCase",[]);
    if (gs.equals(gSswitch0, "warning")) {
      return "grey-10";
     } else {
      return "white";
     };
   }
  gSobject['severityIcon'] = function(severity) {
    var gSswitch0 = gs.mc(gs.mc(gs.elvis(gs.bool(severity) , severity , ""),"toString",[]),"toLowerCase",[]);
    if (gs.equals(gSswitch0, "alarm")) {
      return "o_error";
     } else if (gs.equals(gSswitch0, "warning")) {
      return "o_warning_amber";
     } else {
      return "o_notifications";
     };
   }
  gSobject['statusChipColor'] = function(status) {
    var gSswitch0 = gs.mc(gs.mc(gs.elvis(gs.bool(status) , status , ""),"toString",[]),"toLowerCase",[]);
    if (gs.equals(gSswitch0, "resolved")) {
      return "positive";
     } else if (gs.equals(gSswitch0, "system-auto-resolved")) {
      return "blue-grey";
     } else if (gs.equals(gSswitch0, "acknowledged")) {
      return "primary";
     } else if (gs.equals(gSswitch0, "snoozed")) {
      return "deep-orange";
     } else if (gs.equals(gSswitch0, "active")) {
      return "negative";
     } else {
      return "grey-7";
     };
   }
  gSobject['expandLabel'] = function(expanded) {
    return (gs.bool(expanded) ? "Hide Details" : "View Details");
   }
  gSobject['latestLogSummary'] = function(event) {
    var latestLog = ((gs.bool(gs.gp(event,"eventLogs",true))) && (gs.mc(gs.gp(event,"eventLogs"),"size",[]) > 0) ? gs.gp(event,"eventLogs")[0] : null);
    if (!gs.bool(latestLog)) {
      return "";
     };
    var actor = gs.elvis(gs.bool(gs.gp(latestLog,"userName")) , gs.gp(latestLog,"userName") , "System");
    var status = gs.elvis(gs.bool(gs.gp(latestLog,"status")) , gs.gp(latestLog,"status") , "active");
    return actor;
   }
  gSobject['currentEditorName'] = function(it) {
    return gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"name",true)) , gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"name",true) , gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"fullName",true)) , gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"fullName",true) , gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"email",true)));
   }
  gSobject['currentEditorOrgId'] = function(it) {
    return gs.gp(gs.fs('session', this, gSobject),"orgName",true);
   }
  gSobject['addEventLog'] = function(event) {
    var status = gs.mc(gs.mc(gs.gp(event,"logStatus"),"toString",[], null, true),"trim",[], null, true);
    var comment = gs.mc(gs.mc(gs.gp(event,"logComment"),"toString",[], null, true),"trim",[], null, true);
    if (!gs.bool(status)) {
      gs.mc(gSobject,"notify",["Select a status before adding an entry", "warning"]);
      return null;
     };
    if (!gs.bool(comment)) {
      gs.mc(gSobject,"notify",["Comment required", "warning"]);
      return null;
     };
    var logEntry = gs.map().add("timestamp",gs.date()).add("userName",gs.mc(gSobject,"currentEditorName",[])).add("status",status).add("comment",comment).add("orgId",gs.mc(gSobject,"currentEditorOrgId",[]));
    gs.sp(event,"eventLogs",(gs.plus(gs.list([logEntry]), gs.elvis(gs.bool(gs.gp(event,"eventLogs")) , gs.gp(event,"eventLogs") , gs.list([])))));
    gs.sp(event,"logComment","");
    var savePayload = gs.map().add("_id",gs.gp(event,"_id")).add("eventLogs",gs.gp(event,"eventLogs")).add("status",gs.mc(gSobject,"mapAlertStatus",[status])).add("acknowledged",gs.equals(status, "acknowledged")).add("isSnoozed",gs.equals(status, "snoozed")).add("isResolved",gs.equals(status, "resolved")).add("resolvedAt",(gs.equals(status, "resolved") ? gs.date() : null)).add("resolvedBy",(gs.equals(status, "resolved") ? gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"email",true)) , gs.gp(gs.gp(gs.fs('session', this, gSobject),"user"),"email",true) , gs.elvis(gs.mc(gSobject,"currentEditorName",[]) , gs.mc(gSobject,"currentEditorName",[]) , "user")) : null));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAlertService"),"updateAlertStatus",[savePayload, function(data) {
      gs.mc(gSobject,"notify",["Entry added"]);
      return gs.mc(gSobject,"refreshEvents",[]);
     }]);
   }
  gSobject['mapAlertStatus'] = function(logStatus) {
    var gSswitch0 = logStatus;
    if (gs.equals(gSswitch0, "resolved")) {
      return "resolved";
     } else if (gs.equals(gSswitch0, "snoozed")) {
      return "snoozed";
     } else if (gs.equals(gSswitch0, "acknowledged")) {
      return "acknowledged";
     } else {
      return "active";
     };
   }
  gSobject['onResolvedLimitChanged'] = function(it) {
    return gs.mc(gSobject,"refreshEvents",[]);
   }
  gSobject['logIcon'] = function(logStatus) {
    var status = gs.mc(gs.mc(gs.elvis(gs.bool(logStatus) , logStatus , ""),"toString",[]),"toLowerCase",[]);
    return ((gs.equals(status, "new")) || (gs.equals(status, "triggered")) ? "o_warning" : "o_chat");
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitSensorReadingsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitSensorReadingsTab', simpleName: 'UnitSensorReadingsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject['created'] = function(it) {
    var self = this;
    gs.sp(gSobject.scope,"selectedSensorType","Temperature");
    return gs.sp(gSobject.scope,"sensorTypeOptions",gs.list(["Temperature" , "Humidity" , "CO2" , "Digital I/O"]));
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaContacts() {
  var gSobject = gs.init('CordovaContacts');
  gSobject.clazz = { name: 'CordovaContacts', simpleName: 'CordovaContacts'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.findContacts = function(filterText, callback) {
    navigator.contacts.find(
            [
                navigator.contacts.fieldType.phoneNumbers,
                navigator.contacts.fieldType.displayName, 
                navigator.contacts.fieldType.name
            ],
            function(data) {
                callback(data);
            },
            function(error) {
                console.log('Error finding contacts: ', error);
            },
            {
                hasPhoneNumber: true,
                filter: filterText || '',
            }
        );
   }
  gSobject.newContact = function(callback) {
    let contact = navigator.contacts.create();
        callback(contact);
   }
  gSobject.saveContact = function(contact, callback) {
    contact.save(
            function(success) {
                console.log('CordovaContacts: Contact Saved: ', success);
                callback({status: true, message: 'Contact saved successfully', contact: success});
            },
            function(error) {
                console.log('CordovaContacts: Error Saving contacts: ', error);
                callback({status: false, message: 'Failed to save contact'});
            }
        );
   }
  gSobject.deleteContact = function(contact, callback) {
    contact.remove(
            function(success) {
                console.log('CordovaContacts: Contact Deleted: ', success);
                callback({status: true, message: 'Contact deleted successfully'});
            },
            function(error) {
                console.log('CordovaContacts: Failed to delete contact: ', error);
                callback({status: false, message: 'Failed to delete contact'});
            }
        );
   }
  gSobject.isAvailable = function() { return CordovaContacts.isAvailable(); }
  gSobject.getContactsInstance = function() { return CordovaContacts.getContactsInstance(); }
  gSobject['CordovaContacts0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceReady", function(it) {
      if (!gs.bool(gs.mc(this,"isAvailable",[], gSobject))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova-plugin-contacts: Not Available"]);
        return null;
       } else {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova-plugin-contacts: Available"]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaContacts0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaContacts.isAvailable = function() {
  // Contacts plugin is not available
        if (!navigator.contacts) return false;
        else return true;
 }
CordovaContacts.getContactsInstance = function() {
  return navigator.contacts;
 }

function CordovaCalendar() {
  var gSobject = gs.init('CordovaCalendar');
  gSobject.clazz = { name: 'CordovaCalendar', simpleName: 'CordovaCalendar'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['createEvent'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeCreateEvent",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['createEventInteractively'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeCreateEventInteractively",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['findEvent'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeFindEvent",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['deleteEvent'] = function(title, location, notes, startDate, endDate, success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeDeleteEvent",[title, location, notes, startDate, endDate, success, error]);
   }
  gSobject['listCalendars'] = function(success, error) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    return gs.mc(gSobject,"nativeListCalendars",[success, error]);
   }
  gSobject['openCalendar'] = function(date) {
    if (date === undefined) date = null;
    return gs.mc(gSobject,"nativeOpenCalendar",[date]);
   }
  gSobject.nativeCreateEvent = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.createEvent(title, location, notes, startDate, endDate, success, error); }
        else { if (error) error('Calendar not available'); }
   }
  gSobject.nativeCreateEventInteractively = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.createEventInteractively(title, location, notes, startDate, endDate, success, error); }
        else { if (error) error('Calendar not available'); }
   }
  gSobject.nativeFindEvent = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.findEvent(title, location, notes, startDate, endDate, success, error); }
        else { if (success) success([]); }
   }
  gSobject.nativeDeleteEvent = function(title, location, notes, startDate, endDate, success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.deleteEvent(title, location, notes, startDate, endDate, success, error); }
        else { if (error) error('Calendar not available'); }
   }
  gSobject.nativeListCalendars = function(success, error) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.listCalendars(success, error); }
        else { if (success) success([]); }
   }
  gSobject.nativeOpenCalendar = function(date) {
    if (window.plugins && window.plugins.calendar) { window.plugins.calendar.openCalendar(date); }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AuditTrailComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AuditTrailComponent', simpleName: 'AuditTrailComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"events",gs.list([]));
    gs.sp(gSobject.scope,"loading",false);
    gs.sp(gSobject.scope,"selectedId",null);
    gs.sp(gSobject.scope,"selectedLabel","");
    gs.sp(gSobject.scope,"trail",gs.list([]));
    gs.sp(gSobject.scope,"trailLoading",false);
    gs.sp(gSobject.scope,"eventColumns",gs.list([gs.map().add("name","when").add("label","Date").add("field","when").add("align","left").add("sortable",true) , gs.map().add("name","objectType").add("label","Type").add("field","objectType").add("align","left").add("sortable",true) , gs.map().add("name","objectLabel").add("label","Record").add("field","objectLabel").add("align","left").add("sortable",true) , gs.map().add("name","updatedBy").add("label","Updated By").add("field","updatedBy").add("align","left").add("sortable",true)]));
    gs.sp(gSobject.scope,"trailColumns",gs.list([gs.map().add("name","lastUpdated").add("label","Date").add("field","lastUpdated").add("align","left") , gs.map().add("name","updatedBy").add("label","Updated By").add("field","updatedBy").add("align","left") , gs.map().add("name","propertyName").add("label","Property").add("field","propertyName").add("align","left") , gs.map().add("name","oldValue").add("label","Before").add("field","oldValue").add("align","left") , gs.map().add("name","newValue").add("label","After").add("field","newValue").add("align","left")]));
    gs.sp(gSobject.scope,"pagination",gs.map().add("rowsPerPage",15).add("sortBy","when").add("descending",true));
    return gs.mc(gSobject,"loadRecent",[]);
   }
  gSobject['activated'] = function(it) {
    gs.mc(gSobject,"clearTrail",[]);
    return gs.mc(gSobject,"loadRecent",[]);
   }
  gSobject['loadRecent'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAuditService"),"recentUnitAudit",[gs.map().add("limit",200), function(events) {
      gs.sp(gSobject.scope,"loading",false);
      return gs.sp(gSobject.scope,"events",gs.elvis(gs.bool(events) , events , gs.list([])));
     }]);
   }
  gSobject['openTrail'] = function(row) {
    if ((!gs.bool(row)) || (!gs.bool(gs.gp(row,"objectId")))) {
      return null;
     };
    gs.sp(gSobject.scope,"selectedId",gs.gp(row,"objectId"));
    gs.sp(gSobject.scope,"selectedLabel",gs.elvis(gs.bool(gs.gp(row,"objectLabel")) , gs.gp(row,"objectLabel") , gs.gp(row,"objectId")));
    gs.sp(gSobject.scope,"trail",gs.list([]));
    gs.sp(gSobject.scope,"trailLoading",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAuditService"),"unitAuditTrail",[gs.gp(row,"objectId"), function(trail) {
      gs.sp(gSobject.scope,"trailLoading",false);
      return gs.sp(gSobject.scope,"trail",gs.elvis(gs.bool(trail) , trail , gs.list([])));
     }]);
   }
  gSobject['clearTrail'] = function(it) {
    gs.sp(gSobject.scope,"selectedId",null);
    gs.sp(gSobject.scope,"selectedLabel","");
    return gs.sp(gSobject.scope,"trail",gs.list([]));
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaGoogleSignIn() {
  var gSobject = gs.init('CordovaGoogleSignIn');
  gSobject.clazz = { name: 'CordovaGoogleSignIn', simpleName: 'CordovaGoogleSignIn'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.googleSignIn = function(success, error) {
    // Try new i3 plugin first, fall back to old plugin
        if (cordova.plugins.i3GoogleSignIn) {
            cordova.plugins.i3GoogleSignIn.login(function(authData) {
                success(authData);
            }, function(err) {
                if (error) error(err);
            });
        } else if (cordova.plugins.GoogleSignInPlugin) {
            cordova.plugins.GoogleSignInPlugin.signIn(function(authData) {
                success(authData);
            }, function(err) {
                if (error) error(err);
            });
        } else {
            if (error) error('No Google Sign-In plugin available');
        }
   }
  gSobject.isSignedIn = function(success, error) {
    if (cordova.plugins.GoogleSignInPlugin && cordova.plugins.GoogleSignInPlugin.isSignedIn) {
            cordova.plugins.GoogleSignInPlugin.isSignedIn(function(result) {
                success(result);
            }, function(err) { 
                if (error) error(err);
            });
        } else {
            success({isSignedIn: false});
        }
   }
  gSobject.signOut = function(success, error) {
    if (cordova.plugins.i3GoogleSignIn) {
            cordova.plugins.i3GoogleSignIn.logout(function(result) {
                if (success) success(result);
            }, function(err) {
                if (error) error(err);
            });
        } else if (cordova.plugins.GoogleSignInPlugin) {
            cordova.plugins.GoogleSignInPlugin.signOut(function(result) {
                if (success) success(result);
            }, function(err) {
                if (error) error(err);
            });
        } else {
            if (success) success();
        }
   }
  gSobject.trySilentLogin = function(success, error) {
    if (cordova.plugins.i3GoogleSignIn) {
            cordova.plugins.i3GoogleSignIn.trySilentLogin(function(result) {
                success(result);
            }, function(err) {
                if (error) error(err);
            });
        } else {
            if (error) error('Silent login not available');
        }
   }
  gSobject.isAvailable = function() { return CordovaGoogleSignIn.isAvailable(); }
  gSobject['CordovaGoogleSignIn0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      if (!gs.bool(gs.mc(this,"isAvailable",[], gSobject))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["GoogleSignIn: Not Available"]);
        return null;
       } else {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["GoogleSignIn: Available"]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaGoogleSignIn0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaGoogleSignIn.isAvailable = function() {
  return !!(cordova.plugins.i3GoogleSignIn || cordova.plugins.GoogleSignInPlugin);
 }

function I3PageHeader() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3PageHeader', simpleName: 'I3PageHeader'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("backBtn",Boolean);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  gSobject['back'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"back",[]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitIOReadingsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitIOReadingsTab', simpleName: 'UnitIOReadingsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject.self = this;
  gSobject.data = function(it) {
    return gs.map().add("isLoading",false).add("isSeeding",false).add("digitalIOReadings",gs.list([]));
   };
  gSobject['created'] = function(it) {
    gs.println("[UnitIOReadingsTab] created unitId=" + (gs.gp(gSobject.self,"unitId")) + "");
    return gs.mc(gSobject,"refreshReadings",[]);
   }
  gSobject['activated'] = function(it) {
    gs.println("[UnitIOReadingsTab] activated unitId=" + (gs.gp(gSobject.self,"unitId")) + "");
    return gs.mc(gSobject,"refreshReadings",[]);
   }
  gSobject['refreshReadings'] = function(it) {
    gs.println("[UnitIOReadingsTab] refreshReadings unitId=" + (gs.gp(gSobject.self,"unitId")) + "");
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.println("[UnitIOReadingsTab] no unitId; clearing rows");
      gs.sp(gSobject.self,"digitalIOReadings",gs.list([]));
      gs.sp(gSobject.self,"isLoading",false);
      return null;
     };
    gs.sp(gSobject.self,"isLoading",true);
    if (!gs.bool(gs.gp(gs.gp(gs.fs('o', this, gSobject),"cwIoReadingsService"),"fetchUnitDigitalIOView",true))) {
      gs.sp(gSobject.self,"digitalIOReadings",gs.list([]));
      gs.sp(gSobject.self,"isLoading",false);
      gs.println("[UnitIOReadingsTab] cwIoReadingsService.fetchUnitDigitalIOView not available");
      gs.mc(gSobject,"notify",["Digital I/O service is not available in this runtime", "warning"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwIoReadingsService"),"fetchUnitDigitalIOView",[gs.gp(gSobject.self,"unitId"), function(payload) {
        gs.sp(gSobject.self,"digitalIOReadings",gs.elvis(gs.bool(gs.gp(payload,"rows",true)) , gs.gp(payload,"rows",true) , gs.list([])));
        gs.sp(gSobject.self,"isLoading",false);
        return gs.println("[UnitIOReadingsTab] fetch payload rows=" + (gs.mc(gs.gp(gSobject.self,"digitalIOReadings"),"size",[])) + " latestFixId=" + (gs.gp(gs.gp(payload,"latestFix",true),"fixId",true)) + "");
       }]);
     }
    catch (all) {
      gs.sp(gSobject.self,"isLoading",false);
      gs.println("[UnitIOReadingsTab] refreshReadings error: " + (gs.fs('all', this, gSobject)) + "");
      gs.mc(gSobject,"notify",["Failed to load digital I/O readings", "negative"]);
     }
    ;
   }
  gSobject['seedDemoReadings'] = function(it) {
    gs.println("[UnitIOReadingsTab] seedDemoReadings unitId=" + (gs.gp(gSobject.self,"unitId")) + "");
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.println("[UnitIOReadingsTab] seed blocked: no unitId");
      gs.mc(gSobject,"notify",["No unit selected for seeding", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gs.fs('o', this, gSobject),"cwIoReadingsService"),"seedDemoFixesForUnit",true))) {
      gs.println("[UnitIOReadingsTab] cwIoReadingsService.seedDemoFixesForUnit not available");
      gs.mc(gSobject,"notify",["Demo seed service is not available in this runtime", "warning"]);
      return null;
     };
    try {
      gs.sp(gSobject.self,"isSeeding",true);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwIoReadingsService"),"seedDemoFixesForUnit",[gs.gp(gSobject.self,"unitId"), true, function(data) {
        gs.sp(gSobject.self,"isSeeding",false);
        var seeded = gs.elvis(gs.bool(gs.gp(data,"seeded",true)) , gs.gp(data,"seeded",true) , 0);
        gs.println("[UnitIOReadingsTab] seed callback seeded=" + (seeded) + " totalRows=" + (gs.gp(data,"totalRows",true)) + "");
        gs.mc(gSobject,"notify",["Demo digital I/O readings seeded (" + (seeded) + ")"]);
        return gs.mc(gSobject,"refreshReadings",[]);
       }]);
     }
    catch (all) {
      gs.sp(gSobject.self,"isSeeding",false);
      gs.println("[UnitIOReadingsTab] seedDemoReadings error: " + (gs.fs('all', this, gSobject)) + "");
      gs.mc(gSobject,"notify",["Failed to seed demo digital I/O readings", "negative"]);
     }
    ;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function MetricGraphComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'MetricGraphComponent', simpleName: 'MetricGraphComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("objectId",String).add("metricName",String).add("type",String);
  gSobject.data = function(it) {
    return gs.map().add("selectedPeriod","Day").add("timePeriod",gs.list([]));
   };
  gSobject['created'] = function(it) {
    var self = this;
    gs.sp(self,"timePeriod",gs.list([gs.map().add("label","Hour").add("value","Hour") , gs.map().add("label","Day").add("value","Day") , gs.map().add("label","Month").add("value","Month")]));
    return gs.mc(gSobject,"loadGraph",[true, self]);
   }
  gSobject['watchObjectId'] = function(it) {
    return gs.mc(gSobject,"loadGraph",[true, this]);
   }
  gSobject['loadGraph'] = function(newGraph, self) {
    if (newGraph === undefined) newGraph = false;
    if (self === undefined) self = this;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"loadSelectedPeriodSeries",[gs.gp(self,"metricName"), gs.date(), gs.gp(self,"selectedPeriod"), gs.gp(self,"objectId"), function(data) {
      var rangeValues = gs.gp(data,"values");
      if (gs.equals(gs.gp(self,"type"), "aggregated")) {
        rangeValues = gs.gp(data,"aggValues");
       } else {
        if (gs.equals(gs.gp(self,"type"), "average")) {
          rangeValues = gs.gp(data,"avgValues");
         };
       };
      if (gs.bool(newGraph)) {
        return gs.execStatic(MetricGraphComponent,'paintGraph', this,["graph", gs.gp(data,"labels"), rangeValues]);
       } else {
        return gs.execStatic(MetricGraphComponent,'updateData', this,["graph", gs.gp(data,"labels"), rangeValues]);
       };
     }]);
   }
  gSobject.updateData = function(x0,x1,x2) { return MetricGraphComponent.updateData(x0,x1,x2); }
  gSobject.paintGraph = function(x0,x1,x2,x3) { return MetricGraphComponent.paintGraph(x0,x1,x2,x3); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
MetricGraphComponent.updateData = function(graphId, graphLabels, dataSet) {
  let chart = Chart.getChart(graphId);
        chart.data.datasets[0].data =  gs.toJavascript(dataSet)
        chart.data.labels = gs.toJavascript(graphLabels)
        chart.update()
 }
MetricGraphComponent.paintGraph = function(graphId, graphLabels, dataSet, type) {
  if (type === undefined) type = "line";
  const oldChart = Chart.getChart(graphId)
        if (oldChart != undefined) oldChart.destroy()
        
        const data = {
            labels: gs.toJavascript(graphLabels),
            datasets: [{
                data: gs.toJavascript(dataSet), 
                borderColor: Quasar.getCssVar('primary'),
                tension: 0.1,
              }]
        } 
        const options = {
            scales: {
                y: { beginAtZero:true, min:0 }
            },
            plugins: {
                legend: { display: false }
            }
        }
        const config = { 
            type: type,
            data: data,
            options: options,
        };
        
        console.log('data', data)
        
        const myChart = new Chart( document.getElementById(graphId),config);
 }

function DymicoAuthService() {
  var gSobject = gs.init('DymicoAuthService');
  gSobject.clazz = { name: 'DymicoAuthService', simpleName: 'DymicoAuthService'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['auth'] = function(username, password, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"dymicoAuthService"),"authenticate",[username, password, function(authData) {
      gs.println("DymicoAuthService");
      gs.println(authData);
      if (gs.bool(gs.gp(authData,"authenticated"))) {
        gs.execStatic(Utils,'updateAuthTokenToSession', this,[authData]);
        gs.sp(gs.fs('session', this, gSobject),"authToken",gs.gp(gs.gp(authData,"zoner"),"token"));
        return null;
       };
      return gs.execCall(callback, this, [gs.gp(authData,"authenticated")]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3Table() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Table', simpleName: 'I3Table'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list([]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  gSobject['onRequest'] = function(props) {
    if (props === undefined) props = gs.map();
    var self = this;
    gs.mc(self,"$emit",["paginate", gs.gp(props,"pagination")]);
    return gs.mc(self,"$emit",["update:pagination", gs.gp(props,"pagination")]);
   }
  gSobject['selectRow'] = function(evt, row, index) {
    var self = this;
    return gs.mc(self,"$emit",["select-row", gs.gp(row,"_id")]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaBgGps() {
  var gSobject = gs.init('CordovaBgGps');
  gSobject.clazz = { name: 'CordovaBgGps', simpleName: 'CordovaBgGps'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'HIGH_ACCURACY', { get: function() { return CordovaBgGps.HIGH_ACCURACY; }, set: function(gSval) { CordovaBgGps.HIGH_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'BALANCED_ACCURACY', { get: function() { return CordovaBgGps.BALANCED_ACCURACY; }, set: function(gSval) { CordovaBgGps.BALANCED_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'LOW_ACCURACY', { get: function() { return CordovaBgGps.LOW_ACCURACY; }, set: function(gSval) { CordovaBgGps.LOW_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'PASSIVE_ACCURACY', { get: function() { return CordovaBgGps.PASSIVE_ACCURACY; }, set: function(gSval) { CordovaBgGps.PASSIVE_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MEDIUM_ACCURACY', { get: function() { return CordovaBgGps.MEDIUM_ACCURACY; }, set: function(gSval) { CordovaBgGps.MEDIUM_ACCURACY = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GEOFENCE_ENTER', { get: function() { return CordovaBgGps.GEOFENCE_ENTER; }, set: function(gSval) { CordovaBgGps.GEOFENCE_ENTER = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GEOFENCE_EXIT', { get: function() { return CordovaBgGps.GEOFENCE_EXIT; }, set: function(gSval) { CordovaBgGps.GEOFENCE_EXIT = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'GEOFENCE_DWELL', { get: function() { return CordovaBgGps.GEOFENCE_DWELL; }, set: function(gSval) { CordovaBgGps.GEOFENCE_DWELL = gSval; }, enumerable: true });
  gSobject.lastLocation = null;
  gSobject.started = false;
  gSobject.compassHeading = 0;
  gSobject.acceleration = gs.map().add("x",0).add("y",0).add("z",0);
  gSobject.linearAccel = gs.map().add("x",0).add("y",0).add("z",0);
  gSobject.motionMagnitude = 0;
  gSobject.isMoving = false;
  gSobject.motionState = "unknown";
  Object.defineProperty(gSobject, 'STILL_SPEED', { get: function() { return CordovaBgGps.STILL_SPEED; }, set: function(gSval) { CordovaBgGps.STILL_SPEED = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'FAST_SPEED', { get: function() { return CordovaBgGps.FAST_SPEED; }, set: function(gSval) { CordovaBgGps.FAST_SPEED = gSval; }, enumerable: true });
  gSobject.lastSpeedMps = null;
  Object.defineProperty(gSobject, 'STILL_THRESHOLD', { get: function() { return CordovaBgGps.STILL_THRESHOLD; }, set: function(gSval) { CordovaBgGps.STILL_THRESHOLD = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MOVING_THRESHOLD', { get: function() { return CordovaBgGps.MOVING_THRESHOLD; }, set: function(gSval) { CordovaBgGps.MOVING_THRESHOLD = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'FAST_THRESHOLD', { get: function() { return CordovaBgGps.FAST_THRESHOLD; }, set: function(gSval) { CordovaBgGps.FAST_THRESHOLD = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'singletonInstance', { get: function() { return CordovaBgGps.singletonInstance; }, set: function(gSval) { CordovaBgGps.singletonInstance = gSval; }, enumerable: true });
  gSobject.compassListening = false;
  gSobject.accelListening = false;
  gSobject.onMotionStateCallback = function(it) {
   };
  gSobject.onLocationCallback = function(it) {
   };
  gSobject.onStationaryCallback = function(it) {
   };
  gSobject.onActivityCallback = function(it) {
   };
  gSobject.onGeofenceCallback = function(it) {
   };
  gSobject.onErrorCallback = function(it) {
   };
  gSobject.defaultConfig = gs.map().add("debug",false).add("desiredAccuracy",CordovaBgGps.BALANCED_ACCURACY).add("notificationTitle","GPS tracking").add("notificationText","Location tracking active").add("startOnBoot",false).add("stopOnTerminate",false);
  gSobject.currentConfig = gs.map();
  gSobject.instance = function() { return CordovaBgGps.instance(); }
  gSobject['config'] = function(cfg) {
    gs.mc(gSobject.currentConfig,'leftShift', gs.list([cfg]));
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[gSobject.currentConfig]);
     };
    gs.mc(gSobject,"configureTelemetry",[]);
    return this;
   }
  gSobject['getConfig'] = function(it) {
    return gSobject.currentConfig;
   }
  gSobject['start'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: BackgroundGeolocation not available"]);
      return this;
     };
    if (gs.bool(gSobject.started)) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"configure",[gSobject.currentConfig]);
    gs.mc(gSobject,"configureTelemetry",[]);
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"start",[]);
    gSobject.started = true;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: started"]);
    return this;
   }
  gSobject['stop'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"stop",[]);
    gSobject.started = false;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: stopped"]);
    return this;
   }
  gSobject['switchToHighAccuracy'] = function(it) {
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"switchMode",[1]);
     };
    return this;
   }
  gSobject['switchToBalanced'] = function(it) {
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"switchMode",[0]);
     };
    return this;
   }
  gSobject['getCurrentLocation'] = function(successCallback, failedCallback, config) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    if (config === undefined) config = gs.map();
    var callbackWrapper = function(location) {
      var normalized = gs.mc(gSobject,"normalizeLocation",[location]);
      gSobject.lastLocation = normalized;
      return gs.execCall(successCallback, this, [normalized]);
     };
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getCurrentLocation",[callbackWrapper, failedCallback, gs.mc(gs.map().add("enableHighAccuracy",true).add("maximumAge",gs.multiply((gs.multiply(4, 60)), 1000)).add("timeout",gs.multiply(60, 1000)),'leftShift', gs.list([config]))]);
     } else {
      if (gs.mc(gSobject,"navigatorGeoDefined",[])) {
        gs.mc(gs.gp(gs.fs('navigator', this, gSobject),"geolocation"),"getCurrentPosition",[function(position) {
          return gs.execCall(callbackWrapper, this, [gs.gp(position,"coords")]);
         }, failedCallback, gs.map().add("enableHighAccuracy",true).add("maximumAge",30000).add("timeout",30000)]);
       } else {
        gs.execCall(failedCallback, this, [gs.map().add("code",2).add("message","GPS not available")]);
       };
     };
    return this;
   }
  gSobject['onLocation'] = function(successCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    gSobject.onLocationCallback = successCallback;
    gSobject.onErrorCallback = failedCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["location", function(location) {
        var normalized = gs.mc(gSobject,"normalizeLocation",[location]);
        gSobject.lastLocation = normalized;
        return gs.mc(gSobject,"onLocationCallback",[normalized]);
       }]);
     };
    return this;
   }
  gSobject['onStationary'] = function(stationaryCallback, failedCallback) {
    if (failedCallback === undefined) failedCallback = function(it) {
     };
    gSobject.onStationaryCallback = stationaryCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["stationary", function(location) {
        var normalized = gs.mc(gSobject,"normalizeLocation",[location]);
        gSobject.lastLocation = normalized;
        return gs.mc(gSobject,"onStationaryCallback",[normalized]);
       }]);
     };
    return this;
   }
  gSobject['onActivity'] = function(activityCallback) {
    gSobject.onActivityCallback = activityCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["activity", function(activity) {
        return gs.mc(gSobject,"onActivityCallback",[activity]);
       }]);
     };
    return this;
   }
  gSobject['onMotionState'] = function(callback) {
    gSobject.onMotionStateCallback = callback;
    return this;
   }
  gSobject['isDeviceMoving'] = function(it) {
    return gSobject.isMoving;
   }
  gSobject['onError'] = function(errorCallback) {
    gSobject.onErrorCallback = errorCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["error", function(error) {
        return gs.mc(gSobject,"onErrorCallback",[error]);
       }]);
     };
    return this;
   }
  gSobject['addGeofence'] = function(fence) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"addGeofence",[fence, function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofence added: " + (gs.gp(fence,"id")) + ""]);
     }, function(error) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofence error: " + (error) + ""]);
     }]);
    return this;
   }
  gSobject['addGeofences'] = function(fences) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"addGeofences",[fences, function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: " + (gs.mc(fences,"size",[])) + " geofences added"]);
     }, function(error) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofences error: " + (error) + ""]);
     }]);
    return this;
   }
  gSobject['removeGeofence'] = function(id) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"removeGeofence",[id]);
    return this;
   }
  gSobject['removeAllGeofences'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"removeAllGeofences",[]);
    return this;
   }
  gSobject['getGeofences'] = function(callback) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.execCall(callback, this, [gs.list([])]);
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getGeofences",[callback]);
    return this;
   }
  gSobject['onGeofence'] = function(geofenceCallback) {
    gSobject.onGeofenceCallback = geofenceCallback;
    if (gs.mc(gSobject,"bgGeoDefined",[])) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["geofence", function(event) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: geofence event: " + (gs.gp(event,"fenceId")) + " " + (gs.gp(event,"transition")) + ""]);
        return gs.mc(gSobject,"onGeofenceCallback",[event]);
       }]);
     };
    return this;
   }
  gSobject['getGeofenceEvents'] = function(callback) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.execCall(callback, this, [gs.list([])]);
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getGeofenceEvents",[callback]);
    return this;
   }
  gSobject['checkStatus'] = function(callback) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.execCall(callback, this, [gs.map().add("isRunning",false)]);
      return this;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"checkStatus",[callback]);
    return this;
   }
  gSobject['getName'] = function(it) {
    return "CordovaBgGps";
   }
  gSobject['sync'] = function(it) {
    return this;
   }
  gSobject['normalizeLocation'] = function(location) {
    if (gs.gp(location,"speed") != null) {
      gSobject.lastSpeedMps = gs.gp(location,"speed");
     };
    var speed = gs.gp(location,"speed");
    if ((speed != null) && (speed < CordovaBgGps.STILL_SPEED)) {
      speed = 0;
     };
    gSobject.motionState = gs.mc(gSobject,"classifyMotion",[]);
    gSobject.isMoving = (gSobject.motionState != "still");
    return gs.map().add("fixId",gs.execStatic(Utils,'uuid', this,[])).add("provider",gs.elvis(gs.bool(gs.gp(location,"provider")) , gs.gp(location,"provider") , "gps")).add("unixTimeMs",gs.elvis(gs.bool(gs.gp(location,"time")) , gs.gp(location,"time") , gs.mc(gs.date(),"getTime",[]))).add("accuracy",gs.gp(location,"accuracy")).add("speed",speed).add("altitude",gs.gp(location,"altitude")).add("latitude",gs.gp(location,"latitude")).add("longitude",gs.gp(location,"longitude")).add("bearing",gs.elvis(gs.bool(gs.gp(location,"bearing")) , gs.gp(location,"bearing") , 0)).add("heading",gSobject.compassHeading).add("motionState",gSobject.motionState).add("motionMagnitude",gSobject.motionMagnitude).add("service","CordovaBgGps").add("user",gs.gp(gs.fs('session', this, gSobject),"userId")).add("uuid",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device",true),"uuid",true));
   }
  gSobject['persistLocation'] = function(location) {
    return location;
   }
  gSobject['configureTelemetry'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"telemetryDefined",[]))) {
      return null;
     };
    try {
      gs.mc(gs.fs('DymicoTelemetry', this, gSobject),"configure",[gs.map().add("syncUrl",gs.plus(gs.mc(gSobject,"originUrl",[]), "/cordovaTelemetryApi/telemetry")).add("user",gs.gp(gs.fs('session', this, gSobject),"userId")).add("uuid",gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device",true),"uuid",true)).add("syncIntervalMs",30000)]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: configureTelemetry error: " + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['getBufferStats'] = function(callback) {
    if ((gs.mc(gSobject,"telemetryDefined",[])) && (gs.mc(gSobject,"bgGeoDefined",[]))) {
      gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"getBufferStats",[callback]);
     } else {
      gs.execCall(callback, this, [gs.map().add("bound",false).add("unsynced",0)]);
     };
    return this;
   }
  gSobject['flushSync'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (gs.mc(gSobject,"telemetryDefined",[])) {
      gs.mc(gs.fs('DymicoTelemetry', this, gSobject),"flushNow",[callback]);
     };
    return this;
   }
  gSobject['recentTelemetry'] = function(opts, callback) {
    if (gs.mc(gSobject,"telemetryDefined",[])) {
      gs.mc(gs.fs('DymicoTelemetry', this, gSobject),"query",[opts, callback]);
     } else {
      gs.execCall(callback, this, [gs.list([])]);
     };
    return this;
   }
  gSobject['setupAuthorizationHandler'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"bgGeoDefined",[]))) {
      return null;
     };
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["authorization", function(status) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: authorization status: " + (status) + ""]);
      if (status !== gs.gp(gs.fs('BackgroundGeolocation', this, gSobject),"AUTHORIZED")) {
        return gs.execStatic(Utils,'setTimeout', this,[function(it) {
          var showSettings = gs.mc(this,"confirm",["App requires location tracking permission. Would you like to open app settings?"], gSobject);
          if (gs.bool(showSettings)) {
            return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"showAppSettings",[]);
           };
         }, 500]);
       };
     }]);
    gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["foreground", function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: app foreground"]);
     }]);
    return gs.mc(gs.fs('BackgroundGeolocation', this, gSobject),"on",["background", function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: app background"]);
     }]);
   }
  gSobject.bgGeoDefined = function() {
    return typeof BackgroundGeolocation !== 'undefined';
   }
  gSobject.navigatorGeoDefined = function() {
    return typeof navigator !== 'undefined' && navigator.geolocation;
   }
  gSobject.telemetryDefined = function() {
    return typeof DymicoTelemetry !== 'undefined';
   }
  gSobject.originUrl = function() {
    return (typeof window !== 'undefined' && window.location && window.location.origin) ? window.location.origin : '';
   }
  gSobject['setupCompass'] = function(it) {
    if (gs.bool(gSobject.compassListening)) {
      return null;
     };
    if (CordovaBgGps.deviceOrientationAvailable()) {
      var handler = function(event) {
        if (gs.gp(event,"webkitCompassHeading") != null) {
          return gSobject.compassHeading = Math.round(gs.gp(event,"webkitCompassHeading"));
         } else {
          if (gs.gp(event,"alpha") != null) {
            return gSobject.compassHeading = Math.round(gs.gp(event,"alpha"));
           };
         };
       };
      gs.mc(gSobject,"addOrientationListener",[handler]);
      gSobject.compassListening = true;
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: compass listener started"]);
     } else {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: DeviceOrientation API not available"]);
     };
   }
  gSobject.addOrientationListener = function(handler) {
    // iOS 13+ requires explicit permission via user gesture
        if (typeof DeviceOrientationEvent.requestPermission === 'function') {
            // Defer: register a one-time touch handler to request permission
            var requestOnce = function() {
                document.removeEventListener('touchend', requestOnce);
                document.removeEventListener('click', requestOnce);
                DeviceOrientationEvent.requestPermission().then(function(state) {
                    if (state === 'granted') {
                        window.addEventListener('deviceorientation', handler, true);
                    }
                }).catch(function() {});
            };
            document.addEventListener('touchend', requestOnce, { once: true });
            document.addEventListener('click', requestOnce, { once: true });
        } else {
            // Android and older iOS: just add the listener
            window.addEventListener('deviceorientationabsolute', handler, true);
            window.addEventListener('deviceorientation', handler, true);
        }
   }
  gSobject.deviceOrientationAvailable = function() { return CordovaBgGps.deviceOrientationAvailable(); }
  gSobject['classifyMotion'] = function(it) {
    if (gSobject.lastSpeedMps != null) {
      if (gSobject.lastSpeedMps < CordovaBgGps.STILL_SPEED) {
        return "still";
       };
      if (gSobject.lastSpeedMps < CordovaBgGps.FAST_SPEED) {
        return "moving";
       };
      return "fast";
     };
    if (gSobject.motionMagnitude < CordovaBgGps.STILL_THRESHOLD) {
      return "still";
     };
    if (gSobject.motionMagnitude < CordovaBgGps.MOVING_THRESHOLD) {
      return "moving";
     };
    return "fast";
   }
  gSobject['setupAccelerometer'] = function(it) {
    if (gs.bool(gSobject.accelListening)) {
      return null;
     };
    if (CordovaBgGps.deviceMotionAvailable()) {
      gs.mc(gSobject,"addMotionListener",[function(event) {
        if (gs.bool(gs.gp(event,"accelerationIncludingGravity"))) {
          gSobject.acceleration = gs.map().add("x",gs.elvis(gs.bool(gs.gp(gs.gp(event,"accelerationIncludingGravity"),"x")) , gs.gp(gs.gp(event,"accelerationIncludingGravity"),"x") , 0)).add("y",gs.elvis(gs.bool(gs.gp(gs.gp(event,"accelerationIncludingGravity"),"y")) , gs.gp(gs.gp(event,"accelerationIncludingGravity"),"y") , 0)).add("z",gs.elvis(gs.bool(gs.gp(gs.gp(event,"accelerationIncludingGravity"),"z")) , gs.gp(gs.gp(event,"accelerationIncludingGravity"),"z") , 0));
         };
        if (gs.bool(gs.gp(event,"acceleration"))) {
          gSobject.linearAccel = gs.map().add("x",gs.elvis(gs.bool(gs.gp(gs.gp(event,"acceleration"),"x")) , gs.gp(gs.gp(event,"acceleration"),"x") , 0)).add("y",gs.elvis(gs.bool(gs.gp(gs.gp(event,"acceleration"),"y")) , gs.gp(gs.gp(event,"acceleration"),"y") , 0)).add("z",gs.elvis(gs.bool(gs.gp(gs.gp(event,"acceleration"),"z")) , gs.gp(gs.gp(event,"acceleration"),"z") , 0));
         };
        var ax = gs.elvis(gs.bool(gs.gp(gSobject.linearAccel,"x")) , gs.gp(gSobject.linearAccel,"x") , 0);
        var ay = gs.elvis(gs.bool(gs.gp(gSobject.linearAccel,"y")) , gs.gp(gSobject.linearAccel,"y") , 0);
        var az = gs.elvis(gs.bool(gs.gp(gSobject.linearAccel,"z")) , gs.gp(gSobject.linearAccel,"z") , 0);
        gSobject.motionMagnitude = Math.sqrt(gs.plus((gs.plus((gs.multiply(ax, ax)), (gs.multiply(ay, ay)))), (gs.multiply(az, az))));
        var prevState = gSobject.motionState;
        gSobject.motionState = gs.mc(gSobject,"classifyMotion",[]);
        gSobject.isMoving = (gSobject.motionState != "still");
        if ((prevState != gSobject.motionState) && (gs.bool(gSobject.onMotionStateCallback))) {
          return gs.mc(gSobject,"onMotionStateCallback",[gs.map().add("state",gSobject.motionState).add("magnitude",gSobject.motionMagnitude)]);
         };
       }]);
      gSobject.accelListening = true;
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: accelerometer listener started"]);
     } else {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBgGps: DeviceMotion API not available"]);
     };
   }
  gSobject.addMotionListener = function(handler) {
    window.addEventListener('devicemotion', handler, true);
   }
  gSobject.deviceMotionAvailable = function() { return CordovaBgGps.deviceMotionAvailable(); }
  gSobject['CordovaBgGps0'] = function(it) {
    gs.mc(gSobject.currentConfig,'leftShift', gs.list([gSobject.defaultConfig]));
    gs.mc(gSobject,"setupAuthorizationHandler",[]);
    gs.mc(gSobject,"setupCompass",[]);
    gs.mc(gSobject,"setupAccelerometer",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaBgGps0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBgGps.instance = function(it) {
  if (!gs.bool(CordovaBgGps.singletonInstance)) {
    CordovaBgGps.singletonInstance = CordovaBgGps();
   };
  return CordovaBgGps.singletonInstance;
 }
CordovaBgGps.deviceOrientationAvailable = function() {
  return typeof DeviceOrientationEvent !== 'undefined';
 }
CordovaBgGps.deviceMotionAvailable = function() {
  return typeof DeviceMotionEvent !== 'undefined';
 }
CordovaBgGps.HIGH_ACCURACY = 0;
CordovaBgGps.BALANCED_ACCURACY = 100;
CordovaBgGps.LOW_ACCURACY = 1000;
CordovaBgGps.PASSIVE_ACCURACY = 10000;
CordovaBgGps.MEDIUM_ACCURACY = 100;
CordovaBgGps.GEOFENCE_ENTER = 1;
CordovaBgGps.GEOFENCE_EXIT = 2;
CordovaBgGps.GEOFENCE_DWELL = 4;
CordovaBgGps.STILL_SPEED = 0.7;
CordovaBgGps.FAST_SPEED = 6.0;
CordovaBgGps.STILL_THRESHOLD = 0.3;
CordovaBgGps.MOVING_THRESHOLD = 1.5;
CordovaBgGps.FAST_THRESHOLD = 5.0;
CordovaBgGps.singletonInstance = null;

function CordovaProblemReporter() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CordovaProblemReporter', simpleName: 'CordovaProblemReporter'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/reportProblem";
  gSobject.roles = gs.list([]);
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"userMessage","");
    gs.sp(gSobject.scope,"severity","normal");
    gs.sp(gSobject.scope,"severities",gs.list(["low" , "normal" , "high" , "critical"]));
    gs.sp(gSobject.scope,"thumbnailUrl","");
    gs.sp(gSobject.scope,"submitting",false);
    gs.sp(gSobject.scope,"captureCountdown",0);
    gs.sp(gSobject.scope,"hasCapture",false);
    gs.sp(gSobject.scope,"userId",gs.elvis(gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId")) , gs.gp(gs.fs('session', this, gSobject),"userId") , "(anonymous)"));
    gs.sp(gSobject.scope,"deviceUuid",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid",true) , ""));
    gs.sp(gSobject.scope,"platform",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform",true)) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform",true) , "browser"));
    return gs.mc(gSobject,"loadPendingCapture",[]);
   }
  gSobject['loadPendingCapture'] = function(it) {
    var pending = gs.mc(gSobject,"nativeReadPendingBlob",[]);
    if ((gs.bool(pending)) && (gs.bool(gs.gp(pending,"blob")))) {
      gs.sp(gSobject.scope,"hasCapture",true);
      return gs.sp(gSobject.scope,"thumbnailUrl",gs.mc(gSobject,"nativeBlobToObjectUrl",[gs.gp(pending,"blob")]));
     };
   }
  gSobject['captureWithCountdown'] = function(it) {
    gs.sp(gSobject.scope,"captureCountdown",3);
    return gs.mc(gSobject,"tick",[]);
   }
  gSobject['tick'] = function(it) {
    if (gs.gp(gSobject.scope,"captureCountdown") <= 0) {
      gs.mc(gSobject,"doCapture",[]);
      return null;
     };
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      gs.sp(gSobject.scope,"captureCountdown",(gs.minus(gs.gp(gSobject.scope,"captureCountdown"), 1)));
      return gs.mc(gSobject,"tick",[]);
     }, 1000]);
   }
  gSobject['doCapture'] = function(it) {
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"capture",[function(blob, meta) {
      gs.mc(gSobject,"nativeStashBlob",[blob]);
      gs.sp(gSobject.scope,"hasCapture",true);
      return gs.sp(gSobject.scope,"thumbnailUrl",gs.mc(gSobject,"nativeBlobToObjectUrl",[blob]));
     }, function(err) {
      return gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","negative").add("message","Capture failed: " + (err) + "")]);
     }]);
   }
  gSobject['submit'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"submitting"))) {
      return null;
     };
    if (!gs.bool(gs.mc(gs.gp(gSobject.scope,"userMessage"),"trim",[], null, true))) {
      gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","warning").add("message","Please describe the problem")]);
      return null;
     };
    gs.sp(gSobject.scope,"submitting",true);
    var opts = gs.map().add("severity",gs.gp(gSobject.scope,"severity"));
    return gs.mc(gs.fs('cordovaScreenCapture', this, gSobject),"reportProblem",[gs.gp(gSobject.scope,"userMessage"), opts, function(reportId) {
      gs.sp(gSobject.scope,"submitting",false);
      gs.mc(gSobject,"nativeClearPendingBlob",[]);
      gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","positive").add("message","Problem reported. Thanks!").add("actions",gs.list([gs.map().add("label","View").add("color","white").add("handler",function(it) {
        return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/cordovaErrors"]);
       })]))]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"back",[]);
     }, function(err) {
      gs.sp(gSobject.scope,"submitting",false);
      return gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Notify"),"create",[gs.map().add("type","negative").add("message","Failed to send: " + (err) + "")]);
     }]);
   }
  gSobject['cancel'] = function(it) {
    gs.mc(gSobject,"nativeClearPendingBlob",[]);
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"back",[]);
   }
  gSobject.nativeReadPendingBlob = function() {
    return window._cwPendingReport || null;
   }
  gSobject.nativeStashBlob = function(blob) {
    window._cwPendingReport = { blob: blob, ts: Date.now() };
   }
  gSobject.nativeClearPendingBlob = function() {
    if (window._cwPendingReport && window._cwPendingReport.thumbnailUrl) {
            try { URL.revokeObjectURL(window._cwPendingReport.thumbnailUrl); } catch(_) {}
        }
        window._cwPendingReport = null;
   }
  gSobject.nativeBlobToObjectUrl = function(blob) {
    try { return URL.createObjectURL(blob); } catch(e) { return ''; }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaScreenCapture() {
  var gSobject = gs.init('CordovaScreenCapture');
  gSobject.clazz = { name: 'CordovaScreenCapture', simpleName: 'CordovaScreenCapture'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['capture'] = function(success, error, opts) {
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    if (opts === undefined) opts = gs.map();
    return gs.mc(gSobject,"nativeCaptureSvgToPng",[gs.elvis(gs.bool(gs.gp(opts,"maxWidth")) , gs.gp(opts,"maxWidth") , 1280), success, error]);
   }
  gSobject['openProblemReport'] = function(it) {
    return gs.mc(gSobject,"capture",[function(blob, meta) {
      gs.mc(gSobject,"nativeStashBlob",[blob]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/reportProblem"]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["openProblemReport: capture failed: " + (err) + ""]);
      gs.mc(gSobject,"nativeStashBlob",[null]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/reportProblem"]);
     }]);
   }
  gSobject['reportProblem'] = function(userMessage, opts, success, error) {
    if (opts === undefined) opts = gs.map();
    if (success === undefined) success = function(it) {
     };
    if (error === undefined) error = function(it) {
     };
    var stashed = gs.mc(gSobject,"nativeReadStashedBlob",[]);
    if (gs.bool(stashed)) {
      gs.mc(gSobject,"uploadAndCreateReport",[userMessage, opts, stashed, gs.map().add("type","image/png").add("width",0).add("height",0).add("fallback",false), success, error]);
      return null;
     };
    return gs.mc(gSobject,"capture",[function(blob, meta) {
      return gs.mc(gSobject,"uploadAndCreateReport",[userMessage, opts, blob, meta, success, error]);
     }, function(captureErr) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaScreenCapture:reportProblem:capture failed: " + (captureErr) + ""]);
      return gs.mc(gSobject,"uploadAndCreateReport",[userMessage, opts, null, gs.map(), success, error]);
     }]);
   }
  gSobject['uploadAndCreateReport'] = function(userMessage, opts, blob, meta, success, error) {
    var report = gs.mc(gSobject,"buildReportContext",[userMessage, opts, meta]);
    gs.sp(report,"hasScreenshot",(blob != null));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaService"),"userProblem",[gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"uuid"), report, function(result) {
      if (!gs.bool(gs.gp(result,"id",true))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaScreenCapture:reportProblem:userProblem returned no id"]);
        return gs.execCall(error, this, ["Failed to create problem report"]);
       };
      if (!gs.bool(blob)) {
        return gs.execCall(success, this, [gs.gp(result,"id")]);
       };
      return gs.execStatic(Utils,'post', this,[blob, "screenshot", "userError", gs.gp(result,"id"), function(uploadResult) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaScreenCapture:reportProblem:uploaded screenshot for " + (gs.gp(result,"id")) + ""]);
        return gs.execCall(success, this, [gs.gp(result,"id")]);
       }, function(uploadErr) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaScreenCapture:reportProblem:screenshot upload failed: " + (uploadErr) + ""]);
        return gs.execCall(success, this, [gs.gp(result,"id")]);
       }]);
     }]);
   }
  gSobject['buildReportContext'] = function(userMessage, opts, meta) {
    var ctx = gs.mc(gSobject,"nativeGatherContext",[]);
    return gs.map().add("userMessage",gs.elvis(gs.bool(userMessage) , userMessage , "")).add("severity",gs.elvis(gs.bool(gs.gp(opts,"severity")) , gs.gp(opts,"severity") , "normal")).add("message",gs.elvis(gs.bool(userMessage) , userMessage , "(no description)")).add("route",gs.gp(ctx,"route")).add("pageTitle",gs.gp(ctx,"pageTitle")).add("appPath",gs.gp(ctx,"appPath")).add("viewport",gs.gp(ctx,"viewport")).add("orientation",gs.gp(ctx,"orientation")).add("locale",gs.gp(ctx,"locale")).add("tz",gs.gp(ctx,"tz")).add("consoleTail",gs.gp(ctx,"consoleTail")).add("routeHistory",gs.gp(ctx,"routeHistory")).add("userAgent",gs.gp(ctx,"userAgent")).add("platform",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform")) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"platform") , "browser")).add("appVersion",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"version")) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"version") , "")).add("appBuild",gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"cordova")) , gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"device"),"cordova") , "")).add("clientReportedAt",gs.mc(gs.date(),"getTime",[]));
   }
  gSobject.nativeGatherContext = function() {
    var route = '';
        var routeHistory = '';
        try {
            if (window.vue && window.vue.router && window.vue.router.currentRoute) {
                route = window.vue.router.currentRoute.value
                    ? window.vue.router.currentRoute.value.fullPath
                    : window.vue.router.currentRoute.fullPath || '';
            }
        } catch(e) {}
        try {
            if (window._cwRouteHistory) routeHistory = window._cwRouteHistory.slice(-5).join(' -> ');
        } catch(e) {}

        var tail = '';
        try { if (window._cwConsoleTail) tail = window._cwConsoleTail.join('\n'); } catch(e) {}

        return {
            route       : route,
            pageTitle   : (typeof document !== 'undefined') ? (document.title || '') : '',
            appPath     : (typeof window !== 'undefined' && window.location) ? window.location.pathname : '',
            viewport    : (window.innerWidth + 'x' + window.innerHeight + ' @ ' + (window.devicePixelRatio || 1) + 'x'),
            orientation : (screen && screen.orientation) ? (screen.orientation.type || '') : '',
            locale      : (navigator && navigator.language) ? navigator.language : '',
            tz          : (Intl && Intl.DateTimeFormat) ? Intl.DateTimeFormat().resolvedOptions().timeZone : '',
            consoleTail : tail,
            routeHistory: routeHistory,
            userAgent   : (navigator && navigator.userAgent) ? navigator.userAgent : ''
        };
   }
  gSobject.nativeStashBlob = function(blob) {
    if (blob) window._cwPendingReport = { blob: blob, ts: Date.now() };
        else window._cwPendingReport = null;
   }
  gSobject.nativeReadStashedBlob = function() {
    return window._cwPendingReport ? window._cwPendingReport.blob : null;
   }
  gSobject.nativeCaptureSvgToPng = function(maxWidth, success, error) {
    try {
            var node = document.documentElement;
            var w = Math.max(node.scrollWidth, document.body ? document.body.scrollWidth : 0, window.innerWidth);
            var h = Math.max(node.scrollHeight, document.body ? document.body.scrollHeight : 0, window.innerHeight);

            // Clone so we can inline computed styles without mutating the live DOM.
            var clone = node.cloneNode(true);

            // Strip <script> and elements that don't render.
            var scripts = clone.querySelectorAll('script, link[rel="preload"], link[as="script"]');
            for (var i = 0; i < scripts.length; i++) scripts[i].parentNode.removeChild(scripts[i]);

            var serializer = new XMLSerializer();
            var html;
            try {
                html = serializer.serializeToString(clone);
            } catch(e) {
                return error('serialize failed: ' + e);
            }

            // Wrap in xhtml namespace so foreignObject can host it
            var svg =
                '<svg xmlns="http://www.w3.org/2000/svg" width="' + w + '" height="' + h + '">' +
                  '<foreignObject width="100%" height="100%">' +
                    '<div xmlns="http://www.w3.org/1999/xhtml">' + html + '</div>' +
                  '</foreignObject>' +
                '</svg>';

            var svgBlob = new Blob([svg], { type: 'image/svg+xml;charset=utf-8' });
            var url = URL.createObjectURL(svgBlob);
            var img = new Image();

            // Optional downscale for very wide pages
            var scale = (maxWidth && w > maxWidth) ? (maxWidth / w) : 1;
            var outW = Math.round(w * scale);
            var outH = Math.round(h * scale);

            img.onload = function() {
                try {
                    var canvas = document.createElement('canvas');
                    canvas.width = outW;
                    canvas.height = outH;
                    var ctx = canvas.getContext('2d');
                    ctx.fillStyle = '#ffffff';
                    ctx.fillRect(0, 0, outW, outH);
                    ctx.drawImage(img, 0, 0, outW, outH);
                    URL.revokeObjectURL(url);

                    canvas.toBlob(function(blob) {
                        if (blob) {
                            success(blob, { type:'image/png', width:outW, height:outH, fallback:false });
                        } else {
                            // Canvas likely tainted by cross-origin images — fall back to raw SVG
                            success(svgBlob, { type:'image/svg+xml', width:w, height:h, fallback:true });
                        }
                    }, 'image/png', 0.9);
                } catch(e) {
                    URL.revokeObjectURL(url);
                    // Tainted canvas → fall back to raw SVG so the report still has *something*
                    success(svgBlob, { type:'image/svg+xml', width:w, height:h, fallback:true });
                }
            };
            img.onerror = function(e) {
                URL.revokeObjectURL(url);
                // Image load failed — return the raw SVG so caller still has visual context
                success(svgBlob, { type:'image/svg+xml', width:w, height:h, fallback:true });
            };
            img.src = url;
        } catch(e) {
            error('capture failed: ' + (e.message || e));
        }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueMediaUploadComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueMediaUploadComponent', simpleName: 'VueMediaUploadComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["oObject" , "oName" , "oPropName" , "label" , "width" , "height" , "mimeType" , "upload" , "controls" , "autoplay" , "playOnHover" , "muted" , "fit" , "controlsList" , "previewOnly" , "loop" , "customControls" , "trapezoid" , "fill" , "radius" , "downloadFile" , "zoom" , "uploadCallback" , "showFileName" , "staticHeight"]);
  gSobject.data = function(it) {
    return gs.map().add("mediaUrl","").add("myStyle","").add("acceptFiles","").add("contentType","").add("showPlayer",false).add("isCordova",false).add("playing",false).add("muted",false).add("fullscreen",false).add("showImageDialog",false);
   };
  gSobject['mounted'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"playOnHover"))) {
      gs.sp(self,"playOnHover",false);
     };
    if (!gs.bool(gs.gp(self,"upload"))) {
      gs.sp(self,"upload",false);
     };
    if (!gs.bool(gs.gp(self,"controls"))) {
      gs.sp(self,"controls",false);
     };
    if (!gs.bool(gs.gp(self,"muted"))) {
      gs.sp(self,"muted",false);
     };
    if (!gs.bool(gs.gp(self,"autoplay"))) {
      gs.sp(self,"autoplay",false);
     };
    if (gs.bool(gs.gp(self,"previewOnly"))) {
      gs.sp(self,"previewOnly",true);
     } else {
      gs.sp(self,"previewOnly",false);
     };
    if (!gs.bool(gs.gp(self,"loop"))) {
      gs.sp(self,"loop",false);
     };
    if (!gs.bool(gs.gp(self,"trapezoid"))) {
      gs.sp(self,"trapezoid",false);
     };
    if (!gs.bool(gs.gp(self,"fit"))) {
      gs.sp(self,"fit","cover");
     };
    if (!gs.bool(gs.gp(self,"fill"))) {
      gs.sp(self,"fill","fill");
     };
    if (!gs.bool(gs.gp(self,"downloadFile"))) {
      gs.sp(self,"downloadFile",false);
     };
    if (!gs.bool(gs.gp(self,"zoom"))) {
      gs.sp(self,"zoom",false);
     };
    if (!gs.bool(gs.gp(self,"showFileName"))) {
      gs.sp(self,"showFileName",false);
     };
    if (!gs.bool(gs.gp(self,"controlsList"))) {
      gs.sp(self,"controlsList","nofullscreen nodownload");
     };
    if (!gs.bool(gs.gp(self,"customControls"))) {
      gs.sp(self,"customControls",false);
     };
    gs.sp(self,"isCordova",gs.execStatic(Utils,'isCordova', this,[]));
    if (((!gs.bool(gs.gp(self,"previewOnly"))) && (!gs.bool(gs.gp(self,"playOnHover")))) && (gs.mc(gSobject,"isType",["media", self]))) {
      gs.sp(self,"showPlayer",true);
     };
    gs.sp(self,"showImageDialog",false);
    gs.mc(gSobject,"setupUrls",[self]);
    return gs.mc(gSobject,"setupZoomView",[self]);
   }
  gSobject['watchOObject'] = function(val, oldVal) {
    var self = this;
    gs.mc(gSobject,"setupUrls",[self]);
    return gs.mc(gSobject,"setupZoomView",[self]);
   }
  gSobject['created'] = function(it) {
   }
  gSobject['mouseover'] = function(it) {
    return gs.mc(gSobject,"videoControl",[this, true]);
   }
  gSobject['mouseout'] = function(it) {
    return gs.mc(gSobject,"videoControl",[this, false]);
   }
  gSobject['videoControl'] = function(self, playNow) {
    if (gs.bool(gs.gp(self,"playOnHover"))) {
      gs.sp(self,"showPlayer",playNow);
      if (gs.bool(playNow)) {
        return gs.mc(gSobject,"nextTick",[function(it) {
          return gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
         }]);
       };
     };
   }
  gSobject['play'] = function(it) {
    var self = this;
    gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
    gs.sp(self,"playing",true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"add",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"legionUser"),"_id",true), "fitworld.video.play", gs.gp(gs.gp(self,"oObject"),"_id")]),"do",[]);
   }
  gSobject['pause'] = function(it) {
    var self = this;
    gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"pause",[]);
    return gs.sp(self,"playing",false);
   }
  gSobject['show'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"zoom"))) {
      return null;
     };
    gs.sp(self,"showImageDialog",true);
    gs.mc(gSobject,"nextTick",[function(it) {
     }]);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["any"]);
     };
   }
  gSobject['hideImageDialog'] = function(it) {
    gs.sp(gSobject.self,"showImageDialog",false);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["portrait"]);
     };
   }
  gSobject['changeFullscreen'] = function(it) {
    gs.println("fullscreen");
    var self = this;
    gs.sp(self,"fullscreen",true);
    var video = gs.gp(gs.gp(self,"$refs"),"video");
    var onfullscreenchange = function(it) {
      gs.println("onfullscreenchange");
      gs.sp(self,"fullscreen",!gs.gp(self,"fullscreen"));
      return gs.println(gs.gp(self,"fullscreen"));
     };
    gs.sp(video,"onfullscreenchange",onfullscreenchange);
    gs.sp(video,"mozfullscreenchange",onfullscreenchange);
    gs.sp(video,"webkitfullscreenchange",onfullscreenchange);
    gs.sp(video,"msfullscreenchange",onfullscreenchange);
    if (gs.bool(gs.gp(video,"requestFullScreen"))) {
      return gs.mc(video,"requestFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"webkitEnterFullScreen"))) {
      return gs.mc(video,"webkitEnterFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"webkitRequestFullScreen"))) {
      return gs.mc(video,"webkitRequestFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"mozRequestFullScreen"))) {
      return gs.mc(video,"mozRequestFullScreen",[]);
     };
    if (gs.bool(gs.gp(video,"msRequestFullscreen"))) {
      return gs.mc(video,"msRequestFullscreen",[]);
     };
   }
  gSobject['mute'] = function(it) {
    var self = this;
    gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",true);
    return gs.sp(self,"muted",true);
   }
  gSobject['unmute'] = function(it) {
    var self = this;
    gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",false);
    return gs.sp(self,"muted",false);
   }
  gSobject['download'] = function(it) {
    var self = this;
    return gs.mc(gs.fs('window', this, gSobject),"open",[gs.gp(self,"downloadUrl"), "_system", "closebuttoncaption=DONE&location=no"]);
   }
  gSobject['isProcessing'] = function(it) {
    return (gs.bool(gs.gp(gSobject.self,"oObject"))) && (gs.equals(gs.gp(gs.gp(gSobject.self,"oObject")[gs.gp(gSobject.self,"oPropName")],"processing",true), true));
   }
  gSobject['setupUrls'] = function(self) {
    gs.sp(self,"placeHolderUrl","/statics/vue-wrapper/img/placeHolder.png?" + ((gs.bool(gs.gp(self,"width")) ? gs.plus("&width=", gs.gp(self,"width")) : "")) + "" + ((gs.bool(gs.gp(self,"height")) ? gs.plus("&height=", gs.gp(self,"height")) : "")) + ";" + ((gs.bool(gs.gp(self,"staticHeight")) ? gs.plus("height:", gs.gp(self,"staticHeight")) : "")) + ";");
    gs.sp(self,"myStyle","" + ((gs.bool(gs.gp(self,"width")) ? gs.plus((gs.plus("min-width:", gs.gp(self,"width"))), "px") : "")) + ";" + ((gs.bool(gs.gp(self,"height")) ? gs.plus((gs.plus("min-height:", gs.gp(self,"height"))), "px") : "")) + ";" + ((gs.bool(gs.gp(self,"radius")) ? gs.plus((gs.plus("border-radius:", gs.gp(self,"radius"))), "px") : "")) + ";" + ((gs.bool(gs.gp(self,"staticHeight")) ? gs.plus("height:", gs.gp(self,"staticHeight")) : "")) + ";");
    gs.sp(self,"acceptFiles",gs.elvis(gs.bool(gs.gp(self,"mimeType")) , gs.gp(self,"mimeType") , "image/*"));
    if ((!gs.bool(gs.gp(self,"oObject"))) || (!gs.bool(gs.gp(self,"oObject")[gs.gp(self,"oPropName")]))) {
      gs.println("NO OBJECT");
      gs.sp(self,"previewUrl",gs.gp(self,"placeHolder"));
      gs.sp(self,"downloadUrl",gs.gp(self,"placeHolderUrl"));
      gs.println(gs.gp(self,"previewUrl"));
      gs.println(gs.gp(self,"downloadUrl"));
      return null;
     };
    if (gs.mc(gSobject,"isProcessing",[])) {
      gs.println("isProcessing");
      gs.sp(self,"placeHolderUrl","/statics/vue-wrapper/img/spinner.gif");
      gs.sp(self,"previewUrl",gs.gp(self,"placeHolder"));
      gs.sp(self,"downloadUrl",gs.gp(self,"placeHolderUrl"));
      gs.println(gs.gp(self,"previewUrl"));
      gs.println(gs.gp(self,"downloadUrl"));
      return null;
     };
    gs.println("ALL GOOD");
    var fileInfo = gs.gp(self,"oObject")[gs.gp(self,"oPropName")];
    gs.sp(self,"contentType",gs.gp(fileInfo,"contentType"));
    var objectId = gs.gp(gs.gp(self,"oObject"),"_id");
    var lastUpdated = gs.gp(gs.gp(self,"oObject"),"_lastUpdated");
    try {
      lastUpdated = gs.mc(lastUpdated,"getTime",[]);
     }
    catch (all) {
     }
    ;
    gs.sp(self,"previewUrl","/media-cache/filePreview/" + (objectId) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "?" + ((gs.bool(gs.gp(self,"width")) ? gs.plus("&width=", gs.gp(self,"width")) : "")) + "" + ((gs.bool(gs.gp(self,"height")) ? gs.plus("&height=", gs.gp(self,"height")) : "")) + "");
    gs.sp(self,"downloadUrl","/media-cache/file/" + (objectId) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    gs.println(gs.gp(self,"previewUrl"));
    return gs.println(gs.gp(self,"downloadUrl"));
   }
  gSobject['setupZoomView'] = function(self) {
    return gs.sp(self,"hammerRef",(gs.bool(gs.gp(self,"oObject")) ? gs.plus((gs.plus((gs.plus("hammerRef:", gs.gp(gs.gp(self,"oObject"),"_id"))), ":")), gs.gp(self,"oPropName")) : ""));
   }
  gSobject['isType'] = function(testType, self) {
    if (self === undefined) self = this;
    if (!gs.bool(gs.gp(self,"oObject"))) {
      if (gs.equals(testType, "empty")) {
        return true;
       };
      return false;
     };
    var fileInfo = gs.gp(self,"oObject")[gs.gp(self,"oPropName")];
    if ((gs.equals(testType, "empty")) && (!gs.bool(fileInfo))) {
      return true;
     };
    if (!gs.bool(fileInfo)) {
      return false;
     };
    if (gs.equals(testType, "image")) {
      return gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["image"]);
     };
    if (gs.equals(testType, "media")) {
      return (gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["video"])) || (gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["audio"]));
     };
    if (gs.equals(testType, "application/pdf")) {
      return gs.mc(gs.gp(fileInfo,"contentType"),"startsWith",["application/pdf"]);
     };
    return false;
   }
  gSobject['saveFile'] = function(newFile) {
    var self = this;
    var uploadFile = gs.gp(gs.gp(newFile,"target"),"files")[0];
    return gs.execStatic(Utils,'post', this,[uploadFile, gs.fs('oPropName', this, gSobject), gs.fs('oName', this, gSobject), gs.gp(gs.fs('oObject', this, gSobject),"_id"), function(data) {
      gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"mediaCacheService"),"deleteCache",[gs.gp(gs.gp(self,"oObject"),"_id"), gs.gp(self,"oPropName")]),"do",[]);
      var fileInfo = gs.map().add("id","" + (gs.gp(gs.gp(self,"oObject"),"_id")) + "_" + (gs.gp(self,"oPropName")) + "").add("filename",gs.gp(uploadFile,"name")).add("contentType",gs.gp(uploadFile,"type"));
      gs.sp(gs.gp(self,"oObject"),"_lastUpdated",gs.date());
      (gs.gp(self,"oObject")[gs.gp(self,"oPropName")]) = fileInfo;
      gs.mc(gSobject,"setupUrls",[self]);
      if (gs.bool(gs.gp(self,"uploadCallback"))) {
        return gs.mc(self,"uploadCallback",[]);
       };
     }]);
   }
  gSobject['beforeUnmount'] = function(it) {
    var self = this;
    return gs.sp(self,"showPlayer",false);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminOrganisationsListComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminOrganisationsListComponent', simpleName: 'AdminOrganisationsListComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"searchText","");
    gs.sp(gSobject.scope,"organisations",gs.list([]));
    gs.sp(gSobject.scope,"filter",gs.map());
    gs.sp(gSobject.scope,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    gs.sp(gSobject.scope,"dialogOpen",false);
    gs.sp(gSobject.scope,"dialogOrgName","");
    gs.sp(gSobject.scope,"myOnboardings",gs.list([]));
    gs.sp(gSobject.scope,"pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","name").add("descending",false));
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","code").add("label","Code").add("field","code").add("align","left").add("sortable",true) , gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","status").add("label","Status").add("field","status").add("align","left").add("sortable",true) , gs.map().add("name","userCount").add("label","Users").add("field","userCount").add("align","left").add("sortable",true) , gs.map().add("name","setup").add("label","Setup").add("field","setupComplete").add("align","left")]));
    gs.mc(gSobject,"loadOrganisations",[]);
    return gs.mc(gSobject,"loadMyOnboardings",[]);
   }
  gSobject['loadMyOnboardings'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOnboardingService"),"myInProgress",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
      return gs.sp(gSobject.scope,"myOnboardings",gs.elvis(gs.bool(gs.gp(data,"onboardings")) , gs.gp(data,"onboardings") , gs.list([])));
     }]);
   }
  gSobject['resumeOnboarding'] = function(id) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[gs.map().add("path","/onboarding").add("query",gs.toJavascript(gs.map().add("onboardingId",id)))]);
   }
  gSobject['dismissOnboarding'] = function(id) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOnboardingService"),"abandon",[gs.gp(gs.fs('session', this, gSobject),"userId"), id, function(result) {
      return gs.mc(gSobject,"loadMyOnboardings",[]);
     }]);
   }
  gSobject['loadOrganisations'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"paginatedOrganisations",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.scope,"searchText"), gs.gp(gSobject.scope,"filter"), gs.gp(gSobject.scope,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"organisations",gs.gp(data,"organisations"));
      return gs.sp(gs.gp(gSobject.scope,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['onRequest'] = function(props) {
    return gs.mc(gSobject,"updatePagination",[gs.gp(props,"pagination")]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.scope,"pagination",pagination);
    return gs.mc(gSobject,"loadOrganisations",[]);
   }
  gSobject['onRowClick'] = function(evt, row, index) {
    if (!gs.bool(gs.mc(gSobject,"canOpen",[row]))) {
      return null;
     };
    return gs.mc(gSobject,"selectOrganisation",[gs.gp(row,"_id")]);
   }
  gSobject['canOpen'] = function(row) {
    return (gs.bool(gs.gp(gSobject.scope,"isAdmin"))) || (gs.gp(row,"status",true) != "Deactivated");
   }
  gSobject['selectOrganisation'] = function(id) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[gs.map().add("path","/organisation/" + (id) + "").add("query",gs.toJavascript(gs.map().add("tab","details")))]);
   }
  gSobject['openAddDialog'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"isAdmin"))) {
      return null;
     };
    gs.sp(gSobject.scope,"dialogOrgName","");
    return gs.sp(gSobject.scope,"dialogOpen",true);
   }
  gSobject['closeAddDialog'] = function(it) {
    return gs.sp(gSobject.scope,"dialogOpen",false);
   }
  gSobject['openSetupWizard'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"isAdmin"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/onboarding"]);
   }
  gSobject['createOrganisation'] = function(it) {
    var name = gs.mc(gs.gp(gSobject.scope,"dialogOrgName"),"trim",[], null, true);
    if (!gs.bool(name)) {
      return gs.mc(gSobject,"notify",["Please enter a name", "negative"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"save",[gs.map().add("name",name).add("status","Active"), function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"dialogOpen",false);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[gs.map().add("path","/organisation/" + (gs.gp(saved,"_id")) + "").add("query",gs.toJavascript(gs.map().add("tab","details")))]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaShare() {
  var gSobject = gs.init('CordovaShare');
  gSobject.clazz = { name: 'CordovaShare', simpleName: 'CordovaShare'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['share'] = function(message, subject, files, url, success, failure) {
    if (subject === undefined) subject = null;
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"share",[message, subject, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaEmail'] = function(message, subject, to, cc, bcc, files, success, failure) {
    if (subject === undefined) subject = "";
    if (to === undefined) to = gs.list([]);
    if (cc === undefined) cc = gs.list([]);
    if (bcc === undefined) bcc = gs.list([]);
    if (files === undefined) files = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaEmail",[message, subject, to, cc, bcc, files, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaSMS'] = function(message, phoneNumbers, success, failure) {
    if (phoneNumbers === undefined) phoneNumbers = "";
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaSMS",[gs.map().add("message",message), phoneNumbers, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaWhatsApp'] = function(message, files, url, success, failure) {
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaWhatsApp",[message, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaTwitter'] = function(message, files, url, success, failure) {
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaTwitter",[message, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['shareViaFacebook'] = function(message, files, url, success, failure) {
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"shareViaFacebook",[message, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['canShareVia'] = function(via, message, subject, files, url, success, failure) {
    if (message === undefined) message = "";
    if (subject === undefined) subject = null;
    if (files === undefined) files = null;
    if (url === undefined) url = null;
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"canShareVia",[via, message, subject, files, url, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['saveToPhotoAlbum'] = function(files, success, failure) {
    if (success === undefined) success = function(it) {
     };
    if (failure === undefined) failure = function(it) {
     };
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(failure, this, ["socialsharing not installed"]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"saveToPhotoAlbum",[files, success, failure]);
     }
    catch (e) {
      gs.execCall(failure, this, ["" + (gs.fs('e', this, gSobject)) + ""]);
     }
    ;
   }
  gSobject['available'] = function(callback) {
    if (!gs.bool(CordovaShare.shareInstalled())) {
      gs.execCall(callback, this, [false]);
      return null;
     };
    try {
      gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"plugins"),"socialsharing"),"available",[callback]);
     }
    catch (e) {
      gs.execCall(callback, this, [false]);
     }
    ;
   }
  gSobject.shareInstalled = function() { return CordovaShare.shareInstalled(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaShare.shareInstalled = function() {
  return typeof window.plugins !== 'undefined' && typeof window.plugins.socialsharing !== 'undefined';
 }

function CordovaPushNotification() {
  var gSobject = gs.init('CordovaPushNotification');
  gSobject.clazz = { name: 'CordovaPushNotification', simpleName: 'CordovaPushNotification'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.pushService = null;
  gSobject.notificationListeners = gs.list([]);
  gSobject.pushConfig = gs.map().add("android",gs.map().add("icon","ic_notification")).add("ios",gs.map().add("alert","true").add("badge","true").add("sound","true")).add("windows",gs.map());
  gSobject['toLocation'] = function(path) {
    return gs.execStatic(Utils,'setTimeout', this,[function(it) {
      if (!gs.bool(gs.mc(path,"startsWith",["http"]))) {
        path = (gs.plus((gs.plus((gs.mc(gs.mc(gs.gp(gs.gp(gs.fs('window', this, gSobject),"location"),"href"),"toString",[]),"split",["#"])[0]), "#")), path));
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:path:" + (path) + ""]);
       };
      return gs.sp(gs.fs('window', this, gSobject),"location",path);
     }, 1000]);
   }
  gSobject['subscribe'] = function(callback) {
    return gs.mc(gSobject.notificationListeners,"add",[callback]);
   }
  gSobject.pluginInstalled = function() { return CordovaPushNotification.pluginInstalled(); }
  gSobject.hasNotificationPermission = function(x0) { return CordovaPushNotification.hasNotificationPermission(x0); }
  gSobject['CordovaPushNotification0'] = function(it) {
    gs.mc(document,"addEventListener",["deviceready", function(it) {
      if (!gs.bool(gs.mc(this,"pluginInstalled",[], gSobject))) {
        return null;
       };
      return gs.mc(gs.fs('legionUserService', this, gSobject),"loadLegionUser",[function(user) {
        gSobject.pushService = gs.mc(gs.fs('PushNotification', this, gSobject),"init",[gSobject.pushConfig]);
        gs.mc(gSobject.pushService,"on",["registration", function(data) {
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:registration:START:" + (gs.gp(user,"_id")) + ":" + (gs.execStatic(Utils,'deviceType', this,[])) + ":" + (gs.gp(data,"registrationId")) + ""]);
          gs.mc(this,"hasNotificationPermission",[function(status) {
            return gs.println("CordovaPushNotificationService:registration:STATUS:" + (gs.gp(user,"_id")) + ":" + (status) + "");
           }], gSobject);
          return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cordovaDeviceNotificationService"),"registerDevice",[gs.gp(user,"_id"), gs.gp(data,"registrationId"), gs.execStatic(Utils,'deviceType', this,[]), function(it) {
            return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:registration:DONE:" + (gs.gp(user,"_id")) + ":" + (gs.execStatic(Utils,'deviceType', this,[])) + ":" + (gs.gp(data,"registrationId")) + ""]);
           }]);
         }]);
        gs.mc(gSobject.pushService,"on",["error", function(error) {
          return gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:error:" + (error) + ""]);
         }]);
        return gs.mc(gSobject.pushService,"on",["notification", function(data) {
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["Notification received by device - " + (data) + ""]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[data]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:notification:1:" + (gs.gp(data,"message")) + ""]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:notification:2:" + (gs.gp(gs.gp(data,"additionalData"),"foreground")) + ""]);
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaPushNotificationService:notification:3:" + (gs.gp(gs.gp(data,"additionalData"),"url")) + ""]);
          if (gs.bool(gSobject.notificationListeners)) {
            gs.mc(gSobject.notificationListeners,"each",[function(callback) {
              return gs.execCall(callback, this, [data]);
             }]);
            return null;
           };
          if ((gs.equals(gs.gp(gs.gp(data,"additionalData"),"foreground"), false)) && (gs.bool(gs.gp(gs.gp(data,"additionalData"),"url")))) {
            return gs.mc(gSobject,"toLocation",[gs.gp(gs.gp(data,"additionalData"),"url")]);
           };
         }]);
       }]);
     }, false]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaPushNotification0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaPushNotification.pluginInstalled = function() {
  return ( typeof PushNotification !== 'undefined')
 }
CordovaPushNotification.hasNotificationPermission = function(callback) {
  if (callback === undefined) callback = function(it) {
   };
  
 }

function UnitTemperatureReadingTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitTemperatureReadingTab', simpleName: 'UnitTemperatureReadingTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject.self = null;
  gSobject.pollingTimer = null;
  gSobject.data = function(it) {
    return gs.map().add("sensorReadings",gs.list([])).add("highestTemp",null).add("lowestTemp",null).add("selectedTimeframe","5min").add("customDays",7).add("showMinMax",false).add("historyLabels",gs.list([])).add("historyDatasets",gs.list([])).add("historySeriesNames",gs.list([])).add("historyMinDatasets",gs.list([])).add("historyMaxDatasets",gs.list([])).add("historyBucketStartMs",gs.list([])).add("historyBucketMinutes",1).add("hiddenTempSeries",gs.list([])).add("voltageLabels",gs.list([])).add("voltageDatasets",gs.list([])).add("voltageSeriesNames",gs.list([])).add("drillFromMs",null).add("drillToMs",null).add("drillLabel",null).add("loadingHistory",false);
   };
  gSobject['created'] = function(it) {
    gSobject.self = this;
    gs.execStatic(CwChart,'registerClickHandler', this,["unitTemperatureHistory", function(datasetIndex, bucketIndex) {
      return gs.mc(gSobject,"drillIntoBucket",[bucketIndex]);
     }]);
    gs.mc(gSobject,"loadMeasurements",[]);
    gs.mc(gSobject,"loadHistory",[]);
    return gSobject.pollingTimer = gs.execStatic(Utils,'setInterval', this,[function(it) {
      return gs.mc(gSobject,"loadMeasurements",[]);
     }, 60000]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
   }
  gSobject['loadHistoryTimeframe'] = function(timeframe) {
    gs.sp(gSobject.self,"selectedTimeframe",timeframe);
    gs.sp(gSobject.self,"drillFromMs",null);
    gs.sp(gSobject.self,"drillToMs",null);
    gs.sp(gSobject.self,"drillLabel",null);
    if (gs.equals(timeframe, "custom")) {
      return null;
     };
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['updateCustomDays'] = function(days) {
    var d = gs.elvis(gs.bool(days) , days , 7);
    if (d < 2) {
      d = 2;
     };
    if (d > 30) {
      d = 30;
     };
    return gs.sp(gSobject.self,"customDays",d);
   }
  gSobject['applyCustomRange'] = function(it) {
    gs.sp(gSobject.self,"selectedTimeframe","custom");
    gs.sp(gSobject.self,"drillFromMs",null);
    gs.sp(gSobject.self,"drillToMs",null);
    gs.sp(gSobject.self,"drillLabel",null);
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['updateShowMinMax'] = function(val) {
    return gs.sp(gSobject.self,"showMinMax",(gs.bool(val) ? true : false));
   }
  gSobject['isDrillable'] = function(it) {
    var tf = gs.gp(gSobject.self,"selectedTimeframe");
    return ((gs.equals(tf, "8hours")) || (gs.equals(tf, "24hours"))) || (gs.equals(tf, "custom"));
   }
  gSobject['toggleTempSeries'] = function(index) {
    var current = gs.elvis(gs.bool(gs.gp(gSobject.self,"hiddenTempSeries")) , gs.gp(gSobject.self,"hiddenTempSeries") , gs.list([]));
    var updated = gs.list([]);
    var found = false;
    gs.mc(current,"each",[function(item) {
      if (gs.equals(item, index)) {
        return found = true;
       } else {
        return gs.mc(updated,'leftShift', gs.list([item]));
       };
     }]);
    if (!gs.bool(found)) {
      gs.mc(updated,'leftShift', gs.list([index]));
     };
    return gs.sp(gSobject.self,"hiddenTempSeries",updated);
   }
  gSobject['drillIntoBucket'] = function(bucketIndex) {
    if (!gs.bool(gs.mc(gSobject,"isDrillable",[]))) {
      return null;
     };
    var starts = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyBucketStartMs")) , gs.gp(gSobject.self,"historyBucketStartMs") , gs.list([]));
    if (((gs.equals(bucketIndex, null)) || (bucketIndex < 0)) || (bucketIndex >= gs.mc(starts,"size",[]))) {
      return null;
     };
    var bucketStart = starts[bucketIndex];
    var bucketMins = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyBucketMinutes")) , gs.gp(gSobject.self,"historyBucketMinutes") , 1);
    var halfWindowMins = Math.max(30, bucketMins);
    var windowMs = gs.multiply((gs.multiply(halfWindowMins, 60)), 1000);
    var center = gs.plus(bucketStart, (gs.div((gs.multiply((gs.multiply(bucketMins, 60)), 1000)), 2)));
    gs.sp(gSobject.self,"drillFromMs",(gs.minus(center, windowMs)));
    gs.sp(gSobject.self,"drillToMs",(gs.plus(center, windowMs)));
    gs.sp(gSobject.self,"drillLabel",gs.mc(gSobject,"formatDrillWindow",[gs.gp(gSobject.self,"drillFromMs"), gs.gp(gSobject.self,"drillToMs")]));
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['exitDrillDown'] = function(it) {
    gs.sp(gSobject.self,"drillFromMs",null);
    gs.sp(gSobject.self,"drillToMs",null);
    gs.sp(gSobject.self,"drillLabel",null);
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['formatDrillWindow'] = function(fromMs, toMs) {
    var from = gs.date(fromMs);
    var to = gs.date(toMs);
    return gs.plus((gs.plus(gs.mc(from,"format",["dd/MM HH:mm"]), " → ")), gs.mc(to,"format",["HH:mm"]));
   }
  gSobject['loadHistory'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      return null;
     };
    gs.sp(gSobject.self,"loadingHistory",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchUnitTemperatureHistory",[gs.gp(gSobject.self,"unitId"), gs.gp(gSobject.self,"selectedTimeframe"), gs.gp(gSobject.self,"customDays"), gs.gp(gSobject.self,"drillFromMs"), gs.gp(gSobject.self,"drillToMs"), function(result) {
      var allNames = gs.elvis(gs.bool(gs.gp(result,"seriesNames",true)) , gs.gp(result,"seriesNames",true) , gs.list([]));
      var allDatasets = gs.elvis(gs.bool(gs.gp(result,"datasets",true)) , gs.gp(result,"datasets",true) , gs.list([]));
      var allLabels = gs.elvis(gs.bool(gs.gp(result,"labels",true)) , gs.gp(result,"labels",true) , gs.list([]));
      var allMin = gs.elvis(gs.bool(gs.gp(result,"minDatasets",true)) , gs.gp(result,"minDatasets",true) , gs.list([]));
      var allMax = gs.elvis(gs.bool(gs.gp(result,"maxDatasets",true)) , gs.gp(result,"maxDatasets",true) , gs.list([]));
      var bucketStartMs = gs.elvis(gs.bool(gs.gp(result,"bucketStartMs",true)) , gs.gp(result,"bucketStartMs",true) , gs.list([]));
      var bucketMinutes = gs.elvis(gs.bool(gs.gp(result,"bucketMinutes",true)) , gs.gp(result,"bucketMinutes",true) , 1);
      var tempIndices = gs.list([]);
      var voltIndices = gs.list([]);
      gs.mc(allNames,"eachWithIndex",[function(name, i) {
        if (gs.equals(name, "V-In")) {
          return gs.mc(voltIndices,'leftShift', gs.list([i]));
         } else {
          return gs.mc(tempIndices,'leftShift', gs.list([i]));
         };
       }]);
      gs.sp(gSobject.self,"historyLabels",allLabels);
      gs.sp(gSobject.self,"historyDatasets",gs.mc(tempIndices,"collect",[function(it) {
        return allDatasets[it];
       }]));
      gs.sp(gSobject.self,"historySeriesNames",gs.mc(tempIndices,"collect",[function(it) {
        return allNames[it];
       }]));
      gs.sp(gSobject.self,"historyMinDatasets",gs.mc(tempIndices,"collect",[function(it) {
        return gs.elvis(allMin[it] , allMin[it] , gs.list([]));
       }]));
      gs.sp(gSobject.self,"historyMaxDatasets",gs.mc(tempIndices,"collect",[function(it) {
        return gs.elvis(allMax[it] , allMax[it] , gs.list([]));
       }]));
      gs.sp(gSobject.self,"historyBucketStartMs",bucketStartMs);
      gs.sp(gSobject.self,"historyBucketMinutes",bucketMinutes);
      gs.sp(gSobject.self,"voltageLabels",allLabels);
      gs.sp(gSobject.self,"voltageDatasets",gs.mc(voltIndices,"collect",[function(it) {
        return allDatasets[it];
       }]));
      gs.sp(gSobject.self,"voltageSeriesNames",gs.mc(voltIndices,"collect",[function(it) {
        return allNames[it];
       }]));
      return gs.sp(gSobject.self,"loadingHistory",false);
     }]);
   }
  gSobject['historyColors'] = function(it) {
    var palette = gs.list(["#1E88E5" , "#E53935" , "#43A047" , "#FB8C00" , "#8E24AA" , "#00ACC1" , "#F4511E" , "#6D4C41" , "#1E88E5" , "#D81B60" , "#546E7A" , "#FFB300" , "#00897B" , "#7CB342" , "#039BE5" , "#C0CA33" , "#5E35B1" , "#F06292" , "#4DB6AC" , "#AED581"]);
    var names = gs.elvis(gs.bool(gs.gp(gSobject.self,"historySeriesNames")) , gs.gp(gSobject.self,"historySeriesNames") , gs.list([]));
    var colors = gs.list([]);
    for (var i = 0 ; i < gs.mc(names,"size",[]) ; i++) {
      gs.mc(colors,'leftShift', gs.list([(palette[(gs.mod(i, gs.mc(palette,"size",[])))])]));
     };
    return colors;
   }
  gSobject['voltageColors'] = function(it) {
    return gs.list(["#78909C"]);
   }
  gSobject['composedDatasets'] = function(it) {
    var result = gs.list([]);
    var names = gs.elvis(gs.bool(gs.gp(gSobject.self,"historySeriesNames")) , gs.gp(gSobject.self,"historySeriesNames") , gs.list([]));
    var avgs = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyDatasets")) , gs.gp(gSobject.self,"historyDatasets") , gs.list([]));
    var mins = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyMinDatasets")) , gs.gp(gSobject.self,"historyMinDatasets") , gs.list([]));
    var maxs = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyMaxDatasets")) , gs.gp(gSobject.self,"historyMaxDatasets") , gs.list([]));
    var showBand = (gs.bool(gs.gp(gSobject.self,"showMinMax"))) && (gs.mc(gSobject,"isDrillable",[]));
    for (var i = 0 ; i < gs.mc(names,"size",[]) ; i++) {
      if (gs.bool(showBand)) {
        gs.mc(result,'leftShift', gs.list([gs.elvis(mins[i] , mins[i] , gs.list([]))]));
        gs.mc(result,'leftShift', gs.list([gs.elvis(maxs[i] , maxs[i] , gs.list([]))]));
       };
      gs.mc(result,'leftShift', gs.list([gs.elvis(avgs[i] , avgs[i] , gs.list([]))]));
     };
    return result;
   }
  gSobject['composedDatasetOptions'] = function(it) {
    var result = gs.list([]);
    var names = gs.elvis(gs.bool(gs.gp(gSobject.self,"historySeriesNames")) , gs.gp(gSobject.self,"historySeriesNames") , gs.list([]));
    var colors = gs.mc(gSobject,"historyColors",[]);
    var hiddenList = gs.elvis(gs.bool(gs.gp(gSobject.self,"hiddenTempSeries")) , gs.gp(gSobject.self,"hiddenTempSeries") , gs.list([]));
    var showBand = (gs.bool(gs.gp(gSobject.self,"showMinMax"))) && (gs.mc(gSobject,"isDrillable",[]));
    for (var i = 0 ; i < gs.mc(names,"size",[]) ; i++) {
      var color = gs.elvis(colors[i] , colors[i] , "#999999");
      var displayName = gs.elvis(names[i] , names[i] , gs.plus("Sensor ", (gs.plus(i, 1))));
      var sensorHidden = false;
      gs.mc(hiddenList,"each",[function(h) {
        if (gs.equals(h, i)) {
          return sensorHidden = true;
         };
       }]);
      if (gs.bool(showBand)) {
        var minOpts = gs.map().add("label",gs.plus((gs.plus((gs.plus("sensor-", i)), "-min|")), displayName)).add("borderColor","rgba(0,0,0,0)").add("backgroundColor",gs.plus(color, "22")).add("borderWidth",0).add("pointRadius",0).add("fill",false);
        gs.sp(minOpts,"hidden",sensorHidden);
        gs.mc(result,'leftShift', gs.list([minOpts]));
        var maxOpts = gs.map().add("label",gs.plus((gs.plus((gs.plus("sensor-", i)), "-max|")), displayName)).add("borderColor","rgba(0,0,0,0)").add("backgroundColor",gs.plus(color, "22")).add("borderWidth",0).add("pointRadius",0).add("fill","-1");
        gs.sp(maxOpts,"hidden",sensorHidden);
        gs.mc(result,'leftShift', gs.list([maxOpts]));
       };
      var avgOpts = gs.map().add("label",gs.plus((gs.plus((gs.plus("sensor-", i)), "-avg|")), displayName)).add("borderColor",color).add("backgroundColor",color).add("borderWidth",1).add("borderDash",gs.list([2 , 2])).add("pointRadius",2);
      gs.sp(avgOpts,"hidden",sensorHidden);
      gs.mc(result,'leftShift', gs.list([avgOpts]));
     };
    return result;
   }
  gSobject['loadMeasurements'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.sp(gSobject.self,"sensorReadings",gs.list([]));
      gs.sp(gSobject.self,"highestTemp",null);
      gs.sp(gSobject.self,"lowestTemp",null);
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchLatestUnitSensorReadingsByType",[gs.gp(gSobject.self,"unitId"), "temperature", function(result) {
      var list = gs.elvis(gs.bool(result) , result , gs.list([]));
      var temperatures = gs.mc(gs.mc(list,"collect",[function(it) {
        return gs.gp(it,"currentTemp",true);
       }]),"findAll",[function(value) {
        return value != null;
       }]);
      gs.sp(gSobject.self,"highestTemp",(gs.bool(temperatures) ? gs.mc(temperatures,"max",[]) : null));
      gs.sp(gSobject.self,"lowestTemp",(gs.bool(temperatures) ? gs.mc(temperatures,"min",[]) : null));
      return gs.sp(gSobject.self,"sensorReadings",gs.mc(list,"collect",[function(it) {
        return gs.map().add("id",gs.gp(it,"id",true)).add("sensorId",gs.gp(it,"sensorId",true)).add("snoozed",gs.elvis(gs.bool(gs.gp(it,"snoozed",true)) , gs.gp(it,"snoozed",true) , false)).add("sensorName",gs.elvis(gs.bool(gs.gp(it,"sensorName",true)) , gs.gp(it,"sensorName",true) , "-")).add("currentTemp",gs.gp(it,"currentTemp",true)).add("low",gs.gp(it,"low",true)).add("high",gs.gp(it,"high",true)).add("lowWarn",gs.gp(it,"lowWarn",true)).add("highWarn",gs.gp(it,"highWarn",true));
       }]));
     }]);
   }
  gSobject['formatTemperature'] = function(value) {
    if (gs.equals(value, null)) {
      return "-";
     };
    var numericValue = value;
    return gs.div(Math.floor(gs.multiply(numericValue, 10)), 10);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3Media() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Media', simpleName: 'I3Media'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  Object.defineProperty(gSobject, 'PREVIEW_LIMIT', { get: function() { return I3Media.PREVIEW_LIMIT; }, set: function(gSval) { I3Media.PREVIEW_LIMIT = gSval; }, enumerable: true });
  gSobject.props = gs.map().add("object",Map).add("prop",String).add("objectName",String).add("serverWidth",String).add("serverHeight",String).add("placeholder",String).add("eager",Boolean).add("path",String).add("type",String).add("upload",Boolean).add("delete",Boolean).add("camera",Boolean).add("initCallback",gs.map().add("type",Function).add("default",function(it) {
   })).add("removedCallback",gs.map().add("type",Function).add("default",function(it) {
   })).add("callback",gs.map().add("type",Function).add("default",function(it) {
   })).add("base64",Boolean).add("embedText",Function).add("view",Boolean).add("download",Boolean).add("preview",Boolean).add("autoplay",Boolean).add("muted",Boolean).add("loop",Boolean).add("controls",Boolean).add("customControls",Boolean).add("fullscreenControl",Boolean).add("muteControl",Boolean).add("classes",String).add("width",String).add("height",String).add("maxWidth",String).add("maxHeight",String).add("borderRadius",String).add("ratio",String).add("fit",String).add("noSpinner",Boolean).add("noTransition",Boolean).add("noAnimation",Boolean).add("location",Boolean).add("grayScale",Boolean);
  gSobject.data = function(it) {
    return gs.map().add("mediaType","").add("uploadSpinner",false).add("viewDialog",false).add("videoPlaying",false).add("videoEnded",false).add("videoMuted",false).add("imageMetadata",gs.map());
   };
  gSobject['created'] = function(it) {
    gs.println("I3Media.created()");
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['watchObject'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    gs.sp(self,"placeholderUrl","/statics/vue-wrapper/img/placeHolder.png");
    gs.sp(self,"mediaType","");
    gs.sp(self,"fileToUpload",null);
    gs.sp(self,"viewDialog",false);
    gs.sp(self,"uploadEnabled",false);
    gs.sp(self,"deleteEnabled",false);
    gs.sp(self,"downloadEnabled",false);
    gs.sp(self,"cameraEnabled",false);
    gs.sp(self,"ratioStyle",(gs.bool(gs.gp(self,"ratio")) ? gs.plus((gs.plus("padding-top:", (gs.multiply(Math.pow(gs.gp(self,"ratio"), -1), 100)))), "%") : ""));
    gs.sp(self,"ratioClass",(gs.bool(gs.gp(self,"ratio")) ? "absolute" : ""));
    gs.sp(self,"borderRadiusStyle",(gs.bool(gs.gp(self,"borderRadius")) ? gs.plus("border-radius:", gs.gp(self,"borderRadius")) : ""));
    gs.sp(self,"maxWidthStyle",(gs.bool(gs.gp(self,"maxWidth")) ? gs.plus("max-width:", gs.gp(self,"maxWidth")) : ""));
    gs.sp(self,"maxHeightStyle",(gs.bool(gs.gp(self,"maxHeight")) ? gs.plus("max-height:", gs.gp(self,"maxHeight")) : ""));
    gs.sp(self,"grayScaleStyle",(gs.bool(gs.gp(self,"grayScale")) ? "filter: grayscale(1)" : ""));
    gs.sp(self,"staticWidth",(gs.bool(gs.gp(self,"width")) ? gs.plus("width:", gs.gp(self,"width")) : ""));
    gs.sp(self,"staticHeight",(gs.bool(gs.gp(self,"height")) ? gs.plus("height:", gs.gp(self,"height")) : ""));
    gs.sp(self,"loading",(gs.bool(gs.gp(self,"eager")) ? "eager" : "lazy"));
    gs.sp(self,"videoMuted",gs.gp(self,"muted"));
    gs.sp(self,"accepted",gs.mc(gSobject,"resolveAcceptedType",[gs.gp(self,"type")]));
    if (gs.bool(gs.gp(self,"path"))) {
      return gs.sp(self,"previewUrl",gs.gp(self,"path"));
     };
    if (gs.bool(gs.gp(self,"placeholder"))) {
      gs.sp(self,"placeholderUrl",gs.gp(self,"placeholder"));
     };
    if ((!gs.bool(gs.gp(self,"object"))) || (!gs.bool(gs.gp(self,"prop")))) {
      return gs.sp(self,"previewUrl",gs.gp(self,"placeholderUrl"));
     };
    if (gs.bool(gs.gp(self,"upload"))) {
      gs.sp(self,"uploadEnabled",true);
     };
    if (gs.bool(gs.gp(self,"camera"))) {
      gs.sp(self,"cameraEnabled",((gs.execStatic(Utils,'isCordova', this,[])) && (gs.bool(gs.gp(self,"camera")))));
     };
    if (!gs.bool(gs.gp(self,"object")[gs.gp(self,"prop")])) {
      return gs.sp(self,"previewUrl",gs.gp(self,"placeholderUrl"));
     };
    if (gs.bool(gs.gp(self,"delete"))) {
      gs.sp(self,"deleteEnabled",true);
     };
    if (gs.bool(gs.gp(self,"download"))) {
      gs.sp(self,"downloadEnabled",true);
     };
    var fileInfo = gs.gp(self,"object")[gs.gp(self,"prop")];
    var lastUpdated = gs.gp(gs.gp(self,"object"),"_lastUpdated");
    try {
      lastUpdated = gs.mc(lastUpdated,"getTime",[]);
     }
    catch (all) {
     }
    ;
    if (gs.bool(gs.gp(self,"base64"))) {
      gs.sp(self,"mediaType","image");
      gs.sp(self,"previewUrl",(gs.gp(self,"object")[gs.gp(self,"prop")]));
      gs.sp(self,"downloadUrl",(gs.gp(self,"object")[gs.gp(self,"prop")]));
      gs.sp(self,"uploadSpinner",false);
      return null;
     };
    gs.sp(self,"mediaType",gs.mc(gSobject,"resolveMediaType",[fileInfo, gs.gp(self,"preview")]));
    var url = "/media-cache/filePreview/" + (gs.gp(gs.gp(self,"object"),"_id")) + "/" + (gs.gp(self,"prop")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "?";
    if (gs.bool(gs.gp(self,"serverWidth"))) {
      url += (gs.plus("&width=", gs.gp(self,"serverWidth")));
     };
    if (gs.bool(gs.gp(self,"serverHeight"))) {
      url += (gs.plus("&height=", gs.gp(self,"serverHeight")));
     };
    gs.sp(self,"previewUrl",url);
    gs.sp(self,"downloadUrl","/media-cache/file/" + (gs.gp(gs.gp(self,"object"),"_id")) + "/" + (gs.gp(self,"prop")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["svg"])) {
      gs.sp(self,"previewUrl",gs.gp(self,"downloadUrl"));
     };
    return gs.mc(gSobject,"loadFromBlob",[self]);
   }
  gSobject['loadFromBlob'] = function(self) {
    if (gs.equals(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"network"),"status"), "online")) {
      return null;
     };
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"getBlobFromCachedFile",[gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id"), function(entry) {
      if ((gs.bool(gs.gp(entry,"blob"))) && (gs.mc(gs.gp(entry,"type"),"startsWith",["image/"]))) {
        var blob = gs.gp(entry,"blob");
        return gs.execStatic(Utils,'blobToDataUrl', this,[blob, function(base64) {
          gs.sp(self,"previewUrl",base64);
          gs.sp(self,"downloadUrl",base64);
          gs.sp(self,"uploadSpinner",false);
          return gs.mc(gSobject,"refreshImage",[self]);
         }]);
       };
     }]);
   }
  gSobject['refreshImage'] = function(self) {
    var mediaType = gs.gp(self,"mediaType");
    gs.sp(self,"mediaType","");
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(self,"mediaType",mediaType);
     }]);
   }
  gSobject['objectName'] = function(self) {
    if (gs.bool(gs.gp(self,"objectName"))) {
      return gs.gp(self,"objectName");
     };
    return gs.mc(gs.gp(gs.gp(self,"object"),"_path"),"split",["/"])[2];
   }
  gSobject['openViewDialog'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"view"))) {
      return null;
     };
    if (!gs.bool(gs.mc(gSobject,"fileExists",[self]))) {
      return null;
     };
    gs.sp(self,"viewDialog",true);
    return gs.mc(gSobject,"nextTick",[function(it) {
      if (gs.equals(gs.gp(self,"mediaType"), "pdf")) {
        return gs.mc(PdfJsHandler(),"build",[gs.gp(self,"downloadUrl"), function(it) {
          return gs.execStatic(Utils,'setTimeout', this,[function(it) {
            return PinchToZoomHandler("pdf-viewer", "pdf");
           }, 3000]);
         }]);
       } else {
        return PinchToZoomHandler("viewer-id", "image");
       };
     }]);
   }
  gSobject['closeViewDialog'] = function(it) {
    var self = this;
    return gs.sp(self,"viewDialog",false);
   }
  gSobject['fileExists'] = function(self) {
    if (self === undefined) self = this;
    if (!gs.bool(self)) {
      self = this;
     };
    if (!gs.bool(gs.gp(self,"object"))) {
      return false;
     };
    return (gs.gp(self,"object")[gs.gp(self,"prop")] ? true : false);
   }
  gSobject['downloadFile'] = function(it) {
    var self = this;
    return gs.mc(gs.fs('window', this, gSobject),"open",[gs.gp(self,"downloadUrl"), "_system"]);
   }
  gSobject['saveFile'] = function(it) {
    var self = this;
    gs.sp(self,"uploadSpinner",true);
    gs.mc(self,"initCallback",[gs.gp(self,"object")]);
    gs.println("self.embedText()");
    gs.println(gs.gp(self,"embedText"));
    var embedText = "";
    if (gs.bool(gs.gp(self,"embedText"))) {
      embedText = gs.mc(self,"embedText",[]);
     };
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"addFile",[gs.gp(self,"fileToUpload"), gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id"), function(result, blob) {
      gs.mc(gSobject,"notify",["Media Uploaded"]);
      gs.sp(self,"uploadSpinner",false);
      return gs.mc(gSobject,"updateMedia",[self, gs.gp(gs.gp(self,"fileToUpload"),"name"), gs.gp(gs.gp(self,"fileToUpload"),"type")]);
     }, function(error) {
      gs.mc(gSobject,"notify",["Your offline. Upload will resume later..."]);
      return gs.mc(gSobject,"updateMedia",[self, gs.gp(gs.gp(self,"fileToUpload"),"name"), gs.gp(gs.gp(self,"fileToUpload"),"type")]);
     }]);
   }
  gSobject['deleteFile'] = function(it) {
    var self = this;
    gs.sp(gs.gp(self,"object"),"_lastUpdated",gs.date());
    (gs.gp(self,"object")[gs.gp(self,"prop")]) = null;
    gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"vueWrapperService"),"deleteFile",[gs.gp(gs.gp(self,"object"),"_id"), gs.gp(self,"prop")]),"do",[]);
    gs.mc(gs.fs('cordovaFile', this, gSobject),"deleteFile",[gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id")]);
    gs.mc(gSobject,"init",[self]);
    return gs.mc(self,"removedCallback",[gs.gp(self,"object")]);
   }
  gSobject['startCamera'] = function(it) {
    var self = this;
    gs.sp(self,"uploadSpinner",true);
    gs.mc(self,"initCallback",[gs.gp(self,"object")]);
    return gs.mc(gs.fs('cordovaCamera', this, gSobject),"takePhotoAndUpload",[gs.mc(gSobject,"objectName",[self]), gs.gp(self,"prop"), gs.gp(gs.gp(self,"object"),"_id"), function(localFile, blob) {
      gs.mc(gSobject,"notify",["Photo Uploaded"]);
      gs.sp(self,"uploadSpinner",false);
      return gs.mc(gSobject,"updateMedia",[self, "blob", gs.gp(localFile,"type")]);
     }, function(error) {
      gs.mc(gSobject,"notify",["Photo Upload Failed", "negative"]);
      return gs.sp(self,"uploadSpinner",false);
     }]);
   }
  gSobject['updateMedia'] = function(self, filename, contentType) {
    gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"mediaCacheService"),"deleteCache",[gs.gp(gs.gp(self,"object"),"_id"), gs.gp(self,"prop")]),"do",[]);
    var fileInfo = gs.map().add("id","" + (gs.gp(gs.gp(self,"object"),"_id")) + "_" + (gs.gp(self,"prop")) + "").add("filename",filename).add("contentType",contentType);
    gs.sp(gs.gp(self,"object"),"_lastUpdated",gs.date());
    (gs.gp(self,"object")[gs.gp(self,"prop")]) = fileInfo;
    gs.mc(gSobject,"init",[self]);
    return gs.mc(self,"callback",[gs.gp(self,"object")]);
   }
  gSobject['resolveMediaType'] = function(fileInfo, preview) {
    if ((gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["image"], null, true)) || (gs.bool(preview))) {
      return "image";
     };
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["video"], null, true)) {
      return "video";
     };
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["audio"], null, true)) {
      return "audio";
     };
    if (gs.mc(gs.gp(fileInfo,"contentType",true),"contains",["application"], null, true)) {
      return "pdf";
     };
    return "image";
   }
  gSobject['resolveAcceptedType'] = function(type) {
    if (gs.equals(type, "pdf")) {
      return "application/pdf";
     };
    if (gs.equals(type, "video")) {
      return "video/*";
     };
    if (gs.equals(type, "audio")) {
      return "audio/*";
     };
    if (gs.equals(type, "image")) {
      return "image/*";
     };
   }
  gSobject.clearPdfViewer = function() {
    const element = document.getElementById("pdf-viewer");
        while (element.firstChild) { element.removeChild(element.lastChild); }
   }
  gSobject['handlePlayback'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"customControls"))) {
      return null;
     };
    if (gs.bool(gs.gp(self,"videoEnded"))) {
      gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
     } else {
      if (gs.bool(gs.gp(self,"videoPlaying"))) {
        gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"pause",[]);
        gs.sp(self,"videoPlaying",false);
       } else {
        if (!gs.bool(gs.gp(self,"videoPlaying"))) {
          gs.mc(gs.gp(gs.gp(self,"$refs"),"video"),"play",[]);
          gs.sp(self,"videoPlaying",true);
         };
       };
     };
    return gs.sp(self,"videoEnded",false);
   }
  gSobject['playbackEnded'] = function(it) {
    var self = this;
    return gs.sp(self,"videoEnded",true);
   }
  gSobject['goFullscreen'] = function(it) {
    var self = this;
    var video = gs.gp(gs.gp(self,"$refs"),"video");
    if (gs.bool(gs.gp(video,"requestFullscreen"))) {
      return gs.mc(video,"requestFullscreen",[]);
     };
    if (gs.bool(gs.gp(video,"webkitRequestFullscreen"))) {
      return gs.mc(video,"webkitRequestFullscreen",[]);
     };
   }
  gSobject['handleMute'] = function(it) {
    var self = this;
    if (gs.bool(gs.gp(self,"videoMuted"))) {
      gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",false);
      return gs.sp(self,"videoMuted",false);
     } else {
      gs.sp(gs.gp(gs.gp(self,"$refs"),"video"),"muted",true);
      return gs.sp(self,"videoMuted",true);
     };
   }
  gSobject['updateImageMetadata'] = function(metadata) {
    var self = this;
    return gs.sp(self,"imageMetadata",metadata);
   }
  gSobject['hasLocationData'] = function(it) {
    var self = this;
    return (gs.gp(gs.gp(self,"imageMetadata"),"latitude",true) != null) && (gs.gp(gs.gp(self,"imageMetadata"),"longitude",true) != null);
   }
  gSobject['loadGoogleMapsLink'] = function(it) {
    var self = this;
    return "https://www.google.com/maps?q=" + (gs.gp(gs.gp(self,"imageMetadata"),"latitude")) + "," + (gs.gp(gs.gp(self,"imageMetadata"),"longitude")) + "";
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
I3Media.PREVIEW_LIMIT = gs.multiply((gs.multiply(10, 1024)), 1024);

function I3Page() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Page', simpleName: 'I3Page'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list([]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitMapsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitMapsTab', simpleName: 'UnitMapsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject.self = null;
  gSobject.pollingTimer = null;
  gSobject.data = function(it) {
    return gs.map().add("distanceKm",null);
   };
  gSobject['mounted'] = function(it) {
    gSobject.self = this;
    gs.mc(gSobject,"initMap",[]);
    if (gs.bool(gs.gp(gSobject.self,"unitId"))) {
      return gs.mc(gSobject.self,"loadMapData",[gs.gp(gSobject.self,"unitId")]);
     };
   }
  gSobject['destroyed'] = function(it) {
    gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
    return gs.mc(gSobject,"cleanupDarkObserver",[]);
   }
  gSobject['watchUnitId'] = function(newVal, oldVal) {
    gSobject.self = this;
    gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
    gs.sp(gSobject.self,"distanceKm",null);
    if (gs.bool(newVal)) {
      return gs.mc(gSobject.self,"loadMapData",[newVal]);
     };
   }
  gSobject['loadMapData'] = function(unitId) {
    gSobject.self = this;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchUnitMapHistory",[unitId, function(payload) {
      var route = gs.elvis(gs.bool(gs.gp(payload,"route",true)) , gs.gp(payload,"route",true) , gs.list([]));
      var latest = gs.gp(payload,"latest",true);
      gs.sp(gSobject.self,"distanceKm",gs.mc(gSobject.self,"calculateRouteDistance",[route]));
      if (gs.bool(latest)) {
        gs.mc(gSobject.self,"showUnitLocation",[gs.gp(latest,"lat"), gs.gp(latest,"lng"), route, latest]);
       };
      gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
      return gSobject.pollingTimer = gs.execStatic(Utils,'setInterval', this,[function(it) {
        return gs.mc(gSobject.self,"pollLatest",[unitId]);
       }, 60000]);
     }]);
   }
  gSobject['pollLatest'] = function(unitId) {
    gSobject.self = this;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchUnitMapHistory",[unitId, function(payload) {
      var latest = gs.gp(payload,"latest",true);
      var route = gs.elvis(gs.bool(gs.gp(payload,"route",true)) , gs.gp(payload,"route",true) , gs.list([]));
      gs.sp(gSobject.self,"distanceKm",gs.mc(gSobject.self,"calculateRouteDistance",[route]));
      if (gs.bool(latest)) {
        return gs.mc(gSobject.self,"updateMap",[gs.gp(latest,"lat"), gs.gp(latest,"lng"), route, latest]);
       };
     }]);
   }
  gSobject.calculateRouteDistance = function(route) {
    if (!route || route.length < 2) return 0;
        var R = 6371;
        var toRad = function(d) { return d * Math.PI / 180; };
        var total = 0;
        for (var i = 1; i < route.length; i++) {
            var a = route[i-1];
            var b = route[i];
            if (!a || !b || a.lat == null || b.lat == null || a.lng == null || b.lng == null) continue;
            var dLat = toRad(b.lat - a.lat);
            var dLng = toRad(b.lng - a.lng);
            var lat1 = toRad(a.lat);
            var lat2 = toRad(b.lat);
            var h = Math.sin(dLat/2) * Math.sin(dLat/2) + Math.sin(dLng/2) * Math.sin(dLng/2) * Math.cos(lat1) * Math.cos(lat2);
            total += R * (2 * Math.atan2(Math.sqrt(h), Math.sqrt(1-h)));
        }
        return total;
   }
  gSobject.initMap = function() {
    var self = this;
        var el = document.getElementById('unit-map');
        if (!el) return;
        if (!window.google || !window.google.maps) {
            setTimeout(function() { self.initMap(); }, 500);
            return;
        }

        var darkStyles = [
            { elementType: "geometry", stylers: [{ color: "#212121" }] },
            { elementType: "labels.icon", stylers: [{ visibility: "off" }] },
            { elementType: "labels.text.fill", stylers: [{ color: "#757575" }] },
            { elementType: "labels.text.stroke", stylers: [{ color: "#212121" }] },
            { featureType: "administrative.country", elementType: "labels.text.fill", stylers: [{ color: "#9e9e9e" }] },
            { featureType: "administrative.locality", elementType: "labels.text.fill", stylers: [{ color: "#bdbdbd" }] },
            { featureType: "poi", elementType: "labels.text.fill", stylers: [{ color: "#757575" }] },
            { featureType: "poi.park", elementType: "geometry", stylers: [{ color: "#181818" }] },
            { featureType: "road", elementType: "geometry.fill", stylers: [{ color: "#2c2c2c" }] },
            { featureType: "road", elementType: "labels.text.fill", stylers: [{ color: "#8a8a8a" }] },
            { featureType: "road.highway", elementType: "geometry", stylers: [{ color: "#3c3c3c" }] },
            { featureType: "water", elementType: "geometry", stylers: [{ color: "#000000" }] },
            { featureType: "water", elementType: "labels.text.fill", stylers: [{ color: "#3d3d3d" }] }
        ];
        var isDark = document.body.classList.contains('body--dark');

        var map = new google.maps.Map(el, {
            zoom: 5,
            center: { lat: -29.0, lng: 25.0 },
            mapTypeId: 'roadmap',
            styles: isDark ? darkStyles : []
        });

        window._unitMap = map;
        window._unitMarker = null;
        window._unitInfoWindow = null;
        window._unitPolyline = null;
        window._unitMapDarkStyles = darkStyles;

        if (window._unitMapObserver) window._unitMapObserver.disconnect();
        window._unitMapObserver = new MutationObserver(function() {
            var nowDark = document.body.classList.contains('body--dark');
            if (window._unitMap) {
                window._unitMap.setOptions({ styles: nowDark ? window._unitMapDarkStyles : [] });
            }
        });
        window._unitMapObserver.observe(document.body, { attributes: true, attributeFilter: ['class'] });
   }
  gSobject.cleanupDarkObserver = function() {
    if (window._unitMapObserver) {
            window._unitMapObserver.disconnect();
            window._unitMapObserver = null;
        }
   }
  gSobject.showUnitLocation = function(lat, lon, route, latest) {
    var map = window._unitMap;
        if (!map) return;

        var center = { lat: lat, lng: lon };
        map.setCenter(center);

        var currentZoom = map.getZoom() || 5;
        var targetZoom = 12;
        var step = 0;
        var totalSteps = targetZoom - currentZoom;
        if (totalSteps > 0) {
            var interval = setInterval(function() {
                step++;
                map.setZoom(currentZoom + step);
                if (step >= totalSteps) clearInterval(interval);
            }, 120);
        }

        var path = (route && route.length > 0) ? route.map(function(p) { return { lat: p.lat, lng: p.lng }; }) : [];

        var polyline = new google.maps.Polyline({
            path: path,
            map: path.length > 1 ? map : null,
            strokeColor: '#FF6F00',
            strokeOpacity: 0.85,
            strokeWeight: 5
        });

        if (path.length > 1) {
            new google.maps.Marker({
                position: path[0],
                map: map,
                title: route[0].date || '24 hours ago',
                icon: {
                    path: google.maps.SymbolPath.CIRCLE,
                    scale: 8,
                    fillColor: '#4CAF50',
                    fillOpacity: 1,
                    strokeColor: '#ffffff',
                    strokeWeight: 2
                }
            });
        }

        var infoContent = latest
            ? '<div style="padding:4px 2px"><strong>Current Location</strong><br><small>' + (latest.date || '') + '</small></div>'
            : '<div style="padding:4px 2px"><strong>Current Location</strong></div>';

        var infoWindow = new google.maps.InfoWindow({ content: infoContent });
        var marker = new google.maps.Marker({
            position: center,
            map: map,
            title: 'Current Location',
            icon: {
                path: google.maps.SymbolPath.CIRCLE,
                scale: 10,
                fillColor: '#1565C0',
                fillOpacity: 1,
                strokeColor: '#ffffff',
                strokeWeight: 2.5
            },
            zIndex: 10
        });
        marker.addListener('click', function() {
            infoWindow.open(map, marker);
        });

        window._unitMarker = marker;
        window._unitInfoWindow = infoWindow;
        window._unitPolyline = polyline;
   }
  gSobject.updateMap = function(lat, lon, route, latest) {
    var map = window._unitMap;
        if (!map) return;

        var marker = window._unitMarker;
        var polyline = window._unitPolyline;
        var infoWindow = window._unitInfoWindow;

        var newPos = { lat: lat, lng: lon };

        if (!marker) {
            this.showUnitLocation(lat, lon, route, latest);
            return;
        }

        marker.setPosition(newPos);

        if (infoWindow && latest) {
            infoWindow.setContent('<div style="padding:4px 2px"><strong>Current Location</strong><br><small>' + (latest.date || '') + '</small></div>');
        }

        if (polyline && route && route.length > 1) {
            var path = route.map(function(p) { return { lat: p.lat, lng: p.lng }; });
            polyline.setPath(path);
            polyline.setMap(map);
        }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminAppConfigComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminAppConfigComponent', simpleName: 'AdminAppConfigComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"searchText","");
    gs.sp(gSobject.scope,"sounds",gs.list([]));
    gs.sp(gSobject.scope,"pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","name").add("descending",false));
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","preview").add("label","Preview").add("field","preview").add("align","left") , gs.map().add("name","actions").add("label","").add("field","actions").add("align","right")]));
    gs.sp(gSobject.scope,"dialogOpen",false);
    gs.sp(gSobject.scope,"editing",gs.map().add("_id",null).add("name","").add("sound",null));
    gs.sp(gSobject.scope,"isNew",false);
    return gs.mc(gSobject,"loadSounds",[]);
   }
  gSobject['loadSounds'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"paginatedSounds",[gs.gp(gSobject.scope,"searchText"), gs.map(), gs.gp(gSobject.scope,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"sounds",gs.gp(data,"sounds"));
      return gs.sp(gs.gp(gSobject.scope,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.scope,"pagination",pagination);
    return gs.mc(gSobject,"loadSounds",[]);
   }
  gSobject['soundUrl'] = function(row) {
    if (((!gs.bool(row)) || (!gs.bool(gs.gp(row,"_id")))) || (!gs.bool(gs.gp(row,"sound")))) {
      return "";
     };
    var ts = gs.gp(row,"_lastUpdated");
    try {
      ts = gs.mc(ts,"getTime",[]);
     }
    catch (all) {
      try {
        ts = gs.mc(gs.date(ts),"getTime",[]);
       }
      catch (all2) {
       }
      ;
     }
    ;
    return gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("/media-cache/file/", gs.gp(row,"_id"))), "/sound/")), ts)), "/")), gs.gp(gs.gp(row,"sound"),"filename"));
   }
  gSobject['onTableRequest'] = function(props) {
    gs.sp(gSobject.scope,"pagination",gs.gp(props,"pagination"));
    return gs.mc(gSobject,"loadSounds",[]);
   }
  gSobject['onRowClick'] = function(evt, row) {
    return gs.mc(gSobject,"selectSound",[gs.gp(row,"_id")]);
   }
  gSobject['newSound'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"save",[gs.map().add("name",""), function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"editing",saved);
      gs.sp(gSobject.scope,"isNew",true);
      return gs.sp(gSobject.scope,"dialogOpen",true);
     }]);
   }
  gSobject['selectSound'] = function(id) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"fetchOneById",[id, function(record) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"editing",record);
      gs.sp(gSobject.scope,"isNew",false);
      return gs.sp(gSobject.scope,"dialogOpen",true);
     }]);
   }
  gSobject['saveDialog'] = function(it) {
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"editing"),"name"),"trim",[], null, true))) {
      return gs.mc(gSobject,"notify",["Name is required", "negative"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"save",[gs.gp(gSobject.scope,"editing"), function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"editing",saved);
      gs.sp(gSobject.scope,"isNew",false);
      gs.sp(gSobject.scope,"dialogOpen",false);
      gs.mc(gSobject,"notify",["Sound saved", "positive"]);
      return gs.mc(gSobject,"loadSounds",[]);
     }]);
   }
  gSobject['cancelDialog'] = function(it) {
    if ((gs.bool(gs.gp(gSobject.scope,"isNew"))) && (gs.bool(gs.gp(gs.gp(gSobject.scope,"editing"),"_id")))) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"delete",[gs.gp(gs.gp(gSobject.scope,"editing"),"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.scope,"dialogOpen",false);
        gs.sp(gSobject.scope,"isNew",false);
        return gs.mc(gSobject,"loadSounds",[]);
       }]);
     } else {
      return gs.sp(gSobject.scope,"dialogOpen",false);
     };
   }
  gSobject['onSoundUploaded'] = function(it) {
    return gs.mc(gSobject,"refreshEditing",[]);
   }
  gSobject['deleteSoundFile'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"vueWrapperService"),"deleteFile",[gs.gp(gs.gp(gSobject.scope,"editing"),"_id"), "sound", function(it) {
      return gs.mc(gSobject,"refreshEditing",[]);
     }]);
   }
  gSobject['refreshEditing'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"fetchOneById",[gs.gp(gs.gp(gSobject.scope,"editing"),"_id"), function(fresh) {
      gs.sp(gSobject.scope,"editing",fresh);
      return gs.mc(gSobject,"loadSounds",[]);
     }]);
   }
  gSobject['removeSound'] = function(row) {
    return gs.mc(gSobject,"confirmAndDelete",[gs.gp(row,"_id"), gs.gp(row,"name")]);
   }
  gSobject['deleteFromDialog'] = function(it) {
    return gs.mc(gSobject,"confirmAndDelete",[gs.gp(gs.gp(gSobject.scope,"editing"),"_id"), gs.gp(gs.gp(gSobject.scope,"editing"),"name"), function(it) {
      return gs.sp(gSobject.scope,"dialogOpen",false);
     }]);
   }
  gSobject['confirmAndDelete'] = function(id, name, onComplete) {
    if (onComplete === undefined) onComplete = null;
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Sound").add("message",gs.plus((gs.plus("Are you sure you want to delete \"", name)), "\"?")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"delete",[id, function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Sound deleted", "negative"]);
        gs.mc(gSobject,"loadSounds",[]);
        if (gs.bool(onComplete)) {
          return gs.execCall(onComplete, this, []);
         };
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaBrowser() {
  var gSobject = gs.init('CordovaBrowser');
  gSobject.clazz = { name: 'CordovaBrowser', simpleName: 'CordovaBrowser'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['openInApp'] = function(url, options) {
    if (options === undefined) options = gs.map();
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBrowser: InAppBrowser not installed"]);
      return null;
     };
    try {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_blank", gs.mc(gSobject,"optionsString",[options])]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openInApp: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['openSystem'] = function(url) {
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBrowser: InAppBrowser not installed"]);
      return null;
     };
    try {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_system"]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openSystem: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['openHidden'] = function(url, onLoad) {
    if (onLoad === undefined) onLoad = function(it) {
     };
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaBrowser: InAppBrowser not installed"]);
      return null;
     };
    try {
      var ref = gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, "_blank", "hidden=yes"]);
      gs.mc(ref,"addEventListener",["loadstop", function(event) {
        gs.execCall(onLoad, this, [event]);
        try {
          gs.mc(ref,"close",[]);
         }
        catch (e2) {
         }
        ;
       }]);
      gs.mc(ref,"addEventListener",["loaderror", function(event) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openHidden loaderror: " + (event) + ""]);
        try {
          gs.mc(ref,"close",[]);
         }
        catch (e2) {
         }
        ;
       }]);
      return ref;
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["openHidden: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['open'] = function(url, target, options) {
    if (target === undefined) target = "_blank";
    if (options === undefined) options = gs.map();
    if (!gs.bool(CordovaBrowser.browserInstalled())) {
      return null;
     };
    try {
      return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[url, target, gs.mc(gSobject,"optionsString",[options])]);
     }
    catch (e) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["open: " + (gs.fs('e', this, gSobject)) + ""]);
      return null;
     }
    ;
   }
  gSobject['optionsString'] = function(opts) {
    if ((gs.equals(opts, null)) || ((gs.instanceOf(opts, "Map")) && (gs.mc(opts,"isEmpty",[])))) {
      return "";
     };
    if (gs.instanceOf(opts, "String")) {
      return opts;
     };
    var parts = gs.list([]);
    gs.mc(opts,"each",[function(k, v) {
      return gs.mc(parts,"add",["" + (k) + "=" + (v) + ""]);
     }]);
    return gs.mc(parts,"join",[","]);
   }
  gSobject.browserInstalled = function() { return CordovaBrowser.browserInstalled(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaBrowser.browserInstalled = function() {
  return typeof cordova !== 'undefined' && typeof cordova.InAppBrowser !== 'undefined';
 }

function AdminRelayDestinationsComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminRelayDestinationsComponent', simpleName: 'AdminRelayDestinationsComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"destinations",gs.list([]));
    gs.sp(gSobject.scope,"showCreateDialog",false);
    gs.sp(gSobject.scope,"showEditDialog",false);
    gs.sp(gSobject.scope,"newDest",gs.map());
    gs.sp(gSobject.scope,"editDest",gs.map());
    gs.sp(gSobject.scope,"providerOptions",gs.list([gs.map().add("label","All providers").add("value","") , gs.map().add("label","cw-gateway").add("value","cw-gateway") , gs.map().add("label","flespi").add("value","flespi")]));
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","url").add("label","URL").add("field","url").add("align","left").add("sortable",true) , gs.map().add("name","provider").add("label","Provider").add("field","provider").add("align","left").add("sortable",true) , gs.map().add("name","enabled").add("label","Enabled").add("field","enabled").add("align","left").add("sortable",true) , gs.map().add("name","cursor").add("label","Last Forwarded").add("field","lastForwardedAtText").add("align","left").add("sortable",true) , gs.map().add("name","status").add("label","Last Status").add("field","lastStatus").add("align","left") , gs.map().add("name","actions").add("label","").add("field","actions").add("align","right")]));
    gs.sp(gSobject.scope,"pagination",gs.map().add("page",1).add("rowsPerPage",20).add("sortBy","name").add("descending",false));
    return gs.mc(gSobject,"loadDestinations",[]);
   }
  gSobject['loadDestinations'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwRelayService"),"listDestinations",[function(rows) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.sp(gSobject.scope,"destinations",gs.mc(gs.elvis(gs.bool(rows) , rows , gs.list([])),"collect",[function(row) {
        gs.sp(row,"lastForwardedAtText",gs.mc(gSobject,"formatTime",[gs.gp(row,"lastForwardedAt")]));
        return row;
       }]));
     }]);
   }
  gSobject['formatTime'] = function(value) {
    if (!gs.bool(value)) {
      return "";
     };
    var date = (gs.instanceOf(value, "Date") ? value : gs.date(value));
    return gs.mc(date,"format",["dd/MM/yyyy HH:mm"]);
   }
  gSobject['openCreateDialog'] = function(it) {
    gs.sp(gSobject.scope,"newDest",gs.map().add("name","").add("url","").add("provider","").add("enabled",true));
    return gs.sp(gSobject.scope,"showCreateDialog",true);
   }
  gSobject['createDestination'] = function(it) {
    var d = gs.gp(gSobject.scope,"newDest");
    if (!gs.bool(gs.mc(gs.gp(d,"name"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Name is required", "negative"]);
      return null;
     };
    if (!gs.bool(gs.mc(gs.gp(d,"url"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["URL is required", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwRelayService"),"saveDestination",["", gs.gp(d,"name"), gs.gp(d,"url"), gs.elvis(gs.bool(gs.gp(d,"provider")) , gs.gp(d,"provider") , ""), gs.equals(gs.gp(d,"enabled"), true), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error"))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.sp(gSobject.scope,"showCreateDialog",false);
      gs.mc(gSobject,"notify",["Destination created — forwarding starts from now"]);
      return gs.mc(gSobject,"loadDestinations",[]);
     }]);
   }
  gSobject['openEditDialog'] = function(row) {
    gs.sp(gSobject.scope,"editDest",gs.map().add("_id",gs.gp(row,"_id")).add("name",gs.gp(row,"name")).add("url",gs.gp(row,"url")).add("provider",gs.elvis(gs.bool(gs.gp(row,"provider")) , gs.gp(row,"provider") , "")).add("enabled",gs.equals(gs.gp(row,"enabled"), true)));
    return gs.sp(gSobject.scope,"showEditDialog",true);
   }
  gSobject['saveEditDestination'] = function(it) {
    var d = gs.gp(gSobject.scope,"editDest");
    if (!gs.bool(gs.mc(gs.gp(d,"url"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["URL is required", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwRelayService"),"saveDestination",[gs.gp(d,"_id"), gs.gp(d,"name"), gs.gp(d,"url"), gs.elvis(gs.bool(gs.gp(d,"provider")) , gs.gp(d,"provider") , ""), gs.equals(gs.gp(d,"enabled"), true), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error"))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.sp(gSobject.scope,"showEditDialog",false);
      gs.mc(gSobject,"notify",["Destination updated"]);
      return gs.mc(gSobject,"loadDestinations",[]);
     }]);
   }
  gSobject['toggleEnabled'] = function(row, val) {
    var newVal = gs.equals(val, true);
    gs.sp(row,"enabled",newVal);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwRelayService"),"setEnabled",[gs.gp(row,"_id"), newVal, function(result) {
      if (gs.bool(gs.gp(result,"error",true))) {
        gs.sp(row,"enabled",!newVal);
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      return gs.mc(gSobject,"notify",[gs.plus((gs.bool(newVal) ? "Enabled " : "Disabled "), gs.elvis(gs.bool(gs.gp(row,"name")) , gs.gp(row,"name") , "destination"))]);
     }]);
   }
  gSobject['resetCursor'] = function(row) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Reset Cursor").add("message",gs.plus((gs.plus("Reset \"", gs.elvis(gs.bool(gs.gp(row,"name")) , gs.gp(row,"name") , ""))), "\" to forward only NEW fixes from now? Any currently-unsent older fixes will be skipped.")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwRelayService"),"resetCursorToNow",[gs.gp(row,"_id"), function(result) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(result,"error",true))) {
          gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
          return null;
         };
        gs.mc(gSobject,"notify",["Cursor reset to now"]);
        return gs.mc(gSobject,"loadDestinations",[]);
       }]);
     }]);
   }
  gSobject['removeDestination'] = function(row) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Destination").add("message",gs.plus((gs.plus("Delete relay destination \"", gs.elvis(gs.bool(gs.gp(row,"name")) , gs.gp(row,"name") , ""))), "\"? Forwarding to this location will stop.")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwRelayService"),"deleteDestination",[gs.gp(row,"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Destination deleted", "negative"]);
        return gs.mc(gSobject,"loadDestinations",[]);
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueDocumentViewer() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueDocumentViewer', simpleName: 'VueDocumentViewer'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["oObject" , "oName" , "oPropName" , "download" , "filePreview" , "displayName" , "myStyle"]);
  gSobject.data = function(it) {
    return gs.map().add("showFullscreenDialog",false);
   };
  gSobject['mounted'] = function(it) {
    var self = this;
    var fileInfo = gs.gp(self,"oObject")[gs.gp(self,"oPropName")];
    var lastUpdated = gs.gp(gs.gp(self,"oObject"),"_lastUpdated");
    try {
      lastUpdated = gs.mc(lastUpdated,"getTime",[]);
     }
    catch (all) {
     }
    ;
    gs.sp(self,"pdfUrl","/media-cache/file/" + (gs.gp(gs.gp(self,"oObject"),"_id")) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    gs.sp(self,"preview","/media-cache/filePreview/" + (gs.gp(gs.gp(self,"oObject"),"_id")) + "/" + (gs.gp(self,"oPropName")) + "/" + (lastUpdated) + "/" + (gs.gp(fileInfo,"filename")) + "");
    if (!gs.bool(gs.gp(self,"download"))) {
      gs.sp(self,"download",false);
     };
    if (!gs.bool(gs.gp(self,"filePreview"))) {
      gs.sp(self,"filePreview",false);
     };
    if (!gs.bool(gs.gp(self,"displayName"))) {
      gs.sp(self,"displayName",false);
     };
    return gs.sp(self,"showFullscreenDialog",false);
   }
  gSobject['objectLoaded'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"oObject"))) {
      return false;
     };
    return true;
   }
  gSobject['show'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"filePreview"))) {
      return null;
     };
    gs.mc(gs.gp(gs.mc(gSobject,"getRefs",[]),"dialog"),"show",[]);
    gs.mc(gSobject,"nextTick",[function(it) {
      PdfJsHandler(gs.gp(self,"pdfUrl"));
      return HammerJsZoom("pdf_canvas");
     }]);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["any"]);
     };
   }
  gSobject['hideFullscreenDialog'] = function(it) {
    gs.sp(gSobject.self,"showFullscreenDialog",false);
    if (gs.execStatic(Utils,'isCordova', this,[])) {
      return gs.mc(gs.gp(gs.fs('screen', this, gSobject),"orientation"),"lock",["portrait"]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3Select() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Select', simpleName: 'I3Select'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("modelValue",gs.map().add("type",String).add("default","")).add("beforeIcon",gs.map().add("type",String).add("default","")).add("prependIcon",gs.map().add("type",String).add("default","")).add("appendIcon",gs.map().add("type",String).add("default","")).add("afterIcon",gs.map().add("type",String).add("default",""));
  gSobject.defaults = gs.map().add("filled",true).add("dense",false).add("outlined",false).add("rounded",false).add("borderless",false).add("square",false).add("dense",true).add("debounce","500");
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
    var appConfig = gs.elvis(gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig")) , gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig") , gs.map());
    var config = (gs.gp(appConfig,"input") != null ? gs.gp(appConfig,"input") : gs.map());
    var attrs = (gs.gp(self,"$attrs") != null ? gs.gp(self,"$attrs") : gs.map());
    return gs.sp(self,"selectProps",gs.toJavascript(gs.plus((gs.plus(gSobject.defaults, config)), attrs)));
   }
  gSobject['update'] = function(val) {
    var self = this;
    gs.mc(self,"$emit",["update:modelValue", val]);
    return gs.mc(self,"$emit",["change"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminUserDetailsComponent() {
  var gSobject = gs.init('AdminUserDetailsComponent');
  gSobject.clazz = { name: 'AdminUserDetailsComponent', simpleName: 'AdminUserDetailsComponent'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorGraphComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'SensorGraphComponent', simpleName: 'SensorGraphComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("type",String).add("sensorId",String).add("snoozed",Boolean).add("currentTemp",Number).add("low",Number).add("high",Number).add("lowWarn",Number).add("highWarn",Number);
  gSobject.data = function(it) {
    return gs.map().add("isSnoozed",false).add("showSnoozeDialog",false).add("lowRedStyle",gs.map().add("display","none")).add("lowWarnStyle",gs.map().add("display","none")).add("greenStyle",gs.map().add("display","none")).add("middleRangeClass","bg-positive").add("highWarnStyle",gs.map().add("display","none")).add("highRedStyle",gs.map().add("display","none")).add("currentIndicatorStyle",gs.map().add("display","none")).add("currentValueStyle",gs.map().add("display","none")).add("highValueStyle",gs.map().add("display","none")).add("highWarnValueStyle",gs.map().add("display","none")).add("lowWarnValueStyle",gs.map().add("display","none")).add("lowValueStyle",gs.map().add("display","none")).add("currentText","-").add("highText","-").add("highWarnText","-").add("lowWarnText","-").add("lowText","-");
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.sp(self,"isSnoozed",gs.elvis(gs.bool(gs.gp(self,"snoozed")) , gs.gp(self,"snoozed") , false));
   }
  gSobject['mounted'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.mc(self,"refreshGraph",[self]);
     }]);
   }
  gSobject['watchSnoozed'] = function(newValue, oldValue) {
    var self = this;
    return gs.sp(self,"isSnoozed",gs.elvis(gs.bool(newValue) , newValue , false));
   }
  gSobject['snoozeGraphStyle'] = function(self) {
    if (self === undefined) self = this;
    if (gs.bool(gs.gp(self,"isSnoozed"))) {
      return gs.map().add("filter","grayscale(1) opacity(0.5)");
     };
    return gs.map();
   }
  gSobject['doSnooze'] = function(minutes) {
    var self = this;
    if (!gs.bool(gs.gp(self,"sensorId"))) {
      return null;
     };
    gs.sp(self,"showSnoozeDialog",false);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"snooze",[gs.gp(self,"sensorId"), minutes, function(result) {
      gs.sp(self,"isSnoozed",true);
      return gs.mc(self,"refreshGraph",[self]);
     }]);
   }
  gSobject['doUnsnooze'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"sensorId"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"unsnooze",[gs.gp(self,"sensorId"), function(result) {
      gs.sp(self,"isSnoozed",false);
      return gs.mc(self,"refreshGraph",[self]);
     }]);
   }
  gSobject['openSnoozeDialog'] = function(it) {
    var self = this;
    return gs.sp(self,"showSnoozeDialog",true);
   }
  gSobject['closeSnoozeDialog'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.sp(self,"showSnoozeDialog",false);
     }]);
   }
  gSobject['rangeBounds'] = function(self) {
    if (self === undefined) self = this;
    var values = gs.mc(gs.list([gs.gp(self,"currentTemp") , gs.gp(self,"low") , gs.gp(self,"high") , gs.gp(self,"lowWarn") , gs.gp(self,"highWarn")]),"findAll",[function(it) {
      return it != null;
     }]);
    if (!gs.bool(values)) {
      return gs.map().add("min",0.0).add("max",1.0);
     };
    var minVal = gs.mc(values,"min",[]);
    var maxVal = gs.mc(values,"max",[]);
    if (gs.gp(self,"low") != null) {
      minVal = Math.min(minVal, gs.minus(gs.gp(self,"low"), 5.0));
     };
    if (gs.gp(self,"high") != null) {
      maxVal = Math.max(maxVal, gs.plus(gs.gp(self,"high"), 5.0));
     };
    if (gs.equals(minVal, maxVal)) {
      minVal = (gs.minus(minVal, 1.0));
      maxVal = (gs.plus(maxVal, 1.0));
     };
    return gs.map().add("min",minVal).add("max",maxVal);
   }
  gSobject['valuePercent'] = function(value, self) {
    if (self === undefined) self = this;
    if (gs.equals(value, null)) {
      return 0.0;
     };
    var num = value;
    var bounds = gs.mc(gSobject,"rangeBounds",[self]);
    var span = gs.minus(gs.gp(bounds,"max"), gs.gp(bounds,"min"));
    if (span <= 0.0) {
      return 0.0;
     };
    var raw = gs.multiply((gs.div((gs.minus(num, gs.gp(bounds,"min"))), span)), 100.0);
    return Math.max(0.0, Math.min(100.0, raw));
   }
  gSobject['zoneStyle'] = function(fromValue, toValue, self) {
    if (self === undefined) self = this;
    var fromNum = fromValue;
    var toNum = toValue;
    if ((gs.equals(fromNum, null)) || (gs.equals(toNum, null))) {
      return gs.map().add("display","none");
     };
    var fromPercent = gs.mc(gSobject,"valuePercent",[fromNum, self]);
    var toPercent = gs.mc(gSobject,"valuePercent",[toNum, self]);
    var bottom = Math.min(fromPercent, toPercent);
    var top = Math.max(fromPercent, toPercent);
    return gs.map().add("position","absolute").add("left","0").add("right","0").add("bottom","" + (bottom) + "%").add("height","" + (gs.minus(top, bottom)) + "%");
   }
  gSobject['currentIndicatorStyle'] = function(self) {
    if (self === undefined) self = this;
    var temp = gs.gp(self,"currentTemp");
    if (gs.equals(temp, null)) {
      return gs.map().add("display","none");
     };
    var percent = gs.mc(gSobject,"valuePercent",[temp, self]);
    return gs.map().add("position","absolute").add("left","38px").add("width","40px").add("bottom","calc(" + (percent) + "% - 1px)").add("height","2px").add("borderRadius","2px");
   }
  gSobject['currentValuePositionStyle'] = function(self) {
    if (self === undefined) self = this;
    var temp = gs.gp(self,"currentTemp");
    if (gs.equals(temp, null)) {
      return gs.map().add("display","none");
     };
    var percent = gs.mc(gSobject,"valuePercent",[temp, self]);
    return gs.map().add("position","absolute").add("left","82px").add("bottom","calc(" + (percent) + "% - 7px)").add("lineHeight","1");
   }
  gSobject['valueStyle'] = function(value, self) {
    if (self === undefined) self = this;
    if (gs.equals(value, null)) {
      return gs.map().add("display","none");
     };
    var percent = gs.mc(gSobject,"valuePercent",[value, self]);
    return gs.map().add("position","absolute").add("right","0").add("bottom","calc(" + (percent) + "% - 8px)").add("lineHeight","1");
   }
  gSobject['currentValueLabel'] = function(value, self) {
    if (self === undefined) self = this;
    if (gs.equals(value, null)) {
      return "-";
     };
    var num = value;
    var typeValue = (gs.bool(gs.gp(self,"type")) ? gs.mc(gs.mc(gs.gp(self,"type"),"toString",[]),"toLowerCase",[]) : "");
    if ((gs.equals(typeValue, "digitalinput")) || (gs.equals(typeValue, "digitaloutput"))) {
      return (num > 0.0 ? "ON" : "OFF");
     };
    var text = gs.div(Math.floor(gs.multiply(num, 10)), 10);
    if (gs.equals(typeValue, "humidity")) {
      return gs.plus(text, "%");
     };
    if (gs.equals(typeValue, "co2")) {
      return gs.plus(text, " ppm");
     };
    return gs.plus(text, "°C");
   }
  gSobject['rangeValueLabel'] = function(value) {
    if (gs.equals(value, null)) {
      return "-";
     };
    var num = value;
    return gs.div(Math.floor(gs.multiply(num, 10)), 10);
   }
  gSobject['barStyle'] = function(it) {
    return gs.map().add("width","36px").add("height","200px").add("borderRadius","6px").add("overflow","hidden");
   }
  gSobject['zoneLowRedStyle'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"zoneStyle",[gs.gp(gs.mc(gSobject,"rangeBounds",[self]),"min"), gs.gp(self,"low"), self]);
   }
  gSobject['zoneLowWarnStyle'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"zoneStyle",[gs.gp(self,"low"), gs.gp(self,"lowWarn"), self]);
   }
  gSobject['zoneGreenStyle'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"zoneStyle",[gs.gp(self,"lowWarn"), gs.gp(self,"highWarn"), self]);
   }
  gSobject['zoneHighWarnStyle'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"zoneStyle",[gs.gp(self,"highWarn"), gs.gp(self,"high"), self]);
   }
  gSobject['zoneHighRedStyle'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"zoneStyle",[gs.gp(self,"high"), gs.gp(gs.mc(gSobject,"rangeBounds",[self]),"max"), self]);
   }
  gSobject['watchCurrentTemp'] = function(newValue, oldValue) {
    var self = this;
    return gs.mc(gSobject,"nextTick",[function(it) {
      return gs.mc(self,"refreshGraph",[self]);
     }]);
   }
  gSobject['refreshGraph'] = function(self) {
    if (self === undefined) self = this;
    var typeValue = (gs.bool(gs.gp(self,"type")) ? gs.mc(gs.mc(gs.gp(self,"type"),"toString",[]),"toLowerCase",[]) : "");
    var okColor = "bg-positive";
    if (gs.equals(typeValue, "humidity")) {
      okColor = "bg-blue";
     } else {
      if (gs.equals(typeValue, "co2")) {
        okColor = "bg-teal";
       } else {
        if ((gs.equals(typeValue, "digitalinput")) || (gs.equals(typeValue, "digitaloutput"))) {
          okColor = "bg-grey-6";
         };
       };
     };
    gs.sp(self,"middleRangeClass",(gs.bool(gs.gp(self,"isSnoozed")) ? "bg-grey-4" : okColor));
    gs.sp(self,"lowRedStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"zoneLowRedStyle",[self])));
    gs.sp(self,"lowWarnStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"zoneLowWarnStyle",[self])));
    gs.sp(self,"greenStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.mc(gSobject,"zoneStyle",[gs.gp(gs.mc(gSobject,"rangeBounds",[self]),"min"), gs.gp(gs.mc(gSobject,"rangeBounds",[self]),"max"), self]) : gs.mc(gSobject,"zoneGreenStyle",[self])));
    gs.sp(self,"highWarnStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"zoneHighWarnStyle",[self])));
    gs.sp(self,"highRedStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"zoneHighRedStyle",[self])));
    gs.sp(self,"currentIndicatorStyle",gs.mc(gSobject,"currentIndicatorStyle",[self]));
    gs.sp(self,"currentValueStyle",gs.mc(gSobject,"currentValuePositionStyle",[self]));
    gs.sp(self,"highValueStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"valueStyle",[gs.gp(self,"high"), self])));
    gs.sp(self,"highWarnValueStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"valueStyle",[gs.gp(self,"highWarn"), self])));
    gs.sp(self,"lowWarnValueStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"valueStyle",[gs.gp(self,"lowWarn"), self])));
    gs.sp(self,"lowValueStyle",(gs.bool(gs.gp(self,"isSnoozed")) ? gs.map().add("display","none") : gs.mc(gSobject,"valueStyle",[gs.gp(self,"low"), self])));
    gs.sp(self,"currentText",gs.mc(gSobject,"currentValueLabel",[gs.gp(self,"currentTemp"), self]));
    gs.sp(self,"highText",gs.mc(gSobject,"rangeValueLabel",[gs.gp(self,"high")]));
    gs.sp(self,"highWarnText",gs.mc(gSobject,"rangeValueLabel",[gs.gp(self,"highWarn")]));
    gs.sp(self,"lowWarnText",gs.mc(gSobject,"rangeValueLabel",[gs.gp(self,"lowWarn")]));
    return gs.sp(self,"lowText",gs.mc(gSobject,"rangeValueLabel",[gs.gp(self,"low")]));
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function VueAdComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'VueAdComponent', simpleName: 'VueAdComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list(["canNavigate" , "rootDomain" , "vertical"]);
  gSobject.timer = null;
  gSobject['mounted'] = function(it) {
    var self = this;
    if (!gs.bool(gs.gp(self,"canNavigate"))) {
      gs.sp(self,"canNavigate",true);
     };
    if (!gs.bool(gs.gp(self,"rootDomain"))) {
      gs.sp(self,"rootDomain","");
     };
    if (!gs.bool(gs.gp(self,"vertical"))) {
      return gs.sp(self,"vertical",false);
     };
   }
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"adIndex",0);
    gs.sp(gSobject.scope,"ad",gs.map());
    gs.mc(gSobject,"loadAd",[]);
    if (!gs.bool(gs.mc(gSobject,"isTimerSet",[]))) {
      return gSobject.timer = gs.execStatic(Utils,'setInterval', this,[function(it) {
        return gs.mc(gSobject,"loadAd",[]);
       }, 60000]);
     };
   }
  gSobject['openAd'] = function(ad) {
    gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"add",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"legionUser"),"_id",true), "fitworld.ad.click", gs.gp(ad,"_id")]),"do",[]);
    if (!gs.bool(gs.gp(ad,"url"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('cordova', this, gSobject),"InAppBrowser"),"open",[gs.gp(ad,"url"), "_system", "location=yes"]);
   }
  gSobject['unmounted'] = function(it) {
    return gs.mc(gSobject,"killTimer",[]);
   }
  gSobject['loadAd'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"vueWrapperService"),"loadAd",[gs.gp(gSobject.scope,"adIndex"), function(result) {
      gs.sp(gSobject.scope,"adIndex",gs.gp(result,"index"));
      gs.sp(gSobject.scope,"ad",gs.gp(result,"ad"));
      return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"metricService"),"add",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"legionUser"),"_id",true), "fitworld.ad.show", gs.gp(gs.gp(result,"ad"),"_id")]),"do",[]);
     }]);
   }
  gSobject['killTimer'] = function(it) {
    if (gs.equals(gSobject.timer, null)) {
      return null;
     };
    gs.execStatic(Utils,'clearInterval', this,[gSobject.timer]);
    return gSobject.timer = null;
   }
  gSobject['isTimerSet'] = function(it) {
    return !gs.equals(gSobject.timer, null);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3Toolbar() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Toolbar', simpleName: 'I3Toolbar'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list([]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminCwUsersComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminCwUsersComponent', simpleName: 'AdminCwUsersComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"searchText","");
    gs.sp(gSobject.scope,"orgFilter",null);
    gs.sp(gSobject.scope,"organisations",gs.list([]));
    gs.sp(gSobject.scope,"users",gs.list([]));
    gs.sp(gSobject.scope,"filteredUsers",gs.list([]));
    gs.sp(gSobject.scope,"roleOptions",gs.list(["Admin" , "Viewer"]));
    gs.sp(gSobject.scope,"showCreateDialog",false);
    gs.sp(gSobject.scope,"showEditDialog",false);
    gs.sp(gSobject.scope,"newUser",gs.map());
    gs.sp(gSobject.scope,"editUser",gs.map());
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","email").add("label","Email").add("field","email").add("align","left").add("sortable",true) , gs.map().add("name","org").add("label","Organisation").add("field","org").add("align","left").add("sortable",true) , gs.map().add("name","role").add("label","Role").add("field","role").add("align","left").add("sortable",true) , gs.map().add("name","active").add("label","Status").add("field","active").add("align","left").add("sortable",true) , gs.map().add("name","newApp").add("label","New App").add("field","newAppEnabled").add("align","left").add("sortable",true) , gs.map().add("name","actions").add("label","").add("field","actions").add("align","right")]));
    gs.sp(gSobject.scope,"pagination",gs.map().add("page",1).add("rowsPerPage",20).add("sortBy","email").add("descending",false));
    gs.mc(gSobject,"loadUsers",[]);
    return gs.mc(gSobject,"loadOrganisations",[]);
   }
  gSobject['loadUsers'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"listAllUsersWithOrgs",[function(users) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"users",gs.elvis(gs.bool(users) , users , gs.list([])));
      return gs.mc(gSobject,"applyFilters",[]);
     }]);
   }
  gSobject['loadOrganisations'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"listAllOrganisations",[function(orgs) {
      return gs.sp(gSobject.scope,"organisations",gs.elvis(gs.bool(orgs) , orgs , gs.list([])));
     }]);
   }
  gSobject['applyFilters'] = function(it) {
    var term = gs.mc(gs.mc(gs.gp(gSobject.scope,"searchText"),"trim",[], null, true),"toLowerCase",[], null, true);
    var orgId = gs.gp(gSobject.scope,"orgFilter");
    return gs.sp(gSobject.scope,"filteredUsers",gs.mc(gs.gp(gSobject.scope,"users"),"findAll",[function(u) {
      var matchesTerm = (!gs.bool(term)) || (gs.equals(gs.mc(gs.mc(gs.gp(u,"email"),"toLowerCase",[], null, true),"contains",[term], null, true), true));
      var matchesOrg = (!gs.bool(orgId)) || (gs.equals(gs.gp(u,"orgId"), orgId));
      return (gs.bool(matchesTerm)) && (gs.bool(matchesOrg));
     }]));
   }
  gSobject['openCreateDialog'] = function(it) {
    gs.sp(gSobject.scope,"newUser",gs.map().add("email","").add("orgId",null).add("role","Viewer"));
    return gs.sp(gSobject.scope,"showCreateDialog",true);
   }
  gSobject['createUser'] = function(it) {
    var d = gs.gp(gSobject.scope,"newUser");
    if (!gs.bool(gs.mc(gs.gp(d,"email"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Email is required", "negative"]);
      return null;
     };
    if (!gs.bool(gs.gp(d,"orgId"))) {
      gs.mc(gSobject,"notify",["Organisation is required", "negative"]);
      return null;
     };
    if (!gs.bool(gs.gp(d,"role"))) {
      gs.mc(gSobject,"notify",["Role is required", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"createUser",[gs.gp(d,"email"), gs.gp(d,"orgId"), gs.gp(d,"role"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error"))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.sp(gSobject.scope,"showCreateDialog",false);
      gs.mc(gSobject,"notify",["User created — invitation email sent"]);
      return gs.mc(gSobject,"loadUsers",[]);
     }]);
   }
  gSobject['openEditDialog'] = function(row) {
    gs.sp(gSobject.scope,"editUser",gs.map().add("_id",gs.gp(row,"_id")).add("email",gs.gp(row,"email")).add("orgId",gs.gp(row,"orgId")).add("role",gs.elvis(gs.bool(gs.gp(row,"role")) , gs.gp(row,"role") , "Viewer")));
    return gs.sp(gSobject.scope,"showEditDialog",true);
   }
  gSobject['saveEditUser'] = function(it) {
    var d = gs.gp(gSobject.scope,"editUser");
    if (!gs.bool(gs.gp(d,"orgId"))) {
      gs.mc(gSobject,"notify",["Organisation is required", "negative"]);
      return null;
     };
    if (!gs.bool(gs.gp(d,"role"))) {
      gs.mc(gSobject,"notify",["Role is required", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"updateUserOrgAndRole",[gs.gp(d,"_id"), gs.gp(d,"orgId"), gs.gp(d,"role"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error"))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.sp(gSobject.scope,"showEditDialog",false);
      gs.mc(gSobject,"notify",["User updated"]);
      return gs.mc(gSobject,"loadUsers",[]);
     }]);
   }
  gSobject['unassignUser'] = function(it) {
    var userId = gs.gp(gs.gp(gSobject.scope,"editUser"),"_id",true);
    if (!gs.bool(userId)) {
      return null;
     };
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Unassign User").add("message",gs.plus((gs.plus("Remove \"", gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"editUser"),"email")) , gs.gp(gs.gp(gSobject.scope,"editUser"),"email") , ""))), "\" from their organisation? They will remain a user but belong to no organisation.")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"unassignUserFromOrg",[userId, function(result) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(result,"error"))) {
          gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
          return null;
         };
        gs.sp(gSobject.scope,"showEditDialog",false);
        gs.mc(gSobject,"notify",["User unassigned from organisation"]);
        return gs.mc(gSobject,"loadUsers",[]);
       }]);
     }]);
   }
  gSobject['toggleNewApp'] = function(row, val) {
    var newVal = gs.equals(val, true);
    gs.sp(row,"newAppEnabled",newVal);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"setNewAppEnabled",[gs.gp(row,"_id"), newVal, function(result) {
      if (gs.bool(gs.gp(result,"error",true))) {
        gs.sp(row,"newAppEnabled",!newVal);
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      return gs.mc(gSobject,"notify",[gs.plus((gs.plus((gs.plus("New app ", (gs.bool(newVal) ? "enabled" : "disabled"))), " for ")), gs.elvis(gs.bool(gs.gp(row,"email")) , gs.gp(row,"email") , "user"))]);
     }]);
   }
  gSobject['removeUser'] = function(row) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete User").add("message",gs.plus((gs.plus("Are you sure you want to delete \"", gs.elvis(gs.bool(gs.gp(row,"email")) , gs.gp(row,"email") , gs.gp(row,"name")))), "\"? This will also remove them from all organisations.")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"deleteUserAndOrgUsers",[gs.gp(row,"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["User deleted", "negative"]);
        return gs.mc(gSobject,"loadUsers",[]);
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminOrgThemeTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminOrgThemeTab', simpleName: 'AdminOrgThemeTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("organisationId",String).add("embedded",Boolean);
  gSobject.data = function(it) {
    return gs.map().add("cwOrg",gs.map()).add("cwOrgSnapshot",gs.map()).add("logoPreviewUrl","").add("isAdmin",false).add("ready",false).add("fontOptions",gs.list(["Roboto" , "Open Sans" , "Lato" , "Montserrat" , "Inter" , "Poppins" , "Nunito" , "Source Sans 3" , "Work Sans" , "Raleway"]));
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    return gs.mc(gSobject,"loadCwOrg",[]);
   }
  gSobject['mounted'] = function(it) {
    return gs.mc(gSobject,"registerDirtyOwner",[]);
   }
  gSobject['activated'] = function(it) {
    return gs.mc(gSobject,"registerDirtyOwner",[]);
   }
  gSobject['beforeUnmount'] = function(it) {
    return gs.mc(gSobject,"releaseDirtyOwner",[]);
   }
  gSobject.registerDirtyOwner = function() {
    var self = this;
        if (typeof vue !== 'undefined' && vue.scope) {
            vue.scope.dirtyForm = {
                isDirty: function() { return self.isDirty(); },
                discard: function() { self.discardChanges(); },
                save: function(done) { self.save(done); }
            };
        }
   }
  gSobject.releaseDirtyOwner = function() {
    if (typeof vue !== 'undefined' && vue.scope) {
            vue.scope.dirtyForm = { isDirty: function() { return false; }, discard: function() {} };
        }
   }
  gSobject['discardChanges'] = function(it) {
    return gs.sp(gSobject.self,"cwOrg",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrgSnapshot")]));
   }
  gSobject.snapshot = function(obj) {
    return JSON.parse(JSON.stringify(obj == null ? {} : obj));
   }
  gSobject.equalsSnapshot = function(a, b) {
    return JSON.stringify(a == null ? {} : a) === JSON.stringify(b == null ? {} : b);
   }
  gSobject['isDirty'] = function(it) {
    return !gs.mc(gSobject,"equalsSnapshot",[gs.gp(gSobject.self,"cwOrg"), gs.gp(gSobject.self,"cwOrgSnapshot")]);
   }
  gSobject['loadCwOrg'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchOrCreateByOrgId",[gs.gp(gSobject.self,"organisationId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"cwOrg",gs.elvis(gs.bool(data) , data , gs.map()));
      gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
      gs.sp(gSobject.self,"logoPreviewUrl",gs.mc(gSobject,"buildLogoUrl",[data]));
      gs.sp(gSobject.self,"ready",true);
      return gs.mc(gSobject,"ensureFont",[gs.gp(gs.gp(gSobject.self,"cwOrg"),"brandFont")]);
     }]);
   }
  gSobject['save'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"saveCwOrg",[gs.gp(gSobject.self,"cwOrg"), function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(saved)) {
        gs.sp(gSobject.self,"cwOrg",saved);
       };
      gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
      gs.sp(gSobject.self,"logoPreviewUrl",gs.mc(gSobject,"buildLogoUrl",[gs.gp(gSobject.self,"cwOrg")]));
      if (!gs.bool(gs.gp(gSobject.self,"isAdmin"))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"getBrandingForOrg",[gs.gp(gSobject.self,"organisationId"), function(brand) {
          return gs.mc(gSobject,"applyBrandToShell",[brand]);
         }]);
       };
      gs.mc(gSobject,"notify",["Theme saved"]);
      return gs.execCall(callback, this, []);
     }]);
   }
  gSobject['resetToDefaults'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Reset theme").add("message","Reset all branding (colours, font and logos) to the Coldwatch defaults for this organisation? This clears your customisations.").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"resetBranding",[gs.gp(gSobject.self,"organisationId"), function(saved) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.self,"cwOrg",gs.elvis(gs.bool(saved) , saved , gs.map()));
        gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
        gs.sp(gSobject.self,"logoPreviewUrl",gs.mc(gSobject,"buildLogoUrl",[gs.gp(gSobject.self,"cwOrg")]));
        if (!gs.bool(gs.gp(gSobject.self,"isAdmin"))) {
          gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"getBrandingForOrg",[gs.gp(gSobject.self,"organisationId"), function(brand) {
            return gs.mc(gSobject,"applyBrandToShell",[brand]);
           }]);
         };
        return gs.mc(gSobject,"notify",["Theme reset to defaults"]);
       }]);
     }]);
   }
  gSobject.applyBrandToShell = function(brand) {
    try { if (typeof window !== 'undefined' && window.__cwApplyBrand) window.__cwApplyBrand(brand); } catch (e) {}
   }
  gSobject['onLogoChanged'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchOrCreateByOrgId",[gs.gp(gSobject.self,"organisationId"), function(data) {
      if (gs.bool(data)) {
        return gs.sp(gSobject.self,"logoPreviewUrl",gs.mc(gSobject,"buildLogoUrl",[data]));
       };
     }]);
   }
  gSobject['resetColor'] = function(field) {
    return (gs.gp(gSobject.self,"cwOrg")[field]) = "";
   }
  gSobject['onFontChange'] = function(family) {
    return gs.mc(gSobject,"ensureFont",[family]);
   }
  gSobject.ensureFont = function(family) {
    try {
            if (!family || family === 'Inter' || family === 'Roboto') return;
            var id = 'cw-theme-preview-font';
            var href = 'https://fonts.googleapis.com/css2?family=' + encodeURIComponent(family).replace(/%20/g, '+') + ':wght@300;400;500;700&display=swap';
            var l = document.getElementById(id);
            if (!l) { l = document.createElement('link'); l.id = id; l.rel = 'stylesheet'; document.head.appendChild(l); }
            if (l.href !== href) l.href = href;
        } catch (e) {}
   }
  gSobject['buildLogoUrl'] = function(rec) {
    var f = gs.gp(rec,"brandLogo",true);
    if ((!gs.bool(gs.gp(rec,"_id",true))) || (!gs.bool(gs.gp(f,"filename",true)))) {
      return "";
     };
    return gs.plus((gs.plus((gs.plus((gs.plus((gs.plus("/media-cache/filePreview/", gs.gp(rec,"_id"))), "/brandLogo/")), gs.gp(rec,"_lastUpdated"))), "/")), gs.gp(f,"filename"));
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function HammerJsZoom() {
  var gSobject = gs.init('HammerJsZoom');
  gSobject.clazz = { name: 'HammerJsZoom', simpleName: 'HammerJsZoom'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.showHammerZoom = function(x0) { return HammerJsZoom.showHammerZoom(x0); }
  gSobject['HammerJsZoom1'] = function(elmName) {
    HammerJsZoom.showHammerZoom(elmName);
    return this;
  }
  if (arguments.length==1) {gSobject.HammerJsZoom1(arguments[0]); }
  
  return gSobject;
 };
HammerJsZoom.showHammerZoom = function(name) {
  var elm = document.getElementById(name);
        var hammertime = new Hammer(elm, {});
        hammertime.get('pinch').set({
            enable: true
        });
        
        console.log('hammertime')
        console.log(hammertime)
        
        var posX = 0,
            posY = 0,
            scale = 1,
            last_scale = 1,
            last_posX = 0,
            last_posY = 0,
            max_pos_x = 0,
            max_pos_y = 0,
            transform = "",
            el = elm;
            
        hammertime.on('doubletap pinch pan panend pinchend', function(ev) {
            console.log('event')
            console.log(ev)
            if (ev.type == "doubletap") {
                console.log('doubletapped')
                transform = 
                    "translate3d(0, 0, 0) " +
                    "sacle3d(2, 2, 1) ";
                scale = 2;
                last_sacle = 2;
                
                try{
                    if (window.getComputedStyle(el, null).getPropertyValue('-webkit-transform').toString() != "matrix(1, 0, 0, 1, 0, 0)") {
                        transform = 
                            "translate3d(0, 0, 0) " +
                            "scale3d(1, 1, 1) ";
                        scale = 1;
                        last_scale = 1;
                    }
                } catch (err){}
                
                el.style.webkitTransform = transform;
                transform = ""
            }
            
            //pan
            if (scale != 1) {
                console.log('pan')
                posX = last_posX + ev.deltaX;
                posY = last_posY + ev.deltaY;
                max_pos_x = Math.ceil((scale - 1) * el.clientWidth / 2);
                max_pos_y = Math.ceil((scale - 1) * el.clientHeight / 2);
                if (posX > max_pos_x) {
                    posX = max_pos_x;
                }
                if (posX < -max_pos_x) {
                    posX = -max_pos_x;
                }
                if (posY > max_pos_y) {
                    posY = max_pos_y;
                }
                if (posY < -max_pos_y) {
                    posY = -max_pos_y;
                }
            }
            
            //pinch
            if (ev.type == "pinch") {
                console.log('pinch')
                scale = Math.max(.999, Math.min(last_scale * (ev.scale), 4));
            }
            if(ev.type == "pinchend"){last_scale = scale;}
    
            //panend
            if(ev.type == "panend"){
                console.log('panend')
                last_posX = posX < max_pos_x ? posX : max_pos_x;
                last_posY = posY < max_pos_y ? posY : max_pos_y;
            }
    
            if (scale != 1) {
                console.log('scale not 1')
                transform =
                    "translate3d(" + posX + "px," + posY + "px, 0) " +
                    "scale3d(" + scale + ", " + scale + ", 1)";
            }
    
            if (transform) {
                console.log('transform')
                el.style.webkitTransform = transform;
            }
        });
 }

function CordovaI3Health() {
  var gSobject = gs.init('CordovaI3Health');
  gSobject.clazz = { name: 'CordovaI3Health', simpleName: 'CordovaI3Health'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'HEALTH_PERMISSIONS', { get: function() { return CordovaI3Health.HEALTH_PERMISSIONS; }, set: function(gSval) { CordovaI3Health.HEALTH_PERMISSIONS = gSval; }, enumerable: true });
  gSobject['testIsAvailable'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeIsAvailable",[function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.isAvailable -> " + (result) + ""]);
      return gs.execCall(onSuccess, this, [gs.elvis(gs.bool(gs.gp(result,"available",true)) , gs.gp(result,"available",true) , false)]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.isAvailable error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['requestPermissions'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.requestPermissions: requesting via Android permissions plugin"]);
    return gs.mc(gSobject,"nativeRequestPermissions",[function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.requestPermissions -> " + (result) + ""]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.requestPermissions error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['querySteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQuery",["steps", startDate, endDate, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.query steps -> " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryHeartRate'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQuery",["heartRate", startDate, endDate, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.query heartRate -> " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryBloodPressure'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQuery",["bloodPressure", startDate, endDate, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.query bloodPressure -> " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryAggregatedSteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeQueryAggregated",["steps", startDate, endDate, "day", function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.queryAggregated steps -> success"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['store'] = function(dataType, data, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeStore",[dataType, data, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["dymicoHealth.store " + (dataType) + " -> success"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject.nativeIsAvailable = function(successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.isAvailable(
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.isAvailable exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeRequestPermissions = function(successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            var permissions = cordova.plugins.permissions;
            if (!permissions) { errorCallback("Android permissions plugin not available"); return; }

            var perms = CordovaI3Health.HEALTH_PERMISSIONS;
            console.log('dymicoHealth: requesting', perms.length, 'permissions');

            permissions.requestPermissions(perms, function(status) {
                console.log('dymicoHealth: permissions result:', status);
                successCallback({ authorized: status.hasPermission });
            }, function(err) {
                console.error('dymicoHealth: permissions error:', err);
                errorCallback(err ? err.toString() : "Permission request failed");
            });
        } catch (e) {
            console.error('dymicoHealth.requestPermissions exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQuery = function(dataType, startDate, endDate, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.query(
                dataType,
                startDate instanceof Date ? startDate : new Date(startDate),
                endDate instanceof Date ? endDate : new Date(endDate),
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.query exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQueryAggregated = function(dataType, startDate, endDate, bucket, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.queryAggregated(
                dataType,
                startDate instanceof Date ? startDate : new Date(startDate),
                endDate instanceof Date ? endDate : new Date(endDate),
                bucket || 'day',
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.queryAggregated exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeStore = function(dataType, data, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) { errorCallback("Cordova not available"); return; }
            if (!cordova.plugins.dymicoHealth) { errorCallback("dymicoHealth plugin not installed"); return; }
            cordova.plugins.dymicoHealth.store(
                dataType, data,
                function(result) { successCallback(result); },
                function(err) { errorCallback(err ? err.toString() : "Unknown error"); }
            );
        } catch (e) {
            console.error('dymicoHealth.store exception:', e);
            errorCallback(e.toString());
        }
   }
  gSobject['CordovaI3Health0'] = function(it) {
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaI3Health0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaI3Health.HEALTH_PERMISSIONS = gs.list(["android.permission.health.READ_STEPS" , "android.permission.health.WRITE_STEPS" , "android.permission.health.READ_HEART_RATE" , "android.permission.health.WRITE_HEART_RATE" , "android.permission.health.READ_BLOOD_PRESSURE" , "android.permission.health.WRITE_BLOOD_PRESSURE" , "android.permission.health.READ_BLOOD_GLUCOSE" , "android.permission.health.WRITE_BLOOD_GLUCOSE" , "android.permission.health.READ_WEIGHT" , "android.permission.health.WRITE_WEIGHT" , "android.permission.health.READ_HEIGHT" , "android.permission.health.WRITE_HEIGHT" , "android.permission.health.READ_SLEEP" , "android.permission.health.WRITE_SLEEP" , "android.permission.health.READ_ACTIVE_CALORIES_BURNED" , "android.permission.health.WRITE_ACTIVE_CALORIES_BURNED"]);

function LegionRegisterComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'LegionRegisterComponent', simpleName: 'LegionRegisterComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/register";
  gSobject['created'] = function(it) {
    gs.println("LegionRegisterComponent.created()");
    gs.sp(gSobject.scope,"email","");
    gs.sp(gSobject.scope,"phoneNumber","");
    return gs.sp(gSobject.scope,"processing",false);
   }
  gSobject['generatePin'] = function(it) {
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username",gs.elvis(gs.bool(gs.gp(gSobject.scope,"email")) , gs.gp(gSobject.scope,"email") , gs.gp(gSobject.scope,"phoneNumber")));
    if (!gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"))) {
      gs.mc(gSobject,"notify",["Please enter details", "negative"]);
      return null;
     };
    gs.sp(gSobject.scope,"processing",true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"generatePinForNewOrExistingUser",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), true, (gs.bool(gs.gp(gSobject.scope,"phoneNumber")) ? true : false)]),"then",[function(it) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/legionPin"]);
      gs.mc(gSobject,"notify",["Pin Sent"]);
      return gs.sp(gSobject.scope,"processing",false);
     }, function(error) {
      gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
      return gs.sp(gSobject.scope,"processing",false);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3HeaderButton() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3HeaderButton', simpleName: 'I3HeaderButton'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("icon",gs.map().add("type",String).add("default","o_square")).add("color",gs.map().add("type",String).add("default","primary")).add("dense",gs.map().add("type",Boolean).add("default",true)).add("flat",gs.map().add("type",Boolean).add("default",true)).add("round",gs.map().add("type",Boolean).add("default",true));
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminProfilesListTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminProfilesListTab', simpleName: 'AdminProfilesListTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  Object.defineProperty(gSobject, 'PROFILE_TYPES', { get: function() { return AdminProfilesListTab.PROFILE_TYPES; }, set: function(gSval) { AdminProfilesListTab.PROFILE_TYPES = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIGITAL_TYPES', { get: function() { return AdminProfilesListTab.DIGITAL_TYPES; }, set: function(gSval) { AdminProfilesListTab.DIGITAL_TYPES = gSval; }, enumerable: true });
  gSobject.props = gs.map().add("organisationId",String);
  gSobject.data = function(it) {
    return gs.map().add("searchText","").add("profiles",gs.list([])).add("filter",gs.map()).add("pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","name").add("descending",false)).add("addDialogOpen",false).add("savingProfile",false).add("editingProfileId",null).add("newProfile",gs.map());
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"columns",gs.list([gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","type").add("label","Type").add("field","type").add("align","left").add("sortable",true) , gs.map().add("name","low").add("label","Low Alarm").add("field","low").add("align","left").add("sortable",true) , gs.map().add("name","lowWarn").add("label","Low Warning").add("field","lowWarn").add("align","left").add("sortable",true) , gs.map().add("name","highWarn").add("label","High Warning").add("field","highWarn").add("align","left").add("sortable",true) , gs.map().add("name","high").add("label","High Alarm").add("field","high").add("align","left").add("sortable",true)]));
    gs.sp(gSobject.self,"profileTypeOptions",AdminProfilesListTab.PROFILE_TYPES);
    return gs.mc(gSobject,"loadProfiles",[]);
   }
  gSobject['loadProfiles'] = function(it) {
    gs.sp(gSobject.self,"filter",gs.map().add("org",gs.gp(gSobject.self,"organisationId")));
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"paginatedProfiles",[gs.gp(gSobject.self,"searchText"), gs.gp(gSobject.self,"filter"), gs.gp(gSobject.self,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"profiles",gs.gp(data,"profiles"));
      return gs.sp(gs.gp(gSobject.self,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['onRequest'] = function(props) {
    return gs.mc(gSobject.self,"updatePagination",[gs.gp(props,"pagination")]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.self,"pagination",pagination);
    return gs.mc(gSobject,"loadProfiles",[]);
   }
  gSobject['onRowClick'] = function(evt, row, index) {
    return gs.mc(gSobject.self,"selectProfile",[gs.gp(row,"_id")]);
   }
  gSobject['blankNewProfile'] = function(it) {
    return gs.map().add("name","").add("type","").add("low","").add("high","").add("lowWarn","").add("highWarn","").add("alarmOnState",false).add("alarmOffState",false).add("onAlarmMessage","").add("offAlarmMessage","");
   }
  gSobject['newProfileIsDigital'] = function(it) {
    return gs.mc(AdminProfilesListTab.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.self,"newProfile"),"type",true)]);
   }
  gSobject['openAddDialog'] = function(it) {
    gs.sp(gSobject.self,"editingProfileId",null);
    gs.sp(gSobject.self,"newProfile",gs.mc(gSobject,"blankNewProfile",[]));
    return gs.sp(gSobject.self,"addDialogOpen",true);
   }
  gSobject['selectProfile'] = function(id) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"fetchOneById",[id, function(data) {
      gs.sp(gSobject.self,"editingProfileId",id);
      gs.sp(gSobject.self,"newProfile",data);
      return gs.sp(gSobject.self,"addDialogOpen",true);
     }]);
   }
  gSobject['cancelAddProfile'] = function(it) {
    return gs.sp(gSobject.self,"addDialogOpen",false);
   }
  gSobject['saveNewProfile'] = function(it) {
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"newProfile"),"name"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Measurement template name is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"type"))) {
      gs.mc(gSobject,"notify",["Measurement template type is required", "warning"]);
      return null;
     };
    var isDigital = gs.mc(AdminProfilesListTab.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.self,"newProfile"),"type")]);
    var payload = gs.map().add("name",gs.mc(gs.gp(gs.gp(gSobject.self,"newProfile"),"name"),"trim",[])).add("type",gs.gp(gs.gp(gSobject.self,"newProfile"),"type")).add("org",gs.gp(gSobject.self,"organisationId"));
    if (gs.bool(gs.gp(gSobject.self,"editingProfileId"))) {
      gs.sp(payload,"_id",gs.gp(gSobject.self,"editingProfileId"));
     };
    if (gs.bool(isDigital)) {
      gs.sp(payload,"alarmOnState",(gs.equals(gs.gp(gs.gp(gSobject.self,"newProfile"),"alarmOnState"), true)));
      gs.sp(payload,"alarmOffState",(gs.equals(gs.gp(gs.gp(gSobject.self,"newProfile"),"alarmOffState"), true)));
      gs.sp(payload,"onAlarmMessage",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"onAlarmMessage")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"onAlarmMessage") , ""),"toString",[]));
      gs.sp(payload,"offAlarmMessage",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"offAlarmMessage")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"offAlarmMessage") , ""),"toString",[]));
     } else {
      gs.sp(payload,"low",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"low")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"low") , 0));
      gs.sp(payload,"high",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"high")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"high") , 0));
      gs.sp(payload,"lowWarn",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"lowWarn")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"lowWarn") , 0));
      gs.sp(payload,"highWarn",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"highWarn")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"highWarn") , 0));
     };
    gs.sp(gSobject.self,"savingProfile",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"save",[payload, function(saved) {
      gs.sp(gSobject.self,"savingProfile",false);
      gs.sp(gSobject.self,"addDialogOpen",false);
      gs.mc(gSobject,"notify",[(gs.bool(gs.gp(gSobject.self,"editingProfileId")) ? "Measurement Template Saved" : "Measurement Template Created")]);
      return gs.mc(gSobject,"loadProfiles",[]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
AdminProfilesListTab.PROFILE_TYPES = gs.list(["temperature" , "humidity" , "co2" , "digitalInput" , "digitalOutput"]);
AdminProfilesListTab.DIGITAL_TYPES = gs.list(["digitalInput" , "digitalOutput"]);

function CwChart() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CwChart', simpleName: 'CwChart'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("labels",Array).add("values",Array).add("data",Array).add("datasets",Array).add("id",String).add("type",String).add("title",String).add("legend",Boolean).add("height",Number).add("width",Number).add("borderWidth",Number).add("borderRadius",Number).add("borderColor",String).add("backgroundColor",String).add("color",String).add("tension",Number).add("filled",Boolean).add("horizontal",Boolean).add("xHide",Boolean).add("xStacked",Boolean).add("xGridHide",Boolean).add("yHide",Boolean).add("yStacked",Boolean).add("yGridHide",Boolean).add("forceYZero",Boolean).add("yStepSize",Number).add("yTicksCount",Number).add("rHide",Boolean).add("rGridHide",Boolean).add("yScaleLabel",String).add("yScalePos",String).add("min",Number).add("max",Number).add("yScaleType",String).add("pointStyle",String).add("pointRadius",Number).add("dashedLine",Array).add("stepped",Boolean).add("alternate",Boolean).add("transparent",Boolean).add("datasetOptions",Array).add("tooltipMode",String);
  gSobject.colors = gs.list(["#37a2eb" , "#ff6383" , "#4ac1c0" , "#fca048" , "#9966ff" , "#ffce56" , "#c9cbcf"]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"loadChart",[self, true]);
   }
  gSobject['watchData'] = function(val, oldVal) {
    return gs.mc(gSobject,"loadChart",[this, false]);
   }
  gSobject['watchColor'] = function(val, oldVal) {
    return gs.mc(gSobject,"loadChart",[this, true]);
   }
  gSobject['watchYStepSize'] = function(val, oldVal) {
    return gs.mc(gSobject,"loadChart",[this, true]);
   }
  gSobject['watchLabels'] = function(val, oldVal) {
    return gs.mc(gSobject,"loadChart",[this, false]);
   }
  gSobject['watchDatasets'] = function(val, oldVal) {
    return gs.mc(gSobject,"loadChart",[this, false]);
   }
  gSobject['chartContainerStyle'] = function(self) {
    if (self === undefined) self = this;
    var style = gs.map();
    var height = (gs.equals(gs.gp(self,"height"), null) ? null : gs.mc(gs.mc(gs.gp(self,"height"),"toString",[]),"trim",[]));
    var width = (gs.equals(gs.gp(self,"width"), null) ? null : gs.mc(gs.mc(gs.gp(self,"width"),"toString",[]),"trim",[]));
    if (gs.bool(height)) {
      gs.sp(style,"height",(gs.plus(height, "px")));
      gs.sp(style,"minHeight",(gs.plus(height, "px")));
     };
    if (gs.bool(width)) {
      gs.sp(style,"width",(gs.plus(width, "px")));
     } else {
      gs.sp(style,"width","100%");
     };
    if ((gs.bool(height)) || (gs.bool(width))) {
      gs.sp(style,"position","relative");
     };
    return style;
   }
  gSobject['loadChart'] = function(self, newChart) {
    if (self === undefined) self = this;
    if (newChart === undefined) newChart = false;
    var labels = gs.list([]);
    gs.mc(gs.range(0, 4, true),"each",[function(it) {
      return gs.mc(labels,"add",[it]);
     }]);
    var options = gs.map().add("responsive",true).add("animation",true).add("resizeDelay",150).add("indexAxis",(gs.bool(gs.gp(self,"horizontal")) ? "y" : "x")).add("plugins",gs.toJavascript(gs.mc(gSobject,"plugins",[self]))).add("scales",gs.toJavascript(gs.mc(gSobject,"scales",[self]))).add("spanGaps",true);
    if (gs.bool(gs.gp(self,"tooltipMode"))) {
      gs.sp(options,"tooltipMode",gs.gp(self,"tooltipMode"));
     };
    if ((gs.bool(gs.gp(self,"height"))) || (gs.bool(gs.gp(self,"width")))) {
      gs.sp(options,"maintainAspectRatio",false);
     };
    var data = gs.map();
    gs.sp(data,"labels",(gs.bool(gs.gp(self,"labels")) ? gs.toJavascript(gs.gp(self,"labels")) : gs.toJavascript(labels)));
    gs.sp(data,"datasets",gs.toJavascript(gs.mc(gSobject,"datasets",[self])));
    return gs.mc(gSobject,"nextTick",[function(it) {
      if (gs.bool(newChart)) {
        return gs.execStatic(CwChart,'paintChart', this,[gs.gp(self,"id"), data, options, gs.gp(self,"type")]);
       } else {
        return gs.execStatic(CwChart,'updateData', this,[gs.gp(self,"id"), gs.gp(self,"labels"), data]);
       };
     }]);
   }
  gSobject['dataset'] = function(self, data, index) {
    if (self === undefined) self = this;
    if (index === undefined) index = 0;
    var dataset = gs.map();
    var opts = ((gs.bool(gs.gp(self,"datasetOptions"))) && (index < gs.gp(gs.gp(self,"datasetOptions"),"length")) ? gs.gp(self,"datasetOptions")[index] : null);
    if (!gs.bool(opts)) {
      opts = gs.map();
     };
    gs.sp(dataset,"label",gs.elvis(gs.bool(gs.gp(opts,"label")) , gs.gp(opts,"label") , gs.elvis(gs.bool(gs.gp(self,"label")) , gs.gp(self,"label") , "")));
    gs.sp(dataset,"data",data);
    gs.sp(dataset,"borderWidth",(gs.gp(opts,"borderWidth") != null ? gs.gp(opts,"borderWidth") : gs.elvis(gs.bool(gs.gp(self,"borderWidth")) , gs.gp(self,"borderWidth") , 1)));
    gs.sp(dataset,"borderRadius",gs.elvis(gs.bool(gs.gp(self,"borderRadius")) , gs.gp(self,"borderRadius") , 0));
    gs.sp(dataset,"borderSkipped",false);
    if (gs.bool(gs.gp(self,"data"))) {
      gs.sp(dataset,"borderColor",gs.elvis(gs.bool(gs.gp(opts,"borderColor")) , gs.gp(opts,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors))));
      gs.sp(dataset,"pointBackgroundColor",gs.elvis(gs.bool(gs.gp(opts,"borderColor")) , gs.gp(opts,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors))));
      var color = gs.elvis(gs.bool(gs.gp(opts,"backgroundColor")) , gs.gp(opts,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"backgroundColor")) , gs.gp(self,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors)));
      gs.sp(dataset,"backgroundColor",color);
     };
    if (gs.bool(gs.gp(self,"datasets"))) {
      var color = gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      var resolvedColor = (gs.mc(color,"contains",["#"]) ? color : color[(gs.mod(index, gs.gp(color,"length")))]);
      gs.sp(dataset,"borderColor",gs.elvis(gs.bool(gs.gp(opts,"borderColor")) , gs.gp(opts,"borderColor") , resolvedColor));
      gs.sp(dataset,"pointBackgroundColor",gs.elvis(gs.bool(gs.gp(opts,"borderColor")) , gs.gp(opts,"borderColor") , resolvedColor));
      color = gs.elvis(gs.bool(gs.gp(self,"backgroundColor")) , gs.gp(self,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"backgroundColor",gs.elvis(gs.bool(gs.gp(opts,"backgroundColor")) , gs.gp(opts,"backgroundColor") , (gs.mc(color,"contains",["#"]) ? color : color[(gs.mod(index, gs.gp(color,"length")))])));
     };
    gs.sp(dataset,"tension",(gs.gp(opts,"tension") != null ? gs.gp(opts,"tension") : gs.elvis(gs.bool(gs.gp(self,"tension")) , gs.gp(self,"tension") , 0.1)));
    gs.sp(dataset,"fill",(gs.gp(opts,"fill") != null ? gs.gp(opts,"fill") : gs.elvis(gs.bool(gs.gp(self,"filled")) , gs.gp(self,"filled") , false)));
    gs.sp(dataset,"spanGaps",true);
    gs.sp(dataset,"pointStyle",(gs.gp(opts,"pointStyle") != null ? gs.gp(opts,"pointStyle") : gs.elvis(gs.bool(gs.gp(self,"pointStyle")) , gs.gp(self,"pointStyle") , false)));
    gs.sp(dataset,"pointRadius",(gs.gp(opts,"pointRadius") != null ? gs.gp(opts,"pointRadius") : gs.elvis(gs.bool(gs.gp(self,"pointRadius")) , gs.gp(self,"pointRadius") , 0)));
    gs.sp(dataset,"stepped",gs.elvis(gs.bool(gs.gp(self,"stepped")) , gs.gp(self,"stepped") , false));
    gs.sp(dataset,"borderDash",(gs.gp(opts,"borderDash") != null ? gs.gp(opts,"borderDash") : gs.elvis(gs.bool(gs.gp(self,"dashedLine")) , gs.gp(self,"dashedLine") , gs.list([0 , 0]))));
    if (gs.gp(opts,"hidden") != null) {
      gs.sp(dataset,"hidden",gs.gp(opts,"hidden"));
     };
    return dataset;
   }
  gSobject['datasets'] = function(self) {
    if (self === undefined) self = this;
    var datasets = gs.list([]);
    if (gs.bool(gs.gp(self,"data"))) {
      gs.mc(datasets,"add",[gs.mc(gSobject,"dataset",[self, gs.gp(self,"data")])]);
     };
    if (gs.bool(gs.gp(self,"datasets"))) {
      gs.mc(gs.toJavascript(gs.gp(self,"datasets")),"eachWithIndex",[function(data, index) {
        return gs.mc(datasets,"add",[gs.mc(gSobject,"dataset",[self, data, index])]);
       }]);
     };
    return datasets;
   }
  gSobject['plugins'] = function(self) {
    if (self === undefined) self = this;
    var title = gs.map();
    if (gs.bool(gs.gp(self,"title"))) {
      gs.sp(title,"display",true);
      gs.sp(title,"text",gs.gp(self,"title"));
     };
    var legend = gs.map();
    gs.sp(legend,"display",gs.gp(self,"legend"));
    var plugins = gs.map();
    gs.sp(plugins,"legend",legend);
    gs.sp(plugins,"title",title);
    return plugins;
   }
  gSobject['scales'] = function(self) {
    if (self === undefined) self = this;
    var xScale = gs.map();
    gs.sp(xScale,"display",(gs.bool(gs.gp(self,"xHide")) ? false : true));
    gs.sp(xScale,"stacked",gs.elvis(gs.bool(gs.gp(self,"xStacked")) , gs.gp(self,"xStacked") , false));
    gs.sp(xScale,"grid",gs.map());
    gs.sp(gs.gp(xScale,"grid"),"display",(gs.bool(gs.gp(self,"xGridHide")) ? false : true));
    var yScale = gs.map();
    gs.sp(yScale,"display",(gs.bool(gs.gp(self,"yHide")) ? false : true));
    gs.sp(yScale,"stacked",gs.elvis(gs.bool(gs.gp(self,"yStacked")) , gs.gp(self,"yStacked") , false));
    if (gs.bool(gs.gp(self,"yScaleType"))) {
      gs.sp(yScale,"type",gs.gp(self,"yScaleType"));
     };
    if (gs.bool(gs.gp(self,"forceYZero"))) {
      gs.sp(yScale,"beginAtZero",true);
     };
    if (gs.bool(gs.gp(self,"yStepSize"))) {
      gs.sp(yScale,"ticks",gs.map());
      gs.sp(gs.gp(yScale,"ticks"),"stepSize",gs.gp(self,"yStepSize"));
      gs.sp(gs.gp(yScale,"ticks"),"maxTicksLimit",1000);
     };
    if (gs.bool(gs.gp(self,"yTicksCount"))) {
      if (!gs.bool(gs.gp(yScale,"ticks"))) {
        gs.sp(yScale,"ticks",gs.map());
       };
      gs.sp(gs.gp(yScale,"ticks"),"maxTicksLimit",gs.gp(self,"yTicksCount"));
     };
    if (gs.bool(gs.gp(self,"min"))) {
      gs.sp(yScale,"suggestedMin",gs.gp(self,"min"));
     };
    if (gs.bool(gs.gp(self,"max"))) {
      gs.sp(yScale,"suggestedMax",gs.gp(self,"max"));
     };
    gs.sp(yScale,"grid",gs.map());
    gs.sp(gs.gp(yScale,"grid"),"display",(gs.bool(gs.gp(self,"yGridHide")) ? false : true));
    var rScale = gs.map();
    gs.sp(rScale,"display",(gs.bool(gs.gp(self,"rHide")) ? false : true));
    gs.sp(rScale,"grid",gs.map());
    gs.sp(gs.gp(rScale,"grid"),"display",(gs.bool(gs.gp(self,"rGridHide")) ? false : true));
    var scales = gs.map();
    if (gs.mc(gs.list(["radar" , "polarArea"]),"includes",[gs.gp(self,"type")])) {
      gs.sp(scales,"r",gs.toJavascript(rScale));
     };
    if (!gs.bool(gs.mc(gs.list(["doughnut" , "pie" , "polarArea" , "radar"]),"includes",[gs.gp(self,"type")]))) {
      gs.sp(scales,"x",gs.toJavascript(xScale));
      gs.sp(scales,"y",gs.toJavascript(yScale));
     };
    return scales;
   }
  gSobject.paintChart = function(x0,x1,x2,x3) { return CwChart.paintChart(x0,x1,x2,x3); }
  gSobject.registerClickHandler = function(x0,x1) { return CwChart.registerClickHandler(x0,x1); }
  gSobject.toggleDataset = function(x0,x1) { return CwChart.toggleDataset(x0,x1); }
  gSobject.toggleDatasetGroup = function(x0,x1) { return CwChart.toggleDatasetGroup(x0,x1); }
  gSobject.setDatasetGroupVisibility = function(x0,x1,x2) { return CwChart.setDatasetGroupVisibility(x0,x1,x2); }
  gSobject.updateData = function(x0,x1,x2) { return CwChart.updateData(x0,x1,x2); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CwChart.paintChart = function(chartId, data, options, type) {
  if (type === undefined) type = "line";
  const oldChart = Chart.getChart(chartId)
        if (oldChart != undefined) oldChart.destroy()
        options.onClick = function(evt, elements) {
            const handlers = window.__cwChartClickHandlers || {}
            const handler = handlers[chartId]
            if (handler && elements && elements.length > 0) {
                handler(elements[0].datasetIndex, elements[0].index)
            }
        }
        const isDark = document.body.classList.contains('body--dark')
        const tickColor = isDark ? 'rgba(255,255,255,0.75)' : '#666'
        const gridColor = isDark ? 'rgba(255,255,255,0.12)' : 'rgba(0,0,0,0.1)'
        const borderColor = isDark ? 'rgba(255,255,255,0.3)' : 'rgba(0,0,0,0.3)'
        if (options.scales) {
            for (const axisKey in options.scales) {
                const scale = options.scales[axisKey]
                if (!scale) continue
                scale.ticks = scale.ticks || {}
                if (scale.ticks.color === undefined) scale.ticks.color = tickColor
                scale.grid = scale.grid || {}
                if (scale.grid.color === undefined) scale.grid.color = gridColor
                scale.border = scale.border || {}
                if (scale.border.color === undefined) scale.border.color = borderColor
            }
        }
        if (options.tooltipMode === 'sensorGroup') {
            options.plugins = options.plugins || {}
            const existingTooltip = options.plugins.tooltip || {}
            const fmt = function(v) {
                if (v === null || v === undefined) return '-'
                return (typeof v === 'number') ? (Math.round(v * 10) / 10) : v
            }
            options.plugins.tooltip = Object.assign({}, existingTooltip, {
                filter: function(tooltipItem) {
                    const label = (tooltipItem.dataset && tooltipItem.dataset.label) || ''
                    const base = label.split('|')[0]
                    return !base.endsWith('-min') && !base.endsWith('-max')
                },
                callbacks: {
                    label: function(context) {
                        const rawLabel = (context.dataset && context.dataset.label) || ''
                        const parts = rawLabel.split('|')
                        const base = parts[0]
                        const name = parts.length > 1 ? parts.slice(1).join('|') : base
                        const m = base.match(/^sensor-(\d+)-avg$/)
                        const avg = context.parsed.y
                        if (!m) return name + ': ' + fmt(avg)
                        const idx = m[1]
                        const datasets = context.chart.data.datasets
                        let minVal = null, maxVal = null
                        for (let k = 0; k < datasets.length; k++) {
                            const ds = datasets[k]
                            const dsBase = ((ds.label || '').split('|'))[0]
                            if (dsBase === 'sensor-' + idx + '-min') minVal = ds.data[context.dataIndex]
                            if (dsBase === 'sensor-' + idx + '-max') maxVal = ds.data[context.dataIndex]
                        }
                        if (minVal !== null && minVal !== undefined && maxVal !== null && maxVal !== undefined) {
                            return name + ': ' + fmt(avg) + ' (min ' + fmt(minVal) + ', max ' + fmt(maxVal) + ')'
                        }
                        return name + ': ' + fmt(avg)
                    }
                }
            })
        }
        delete options.tooltipMode

        const config = {
            type: type,
            data: data,
            options: options,
        }
        const myChart = new Chart( document.getElementById(chartId), config)
 }
CwChart.registerClickHandler = function(chartId, handler) {
  if (!window.__cwChartClickHandlers) window.__cwChartClickHandlers = {}
        window.__cwChartClickHandlers[chartId] = handler
 }
CwChart.toggleDataset = function(chartId, datasetIndex) {
  let chart = Chart.getChart(chartId);
        if (!chart) return;
        chart.setDatasetVisibility(datasetIndex, !chart.isDatasetVisible(datasetIndex));
        chart.update();
 }
CwChart.toggleDatasetGroup = function(chartId, labelPrefix) {
  const chart = Chart.getChart(chartId);
        if (!chart) return;
        const indices = [];
        chart.data.datasets.forEach((ds, i) => {
            if (ds.label && ds.label.indexOf(labelPrefix) === 0) indices.push(i);
        });
        if (indices.length === 0) return;
        const nextVisible = !chart.isDatasetVisible(indices[0]);
        indices.forEach(i => chart.setDatasetVisibility(i, nextVisible));
        chart.update();
 }
CwChart.setDatasetGroupVisibility = function(chartId, labelPrefix, visible) {
  const chart = Chart.getChart(chartId);
        if (!chart) return;
        chart.data.datasets.forEach((ds, i) => {
            if (ds.label && ds.label.indexOf(labelPrefix) === 0) {
                chart.setDatasetVisibility(i, visible);
            }
        });
        chart.update();
 }
CwChart.updateData = function(chartId, chartLabels, data) {
  let chart = Chart.getChart(chartId);
        if (!chart) return;

        chart.data.labels = gs.toJavascript(chartLabels);

        let newDatasets = gs.toJavascript(data.datasets);
        if (chart.data.datasets && newDatasets) {
            for (let i = 0; i < newDatasets.length; i++) {
                if (!chart.data.datasets[i]) {
                    chart.data.datasets[i] = {};
                }
                Object.assign(chart.data.datasets[i], newDatasets[i]);
            }
            chart.data.datasets.length = newDatasets.length;
            for (let i = 0; i < newDatasets.length; i++) {
                if (typeof newDatasets[i].hidden === 'boolean') {
                    chart.setDatasetVisibility(i, !newDatasets[i].hidden);
                }
            }
        }
        chart.update();
 }

function WizardUnitBindTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'WizardUnitBindTab', simpleName: 'WizardUnitBindTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String).add("orgId",String).add("unitName",String);
  Object.defineProperty(gSobject, 'ANALOG_ALERT_KEYS', { get: function() { return WizardUnitBindTab.ANALOG_ALERT_KEYS; }, set: function(gSval) { WizardUnitBindTab.ANALOG_ALERT_KEYS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIGITAL_ALERT_KEYS', { get: function() { return WizardUnitBindTab.DIGITAL_ALERT_KEYS; }, set: function(gSval) { WizardUnitBindTab.DIGITAL_ALERT_KEYS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIGITAL_TYPES', { get: function() { return WizardUnitBindTab.DIGITAL_TYPES; }, set: function(gSval) { WizardUnitBindTab.DIGITAL_TYPES = gSval; }, enumerable: true });
  gSobject.data = function(it) {
    return gs.map().add("bindings",gs.list([])).add("sensorOptions",gs.list([])).add("profileOptions",gs.list([])).add("binding",gs.map().add("sensor",null).add("profile",null).add("name","")).add("newSensorDialogOpen",false).add("newSensor",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription","")).add("newProfileDialogOpen",false).add("newProfile",gs.map().add("name","").add("type","").add("low","").add("high","").add("lowWarn","").add("highWarn","").add("alarmOnState",false).add("alarmOffState",false).add("onAlarmMessage","").add("offAlarmMessage","")).add("profileTypeOptions",gs.list(["temperature" , "humidity" , "co2" , "digitalInput" , "digitalOutput"]));
   };
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"loadBindings",[]);
    return gs.mc(gSobject,"loadOptions",[]);
   }
  gSobject['loadBindings'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"paginatedSensorProfiles",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), "", gs.map().add("unit",gs.gp(gSobject.self,"unitId")), gs.map().add("page",1).add("rowsPerPage",100).add("sortBy","name").add("descending",false), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.sp(gSobject.self,"bindings",gs.elvis(gs.bool(gs.gp(data,"sensorProfiles")) , gs.gp(data,"sensorProfiles") , gs.list([])));
     }]);
   }
  gSobject['loadOptions'] = function(it) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"availableForSensorProfile",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.self,"orgId"), "new", function(sensors) {
      return gs.sp(gSobject.self,"sensorOptions",gs.mc(gSobject,"decorateSensors",[sensors]));
     }]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"filteredProfiles",["", gs.map().add("org",gs.gp(gSobject.self,"orgId")), function(profiles) {
      return gs.sp(gSobject.self,"profileOptions",gs.elvis(gs.bool(profiles) , profiles , gs.list([])));
     }]);
   }
  gSobject['sensorDisplayLabel'] = function(s) {
    return gs.elvis(gs.bool(gs.gp(s,"mac",true)) , gs.gp(s,"mac",true) , gs.elvis(gs.bool(gs.gp(s,"identifier",true)) , gs.gp(s,"identifier",true) , gs.elvis(gs.bool(gs.gp(s,"serialNumber",true)) , gs.gp(s,"serialNumber",true) , "(unidentified)")));
   }
  gSobject['decorateSensors'] = function(list) {
    gs.mc(gs.elvis(gs.bool(list) , list , gs.list([])),"each",[function(it) {
      return gs.sp(it,"displayLabel",gs.mc(gSobject,"sensorDisplayLabel",[it]));
     }]);
    return gs.elvis(gs.bool(list) , list , gs.list([]));
   }
  gSobject['defaultAlertOptions'] = function(profile) {
    var keys = (gs.mc(WizardUnitBindTab.DIGITAL_TYPES,"contains",[gs.gp(profile,"type",true)]) ? WizardUnitBindTab.DIGITAL_ALERT_KEYS : WizardUnitBindTab.ANALOG_ALERT_KEYS);
    var opts = gs.map();
    gs.mc(keys,"each",[function(k) {
      return (opts[k]) = true;
     }]);
    return opts;
   }
  gSobject['saveBinding'] = function(it) {
    if (!gs.bool(gs.gp(gs.gp(gs.gp(gSobject.self,"binding"),"sensor"),"_id",true))) {
      return gs.mc(gSobject,"notify",["Physical Sensor is required", "warning"]);
     };
    if (!gs.bool(gs.gp(gs.gp(gs.gp(gSobject.self,"binding"),"profile"),"_id",true))) {
      return gs.mc(gSobject,"notify",["Measurement Template is required", "warning"]);
     };
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"binding"),"name"),"trim",[], null, true))) {
      return gs.mc(gSobject,"notify",["Sensor Display Name is required", "warning"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    var payload = gs.map().add("unit",gs.gp(gSobject.self,"unitId")).add("sensor",gs.gp(gs.gp(gSobject.self,"binding"),"sensor")).add("profile",gs.gp(gs.gp(gSobject.self,"binding"),"profile")).add("name",gs.mc(gs.gp(gs.gp(gSobject.self,"binding"),"name"),"trim",[])).add("alertOptions",gs.mc(gSobject,"defaultAlertOptions",[gs.gp(gs.gp(gSobject.self,"binding"),"profile")])).add("inactivePeriods",gs.list([]));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"save",[payload, function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(data,"error",true))) {
        return gs.mc(gSobject,"notify",[gs.gp(data,"error"), "negative"]);
       };
      gs.mc(gSobject,"notify",["Sensor bound to unit"]);
      gs.sp(gSobject.self,"binding",gs.map().add("sensor",null).add("profile",null).add("name",""));
      gs.mc(gSobject,"loadBindings",[]);
      return gs.mc(gSobject,"loadOptions",[]);
     }]);
   }
  gSobject['removeBinding'] = function(row) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Unbind Sensor").add("message","Remove \"" + (gs.gp(row,"name")) + "\" from this unit?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"delete",[gs.gp(row,"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Sensor unbound", "negative"]);
        gs.mc(gSobject,"loadBindings",[]);
        return gs.mc(gSobject,"loadOptions",[]);
       }]);
     }]);
   }
  gSobject['openNewSensorDialog'] = function(it) {
    gs.sp(gSobject.self,"newSensor",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription",""));
    return gs.sp(gSobject.self,"newSensorDialogOpen",true);
   }
  gSobject['cancelNewSensor'] = function(it) {
    return gs.sp(gSobject.self,"newSensorDialogOpen",false);
   }
  gSobject['saveNewSensor'] = function(it) {
    var mac = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newSensor"),"mac")) , gs.gp(gs.gp(gSobject.self,"newSensor"),"mac") , ""),"trim",[]);
    var identifier = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newSensor"),"identifier")) , gs.gp(gs.gp(gSobject.self,"newSensor"),"identifier") , ""),"trim",[]);
    var serialNumber = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newSensor"),"serialNumber")) , gs.gp(gs.gp(gSobject.self,"newSensor"),"serialNumber") , ""),"trim",[]);
    if (((!gs.bool(mac)) && (!gs.bool(identifier))) && (!gs.bool(serialNumber))) {
      return gs.mc(gSobject,"notify",["A Mac Address, Sensor Identifier or Serial Number is required", "warning"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"save",[gs.map().add("mac",mac).add("identifier",identifier).add("serialNumber",serialNumber).add("locationDescription",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newSensor"),"locationDescription")) , gs.gp(gs.gp(gSobject.self,"newSensor"),"locationDescription") , ""),"trim",[])).add("org",gs.gp(gSobject.self,"orgId")).add("active",true), gs.gp(gs.fs('session', this, gSobject),"userId")]),"then",[function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"newSensorDialogOpen",false);
      gs.mc(gSobject,"notify",["Sensor Created"]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"availableForSensorProfile",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.self,"orgId"), "new", function(sensors) {
        gs.sp(gSobject.self,"sensorOptions",gs.mc(gSobject,"decorateSensors",[sensors]));
        var picked = gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.self,"sensorOptions")) , gs.gp(gSobject.self,"sensorOptions") , gs.list([])),"find",[function(it) {
          return gs.equals(gs.gp(it,"_id"), gs.gp(saved,"_id"));
         }]);
        if (gs.bool(picked)) {
          return gs.sp(gs.gp(gSobject.self,"binding"),"sensor",picked);
         };
       }]);
     }, function(error) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.mc(gSobject,"notify",[gs.elvis(gs.bool(gs.gp(error,"message",true)) , gs.gp(error,"message",true) , "Failed to create sensor"), "negative"]);
     }]);
   }
  gSobject['openNewProfileDialog'] = function(it) {
    gs.sp(gSobject.self,"newProfile",gs.map().add("name","").add("type","").add("low","").add("high","").add("lowWarn","").add("highWarn","").add("alarmOnState",false).add("alarmOffState",false).add("onAlarmMessage","").add("offAlarmMessage",""));
    return gs.sp(gSobject.self,"newProfileDialogOpen",true);
   }
  gSobject['cancelNewProfile'] = function(it) {
    return gs.sp(gSobject.self,"newProfileDialogOpen",false);
   }
  gSobject['newProfileIsDigital'] = function(it) {
    return gs.mc(WizardUnitBindTab.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.self,"newProfile"),"type",true)]);
   }
  gSobject['saveNewProfile'] = function(it) {
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"newProfile"),"name"),"trim",[], null, true))) {
      return gs.mc(gSobject,"notify",["Measurement template name is required", "warning"]);
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"type"))) {
      return gs.mc(gSobject,"notify",["Measurement template type is required", "warning"]);
     };
    var isDigital = gs.mc(WizardUnitBindTab.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.self,"newProfile"),"type")]);
    var payload = gs.map().add("name",gs.mc(gs.gp(gs.gp(gSobject.self,"newProfile"),"name"),"trim",[])).add("type",gs.gp(gs.gp(gSobject.self,"newProfile"),"type")).add("org",gs.gp(gSobject.self,"orgId"));
    if (gs.bool(isDigital)) {
      gs.sp(payload,"alarmOnState",(gs.equals(gs.gp(gs.gp(gSobject.self,"newProfile"),"alarmOnState"), true)));
      gs.sp(payload,"alarmOffState",(gs.equals(gs.gp(gs.gp(gSobject.self,"newProfile"),"alarmOffState"), true)));
      gs.sp(payload,"onAlarmMessage",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"onAlarmMessage")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"onAlarmMessage") , ""),"toString",[]));
      gs.sp(payload,"offAlarmMessage",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"offAlarmMessage")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"offAlarmMessage") , ""),"toString",[]));
     } else {
      gs.sp(payload,"low",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"low")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"low") , 0));
      gs.sp(payload,"high",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"high")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"high") , 0));
      gs.sp(payload,"lowWarn",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"lowWarn")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"lowWarn") , 0));
      gs.sp(payload,"highWarn",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newProfile"),"highWarn")) , gs.gp(gs.gp(gSobject.self,"newProfile"),"highWarn") , 0));
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"save",[payload, function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"newProfileDialogOpen",false);
      gs.mc(gSobject,"notify",["Measurement Template Created"]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"filteredProfiles",["", gs.map().add("org",gs.gp(gSobject.self,"orgId")), function(profiles) {
        gs.sp(gSobject.self,"profileOptions",gs.elvis(gs.bool(profiles) , profiles , gs.list([])));
        var picked = gs.mc(gs.elvis(gs.bool(profiles) , profiles , gs.list([])),"find",[function(it) {
          return gs.equals(gs.gp(it,"_id"), gs.gp(saved,"_id"));
         }]);
        if (gs.bool(picked)) {
          return gs.sp(gs.gp(gSobject.self,"binding"),"profile",picked);
         };
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
WizardUnitBindTab.ANALOG_ALERT_KEYS = gs.list(["highAlarm" , "highWarning" , "lowWarning" , "lowAlarm" , "noDataChange" , "noData"]);
WizardUnitBindTab.DIGITAL_ALERT_KEYS = gs.list(["digitalIoAlarm"]);
WizardUnitBindTab.DIGITAL_TYPES = gs.list(["digitalInput" , "digitalOutput"]);

function LegionPinComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'LegionPinComponent', simpleName: 'LegionPinComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.path = "/legionPin";
  gSobject['created'] = function(it) {
    gs.println("LegionPinComponent.created()");
    gs.sp(gSobject.scope,"pin","");
    return gs.sp(gSobject.scope,"processing",false);
   }
  gSobject['pinAuth'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"pin"))) {
      gs.mc(gSobject,"notify",["Please enter pin", "negative"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"))) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/login"]);
     };
    gs.sp(gSobject.scope,"processing",true);
    return gs.mc(gs.fs('legionUserService', this, gSobject),"authWithPin",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), gs.gp(gSobject.scope,"pin"), function(result) {
      gs.println("result");
      gs.println(result);
      gs.sp(gs.fs('session', this, gSobject),"user",gs.gp(gs.fs('session', this, gSobject),"legionUser"));
      gs.sp(gs.fs('session', this, gSobject),"userId",gs.gp(gs.fs('session', this, gSobject),"legionUserId"));
      gs.sp(gSobject.scope,"processing",false);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
     }, function(error) {
      gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
      return gs.sp(gSobject.scope,"processing",false);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3FormContainer() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3FormContainer', simpleName: 'I3FormContainer'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("margin",gs.map().add("type",String).add("default","lg")).add("gap",gs.map().add("type",String).add("default","sm")).add("maxWidth",gs.map().add("type",String).add("default","")).add("twoColumn",gs.map().add("type",Boolean).add("default",false)).add("threeColumn",gs.map().add("type",Boolean).add("default",false));
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3PageBody() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3PageBody', simpleName: 'I3PageBody'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.list([]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"showFooter",true);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function MapComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'MapComponent', simpleName: 'MapComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("lat",Number).add("lon",Number);
  gSobject['mounted'] = function(it) {
    var self = this;
    var la = gs.elvis(gs.bool(gs.gp(self,"lat")) , gs.gp(self,"lat") , -33.9249);
    var lo = gs.elvis(gs.bool(gs.gp(self,"lon")) , gs.gp(self,"lon") , 18.4241);
    return gs.mc(gSobject,"showMap",[la, lo]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.mc(gSobject,"cleanupDarkObserver",[]);
   }
  gSobject.showMap = function(lat, lon) {
    var component = this;
        var el = document.getElementById('map-component-map');
        if (!el) return;
        if (!window.google || !window.google.maps) {
            setTimeout(function() { component.showMap(lat, lon); }, 500);
            return;
        }
        var center = { lat: lat, lng: lon };
        var darkStyles = [
            { elementType: "geometry", stylers: [{ color: "#212121" }] },
            { elementType: "labels.icon", stylers: [{ visibility: "off" }] },
            { elementType: "labels.text.fill", stylers: [{ color: "#757575" }] },
            { elementType: "labels.text.stroke", stylers: [{ color: "#212121" }] },
            { featureType: "administrative.country", elementType: "labels.text.fill", stylers: [{ color: "#9e9e9e" }] },
            { featureType: "administrative.locality", elementType: "labels.text.fill", stylers: [{ color: "#bdbdbd" }] },
            { featureType: "poi", elementType: "labels.text.fill", stylers: [{ color: "#757575" }] },
            { featureType: "poi.park", elementType: "geometry", stylers: [{ color: "#181818" }] },
            { featureType: "road", elementType: "geometry.fill", stylers: [{ color: "#2c2c2c" }] },
            { featureType: "road", elementType: "labels.text.fill", stylers: [{ color: "#8a8a8a" }] },
            { featureType: "road.highway", elementType: "geometry", stylers: [{ color: "#3c3c3c" }] },
            { featureType: "water", elementType: "geometry", stylers: [{ color: "#000000" }] },
            { featureType: "water", elementType: "labels.text.fill", stylers: [{ color: "#3d3d3d" }] }
        ];
        var isDark = document.body.classList.contains('body--dark');
        var map = new google.maps.Map(el, {
            zoom: 13,
            center: center,
            mapTypeId: 'roadmap',
            styles: isDark ? darkStyles : []
        });
        var infoWindow = new google.maps.InfoWindow({
            content: '<div><strong>Location</strong><br/>' + lat + ', ' + lon + '</div>'
        });
        var marker = new google.maps.Marker({
            position: center,
            map: map,
            title: 'Location'
        });
        marker.addListener('click', function() {
            infoWindow.open(map, marker);
        });
        window._mapComponent_map = map;
        window._mapComponent_marker = marker;
        window._mapComponent_darkStyles = darkStyles;

        if (window._mapComponent_observer) window._mapComponent_observer.disconnect();
        window._mapComponent_observer = new MutationObserver(function() {
            var nowDark = document.body.classList.contains('body--dark');
            if (window._mapComponent_map) {
                window._mapComponent_map.setOptions({ styles: nowDark ? window._mapComponent_darkStyles : [] });
            }
        });
        window._mapComponent_observer.observe(document.body, { attributes: true, attributeFilter: ['class'] });
   }
  gSobject.cleanupDarkObserver = function() {
    if (window._mapComponent_observer) {
            window._mapComponent_observer.disconnect();
            window._mapComponent_observer = null;
        }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaSimBridgeAuth() {
  var gSobject = gs.init('CordovaSimBridgeAuth');
  gSobject.clazz = { name: 'CordovaSimBridgeAuth', simpleName: 'CordovaSimBridgeAuth'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject.active = false;
  gSobject.pendingCallbacks = gs.map();
  gSobject.shouldActivate = function() { return CordovaSimBridgeAuth.shouldActivate(); }
  gSobject['activate'] = function(it) {
    gSobject.active = true;
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["CordovaSimBridgeAuth: ACTIVE — adding auth, health, and media stubs"]);
    gs.mc(gSobject,"patchUserAgent",[]);
    gs.mc(gSobject,"addPluginStubs",[]);
    gs.mc(gSobject,"listenForMessages",[]);
    return gs.mc(gSobject,"patchUtilsIsCordova",[]);
   }
  gSobject.patchUserAgent = function() {
    // Append 'cordova.simulator' to the user agent so Utils.isCordova() returns true.
        // Utils.isCordova() checks: userAgent().contains('cordova')
        try {
            var originalUA = navigator.userAgent;
            Object.defineProperty(navigator, 'userAgent', {
                get: function() { return originalUA + ' cordova.simulator.1.0.0'; },
                configurable: true
            });
            console.log('[SimBridgeAuth] User agent patched — appended cordova.simulator.1.0.0');
        } catch(e) {
            console.warn('[SimBridgeAuth] Could not patch userAgent:', e);
        }
   }
  gSobject.addPluginStubs = function() {
    var bridge = this;

        // ===================== APPLE SIGN-IN =====================
        window.cordova.plugins.SignInWithApple = {
            signin: function(options, success, error) {
                bridge._storePending('appleSignIn', 'signin', success, error);
                console.log('[SimBridgeAuth] Apple Sign-In: waiting for simulated auth...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'appleSignIn', action:'signin'}, '*');
            }
        };

        // ===================== GOOGLE SIGN-IN =====================
        window.cordova.plugins.GoogleSignInPlugin = {
            signIn: function(success, error) {
                bridge._storePending('googleSignIn', 'signIn', success, error);
                console.log('[SimBridgeAuth] Google Sign-In: waiting for simulated auth...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'googleSignIn', action:'signIn'}, '*');
            },
            isSignedIn: function(success, error) {
                if (success) success({isSignedIn: false});
            },
            signOut: function(success, error) {
                console.log('[SimBridgeAuth] Google Sign-Out');
                if (success) success();
            },
            oneTapLogin: function(success, error) {
                bridge._storePending('googleSignIn', 'oneTap', success, error);
                console.log('[SimBridgeAuth] Google One-Tap: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'googleSignIn', action:'oneTap'}, '*');
            },
        };

        // ===================== HEALTH =====================
        window.cordova.plugins.health = {
            isAvailable: function(success, error) {
                console.log('[SimBridgeAuth] Health: isAvailable -> true');
                if (success) success(true);
            },
            requestAuthorization: function(datatypes, success, error) {
                console.log('[SimBridgeAuth] Health: requestAuthorization granted');
                if (success) success(true);
            },
            isAuthorized: function(datatypes, success, error) {
                if (success) success(true);
            },
            query: function(params, success, error) {
                bridge._storePending('health', 'query', success, error);
                console.log('[SimBridgeAuth] Health query:', params.dataType, '— waiting for simulated data...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'health', action:'query', data:params}, '*');
            },
            queryAggregated: function(params, success, error) {
                bridge._storePending('health', 'queryAggregated', success, error);
                console.log('[SimBridgeAuth] Health queryAggregated:', params.dataType, '— waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'health', action:'queryAggregated', data:params}, '*');
            },
            store: function(data, success, error) {
                console.log('[SimBridgeAuth] Health store:', data);
                if (success) success();
            },
        };

        // ===================== MEDIA CAPTURE =====================
        window.navigator.device = window.navigator.device || {};
        window.navigator.device.capture = {
            captureImage: function(success, error, options) {
                bridge._storePending('media', 'captureImage', success, error);
                console.log('[SimBridgeAuth] Media captureImage: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'media', action:'captureImage'}, '*');
            },
            captureAudio: function(success, error, options) {
                bridge._storePending('media', 'captureAudio', success, error);
                console.log('[SimBridgeAuth] Media captureAudio: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'media', action:'captureAudio'}, '*');
            },
            captureVideo: function(success, error, options) {
                bridge._storePending('media', 'captureVideo', success, error);
                console.log('[SimBridgeAuth] Media captureVideo: waiting...');
                window.parent.postMessage({type:'cordova-sim-ready', plugin:'media', action:'captureVideo'}, '*');
            },
        };

        console.log('[SimBridgeAuth] Plugin stubs registered: SignInWithApple, GoogleSignInPlugin, health, media capture');
   }
  gSobject.listenForMessages = function() {
    var bridge = this;
        window.addEventListener('message', function(event) {
            var msg = event.data;
            if (!msg || msg.type !== 'cordova-sim') return;

            switch (msg.plugin) {
                case 'appleSignIn':
                    if (msg.action === 'success') bridge._firePending('appleSignIn', 'signin', msg.data);
                    if (msg.action === 'fail') bridge._firePendingError('appleSignIn', 'signin', msg.data || 'User cancelled');
                    break;

                case 'googleSignIn':
                    if (msg.action === 'success') bridge._firePending('googleSignIn', 'signIn', msg.data);
                    if (msg.action === 'oneTapSuccess') bridge._firePending('googleSignIn', 'oneTap', msg.data);
                    if (msg.action === 'fail') bridge._firePendingError('googleSignIn', 'signIn', msg.data || 'Sign in cancelled');
                    break;

                case 'health':
                    if (msg.action === 'queryResult') bridge._firePending('health', 'query', msg.data);
                    if (msg.action === 'queryAggregatedResult') bridge._firePending('health', 'queryAggregated', msg.data);
                    break;

                case 'media':
                    if (msg.action === 'capturedImage') bridge._firePending('media', 'captureImage', msg.data);
                    if (msg.action === 'capturedAudio') bridge._firePending('media', 'captureAudio', msg.data);
                    if (msg.action === 'capturedVideo') bridge._firePending('media', 'captureVideo', msg.data);
                    break;

                case 'console':
                    if (msg.action === 'eval') {
                        try {
                            var result = eval(msg.data.code);
                            window.parent.postMessage({type:'cordova-sim-event', plugin:'console', action:'result', data:{code: msg.data.code, result: JSON.stringify(result)}}, '*');
                        } catch(e) {
                            window.parent.postMessage({type:'cordova-sim-event', plugin:'console', action:'error', data:{code: msg.data.code, error: e.message}}, '*');
                        }
                    }
                    break;
            }
        });
        console.log('[SimBridgeAuth] postMessage listener registered for auth/health/media');
   }
  gSobject.patchUtilsIsCordova = function() {
    // Utils is loaded later by GrooScript. Poll until it exists, then patch.
        var attempts = 0;
        var patcher = setInterval(function() {
            attempts++;
            if (typeof Utils !== 'undefined' && Utils.isCordova) {
                Utils.isCordova = function() { return true; };
                Utils.cordovaDevice = function() { return true; };
                console.log('[SimBridgeAuth] Utils.isCordova patched to return true');
                clearInterval(patcher);
            }
            if (attempts > 100) clearInterval(patcher); // stop after ~10s
        }, 100);
   }
  gSobject._storePending = function(plugin, action, success, error) {
    var key = plugin + ':' + action;
        this.pendingCallbacks[key] = { success: success, error: error };
   }
  gSobject._firePending = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.success) {
            pending.success(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject._firePendingError = function(plugin, action, data) {
    var key = plugin + ':' + action;
        var pending = this.pendingCallbacks[key];
        if (pending && pending.error) {
            pending.error(data);
            delete this.pendingCallbacks[key];
        }
   }
  gSobject['CordovaSimBridgeAuth0'] = function(it) {
    if (CordovaSimBridgeAuth.shouldActivate()) {
      gs.mc(gSobject,"activate",[]);
     };
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaSimBridgeAuth0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaSimBridgeAuth.shouldActivate = function() {
  // Only activate if CordovaSimBridge already created the fake cordova object
        // i.e. we're in an iframe and window.cordova exists but is our fake one
        return (window.parent !== window) && (typeof window.cordova !== 'undefined') && (typeof window.device !== 'undefined' && window.device.platform === 'Simulator');
 }

function I3Chart() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Chart', simpleName: 'I3Chart'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("labels",Array).add("values",Array).add("data",Array).add("datasets",Array).add("id",String).add("type",String).add("title",String).add("legend",Boolean).add("borderWidth",Number).add("borderRadius",Number).add("borderColor",String).add("backgroundColor",String).add("color",String).add("tension",Number).add("filled",Boolean).add("horizontal",Boolean).add("xHide",Boolean).add("xStacked",Boolean).add("xGridHide",Boolean).add("yHide",Boolean).add("yStacked",Boolean).add("yGridHide",Boolean).add("rHide",Boolean).add("rGridHide",Boolean).add("yScaleLabel",String).add("yScalePos",String).add("min",Number).add("max",Number).add("yScaleType",String).add("pointStyle",String).add("pointRadius",Number).add("dashedLine",Array).add("stepped",Boolean).add("alternate",Boolean).add("transparent",Boolean);
  gSobject.colors = gs.list(["#37a2eb" , "#ff6383" , "#4ac1c0" , "#fca048" , "#9966ff" , "#ffce56" , "#c9cbcf"]);
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gSobject,"loadChart",[self, true]);
   }
  gSobject['loadChart'] = function(self, newChart) {
    if (self === undefined) self = this;
    if (newChart === undefined) newChart = false;
    var labels = gs.list([]);
    gs.mc(gs.range(0, 4, true),"each",[function(it) {
      return gs.mc(labels,"add",[it]);
     }]);
    var options = gs.map().add("responsive",true).add("animation",true).add("indexAxis",(gs.bool(gs.gp(self,"horizontal")) ? "y" : "x")).add("plugins",gs.toJavascript(gs.mc(gSobject,"plugins",[self]))).add("scales",gs.toJavascript(gs.mc(gSobject,"scales",[self])));
    var data = gs.map();
    gs.sp(data,"labels",(gs.bool(gs.gp(self,"labels")) ? gs.toJavascript(gs.gp(self,"labels")) : gs.toJavascript(labels)));
    gs.sp(data,"datasets",gs.toJavascript(gs.mc(gSobject,"datasets",[self])));
    return gs.mc(gSobject,"nextTick",[function(it) {
      if (gs.bool(newChart)) {
        return gs.execStatic(I3Chart,'paintChart', this,[gs.gp(self,"id"), data, options, gs.gp(self,"type")]);
       } else {
        return gs.execStatic(I3Chart,'updateData', this,[gs.gp(self,"id"), gs.gp(self,"labels"), gs.gp(self,"values")]);
       };
     }]);
   }
  gSobject['dataset'] = function(self, data, index) {
    if (self === undefined) self = this;
    if (index === undefined) index = 0;
    var dataset = gs.map();
    gs.sp(dataset,"label",gs.elvis(gs.bool(gs.gp(self,"label")) , gs.gp(self,"label") , ""));
    gs.sp(dataset,"data",data);
    gs.sp(dataset,"borderWidth",gs.elvis(gs.bool(gs.gp(self,"borderWidth")) , gs.gp(self,"borderWidth") , 1));
    gs.sp(dataset,"borderRadius",gs.elvis(gs.bool(gs.gp(self,"borderRadius")) , gs.gp(self,"borderRadius") , 0));
    gs.sp(dataset,"borderSkipped",false);
    if (gs.bool(gs.gp(self,"data"))) {
      gs.sp(dataset,"borderColor",gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors)));
      gs.sp(dataset,"pointBackgroundColor",gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors)));
      var color = gs.elvis(gs.bool(gs.gp(self,"backgroundColor")) , gs.gp(self,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"backgroundColor",color);
     };
    if (gs.bool(gs.gp(self,"datasets"))) {
      var color = gs.elvis(gs.bool(gs.gp(self,"borderColor")) , gs.gp(self,"borderColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"borderColor",(gs.mc(color,"contains",["#"]) ? color : color[(gs.mod(index, gs.gp(color,"length")))]));
      gs.sp(dataset,"pointBackgroundColor",color);
      color = gs.elvis(gs.bool(gs.gp(self,"backgroundColor")) , gs.gp(self,"backgroundColor") , gs.elvis(gs.bool(gs.gp(self,"color")) , gs.gp(self,"color") , gSobject.colors));
      gs.sp(dataset,"backgroundColor",(gs.mc(color,"contains",["#"]) ? color : color[(gs.mod(index, gs.gp(color,"length")))]));
     };
    gs.sp(dataset,"tension",gs.elvis(gs.bool(gs.gp(self,"tension")) , gs.gp(self,"tension") , 0.1));
    gs.sp(dataset,"fill",gs.elvis(gs.bool(gs.gp(self,"filled")) , gs.gp(self,"filled") , false));
    gs.sp(dataset,"pointStyle",gs.elvis(gs.bool(gs.gp(self,"pointStyle")) , gs.gp(self,"pointStyle") , false));
    gs.sp(dataset,"pointRadius",gs.elvis(gs.bool(gs.gp(self,"pointRadius")) , gs.gp(self,"pointRadius") , 0));
    gs.sp(dataset,"stepped",gs.elvis(gs.bool(gs.gp(self,"stepped")) , gs.gp(self,"stepped") , false));
    gs.sp(dataset,"borderDash",gs.elvis(gs.bool(gs.gp(self,"dashedLine")) , gs.gp(self,"dashedLine") , gs.list([0 , 0])));
    return dataset;
   }
  gSobject['datasets'] = function(self) {
    if (self === undefined) self = this;
    var datasets = gs.list([]);
    if (gs.bool(gs.gp(self,"data"))) {
      gs.mc(datasets,"add",[gs.mc(gSobject,"dataset",[self, gs.gp(self,"data")])]);
     };
    if (gs.bool(gs.gp(self,"datasets"))) {
      gs.mc(gs.toJavascript(gs.gp(self,"datasets")),"eachWithIndex",[function(data, index) {
        return gs.mc(datasets,"add",[gs.mc(gSobject,"dataset",[self, data, index])]);
       }]);
     };
    return datasets;
   }
  gSobject['plugins'] = function(self) {
    if (self === undefined) self = this;
    var title = gs.map();
    if (gs.bool(gs.gp(self,"title"))) {
      gs.sp(title,"display",true);
      gs.sp(title,"text",gs.gp(self,"title"));
     };
    var legend = gs.map();
    gs.sp(legend,"display",gs.gp(self,"legend"));
    var plugins = gs.map();
    gs.sp(plugins,"legend",legend);
    gs.sp(plugins,"title",title);
    return plugins;
   }
  gSobject['scales'] = function(self) {
    if (self === undefined) self = this;
    var xScale = gs.map();
    gs.sp(xScale,"display",(gs.bool(gs.gp(self,"xHide")) ? false : true));
    gs.sp(xScale,"stacked",gs.elvis(gs.bool(gs.gp(self,"xStacked")) , gs.gp(self,"xStacked") , false));
    gs.sp(xScale,"grid",gs.map());
    gs.sp(gs.gp(xScale,"grid"),"display",(gs.bool(gs.gp(self,"xGridHide")) ? false : true));
    var yScale = gs.map();
    gs.sp(yScale,"display",(gs.bool(gs.gp(self,"yHide")) ? false : true));
    gs.sp(yScale,"stacked",gs.elvis(gs.bool(gs.gp(self,"yStacked")) , gs.gp(self,"yStacked") , false));
    if (gs.bool(gs.gp(self,"min"))) {
      gs.sp(yScale,"suggestedMin",gs.gp(self,"min"));
     };
    if (gs.bool(gs.gp(self,"max"))) {
      gs.sp(yScale,"suggestedMax",gs.gp(self,"max"));
     };
    gs.sp(yScale,"grid",gs.map());
    gs.sp(gs.gp(yScale,"grid"),"display",(gs.bool(gs.gp(self,"yGridHide")) ? false : true));
    var rScale = gs.map();
    gs.sp(rScale,"display",(gs.bool(gs.gp(self,"rHide")) ? false : true));
    gs.sp(rScale,"grid",gs.map());
    gs.sp(gs.gp(rScale,"grid"),"display",(gs.bool(gs.gp(self,"rGridHide")) ? false : true));
    var scales = gs.map();
    if (gs.mc(gs.list(["radar" , "polarArea"]),"includes",[gs.gp(self,"type")])) {
      gs.sp(scales,"r",gs.toJavascript(rScale));
     };
    if (!gs.bool(gs.mc(gs.list(["doughnut" , "pie" , "polarArea" , "radar"]),"includes",[gs.gp(self,"type")]))) {
      gs.sp(scales,"x",gs.toJavascript(xScale));
      gs.sp(scales,"y",gs.toJavascript(yScale));
     };
    return scales;
   }
  gSobject.paintChart = function(x0,x1,x2,x3) { return I3Chart.paintChart(x0,x1,x2,x3); }
  gSobject.updateData = function(x0,x1,x2) { return I3Chart.updateData(x0,x1,x2); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
I3Chart.paintChart = function(chartId, data, options, type) {
  if (type === undefined) type = "line";
  const oldChart = Chart.getChart(chartId)
        if (oldChart != undefined) oldChart.destroy()
        const config = { 
            type: type,
            data: data,
            options: options,
        }
        const myChart = new Chart( document.getElementById(chartId), config)
 }
I3Chart.updateData = function(chartId, chartLabels, dataSet) {
  let chart = Chart.getChart(chartId);
        chart.data.datasets[0].data =  gs.toJavascript(dataSet)
        chart.data.labels = gs.toJavascript(chartLabels)
        chart.update()
 }

function AdminSensorsListTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminSensorsListTab', simpleName: 'AdminSensorsListTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("organisationId",String);
  gSobject.data = function(it) {
    return gs.map().add("searchText","").add("sensors",gs.list([])).add("filter",gs.map()).add("pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","mac").add("descending",false)).add("dialogOpen",false).add("isNew",false).add("editing",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription",""));
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"columns",gs.list([gs.map().add("name","mac").add("label","Mac Address").add("field","mac").add("align","left").add("sortable",true) , gs.map().add("name","identifier").add("label","Identifier").add("field","identifier").add("align","left").add("sortable",true) , gs.map().add("name","serialNumber").add("label","Serial Number").add("field","serialNumber").add("align","left").add("sortable",true)]));
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['loadSensors'] = function(it) {
    gs.sp(gSobject.self,"filter",gs.map().add("org",gs.gp(gSobject.self,"organisationId")));
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"paginatedSensors",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.self,"searchText"), gs.gp(gSobject.self,"filter"), gs.gp(gSobject.self,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"sensors",gs.gp(data,"sensors"));
      return gs.sp(gs.gp(gSobject.self,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['onRequest'] = function(props) {
    return gs.mc(gSobject.self,"updatePagination",[gs.gp(props,"pagination")]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.self,"pagination",pagination);
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['onRowClick'] = function(evt, row, index) {
    return gs.mc(gSobject.self,"openEdit",[row]);
   }
  gSobject['openNew'] = function(it) {
    gs.sp(gSobject.self,"isNew",true);
    gs.sp(gSobject.self,"editing",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription","").add("org",gs.gp(gSobject.self,"organisationId")));
    return gs.sp(gSobject.self,"dialogOpen",true);
   }
  gSobject['openEdit'] = function(sensor) {
    gs.sp(gSobject.self,"isNew",false);
    gs.sp(gSobject.self,"editing",gs.map().add("_id",gs.gp(sensor,"_id")).add("mac",gs.elvis(gs.bool(gs.gp(sensor,"mac")) , gs.gp(sensor,"mac") , "")).add("identifier",gs.elvis(gs.bool(gs.gp(sensor,"identifier")) , gs.gp(sensor,"identifier") , "")).add("serialNumber",gs.elvis(gs.bool(gs.gp(sensor,"serialNumber")) , gs.gp(sensor,"serialNumber") , "")).add("locationDescription",gs.elvis(gs.bool(gs.gp(sensor,"locationDescription")) , gs.gp(sensor,"locationDescription") , "")).add("org",gs.gp(gSobject.self,"organisationId")));
    return gs.sp(gSobject.self,"dialogOpen",true);
   }
  gSobject['cancelDialog'] = function(it) {
    return gs.sp(gSobject.self,"dialogOpen",false);
   }
  gSobject['saveDialog'] = function(it) {
    if (((!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"editing"),"mac"),"trim",[], null, true))) && (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"editing"),"identifier"),"trim",[], null, true)))) && (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"editing"),"serialNumber"),"trim",[], null, true)))) {
      gs.mc(gSobject,"notify",["A Mac Address, Sensor Identifier or Serial Number is required", "warning"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"save",[gs.gp(gSobject.self,"editing"), gs.gp(gs.fs('session', this, gSobject),"userId")]),"then",[function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"dialogOpen",false);
      gs.mc(gSobject,"notify",["Physical Sensor Saved"]);
      return gs.mc(gSobject,"loadSensors",[]);
     }, function(error) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.mc(gSobject,"notify",[gs.elvis(gs.bool(gs.gp(error,"message",true)) , gs.gp(error,"message",true) , "Failed to save physical sensor"), "negative"]);
     }]);
   }
  gSobject['removeFromDialog'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Confirmation").add("message","Are you sure you want to delete this physical sensor?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"remove",[gs.gp(gs.gp(gSobject.self,"editing"),"_id"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.self,"dialogOpen",false);
        gs.mc(gSobject,"notify",["Physical Sensor Deleted", "negative"]);
        return gs.mc(gSobject,"loadSensors",[]);
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitHumidityReadingsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitHumidityReadingsTab', simpleName: 'UnitHumidityReadingsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("unitId",String);
  gSobject.self = null;
  gSobject.pollingTimer = null;
  gSobject.data = function(it) {
    return gs.map().add("sensorReadings",gs.list([])).add("highestHumidity",null).add("lowestHumidity",null).add("selectedTimeframe","5min").add("customDays",7).add("showMinMax",false).add("historyLabels",gs.list([])).add("historyDatasets",gs.list([])).add("historySeriesNames",gs.list([])).add("historyMinDatasets",gs.list([])).add("historyMaxDatasets",gs.list([])).add("historyBucketStartMs",gs.list([])).add("historyBucketMinutes",1).add("hiddenHumiditySeries",gs.list([])).add("voltageLabels",gs.list([])).add("voltageDatasets",gs.list([])).add("voltageSeriesNames",gs.list([])).add("drillFromMs",null).add("drillToMs",null).add("drillLabel",null).add("loadingHistory",false);
   };
  gSobject['created'] = function(it) {
    gSobject.self = this;
    gs.execStatic(CwChart,'registerClickHandler', this,["unitHumidityHistory", function(datasetIndex, bucketIndex) {
      return gs.mc(gSobject,"drillIntoBucket",[bucketIndex]);
     }]);
    gs.mc(gSobject,"loadMeasurements",[]);
    gs.mc(gSobject,"loadHistory",[]);
    return gSobject.pollingTimer = gs.execStatic(Utils,'setInterval', this,[function(it) {
      return gs.mc(gSobject,"loadMeasurements",[]);
     }, 60000]);
   }
  gSobject['destroyed'] = function(it) {
    return gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
   }
  gSobject['loadHistoryTimeframe'] = function(timeframe) {
    gs.sp(gSobject.self,"selectedTimeframe",timeframe);
    gs.sp(gSobject.self,"drillFromMs",null);
    gs.sp(gSobject.self,"drillToMs",null);
    gs.sp(gSobject.self,"drillLabel",null);
    if (gs.equals(timeframe, "custom")) {
      return null;
     };
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['updateCustomDays'] = function(days) {
    var d = gs.elvis(gs.bool(days) , days , 7);
    if (d < 2) {
      d = 2;
     };
    if (d > 30) {
      d = 30;
     };
    return gs.sp(gSobject.self,"customDays",d);
   }
  gSobject['applyCustomRange'] = function(it) {
    gs.sp(gSobject.self,"selectedTimeframe","custom");
    gs.sp(gSobject.self,"drillFromMs",null);
    gs.sp(gSobject.self,"drillToMs",null);
    gs.sp(gSobject.self,"drillLabel",null);
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['updateShowMinMax'] = function(val) {
    return gs.sp(gSobject.self,"showMinMax",(gs.bool(val) ? true : false));
   }
  gSobject['isDrillable'] = function(it) {
    var tf = gs.gp(gSobject.self,"selectedTimeframe");
    return ((gs.equals(tf, "8hours")) || (gs.equals(tf, "24hours"))) || (gs.equals(tf, "custom"));
   }
  gSobject['toggleHumiditySeries'] = function(index) {
    var current = gs.elvis(gs.bool(gs.gp(gSobject.self,"hiddenHumiditySeries")) , gs.gp(gSobject.self,"hiddenHumiditySeries") , gs.list([]));
    var updated = gs.list([]);
    var found = false;
    gs.mc(current,"each",[function(item) {
      if (gs.equals(item, index)) {
        return found = true;
       } else {
        return gs.mc(updated,'leftShift', gs.list([item]));
       };
     }]);
    if (!gs.bool(found)) {
      gs.mc(updated,'leftShift', gs.list([index]));
     };
    return gs.sp(gSobject.self,"hiddenHumiditySeries",updated);
   }
  gSobject['drillIntoBucket'] = function(bucketIndex) {
    if (!gs.bool(gs.mc(gSobject,"isDrillable",[]))) {
      return null;
     };
    var starts = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyBucketStartMs")) , gs.gp(gSobject.self,"historyBucketStartMs") , gs.list([]));
    if (((gs.equals(bucketIndex, null)) || (bucketIndex < 0)) || (bucketIndex >= gs.mc(starts,"size",[]))) {
      return null;
     };
    var bucketStart = starts[bucketIndex];
    var bucketMins = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyBucketMinutes")) , gs.gp(gSobject.self,"historyBucketMinutes") , 1);
    var halfWindowMins = Math.max(30, bucketMins);
    var windowMs = gs.multiply((gs.multiply(halfWindowMins, 60)), 1000);
    var center = gs.plus(bucketStart, (gs.div((gs.multiply((gs.multiply(bucketMins, 60)), 1000)), 2)));
    gs.sp(gSobject.self,"drillFromMs",(gs.minus(center, windowMs)));
    gs.sp(gSobject.self,"drillToMs",(gs.plus(center, windowMs)));
    gs.sp(gSobject.self,"drillLabel",gs.mc(gSobject,"formatDrillWindow",[gs.gp(gSobject.self,"drillFromMs"), gs.gp(gSobject.self,"drillToMs")]));
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['exitDrillDown'] = function(it) {
    gs.sp(gSobject.self,"drillFromMs",null);
    gs.sp(gSobject.self,"drillToMs",null);
    gs.sp(gSobject.self,"drillLabel",null);
    return gs.mc(gSobject,"loadHistory",[]);
   }
  gSobject['formatDrillWindow'] = function(fromMs, toMs) {
    var from = gs.date(fromMs);
    var to = gs.date(toMs);
    return gs.plus((gs.plus(gs.mc(from,"format",["dd/MM HH:mm"]), " → ")), gs.mc(to,"format",["HH:mm"]));
   }
  gSobject['loadHistory'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      return null;
     };
    gs.sp(gSobject.self,"loadingHistory",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchUnitHumidityHistory",[gs.gp(gSobject.self,"unitId"), gs.gp(gSobject.self,"selectedTimeframe"), gs.gp(gSobject.self,"customDays"), gs.gp(gSobject.self,"drillFromMs"), gs.gp(gSobject.self,"drillToMs"), function(result) {
      var allNames = gs.elvis(gs.bool(gs.gp(result,"seriesNames",true)) , gs.gp(result,"seriesNames",true) , gs.list([]));
      var allDatasets = gs.elvis(gs.bool(gs.gp(result,"datasets",true)) , gs.gp(result,"datasets",true) , gs.list([]));
      var allLabels = gs.elvis(gs.bool(gs.gp(result,"labels",true)) , gs.gp(result,"labels",true) , gs.list([]));
      var allMin = gs.elvis(gs.bool(gs.gp(result,"minDatasets",true)) , gs.gp(result,"minDatasets",true) , gs.list([]));
      var allMax = gs.elvis(gs.bool(gs.gp(result,"maxDatasets",true)) , gs.gp(result,"maxDatasets",true) , gs.list([]));
      var bucketStartMs = gs.elvis(gs.bool(gs.gp(result,"bucketStartMs",true)) , gs.gp(result,"bucketStartMs",true) , gs.list([]));
      var bucketMinutes = gs.elvis(gs.bool(gs.gp(result,"bucketMinutes",true)) , gs.gp(result,"bucketMinutes",true) , 1);
      var humidIndices = gs.list([]);
      var voltIndices = gs.list([]);
      gs.mc(allNames,"eachWithIndex",[function(name, i) {
        if (gs.equals(name, "V-In")) {
          return gs.mc(voltIndices,'leftShift', gs.list([i]));
         } else {
          return gs.mc(humidIndices,'leftShift', gs.list([i]));
         };
       }]);
      gs.sp(gSobject.self,"historyLabels",allLabels);
      gs.sp(gSobject.self,"historyDatasets",gs.mc(humidIndices,"collect",[function(it) {
        return allDatasets[it];
       }]));
      gs.sp(gSobject.self,"historySeriesNames",gs.mc(humidIndices,"collect",[function(it) {
        return allNames[it];
       }]));
      gs.sp(gSobject.self,"historyMinDatasets",gs.mc(humidIndices,"collect",[function(it) {
        return gs.elvis(allMin[it] , allMin[it] , gs.list([]));
       }]));
      gs.sp(gSobject.self,"historyMaxDatasets",gs.mc(humidIndices,"collect",[function(it) {
        return gs.elvis(allMax[it] , allMax[it] , gs.list([]));
       }]));
      gs.sp(gSobject.self,"historyBucketStartMs",bucketStartMs);
      gs.sp(gSobject.self,"historyBucketMinutes",bucketMinutes);
      gs.sp(gSobject.self,"voltageLabels",allLabels);
      gs.sp(gSobject.self,"voltageDatasets",gs.mc(voltIndices,"collect",[function(it) {
        return allDatasets[it];
       }]));
      gs.sp(gSobject.self,"voltageSeriesNames",gs.mc(voltIndices,"collect",[function(it) {
        return allNames[it];
       }]));
      return gs.sp(gSobject.self,"loadingHistory",false);
     }]);
   }
  gSobject['historyColors'] = function(it) {
    var palette = gs.list(["#1E88E5" , "#E53935" , "#43A047" , "#FB8C00" , "#8E24AA" , "#00ACC1" , "#F4511E" , "#6D4C41" , "#1E88E5" , "#D81B60" , "#546E7A" , "#FFB300" , "#00897B" , "#7CB342" , "#039BE5" , "#C0CA33" , "#5E35B1" , "#F06292" , "#4DB6AC" , "#AED581"]);
    var names = gs.elvis(gs.bool(gs.gp(gSobject.self,"historySeriesNames")) , gs.gp(gSobject.self,"historySeriesNames") , gs.list([]));
    var colors = gs.list([]);
    for (var i = 0 ; i < gs.mc(names,"size",[]) ; i++) {
      gs.mc(colors,'leftShift', gs.list([(palette[(gs.mod(i, gs.mc(palette,"size",[])))])]));
     };
    return colors;
   }
  gSobject['voltageColors'] = function(it) {
    return gs.list(["#78909C"]);
   }
  gSobject['composedDatasets'] = function(it) {
    var result = gs.list([]);
    var names = gs.elvis(gs.bool(gs.gp(gSobject.self,"historySeriesNames")) , gs.gp(gSobject.self,"historySeriesNames") , gs.list([]));
    var avgs = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyDatasets")) , gs.gp(gSobject.self,"historyDatasets") , gs.list([]));
    var mins = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyMinDatasets")) , gs.gp(gSobject.self,"historyMinDatasets") , gs.list([]));
    var maxs = gs.elvis(gs.bool(gs.gp(gSobject.self,"historyMaxDatasets")) , gs.gp(gSobject.self,"historyMaxDatasets") , gs.list([]));
    var showBand = (gs.bool(gs.gp(gSobject.self,"showMinMax"))) && (gs.mc(gSobject,"isDrillable",[]));
    for (var i = 0 ; i < gs.mc(names,"size",[]) ; i++) {
      if (gs.bool(showBand)) {
        gs.mc(result,'leftShift', gs.list([gs.elvis(mins[i] , mins[i] , gs.list([]))]));
        gs.mc(result,'leftShift', gs.list([gs.elvis(maxs[i] , maxs[i] , gs.list([]))]));
       };
      gs.mc(result,'leftShift', gs.list([gs.elvis(avgs[i] , avgs[i] , gs.list([]))]));
     };
    return result;
   }
  gSobject['composedDatasetOptions'] = function(it) {
    var result = gs.list([]);
    var names = gs.elvis(gs.bool(gs.gp(gSobject.self,"historySeriesNames")) , gs.gp(gSobject.self,"historySeriesNames") , gs.list([]));
    var colors = gs.mc(gSobject,"historyColors",[]);
    var hiddenList = gs.elvis(gs.bool(gs.gp(gSobject.self,"hiddenHumiditySeries")) , gs.gp(gSobject.self,"hiddenHumiditySeries") , gs.list([]));
    var showBand = (gs.bool(gs.gp(gSobject.self,"showMinMax"))) && (gs.mc(gSobject,"isDrillable",[]));
    for (var i = 0 ; i < gs.mc(names,"size",[]) ; i++) {
      var color = gs.elvis(colors[i] , colors[i] , "#999999");
      var displayName = gs.elvis(names[i] , names[i] , gs.plus("Sensor ", (gs.plus(i, 1))));
      var sensorHidden = false;
      gs.mc(hiddenList,"each",[function(h) {
        if (gs.equals(h, i)) {
          return sensorHidden = true;
         };
       }]);
      if (gs.bool(showBand)) {
        var minOpts = gs.map().add("label",gs.plus((gs.plus((gs.plus("sensor-", i)), "-min|")), displayName)).add("borderColor","rgba(0,0,0,0)").add("backgroundColor",gs.plus(color, "22")).add("borderWidth",0).add("pointRadius",0).add("fill",false);
        gs.sp(minOpts,"hidden",sensorHidden);
        gs.mc(result,'leftShift', gs.list([minOpts]));
        var maxOpts = gs.map().add("label",gs.plus((gs.plus((gs.plus("sensor-", i)), "-max|")), displayName)).add("borderColor","rgba(0,0,0,0)").add("backgroundColor",gs.plus(color, "22")).add("borderWidth",0).add("pointRadius",0).add("fill","-1");
        gs.sp(maxOpts,"hidden",sensorHidden);
        gs.mc(result,'leftShift', gs.list([maxOpts]));
       };
      var avgOpts = gs.map().add("label",gs.plus((gs.plus((gs.plus("sensor-", i)), "-avg|")), displayName)).add("borderColor",color).add("backgroundColor",color).add("borderWidth",1).add("borderDash",gs.list([2 , 2])).add("pointRadius",2);
      gs.sp(avgOpts,"hidden",sensorHidden);
      gs.mc(result,'leftShift', gs.list([avgOpts]));
     };
    return result;
   }
  gSobject['loadMeasurements'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"unitId"))) {
      gs.sp(gSobject.self,"sensorReadings",gs.list([]));
      gs.sp(gSobject.self,"highestHumidity",null);
      gs.sp(gSobject.self,"lowestHumidity",null);
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchLatestUnitSensorReadingsByType",[gs.gp(gSobject.self,"unitId"), "humidity", function(result) {
      var list = gs.elvis(gs.bool(result) , result , gs.list([]));
      var humidities = gs.mc(gs.mc(list,"collect",[function(it) {
        return gs.gp(it,"currentHumidity",true);
       }]),"findAll",[function(value) {
        return value != null;
       }]);
      gs.sp(gSobject.self,"highestHumidity",(gs.bool(humidities) ? gs.mc(humidities,"max",[]) : null));
      gs.sp(gSobject.self,"lowestHumidity",(gs.bool(humidities) ? gs.mc(humidities,"min",[]) : null));
      return gs.sp(gSobject.self,"sensorReadings",gs.mc(list,"collect",[function(it) {
        return gs.map().add("id",gs.gp(it,"id",true)).add("sensorId",gs.gp(it,"sensorId",true)).add("snoozed",gs.elvis(gs.bool(gs.gp(it,"snoozed",true)) , gs.gp(it,"snoozed",true) , false)).add("sensorName",gs.elvis(gs.bool(gs.gp(it,"sensorName",true)) , gs.gp(it,"sensorName",true) , "-")).add("currentHumidity",gs.gp(it,"currentHumidity",true)).add("low",gs.gp(it,"low",true)).add("high",gs.gp(it,"high",true)).add("lowWarn",gs.gp(it,"lowWarn",true)).add("highWarn",gs.gp(it,"highWarn",true));
       }]));
     }]);
   }
  gSobject['formatHumidity'] = function(value) {
    if (gs.equals(value, null)) {
      return "-";
     };
    var numericValue = value;
    return gs.div(Math.floor(gs.multiply(numericValue, 10)), 10);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaMedia() {
  var gSobject = gs.init('CordovaMedia');
  gSobject.clazz = { name: 'CordovaMedia', simpleName: 'CordovaMedia'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['processFile'] = function(onSuccess, onError, mediaFiles) {
    var file = mediaFiles[0];
    return gs.mc(gs.fs('cordovaFile', this, gSobject),"blobFromFileUrl",[gs.gp(file,"fullPath"), function(blob) {
      return gs.execCall(onSuccess, this, [blob]);
     }, onError]);
   }
  gSobject['captureAudio'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureAudio",[function(mediaFiles) {
      return gs.mc(gSobject,"processFile",[onSuccess, onError, mediaFiles]);
     }, onError, gs.map().add("limit",1).add("duration",120)]);
   }
  gSobject['captureImage'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureImage",[function(mediaFiles) {
      return gs.mc(gSobject,"processFile",[onSuccess, onError, mediaFiles]);
     }, onError, gs.map().add("limit",1)]);
   }
  gSobject['captureVideo'] = function(onSuccess, onError) {
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gs.gp(gs.gp(gs.fs('navigator', this, gSobject),"device"),"capture"),"captureVideo",[function(mediaFiles) {
      return gs.mc(gSobject,"processFile",[onSuccess, onError, mediaFiles]);
     }, onError, gs.map().add("limit",1).add("duration",120).add("quality",0.6)]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function RootComponent() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.roles = gs.list(["ROLE_USER"]);
  gSobject['init'] = function(it) {
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"logout",gSobject.logout);
    if (gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"appConfig"))) {
      return null;
     };
   }
  gSobject['afterMounted'] = function(it) {
    return gs.mc(gSobject,"handleLoggedIn",[]);
   }
  gSobject['handleLoggedIn'] = function(it) {
    gs.println("session.zonerId");
    gs.println(gs.gp(gs.fs('session', this, gSobject),"zonerId"));
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"loggedIn",(gs.gp(gs.fs('session', this, gSobject),"zonerId") != null));
    gs.println("vue.scope.loggedIn");
    return gs.println(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"loggedIn"));
   }
  gSobject['logout'] = function(it) {
    return gs.mc(gs.mc(gs.gp(gs.fs('Quasar', this, gSobject),"Dialog"),"create",[gs.map().add("title","Sign Out?").add("message","Are you sure you wish to sign out?").add("cancel",true).add("persistent",true)]),"onOk",[function(it) {
      return gs.execStatic(Utils,'logout', this,[""]);
     }]);
   }
  gSobject['back'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"back",[]);
   }
  gSobject['configurePage'] = function(title, back) {
    if (title === undefined) title = "page_title";
    if (back === undefined) back = true;
    gs.println("" + (gs.gp(this.clazz,"name")) + ".created()");
    gs.mc(gSobject,"setPageTitle",[title]);
    return gs.mc(gSobject,"showBackBtn",[back]);
   }
  gSobject['setPageTitle'] = function(title) {
    if (title === undefined) title = "page_title";
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"pageTitle",title);
   }
  gSobject['showBackBtn'] = function(val) {
    if (val === undefined) val = true;
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"showBack",val);
   }
  gSobject['formatNumber'] = function(val) {
    return gs.elvis(gs.bool(val) , val , "0");
   }
  gSobject['formatDate'] = function(date, format) {
    if (format === undefined) format = "DD MMM YYYY HH:mm";
    return (gs.bool(date) ? gs.mc(gs.mc(gSobject,"moment",[date]),"format",[format]) : "");
   }
  gSobject['formatCurrency'] = function(val) {
    return (gs.bool(val) ? gs.mc(gs.mc(gs.mc(this,"parseFloat",[val], gSobject),"toFixed",[2]),"replaceAll",[/~(\B(?=(\d{3})+(?!\d)))/, ","]) : "0.00");
   }
  gSobject['toggleDarkMode'] = function(it) {
    gs.sp(gSobject.scope,"darkMode",!gs.gp(gSobject.scope,"darkMode"));
    gs.mc(gs.gp(gSobject.q,"dark"),"set",[gs.gp(gSobject.scope,"darkMode")]);
    return gs.mc(gSobject,"saveDarkModePreference",[gs.gp(gSobject.scope,"darkMode")]);
   }
  gSobject.initDarkMode = function(scope) {
    try {
            var saved = localStorage.getItem('twf_darkMode');
            if (saved !== null) { var isDark = (saved === '1'); scope.darkMode = isDark; q.dark.set(isDark); }
        } catch(e) {}
   }
  gSobject.saveDarkModePreference = function(enabled) {
    try { localStorage.setItem('twf_darkMode', enabled ? '1' : '0'); } catch(e) {}
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminOrganisationDetailsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'AdminOrganisationDetailsTab', simpleName: 'AdminOrganisationDetailsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("organisationId",String).add("embedded",Boolean);
  gSobject.data = function(it) {
    return gs.map().add("organisation",gs.map()).add("cwOrg",gs.map()).add("summaryConfig",gs.map()).add("organisationSnapshot",gs.map()).add("cwOrgSnapshot",gs.map()).add("summaryConfigSnapshot",gs.map()).add("summaryFrequencyOptions",gs.list(["daily" , "weekly" , "monthly"])).add("divisions",gs.list([])).add("units",gs.list([])).add("isAdmin",false).add("newDivisionName","").add("selectedDivision",null).add("dialogOpen",false).add("deleteDialogOpen",false).add("deleteConfirmName","").add("tempUnitOptions",gs.list(["C - Celcius" , "F - Fahrenheit" , "K - Kelvin"])).add("humidityUnitOptions",gs.list(["%"])).add("co2UnitOptions",gs.list(["%" , "ppm"])).add("ioUnitOptions",gs.list(["V - Volts" , "A - Amps"])).add("subscriptionOptions",gs.list(["Fuel Management"])).add("allRecipients",gs.list([]));
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"divisionColumns",gs.list([gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","units").add("label","Units").add("field","units").add("align","left")]));
    gs.sp(gSobject.self,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    gs.mc(gSobject,"loadOrganisation",[]);
    gs.mc(gSobject,"loadCwOrg",[]);
    gs.mc(gSobject,"loadSummaryConfig",[]);
    gs.mc(gSobject,"loadDivisions",[]);
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['mounted'] = function(it) {
    return gs.mc(gSobject,"registerDirtyOwner",[]);
   }
  gSobject['activated'] = function(it) {
    return gs.mc(gSobject,"registerDirtyOwner",[]);
   }
  gSobject['beforeUnmount'] = function(it) {
    return gs.mc(gSobject,"releaseDirtyOwner",[]);
   }
  gSobject.registerDirtyOwner = function() {
    var self = this;
        if (typeof vue !== 'undefined' && vue.scope) {
            vue.scope.dirtyForm = {
                isDirty: function() { return self.isDirty(); },
                discard: function() { self.discardChanges(); },
                save: function(done) { self.save(done); }
            };
        }
   }
  gSobject.releaseDirtyOwner = function() {
    if (typeof vue !== 'undefined' && vue.scope) {
            vue.scope.dirtyForm = { isDirty: function() { return false; }, discard: function() {} };
        }
   }
  gSobject['discardChanges'] = function(it) {
    gs.sp(gSobject.self,"organisation",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"organisationSnapshot")]));
    gs.sp(gSobject.self,"cwOrg",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrgSnapshot")]));
    gs.sp(gSobject.self,"summaryConfig",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"summaryConfigSnapshot")]));
    if (!gs.bool(gs.instanceOf(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride"), "List"))) {
      return gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",gs.list([]));
     };
   }
  gSobject.snapshot = function(obj) {
    return JSON.parse(JSON.stringify(obj == null ? {} : obj));
   }
  gSobject.equalsSnapshot = function(a, b) {
    return JSON.stringify(a == null ? {} : a) === JSON.stringify(b == null ? {} : b);
   }
  gSobject['isDirty'] = function(it) {
    return ((!gs.bool(gs.mc(gSobject,"equalsSnapshot",[gs.gp(gSobject.self,"organisation"), gs.gp(gSobject.self,"organisationSnapshot")]))) || (!gs.bool(gs.mc(gSobject,"equalsSnapshot",[gs.gp(gSobject.self,"cwOrg"), gs.gp(gSobject.self,"cwOrgSnapshot")])))) || (!gs.bool(gs.mc(gSobject,"equalsSnapshot",[gs.gp(gSobject.self,"summaryConfig"), gs.gp(gSobject.self,"summaryConfigSnapshot")])));
   }
  gSobject['loadUnits'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchMany",[gs.map().add("org",gs.gp(gSobject.self,"organisationId")), function(data) {
      return gs.sp(gSobject.self,"units",gs.elvis(gs.bool(data) , data , gs.list([])));
     }]);
   }
  gSobject['unitsForDivision'] = function(divisionId) {
    return gs.mc(gs.gp(gSobject.self,"units"),"findAll",[function(unit) {
      return gs.equals(gs.gp(unit,"division"), divisionId);
     }]);
   }
  gSobject['loadOrganisation'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"fetchOneByIdOrNew",[gs.gp(gSobject.self,"organisationId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"organisation",data);
      return gs.sp(gSobject.self,"organisationSnapshot",gs.mc(gSobject,"snapshot",[data]));
     }]);
   }
  gSobject['loadCwOrg'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchByOrgId",[gs.gp(gSobject.self,"organisationId"), function(data) {
      gs.sp(gSobject.self,"cwOrg",gs.mc(gSobject,"applyCwOrgDefaults",[gs.elvis(gs.bool(data) , data , gs.map())]));
      return gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
     }]);
   }
  gSobject['applyCwOrgDefaults'] = function(cwOrg) {
    if (!gs.bool(gs.gp(cwOrg,"defaultTempUnit"))) {
      gs.sp(cwOrg,"defaultTempUnit","C - Celcius");
     };
    if (!gs.bool(gs.gp(cwOrg,"defaultHumidityUnit"))) {
      gs.sp(cwOrg,"defaultHumidityUnit","%");
     };
    if (!gs.bool(gs.gp(cwOrg,"defaultCO2Unit"))) {
      gs.sp(cwOrg,"defaultCO2Unit","ppm");
     };
    if (!gs.bool(gs.gp(cwOrg,"defaultIOUnit"))) {
      gs.sp(cwOrg,"defaultIOUnit","V - Volts");
     };
    return cwOrg;
   }
  gSobject['loadSummaryConfig'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwEventSummaryService"),"fetchByOrg",[gs.gp(gSobject.self,"organisationId"), function(data) {
      gs.sp(gSobject.self,"summaryConfig",gs.elvis(gs.bool(data) , data , gs.map()));
      if (!gs.bool(gs.instanceOf(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride"), "List"))) {
        gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",gs.list([]));
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"frequency"))) {
        gs.sp(gs.gp(gSobject.self,"summaryConfig"),"frequency","weekly");
       };
      gs.sp(gSobject.self,"summaryConfigSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"summaryConfig")]));
      return gs.mc(gSobject,"loadRecipients",[]);
     }]);
   }
  gSobject['loadRecipients'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwEventSummaryService"),"listRecipients",[gs.gp(gSobject.self,"organisationId"), function(list) {
      gs.sp(gSobject.self,"allRecipients",gs.elvis(gs.bool(list) , list , gs.list([])));
      if ((!gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride"))) || (gs.equals(gs.mc(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride"),"size",[]), 0))) {
        gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",gs.mc(gs.gp(gSobject.self,"allRecipients"),"collect",[function(it) {
          return gs.gp(it,"email");
         }]));
       };
      return gs.sp(gSobject.self,"summaryConfigSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"summaryConfig")]));
     }]);
   }
  gSobject['toggleRecipient'] = function(email) {
    var list = gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride")) , gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride") , gs.list([]));
    if (gs.mc(list,"contains",[email])) {
      gs.mc(list,"remove",[email]);
     } else {
      gs.mc(list,"add",[email]);
     };
    return gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",list);
   }
  gSobject['toggleAllRecipients'] = function(val) {
    if (gs.bool(val)) {
      return gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",gs.mc(gs.gp(gSobject.self,"allRecipients"),"collect",[function(it) {
        return gs.gp(it,"email");
       }]));
     } else {
      return gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",gs.list([]));
     };
   }
  gSobject['recipientDisplayText'] = function(it) {
    var selected = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride")) , gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride") , gs.list([])),"size",[]);
    var total = gs.mc(gs.gp(gSobject.self,"allRecipients"),"size",[]);
    if (gs.equals(total, 0)) {
      return "No recipients available";
     };
    if (gs.equals(selected, total)) {
      return "All selected (" + (total) + ")";
     };
    if (gs.equals(selected, 0)) {
      return "None selected";
     };
    return "" + (selected) + " of " + (total) + " selected";
   }
  gSobject['allRecipientsChecked'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"allRecipients"))) {
      return false;
     };
    var list = gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride")) , gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride") , gs.list([]));
    return gs.mc(gs.gp(gSobject.self,"allRecipients"),"every",[function(it) {
      return gs.mc(list,"contains",[gs.gp(it,"email")]);
     }]);
   }
  gSobject['loadDivisions'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchDivisionsByOrgId",[gs.gp(gSobject.self,"organisationId"), function(data) {
      return gs.sp(gSobject.self,"divisions",gs.elvis(gs.bool(data) , data , gs.list([])));
     }]);
   }
  gSobject['sendSummaryNow'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwEventSummaryService"),"sendNow",[gs.gp(gSobject.self,"organisationId"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error",true))) {
        return gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
       };
      return gs.mc(gSobject,"notify",["Summary email sent"]);
     }]);
   }
  gSobject['saveOrganisation'] = function(it) {
    return gs.mc(gSobject,"save",[function(it) {
      return gs.mc(gSobject,"notify",["Organisation Saved"]);
     }]);
   }
  gSobject['toggleActive'] = function(it) {
    var deactivated = gs.equals(gs.gp(gs.gp(gSobject.self,"organisation"),"status"), "Deactivated");
    if (gs.bool(deactivated)) {
      return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Activate Organisation?").add("message","Are you sure you want to activate this organisation?").add("cancel",true)]),"onOk",[function(it) {
        gs.mc(gSobject,"showLoading",[]);
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"reactivate",[gs.gp(gSobject.self,"organisationId"), function(it) {
          gs.mc(gSobject,"hideLoading",[]);
          gs.sp(gs.gp(gSobject.self,"organisation"),"status","Active");
          gs.sp(gs.gp(gSobject.self,"cwOrg"),"deactivatedReason","");
          gs.sp(gs.gp(gSobject.self,"cwOrg"),"deactivatedAt",null);
          gs.sp(gSobject.self,"organisationSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"organisation")]));
          gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
          return gs.mc(gSobject,"notify",["Organisation Activated"]);
         }]);
       }]);
     } else {
      return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Deactivate Organisation").add("message","Provide a reason for deactivation:").add("prompt",gs.map().add("model","").add("type","text")).add("cancel",true)]),"onOk",[function(reason) {
        gs.mc(gSobject,"showLoading",[]);
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"deactivate",[gs.gp(gSobject.self,"organisationId"), gs.elvis(gs.bool(reason) , reason , ""), function(it) {
          gs.mc(gSobject,"hideLoading",[]);
          gs.sp(gs.gp(gSobject.self,"organisation"),"status","Deactivated");
          gs.sp(gs.gp(gSobject.self,"cwOrg"),"deactivatedReason",gs.elvis(gs.bool(reason) , reason , ""));
          gs.sp(gs.gp(gSobject.self,"cwOrg"),"deactivatedAt",gs.date());
          gs.sp(gSobject.self,"organisationSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"organisation")]));
          gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
          return gs.mc(gSobject,"notify",["Organisation Deactivated", "warning"]);
         }]);
       }]);
     };
   }
  gSobject['save'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.self,"organisation"),"name"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Organisation name is required", "warning"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"save",[gs.gp(gSobject.self,"organisation")]),"then",[function(orgData) {
      gs.sp(gSobject.self,"organisation",orgData);
      gs.sp(gs.gp(gSobject.self,"cwOrg"),"org",gs.gp(orgData,"_id"));
      var summaryPayload = gs.map().add("_id",gs.gp(gs.gp(gSobject.self,"summaryConfig"),"_id")).add("org",gs.elvis(gs.bool(gs.gp(orgData,"_id")) , gs.gp(orgData,"_id") , gs.gp(gSobject.self,"organisationId"))).add("enabled",gs.equals(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"enabled"), true)).add("frequency",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"frequency")) , gs.gp(gs.gp(gSobject.self,"summaryConfig"),"frequency") , "weekly")).add("recipientsOverride",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride")) , gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride") , gs.list([])));
      return gs.mc(gs.mc(gs.fs('Promise', this, gSobject),"all",[gs.list([gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"saveCwOrg",[gs.gp(gSobject.self,"cwOrg")]) , gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwEventSummaryService"),"saveConfig",[summaryPayload])])]),"then",[function(results) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.self,"cwOrg",(results[0]));
        gs.sp(gSobject.self,"summaryConfig",gs.elvis(results[1] , results[1] , gs.gp(gSobject.self,"summaryConfig")));
        if (!gs.bool(gs.instanceOf(gs.gp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride"), "List"))) {
          gs.sp(gs.gp(gSobject.self,"summaryConfig"),"recipientsOverride",gs.list([]));
         };
        gs.sp(gSobject.self,"organisationSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"organisation")]));
        gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
        gs.sp(gSobject.self,"summaryConfigSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"summaryConfig")]));
        return gs.execCall(callback, this, []);
       }]);
     }]);
   }
  gSobject['addDivision'] = function(it) {
    var name = gs.mc(gs.gp(gSobject.self,"newDivisionName"),"trim",[], null, true);
    if (!gs.bool(name)) {
      gs.mc(gSobject,"notify",["Division name is required", "warning"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    var payload = gs.map().add("org",gs.gp(gSobject.self,"organisationId")).add("name",name);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"saveDivision",[payload]),"then",[function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"newDivisionName","");
      gs.mc(gSobject,"loadDivisions",[]);
      return gs.mc(gSobject,"notify",["Division Added"]);
     }, function(err) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.mc(gSobject,"notify",["Could not add division", "negative"]);
     }]);
   }
  gSobject['selectDivision'] = function(division) {
    gs.sp(gSobject.self,"selectedDivision",gs.map().add("_id",gs.gp(division,"_id")).add("name",gs.gp(division,"name")));
    return gs.sp(gSobject.self,"dialogOpen",true);
   }
  gSobject['cancelDialog'] = function(it) {
    gs.sp(gSobject.self,"dialogOpen",false);
    return gs.sp(gSobject.self,"selectedDivision",null);
   }
  gSobject['saveSelectedDivision'] = function(it) {
    var name = gs.mc(gs.gp(gs.gp(gSobject.self,"selectedDivision"),"name",true),"trim",[], null, true);
    if (!gs.bool(name)) {
      gs.mc(gSobject,"notify",["Division name is required", "warning"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    var payload = gs.map().add("_id",gs.gp(gs.gp(gSobject.self,"selectedDivision"),"_id")).add("org",gs.gp(gSobject.self,"organisationId")).add("name",name);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"saveDivision",[payload, function(it) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"dialogOpen",false);
      gs.sp(gSobject.self,"selectedDivision",null);
      gs.mc(gSobject,"loadDivisions",[]);
      return gs.mc(gSobject,"notify",["Division Saved"]);
     }]);
   }
  gSobject['removeSelectedDivision'] = function(it) {
    var division = gs.gp(gSobject.self,"selectedDivision");
    if (!gs.bool(division)) {
      return null;
     };
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Division?").add("message","Are you sure you want to delete \"" + (gs.gp(division,"name")) + "\"?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"deleteDivision",[gs.gp(division,"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.self,"dialogOpen",false);
        gs.sp(gSobject.self,"selectedDivision",null);
        gs.mc(gSobject,"loadDivisions",[]);
        return gs.mc(gSobject,"notify",["Division Deleted", "negative"]);
       }]);
     }]);
   }
  gSobject['openDeleteDialog'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"isAdmin"))) {
      return null;
     };
    gs.sp(gSobject.self,"deleteConfirmName","");
    return gs.sp(gSobject.self,"deleteDialogOpen",true);
   }
  gSobject['closeDeleteDialog'] = function(it) {
    gs.sp(gSobject.self,"deleteDialogOpen",false);
    return gs.sp(gSobject.self,"deleteConfirmName","");
   }
  gSobject['confirmDeleteOrganisation'] = function(it) {
    var expected = gs.mc(gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"organisation"),"name",true)) , gs.gp(gs.gp(gSobject.self,"organisation"),"name",true) , ""),"toString",[]),"trim",[]);
    var entered = gs.mc(gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.self,"deleteConfirmName")) , gs.gp(gSobject.self,"deleteConfirmName") , ""),"toString",[]),"trim",[]);
    if ((!gs.bool(expected)) || (entered != expected)) {
      gs.mc(gSobject,"notify",["Name does not match", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"deletePermanently",[gs.gp(gSobject.self,"organisationId"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"deleteDialogOpen",false);
      gs.sp(gSobject.self,"deleteConfirmName","");
      gs.sp(gSobject.self,"organisationSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"organisation")]));
      gs.sp(gSobject.self,"cwOrgSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"cwOrg")]));
      gs.sp(gSobject.self,"summaryConfigSnapshot",gs.mc(gSobject,"snapshot",[gs.gp(gSobject.self,"summaryConfig")]));
      gs.mc(gSobject,"notify",["Organisation deleted", "negative"]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/admin-tools"]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function DevReload() {
  var gSobject = gs.init('DevReload');
  gSobject.clazz = { name: 'DevReload', simpleName: 'DevReload'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'devMode', { get: function() { return DevReload.devMode; }, set: function(gSval) { DevReload.devMode = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'tagName', { get: function() { return DevReload.tagName; }, set: function(gSval) { DevReload.tagName = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'productIds', { get: function() { return DevReload.productIds; }, set: function(gSval) { DevReload.productIds = gSval; }, enumerable: true });
  gSobject.init = function() { return DevReload.init(); }
  gSobject.reloadCss = function(x0) { return DevReload.reloadCss(x0); }
  gSobject.reloadViews = function(x0) { return DevReload.reloadViews(x0); }
  gSobject.patchComponents = function(x0) { return DevReload.patchComponents(x0); }
  gSobject.reloadGrooscript = function(x0) { return DevReload.reloadGrooscript(x0); }
  gSobject.reloadFullBundle = function(x0) { return DevReload.reloadFullBundle(x0); }
  gSobject.forceRemount = function() { return DevReload.forceRemount(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
DevReload.init = function() {
  // Guard: only subscribe once per page lifetime.
        // The jsDynamo bundle is re-executed on every hot reload, so without this
        // guard each save would create a new setInterval and add duplicate subscriptions.
        if (window.__devReloadInitDone) return
        window.__devReloadInitDone = true

        console.log('DevReload: init(), tag=' + DevReload.tagName + ', devMode=' + DevReload.devMode + ', productIds=' + JSON.stringify(DevReload.productIds))
        if (!DevReload.devMode) return

        function handleMessage(message) {
            // Spring serialises via Jackson so body arrives JSON-quoted — unwrap first.
            var body = message.body || ''
            try { body = JSON.parse(body) } catch(e) {}

            console.log('DevReload: message received, body=' + body)

            if (body.indexOf('css:') === 0) {
                DevReload.reloadCss(body.substring(4))
            } else if (body.indexOf('view:') === 0) {
                DevReload.reloadViews(body.substring(5))
            } else if (body.indexOf('grooscript:') === 0) {
                DevReload.reloadGrooscript(body.substring(11))
            }
        }

        // Track the last STOMP client we subscribed to.
        // On WebSocket reconnect, socketConnect() creates a NEW Stomp client and assigns
        // it to Socket.websocketClient.  The old subscriptions are gone.  By comparing
        // the reference we detect the reconnect and re-subscribe automatically.
        var subscribedClient = null

        setInterval(function() {
            if (typeof Socket === 'undefined' || !Socket.websocketClient || !Socket.websocketClient.connected) return
            if (Socket.websocketClient === subscribedClient) return  // still the same connection — nothing to do

            subscribedClient = Socket.websocketClient

            var ids = DevReload.productIds || []
            ids.forEach(function(pid) {
                Socket.websocketClient.subscribe('/topic/devReload/' + pid, handleMessage)
                console.log('DevReload: subscribed to /topic/devReload/' + pid + ' (tag=' + DevReload.tagName + ')')
            })
        }, 500)
 }
DevReload.reloadCss = function(version) {
  console.log('DevReload: reloading CSS, v=' + version)
        document.querySelectorAll('link[rel="stylesheet"]').forEach(function(link) {
            if (!link.href.includes('/resourceBundle/')) return
            var base = link.href.split('?')[0]
            link.href = base + '?v=' + version
            console.log('DevReload: swapped CSS', base)
        })
 }
DevReload.reloadViews = function(version) {
  console.log('DevReload: reloadViews v=' + version)

        fetch('/resourceBundle/packCode/htmlBody?v=' + version)
            .then(function(res) { return res.text() })
            .then(function(html) {
                // Parse all x-template blocks and update the DOM
                var updatedHtmlMap = {}
                var regex = /<script\s[^>]*type="text\/x-template"[^>]*id="([^"]+)"[^>]*>([\s\S]*?)<\/script>/gi
                var match
                while ((match = regex.exec(html)) !== null) {
                    var el = document.getElementById(match[1])
                    if (el) {
                        el.innerHTML = match[2]
                        updatedHtmlMap[match[1]] = match[2]
                    }
                }
                console.log('DevReload: updated DOM templates:', Object.keys(updatedHtmlMap))

                DevReload.patchComponents(updatedHtmlMap)
                DevReload.forceRemount()
            })
            .catch(function(err) { console.error('DevReload: reloadViews failed', err) })
 }
DevReload.patchComponents = function(updatedHtmlMap) {
  var patched = []

        function patchComp(comp) {
            if (!comp || patched.indexOf(comp) >= 0) return

            var tid = null

            // Strategy 1: comp.template is still the '#id' selector
            if (comp.template && comp.template.charAt(0) === '#') {
                var sel = comp.template.substring(1)
                if (updatedHtmlMap[sel]) tid = sel
            }

            // Strategy 2: comp.template is inline HTML from a previous reload —
            // identify by name convention (vueComponentName + 'View')
            if (!tid && comp.vueComponentName) {
                var nameId = comp.vueComponentName + 'View'
                if (updatedHtmlMap[nameId]) tid = nameId
            }

            if (!tid) return

            comp.template = updatedHtmlMap[tid]
            delete comp.render
            delete comp.__vccOpts
            patched.push(comp)
            console.log('DevReload: patched component', comp.vueComponentName, '(template', tid + ')')
        }

        if (vue && vue.componentList) {
            vue.componentList.forEach(function(c) { patchComp(c) })
        }

        if (vue && vue.router && vue.router.getRoutes) {
            vue.router.getRoutes().forEach(function(route) {
                if (!route.components) return
                Object.keys(route.components).forEach(function(k) { patchComp(route.components[k]) })
            })
        }

        console.log('DevReload: patched', patched.length, 'component object(s)')
        if (patched.length === 0) {
            console.warn('DevReload: no components matched — possible naming mismatch')
        }
 }
DevReload.reloadGrooscript = function(payload) {
  var colonIdx = payload.indexOf(':')
        var version = colonIdx > 0 ? payload.substring(colonIdx + 1) : payload
        console.log('DevReload: reloading GrooScript, v=' + version)
        DevReload.reloadFullBundle(version)
 }
DevReload.reloadFullBundle = function(version) {
  console.log('DevReload: reloading jsDynamo bundle, v=' + version)

        vue.componentList.splice(0, vue.componentList.length)

        var script = document.createElement('script')
        script.src = '/resourceBundle/pack/jsDynamo?v=' + version
        script.onload = function() {
            console.log('DevReload: jsDynamo loaded —', vue.componentList.length, 'components')

            // Re-register all components globally
            vue.componentList.forEach(function(comp) {
                if (comp.vueComponentName) vue.vue.component(comp.vueComponentName, comp)
            })

            // Build name → new component lookup
            var nameToComp = {}
            vue.componentList.forEach(function(comp) {
                if (comp.vueComponentName) nameToComp[comp.vueComponentName] = comp
            })

            // Resync router route records to the new component objects
            var routesResynced = 0
            if (vue && vue.router && vue.router.getRoutes) {
                vue.router.getRoutes().forEach(function(route) {
                    if (!route.components) return
                    Object.keys(route.components).forEach(function(k) {
                        var oldComp = route.components[k]
                        var name = oldComp && oldComp.vueComponentName
                        if (name && nameToComp[name] && nameToComp[name] !== oldComp) {
                            route.components[k] = nameToComp[name]
                            routesResynced++
                        }
                    })
                })
            }
            console.log('DevReload: resynced', routesResynced, 'router route record(s)')

            // Re-apply current DOM innerHTML to every new component to preserve
            // any view edits made before this Grooscript save
            var domSynced = 0
            vue.componentList.forEach(function(comp) {
                if (!comp.template || comp.template.charAt(0) !== '#') return
                var el = document.getElementById(comp.template.substring(1))
                if (!el) return
                comp.template = el.innerHTML
                delete comp.render
                delete comp.__vccOpts
                domSynced++
            })
            console.log('DevReload: re-applied current DOM to', domSynced, 'component(s)')

            DevReload.forceRemount()
        }
        script.onerror = function() {
            console.error('DevReload: failed to load jsDynamo bundle')
        }
        document.head.appendChild(script)
 }
DevReload.forceRemount = function() {
  if (typeof vue === 'undefined' || !vue.router) return
        var currentPath = vue.router.currentRoute.value.fullPath
        console.log('DevReload: remounting', currentPath)
        vue.router.replace('/__devreload__').then(function() {
            return vue.router.replace(currentPath)
        }).then(function() {
            var matched = vue.router.currentRoute.value.matched
            for (var i = 0; i < matched.length; i++) {
                var component = matched[i].components && matched[i].components.default
                if (component && typeof component.created === 'function') {
                    var name = component.vueComponentName
                    var formattedName = name.charAt(0).toLowerCase() + name.slice(1)
                    eval(formattedName + '.created()')
                    console.log('DevReload: called created() on', formattedName)
                }
            }
        }).catch(function(err) {
            console.error('DevReload: navigation error', err)
        })
 }
DevReload.devMode = null;
DevReload.tagName = "dev";
DevReload.productIds = null;

function MyOrganisationRedirect() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'MyOrganisationRedirect', simpleName: 'MyOrganisationRedirect'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/my-organisation";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["My Organisation", false]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"fetchMyAccount",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(account) {
      var orgUsers = gs.elvis(gs.bool(gs.gp(account,"orgUsers",true)) , gs.gp(account,"orgUsers",true) , gs.list([]));
      if ((!gs.bool(orgUsers)) || (gs.equals(gs.mc(orgUsers,"size",[]), 0))) {
        gs.mc(gSobject,"notify",["You are not assigned to an organisation", "warning"]);
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/"]);
        return null;
       };
      var orgId = gs.mc(gs.gp(orgUsers[0],"org"),"toString",[], null, true);
      if (!gs.bool(orgId)) {
        gs.mc(gSobject,"notify",["Organisation not found", "negative"]);
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/"]);
        return null;
       };
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.map().add("path","/organisation/" + (orgId) + "").add("query",gs.toJavascript(gs.map().add("tab","details")))]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaFile() {
  var gSobject = gs.init('CordovaFile');
  gSobject.clazz = { name: 'CordovaFile', simpleName: 'CordovaFile'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'DB_NAME', { get: function() { return CordovaFile.DB_NAME; }, set: function(gSval) { CordovaFile.DB_NAME = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'STORE_NAME', { get: function() { return CordovaFile.STORE_NAME; }, set: function(gSval) { CordovaFile.STORE_NAME = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'FILE_CACHE_MIL', { get: function() { return CordovaFile.FILE_CACHE_MIL; }, set: function(gSval) { CordovaFile.FILE_CACHE_MIL = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'MAX_FILE_SIZE_TO_CACHE', { get: function() { return CordovaFile.MAX_FILE_SIZE_TO_CACHE; }, set: function(gSval) { CordovaFile.MAX_FILE_SIZE_TO_CACHE = gSval; }, enumerable: true });
  gSobject.db = null;
  Object.defineProperty(gSobject, 'MIME_TYPES', { get: function() { return CordovaFile.MIME_TYPES; }, set: function(gSval) { CordovaFile.MIME_TYPES = gSval; }, enumerable: true });
  gSobject['initDB'] = function(it) {
    var request = gs.mc(gs.fs('indexedDB', this, gSobject),"open",[gs.gp(CordovaFile,"DB_NAME"), 1]);
    gs.sp(request,"onupgradeneeded",function(e) {
      var db = gs.gp(gs.gp(e,"target"),"result");
      if (!gs.bool(gs.mc(gs.gp(db,"objectStoreNames"),"contains",[gs.gp(CordovaFile,"STORE_NAME")]))) {
        var store = gs.mc(db,"createObjectStore",[gs.gp(CordovaFile,"STORE_NAME"), gs.map().add("keyPath","id").add("autoIncrement",true)]);
        gs.mc(store,"createIndex",["objectKey", gs.list(["objectName" , "property" , "objectId"]), gs.map().add("unique",true)]);
        return gs.mc(store,"createIndex",["synced", "synced"]);
       };
     });
    gs.sp(request,"onsuccess",function(e) {
      gSobject.db = gs.gp(gs.gp(e,"target"),"result");
      return gs.println("✅ Browser file cache (IndexedDB) ready – 2-day cleanup active");
     });
    return gs.sp(request,"onerror",function(e) {
      return gs.mc(gs.fs('console', this, gSobject),"error",["IndexedDB failed", gs.gp(gs.gp(e,"target"),"error")]);
     });
   }
  gSobject['transaction'] = function(mode, callback) {
    if (!gs.bool(gSobject.db)) {
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.mc(gSobject,"transaction",[mode, callback]);
       }, 50]);
     };
    var tx = gs.mc(gSobject.db,"transaction",[gs.gp(CordovaFile,"STORE_NAME"), mode]);
    var store = gs.mc(tx,"objectStore",[gs.gp(CordovaFile,"STORE_NAME")]);
    return gs.execCall(callback, this, [store, tx]);
   }
  gSobject['find'] = function(objectName, property, objectId, cb) {
    gs.println("find");
    gs.println(objectName);
    gs.println(property);
    gs.println(objectId);
    return gs.mc(gSobject,"transaction",["readonly", function(store, tx) {
      var idx = gs.mc(store,"index",["objectKey"]);
      var req = gs.mc(idx,"get",[gs.list([objectName , property , objectId])]);
      gs.sp(req,"onsuccess",function(it) {
        return gs.execCall(cb, this, [gs.gp(req,"result")]);
       });
      return gs.sp(req,"onerror",function(it) {
        return gs.execCall(cb, this, [null]);
       });
     }]);
   }
  gSobject['put'] = function(entry, cb) {
    if (cb === undefined) cb = function(it) {
     };
    gs.sp(entry,"_lastUpdated",gs.mc(gs.date(),"getTime",[]));
    if (!gs.bool(gs.gp(entry,"_created"))) {
      gs.sp(entry,"_created",gs.gp(entry,"_lastUpdated"));
     };
    return gs.mc(gSobject,"transaction",["readwrite", function(store, tx) {
      var req = gs.mc(store,"put",[gs.mc(gs.fs('gs', this, gSobject),"toJavascript",[entry])]);
      return gs.sp(req,"onsuccess",function(it) {
        gs.sp(entry,"id",gs.gp(req,"result"));
        return gs.execCall(cb, this, [entry]);
       });
     }]);
   }
  gSobject['delete'] = function(objectName, property, objectId, cb) {
    if (cb === undefined) cb = function(it) {
     };
    return gs.mc(gSobject,"find",[objectName, property, objectId, function(existing) {
      if (!gs.bool(existing)) {
        return gs.execCall(cb, this, [null]);
       };
      return gs.mc(gSobject,"transaction",["readwrite", function(store) {
        gs.mc(store,"delete",[gs.gp(existing,"id")]);
        return gs.execCall(cb, this, [existing]);
       }]);
     }]);
   }
  gSobject['findUnsynced'] = function(cb) {
    gs.println("findUnsynced:start");
    return gs.mc(gSobject,"transaction",["readonly", function(store) {
      var idx = gs.mc(store,"index",["synced"]);
      var cursor = gs.mc(idx,"openCursor",[gs.mc(gs.fs('IDBKeyRange', this, gSobject),"only",[0])]);
      var list = gs.list([]);
      return gs.sp(cursor,"onsuccess",function(e) {
        var c = gs.gp(gs.gp(e,"target"),"result");
        gs.println("findUnsynced:list");
        gs.println(c);
        if (gs.bool(c)) {
          gs.mc(list,"push",[gs.gp(c,"value")]);
          return gs.mc(c,"continue",[]);
         } else {
          return gs.execCall(cb, this, [list]);
         };
       });
     }]);
   }
  gSobject['addFile'] = function(fileOrBlob, objectName, property, objectId, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (gs.instanceOf(fileOrBlob, "String")) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["addFile:fileOrBlob:string"]);
      return CordovaFile.blobFromFileUrl(fileOrBlob, function(blob) {
        return gs.mc(gSobject,"addFile",[blob, objectName, property, objectId, onSuccess, onError]);
       }, onError);
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["addFile:fileOrBlob:blob"]);
    var size = gs.elvis(gs.bool(gs.gp(fileOrBlob,"size")) , gs.gp(fileOrBlob,"size") , 0);
    var entry = gs.map().add("objectName",objectName).add("property",property).add("objectId",objectId).add("name",gs.elvis(gs.bool(gs.gp(fileOrBlob,"name")) , gs.gp(fileOrBlob,"name") , "blob")).add("type",gs.gp(fileOrBlob,"type")).add("size",size).add("lastModified",gs.elvis(gs.bool(gs.gp(fileOrBlob,"lastModified")) , gs.gp(fileOrBlob,"lastModified") , gs.mc(gs.date(),"getTime",[]))).add("blob",fileOrBlob).add("synced",0);
    return gs.mc(gSobject,"delete",[objectName, property, objectId, function(stored) {
      return gs.mc(gSobject,"put",[entry, function(saved) {
        if (gs.equals(gs.gp(gs.gp(gs.fs('cordovaDevice', this, gSobject),"network"),"status"), "offline")) {
          return gs.execCall(onError, this, [entry, fileOrBlob]);
         };
        return gs.mc(gSobject,"syncSingle",[saved, function(it) {
          return gs.execCall(onSuccess, this, [entry, fileOrBlob]);
         }, onError]);
       }]);
     }]);
   }
  gSobject['deleteFile'] = function(objectName, property, objectId, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"delete",[objectName, property, objectId, function(it) {
      return gs.execCall(onSuccess, this, [it]);
     }]);
   }
  gSobject['getBlobFromCachedFile'] = function(objectName, property, objectId, callback) {
    return gs.mc(gSobject,"find",[objectName, property, objectId, function(entry) {
      return gs.execCall(callback, this, [entry]);
     }]);
   }
  gSobject['syncSingle'] = function(entry, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    if (!gs.bool(gs.gp(entry,"blob",true))) {
      return null;
     };
    return gs.execStatic(Utils,'post', this,[gs.gp(entry,"blob"), gs.gp(entry,"property"), gs.gp(entry,"objectName"), gs.gp(entry,"objectId"), function(data) {
      gs.sp(entry,"synced",1);
      gs.sp(entry,"_lastUpdated",gs.mc(gs.date(),"getTime",[]));
      gs.mc(gSobject,"put",[entry]);
      gs.mc(gSobject,"delete",[gs.gp(entry,"property"), gs.gp(entry,"objectName"), gs.gp(entry,"objectId")]);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaFile:syncSingle:success"]);
      return gs.execCall(onSuccess, this, [entry]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"error",["CordovaFile:syncSingle:failed:" + (err) + ""]);
      return gs.execCall(onError, this, [entry]);
     }]);
   }
  gSobject['sync'] = function(it) {
    return gs.mc(gSobject,"findUnsynced",[function(list) {
      return gs.mc(list,"each",[function(it) {
        return gs.mc(gSobject,"syncSingle",[it]);
       }]);
     }]);
   }
  gSobject['cleanup'] = function(it) {
    var now = gs.mc(gs.date(),"getTime",[]);
    return gs.mc(gSobject,"transaction",["readonly", function(store) {
      var req = gs.mc(store,"getAll",[]);
      return gs.sp(req,"onsuccess",function(it) {
        return gs.mc(gs.gp(req,"result"),"each",[function(entry) {
          var age = gs.minus(now, gs.elvis(gs.bool(gs.gp(entry,"_lastUpdated")) , gs.gp(entry,"_lastUpdated") , gs.elvis(gs.bool(gs.gp(entry,"_created")) , gs.gp(entry,"_created") , 0)));
          if (age > gs.gp(CordovaFile,"FILE_CACHE_MIL")) {
            gs.println("cleanup: deleting file older than 2 days – " + (gs.gp(entry,"name")) + "");
            return gs.mc(gSobject,"delete",[gs.gp(entry,"objectName"), gs.gp(entry,"property"), gs.gp(entry,"objectId")]);
           };
         }]);
       });
     }]);
   }
  gSobject['showAll'] = function(it) {
    return gs.mc(gSobject,"transaction",["readonly", function(store) {
      return gs.sp(gs.mc(store,"getAll",[]),"onsuccess",function(it) {
        return gs.println("Cached files:", gs.gp(gs.gp(it,"target"),"result"));
       });
     }]);
   }
  gSobject['clearAll'] = function(it) {
    return gs.mc(gSobject,"transaction",["readwrite", function(store) {
      return gs.mc(store,"clear",[]);
     }]);
   }
  gSobject['getContentTypeFromUrl'] = function(url) {
    if (!gs.bool(url)) {
      return null;
     };
    var fileName = gs.mc(gs.mc(url,"tokenize",["/"]),"last",[]);
    if (!gs.bool(gs.mc(fileName,"contains",["."]))) {
      return null;
     };
    var ext = gs.mc(gs.mc(gs.mc(fileName,"tokenize",["."]),"last",[]),"toLowerCase",[]);
    return gs.mc(CordovaFile.MIME_TYPES,"get",[ext, "application/octet-stream"]);
   }
  gSobject['resolveFileUrl'] = function(url) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:1:", url)]);
    if (gs.mc(url,"startsWith",["app://localhost/_app_file_"])) {
      url = (url = gs.mc(url,"substring",[26]));
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:2:", url)]);
    if (gs.mc(url,"startsWith",["file:///"])) {
      url = (url = gs.mc(url,"substring",[8]));
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:3:", url)]);
    if (gs.mc(url,"startsWith",["private/"])) {
      url = gs.mc(url,"substring",[8]);
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:4:", url)]);
    if (!gs.bool(gs.mc(url,"startsWith",["http"]))) {
      url = (gs.plus("file:///", url));
     };
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",[gs.plus("resolveFileUrl:5:", url)]);
    return url;
   }
  gSobject.blobFromFileUrl = function(x0,x1,x2) { return CordovaFile.blobFromFileUrl(x0,x1,x2); }
  gSobject['CordovaFile0'] = function(it) {
    gs.mc(gSobject,"initDB",[]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"sync",[]);
     }, gs.multiply(60, 1000)]);
    gs.execStatic(Utils,'setTimeout', this,[function(it) {
      return gs.mc(gSobject,"cleanup",[]);
     }, gs.multiply((gs.multiply(3, 60)), 1000)]);
    gs.mc(cordovaDevice,"addAppEventListeners",[function(event) {
      if ("network.online") {
        return gs.mc(gSobject,"sync",[]);
       };
     }]);
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaFile0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
CordovaFile.blobFromFileUrl = function(url, onSuccess, onError) {
  url = cordovaFile.resolveFileUrl(url)
    
        var contentType = cordovaFile.getContentTypeFromUrl(url)
        
        console.log('blobFromFileUrl', contentType, url)
        
        window.resolveLocalFileSystemURL(url, function success(fileEntry) {
            fileEntry.file(function (file) {
                var reader = new FileReader();
                reader.onloadend = function() {
                    var blob = new Blob([new Uint8Array(this.result)], { type: contentType });
                    onSuccess(blob)
                };
                reader.readAsArrayBuffer(file);
            }, function (err) { 
                console.error('error getting fileentry file!' + err); 
                onError(err)
            });
        }, function (err) { 
            console.error('error getting file! ' + err); 
            onError(err)
        });
 }
CordovaFile.DB_NAME = "localFileCacheDB";
CordovaFile.STORE_NAME = "localFiles";
CordovaFile.FILE_CACHE_MIL = gs.multiply((gs.multiply((gs.multiply((gs.multiply(2, 24)), 60)), 60)), 1000);
CordovaFile.MAX_FILE_SIZE_TO_CACHE = gs.multiply((gs.multiply(1024, 1024)), 8);
CordovaFile.MIME_TYPES = gs.map().add("txt","text/plain").add("html","text/html").add("htm","text/html").add("css","text/css").add("js","application/javascript").add("json","application/json").add("xml","application/xml").add("csv","text/csv").add("rtf","application/rtf").add("pdf","application/pdf").add("doc","application/msword").add("docx","application/vnd.openxmlformats-officedocument.wordprocessingml.document").add("xls","application/vnd.ms-excel").add("xlsx","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet").add("ppt","application/vnd.ms-powerpoint").add("pptx","application/vnd.openxmlformats-officedocument.presentationml.presentation").add("zip","application/zip").add("rar","application/vnd.rar").add("7z","application/x-7z-compressed").add("tar","application/x-tar").add("gz","application/gzip").add("bz2","application/x-bzip2").add("xz","application/x-xz").add("jpg","image/jpeg").add("jpeg","image/jpeg").add("png","image/png").add("gif","image/gif").add("bmp","image/bmp").add("webp","image/webp").add("heic","image/heic").add("heif","image/heif").add("tiff","image/tiff").add("tif","image/tiff").add("svg","image/svg+xml").add("raw","image/x-raw").add("dng","image/x-adobe-dng").add("ico","image/x-icon").add("mp3","audio/mpeg").add("wav","audio/wav").add("m4a","audio/mp4").add("aac","audio/aac").add("ogg","audio/ogg").add("oga","audio/ogg").add("opus","audio/opus").add("flac","audio/flac").add("amr","audio/amr").add("awb","audio/amr-wb").add("3ga","audio/3gpp").add("3g2a","audio/3gpp2").add("mid","audio/midi").add("midi","audio/midi").add("mp4","video/mp4").add("m4v","video/mp4").add("mov","video/quicktime").add("qt","video/quicktime").add("3gp","video/3gpp").add("3g2","video/3gpp2").add("avi","video/x-msvideo").add("mkv","video/x-matroska").add("webm","video/webm").add("ts","video/mp2t").add("mpeg","video/mpeg").add("mpg","video/mpeg").add("mpe","video/mpeg").add("vcf","text/vcard").add("vcs","text/x-vcalendar").add("ics","text/calendar");

function I3Container() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3Container', simpleName: 'I3Container'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("margin",gs.map().add("type",String).add("default","lg")).add("gap",gs.map().add("type",String).add("default","sm")).add("maxWidth",gs.map().add("type",String).add("default","")).add("twoColumn",gs.map().add("type",Boolean).add("default",false)).add("threeColumn",gs.map().add("type",Boolean).add("default",false));
  gSobject.data = function(it) {
    return gs.list([]);
   };
  gSobject['created'] = function(it) {
    var self = this;
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitGraphsTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitGraphsTab', simpleName: 'UnitGraphsTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaLocalNotification() {
  var gSobject = gs.init('CordovaLocalNotification');
  gSobject.clazz = { name: 'CordovaLocalNotification', simpleName: 'CordovaLocalNotification'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['hasPermission'] = function(callback) {
    return gs.mc(gSobject,"nativeHasPermission",[callback]);
   }
  gSobject['requestPermission'] = function(callback) {
    return gs.mc(gSobject,"nativeRequestPermission",[callback]);
   }
  gSobject['schedule'] = function(options, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativeSchedule",[options, callback]);
   }
  gSobject['cancel'] = function(id, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativeCancel",[id, callback]);
   }
  gSobject['cancelAll'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    return gs.mc(gSobject,"nativeCancelAll",[callback]);
   }
  gSobject['on'] = function(event, callback) {
    return gs.mc(gSobject,"nativeOn",[event, callback]);
   }
  gSobject['getAll'] = function(callback) {
    return gs.mc(gSobject,"nativeGetAll",[callback]);
   }
  gSobject.nativeHasPermission = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.hasPermission) { p.hasPermission(callback); }
        else { console.log('[LocalNotif] hasPermission: no plugin'); if (callback) callback(false); }
   }
  gSobject.nativeRequestPermission = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.requestPermission) { p.requestPermission(callback); }
        else { console.log('[LocalNotif] requestPermission: no plugin'); if (callback) callback(false); }
   }
  gSobject.nativeSchedule = function(options, callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.schedule) { 
            console.log('[LocalNotif] scheduling:', JSON.stringify(options));
            p.schedule(options, callback); 
        }
        else { console.log('[LocalNotif] schedule: no plugin. keys:', typeof cordova !== 'undefined' && cordova.plugins ? Object.keys(cordova.plugins).join(',') : 'n/a'); if (callback) callback(); }
   }
  gSobject.nativeCancel = function(id, callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.cancel) { p.cancel(id, callback); }
        else { if (callback) callback(); }
   }
  gSobject.nativeCancelAll = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.cancelAll) { p.cancelAll(callback); }
        else { if (callback) callback(); }
   }
  gSobject.nativeOn = function(event, callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.on) { p.on(event, callback); }
        else { console.log('[LocalNotif] on(' + event + '): no plugin'); }
   }
  gSobject.nativeGetAll = function(callback) {
    var p = null;
        if (typeof cordova !== 'undefined' && cordova.plugins) {
            p = cordova.plugins.i3LocalNotification || (cordova.plugins.notification && cordova.plugins.notification.local);
        }
        if (p && p.getScheduledIds) { p.getScheduledIds(callback); }
        else { if (callback) callback([]); }
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function PdfJsHandler() {
  var gSobject = gs.init('PdfJsHandler');
  gSobject.clazz = { name: 'PdfJsHandler', simpleName: 'PdfJsHandler'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'rendering', { get: function() { return PdfJsHandler.rendering; }, set: function(gSval) { PdfJsHandler.rendering = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'numberPending', { get: function() { return PdfJsHandler.numberPending; }, set: function(gSval) { PdfJsHandler.numberPending = gSval; }, enumerable: true });
  gSobject['build'] = function(filePath, callback) {
    if (callback === undefined) callback = function(it) {
     };
    return PdfJsHandler.paintWholePdf(filePath, callback);
   }
  gSobject.paintWholePdf = function(x0,x1) { return PdfJsHandler.paintWholePdf(x0,x1); }
  gSobject.renderPageScroll = function(x0,x1) { return PdfJsHandler.renderPageScroll(x0,x1); }
  gSobject.paintPdf = function(x0,x1) { return PdfJsHandler.paintPdf(x0,x1); }
  gSobject.renderPage = function(x0,x1) { return PdfJsHandler.renderPage(x0,x1); }
  gSobject['PdfJsHandler1'] = function(filePath) {
    if (filePath === undefined) filePath = "";
    if (!gs.bool(filePath)) {
      return null;
     };
    gs.mc(this,"paintWholePdf",[filePath], gSobject);
    return this;
  }
  if (arguments.length==1) {gSobject.PdfJsHandler1(arguments[0]); }
  
  return gSobject;
 };
PdfJsHandler.paintWholePdf = function(filePath, callback) {
  spinnerDiv = document.createElement('div');
        spinnerDiv.setAttribute("id", "spinner");
        spinnerDiv.setAttribute("class", "fixed-center")
        spinner = document.createElement('div');
        spinner.setAttribute("class", "i3-media-pdf-spinner");
        spinnerDiv.append(spinner);
        $('#pdf-viewer').append(spinnerDiv);
        
        pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.10.111/pdf.worker.min.js';
        var loadPdf = pdfjsLib.getDocument(filePath);
        loadPdf.promise.then(function(pdf) {
            
            const maxPage = pdf._pdfInfo.numPages;
        
            for (var i = 1; i <= maxPage; i++) {
                PdfJsHandler.renderPageScroll(pdf, i);
            }
            document.getElementById('spinner').remove();
            callback()
        })
 }
PdfJsHandler.renderPageScroll = function(pdf, number) {
  pdf.getPage(number).then(function(page) {
        
            const canvasId = 'pdf_viewer-' + number;
            $('#pdf-viewer').append($('<canvas/>', {'id': canvasId, 'style': 'object-fit:contain', 'class':'full-width'}));
            // $('#pdf-viewer').append($('<canvas/>', {'id': canvasId}));
            const canvas = document.getElementById(canvasId);
            const viewport = page.getViewport({scale: 1});
            const context = canvas.getContext("2d");
            
            canvas.height = viewport.height;
            canvas.width = viewport.width;
            
            var renderContext = {
                canvasContext: context,
                viewport: viewport
            };
            
            const renderTask = page.render(renderContext);
        });
 }
PdfJsHandler.paintPdf = function(filePath, getPage) {
  pdfjsLib.GlobalWorkerOptions.workerSrc = 'https://cdnjs.cloudflare.com/ajax/libs/pdf.js/3.10.111/pdf.worker.min.js';
            var loadPdf = pdfjsLib.getDocument(filePath);
            loadPdf.promise.then(function(pdf) {
                
                const minPage = 1;
                const maxPage = pdf._pdfInfo.numPages;
                let currentPage = 1;
                PdfJsHandler.rendering = false;
                PdfJsHandler.numberPending = null;
                PdfJsHandler.renderPage(pdf, currentPage);
                
                document.getElementById("pdfPageNumber").innerHTML = `Page ${currentPage} of ${maxPage}`;
                document.getElementById("pdfPrev").addEventListener("click", () => {
                    if (currentPage > minPage) {
                        currentPage = currentPage - 1
                        PdfJsHandler.renderPage(pdf, currentPage);
                        document.getElementById("pdfPageNumber").innerHTML = `Page ${currentPage} of ${maxPage}`;
                    }
                })
                document.getElementById("pdfNext").addEventListener("click", () => {
                    if (currentPage < maxPage) {
                        currentPage = currentPage + 1
                        PdfJsHandler.renderPage(pdf, currentPage);
                        document.getElementById("pdfPageNumber").innerHTML = `Page ${currentPage} of ${maxPage}`;
                    }
                })
            })
 }
PdfJsHandler.renderPage = function(pdf, number) {
  console.log('renderPage with ' + number + ', ' + PdfJsHandler.rendering + ', ' + PdfJsHandler.numberPending)
        if (PdfJsHandler.rendering) {
            PdfJsHandler.numberPending = number;
        } else {
            PdfJsHandler.rendering = true;
            pdf.getPage(number).then(function(page) {
            
                const canvas = document.getElementById("pdf_canvas");
                const viewport = page.getViewport({scale: 1});
                const context = canvas.getContext("2d");
                
                canvas.height = viewport.height;
                canvas.width = viewport.width;
                
                var renderContext = {
                    canvasContext: context,
                    viewport: viewport
                };
                
                const renderTask = page.render(renderContext);
                
                renderTask.promise.then(function() {
                    PdfJsHandler.rendering = false;
                    if (PdfJsHandler.numberPending !== null) {
                        PdfJsHandler.renderPage(pdf, number);
                        PdfJsHandler.numberPending = null;
                    }
                });
            });
        }
 }
PdfJsHandler.rendering = false;
PdfJsHandler.numberPending = null;

function AdminUnitDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminUnitDetailsComponent', simpleName: 'AdminUnitDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/organisation/:orgId/unit/:id";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Unit Details", true]);
    var initialTab = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"tab")) , gs.gp(gs.gp(gSobject.route,"query"),"tab") , "details"),"toString",[]);
    gs.sp(gSobject.scope,"tab",initialTab);
    gs.sp(gSobject.scope,"orgId",gs.gp(gs.gp(gSobject.route,"params"),"orgId"));
    gs.sp(gSobject.scope,"orgName","");
    gs.sp(gSobject.scope,"unit",gs.map());
    gs.sp(gSobject.scope,"tagInput","");
    gs.sp(gSobject.scope,"deleteEnabled",(gs.gp(gs.gp(gSobject.route,"params"),"id") != "new"));
    gs.sp(gSobject.scope,"notificationSounds",gs.list([]));
    gs.sp(gSobject.scope,"divisions",gs.list([]));
    gs.sp(gSobject.scope,"unitUsers",gs.list([]));
    gs.sp(gSobject.scope,"canManage",false);
    gs.sp(gSobject.scope,"assignDialogOpen",false);
    gs.sp(gSobject.scope,"assignableUsers",gs.list([]));
    gs.sp(gSobject.scope,"filteredAssignableUsers",gs.list([]));
    gs.sp(gSobject.scope,"selectedAssignUser",null);
    if (!gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"tab"))) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.map().add("path",gs.gp(gSobject.route,"path")).add("query",gs.toJavascript(gs.map().add("tab",initialTab)))]);
     };
    gs.mc(gSobject,"checkPermission",[]);
    gs.mc(gSobject,"loadOrg",[]);
    gs.mc(gSobject,"loadUnit",[]);
    gs.mc(gSobject,"loadNotificationSounds",[]);
    gs.mc(gSobject,"loadDivisions",[]);
    return gs.mc(gSobject,"loadUnitUsers",[]);
   }
  gSobject['loadOrg'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"fetchOneByIdOrNew",[gs.gp(gs.gp(gSobject.route,"params"),"orgId"), function(data) {
      gs.sp(gSobject.scope,"orgName",gs.elvis(gs.bool(gs.gp(data,"name",true)) , gs.gp(data,"name",true) , ""));
      return gs.mc(gSobject,"updateTitle",[]);
     }]);
   }
  gSobject['checkPermission'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"isOrgAdmin",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gs.gp(gSobject.route,"params"),"orgId"), function(result) {
      return gs.sp(gSobject.scope,"canManage",result);
     }]);
   }
  gSobject['loadUnitUsers'] = function(it) {
    if (gs.equals(gs.gp(gs.gp(gSobject.route,"params"),"id"), "new")) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitUserService"),"listUsersForUnit",[gs.gp(gs.gp(gSobject.route,"params"),"id"), function(users) {
      return gs.sp(gSobject.scope,"unitUsers",gs.elvis(gs.bool(users) , users , gs.list([])));
     }]);
   }
  gSobject['loadAssignableUsers'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitUserService"),"listAssignableUsersForUnit",[gs.gp(gs.gp(gSobject.route,"params"),"orgId"), gs.gp(gs.gp(gSobject.route,"params"),"id"), function(users) {
      gs.sp(gSobject.scope,"assignableUsers",gs.elvis(gs.bool(users) , users , gs.list([])));
      return gs.sp(gSobject.scope,"filteredAssignableUsers",gs.elvis(gs.bool(users) , users , gs.list([])));
     }]);
   }
  gSobject['filterAssignableUsers'] = function(val, update) {
    if (!gs.bool(val)) {
      gs.execCall(update, this, [function(it) {
        return gs.sp(gSobject.scope,"filteredAssignableUsers",gs.gp(gSobject.scope,"assignableUsers"));
       }]);
      return null;
     };
    var lower = gs.mc(gs.mc(val,"toString",[]),"toLowerCase",[]);
    return gs.execCall(update, this, [function(it) {
      return gs.sp(gSobject.scope,"filteredAssignableUsers",gs.mc(gs.gp(gSobject.scope,"assignableUsers"),"findAll",[function(u) {
        return (gs.bool(gs.gp(u,"email"))) && (gs.mc(gs.mc(gs.mc(gs.gp(u,"email"),"toString",[]),"toLowerCase",[]),"contains",[lower]));
       }]));
     }]);
   }
  gSobject['openAssignDialog'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"canManage"))) {
      return null;
     };
    gs.sp(gSobject.scope,"selectedAssignUser",null);
    gs.mc(gSobject,"loadAssignableUsers",[]);
    return gs.sp(gSobject.scope,"assignDialogOpen",true);
   }
  gSobject['cancelAssignDialog'] = function(it) {
    return gs.sp(gSobject.scope,"assignDialogOpen",false);
   }
  gSobject['saveAssignDialog'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"selectedAssignUser"))) {
      return gs.mc(gSobject,"notify",["Please select a user", "negative"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitUserService"),"assignUserToUnit",[gs.gp(gs.gp(gSobject.scope,"selectedAssignUser"),"_id"), gs.gp(gs.gp(gSobject.route,"params"),"orgId"), gs.gp(gs.gp(gSobject.route,"params"),"id"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error",true))) {
        return gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
       };
      gs.mc(gSobject,"notify",["User assigned"]);
      gs.sp(gSobject.scope,"assignDialogOpen",false);
      return gs.mc(gSobject,"loadUnitUsers",[]);
     }]);
   }
  gSobject['removeUnitUser'] = function(unitUser) {
    if ((!gs.bool(gs.gp(gSobject.scope,"canManage"))) || (!gs.bool(gs.gp(unitUser,"_id",true)))) {
      return null;
     };
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Remove Confirmation").add("message","Remove " + (gs.elvis(gs.bool(gs.gp(unitUser,"email")) , gs.gp(unitUser,"email") , "this user")) + " from this unit?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitUserService"),"unassignUserFromUnit",[gs.gp(unitUser,"_id"), function(result) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(result,"error",true))) {
          return gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
         };
        gs.mc(gSobject,"notify",["User removed", "negative"]);
        return gs.mc(gSobject,"loadUnitUsers",[]);
       }]);
     }]);
   }
  gSobject['loadNotificationSounds'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationSoundService"),"fetchAll",[function(sounds) {
      return gs.sp(gSobject.scope,"notificationSounds",gs.elvis(gs.bool(sounds) , sounds , gs.list([])));
     }]);
   }
  gSobject['loadDivisions'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchDivisionsByOrgId",[gs.gp(gs.gp(gSobject.route,"params"),"orgId"), function(data) {
      gs.sp(gSobject.scope,"divisions",gs.elvis(gs.bool(data) , data , gs.list([])));
      return gs.mc(gSobject,"updateTitle",[]);
     }]);
   }
  gSobject['loadUnit'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchOneByIdOrNew",[gs.gp(gs.gp(gSobject.route,"params"),"id"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"unit",data);
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"org"))) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"org",gs.gp(gs.gp(gSobject.route,"params"),"orgId"));
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"status"))) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"status","Active");
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"autoResolveDays"))) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"autoResolveDays",7);
       };
      if (gs.equals(gs.gp(gs.gp(gSobject.scope,"unit"),"autoResolveOnRecover"), null)) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"autoResolveOnRecover",true);
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"commHealthThresholdMins"))) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"commHealthThresholdMins",60);
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"commHealthWarningMins"))) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"commHealthWarningMins",30);
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"))) {
        gs.sp(gs.gp(gSobject.scope,"unit"),"tags",gs.list([]));
       };
      return gs.mc(gSobject,"updateTitle",[]);
     }]);
   }
  gSobject['save'] = function(it) {
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"name"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Name is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"code"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["IMEI / Serial is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"division"))) {
      gs.mc(gSobject,"notify",["Division is required", "warning"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"save",[gs.gp(gSobject.scope,"unit"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"unit",data);
      gs.sp(gSobject.scope,"deleteEnabled",true);
      gs.mc(gSobject,"updateTitle",[]);
      return gs.mc(gSobject,"notify",["Unit Saved"]);
     }]);
   }
  gSobject['deleteUnit'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Archive Unit").add("message","Provide a reason for archiving:").add("prompt",gs.map().add("model","").add("type","text")).add("cancel",true)]),"onOk",[function(reason) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"delete",[gs.gp(gs.gp(gSobject.scope,"unit"),"_id"), gs.elvis(gs.bool(reason) , reason , ""), gs.gp(gs.fs('session', this, gSobject),"userId"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Unit Archived", "negative"]);
        return gs.mc(gSobject,"back",[]);
       }]);
     }]);
   }
  gSobject['unarchiveUnit'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Restore Confirmation").add("message","Restore this archived unit? It will reappear in default lists.").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"unarchive",[gs.gp(gs.gp(gSobject.scope,"unit"),"_id"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(restored) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(restored)) {
          gs.sp(gSobject.scope,"unit",restored);
         };
        return gs.mc(gSobject,"notify",["Unit Restored", "positive"]);
       }]);
     }]);
   }
  gSobject['updateTitle'] = function(it) {
    return gs.mc(gSobject,"setPageTitle",[(gs.bool(gs.gp(gSobject.scope,"orgName")) ? "Unit Details for " + (gs.gp(gSobject.scope,"orgName")) + "" : "Unit Details")]);
   }
  gSobject['snoozeUnit'] = function(hours) {
    if (gs.equals(hours, 0)) {
      gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Snooze Duration").add("message","Enter number of hours to snooze:").add("prompt",gs.map().add("model","").add("type","number")).add("cancel",true)]),"onOk",[function(val) {
        return gs.mc(gSobject,"applySnooze",[val]);
       }]);
      return null;
     };
    return gs.mc(gSobject,"applySnooze",[hours]);
   }
  gSobject['applySnooze'] = function(hours) {
    gs.mc(gSobject,"showLoading",[]);
    gs.sp(gs.gp(gSobject.scope,"unit"),"status","Snoozed");
    gs.sp(gs.gp(gSobject.scope,"unit"),"snoozedAt",gs.date());
    gs.sp(gs.gp(gSobject.scope,"unit"),"snoozeDurationHours",hours);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"save",[gs.gp(gSobject.scope,"unit"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"unit",data);
      return gs.mc(gSobject,"notify",["Unit snoozed for " + (hours) + "h", "warning"]);
     }]);
   }
  gSobject['disableUnit'] = function(hours) {
    if (gs.equals(hours, 0)) {
      gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Disable Duration").add("message","Enter number of hours to disable:").add("prompt",gs.map().add("model","").add("type","number")).add("cancel",true)]),"onOk",[function(val) {
        return gs.mc(gSobject,"applyDisable",[val]);
       }]);
      return null;
     };
    return gs.mc(gSobject,"applyDisable",[hours]);
   }
  gSobject['applyDisable'] = function(hours) {
    gs.mc(gSobject,"showLoading",[]);
    gs.sp(gs.gp(gSobject.scope,"unit"),"status","Disabled");
    gs.sp(gs.gp(gSobject.scope,"unit"),"disabledAt",gs.date());
    gs.sp(gs.gp(gSobject.scope,"unit"),"disableDurationHours",hours);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"save",[gs.gp(gSobject.scope,"unit"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"unit",data);
      return gs.mc(gSobject,"notify",["Unit disabled for " + (hours) + "h", "negative"]);
     }]);
   }
  gSobject['activateUnit'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Set Active").add("message","Are you sure you want to set this unit back to Active?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      gs.sp(gs.gp(gSobject.scope,"unit"),"status","Active");
      gs.sp(gs.gp(gSobject.scope,"unit"),"snoozedAt",null);
      gs.sp(gs.gp(gSobject.scope,"unit"),"snoozeDurationHours",0);
      gs.sp(gs.gp(gSobject.scope,"unit"),"disabledAt",null);
      gs.sp(gs.gp(gSobject.scope,"unit"),"disableDurationHours",0);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"save",[gs.gp(gSobject.scope,"unit"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.scope,"unit",data);
        return gs.mc(gSobject,"notify",["Unit set to Active"]);
       }]);
     }]);
   }
  gSobject['formatTimestamp'] = function(value) {
    if (!gs.bool(value)) {
      return "";
     };
    var date = (gs.instanceOf(value, "Date") ? value : gs.date(value));
    return gs.mc(date,"format",["dd/MM/yyyy HH:mm"]);
   }
  gSobject['addTag'] = function(it) {
    var tagText = gs.mc(gs.gp(gSobject.scope,"tagInput"),"trim",[], null, true);
    if (!gs.bool(tagText)) {
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"))) {
      gs.sp(gs.gp(gSobject.scope,"unit"),"tags",gs.list([]));
     };
    if (gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"),"size",[]) >= 5) {
      gs.mc(gSobject,"notify",["Maximum 5 tags allowed", "warning"]);
      return null;
     };
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"),"contains",[tagText]))) {
      gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"),"push",[tagText]);
      return gs.sp(gSobject.scope,"tagInput","");
     };
   }
  gSobject['removeTag'] = function(index) {
    if (((gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"))) && (index >= 0)) && (index < gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"),"size",[]))) {
      return gs.mc(gs.gp(gs.gp(gSobject.scope,"unit"),"tags"),"removeAt",[index]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitStatusTab() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'UnitStatusTab', simpleName: 'UnitStatusTab'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwNotificationBadge() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CwNotificationBadge', simpleName: 'CwNotificationBadge'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.data = function(it) {
    return gs.map().add("unreadCount",0);
   };
  gSobject['created'] = function(it) {
    var self = this;
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"refreshNotificationBadge",function(it) {
      return gs.mc(gSobject,"loadCount",[self]);
     });
    return gs.mc(gSobject,"loadCount",[self]);
   }
  gSobject['loadCount'] = function(self) {
    if (self === undefined) self = this;
    var filter = gs.map().add("read",false).add("zonerId",gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id")).add("userId",gs.gp(gs.fs('session', this, gSobject),"userId"));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationService"),"countFiltered",[filter, function(data) {
      return gs.sp(self,"unreadCount",gs.elvis(gs.bool(gs.gp(data,"count")) , gs.gp(data,"count") , 0));
     }]);
   }
  gSobject['goToNotifications'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/notifications"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwAgentSwitcher() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'CwAgentSwitcher', simpleName: 'CwAgentSwitcher'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.data = function(it) {
    return gs.map().add("currentName","").add("currentOrgId","").add("clients",gs.list([]));
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"load",[self]);
   }
  gSobject['load'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"myClients",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(result) {
      gs.println(gs.plus("[CwAgentSwitcher] load result: ", result));
      gs.sp(self,"clients",gs.elvis(gs.bool(gs.gp(result,"clients",true)) , gs.gp(result,"clients",true) , gs.list([])));
      gs.sp(self,"currentOrgId",gs.elvis(gs.bool(gs.gp(result,"currentOrgId",true)) , gs.gp(result,"currentOrgId",true) , ""));
      var current = gs.mc(gs.gp(self,"clients"),"find",[function(it) {
        return gs.equals(gs.gp(it,"orgId"), gs.gp(self,"currentOrgId"));
       }]);
      return gs.sp(self,"currentName",gs.elvis(gs.bool(gs.gp(current,"name",true)) , gs.gp(current,"name",true) , "Select client"));
     }]);
   }
  gSobject['switchTo'] = function(client, self) {
    if (self === undefined) self = this;
    gs.println(gs.plus("[CwAgentSwitcher] switchTo called with: ", client));
    if ((!gs.bool(gs.gp(client,"orgId",true))) || (gs.equals(gs.gp(client,"orgId"), gs.gp(self,"currentOrgId")))) {
      gs.println("[CwAgentSwitcher] switchTo early-return (no orgId or same as current)");
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"selectClient",[gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(client,"orgId"), function(result) {
      gs.println(gs.plus("[CwAgentSwitcher] selectClient result: ", result));
      if (gs.bool(gs.gp(result,"error",true))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.println("[CwAgentSwitcher] calling CwBrowser.reloadToRoot()");
      return gs.execStatic(CwBrowser,'reloadToRoot', this,[]);
     }]);
   }
  gSobject['goToClients'] = function(self) {
    if (self === undefined) self = this;
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/myClients"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3DatePicker() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3DatePicker', simpleName: 'I3DatePicker'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("date",Date).add("clearable",Boolean).add("label",String).add("disable",Boolean).add("readonly",Boolean).add("filled",Boolean).add("outlined",Boolean).add("borderless",Boolean).add("standout",Boolean).add("rounded",Boolean).add("square",Boolean).add("dense",Boolean).add("landscape",Boolean).add("todayBtn",Boolean).add("minimal",Boolean).add("mask",String);
  gSobject.data = function(it) {
    return gs.map().add("dateString","").add("formatString","DD MMM YYYY").add("datePickerDialog",false);
   };
  gSobject['created'] = function(it) {
    var self = this;
    gs.println("self.date");
    gs.println(gs.gp(self,"date"));
    return gs.mc(gSobject,"init",[self]);
   }
  gSobject['init'] = function(self) {
    if (gs.bool(gs.gp(self,"mask"))) {
      gs.sp(self,"formatString",gs.gp(self,"mask"));
     };
    return gs.sp(self,"dateString",(gs.bool(gs.gp(self,"date")) ? gs.mc(gs.mc(gSobject,"moment",[gs.gp(self,"date")]),"format",["YYYY-MM-DD"]) : null));
   }
  gSobject['openDatePickerDialog'] = function(it) {
    var self = this;
    return gs.sp(self,"datePickerDialog",true);
   }
  gSobject['selectDate'] = function(val) {
    var self = this;
    gs.println("val");
    gs.println(val);
    var date = gs.date(val);
    gs.println("date");
    gs.println(date);
    gs.sp(self,"dateString",(gs.bool(date) ? gs.mc(gs.mc(gSobject,"moment",[date]),"format",["YYYY-MM-DD"]) : null));
    gs.sp(self,"datePickerDialog",false);
    return gs.mc(gSobject,"emit",["update:date", date]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function I3BottomContainer() {
  var gSobject = VueComponent();
  gSobject.clazz = { name: 'I3BottomContainer', simpleName: 'I3BottomContainer'};
  gSobject.clazz.superclass = { name: 'VueComponent', simpleName: 'VueComponent'};
  gSobject.props = gs.map().add("margin",gs.map().add("type",String).add("default","lg")).add("maxWidth",gs.map().add("type",String).add("default",""));
  gSobject.data = function(it) {
    return gs.map().add("bottomContainerHeight",60);
   };
  gSobject['created'] = function(it) {
    var self = this;
    return gs.mc(gSobject,"waitForRefs",[function(it) {
      return gs.sp(self,"bottomContainerHeight",gs.gp(gs.gp(gSobject.refs,"bottomContainer"),"offsetHeight"));
     }]);
   }
  gSobject['waitForRefs'] = function(callback) {
    if (callback === undefined) callback = function(it) {
     };
    if (gs.bool(gs.gp(gSobject.refs,"bottomContainer",true))) {
      return gs.execCall(callback, this, []);
     } else {
      return gs.execStatic(Utils,'setTimeout', this,[function(it) {
        return gs.mc(gSobject,"waitForRefs",[callback]);
       }, 100]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CordovaHealth() {
  var gSobject = gs.init('CordovaHealth');
  gSobject.clazz = { name: 'CordovaHealth', simpleName: 'CordovaHealth'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  gSobject['testIsAvailable'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    return gs.mc(gSobject,"nativeIsAvailable",[function(available) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health. isAvailable -> success: " + (available) + ""]);
      return gs.execCall(onSuccess, this, [available]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.isAvailable -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['requestPermissions'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    datatypes = gs.map().add("read",gs.list(["steps" , "blood_pressure" , "heart_rate"]));
    return gs.mc(gSobject,"nativeRequestAuthorization",[datatypes, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health. requestAuthorization -> success: " + (result) + ""]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova. plugins.health.requestAuthorization -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['querySteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","steps").add("limit",50000);
    return gs.mc(gSobject,"nativeQuery",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query steps -> success: " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query steps -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryBloodPressure'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","blood_pressure").add("limit",2000);
    return gs.mc(gSobject,"nativeQuery",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query blood_pressure -> success: " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query blood_pressure -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryHeartRate'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","heart_rate").add("limit",50000);
    return gs.mc(gSobject,"nativeQuery",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query heart_rate -> success: " + (gs.mc(result,"size",[], null, true)) + " records"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.query heart_rate -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['queryAggregatedSteps'] = function(startDate, endDate, onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    var queryParams = gs.map().add("startDate",startDate).add("endDate",endDate).add("dataType","steps").add("bucket","day");
    return gs.mc(gSobject,"nativeQueryAggregated",[queryParams, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins. health.queryAggregated steps -> success"]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova. plugins.health.queryAggregated steps -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject['isAuthorizedForHealth'] = function(onSuccess, onError) {
    if (onSuccess === undefined) onSuccess = function(it) {
     };
    if (onError === undefined) onError = function(it) {
     };
    datatypes = gs.map().add("read",gs.list(["steps"]));
    return gs.mc(gSobject,"nativeIsAuthorized",[datatypes, function(result) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.isAuthorized health -> success: " + (result) + ""]);
      return gs.execCall(onSuccess, this, [result]);
     }, function(err) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"log"),"info",["cordova.plugins.health.isAuthorized health -> error: " + (err) + ""]);
      return gs.execCall(onError, this, [err]);
     }]);
   }
  gSobject.nativeIsAvailable = function(successCallback, errorCallback) {
    try {
            if (! Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.isAvailable(
                function(available) {
                    successCallback(available);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.isAvailable:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeRequestAuthorization = function(datatypes, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.requestAuthorization(
                datatypes,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.requestAuthorization:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQuery = function(queryParams, successCallback, errorCallback) {
    try {
            if (! Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.query(
                queryParams,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins. health.query:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeQueryAggregated = function(queryParams, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.queryAggregated(
                queryParams,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.queryAggregated:', e);
            errorCallback(e.toString());
        }
   }
  gSobject.nativeIsAuthorized = function(datatypes, successCallback, errorCallback) {
    try {
            if (!Utils.isCordova()) {
                errorCallback("Cordova not available");
                return;
            }

            cordova.plugins.health.isAuthorized(
                datatypes,
                function(result) {
                    successCallback(result);
                },
                function(err) {
                    errorCallback(err.toString());
                }
            );

        } catch (e) {
            console.error('Exception calling cordova.plugins.health.isAuthorized:', e);
            errorCallback(e.toString());
        }
   }
  gSobject['CordovaHealth0'] = function(it) {
    return this;
  }
  if (arguments.length==0) {gSobject.CordovaHealth0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function FullMapComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'FullMapComponent', simpleName: 'FullMapComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/map";
  gSobject.self = null;
  gSobject.pollingTimer = null;
  gSobject['created'] = function(it) {
    gSobject.self = this;
    gs.mc(gSobject,"configurePage",["Map", false]);
    gs.sp(gSobject.scope,"units",gs.list([]));
    return gs.mc(gSobject.self,"loadLocations",[]);
   }
  gSobject['destroyed'] = function(it) {
    gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
    return gs.mc(gSobject,"cleanupDarkObserver",[]);
   }
  gSobject['loadLocations'] = function(it) {
    gSobject.self = this;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchAllUnitsCurrentLocations",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(units) {
      gs.sp(gSobject.scope,"units",units);
      gs.mc(gSobject.self,"showMap",[units]);
      gs.execStatic(Utils,'clearInterval', this,[gSobject.pollingTimer]);
      return gSobject.pollingTimer = gs.execStatic(Utils,'setInterval', this,[function(it) {
        return gs.mc(gSobject.self,"pollLocations",[]);
       }, 60000]);
     }]);
   }
  gSobject['pollLocations'] = function(it) {
    gSobject.self = this;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchAllUnitsCurrentLocations",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(units) {
      gs.sp(gSobject.scope,"units",units);
      return gs.mc(gSobject.self,"updateMarkers",[units]);
     }]);
   }
  gSobject['navigateToUnit'] = function(unitId) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[gs.plus((gs.plus("/unit-details/", unitId)), "/?tab=details")]);
   }
  gSobject.showMap = function(units) {
    var component = this;
        var el = document.getElementById('full-map-container');
        if (!el) {
            setTimeout(function() { component.showMap(units); }, 300);
            return;
        }
        if (!window.google || !window.google.maps) {
            setTimeout(function() { component.showMap(units); }, 500);
            return;
        }
        window._navigateToUnit = function(id) { component.navigateToUnit(id); };
        var center = { lat: -28.5, lng: 24.5 };
        var darkStyles = [
            { elementType: "geometry", stylers: [{ color: "#212121" }] },
            { elementType: "labels.icon", stylers: [{ visibility: "off" }] },
            { elementType: "labels.text.fill", stylers: [{ color: "#757575" }] },
            { elementType: "labels.text.stroke", stylers: [{ color: "#212121" }] },
            { featureType: "administrative.country", elementType: "labels.text.fill", stylers: [{ color: "#9e9e9e" }] },
            { featureType: "administrative.locality", elementType: "labels.text.fill", stylers: [{ color: "#bdbdbd" }] },
            { featureType: "poi", elementType: "labels.text.fill", stylers: [{ color: "#757575" }] },
            { featureType: "poi.park", elementType: "geometry", stylers: [{ color: "#181818" }] },
            { featureType: "road", elementType: "geometry.fill", stylers: [{ color: "#2c2c2c" }] },
            { featureType: "road", elementType: "labels.text.fill", stylers: [{ color: "#8a8a8a" }] },
            { featureType: "road.highway", elementType: "geometry", stylers: [{ color: "#3c3c3c" }] },
            { featureType: "water", elementType: "geometry", stylers: [{ color: "#000000" }] },
            { featureType: "water", elementType: "labels.text.fill", stylers: [{ color: "#3d3d3d" }] }
        ];
        var isDark = document.body.classList.contains('body--dark');
        var map = new google.maps.Map(el, {
            zoom: 6,
            center: center,
            mapTypeId: 'roadmap',
            styles: isDark ? darkStyles : []
        });
        var markers = {};
        units.forEach(function(unit) {
            var pos = { lat: unit.lat, lng: unit.lng };
            var marker = new google.maps.Marker({
                position: pos,
                map: map,
                title: unit.name,
                icon: {
                    path: google.maps.SymbolPath.CIRCLE,
                    scale: 10,
                    fillColor: '#1565C0',
                    fillOpacity: 1,
                    strokeColor: '#ffffff',
                    strokeWeight: 2.5
                }
            });
            var infoWindow = new google.maps.InfoWindow({
                content: '<div style="padding:4px 2px"><strong>' + unit.name + '</strong><br/><small>Code: ' + unit.code + '</small>' + (unit.date ? '<br/><small>' + unit.date + '</small>' : '') + '<br/><button onclick="window._navigateToUnit(\'' + unit.id + '\')" style="margin-top:6px;padding:3px 10px;background:#1565C0;color:#fff;border:none;border-radius:4px;cursor:pointer;font-size:12px;">View Details</button></div>'
            });
            marker.addListener('click', function() {
                infoWindow.open(map, marker);
            });
            markers[unit.id] = { marker: marker, infoWindow: infoWindow };
        });
        window._fullMap = map;
        window._fullMapMarkers = markers;
        window._fullMapDarkStyles = darkStyles;

        if (window._fullMapObserver) window._fullMapObserver.disconnect();
        window._fullMapObserver = new MutationObserver(function() {
            var nowDark = document.body.classList.contains('body--dark');
            if (window._fullMap) {
                window._fullMap.setOptions({ styles: nowDark ? window._fullMapDarkStyles : [] });
            }
        });
        window._fullMapObserver.observe(document.body, { attributes: true, attributeFilter: ['class'] });
   }
  gSobject.cleanupDarkObserver = function() {
    if (window._fullMapObserver) {
            window._fullMapObserver.disconnect();
            window._fullMapObserver = null;
        }
   }
  gSobject.updateMarkers = function(units) {
    var map = window._fullMap;
        var markers = window._fullMapMarkers;
        if (!map || !markers) return;
        units.forEach(function(unit) {
            var pos = { lat: unit.lat, lng: unit.lng };
            if (markers[unit.id]) {
                markers[unit.id].marker.setPosition(pos);
                markers[unit.id].infoWindow.setContent('<div style="padding:4px 2px"><strong>' + unit.name + '</strong><br/><small>Code: ' + unit.code + '</small>' + (unit.date ? '<br/><small>' + unit.date + '</small>' : '') + '<br/><button onclick="window._navigateToUnit(\'' + unit.id + '\')" style="margin-top:6px;padding:3px 10px;background:#1565C0;color:#fff;border:none;border-radius:4px;cursor:pointer;font-size:12px;">View Details</button></div>');
            } else {
                var marker = new google.maps.Marker({
                    position: pos,
                    map: map,
                    title: unit.name,
                    icon: {
                        path: google.maps.SymbolPath.CIRCLE,
                        scale: 10,
                        fillColor: '#1565C0',
                        fillOpacity: 1,
                        strokeColor: '#ffffff',
                        strokeWeight: 2.5
                    }
                });
                var infoWindow = new google.maps.InfoWindow({
                    content: '<div style="padding:4px 2px"><strong>' + unit.name + '</strong><br/><small>Code: ' + unit.code + '</small>' + (unit.date ? '<br/><small>' + unit.date + '</small>' : '') + '<br/><button onclick="window._navigateToUnit(\'' + unit.id + '\')" style="margin-top:6px;padding:3px 10px;background:#1565C0;color:#fff;border:none;border-radius:4px;cursor:pointer;font-size:12px;">View Details</button></div>'
                });
                marker.addListener('click', function() {
                    infoWindow.open(map, marker);
                });
                markers[unit.id] = { marker: marker, infoWindow: infoWindow };
            }
        });
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorsListComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorsListComponent', simpleName: 'SensorsListComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/sensors-list";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Physical Sensors", true]);
    gs.sp(gSobject.scope,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    gs.sp(gSobject.scope,"canManage",((gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"])) || (gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_AGENT"]))));
    gs.sp(gSobject.scope,"sensors",gs.list([]));
    gs.sp(gSobject.scope,"loading",true);
    gs.sp(gSobject.scope,"searchText","");
    gs.sp(gSobject.scope,"filterOrg",null);
    gs.sp(gSobject.scope,"filterUnit",null);
    gs.sp(gSobject.scope,"filterAssignment",null);
    gs.sp(gSobject.scope,"assignmentOptions",gs.list([gs.map().add("value",null).add("label","All") , gs.map().add("value","assigned").add("label","Assigned") , gs.map().add("value","unassigned").add("label","Unassigned")]));
    gs.sp(gSobject.scope,"orgs",gs.list([]));
    gs.sp(gSobject.scope,"units",gs.list([]));
    gs.sp(gSobject.scope,"dialogOpen",false);
    gs.sp(gSobject.scope,"saving",false);
    gs.sp(gSobject.scope,"isNew",false);
    gs.sp(gSobject.scope,"editing",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription","").add("org",""));
    gs.sp(gSobject.scope,"pagination",gs.map().add("sortBy","mac").add("descending",false).add("page",1).add("rowsPerPage",50).add("rowsNumber",0));
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","mac").add("label","MAC").add("field","mac").add("align","left").add("sortable",true) , gs.map().add("name","identifier").add("label","Identifier").add("field","identifier").add("align","left").add("sortable",true) , gs.map().add("name","serialNumber").add("label","Serial Number").add("field","serialNumber").add("align","left").add("sortable",true) , gs.map().add("name","orgName").add("label","Organisation").add("field","orgName").add("align","left").add("sortable",true) , gs.map().add("name","assignedUnitName").add("label","Unit").add("field","assignedUnitName").add("align","left").add("sortable",true)]));
    gs.mc(gSobject,"loadOrgs",[]);
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['loadOrgs'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"filteredOrganisations",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), "", function(orgs) {
      return gs.sp(gSobject.scope,"orgs",gs.mc(gs.elvis(gs.bool(orgs) , orgs , gs.list([])),"collect",[function(it) {
        return gs.map().add("_id",gs.gp(it,"_id")).add("name",gs.gp(it,"name"));
       }]));
     }]);
   }
  gSobject['loadUnitsForOrg'] = function(orgId) {
    if (!gs.bool(orgId)) {
      gs.sp(gSobject.scope,"units",gs.list([]));
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchMany",[gs.map().add("org",orgId), function(units) {
      return gs.sp(gSobject.scope,"units",gs.mc(gs.elvis(gs.bool(units) , units , gs.list([])),"collect",[function(it) {
        return gs.map().add("_id",gs.gp(it,"_id")).add("name",gs.gp(it,"name"));
       }]));
     }]);
   }
  gSobject['applyOrgFilter'] = function(orgId) {
    gs.sp(gSobject.scope,"filterOrg",orgId);
    gs.sp(gSobject.scope,"filterUnit",null);
    gs.mc(gSobject,"loadUnitsForOrg",[orgId]);
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['applyUnitFilter'] = function(unitId) {
    gs.sp(gSobject.scope,"filterUnit",unitId);
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['applyAssignmentFilter'] = function(value) {
    gs.sp(gSobject.scope,"filterAssignment",value);
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['loadSensors'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    var filter = gs.map();
    if (gs.bool(gs.gp(gSobject.scope,"filterOrg"))) {
      gs.sp(filter,"org",gs.gp(gSobject.scope,"filterOrg"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"filterUnit"))) {
      gs.sp(filter,"unit",gs.gp(gSobject.scope,"filterUnit"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"filterAssignment"))) {
      gs.sp(filter,"assignment",gs.gp(gSobject.scope,"filterAssignment"));
     };
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"paginatedSensorsForUser",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.scope,"searchText"), filter, gs.gp(gSobject.scope,"pagination")]),"then",[function(data) {
      gs.sp(gSobject.scope,"sensors",gs.elvis(gs.bool(gs.gp(data,"sensors")) , gs.gp(data,"sensors") , gs.list([])));
      gs.sp(gs.gp(gSobject.scope,"pagination"),"rowsNumber",gs.elvis(gs.bool(gs.gp(data,"totalRows")) , gs.gp(data,"totalRows") , 0));
      return gs.sp(gSobject.scope,"loading",false);
     }, function(error) {
      gs.mc(gSobject,"notify",["Failed to load physical sensors", "negative"]);
      return gs.sp(gSobject.scope,"loading",false);
     }]);
   }
  gSobject['onRequest'] = function(props) {
    gs.sp(gSobject.scope,"pagination",gs.gp(props,"pagination"));
    return gs.mc(gSobject,"loadSensors",[]);
   }
  gSobject['selectSensor'] = function(sensor) {
    if (gs.bool(gs.gp(sensor,"_id",true))) {
      return gs.mc(gSobject,"openEdit",[sensor]);
     };
   }
  gSobject['newSensor'] = function(it) {
    return gs.mc(gSobject,"openNew",[]);
   }
  gSobject['openNew'] = function(it) {
    gs.sp(gSobject.scope,"isNew",true);
    gs.sp(gSobject.scope,"saving",false);
    gs.sp(gSobject.scope,"editing",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription","").add("org",gs.elvis(gs.bool(gs.gp(gSobject.scope,"filterOrg")) , gs.gp(gSobject.scope,"filterOrg") , "")));
    return gs.sp(gSobject.scope,"dialogOpen",true);
   }
  gSobject['openEdit'] = function(sensor) {
    gs.sp(gSobject.scope,"isNew",false);
    gs.sp(gSobject.scope,"saving",false);
    gs.sp(gSobject.scope,"editing",gs.map().add("_id",gs.gp(sensor,"_id")).add("mac",gs.elvis(gs.bool(gs.gp(sensor,"mac")) , gs.gp(sensor,"mac") , "")).add("identifier",gs.elvis(gs.bool(gs.gp(sensor,"identifier")) , gs.gp(sensor,"identifier") , "")).add("serialNumber",gs.elvis(gs.bool(gs.gp(sensor,"serialNumber")) , gs.gp(sensor,"serialNumber") , "")).add("locationDescription",gs.elvis(gs.bool(gs.gp(sensor,"locationDescription")) , gs.gp(sensor,"locationDescription") , "")).add("org",gs.elvis(gs.bool(gs.gp(gs.gp(sensor,"org"),"_id",true)) , gs.gp(gs.gp(sensor,"org"),"_id",true) , gs.elvis(gs.bool(gs.gp(sensor,"org")) , gs.gp(sensor,"org") , gs.elvis(gs.bool(gs.gp(sensor,"orgId")) , gs.gp(sensor,"orgId") , "")))));
    return gs.sp(gSobject.scope,"dialogOpen",true);
   }
  gSobject['cancelDialog'] = function(it) {
    return gs.sp(gSobject.scope,"dialogOpen",false);
   }
  gSobject['saveDialog'] = function(it) {
    if (gs.bool(gs.gp(gSobject.scope,"saving"))) {
      return null;
     };
    if (((!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"editing"),"mac"),"trim",[], null, true))) && (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"editing"),"identifier"),"trim",[], null, true)))) && (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"editing"),"serialNumber"),"trim",[], null, true)))) {
      gs.mc(gSobject,"notify",["A Mac Address, Sensor Identifier or Serial Number is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"editing"),"org"))) {
      gs.mc(gSobject,"notify",["Please select an organisation", "warning"]);
      return null;
     };
    gs.sp(gSobject.scope,"saving",true);
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"save",[gs.gp(gSobject.scope,"editing"), gs.gp(gs.fs('session', this, gSobject),"userId")]),"then",[function(data) {
      gs.sp(gSobject.scope,"saving",false);
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(data)) {
        gs.sp(gSobject.scope,"editing",data);
       };
      gs.sp(gSobject.scope,"dialogOpen",false);
      gs.mc(gSobject,"notify",["Physical Sensor Saved"]);
      return gs.mc(gSobject,"loadSensors",[]);
     }, function(error) {
      gs.sp(gSobject.scope,"saving",false);
      gs.mc(gSobject,"hideLoading",[]);
      return gs.mc(gSobject,"notify",[gs.elvis(gs.bool(gs.gp(error,"message",true)) , gs.gp(error,"message",true) , "Failed to save physical sensor"), "negative"]);
     }]);
   }
  gSobject['removeFromDialog'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Confirmation").add("message","Are you sure you want to delete this physical sensor?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"remove",[gs.gp(gs.gp(gSobject.scope,"editing"),"_id"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.sp(gSobject.scope,"dialogOpen",false);
        gs.mc(gSobject,"notify",["Physical Sensor Deleted", "negative"]);
        return gs.mc(gSobject,"loadSensors",[]);
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function TransmissionBootstrapEnd() {
  var gSobject = gs.init('TransmissionBootstrapEnd');
  gSobject.clazz = { name: 'TransmissionBootstrapEnd', simpleName: 'TransmissionBootstrapEnd'};
  gSobject.clazz.superclass = { name: 'java.lang.Object', simpleName: 'Object'};
  Object.defineProperty(gSobject, 'session', { get: function() { return TransmissionBootstrapEnd.session; }, set: function(gSval) { TransmissionBootstrapEnd.session = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'transmissionReadyCallbackList', { get: function() { return TransmissionBootstrapEnd.transmissionReadyCallbackList; }, set: function(gSval) { TransmissionBootstrapEnd.transmissionReadyCallbackList = gSval; }, enumerable: true });
  gSobject['startApp'] = function(it) {
    return gs.execStatic(Utils,'documentReady', this,[function(it) {
      gs.println("TransmissionBootstrapEnd:startApp:Utils.documentReady");
      return gs.execStatic(LocalDB,'getInstance', this,[function(it) {
        gs.println("TransmissionBootstrapEnd:startApp:LocalDB.getInstance");
        gs.mc(gs.fs('startupParams', this, gSobject),"beforeSocketInit",[]);
        gs.execStatic(Socket,'initSocket', this,[gs.gp(gs.fs('startupParams', this, gSobject),"afterSocketInit")]);
        return gs.mc(gs.gp(gs.fs('transmission', this, gSobject),"onReady"),"runCallbacks",[]);
       }]);
     }]);
   }
  gSobject['TransmissionBootstrapEnd0'] = function(it) {
    gs.println("TransmissionBootstrapEnd:start");
    if (gs.execStatic(Socket,'isDymicoSystemUpdating', this,[])) {
      return null;
     };
    gs.mc(gSobject,"startApp",[]);
    gs.println("TransmissionBootstrapEnd:end");
    return this;
  }
  if (arguments.length==0) {gSobject.TransmissionBootstrapEnd0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
TransmissionBootstrapEnd.session = gs.execStatic(Session,'instance', this,[]);
TransmissionBootstrapEnd.transmissionReadyCallbackList = gs.list([]);

function DashboardComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'DashboardComponent', simpleName: 'DashboardComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Dashboard", false]);
    gs.sp(gSobject.scope,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    gs.sp(gSobject.scope,"stats",gs.map().add("totalUnits",null).add("avgTemp",null).add("minTemp",null).add("maxTemp",null).add("criticalAlertCount",null));
    gs.sp(gSobject.scope,"alertTrendLabels",gs.list([]));
    gs.sp(gSobject.scope,"alertTrendAlarm",gs.list([]));
    gs.sp(gSobject.scope,"alertTrendWarning",gs.list([]));
    gs.sp(gSobject.scope,"latestAlerts",gs.list([]));
    gs.sp(gSobject.scope,"orgsByUnitCount",gs.list([]));
    gs.sp(gSobject.scope,"orgsByAlertRate",gs.list([]));
    gs.sp(gSobject.scope,"orgDetails",null);
    gs.sp(gSobject.scope,"pending",0);
    gs.mc(gSobject,"loadDashboard",[]);
    return gs.println("DASHBOARD LOADED");
   }
  gSobject['loadDashboard'] = function(it) {
    gs.sp(gSobject.scope,"pending",(gs.bool(gs.gp(gSobject.scope,"isAdmin")) ? 5 : 4));
    var zonerId = gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id");
    var userId = gs.gp(gs.fs('session', this, gSobject),"userId");
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwDashboardService"),"summary",[zonerId, userId, function(data) {
      gs.sp(gSobject.scope,"stats",data);
      return gs.mc(gSobject,"checkDone",[]);
     }]);
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwDashboardService"),"alertTrend",[zonerId, userId, function(data) {
      gs.sp(gSobject.scope,"alertTrendLabels",gs.gp(data,"labels"));
      gs.sp(gSobject.scope,"alertTrendAlarm",gs.gp(data,"alarm"));
      gs.sp(gSobject.scope,"alertTrendWarning",gs.gp(data,"warning"));
      return gs.mc(gSobject,"checkDone",[]);
     }]);
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwDashboardService"),"latestAlerts",[zonerId, userId, function(data) {
      gs.sp(gSobject.scope,"latestAlerts",data);
      return gs.mc(gSobject,"checkDone",[]);
     }]);
    if (gs.bool(gs.gp(gSobject.scope,"isAdmin"))) {
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwDashboardService"),"orgsByUnitCount",[zonerId, userId, function(data) {
        gs.sp(gSobject.scope,"orgsByUnitCount",data);
        return gs.mc(gSobject,"checkDone",[]);
       }]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwDashboardService"),"orgsByAlertRate",[zonerId, userId, function(data) {
        gs.sp(gSobject.scope,"orgsByAlertRate",data);
        return gs.mc(gSobject,"checkDone",[]);
       }]);
     } else {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwDashboardService"),"orgDetails",[zonerId, userId, function(data) {
        gs.sp(gSobject.scope,"orgDetails",data);
        return gs.mc(gSobject,"checkDone",[]);
       }]);
     };
   }
  gSobject['checkDone'] = function(it) {
    gs.sp(gSobject.scope,"pending",(gs.minus(gs.gp(gSobject.scope,"pending"), 1)));
    if (gs.gp(gSobject.scope,"pending") < 0) {
      return gs.sp(gSobject.scope,"pending",0);
     };
   }
  gSobject['severityColor'] = function(severity) {
    if (gs.equals(severity, "alarm")) {
      return "negative";
     };
    return "warning";
   }
  gSobject['severityIcon'] = function(severity) {
    if (gs.equals(severity, "alarm")) {
      return "o_crisis_alert";
     };
    return "o_warning";
   }
  gSobject['formatDate'] = function(dateValue) {
    if (!gs.bool(dateValue)) {
      return "-";
     };
    var date = (gs.instanceOf(dateValue, "Date") ? dateValue : gs.date(gs.mc(dateValue,"toString",[])));
    return gs.mc(date,"format",["dd/MM HH:mm"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminSensorProfileDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminSensorProfileDetailsComponent', simpleName: 'AdminSensorProfileDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/organisation/:orgId/sensorProfile/:id";
  Object.defineProperty(gSobject, 'TYPE_LABELS', { get: function() { return AdminSensorProfileDetailsComponent.TYPE_LABELS; }, set: function(gSval) { AdminSensorProfileDetailsComponent.TYPE_LABELS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'ANALOG_ALERT_KEYS', { get: function() { return AdminSensorProfileDetailsComponent.ANALOG_ALERT_KEYS; }, set: function(gSval) { AdminSensorProfileDetailsComponent.ANALOG_ALERT_KEYS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIGITAL_ALERT_KEYS', { get: function() { return AdminSensorProfileDetailsComponent.DIGITAL_ALERT_KEYS; }, set: function(gSval) { AdminSensorProfileDetailsComponent.DIGITAL_ALERT_KEYS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'ALERT_LABELS', { get: function() { return AdminSensorProfileDetailsComponent.ALERT_LABELS; }, set: function(gSval) { AdminSensorProfileDetailsComponent.ALERT_LABELS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIGITAL_TYPES', { get: function() { return AdminSensorProfileDetailsComponent.DIGITAL_TYPES; }, set: function(gSval) { AdminSensorProfileDetailsComponent.DIGITAL_TYPES = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'PROFILE_TYPES', { get: function() { return AdminSensorProfileDetailsComponent.PROFILE_TYPES; }, set: function(gSval) { AdminSensorProfileDetailsComponent.PROFILE_TYPES = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DAY_OPTIONS', { get: function() { return AdminSensorProfileDetailsComponent.DAY_OPTIONS; }, set: function(gSval) { AdminSensorProfileDetailsComponent.DAY_OPTIONS = gSval; }, enumerable: true });
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Sensor Profile Details", true]);
    gs.sp(gSobject.scope,"sensorProfile",gs.map().add("profile",gs.map().add("type","")).add("alertOptions",gs.map()).add("inactivePeriods",gs.list([])));
    gs.sp(gSobject.scope,"deleteEnabled",(gs.gp(gs.gp(gSobject.route,"params"),"id") != "new"));
    gs.sp(gSobject.scope,"isDigital",false);
    gs.sp(gSobject.scope,"unitOptions",gs.list([]));
    gs.sp(gSobject.scope,"filteredUnitOptions",gs.list([]));
    gs.sp(gSobject.scope,"sensorOptions",gs.list([]));
    gs.sp(gSobject.scope,"filteredSensorOptions",gs.list([]));
    gs.sp(gSobject.scope,"profileOptions",gs.list([]));
    gs.sp(gSobject.scope,"filteredProfileOptions",gs.list([]));
    gs.sp(gSobject.scope,"alertLabels",AdminSensorProfileDetailsComponent.ALERT_LABELS);
    gs.sp(gSobject.scope,"alertKeys",gs.list([]));
    gs.sp(gSobject.scope,"dayOptions",AdminSensorProfileDetailsComponent.DAY_OPTIONS);
    gs.sp(gSobject.scope,"profileTypeOptions",AdminSensorProfileDetailsComponent.PROFILE_TYPES);
    gs.sp(gSobject.scope,"newSensorDialogOpen",false);
    gs.sp(gSobject.scope,"newSensor",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription",""));
    gs.sp(gSobject.scope,"newProfileDialogOpen",false);
    gs.sp(gSobject.scope,"newProfile",gs.mc(gSobject,"blankNewProfile",[]));
    gs.mc(gSobject,"loadOptions",[]);
    return gs.mc(gSobject,"loadSensorProfile",[]);
   }
  gSobject['blankNewProfile'] = function(it) {
    return gs.map().add("name","").add("type","").add("low","").add("high","").add("lowWarn","").add("highWarn","").add("alarmOnState",false).add("alarmOffState",false).add("onAlarmMessage","").add("offAlarmMessage","");
   }
  gSobject['newProfileIsDigital'] = function(it) {
    return gs.mc(AdminSensorProfileDetailsComponent.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.scope,"newProfile"),"type",true)]);
   }
  gSobject['sensorDisplayLabel'] = function(s) {
    return gs.elvis(gs.bool(gs.gp(s,"mac",true)) , gs.gp(s,"mac",true) , gs.elvis(gs.bool(gs.gp(s,"identifier",true)) , gs.gp(s,"identifier",true) , gs.elvis(gs.bool(gs.gp(s,"serialNumber",true)) , gs.gp(s,"serialNumber",true) , "(unidentified)")));
   }
  gSobject['decorateSensors'] = function(list) {
    gs.mc(gs.elvis(gs.bool(list) , list , gs.list([])),"each",[function(it) {
      return gs.sp(it,"displayLabel",gs.mc(gSobject,"sensorDisplayLabel",[it]));
     }]);
    return gs.elvis(gs.bool(list) , list , gs.list([]));
   }
  gSobject['loadSensorProfile'] = function(it) {
    var loader = gs.mc(gSobject,"showLoading",["Loading Sensor Profile..."]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"fetchOneByIdOrNew",[gs.gp(gs.gp(gSobject.route,"params"),"id"), function(data) {
      gs.execCall(loader, this, []);
      gs.sp(gSobject.scope,"sensorProfile",data);
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions"))) {
        gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions",gs.map());
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods"))) {
        gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods",gs.list([]));
       };
      gs.mc(gSobject,"normalizePeriods",[]);
      if (gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"sensor"))) {
        gs.sp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"sensor"),"displayLabel",gs.mc(gSobject,"sensorDisplayLabel",[gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"sensor")]));
       };
      if (gs.bool(gs.gp(gs.gp(gSobject.route,"query",true),"unitId",true))) {
        gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchOneById",[gs.gp(gs.gp(gSobject.route,"query"),"unitId"), function(unit) {
          if (gs.bool(unit)) {
            gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"unit",unit);
            return gs.mc(gSobject,"updateTitle",[]);
           };
         }]);
       };
      gs.mc(gSobject,"refreshAlertOptions",[]);
      return gs.mc(gSobject,"updateTitle",[]);
     }]);
   }
  gSobject['loadOptions'] = function(it) {
    var unitsLoader = gs.mc(gSobject,"showLoading",["Loading Units..."]);
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"filteredUnits",["", gs.map().add("org",gs.gp(gs.gp(gSobject.route,"params"),"orgId")), function(units) {
      gs.execCall(unitsLoader, this, []);
      return gs.sp(gSobject.scope,"unitOptions",units);
     }]);
    var sensorsLoader = gs.mc(gSobject,"showLoading",["Loading Sensors..."]);
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"availableForSensorProfile",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gs.gp(gSobject.route,"params"),"orgId"), gs.gp(gs.gp(gSobject.route,"params"),"id"), function(sensors) {
      gs.execCall(sensorsLoader, this, []);
      return gs.sp(gSobject.scope,"sensorOptions",gs.mc(gSobject,"decorateSensors",[sensors]));
     }]);
    var profilesLoader = gs.mc(gSobject,"showLoading",["Loading Measurement Templates..."]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"filteredProfiles",["", gs.map().add("org",gs.gp(gs.gp(gSobject.route,"params"),"orgId")), function(profiles) {
      gs.execCall(profilesLoader, this, []);
      return gs.sp(gSobject.scope,"profileOptions",profiles);
     }]);
   }
  gSobject['filterUnits'] = function(val, update) {
    return gs.mc(gSobject,"filterOptions",[val, update, "unitOptions", "filteredUnitOptions"]);
   }
  gSobject['filterSensors'] = function(val, update) {
    return gs.mc(gSobject,"filterOptions",[val, update, "sensorOptions", "filteredSensorOptions"]);
   }
  gSobject['filterProfiles'] = function(val, update) {
    return gs.mc(gSobject,"filterOptions",[val, update, "profileOptions", "filteredProfileOptions"]);
   }
  gSobject['onProfileChange'] = function(it) {
    return gs.mc(gSobject,"refreshAlertOptions",[]);
   }
  gSobject['refreshAlertOptions'] = function(it) {
    var type = gs.gp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"profile",true),"type",true);
    var isDigital = gs.mc(AdminSensorProfileDetailsComponent.DIGITAL_TYPES,"contains",[type]);
    gs.sp(gSobject.scope,"isDigital",isDigital);
    gs.sp(gSobject.scope,"alertKeys",(gs.bool(type) ? (gs.bool(isDigital) ? AdminSensorProfileDetailsComponent.DIGITAL_ALERT_KEYS : AdminSensorProfileDetailsComponent.ANALOG_ALERT_KEYS) : gs.list([])));
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions"))) {
      gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions",gs.map());
     };
    var isNew = !gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"_dateCreated",true);
    return gs.mc(gs.gp(gSobject.scope,"alertKeys"),"each",[function(key) {
      if ((gs.bool(isNew)) && (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions")[key]))) {
        return (gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions")[key]) = true;
       } else {
        return (gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions")[key]) = (gs.equals((gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions")[key]), true));
       };
     }]);
   }
  gSobject['normalizePeriods'] = function(it) {
    return gs.mc(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods"),"each",[function(period) {
      if (gs.equals(gs.gp(period,"name"), null)) {
        gs.sp(period,"name","");
       };
      if (gs.equals(gs.gp(period,"enabled"), null)) {
        gs.sp(period,"enabled",true);
       };
      if (gs.equals(gs.gp(period,"days"), null)) {
        return gs.sp(period,"days",(gs.bool(gs.gp(period,"day")) ? gs.list([gs.gp(period,"day")]) : gs.list([])));
       };
     }]);
   }
  gSobject['addPeriod'] = function(it) {
    return gs.mc(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods"),"push",[gs.map().add("name","").add("enabled",true).add("startTime","00:00").add("endTime","00:00").add("days",gs.list([]))]);
   }
  gSobject['removePeriod'] = function(index) {
    return gs.mc(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods"),"splice",[index, 1]);
   }
  gSobject['typeLabel'] = function(it) {
    return gs.elvis(AdminSensorProfileDetailsComponent.TYPE_LABELS[gs.gp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"profile",true),"type",true)] , AdminSensorProfileDetailsComponent.TYPE_LABELS[gs.gp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"profile",true),"type",true)] , "");
   }
  gSobject['alertLabel'] = function(key) {
    var prefix = gs.mc(gSobject,"typeLabel",[]);
    return gs.plus((gs.bool(prefix) ? gs.plus(prefix, " ") : ""), (gs.gp(gSobject.scope,"alertLabels")[key]));
   }
  gSobject['save'] = function(it) {
    if (!gs.bool(gs.gp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"sensor"),"_id",true))) {
      gs.mc(gSobject,"notify",["Physical Sensor is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"profile"),"_id",true))) {
      gs.mc(gSobject,"notify",["Measurement Template is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"name"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Sensor Display Name is required", "warning"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"save",[gs.gp(gSobject.scope,"sensorProfile"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"sensorProfile",data);
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions"))) {
        gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"alertOptions",gs.map());
       };
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods"))) {
        gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"inactivePeriods",gs.list([]));
       };
      gs.mc(gSobject,"normalizePeriods",[]);
      gs.sp(gSobject.scope,"deleteEnabled",true);
      gs.mc(gSobject,"refreshAlertOptions",[]);
      gs.mc(gSobject,"updateTitle",[]);
      return gs.mc(gSobject,"notify",["Sensor Profile Saved"]);
     }]);
   }
  gSobject['deleteSensorProfile'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Confirmation").add("message","Are you sure you want to delete this sensor profile?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"delete",[gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Sensor Profile Deleted", "negative"]);
        return gs.mc(gSobject,"back",[]);
       }]);
     }]);
   }
  gSobject['updateTitle'] = function(it) {
    var unitName = gs.gp(gs.gp(gs.gp(gSobject.scope,"sensorProfile"),"unit",true),"name",true);
    return gs.mc(gSobject,"setPageTitle",[(gs.bool(unitName) ? gs.plus("Sensor Profile Details: ", unitName) : "Sensor Profile Details")]);
   }
  gSobject['openNewSensorDialog'] = function(it) {
    gs.sp(gSobject.scope,"newSensor",gs.map().add("mac","").add("identifier","").add("serialNumber","").add("locationDescription",""));
    return gs.sp(gSobject.scope,"newSensorDialogOpen",true);
   }
  gSobject['cancelNewSensor'] = function(it) {
    return gs.sp(gSobject.scope,"newSensorDialogOpen",false);
   }
  gSobject['saveNewSensor'] = function(it) {
    var mac = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newSensor"),"mac")) , gs.gp(gs.gp(gSobject.scope,"newSensor"),"mac") , ""),"trim",[]);
    var identifier = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newSensor"),"identifier")) , gs.gp(gs.gp(gSobject.scope,"newSensor"),"identifier") , ""),"trim",[]);
    var serialNumber = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newSensor"),"serialNumber")) , gs.gp(gs.gp(gSobject.scope,"newSensor"),"serialNumber") , ""),"trim",[]);
    if (((!gs.bool(mac)) && (!gs.bool(identifier))) && (!gs.bool(serialNumber))) {
      gs.mc(gSobject,"notify",["A Mac Address, Sensor Identifier or Serial Number is required", "warning"]);
      return null;
     };
    var loader = gs.mc(gSobject,"showLoading",["Creating sensor..."]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"save",[gs.map().add("mac",mac).add("identifier",identifier).add("serialNumber",serialNumber).add("locationDescription",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newSensor"),"locationDescription")) , gs.gp(gs.gp(gSobject.scope,"newSensor"),"locationDescription") , ""),"trim",[])).add("org",gs.gp(gs.gp(gSobject.route,"params"),"orgId")).add("active",true), gs.gp(gs.fs('session', this, gSobject),"userId")]),"then",[function(saved) {
      gs.execCall(loader, this, []);
      gs.sp(gSobject.scope,"newSensorDialogOpen",false);
      gs.mc(gSobject,"notify",["Sensor Created"]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"availableForSensorProfile",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gs.gp(gSobject.route,"params"),"orgId"), gs.gp(gs.gp(gSobject.route,"params"),"id"), function(sensors) {
        gs.sp(gSobject.scope,"sensorOptions",gs.mc(gSobject,"decorateSensors",[sensors]));
        var picked = gs.mc(gs.elvis(gs.bool(gs.gp(gSobject.scope,"sensorOptions")) , gs.gp(gSobject.scope,"sensorOptions") , gs.list([])),"find",[function(it) {
          return gs.equals(gs.gp(it,"_id"), gs.gp(saved,"_id"));
         }]);
        if (gs.bool(picked)) {
          return gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"sensor",picked);
         };
       }]);
     }, function(error) {
      gs.execCall(loader, this, []);
      return gs.mc(gSobject,"notify",[gs.elvis(gs.bool(gs.gp(error,"message",true)) , gs.gp(error,"message",true) , "Failed to create sensor"), "negative"]);
     }]);
   }
  gSobject['openNewProfileDialog'] = function(it) {
    gs.sp(gSobject.scope,"newProfile",gs.mc(gSobject,"blankNewProfile",[]));
    return gs.sp(gSobject.scope,"newProfileDialogOpen",true);
   }
  gSobject['cancelNewProfile'] = function(it) {
    return gs.sp(gSobject.scope,"newProfileDialogOpen",false);
   }
  gSobject['saveNewProfile'] = function(it) {
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"newProfile"),"name"),"trim",[], null, true))) {
      gs.mc(gSobject,"notify",["Measurement template name is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"type"))) {
      gs.mc(gSobject,"notify",["Measurement template type is required", "warning"]);
      return null;
     };
    var isDigital = gs.mc(AdminSensorProfileDetailsComponent.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.scope,"newProfile"),"type")]);
    var payload = gs.map().add("name",gs.mc(gs.gp(gs.gp(gSobject.scope,"newProfile"),"name"),"trim",[])).add("type",gs.gp(gs.gp(gSobject.scope,"newProfile"),"type")).add("org",gs.gp(gs.gp(gSobject.route,"params"),"orgId"));
    if (gs.bool(isDigital)) {
      gs.sp(payload,"alarmOnState",(gs.equals(gs.gp(gs.gp(gSobject.scope,"newProfile"),"alarmOnState"), true)));
      gs.sp(payload,"alarmOffState",(gs.equals(gs.gp(gs.gp(gSobject.scope,"newProfile"),"alarmOffState"), true)));
      gs.sp(payload,"onAlarmMessage",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"onAlarmMessage")) , gs.gp(gs.gp(gSobject.scope,"newProfile"),"onAlarmMessage") , ""),"toString",[]));
      gs.sp(payload,"offAlarmMessage",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"offAlarmMessage")) , gs.gp(gs.gp(gSobject.scope,"newProfile"),"offAlarmMessage") , ""),"toString",[]));
     } else {
      gs.sp(payload,"low",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"low")) , gs.gp(gs.gp(gSobject.scope,"newProfile"),"low") , 0));
      gs.sp(payload,"high",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"high")) , gs.gp(gs.gp(gSobject.scope,"newProfile"),"high") , 0));
      gs.sp(payload,"lowWarn",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"lowWarn")) , gs.gp(gs.gp(gSobject.scope,"newProfile"),"lowWarn") , 0));
      gs.sp(payload,"highWarn",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newProfile"),"highWarn")) , gs.gp(gs.gp(gSobject.scope,"newProfile"),"highWarn") , 0));
     };
    var loader = gs.mc(gSobject,"showLoading",["Creating measurement template..."]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"save",[payload, function(saved) {
      gs.execCall(loader, this, []);
      gs.sp(gSobject.scope,"newProfileDialogOpen",false);
      gs.mc(gSobject,"notify",["Measurement Template Created"]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"filteredProfiles",["", gs.map().add("org",gs.gp(gs.gp(gSobject.route,"params"),"orgId")), function(profiles) {
        gs.sp(gSobject.scope,"profileOptions",profiles);
        var picked = gs.mc(gs.elvis(gs.bool(profiles) , profiles , gs.list([])),"find",[function(it) {
          return gs.equals(gs.gp(it,"_id"), gs.gp(saved,"_id"));
         }]);
        if (gs.bool(picked)) {
          gs.sp(gs.gp(gSobject.scope,"sensorProfile"),"profile",picked);
          return gs.mc(gSobject,"refreshAlertOptions",[]);
         };
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
AdminSensorProfileDetailsComponent.TYPE_LABELS = gs.map().add("temperature","Temperature").add("humidity","Humidity").add("co2","CO2").add("digitalInput","Digital Input").add("digitalOutput","Digital Output");
AdminSensorProfileDetailsComponent.ANALOG_ALERT_KEYS = gs.list(["highAlarm" , "highWarning" , "lowWarning" , "lowAlarm" , "noDataChange" , "noData"]);
AdminSensorProfileDetailsComponent.DIGITAL_ALERT_KEYS = gs.list(["digitalIoAlarm"]);
AdminSensorProfileDetailsComponent.ALERT_LABELS = gs.map().add("highAlarm","High Alarm").add("highWarning","High Warning").add("lowWarning","Low Warning").add("lowAlarm","Low Alarm").add("noDataChange","No Data Change").add("noData","No Data").add("digitalIoAlarm","Digital I/O Alarm");
AdminSensorProfileDetailsComponent.DIGITAL_TYPES = gs.list(["digitalInput" , "digitalOutput"]);
AdminSensorProfileDetailsComponent.PROFILE_TYPES = gs.list(["temperature" , "humidity" , "co2" , "digitalInput" , "digitalOutput"]);
AdminSensorProfileDetailsComponent.DAY_OPTIONS = gs.list(["Monday" , "Tuesday" , "Wednesday" , "Thursday" , "Friday" , "Saturday" , "Sunday"]);

function AdminConfigComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminConfigComponent', simpleName: 'AdminConfigComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/adminConfig";
  gSobject['created'] = function(it) {
    gs.println("AdminConfigComponent.created()");
    gs.mc(gSobject,"setPageTitle",["Admin Configuration"]);
    gs.sp(gSobject.scope,"appTab","settings");
    gs.sp(gSobject.scope,"menuItemDialog",false);
    gs.sp(gSobject.scope,"menuItems",gs.list([]));
    gs.sp(gSobject.scope,"selectedMenuItem",null);
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","order").add("label","Order").add("field","order").add("align","left") , gs.map().add("name","label").add("label","Label").add("field","label").add("align","left") , gs.map().add("name","icon").add("label","Icon").add("field","icon").add("align","left") , gs.map().add("name","call").add("label","Call").add("field","call").add("align","left") , gs.map().add("name","route").add("label","Route").add("field","route").add("align","left") , gs.map().add("name","parentKey").add("label","Parent").add("field","parentKey").add("align","left") , gs.map().add("name","_lastUpdated").add("label","Last Updated").add("field",function(row) {
      return gs.mc(gSobject,"formatDate",[gs.gp(row,"_lastUpdated")]);
     }).add("align","left")]));
    gs.sp(gSobject.scope,"appConfigAvailable",false);
    gs.sp(gSobject.scope,"appConfigLoaded",false);
    gs.sp(gSobject.scope,"splitter","400");
    gs.sp(gSobject.scope,"activeProduct",gs.gp(gs.fs('session', this, gSobject),"activeProduct"));
    gs.sp(gSobject.scope,"clientProducts",gs.list([]));
    gs.sp(gSobject.scope,"menuProductOptions",gs.list([]));
    gs.sp(gSobject.scope,"appConfig",gs.map());
    gs.sp(gSobject.scope,"loginConfig",null);
    gs.sp(gSobject.scope,"sizeOptions",gs.list([gs.map().add("label","XSmall").add("value","xs") , gs.map().add("label","Small").add("value","sm") , gs.map().add("label","Medium").add("value","md") , gs.map().add("label","Large").add("value","lg") , gs.map().add("label","XLarge").add("value","xl")]));
    gs.sp(gSobject.scope,"menubuttonOptions",gs.list([gs.map().add("label","Flat").add("value","flat") , gs.map().add("label","Unelevated").add("value","unelevated") , gs.map().add("label","No Caps").add("value","noCaps") , gs.map().add("label","Outline").add("value","outline") , gs.map().add("label","Rounded").add("value","rounded") , gs.map().add("label","Push").add("value","push") , gs.map().add("label","Square").add("value","square") , gs.map().add("label","Glossy").add("value","glossy") , gs.map().add("label","Dense").add("value","dense")]));
    gs.sp(gSobject.scope,"inputOptions",gs.list([gs.map().add("label","Filled").add("value","filled") , gs.map().add("label","Outlined").add("value","outlined") , gs.map().add("label","Standout").add("value","standout") , gs.map().add("label","Rounded").add("value","rounded") , gs.map().add("label","Borderless").add("value","borderless") , gs.map().add("label","Square").add("value","square") , gs.map().add("label","Dense").add("value","dense")]));
    gs.mc(gSobject,"loadLoginConfig",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"appConfigService"),"fetchClientProducts",[function(data) {
      gs.sp(gSobject.scope,"clientProducts",data);
      gs.sp(gSobject.scope,"menuProductOptions",(gs.plus(gs.list([gs.map().add("name","Global (all apps)").add("id","*")]), data)));
      gs.sp(gSobject.scope,"appConfigAvailable",true);
      gs.mc(gSobject,"loadMenuItems",[]);
      if (gs.bool(gs.gp(gs.fs('session', this, gSobject),"activeProduct"))) {
        return gs.mc(gSobject,"loadAppConfig",[]);
       };
     }]);
   }
  gSobject['loadMenuItems'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"i3AdminService"),"loadMenuItems",[gs.gp(gSobject.scope,"activeProduct"), function(data) {
      return gs.sp(gSobject.scope,"menuItems",data);
     }]);
   }
  gSobject['selectMenuItem'] = function(evt, menuItem, index) {
    return gs.mc(gSobject,"openMenuItemDialog",[menuItem]);
   }
  gSobject['addMenuItem'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"i3AdminService"),"newMenuItem",[function(menuItem) {
      if (gs.bool(gs.gp(gSobject.scope,"activeProduct"))) {
        gs.sp(menuItem,"productId",gs.gp(gSobject.scope,"activeProduct"));
       };
      return gs.mc(gSobject,"openMenuItemDialog",[menuItem]);
     }]);
   }
  gSobject['saveMenuItem'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"i3AdminService"),"saveMenuItem",[gs.gp(gSobject.scope,"selectedMenuItem"), function(it) {
      gs.mc(gSobject,"resetMenuItemDialog",[]);
      return gs.mc(gSobject,"notify",["Menu Item Updated"]);
     }]);
   }
  gSobject['deleteMenuItem'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Menu Item?").add("message","Are you sure you wish to delete this menu item? This action is irreversible").add("cancel",true)]),"onOk",[function(it) {
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"i3AdminService"),"deleteMenuItem",[gs.gp(gs.gp(gSobject.scope,"selectedMenuItem"),"_id"), function(it) {
        gs.mc(gSobject,"resetMenuItemDialog",[]);
        return gs.mc(gSobject,"notify",["Item Deleted", "negative"]);
       }]);
     }]);
   }
  gSobject['openMenuItemDialog'] = function(menuItem) {
    gs.sp(gSobject.scope,"selectedMenuItem",menuItem);
    return gs.sp(gSobject.scope,"menuItemDialog",true);
   }
  gSobject['resetMenuItemDialog'] = function(it) {
    gs.sp(gSobject.scope,"menuItemDialog",false);
    gs.sp(gSobject.scope,"selectedMenuItem",null);
    return gs.mc(gSobject,"loadMenuItems",[]);
   }
  gSobject['updateActiveProduct'] = function(it) {
    gs.sp(gs.fs('session', this, gSobject),"activeProduct",gs.gp(gSobject.scope,"activeProduct"));
    gs.mc(gSobject,"loadAppConfig",[]);
    gs.mc(gSobject,"loadMenuItems",[]);
    return gs.mc(gSobject,"loadLoginConfig",[]);
   }
  gSobject['loadAppConfig'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"appConfigService"),"appConfig",[gs.gp(gs.fs('session', this, gSobject),"activeProduct"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"appConfig",data);
      gs.sp(gSobject.scope,"appConfigLoaded",true);
      return gs.mc(gs.gp(gs.gp(gSobject.scope,"appConfig"),"theme",true),"each",[function(color, value) {
        return gs.mc(gSobject,"updateColor",[color, value]);
       }]);
     }]);
   }
  gSobject['updateColor'] = function(color, value) {
    return gs.mc(gs.fs('Quasar', this, gSobject),"setCssVar",[color, value]);
   }
  gSobject['logoSaved'] = function(logoName) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"appConfigService"),"logoSaved",[gs.gp(gs.fs('session', this, gSobject),"activeProduct"), logoName, function(result) {
      return gs.mc(gSobject,"notify",["Logo updated"]);
     }]);
   }
  gSobject['saveConfig'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"appConfigService"),"saveAppConfig",[gs.gp(gs.fs('session', this, gSobject),"activeProduct"), gs.gp(gSobject.scope,"appConfig"), function(data) {
      return gs.mc(gSobject,"notify",["Config Saved"]);
     }]);
   }
  gSobject['loadLoginConfig'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"i3AdminService"),"loadLoginConfig",[gs.gp(gSobject.scope,"activeProduct"), function(data) {
      return gs.sp(gSobject.scope,"loginConfig",data);
     }]);
   }
  gSobject['saveLoginConfig'] = function(it) {
    var payload = gs.map().add("productId",gs.gp(gSobject.scope,"activeProduct")).add("authMethod",gs.gp(gs.gp(gSobject.scope,"loginConfig"),"authMethod")).add("webauthnEnabled",gs.gp(gs.gp(gSobject.scope,"loginConfig"),"webauthnEnabled")).add("welcome",gs.gp(gs.gp(gSobject.scope,"loginConfig"),"welcome"));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"i3AdminService"),"saveLoginConfig",[payload, function(data) {
      gs.sp(gSobject.scope,"loginConfig",data);
      return gs.mc(gSobject,"notify",["Login settings saved"]);
     }]);
   }
  gSobject['loginImageSaved'] = function(it) {
    gs.mc(gSobject,"loadLoginConfig",[]);
    return gs.mc(gSobject,"notify",["Image updated"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function ReportsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'ReportsComponent', simpleName: 'ReportsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/reports";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Reports", true]);
    gs.sp(gSobject.scope,"units",gs.list([]));
    gs.sp(gSobject.scope,"selectedUnit",null);
    gs.sp(gSobject.scope,"searchQuery","");
    gs.sp(gSobject.scope,"loading",true);
    gs.sp(gSobject.scope,"fromDate",null);
    gs.sp(gSobject.scope,"toDate",null);
    gs.sp(gSobject.scope,"fromTime","00:00");
    gs.sp(gSobject.scope,"toTime","23:59");
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['loadUnits'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    return gs.mc(gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnit"),"findAll",[]),"expand",[1]),"then",[function(units) {
      gs.sp(gSobject.scope,"units",gs.elvis(gs.bool(units) , units , gs.list([])));
      gs.sp(gSobject.scope,"loading",false);
      gs.println("UNIT DATA");
      return gs.println(units);
     }, function(error) {
      gs.mc(gSobject,"notify",["Failed to load units", "negative"]);
      return gs.sp(gSobject.scope,"loading",false);
     }]);
   }
  gSobject['filteredUnits'] = function(it) {
    var query = gs.elvis(gs.mc(gs.gp(gSobject.scope,"searchQuery"),"toLowerCase",[], null, true) , gs.mc(gs.gp(gSobject.scope,"searchQuery"),"toLowerCase",[], null, true) , "");
    if (!gs.bool(query)) {
      return gs.gp(gSobject.scope,"units");
     };
    return gs.mc(gs.gp(gSobject.scope,"units"),"findAll",[function(unit) {
      return (gs.mc(gs.mc(gs.gp(unit,"name"),"toLowerCase",[], null, true),"contains",[query], null, true)) || (gs.mc(gs.mc(gs.gp(unit,"code"),"toLowerCase",[], null, true),"contains",[query], null, true));
     }]);
   }
  gSobject['selectUnit'] = function(unit) {
    gs.sp(gSobject.scope,"selectedUnit",unit);
    gs.sp(gSobject.scope,"fromDate",null);
    gs.sp(gSobject.scope,"toDate",null);
    gs.sp(gSobject.scope,"fromTime","00:00");
    return gs.sp(gSobject.scope,"toTime","23:59");
   }
  gSobject['clearSelection'] = function(it) {
    return gs.sp(gSobject.scope,"selectedUnit",null);
   }
  gSobject['validateDateFilter'] = function(it) {
    if ((!gs.bool(gs.gp(gSobject.scope,"fromDate"))) || (!gs.bool(gs.gp(gSobject.scope,"toDate")))) {
      gs.mc(gSobject,"notify",["Please select both From and To dates", "warning"]);
      return false;
     };
    var from = gs.date(gs.gp(gSobject.scope,"fromDate"));
    var to = gs.date(gs.gp(gSobject.scope,"toDate"));
    var diffMs = gs.minus(gs.mc(to,"getTime",[]), gs.mc(from,"getTime",[]));
    var diffDays = Math.floor(gs.div(diffMs, (gs.multiply((gs.multiply((gs.multiply(1000, 60)), 60)), 24))));
    if (diffDays > 31) {
      gs.mc(gSobject,"notify",["Date range cannot exceed 31 days", "warning"]);
      return false;
     };
    if (diffDays < 0) {
      gs.mc(gSobject,"notify",["To date must be after From date", "warning"]);
      return false;
     };
    return true;
   }
  gSobject['exportTempHumidityPdf'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"validateDateFilter",[]))) {
      return null;
     };
    var a = gs.mc(gs.fs('document', this, gSobject),"createElement",["a"]);
    gs.sp(a,"href","/cwExportPdfReport/generatePdfReport/" + (gs.gp(gs.gp(gSobject.scope,"selectedUnit"),"_id")) + "");
    gs.sp(a,"download","report_{scope.selectedUnit.name}.pdf");
    gs.sp(gs.gp(a,"style"),"display","none");
    gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"appendChild",[a]);
    gs.mc(a,"click",[]);
    return gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"removeChild",[a]);
   }
  gSobject['exportTempHumidityCsv'] = function(it) {
    if (!gs.bool(gs.mc(gSobject,"validateDateFilter",[]))) {
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"selectedUnit"),"_id",true))) {
      gs.mc(gSobject,"notify",["Please select a unit first", "warning"]);
      return null;
     };
    gs.sp(gSobject.scope,"loading",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwExportService"),"exportUnitHistoryCsv",[gs.gp(gs.gp(gSobject.scope,"selectedUnit"),"_id"), gs.gp(gSobject.scope,"fromDate"), gs.gp(gSobject.scope,"toDate"), gs.gp(gSobject.scope,"fromTime"), gs.gp(gSobject.scope,"toTime"), function(payload) {
      gs.sp(gSobject.scope,"loading",false);
      if (!gs.bool(gs.gp(payload,"content",true))) {
        gs.mc(gSobject,"notify",["No export data was returned", "warning"]);
        return null;
       };
      gs.mc(gSobject,"downloadCsv",[gs.elvis(gs.bool(gs.gp(payload,"fileName")) , gs.gp(payload,"fileName") , "UnitHistory.csv"), gs.gp(payload,"content")]);
      return gs.mc(gSobject,"notify",["CSV exported" + ((gs.gp(payload,"rowCount") != null ? " (" + (gs.gp(payload,"rowCount")) + " rows)" : "")) + "", "positive"]);
     }]);
   }
  gSobject['downloadCsv'] = function(fileName, content) {
    var link = gs.mc(gs.fs('document', this, gSobject),"createElement",["a"]);
    var url = gs.plus("data:text/csv;charset=utf-8,", gs.mc(this,"encodeURIComponent",[gs.elvis(gs.bool(content) , content , "")], gSobject));
    gs.sp(link,"href",url);
    gs.sp(link,"download",fileName);
    gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"appendChild",[link]);
    gs.mc(link,"click",[]);
    return gs.mc(gs.gp(gs.fs('document', this, gSobject),"body"),"removeChild",[link]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function OrgDeactivatedComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'OrgDeactivatedComponent', simpleName: 'OrgDeactivatedComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/org-deactivated";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Account Inactive", false]);
    gs.sp(gSobject.scope,"organisation",gs.map());
    gs.sp(gSobject.scope,"deactivatedReason","");
    gs.sp(gSobject.scope,"state","");
    gs.sp(gSobject.scope,"loading",true);
    if ((gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId",true))) && (gs.mc(gs.fs('session', this, gSobject),"hasRole",[gs.list(["ROLE_ADMIN"])]))) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/"]);
      return null;
     };
    return gs.mc(gSobject,"loadStatus",[]);
   }
  gSobject['loadStatus'] = function(it) {
    if (!gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId",true))) {
      gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/cwlogin"]);
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"checkUserOrgStatus",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(status) {
      if (gs.bool(gs.gp(status,"notAssigned",true))) {
        gs.sp(gSobject.scope,"state","notAssigned");
        gs.sp(gSobject.scope,"loading",false);
        return null;
       };
      if (!gs.bool(gs.gp(status,"deactivated",true))) {
        gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/"]);
        return null;
       };
      gs.sp(gSobject.scope,"state","deactivated");
      gs.sp(gSobject.scope,"deactivatedReason",gs.elvis(gs.bool(gs.gp(status,"reason")) , gs.gp(status,"reason") , ""));
      if (gs.bool(gs.gp(status,"orgId"))) {
        return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"fetchOneByIdOrNew",[gs.gp(status,"orgId"), function(org) {
          gs.sp(gSobject.scope,"organisation",gs.elvis(gs.bool(org) , org , gs.map().add("name",gs.elvis(gs.bool(gs.gp(status,"orgName")) , gs.gp(status,"orgName") , ""))));
          return gs.sp(gSobject.scope,"loading",false);
         }]);
       } else {
        gs.sp(gSobject.scope,"organisation",gs.map().add("name",gs.elvis(gs.bool(gs.gp(status,"orgName")) , gs.gp(status,"orgName") , "")));
        return gs.sp(gSobject.scope,"loading",false);
       };
     }]);
   }
  gSobject['signOut'] = function(it) {
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"showLogout",true);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitsListComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'UnitsListComponent', simpleName: 'UnitsListComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/units-list";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Units", false]);
    gs.sp(gSobject.scope,"groups",gs.list([]));
    gs.sp(gSobject.scope,"orgs",gs.list([]));
    gs.sp(gSobject.scope,"loading",true);
    gs.sp(gSobject.scope,"searchQuery","");
    gs.sp(gSobject.scope,"orgFilter",null);
    gs.sp(gSobject.scope,"unassignedOnly",false);
    gs.sp(gSobject.scope,"showArchived",false);
    gs.sp(gSobject.scope,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    gs.sp(gSobject.scope,"canManage",((gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"])) || (gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_AGENT"]))));
    gs.sp(gSobject.scope,"expandedMap",gs.map());
    gs.sp(gSobject.scope,"dialogOpen",false);
    gs.sp(gSobject.scope,"dialogOrgId",null);
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","expand").add("label","").add("field","expand").add("align","left") , gs.map().add("name","name").add("label","Division").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","orgName").add("label","Organisation").add("field","orgName").add("align","left").add("sortable",true) , gs.map().add("name","unitCount").add("label","Units").add("field","unitCount").add("align","right").add("sortable",true)]));
    gs.sp(gSobject.scope,"pagination",gs.map().add("sortBy","name").add("descending",false).add("page",1).add("rowsPerPage",50));
    if (gs.bool(gs.gp(gSobject.scope,"canManage"))) {
      gs.mc(gSobject,"loadOrgs",[]);
     };
    return gs.mc(gSobject,"loadGroups",[]);
   }
  gSobject['loadOrgs'] = function(it) {
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"filteredOrganisations",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId")]),"then",[function(orgs) {
      return gs.sp(gSobject.scope,"orgs",gs.mc(gs.elvis(gs.bool(orgs) , orgs , gs.list([])),"collect",[function(it) {
        return gs.map().add("_id",gs.gp(it,"_id")).add("name",gs.elvis(gs.bool(gs.gp(it,"name")) , gs.gp(it,"name") , ""));
       }]));
     }, function(error) {
      return gs.sp(gSobject.scope,"orgs",gs.list([]));
     }]);
   }
  gSobject['loadGroups'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    var orgId = gs.gp(gSobject.scope,"orgFilter");
    var unassignedOnly = gs.equals(gs.gp(gSobject.scope,"unassignedOnly"), true);
    var showArchived = gs.equals(gs.gp(gSobject.scope,"showArchived"), true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"groupedUnitsForUser",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.scope,"searchQuery"), orgId, unassignedOnly, showArchived]),"then",[function(groups) {
      gs.sp(gSobject.scope,"groups",gs.elvis(gs.bool(groups) , groups , gs.list([])));
      gs.sp(gSobject.scope,"expandedMap",gs.map());
      return gs.sp(gSobject.scope,"loading",false);
     }, function(error) {
      gs.mc(gSobject,"notify",["Failed to load units", "negative"]);
      return gs.sp(gSobject.scope,"loading",false);
     }]);
   }
  gSobject['onUnassignedOnlyChange'] = function(value) {
    if (gs.bool(value)) {
      gs.sp(gSobject.scope,"orgFilter",null);
     };
    return gs.mc(gSobject,"loadGroups",[]);
   }
  gSobject['onShowArchivedChange'] = function(value) {
    return gs.mc(gSobject,"loadGroups",[]);
   }
  gSobject['toggleExpand'] = function(row) {
    var key = gs.mc(gs.gp(row,"_id"),"toString",[], null, true);
    if (!gs.bool(key)) {
      return null;
     };
    return (gs.gp(gSobject.scope,"expandedMap")[key]) = !gs.gp(gSobject.scope,"expandedMap")[key];
   }
  gSobject['selectUnit'] = function(unit) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[gs.plus((gs.plus("/unit-details/", gs.gp(unit,"_id"))), "/?tab=details")]);
   }
  gSobject['configureUnit'] = function(unit, orgId) {
    var effectiveOrgId = gs.elvis(gs.bool(orgId) , orgId , gs.elvis(gs.bool(gs.gp(gs.gp(unit,"org",true),"_id",true)) , gs.gp(gs.gp(unit,"org",true),"_id",true) , gs.gp(unit,"org",true)));
    if ((!gs.bool(effectiveOrgId)) || (!gs.bool(gs.gp(unit,"_id",true)))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/organisation/" + (effectiveOrgId) + "/unit/" + (gs.gp(unit,"_id")) + ""]);
   }
  gSobject['commHealthColor'] = function(status) {
    if (gs.equals(status, "healthy")) {
      return "positive";
     };
    if (gs.equals(status, "warning")) {
      return "warning";
     };
    if (gs.equals(status, "offline")) {
      return "negative";
     };
    return "grey";
   }
  gSobject['openAddDialog'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"canManage"))) {
      return null;
     };
    gs.sp(gSobject.scope,"dialogOrgId",null);
    return gs.sp(gSobject.scope,"dialogOpen",true);
   }
  gSobject['closeAddDialog'] = function(it) {
    return gs.sp(gSobject.scope,"dialogOpen",false);
   }
  gSobject['continueAddUnit'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"dialogOrgId"))) {
      return gs.mc(gSobject,"notify",["Please select an organisation", "negative"]);
     };
    gs.sp(gSobject.scope,"dialogOpen",false);
    return gs.mc(gSobject,"gotoNewUnit",[gs.gp(gSobject.scope,"dialogOrgId")]);
   }
  gSobject['gotoNewUnit'] = function(orgId) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/organisation/" + (orgId) + "/unit/new?tab=details"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminSensorDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminSensorDetailsComponent', simpleName: 'AdminSensorDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/sensor/:id";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Physical Sensor", true]);
    gs.sp(gSobject.scope,"assignedUnitName","");
    gs.sp(gSobject.scope,"sensor",gs.map());
    gs.sp(gSobject.scope,"orgId","");
    gs.sp(gSobject.scope,"orgs",gs.list([]));
    gs.sp(gSobject.scope,"deleteEnabled",(gs.gp(gs.gp(gSobject.route,"params"),"id") != "new"));
    gs.sp(gSobject.scope,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    gs.mc(gSobject,"loadOrgs",[]);
    return gs.mc(gSobject,"loadSensor",[]);
   }
  gSobject['loadOrgs'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"filteredOrganisations",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), "", function(orgs) {
      return gs.sp(gSobject.scope,"orgs",gs.mc(gs.elvis(gs.bool(orgs) , orgs , gs.list([])),"collect",[function(it) {
        return gs.map().add("_id",gs.gp(it,"_id")).add("name",gs.gp(it,"name"));
       }]));
     }]);
   }
  gSobject['loadSensor'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"fetchOneByIdOrNew",[gs.gp(gs.gp(gSobject.route,"params"),"id"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"sensor",data);
      gs.sp(gSobject.scope,"orgId",gs.elvis(gs.bool(gs.gp(gs.gp(gs.gp(gSobject.scope,"sensor"),"org"),"_id",true)) , gs.gp(gs.gp(gs.gp(gSobject.scope,"sensor"),"org"),"_id",true) , gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"sensor"),"org")) , gs.gp(gs.gp(gSobject.scope,"sensor"),"org") , "")));
      return gs.mc(gSobject,"loadAssignedUnit",[]);
     }]);
   }
  gSobject['loadAssignedUnit'] = function(it) {
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"sensor"),"_id"))) {
      gs.sp(gSobject.scope,"assignedUnitName","");
      gs.mc(gSobject,"updateTitle",[]);
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"assignedUnitNameForSensor",[gs.gp(gs.gp(gSobject.scope,"sensor"),"_id"), function(name) {
      gs.sp(gSobject.scope,"assignedUnitName",gs.elvis(gs.bool(name) , name , ""));
      return gs.mc(gSobject,"updateTitle",[]);
     }]);
   }
  gSobject['save'] = function(it) {
    if (((!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"sensor"),"mac"),"trim",[], null, true))) && (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"sensor"),"identifier"),"trim",[], null, true)))) && (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"sensor"),"serialNumber"),"trim",[], null, true)))) {
      gs.mc(gSobject,"notify",["A Mac Address, Sensor Identifier or Serial Number is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      gs.mc(gSobject,"notify",["Please select an organisation", "warning"]);
      return null;
     };
    gs.sp(gs.gp(gSobject.scope,"sensor"),"org",gs.gp(gSobject.scope,"orgId"));
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"save",[gs.gp(gSobject.scope,"sensor"), gs.gp(gs.fs('session', this, gSobject),"userId")]),"then",[function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"sensor",data);
      gs.sp(gSobject.scope,"orgId",gs.elvis(gs.bool(gs.gp(gs.gp(gs.gp(gSobject.scope,"sensor"),"org"),"_id",true)) , gs.gp(gs.gp(gs.gp(gSobject.scope,"sensor"),"org"),"_id",true) , gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"sensor"),"org")) , gs.gp(gs.gp(gSobject.scope,"sensor"),"org") , "")));
      gs.sp(gSobject.scope,"deleteEnabled",true);
      gs.mc(gSobject,"loadAssignedUnit",[]);
      return gs.mc(gSobject,"notify",["Physical Sensor Saved"]);
     }, function(error) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.mc(gSobject,"notify",[gs.elvis(gs.bool(gs.gp(error,"message",true)) , gs.gp(error,"message",true) , "Failed to save physical sensor"), "negative"]);
     }]);
   }
  gSobject['deleteSensor'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Confirmation").add("message","Are you sure you want to delete this physical sensor?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorService"),"remove",[gs.gp(gs.gp(gSobject.scope,"sensor"),"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Physical Sensor Deleted", "negative"]);
        return gs.mc(gSobject,"back",[]);
       }]);
     }]);
   }
  gSobject['updateTitle'] = function(it) {
    var unitLabel = gs.elvis(gs.bool(gs.gp(gSobject.scope,"assignedUnitName")) , gs.gp(gSobject.scope,"assignedUnitName") , "Unassigned");
    var sensorLabel = gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"sensor"),"name",true)) , gs.gp(gs.gp(gSobject.scope,"sensor"),"name",true) , "Physical Sensor");
    return gs.mc(gSobject,"setPageTitle",[gs.plus((gs.plus(unitLabel, " - ")), sensorLabel)]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwLogin() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'CwLogin', simpleName: 'CwLogin'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/cwlogin";
  gSobject.roles = "";
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"form",gs.map());
    gs.sp(gSobject.scope,"formStep","login");
    gs.sp(gSobject.scope,"isSubmitting",false);
    return gs.sp(gSobject.scope,"allowRegistration",false);
   }
  gSobject['onSubmitLogin'] = function(it) {
    if (gs.bool(gs.fs('allowRegistration', this, gSobject))) {
      return gs.mc(gSobject,"onSubmitRegister",[]);
     };
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username",gs.gp(gs.gp(gSobject.scope,"form"),"email"));
    gs.sp(gSobject.scope,"isSubmitting",true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"generatePinForExistingUser",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username")]),"then",[function(result) {
      gs.sp(gSobject.scope,"isSubmitting",false);
      gs.mc(gSobject,"switchForm",["pin"]);
      return gs.mc(gSobject,"notify",["Pin sent. Check your inbox"]);
     }, function(error) {
      gs.sp(gSobject.scope,"isSubmitting",false);
      return gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
     }]);
   }
  gSobject['onSubmitRegister'] = function(it) {
    gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username",gs.gp(gs.gp(gSobject.scope,"form"),"email"));
    gs.sp(gSobject.scope,"isSubmitting",true);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionAuthService"),"generatePinForNewOrExistingUser",[gs.gp(gs.gp(gSobject.scope,"form"),"email")]),"then",[function(result) {
      gs.sp(gSobject.scope,"isSubmitting",false);
      gs.mc(gSobject,"switchForm",["pin"]);
      return gs.mc(gSobject,"notify",["Pin sent. Check your inbox"]);
     }, function(error) {
      gs.sp(gSobject.scope,"isSubmitting",false);
      return gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
     }]);
   }
  gSobject['onSubmitPin'] = function(it) {
    gs.sp(gSobject.scope,"isSubmitting",true);
    return gs.mc(gs.fs('legionUserService', this, gSobject),"authWithPin",[gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"username"), gs.gp(gs.gp(gSobject.scope,"form"),"pin"), function(result) {
      gs.sp(gSobject.scope,"isSubmitting",false);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/"]);
     }, function(error) {
      gs.sp(gSobject.scope,"isSubmitting",false);
      return gs.mc(gSobject,"notify",[gs.gp(error,"message"), "negative"]);
     }]);
   }
  gSobject['switchForm'] = function(form) {
    gs.sp(gSobject.scope,"form",gs.map());
    return gs.sp(gSobject.scope,"formStep",form);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwDeactivatedGuard() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'CwDeactivatedGuard', simpleName: 'CwDeactivatedGuard'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/__cw_guard_internal__";
  gSobject.cache = null;
  gSobject.cacheUserId = null;
  gSobject.bypass = gs.list(["/cwlogin" , "/auth" , "/org-deactivated" , "/myClients" , "/__cw_guard_internal__"]);
  gSobject.registerWhenReady = function() {
    var self = this;
        function tryRegister() {
            if (typeof vue === 'undefined' || !vue.router) {
                setTimeout(tryRegister, 50);
                return;
            }
            vue.router.beforeEach(function(to) {
                return self.guard(to);
            });
            try { console.log('[CwGuard] installed'); } catch (e) {}

            var current = vue.router.currentRoute && vue.router.currentRoute.value;
            if (current) {
                var result = self.guard(current);
                if (typeof result === 'string') {
                    vue.router.replace(result);
                }
            }
        }
        tryRegister();
   }
  gSobject['guard'] = function(to) {
    if (gs.mc(gSobject.bypass,"contains",[gs.gp(to,"path")])) {
      return null;
     };
    if (!gs.bool(gs.gp(gs.fs('session', this, gSobject),"userId",true))) {
      return null;
     };
    if (gs.mc(gs.fs('session', this, gSobject),"hasRole",[gs.list(["ROLE_ADMIN"])])) {
      return null;
     };
    if (gs.mc(gs.fs('session', this, gSobject),"hasRole",[gs.list(["ROLE_AGENT"])])) {
      return gs.mc(gSobject,"agentGuard",[to]);
     };
    var userId = gs.gp(gs.fs('session', this, gSobject),"userId");
    if ((gs.bool(gSobject.cache)) && (gs.equals(gSobject.cacheUserId, userId))) {
      return (gs.mc(gSobject,"shouldBlock",[gSobject.cache]) ? "/org-deactivated" : null);
     };
    gs.println("[CwGuard] checking org status for " + (userId) + "");
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"checkUserOrgStatus",[userId, function(result) {
      gSobject.cache = gs.elvis(gs.bool(result) , result , gs.map().add("deactivated",false));
      gSobject.cacheUserId = userId;
      gs.println("[CwGuard] status " + (gSobject.cache) + "");
      if (gs.mc(gSobject,"shouldBlock",[gSobject.cache])) {
        return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/org-deactivated"]);
       };
     }]);
    return null;
   }
  gSobject['agentGuard'] = function(to) {
    gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"currentClient",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(result) {
      if (!gs.bool(gs.gp(result,"orgId",true))) {
        return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",["/myClients"]);
       };
     }]);
    return null;
   }
  gSobject['shouldBlock'] = function(status) {
    return (gs.bool(gs.gp(status,"deactivated",true))) || (gs.bool(gs.gp(status,"notAssigned",true)));
   }
  gSobject['CwDeactivatedGuard0'] = function(it) {
    gs.mc(gSobject,"registerWhenReady",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.CwDeactivatedGuard0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminOrganisationDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminOrganisationDetailsComponent', simpleName: 'AdminOrganisationDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/organisation/:id";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Organisation", true]);
    gs.sp(gSobject.scope,"tab",gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"tab",true)) , gs.gp(gs.gp(gSobject.route,"query"),"tab",true) , "details"));
    gs.sp(gSobject.scope,"visualTab",gs.gp(gSobject.scope,"tab"));
    gs.sp(gSobject.scope,"organisationId",gs.gp(gs.gp(gSobject.route,"params"),"id"));
    gs.sp(gSobject.scope,"organisation",gs.map());
    return gs.mc(gSobject,"loadOrganisation",[]);
   }
  gSobject['changeTab'] = function(name) {
    if (gs.equals(gs.gp(gSobject.scope,"tab"), name)) {
      gs.sp(gSobject.scope,"visualTab",name);
      return null;
     };
    if (gs.mc(gSobject,"isDirtyOwner",[])) {
      if (!gs.bool(gs.mc(gSobject,"confirmDiscard",[]))) {
        gs.sp(gSobject.scope,"visualTab",gs.gp(gSobject.scope,"tab"));
        return null;
       };
      gs.mc(gSobject,"discardDirtyOwner",[]);
     };
    gs.sp(gSobject.scope,"tab",name);
    gs.sp(gSobject.scope,"visualTab",name);
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.map().add("query",gs.map().add("tab",name))]);
   }
  gSobject.isDirtyOwner = function() {
    var slot = (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        if (!slot || typeof slot.isDirty !== 'function') return false;
        try { return !!slot.isDirty(); } catch (err) { return false; }
   }
  gSobject.discardDirtyOwner = function() {
    var slot = (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        if (slot && typeof slot.discard === 'function') {
            try { slot.discard(); } catch (err) {}
        }
   }
  gSobject.confirmDiscard = function() {
    return window.confirm('You have unsaved changes. Discard them?');
   }
  gSobject['loadOrganisation'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"fetchOneByIdOrNew",[gs.gp(gs.gp(gSobject.route,"params"),"id"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"organisation",data);
      gs.mc(gSobject,"setPageTitle",[gs.gp(gs.gp(gSobject.scope,"organisation"),"name")]);
      return gs.sp(gs.fs('session', this, gSobject),"orgName",gs.gp(gs.gp(gSobject.scope,"organisation"),"name"));
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorProfileMapsTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorProfileMapsTab', simpleName: 'SensorProfileMapsTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminProfileDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminProfileDetailsComponent', simpleName: 'AdminProfileDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/organisation/:orgId/profile/:id";
  Object.defineProperty(gSobject, 'TYPE_LABELS', { get: function() { return AdminProfileDetailsComponent.TYPE_LABELS; }, set: function(gSval) { AdminProfileDetailsComponent.TYPE_LABELS = gSval; }, enumerable: true });
  Object.defineProperty(gSobject, 'DIGITAL_TYPES', { get: function() { return AdminProfileDetailsComponent.DIGITAL_TYPES; }, set: function(gSval) { AdminProfileDetailsComponent.DIGITAL_TYPES = gSval; }, enumerable: true });
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["New Measurement Template", true]);
    gs.sp(gSobject.scope,"profile",gs.map());
    gs.sp(gSobject.scope,"deleteEnabled",(gs.gp(gs.gp(gSobject.route,"params"),"id") != "new"));
    gs.sp(gSobject.scope,"isDigital",false);
    return gs.mc(gSobject,"loadProfile",[]);
   }
  gSobject['loadProfile'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"fetchOneByIdOrNew",[gs.gp(gs.gp(gSobject.route,"params"),"id"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"profile",data);
      if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"profile"),"org"))) {
        gs.sp(gs.gp(gSobject.scope,"profile"),"org",gs.gp(gs.gp(gSobject.route,"params"),"orgId"));
       };
      gs.mc(gSobject,"refreshTypeState",[]);
      return gs.mc(gSobject,"updateTitle",[]);
     }]);
   }
  gSobject['refreshTypeState'] = function(it) {
    return gs.sp(gSobject.scope,"isDigital",gs.mc(AdminProfileDetailsComponent.DIGITAL_TYPES,"contains",[gs.gp(gs.gp(gSobject.scope,"profile"),"type")]));
   }
  gSobject['onTypeChange'] = function(it) {
    return gs.mc(gSobject,"refreshTypeState",[]);
   }
  gSobject['typeLabel'] = function(it) {
    return gs.elvis(AdminProfileDetailsComponent.TYPE_LABELS[gs.gp(gs.gp(gSobject.scope,"profile"),"type")] , AdminProfileDetailsComponent.TYPE_LABELS[gs.gp(gs.gp(gSobject.scope,"profile"),"type")] , "");
   }
  gSobject['save'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"save",[gs.gp(gSobject.scope,"profile"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"profile",data);
      gs.sp(gSobject.scope,"deleteEnabled",true);
      gs.mc(gSobject,"refreshTypeState",[]);
      gs.mc(gSobject,"updateTitle",[]);
      return gs.mc(gSobject,"notify",["Measurement Template Saved"]);
     }]);
   }
  gSobject['removeProfile'] = function(it) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Delete Confirmation").add("message","Are you sure you want to delete this measurement template?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwProfileService"),"remove",[gs.gp(gs.gp(gSobject.scope,"profile"),"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["Measurement Template Deleted", "negative"]);
        return gs.mc(gSobject,"back",[]);
       }]);
     }]);
   }
  gSobject['updateTitle'] = function(it) {
    return gs.mc(gSobject,"setPageTitle",[gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"profile"),"name")) , gs.gp(gs.gp(gSobject.scope,"profile"),"name") , "New Measurement Template")]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
AdminProfileDetailsComponent.TYPE_LABELS = gs.map().add("temperature","Temperature").add("humidity","Humidity").add("co2","CO2").add("digitalInput","Digital Input").add("digitalOutput","Digital Output");
AdminProfileDetailsComponent.DIGITAL_TYPES = gs.list(["digitalInput" , "digitalOutput"]);

function SensorProfileDetailsTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorProfileDetailsTab', simpleName: 'SensorProfileDetailsTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorProfileEventsTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorProfileEventsTab', simpleName: 'SensorProfileEventsTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function OnboardingWizardComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'OnboardingWizardComponent', simpleName: 'OnboardingWizardComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/onboarding";
  gSobject.roles = gs.list(["ROLE_ADMIN"]);
  Object.defineProperty(gSobject, 'TOTAL_STEPS', { get: function() { return OnboardingWizardComponent.TOTAL_STEPS; }, set: function(gSval) { OnboardingWizardComponent.TOTAL_STEPS = gSval; }, enumerable: true });
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"orgId","");
    gs.sp(gSobject.scope,"orgName","");
    gs.sp(gSobject.scope,"newOrgName","");
    gs.sp(gSobject.scope,"onboardingId","");
    gs.sp(gSobject.scope,"counts",gs.map().add("users",0).add("templates",0).add("sensors",0).add("units",0).add("bound",0).add("divisions",0));
    gs.sp(gSobject.scope,"divisions",gs.list([]));
    gs.sp(gSobject.scope,"newDivisionName","");
    gs.sp(gSobject.scope,"units",gs.list([]));
    gs.sp(gSobject.scope,"newUnit",gs.map().add("name","").add("code","").add("division",null));
    gs.sp(gSobject.scope,"unitDialogOpen",false);
    gs.sp(gSobject.scope,"bindDialogOpen",false);
    gs.sp(gSobject.scope,"selectedUnitId","");
    gs.sp(gSobject.scope,"selectedUnitName","");
    gs.sp(gSobject.scope,"unitColumns",gs.list([gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","code").add("label","IMEI / Serial").add("field","code").add("align","left") , gs.map().add("name","division").add("label","Division").add("field","division").add("align","left")]));
    gs.sp(gSobject.scope,"step",1);
    gs.mc(gSobject,"applyTitle",[]);
    var onboardingId = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"onboardingId")) , gs.gp(gs.gp(gSobject.route,"query"),"onboardingId") , ""),"toString",[]);
    if (gs.bool(onboardingId)) {
      gs.mc(gSobject,"showLoading",[]);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOnboardingService"),"resumableFor",[gs.gp(gs.fs('session', this, gSobject),"userId"), onboardingId, function(res) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(res,"ok",true))) {
          gs.sp(gSobject.scope,"onboardingId",onboardingId);
          gs.sp(gSobject.scope,"orgId",gs.mc(gs.elvis(gs.bool(gs.gp(res,"org")) , gs.gp(res,"org") , ""),"toString",[]));
          gs.sp(gSobject.scope,"orgName",gs.elvis(gs.bool(gs.gp(res,"orgName")) , gs.gp(res,"orgName") , ""));
          gs.sp(gSobject.scope,"step",gs.mc(gSobject,"clampStep",[gs.gp(res,"step")]));
          gs.mc(gSobject,"applyTitle",[]);
          return gs.mc(gSobject,"afterOrgLoaded",[]);
         } else {
          gs.mc(gSobject,"notify",["That onboarding could not be resumed", "warning"]);
          return gs.sp(gSobject.scope,"step",1);
         };
       }]);
      return null;
     };
    gs.sp(gSobject.scope,"orgId",gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"orgId")) , gs.gp(gs.gp(gSobject.route,"query"),"orgId") , ""),"toString",[]));
    var step = gs.mc(gSobject,"toInt",[gs.gp(gs.gp(gSobject.route,"query"),"step"), 1]);
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      step = 1;
     };
    gs.sp(gSobject.scope,"step",gs.mc(gSobject,"clampStep",[step]));
    if (gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      gs.mc(gSobject,"loadOrganisation",[]);
      return gs.mc(gSobject,"afterOrgLoaded",[]);
     };
   }
  gSobject['applyTitle'] = function(it) {
    return gs.mc(gSobject,"configurePage",[(gs.bool(gs.gp(gSobject.scope,"orgName")) ? "Setup Wizard - " + (gs.gp(gSobject.scope,"orgName")) + "" : "Setup Wizard"), true]);
   }
  gSobject['afterOrgLoaded'] = function(it) {
    gs.mc(gSobject,"loadCounts",[]);
    gs.mc(gSobject,"loadDivisions",[]);
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['loadOrganisation'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"fetchOneByIdOrNew",[gs.gp(gSobject.scope,"orgId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"orgName",gs.elvis(gs.bool(gs.gp(data,"name",true)) , gs.gp(data,"name",true) , ""));
      return gs.mc(gSobject,"applyTitle",[]);
     }]);
   }
  gSobject['createOrganisation'] = function(it) {
    var name = gs.mc(gs.gp(gSobject.scope,"newOrgName"),"trim",[], null, true);
    if (!gs.bool(name)) {
      return gs.mc(gSobject,"notify",["Please enter a name", "negative"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"legionOrganisationService"),"save",[gs.map().add("name",name).add("status","Active"), function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"orgId",gs.elvis(gs.mc(gs.gp(saved,"_id"),"toString",[], null, true) , gs.mc(gs.gp(saved,"_id"),"toString",[], null, true) , ""));
      gs.sp(gSobject.scope,"orgName",gs.elvis(gs.bool(gs.gp(saved,"name")) , gs.gp(saved,"name") , name));
      gs.mc(gSobject,"applyTitle",[]);
      gs.mc(gSobject,"afterOrgLoaded",[]);
      gs.mc(gSobject,"notify",["Organisation created"]);
      return gs.mc(gSobject,"goToStep",[2]);
     }]);
   }
  gSobject['nextStep'] = function(it) {
    return gs.mc(gSobject,"goToStep",[gs.plus(gs.gp(gSobject.scope,"step"), 1)]);
   }
  gSobject['prevStep'] = function(it) {
    return gs.mc(gSobject,"goToStep",[gs.minus(gs.gp(gSobject.scope,"step"), 1)]);
   }
  gSobject['goToStep'] = function(step) {
    if (((step < 1) || (step > OnboardingWizardComponent.TOTAL_STEPS)) || (gs.equals(step, gs.gp(gSobject.scope,"step")))) {
      return null;
     };
    if ((step > 1) && (!gs.bool(gs.gp(gSobject.scope,"orgId")))) {
      return gs.mc(gSobject,"notify",["Create the organisation first", "warning"]);
     };
    if (gs.mc(gSobject,"isDirtyOwner",[])) {
      if (gs.mc(gSobject,"ownerHasSave",[])) {
        gs.mc(gSobject,"callOwnerSave",[function(it) {
          return gs.mc(gSobject,"commitStep",[step]);
         }]);
        return null;
       };
      if (!gs.bool(gs.mc(gSobject,"confirmDiscard",[]))) {
        return null;
       };
      gs.mc(gSobject,"discardDirtyOwner",[]);
     };
    return gs.mc(gSobject,"commitStep",[step]);
   }
  gSobject['commitStep'] = function(step) {
    gs.sp(gSobject.scope,"step",step);
    gs.mc(gSobject,"persistProgress",[step]);
    gs.mc(gSobject,"refreshForStep",[step]);
    return gs.mc(gSobject,"syncUrl",[]);
   }
  gSobject['persistProgress'] = function(step) {
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOnboardingService"),"setStep",[gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.scope,"orgId"), step, function(r) {
      if ((gs.bool(gs.gp(r,"id",true))) && (!gs.bool(gs.gp(gSobject.scope,"onboardingId")))) {
        return gs.sp(gSobject.scope,"onboardingId",gs.gp(r,"id"));
       };
     }]);
   }
  gSobject['refreshForStep'] = function(step) {
    gs.mc(gSobject,"loadCounts",[]);
    if (gs.equals(step, 5)) {
      gs.mc(gSobject,"loadDivisions",[]);
      return gs.mc(gSobject,"loadUnits",[]);
     };
   }
  gSobject['loadCounts'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOnboardingService"),"orgSetupSummary",[gs.gp(gSobject.scope,"orgId"), function(s) {
      if (gs.bool(s)) {
        return gs.sp(gSobject.scope,"counts",s);
       };
     }]);
   }
  gSobject['loadDivisions'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchDivisionsByOrgId",[gs.gp(gSobject.scope,"orgId"), function(data) {
      return gs.sp(gSobject.scope,"divisions",gs.elvis(gs.bool(data) , data , gs.list([])));
     }]);
   }
  gSobject['addDivision'] = function(it) {
    var name = gs.mc(gs.gp(gSobject.scope,"newDivisionName"),"trim",[], null, true);
    if (!gs.bool(name)) {
      return gs.mc(gSobject,"notify",["Division name is required", "warning"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"saveDivision",[gs.map().add("org",gs.gp(gSobject.scope,"orgId")).add("name",name)]),"then",[function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.scope,"newDivisionName","");
      gs.mc(gSobject,"loadDivisions",[]);
      gs.mc(gSobject,"loadCounts",[]);
      return gs.mc(gSobject,"notify",["Division added"]);
     }, function(err) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.mc(gSobject,"notify",["Could not add division", "negative"]);
     }]);
   }
  gSobject['loadUnits'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchMany",[gs.map().add("org",gs.gp(gSobject.scope,"orgId")), function(data) {
      return gs.sp(gSobject.scope,"units",gs.elvis(gs.bool(data) , data , gs.list([])));
     }]);
   }
  gSobject['divisionName'] = function(u) {
    if ((!gs.bool(u)) || (!gs.bool(gs.gp(u,"division")))) {
      return "";
     };
    var did = (gs.bool(gs.gp(gs.gp(u,"division"),"_id")) ? gs.gp(gs.gp(u,"division"),"_id") : gs.gp(u,"division"));
    var d = gs.mc(gs.gp(gSobject.scope,"divisions"),"find",[function(it) {
      return gs.equals(gs.gp(it,"_id"), did);
     }]);
    return ((gs.bool(d)) && (gs.bool(gs.gp(d,"name"))) ? gs.gp(d,"name") : "");
   }
  gSobject['openAddUnit'] = function(it) {
    gs.sp(gSobject.scope,"newUnit",gs.map().add("name","").add("code","").add("division",(gs.equals(gs.mc(gs.gp(gSobject.scope,"divisions"),"size",[]), 1) ? gs.gp(gs.gp(gSobject.scope,"divisions")[0],"_id") : null)));
    return gs.sp(gSobject.scope,"unitDialogOpen",true);
   }
  gSobject['closeAddUnit'] = function(it) {
    return gs.sp(gSobject.scope,"unitDialogOpen",false);
   }
  gSobject['createUnit'] = function(it) {
    if (!gs.bool(gs.mc(gs.gp(gs.gp(gSobject.scope,"newUnit"),"name"),"trim",[], null, true))) {
      return gs.mc(gSobject,"notify",["Name is required", "warning"]);
     };
    if (!gs.bool(gs.mc(gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.scope,"newUnit"),"code")) , gs.gp(gs.gp(gSobject.scope,"newUnit"),"code") , ""),"toString",[]),"trim",[]))) {
      return gs.mc(gSobject,"notify",["IMEI / Serial is required", "warning"]);
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"newUnit"),"division"))) {
      return gs.mc(gSobject,"notify",["Division is required", "warning"]);
     };
    gs.mc(gSobject,"showLoading",[]);
    var payload = gs.map().add("org",gs.gp(gSobject.scope,"orgId")).add("name",gs.mc(gs.gp(gs.gp(gSobject.scope,"newUnit"),"name"),"trim",[])).add("code",gs.gp(gs.gp(gSobject.scope,"newUnit"),"code")).add("division",gs.gp(gs.gp(gSobject.scope,"newUnit"),"division")).add("status","Active");
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"save",[payload, gs.gp(gs.fs('session', this, gSobject),"userId"), function(saved) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.mc(gSobject,"notify",["Unit created"]);
      gs.sp(gSobject.scope,"unitDialogOpen",false);
      gs.sp(gSobject.scope,"newUnit",gs.map().add("name","").add("code","").add("division",null));
      gs.mc(gSobject,"loadUnits",[]);
      gs.mc(gSobject,"loadCounts",[]);
      return gs.mc(gSobject,"chooseUnit",[gs.mc(gs.gp(saved,"_id"),"toString",[], null, true), gs.elvis(gs.bool(gs.gp(saved,"name")) , gs.gp(saved,"name") , "")]);
     }]);
   }
  gSobject['onUnitRowClick'] = function(evt, row) {
    return gs.mc(gSobject,"chooseUnit",[gs.gp(row,"_id"), gs.elvis(gs.bool(gs.gp(row,"name")) , gs.gp(row,"name") , gs.gp(row,"code"))]);
   }
  gSobject['chooseUnit'] = function(id, name) {
    gs.sp(gSobject.scope,"selectedUnitId",gs.elvis(gs.bool(id) , id , ""));
    gs.sp(gSobject.scope,"selectedUnitName",gs.elvis(gs.bool(name) , name , ""));
    return gs.sp(gSobject.scope,"bindDialogOpen",true);
   }
  gSobject['closeBindDialog'] = function(it) {
    gs.sp(gSobject.scope,"bindDialogOpen",false);
    gs.mc(gSobject,"loadUnits",[]);
    return gs.mc(gSobject,"loadCounts",[]);
   }
  gSobject['finishWizard'] = function(it) {
    if (gs.mc(gSobject,"isDirtyOwner",[])) {
      if (gs.mc(gSobject,"ownerHasSave",[])) {
        gs.mc(gSobject,"callOwnerSave",[function(it) {
          return gs.mc(gSobject,"doFinish",[]);
         }]);
        return null;
       };
      if (!gs.bool(gs.mc(gSobject,"confirmDiscard",[]))) {
        return null;
       };
      gs.mc(gSobject,"discardDirtyOwner",[]);
     };
    return gs.mc(gSobject,"doFinish",[]);
   }
  gSobject['doFinish'] = function(it) {
    var orgId = gs.gp(gSobject.scope,"orgId");
    if (!gs.bool(orgId)) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOnboardingService"),"complete",[gs.gp(gs.fs('session', this, gSobject),"userId"), orgId, function(result) {
      gs.mc(gSobject,"notify",["Organisation setup complete"]);
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.map().add("path","/organisation/" + (orgId) + "").add("query",gs.toJavascript(gs.map().add("tab","details")))]);
     }]);
   }
  gSobject['saveAndExit'] = function(it) {
    if ((gs.mc(gSobject,"isDirtyOwner",[])) && (gs.mc(gSobject,"ownerHasSave",[]))) {
      gs.mc(gSobject,"callOwnerSave",[function(it) {
        return gs.mc(gSobject,"doExit",[]);
       }]);
      return null;
     };
    return gs.mc(gSobject,"doExit",[]);
   }
  gSobject['doExit'] = function(it) {
    gs.mc(gSobject,"persistProgress",[gs.gp(gSobject.scope,"step")]);
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/admin-tools"]);
   }
  gSobject['syncUrl'] = function(it) {
    var queryMap = gs.map().add("step",gs.gp(gSobject.scope,"step"));
    if (gs.bool(gs.gp(gSobject.scope,"orgId"))) {
      gs.sp(queryMap,"orgId",gs.gp(gSobject.scope,"orgId"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"onboardingId"))) {
      gs.sp(queryMap,"onboardingId",gs.gp(gSobject.scope,"onboardingId"));
     };
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.map().add("path","/onboarding").add("query",gs.toJavascript(queryMap))]);
   }
  gSobject['clampStep'] = function(s) {
    var n = gs.mc(gSobject,"toInt",[s, 1]);
    if (n < 1) {
      n = 1;
     };
    if (n > OnboardingWizardComponent.TOTAL_STEPS) {
      n = OnboardingWizardComponent.TOTAL_STEPS;
     };
    return n;
   }
  gSobject.toInt = function(value, fallback) {
    var n = parseInt(value, 10);
        return isNaN(n) ? fallback : n;
   }
  gSobject.isDirtyOwner = function() {
    var slot = (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        if (!slot || typeof slot.isDirty !== 'function') return false;
        try { return !!slot.isDirty(); } catch (err) { return false; }
   }
  gSobject.ownerHasSave = function() {
    var slot = (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        return !!(slot && typeof slot.save === 'function');
   }
  gSobject.callOwnerSave = function(done) {
    var slot = (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        if (slot && typeof slot.save === 'function') {
            try { slot.save(done); } catch (err) { done(); }
        } else { done(); }
   }
  gSobject.discardDirtyOwner = function() {
    var slot = (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        if (slot && typeof slot.discard === 'function') {
            try { slot.discard(); } catch (err) {}
        }
   }
  gSobject.confirmDiscard = function() {
    return window.confirm('You have unsaved changes. Discard them?');
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
OnboardingWizardComponent.TOTAL_STEPS = 8;

function AdminUsersListTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminUsersListTab', simpleName: 'AdminUsersListTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.props = gs.map().add("organisationId",String);
  gSobject.data = function(it) {
    return gs.map().add("searchText","").add("users",gs.list([])).add("filter",gs.map()).add("pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","name").add("descending",false)).add("canManage",false).add("roleOptions",gs.list(["Admin" , "Viewer"])).add("unitOptions",gs.list([])).add("unitNameById",gs.map()).add("expandedMap",gs.map()).add("dialogOpen",false).add("isNew",false).add("editing",gs.map()).add("userOptions",gs.list([])).add("filteredUserOptions",gs.list([])).add("selectedUser",null).add("addMode","existing").add("inviteEmail","");
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"columns",gs.list([gs.map().add("name","expand").add("label","").add("field","expand").add("align","left") , gs.map().add("name","email").add("label","Email").add("field","email").add("align","left").add("sortable",true) , gs.map().add("name","role").add("label","Role").add("field","role").add("align","left").add("sortable",true) , gs.map().add("name","actions").add("label","").add("field","actions").add("align","right")]));
    gs.mc(gSobject,"checkPermission",[]);
    gs.mc(gSobject,"loadUnitOptions",[]);
    return gs.mc(gSobject,"loadUsers",[]);
   }
  gSobject['activated'] = function(it) {
    gs.mc(gSobject,"loadUnitOptions",[]);
    return gs.mc(gSobject,"loadUsers",[]);
   }
  gSobject['checkPermission'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"isOrgAdmin",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.self,"organisationId"), function(result) {
      return gs.sp(gSobject.self,"canManage",result);
     }]);
   }
  gSobject['loadUnitOptions'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchMany",[gs.map().add("org",gs.gp(gSobject.self,"organisationId")), function(units) {
      var options = gs.mc(gs.elvis(gs.bool(units) , units , gs.list([])),"collect",[function(it) {
        return gs.map().add("_id",gs.gp(it,"_id")).add("name",gs.elvis(gs.bool(gs.gp(it,"name")) , gs.gp(it,"name") , gs.elvis(gs.bool(gs.gp(it,"code")) , gs.gp(it,"code") , "")));
       }]);
      gs.sp(gSobject.self,"unitOptions",options);
      var map = gs.map();
      gs.mc(options,"each",[function(it) {
        return (map[gs.mc(gs.gp(it,"_id"),"toString",[], null, true)]) = gs.gp(it,"name");
       }]);
      return gs.sp(gSobject.self,"unitNameById",map);
     }]);
   }
  gSobject['loadUsers'] = function(it) {
    gs.sp(gSobject.self,"filter",gs.map().add("org",gs.gp(gSobject.self,"organisationId")));
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"paginatedUsers",[gs.gp(gSobject.self,"searchText"), gs.gp(gSobject.self,"filter"), gs.gp(gSobject.self,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"users",gs.elvis(gs.bool(gs.gp(data,"users")) , gs.gp(data,"users") , gs.list([])));
      return gs.sp(gs.gp(gSobject.self,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['onRequest'] = function(props) {
    gs.sp(gSobject.self,"pagination",gs.gp(props,"pagination"));
    return gs.mc(gSobject,"loadUsers",[]);
   }
  gSobject['toggleExpand'] = function(row) {
    var key = gs.mc(gs.gp(row,"_id"),"toString",[], null, true);
    if (!gs.bool(key)) {
      return null;
     };
    return (gs.gp(gSobject.self,"expandedMap")[key]) = !gs.gp(gSobject.self,"expandedMap")[key];
   }
  gSobject['unitNamesFor'] = function(row) {
    var ids = gs.elvis(gs.bool(gs.gp(row,"assignedUnitIds",true)) , gs.gp(row,"assignedUnitIds",true) , gs.list([]));
    if (!gs.bool(ids)) {
      return gs.list([]);
     };
    return gs.mc(gs.mc(ids,"collect",[function(it) {
      return gs.elvis(gs.gp(gSobject.self,"unitNameById")[gs.mc(it,"toString",[], null, true)] , gs.gp(gSobject.self,"unitNameById")[gs.mc(it,"toString",[], null, true)] , "");
     }]),"findAll",[function(it) {
      return it;
     }]);
   }
  gSobject['filterUserOptions'] = function(val, update) {
    if (!gs.bool(val)) {
      gs.execCall(update, this, [function(it) {
        return gs.sp(gSobject.self,"filteredUserOptions",gs.gp(gSobject.self,"userOptions"));
       }]);
      return null;
     };
    var lower = gs.mc(gs.mc(val,"toString",[]),"toLowerCase",[]);
    return gs.execCall(update, this, [function(it) {
      return gs.sp(gSobject.self,"filteredUserOptions",gs.mc(gs.gp(gSobject.self,"userOptions"),"findAll",[function(u) {
        return (gs.bool(gs.gp(u,"email"))) && (gs.mc(gs.mc(gs.mc(gs.gp(u,"email"),"toString",[]),"toLowerCase",[]),"contains",[lower]));
       }]));
     }]);
   }
  gSobject['loadUserOptions'] = function(includeId) {
    if (includeId === undefined) includeId = null;
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"unassignedLegionUsers",[includeId, function(users) {
      gs.sp(gSobject.self,"userOptions",users);
      return gs.sp(gSobject.self,"filteredUserOptions",users);
     }]);
   }
  gSobject['openNew'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.self,"canManage"))) {
      return null;
     };
    gs.sp(gSobject.self,"isNew",true);
    gs.sp(gSobject.self,"editing",gs.map().add("org",gs.gp(gSobject.self,"organisationId")).add("role","Viewer").add("email","").add("assignedUnitIds",gs.list([])));
    gs.sp(gSobject.self,"selectedUser",null);
    gs.sp(gSobject.self,"addMode","existing");
    gs.sp(gSobject.self,"inviteEmail","");
    gs.mc(gSobject,"loadUserOptions",[]);
    return gs.sp(gSobject.self,"dialogOpen",true);
   }
  gSobject['openEdit'] = function(row) {
    if (!gs.bool(gs.gp(gSobject.self,"canManage"))) {
      return null;
     };
    gs.sp(gSobject.self,"isNew",false);
    gs.sp(gSobject.self,"editing",gs.map().add("_id",gs.gp(row,"_id")).add("org",gs.gp(gSobject.self,"organisationId")).add("role",gs.elvis(gs.bool(gs.gp(row,"role")) , gs.gp(row,"role") , "Viewer")).add("email",gs.elvis(gs.bool(gs.gp(row,"email")) , gs.gp(row,"email") , "")).add("assignedUnitIds",gs.mc(gs.elvis(gs.bool(gs.gp(row,"assignedUnitIds")) , gs.gp(row,"assignedUnitIds") , gs.list([])),"collect",[function(it) {
      return it;
     }])));
    gs.sp(gSobject.self,"selectedUser",null);
    return gs.sp(gSobject.self,"dialogOpen",true);
   }
  gSobject['saveDialog'] = function(it) {
    if (!gs.bool(gs.gp(gs.gp(gSobject.self,"editing"),"role"))) {
      return gs.mc(gSobject,"notify",["Please select a role", "negative"]);
     };
    if ((gs.bool(gs.gp(gSobject.self,"isNew"))) && (gs.equals(gs.gp(gSobject.self,"addMode"), "invite"))) {
      var email = gs.mc(gs.gp(gSobject.self,"inviteEmail"),"trim",[], null, true);
      if (!gs.bool(email)) {
        return gs.mc(gSobject,"notify",["Please enter an email", "negative"]);
       };
      gs.mc(gSobject,"showLoading",[]);
      gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"createUser",[email, gs.gp(gSobject.self,"organisationId"), gs.gp(gs.gp(gSobject.self,"editing"),"role"), function(result) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(result,"error",true))) {
          return gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
         };
        gs.mc(gSobject,"notify",["User created - invitation email sent"]);
        gs.sp(gSobject.self,"dialogOpen",false);
        return gs.mc(gSobject,"loadUsers",[]);
       }]);
      return null;
     };
    if ((gs.bool(gs.gp(gSobject.self,"isNew"))) && (!gs.bool(gs.gp(gSobject.self,"selectedUser")))) {
      return gs.mc(gSobject,"notify",["Please select a user", "negative"]);
     };
    if (gs.bool(gs.gp(gSobject.self,"isNew"))) {
      gs.sp(gs.gp(gSobject.self,"editing"),"email",gs.gp(gs.gp(gSobject.self,"selectedUser"),"email"));
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"saveOrgUser",[gs.gp(gSobject.self,"editing"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(data,"error",true))) {
        return gs.mc(gSobject,"notify",[gs.gp(data,"error"), "negative"]);
       };
      gs.mc(gSobject,"notify",[(gs.bool(gs.gp(gSobject.self,"isNew")) ? "User added" : "User saved")]);
      gs.sp(gSobject.self,"dialogOpen",false);
      return gs.mc(gSobject,"loadUsers",[]);
     }]);
   }
  gSobject['cancelDialog'] = function(it) {
    return gs.sp(gSobject.self,"dialogOpen",false);
   }
  gSobject['removeFromDialog'] = function(it) {
    if (!gs.bool(gs.gp(gs.gp(gSobject.self,"editing"),"_id"))) {
      return null;
     };
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Remove Confirmation").add("message","Are you sure you want to remove this user from the organisation?").add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"remove",[gs.gp(gs.gp(gSobject.self,"editing"),"_id"), function(it) {
        gs.mc(gSobject,"hideLoading",[]);
        gs.mc(gSobject,"notify",["User Removed", "negative"]);
        gs.sp(gSobject.self,"dialogOpen",false);
        return gs.mc(gSobject,"loadUsers",[]);
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminToolsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminToolsComponent', simpleName: 'AdminToolsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/admin-tools";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Admin Tools", false]);
    var initialTab = gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"tab")) , gs.gp(gs.gp(gSobject.route,"query"),"tab") , "organisations"),"toString",[]);
    gs.sp(gSobject.scope,"tab",initialTab);
    if (!gs.bool(gs.gp(gs.gp(gSobject.route,"query"),"tab"))) {
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"replace",[gs.map().add("path","/admin-tools").add("query",gs.toJavascript(gs.map().add("tab",initialTab)))]);
     };
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwMetricsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'CwMetricsComponent', simpleName: 'CwMetricsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/metrics";
  gSobject.roles = gs.list(["ROLE_ADMIN"]);
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Metrics", false]);
    gs.sp(gSobject.scope,"metrics",gs.list([gs.map().add("label","Fixes received").add("value","cw.fix.received") , gs.map().add("label","Fixes processed").add("value","cw.fix.processed") , gs.map().add("label","Alerts opened").add("value","cw.alert.opened") , gs.map().add("label","Alerts resolved").add("value","cw.alert.resolved") , gs.map().add("label","Alerts auto-resolved").add("value","cw.alert.autoResolved") , gs.map().add("label","Alert emails sent").add("value","cw.notification.email") , gs.map().add("label","In-app notifications").add("value","cw.notification.inapp") , gs.map().add("label","CSV exports").add("value","cw.export.csv") , gs.map().add("label","PDF reports").add("value","cw.export.pdf") , gs.map().add("label","Units created").add("value","cw.unit.created") , gs.map().add("label","Units archived").add("value","cw.unit.archived") , gs.map().add("label","Users created").add("value","cw.user.created") , gs.map().add("label","Orgs activated").add("value","cw.org.activated") , gs.map().add("label","Orgs deactivated").add("value","cw.org.deactivated") , gs.map().add("label","Agent client switches").add("value","cw.agent.clientSwitch")]));
    return gs.sp(gSobject.scope,"selectedMetric","cw.fix.received");
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminMyAccountComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminMyAccountComponent', simpleName: 'AdminMyAccountComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/myaccount";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["My Account", false]);
    gs.sp(gSobject.scope,"account",gs.map().add("email","").add("displayName","").add("orgUsers",gs.list([])));
    return gs.mc(gSobject,"loadAccount",[]);
   }
  gSobject['loadAccount'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"fetchMyAccount",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.sp(gSobject.scope,"account",gs.elvis(gs.bool(data) , data , gs.map().add("email","").add("displayName","").add("orgUsers",gs.list([]))));
     }]);
   }
  gSobject['logout'] = function(it) {
    return gs.sp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"showLogout",true);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwDirtyFormGuard() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'CwDirtyFormGuard', simpleName: 'CwDirtyFormGuard'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.registerWhenReady = function() {
    if (typeof vue !== 'undefined' && vue.scope && !vue.scope.dirtyForm) {
            vue.scope.dirtyForm = { isDirty: function() { return false; }, discard: function() {} };
        }

        if (!window.__cwDirtyFormBeforeUnload__) {
            window.__cwDirtyFormBeforeUnload__ = true;
            window.addEventListener('beforeunload', function(e) {
                if (checkDirty()) {
                    e.preventDefault();
                    e.returnValue = '';
                    return '';
                }
            });
        }

        function getSlot() {
            return (typeof vue !== 'undefined' && vue.scope) ? vue.scope.dirtyForm : null;
        }

        function checkDirty() {
            var slot = getSlot();
            if (!slot || typeof slot.isDirty !== 'function') return false;
            try { return !!slot.isDirty(); } catch (err) { return false; }
        }

        function discardSlot() {
            var slot = getSlot();
            if (slot && typeof slot.discard === 'function') {
                try { slot.discard(); } catch (err) {}
            }
        }

        // Single entry point: prompt once, and if the user agrees, drop the in-memory edits before
        // navigation actually happens. The keep-alive tab would otherwise still show the old values.
        function confirmAndDiscard() {
            if (!window.confirm('You have unsaved changes. Discard them?')) return false;
            discardSlot();
            return true;
        }

        function sameLocation(a, b) {
            try {
                var resolvedTo = vue.router.resolve(a);
                var resolvedFrom = b || vue.router.currentRoute.value;
                return resolvedTo.fullPath === resolvedFrom.fullPath;
            } catch (e) { return false; }
        }

        function tryRegister() {
            if (typeof vue === 'undefined' || !vue.router) {
                setTimeout(tryRegister, 50);
                return;
            }
            if (window.__cwDirtyFormGuardInstalled__) return;
            window.__cwDirtyFormGuardInstalled__ = true;

            // Backstop: browser back/forward + cross-route navigations
            vue.router.beforeEach(function(to, from) {
                if (to && from && to.fullPath === from.fullPath) return true;
                if (!checkDirty()) return true;
                return confirmAndDiscard();
            });

            // Primary: intercept all programmatic nav (q-route-tab uses router.replace
            // internally for query-only changes, where beforeEach often doesn't fire).
            var originalPush = vue.router.push.bind(vue.router);
            var originalReplace = vue.router.replace.bind(vue.router);

            vue.router.push = function(to) {
                if (sameLocation(to)) return originalPush(to);
                if (checkDirty() && !confirmAndDiscard()) return Promise.resolve(false);
                return originalPush(to);
            };
            vue.router.replace = function(to) {
                if (sameLocation(to)) return originalReplace(to);
                if (checkDirty() && !confirmAndDiscard()) return Promise.resolve(false);
                return originalReplace(to);
            };

            try { console.log('[CwDirtyFormGuard] installed (beforeEach + push/replace patch)'); } catch (e) {}
        }
        tryRegister();
   }
  gSobject['CwDirtyFormGuard0'] = function(it) {
    gs.mc(gSobject,"registerWhenReady",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.CwDirtyFormGuard0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminUnitsListTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminUnitsListTab', simpleName: 'AdminUnitsListTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.props = gs.map().add("organisationId",String);
  gSobject.data = function(it) {
    return gs.map().add("searchText","").add("units",gs.list([])).add("divisions",gs.list([])).add("divisionFilter",null).add("unassignedOnly",false).add("showArchived",false).add("filter",gs.map()).add("pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","_dateCreated").add("descending",false)).add("addDialogOpen",false).add("savingUnit",false).add("newUnitModel",gs.map());
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"columns",gs.list([gs.map().add("name","code").add("label","Code").add("field","code").add("align","left").add("sortable",true) , gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","division").add("label","Division").add("field",function(row) {
      return gs.elvis(gs.bool(gs.gp(gs.gp(row,"division"),"name",true)) , gs.gp(gs.gp(row,"division"),"name",true) , "");
     }).add("align","left").add("sortable",true) , gs.map().add("name","commHealth").add("label","Health").add("field","commHealth").add("align","left").add("sortable",true)]));
    gs.mc(gSobject,"loadDivisions",[]);
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['loadDivisions'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"fetchDivisionsByOrgId",[gs.gp(gSobject.self,"organisationId"), function(data) {
      return gs.sp(gSobject.self,"divisions",gs.elvis(gs.bool(data) , data , gs.list([])));
     }]);
   }
  gSobject['loadUnits'] = function(it) {
    var filter = gs.map().add("org",gs.gp(gSobject.self,"organisationId"));
    if (gs.bool(gs.gp(gSobject.self,"unassignedOnly"))) {
      gs.sp(filter,"division",null);
     } else {
      if (gs.bool(gs.gp(gSobject.self,"divisionFilter"))) {
        gs.sp(filter,"division",gs.gp(gSobject.self,"divisionFilter"));
       };
     };
    if (gs.bool(gs.gp(gSobject.self,"showArchived"))) {
      gs.sp(filter,"archived",gs.map().add("in",gs.list([true , false])));
     };
    gs.sp(gSobject.self,"filter",filter);
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"paginatedUnits",[gs.gp(gSobject.self,"searchText"), gs.gp(gSobject.self,"filter"), gs.gp(gSobject.self,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"units",gs.gp(data,"units"));
      return gs.sp(gs.gp(gSobject.self,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['applyDivisionFilter'] = function(value) {
    gs.sp(gSobject.self,"divisionFilter",value);
    if (gs.bool(value)) {
      gs.sp(gSobject.self,"unassignedOnly",false);
     };
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['applyUnassignedOnly'] = function(value) {
    gs.sp(gSobject.self,"unassignedOnly",value);
    if (gs.bool(value)) {
      gs.sp(gSobject.self,"divisionFilter",null);
     };
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['applyShowArchived'] = function(value) {
    gs.sp(gSobject.self,"showArchived",value);
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['onRequest'] = function(props) {
    return gs.mc(gSobject.self,"updatePagination",[gs.gp(props,"pagination")]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.self,"pagination",pagination);
    return gs.mc(gSobject,"loadUnits",[]);
   }
  gSobject['onRowClick'] = function(evt, row, index) {
    return gs.mc(gSobject.self,"selectUnit",[gs.gp(row,"_id")]);
   }
  gSobject['selectUnit'] = function(id) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/organisation/" + (gs.gp(gSobject.self,"organisationId")) + "/unit/" + (id) + ""]);
   }
  gSobject['openAddUnitDialog'] = function(it) {
    gs.mc(gSobject,"loadDivisions",[]);
    gs.sp(gSobject.self,"newUnitModel",gs.map().add("name","").add("code","").add("division",null).add("status","Active"));
    return gs.sp(gSobject.self,"addDialogOpen",true);
   }
  gSobject['cancelAddUnit'] = function(it) {
    return gs.sp(gSobject.self,"addDialogOpen",false);
   }
  gSobject['saveNewUnit'] = function(it) {
    var name = (gs.bool(gs.gp(gs.gp(gSobject.self,"newUnitModel"),"name",true)) ? gs.mc(gs.mc(gs.gp(gs.gp(gSobject.self,"newUnitModel"),"name"),"toString",[]),"trim",[]) : "");
    if (!gs.bool(name)) {
      gs.mc(gSobject,"notify",["Name is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.mc(gs.mc(gs.elvis(gs.bool(gs.gp(gs.gp(gSobject.self,"newUnitModel"),"code",true)) , gs.gp(gs.gp(gSobject.self,"newUnitModel"),"code",true) , ""),"toString",[]),"trim",[]))) {
      gs.mc(gSobject,"notify",["IMEI / Serial is required", "warning"]);
      return null;
     };
    if (!gs.bool(gs.gp(gs.gp(gSobject.self,"newUnitModel"),"division",true))) {
      gs.mc(gSobject,"notify",["Division is required", "warning"]);
      return null;
     };
    gs.sp(gSobject.self,"savingUnit",true);
    var payload = gs.map().add("org",gs.gp(gSobject.self,"organisationId")).add("name",name).add("code",gs.gp(gs.gp(gSobject.self,"newUnitModel"),"code",true)).add("division",gs.gp(gs.gp(gSobject.self,"newUnitModel"),"division",true)).add("status","Active");
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"save",[payload, gs.gp(gs.fs('session', this, gSobject),"userId"), function(saved) {
      gs.sp(gSobject.self,"savingUnit",false);
      gs.sp(gSobject.self,"addDialogOpen",false);
      gs.mc(gSobject,"notify",["Unit Created"]);
      return gs.mc(gSobject,"loadUnits",[]);
     }]);
   }
  gSobject['commHealthColor'] = function(status) {
    if (gs.equals(status, "healthy")) {
      return "positive";
     };
    if (gs.equals(status, "warning")) {
      return "warning";
     };
    if (gs.equals(status, "offline")) {
      return "negative";
     };
    return "grey";
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorProfileGraphsTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorProfileGraphsTab', simpleName: 'SensorProfileGraphsTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorProfileDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorProfileDetailsComponent', simpleName: 'SensorProfileDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/sensorProfile";
  gSobject['created'] = function(it) {
    return gs.mc(gSobject,"configurePage",["Sensor Profile", false]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function SensorProfilesListComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'SensorProfilesListComponent', simpleName: 'SensorProfilesListComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/sensorProfiles";
  gSobject['created'] = function(it) {
    return gs.mc(gSobject,"configurePage",["Sensor Profiles List", false]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminSensorProfilesListTab() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminSensorProfilesListTab', simpleName: 'AdminSensorProfilesListTab'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.props = gs.map().add("unitId",String).add("orgId",String);
  gSobject.data = function(it) {
    return gs.map().add("searchText","").add("sensorProfiles",gs.list([])).add("filter",gs.map()).add("pagination",gs.map().add("page",1).add("rowsPerPage",10).add("rowsNumber",0).add("sortBy","name").add("descending",false));
   };
  gSobject['created'] = function(it) {
    gs.sp(gSobject.self,"columns",gs.list([gs.map().add("name","name").add("label","Display Name").add("field","name").add("align","left").add("sortable",true).add("classes","text-weight-bold text-primary") , gs.map().add("name","sensor").add("label","Sensor").add("field",function(row) {
      return gs.elvis(gs.bool(gs.gp(gs.gp(row,"sensor"),"name",true)) , gs.gp(gs.gp(row,"sensor"),"name",true) , "-");
     }).add("align","left").add("sortable",false) , gs.map().add("name","profile").add("label","Measurement Template").add("field",function(row) {
      return gs.elvis(gs.bool(gs.gp(gs.gp(row,"profile"),"name",true)) , gs.gp(gs.gp(row,"profile"),"name",true) , "-");
     }).add("align","left").add("sortable",false) , gs.map().add("name","type").add("label","Type").add("field",function(row) {
      return gs.mc(gs.gp(gs.gp(row,"profile"),"type",true),"capitalize",[]);
     }).add("align","left").add("sortable",false)]));
    return gs.mc(gSobject,"loadSensorProfiles",[]);
   }
  gSobject['loadSensorProfiles'] = function(it) {
    gs.sp(gSobject.self,"filter",gs.map().add("unit",gs.gp(gSobject.self,"unitId")));
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwSensorProfileService"),"paginatedSensorProfiles",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(gSobject.self,"searchText"), gs.gp(gSobject.self,"filter"), gs.gp(gSobject.self,"pagination"), function(data) {
      gs.mc(gSobject,"hideLoading",[]);
      gs.sp(gSobject.self,"sensorProfiles",gs.gp(data,"sensorProfiles"));
      return gs.sp(gs.gp(gSobject.self,"pagination"),"rowsNumber",gs.gp(data,"totalRows"));
     }]);
   }
  gSobject['onRequest'] = function(props) {
    return gs.mc(gSobject.self,"updatePagination",[gs.gp(props,"pagination")]);
   }
  gSobject['updatePagination'] = function(pagination) {
    gs.sp(gSobject.self,"pagination",pagination);
    return gs.mc(gSobject,"loadSensorProfiles",[]);
   }
  gSobject['onRowClick'] = function(evt, row, index) {
    return gs.mc(gSobject.self,"selectSensorProfile",[gs.gp(row,"_id")]);
   }
  gSobject['selectSensorProfile'] = function(id) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/organisation/" + (gs.gp(gSobject.self,"orgId")) + "/sensorProfile/" + (id) + ""]);
   }
  gSobject['newSensorProfile'] = function(it) {
    return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",["/organisation/" + (gs.gp(gSobject.self,"orgId")) + "/sensorProfile/new?unitId=" + (gs.gp(gSobject.self,"unitId")) + ""]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function UnitDetailsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'UnitDetailsComponent', simpleName: 'UnitDetailsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/unit-details/:id";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Unit", true]);
    gs.sp(gSobject.scope,"unit",null);
    gs.sp(gSobject.scope,"loading",false);
    gs.sp(gSobject.scope,"tab","details");
    gs.sp(gSobject.scope,"unitId",gs.gp(gs.gp(gSobject.route,"params"),"id"));
    gs.sp(gSobject.scope,"unit",gs.map());
    return gs.mc(gSobject,"loadUnit",[]);
   }
  gSobject['loadUnit'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUnitService"),"fetchOneById",[gs.gp(gSobject.scope,"unitId"), function(result) {
      gs.sp(gSobject.scope,"unit",result);
      if (gs.bool(gs.gp(gs.gp(gSobject.scope,"unit"),"name",true))) {
        return gs.mc(gSobject,"configurePage",[gs.gp(gs.gp(gSobject.scope,"unit"),"name"), true]);
       };
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AgentMyClientsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AgentMyClientsComponent', simpleName: 'AgentMyClientsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/myClients";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["My Clients", false]);
    gs.sp(gSobject.scope,"clients",gs.list([]));
    gs.sp(gSobject.scope,"currentOrgId","");
    gs.sp(gSobject.scope,"loading",false);
    return gs.mc(gSobject,"loadClients",[]);
   }
  gSobject['loadClients'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"myClients",[gs.gp(gs.fs('session', this, gSobject),"userId"), function(result) {
      gs.sp(gSobject.scope,"loading",false);
      gs.sp(gSobject.scope,"clients",gs.elvis(gs.bool(gs.gp(result,"clients",true)) , gs.gp(result,"clients",true) , gs.list([])));
      return gs.sp(gSobject.scope,"currentOrgId",gs.elvis(gs.bool(gs.gp(result,"currentOrgId",true)) , gs.gp(result,"currentOrgId",true) , ""));
     }]);
   }
  gSobject['chooseClient'] = function(client) {
    if (!gs.bool(gs.gp(client,"orgId",true))) {
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"selectClient",[gs.gp(gs.fs('session', this, gSobject),"userId"), gs.gp(client,"orgId"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error",true))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      return gs.execStatic(CwBrowser,'reloadToRoot', this,[]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwBrandLoader() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'CwBrandLoader', simpleName: 'CwBrandLoader'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/__cw_brand_internal__";
  gSobject.appliedUserId = null;
  gSobject.registerWhenReady = function() {
    var self = this;
        function tryRegister() {
            if (typeof vue === 'undefined' || !vue.router) {
                setTimeout(tryRegister, 50);
                return;
            }
            vue.router.afterEach(function() { self.maybeApply(); });
            // Re-apply the current user's branding (e.g. Theme tab Save when editing your own org).
            window.__cwRefreshBrand = function() { self.forceApply(); };
            // Apply an explicit branding object to the shell (Theme tab live-preview of any org).
            window.__cwApplyBrand = function(b) { self.applyBrand(b || {}); };
            self.maybeApply();
        }
        tryRegister();
   }
  gSobject['maybeApply'] = function(it) {
    var userId = gs.gp(gs.fs('session', this, gSobject),"userId",true);
    if (!gs.bool(userId)) {
      if (gSobject.appliedUserId != null) {
        gSobject.appliedUserId = null;
        gs.mc(gSobject,"applyBrand",[gs.map()]);
       };
      return null;
     };
    if (gs.equals(gSobject.appliedUserId, userId)) {
      return null;
     };
    gSobject.appliedUserId = userId;
    if (gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"])) {
      gs.mc(gSobject,"applyBrand",[gs.map()]);
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwOrgService"),"getBrandingForUser",[userId, function(brand) {
      return gs.mc(gSobject,"applyBrand",[gs.elvis(gs.bool(brand) , brand , gs.map())]);
     }]);
   }
  gSobject['forceApply'] = function(it) {
    gSobject.appliedUserId = null;
    return gs.mc(gSobject,"maybeApply",[]);
   }
  gSobject['applyBrand'] = function(brand) {
    return gs.mc(gSobject,"applyShell",[gs.elvis(gs.bool(gs.gp(brand,"primaryColor")) , gs.gp(brand,"primaryColor") , ""), gs.elvis(gs.bool(gs.gp(brand,"secondaryColor")) , gs.gp(brand,"secondaryColor") , ""), gs.elvis(gs.bool(gs.gp(brand,"accentColor")) , gs.gp(brand,"accentColor") , ""), gs.elvis(gs.bool(gs.gp(brand,"appName")) , gs.gp(brand,"appName") , ""), gs.elvis(gs.bool(gs.gp(brand,"logoUrl")) , gs.gp(brand,"logoUrl") , ""), gs.elvis(gs.bool(gs.gp(brand,"logoDarkUrl")) , gs.gp(brand,"logoDarkUrl") , ""), gs.elvis(gs.bool(gs.gp(brand,"faviconUrl")) , gs.gp(brand,"faviconUrl") , ""), gs.elvis(gs.bool(gs.gp(brand,"font")) , gs.gp(brand,"font") , "")]);
   }
  gSobject.applyShell = function(primary, secondary, accent, appName, logo, logoDark, favicon, font) {
    try {
            if (typeof vue === 'undefined' || !vue.scope) return;
            var d = vue.scope.brandDefaults || {};
            if (!vue.scope.brand) vue.scope.brand = {};
            var title = appName || d.title;
            vue.scope.brand.title = title;
            vue.scope.brand.logo = logo || d.logo;
            vue.scope.brand.logoDark = logoDark || '';   // blank → drawer falls back to brand.logo
            try { document.title = title; } catch (e) {}
            if (typeof Quasar !== 'undefined' && Quasar.setCssVar) {
                Quasar.setCssVar('primary', primary || d.primary);
                Quasar.setCssVar('secondary', secondary || d.secondary);
                Quasar.setCssVar('accent', accent || d.accent);
            }
            try {
                var link = document.querySelector('link[rel~="icon"]');
                if (link) link.href = favicon || d.favicon || link.href;
            } catch (e) {}
            // Font: only override when the org set one. Inter (loaded by cwLayout) and Roboto (platform
            // CDN) are already available, so they need no injection. Blank/logout → clear the inline
            // override so admin.css's default (Inter) governs again.
            try {
                var fam = font || '';
                if (fam && fam !== 'Inter' && fam !== 'Roboto') {
                    var fid = 'cw-brand-font';
                    var href = 'https://fonts.googleapis.com/css2?family=' + encodeURIComponent(fam).replace(/%20/g, '+') + ':wght@300;400;500;700&display=swap';
                    var fl = document.getElementById(fid);
                    if (!fl) { fl = document.createElement('link'); fl.id = fid; fl.rel = 'stylesheet'; document.head.appendChild(fl); }
                    if (fl.href !== href) fl.href = href;
                }
                document.body.style.fontFamily = fam ? ("'" + fam + "', Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif") : '';
            } catch (e) {}
        } catch (e) {}
   }
  gSobject['CwBrandLoader0'] = function(it) {
    gs.mc(gSobject,"registerWhenReady",[]);
    return this;
  }
  if (arguments.length==0) {gSobject.CwBrandLoader0(); }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function CwNotificationsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'CwNotificationsComponent', simpleName: 'CwNotificationsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/notifications";
  gSobject['created'] = function(it) {
    gs.sp(gSobject.scope,"isAdmin",gs.mc(gs.fs('session', this, gSobject),"hasRole",["ROLE_ADMIN"]));
    var title = (gs.bool(gs.gp(gSobject.scope,"isAdmin")) ? "Notifications" : (gs.bool(gs.gp(gs.fs('session', this, gSobject),"orgName")) ? gs.plus(gs.gp(gs.fs('session', this, gSobject),"orgName"), " Notifications") : "Notifications"));
    gs.mc(gSobject,"configurePage",[title, false]);
    gs.sp(gSobject.scope,"loading",true);
    gs.sp(gSobject.scope,"notifications",gs.list([]));
    gs.sp(gSobject.scope,"filterOrg",null);
    gs.sp(gSobject.scope,"filterUnit",null);
    gs.sp(gSobject.scope,"filterStatus",null);
    gs.sp(gSobject.scope,"filterRead",false);
    gs.sp(gSobject.scope,"orgOptions",gs.list([]));
    gs.sp(gSobject.scope,"unitOptions",gs.list([]));
    gs.sp(gSobject.scope,"statusOptions",gs.list([]));
    gs.sp(gSobject.scope,"readOptions",gs.list([gs.map().add("value",false).add("label","Unread") , gs.map().add("value",true).add("label","Read") , gs.map().add("value","all").add("label","All")]));
    if (gs.bool(gs.gp(gSobject.scope,"isAdmin"))) {
      gs.mc(gSobject,"loadFilterOptions",[]);
     };
    return gs.mc(gSobject,"loadNotifications",[]);
   }
  gSobject['loadFilterOptions'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationService"),"fetchFilterOptions",[gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"), gs.gp(gs.fs('session', this, gSobject),"userId"), function(data) {
      gs.sp(gSobject.scope,"orgOptions",gs.elvis(gs.bool(gs.gp(data,"orgs")) , gs.gp(data,"orgs") , gs.list([])));
      gs.sp(gSobject.scope,"unitOptions",gs.elvis(gs.bool(gs.gp(data,"units")) , gs.gp(data,"units") , gs.list([])));
      return gs.sp(gSobject.scope,"statusOptions",gs.elvis(gs.bool(gs.gp(data,"statuses")) , gs.gp(data,"statuses") , gs.list([])));
     }]);
   }
  gSobject['loadNotifications'] = function(it) {
    gs.sp(gSobject.scope,"loading",true);
    var filter = gs.map();
    if (gs.bool(gs.gp(gSobject.scope,"filterOrg"))) {
      gs.sp(filter,"org",gs.gp(gSobject.scope,"filterOrg"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"filterUnit"))) {
      gs.sp(filter,"unit",gs.gp(gSobject.scope,"filterUnit"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"filterStatus"))) {
      gs.sp(filter,"alertStatus",gs.gp(gSobject.scope,"filterStatus"));
     };
    if (gs.gp(gSobject.scope,"filterRead") != "all") {
      gs.sp(filter,"read",gs.gp(gSobject.scope,"filterRead"));
     };
    gs.sp(filter,"zonerId",gs.gp(gs.gp(gs.fs('session', this, gSobject),"zoner"),"id"));
    gs.sp(filter,"userId",gs.gp(gs.fs('session', this, gSobject),"userId"));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationService"),"fetchFiltered",[filter, function(data) {
      gs.sp(gSobject.scope,"notifications",gs.elvis(gs.bool(data) , data , gs.list([])));
      gs.sp(gSobject.scope,"loading",false);
      if (gs.bool(gs.gp(gs.gp(gs.fs('vue', this, gSobject),"scope"),"refreshNotificationBadge"))) {
        return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"scope"),"refreshNotificationBadge",[]);
       };
     }]);
   }
  gSobject['onFilterChanged'] = function(it) {
    return gs.mc(gSobject,"loadNotifications",[]);
   }
  gSobject['clearFilters'] = function(it) {
    gs.sp(gSobject.scope,"filterOrg",null);
    gs.sp(gSobject.scope,"filterUnit",null);
    gs.sp(gSobject.scope,"filterStatus",null);
    gs.sp(gSobject.scope,"filterRead",false);
    return gs.mc(gSobject,"loadNotifications",[]);
   }
  gSobject['hasFilters'] = function(it) {
    return (((gs.bool(gs.gp(gSobject.scope,"filterOrg"))) || (gs.bool(gs.gp(gSobject.scope,"filterUnit")))) || (gs.bool(gs.gp(gSobject.scope,"filterStatus")))) || (gs.gp(gSobject.scope,"filterRead") != false);
   }
  gSobject['toggleRead'] = function(id, currentRead) {
    if (!gs.bool(id)) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationService"),"markAsRead",[id, !currentRead, function(data) {
      return gs.mc(gSobject,"loadNotifications",[]);
     }]);
   }
  gSobject['goToUnit'] = function(notification) {
    if (!gs.bool(notification)) {
      return null;
     };
    var unitId = gs.elvis(gs.bool(gs.gp(gs.gp(notification,"unit"),"_id",true)) , gs.gp(gs.gp(notification,"unit"),"_id",true) , gs.gp(notification,"unit"));
    if (gs.bool(unitId)) {
      return gs.mc(gs.gp(gs.fs('vue', this, gSobject),"router"),"push",[gs.plus((gs.plus("/unit-details/", unitId)), "?tab=eventSummary")]);
     };
   }
  gSobject['deleteNotification'] = function(id) {
    if (!gs.bool(id)) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationService"),"deleteOne",[id, function(data) {
      return gs.mc(gSobject,"loadNotifications",[]);
     }]);
   }
  gSobject['deleteAllFiltered'] = function(it) {
    var filter = gs.map();
    if (gs.bool(gs.gp(gSobject.scope,"filterOrg"))) {
      gs.sp(filter,"org",gs.gp(gSobject.scope,"filterOrg"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"filterUnit"))) {
      gs.sp(filter,"unit",gs.gp(gSobject.scope,"filterUnit"));
     };
    if (gs.bool(gs.gp(gSobject.scope,"filterStatus"))) {
      gs.sp(filter,"alertStatus",gs.gp(gSobject.scope,"filterStatus"));
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwNotificationService"),"deleteFiltered",[filter, function(data) {
      return gs.mc(gSobject,"loadNotifications",[]);
     }]);
   }
  gSobject['statusLabel'] = function(status) {
    if (gs.equals(status, "system-auto-resolved")) {
      return "Auto-Resolved";
     };
    if (!gs.bool(status)) {
      return "Active";
     };
    return gs.mc(gSobject,"capitalize",[status]);
   }
  gSobject['statusShadowColor'] = function(status) {
    if (gs.equals(status, "active")) {
      return "rgba(198,40,40,0.35)";
     };
    if ((gs.equals(status, "resolved")) || (gs.equals(status, "system-auto-resolved"))) {
      return "rgba(46,125,50,0.35)";
     };
    if (gs.equals(status, "snoozed")) {
      return "rgba(117,117,117,0.35)";
     };
    if (gs.equals(status, "acknowledged")) {
      return "rgba(2,136,209,0.35)";
     };
    return "rgba(117,117,117,0.35)";
   }
  gSobject['statusBadgeStyle'] = function(status) {
    return gs.plus("box-shadow: 0 1px 4px ", gs.mc(gSobject,"statusShadowColor",[status]));
   }
  gSobject['severityColor'] = function(severity) {
    if (gs.equals(severity, "alarm")) {
      return "negative";
     };
    return "warning";
   }
  gSobject['statusIcon'] = function(status) {
    if (gs.equals(status, "active")) {
      return "o_notification_add";
     };
    if (gs.equals(status, "acknowledged")) {
      return "o_visibility";
     };
    if (gs.equals(status, "snoozed")) {
      return "o_snooze";
     };
    if (gs.equals(status, "resolved")) {
      return "o_check_circle";
     };
    if (gs.equals(status, "system-auto-resolved")) {
      return "o_check_circle";
     };
    return "o_sync";
   }
  gSobject['statusColor'] = function(status) {
    if (gs.equals(status, "active")) {
      return "negative";
     };
    if ((gs.equals(status, "resolved")) || (gs.equals(status, "system-auto-resolved"))) {
      return "positive";
     };
    if (gs.equals(status, "snoozed")) {
      return "grey-6";
     };
    if (gs.equals(status, "acknowledged")) {
      return "info";
     };
    return "grey-7";
   }
  gSobject['capitalize'] = function(text) {
    if (!gs.bool(text)) {
      return "";
     };
    var s = gs.mc(text,"toString",[]);
    return gs.plus(gs.mc(gs.mc(s,"substring",[0, 1]),"toUpperCase",[]), gs.mc(s,"substring",[1]));
   }
  gSobject['alertDescription'] = function(message) {
    if (!gs.bool(message)) {
      return "-";
     };
    var s = gs.mc(message,"toString",[]);
    var dashIdx = gs.mc(s,"indexOf",[" - "]);
    if (dashIdx > 0) {
      return gs.mc(gs.mc(s,"substring",[0, dashIdx]),"trim",[]);
     };
    var onIdx = gs.mc(s,"indexOf",[" on "]);
    if (onIdx > 0) {
      return gs.mc(gs.mc(s,"substring",[0, onIdx]),"trim",[]);
     };
    return s;
   }
  gSobject['alertSensor'] = function(message) {
    if (!gs.bool(message)) {
      return "";
     };
    var s = gs.mc(message,"toString",[]);
    var dashIdx = gs.mc(s,"indexOf",[" - "]);
    if (dashIdx < 0) {
      return "";
     };
    var afterDash = gs.mc(s,"substring",[gs.plus(dashIdx, 3)]);
    var onIdx = gs.mc(afterDash,"indexOf",[" on "]);
    if (onIdx > 0) {
      return gs.mc(gs.mc(afterDash,"substring",[0, onIdx]),"trim",[]);
     };
    return gs.mc(afterDash,"trim",[]);
   }
  gSobject['formatDate'] = function(dateValue) {
    if (!gs.bool(dateValue)) {
      return "-";
     };
    var date = (gs.instanceOf(dateValue, "Date") ? dateValue : gs.date(gs.mc(dateValue,"toString",[])));
    return gs.mc(date,"format",["dd/MM/yyyy HH:mm"]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };

function AdminAgentsComponent() {
  var gSobject = RootComponent();
  gSobject.clazz = { name: 'AdminAgentsComponent', simpleName: 'AdminAgentsComponent'};
  gSobject.clazz.superclass = { name: 'RootComponent', simpleName: 'RootComponent'};
  gSobject.path = "/agents";
  gSobject['created'] = function(it) {
    gs.mc(gSobject,"configurePage",["Agents", false]);
    gs.sp(gSobject.scope,"agents",gs.list([]));
    gs.sp(gSobject.scope,"orgOptions",gs.list([]));
    gs.sp(gSobject.scope,"assignableUsers",gs.list([]));
    gs.sp(gSobject.scope,"showAssignDialog",false);
    gs.sp(gSobject.scope,"assign",gs.map().add("userId",null).add("orgId",null));
    gs.sp(gSobject.scope,"showManageDialog",false);
    gs.sp(gSobject.scope,"manageAgent",gs.map());
    gs.sp(gSobject.scope,"manageClients",gs.list([]));
    gs.sp(gSobject.scope,"manageAddOrgId",null);
    gs.sp(gSobject.scope,"columns",gs.list([gs.map().add("name","email").add("label","Email").add("field","email").add("align","left").add("sortable",true) , gs.map().add("name","name").add("label","Name").add("field","name").add("align","left").add("sortable",true) , gs.map().add("name","clientCount").add("label","Clients").add("field","clientCount").add("align","center").add("sortable",true) , gs.map().add("name","actions").add("label","").add("field","actions").add("align","right")]));
    gs.mc(gSobject,"loadAgents",[]);
    return gs.mc(gSobject,"loadOrgs",[]);
   }
  gSobject['loadAgents'] = function(it) {
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"listAgents",[function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      return gs.sp(gSobject.scope,"agents",gs.elvis(gs.bool(gs.gp(result,"agents",true)) , gs.gp(result,"agents",true) , gs.list([])));
     }]);
   }
  gSobject['loadOrgs'] = function(it) {
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwUserService"),"listAllOrganisations",[function(orgs) {
      return gs.sp(gSobject.scope,"orgOptions",gs.elvis(gs.bool(orgs) , orgs , gs.list([])));
     }]);
   }
  gSobject['openAssignDialog'] = function(it) {
    gs.sp(gSobject.scope,"assign",gs.map().add("userId",null).add("orgId",null));
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"assignableUsers",[function(result) {
      gs.sp(gSobject.scope,"assignableUsers",gs.elvis(gs.bool(gs.gp(result,"users",true)) , gs.gp(result,"users",true) , gs.list([])));
      return gs.sp(gSobject.scope,"showAssignDialog",true);
     }]);
   }
  gSobject['doAssign'] = function(it) {
    var a = gs.gp(gSobject.scope,"assign");
    if (!gs.bool(gs.gp(a,"userId"))) {
      gs.mc(gSobject,"notify",["Choose a user", "negative"]);
      return null;
     };
    if (!gs.bool(gs.gp(a,"orgId"))) {
      gs.mc(gSobject,"notify",["Choose a client", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"assignClient",[gs.gp(gs.fs('session', this, gSobject),"zonerId"), gs.gp(a,"userId"), gs.gp(a,"orgId"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error",true))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.sp(gSobject.scope,"showAssignDialog",false);
      gs.mc(gSobject,"notify",["Client assigned to agent"]);
      return gs.mc(gSobject,"loadAgents",[]);
     }]);
   }
  gSobject['openManageDialog'] = function(row) {
    gs.sp(gSobject.scope,"manageAgent",row);
    gs.sp(gSobject.scope,"manageAddOrgId",null);
    gs.sp(gSobject.scope,"manageClients",gs.list([]));
    gs.sp(gSobject.scope,"showManageDialog",true);
    return gs.mc(gSobject,"loadManageClients",[]);
   }
  gSobject['loadManageClients'] = function(it) {
    if (!gs.bool(gs.gp(gs.gp(gSobject.scope,"manageAgent"),"userId",true))) {
      return null;
     };
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"clientsForAgent",[gs.gp(gs.gp(gSobject.scope,"manageAgent"),"userId"), function(result) {
      return gs.sp(gSobject.scope,"manageClients",gs.elvis(gs.bool(gs.gp(result,"clients",true)) , gs.gp(result,"clients",true) , gs.list([])));
     }]);
   }
  gSobject['addManageClient'] = function(it) {
    if (!gs.bool(gs.gp(gSobject.scope,"manageAddOrgId"))) {
      gs.mc(gSobject,"notify",["Choose a client to add", "negative"]);
      return null;
     };
    gs.mc(gSobject,"showLoading",[]);
    return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"assignClient",[gs.gp(gs.fs('session', this, gSobject),"zonerId"), gs.gp(gs.gp(gSobject.scope,"manageAgent"),"userId"), gs.gp(gSobject.scope,"manageAddOrgId"), function(result) {
      gs.mc(gSobject,"hideLoading",[]);
      if (gs.bool(gs.gp(result,"error",true))) {
        gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
        return null;
       };
      gs.sp(gSobject.scope,"manageAddOrgId",null);
      gs.mc(gSobject,"notify",["Client added"]);
      gs.mc(gSobject,"loadManageClients",[]);
      return gs.mc(gSobject,"loadAgents",[]);
     }]);
   }
  gSobject['removeManageClient'] = function(client) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Remove Client").add("message",gs.plus((gs.plus("Remove \"", gs.elvis(gs.bool(gs.gp(client,"name")) , gs.gp(client,"name") , "this client"))), "\" from this agent? They will lose access to it.")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"unassignClient",[gs.gp(gs.gp(gSobject.scope,"manageAgent"),"userId"), gs.gp(client,"orgId"), function(result) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(result,"error",true))) {
          gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
          return null;
         };
        gs.mc(gSobject,"notify",["Client removed", "negative"]);
        gs.mc(gSobject,"loadManageClients",[]);
        return gs.mc(gSobject,"loadAgents",[]);
       }]);
     }]);
   }
  gSobject['removeAgent'] = function(row) {
    return gs.mc(gs.mc(gSobject.q,"dialog",[gs.map().add("title","Remove Agent").add("message",gs.plus((gs.plus("Remove agent status from \"", gs.elvis(gs.bool(gs.gp(row,"email")) , gs.gp(row,"email") , ""))), "\"? All their client assignments and current context will be cleared.")).add("cancel",true)]),"onOk",[function(it) {
      gs.mc(gSobject,"showLoading",[]);
      return gs.mc(gs.gp(gs.fs('o', this, gSobject),"cwAgentService"),"removeAgent",[gs.gp(row,"userId"), function(result) {
        gs.mc(gSobject,"hideLoading",[]);
        if (gs.bool(gs.gp(result,"error",true))) {
          gs.mc(gSobject,"notify",[gs.gp(result,"error"), "negative"]);
          return null;
         };
        gs.mc(gSobject,"notify",["Agent removed", "negative"]);
        return gs.mc(gSobject,"loadAgents",[]);
       }]);
     }]);
   }
  if (arguments.length == 1) {gs.passMapToObject(arguments[0],gSobject);};
  
  return gSobject;
 };
gs.println("GROOSCRIPT START : TransmissionBootstrapStart");
var transmission = Transmission;
var startupParams = StartupParams();
gs.mc(startupParams,"checkStartupAuth",[]);

gs.toGroovy = function(obj, objClass) {
    var result = obj;
    if (obj !== undefined && !(typeof(obj) === "function") && !(obj instanceof Date)) {
        if (obj instanceof Array) {
            result = gs.list([]);
            var i;
            for (i = 0; i < obj.length; i++) {
                result.add(gs.toGroovy(obj[i], objClass));
            }
        } else if (obj instanceof Date) {
            // console.log(obj);
            
        } else if (obj instanceof Object) {
            var ob;
            result = (objClass ? objClass() : gs.map());
            for (ob in obj) {
                result[ob] = gs.toGroovy(obj[ob]);
            }
        }
    }
    return result;
};
;

Array.prototype.add = function(pos, element) {
    if (element === undefined) {
        this.push(pos);
    } else {
        this.splice(pos, 0, element);
    }
    return this;
};
;
var session = gs.execStatic(Session,'instance', this,[]);
gs.sp(Socket,"window",window);
gs.sp(Socket,"navigator",navigator);
gs.execStatic(Socket,'init', this,[]);
gs.mc(window,"addEventListener",["online", function(it) {
  gs.println("ONLINE");
  return gs.execStatic(Socket,'reconnect', this,[]);
 }]);
gs.mc(gs.gp(window,"document"),"addEventListener",["visibilitychange", function(it) {
  if (gs.equals(gs.gp(gs.gp(gs.fs('window', this),"document"),"visibilityState"), "visible")) {
    gs.println("VISIBLE");
    return gs.execStatic(Socket,'reconnect', this,[]);
   };
 }]);
gs.mc(window,"addEventListener",["focus", function(it) {
  gs.println("FOCUS");
  return gs.execStatic(Socket,'reconnect', this,[]);
 }]);

Date.prototype.toJSON = function(){
    return moment(this).utc().toISOString();
};
;

String.prototype.endsWith = function(a) {
    return this.substring(this.length - a.length) === a;
};
;
gs.sp(Utils,"window",window);
gs.sp(Utils,"document",document);
var o = ObjectFinder();
var cordovaAppleSignIn = CordovaAppleSignIn();
var qrScanner = QRScanner();
var cordovaCamera = CordovaCamera();

if (!window.__devReloadInitDone) {
    vue = new VueApp()
    StartupParams.offlineStartFunction = vue.init
    StartupParams.onlineStartNoAuthFunction = vue.init
    StartupParams.onlineStartAuthSuccessFunction = vue.init
    vue.scope.toggleDarkMode = vue.toggleDarkMode
}
;

var sfcModuleLoadOptions = {
  moduleCache: {
    vue: Vue
  },
  async getFile(url) {
    
    const res = await fetch(url);
    if ( !res.ok )
      throw Object.assign(new Error(res.statusText + ' ' + url), { res });
    return {
      getContentData: asBinary => asBinary ? res.arrayBuffer() : res.text(),
    }
  },
  addStyle(textContent) {

    const style = Object.assign(document.createElement('style'), { textContent });
    const ref = document.head.getElementsByTagName('style')[0] || null;
    document.head.insertBefore(style, ref);
  },
}

var { loadModule } = window['vue3-sfc-loader'];
;
var legionLoginComponent = gs.mc(gs.mc(LegionLoginComponent(),"register",[]),"registerAsAuthComponent",[]);
gs.sp(startupParams,"onlineStartTokenAuthFailedFunction",gs.gp(vue,"init"));
var legionUserService = LegionUserService();
var cordovaDevice = CordovaDevice();
var cordovaDeepLink = CordovaDeepLink();
gs.mc(VueDateComponent(),"register",[]);
gs.mc(I3MenuButton(),"register",[]);
var unitDetailsTab = gs.mc(UnitDetailsTab(),"register",[]);
var cordovaSimBridge = CordovaSimBridge();
gs.mc(I3QrCode(),"register",[]);
var dashboardComponent = gs.mc(DashboardComponent(),"register",[]);
var adminSensorProfileDetailsComponent = gs.mc(AdminSensorProfileDetailsComponent(),"register",[]);
gs.mc(UnitTemperatureSensorsTab(),"register",[]);
gs.mc(CordovaErrorViewer(),"register",[]);
var cordovaPhoto = CordovaPhoto();
var adminConfigComponent = gs.mc(AdminConfigComponent(),"register",[]);
var reportsComponent = gs.mc(ReportsComponent(),"register",[]);
var unitFixHistoryTab = gs.mc(UnitFixHistoryTab(),"register",[]);
gs.mc(OrgDeactivatedComponent(),"register",[]);
var unitsListComponent = gs.mc(UnitsListComponent(),"register",[]);
var cordovaBle = gs.execStatic(CordovaBle,'instance', this,[]);
var cordovaBiometrics = CordovaBiometrics();
gs.mc(I3Input(),"register",[]);
gs.mc(AdminSensorDetailsComponent(),"register",[]);
gs.mc(UnitCarbonDioxideReadingsTab(),"register",[]);
var cwLogin = gs.mc(gs.mc(CwLogin(),"register",[]),"registerAsAuthComponent",[]);
var vueListSearchComponent = gs.mc(VueListSearchComponent(),"register",[]);
gs.mc(I3SidePanel(),"register",[]);
var unitEventsTab = gs.mc(UnitEventsTab(),"register",[]);
gs.mc(UnitSensorReadingsTab(),"register",[]);
gs.mc(CwDeactivatedGuard(),"register",[]);
var cordovaContacts = CordovaContacts();
gs.mc(AdminOrganisationDetailsComponent(),"register",[]);
var sensorProfileMapsTab = gs.mc(SensorProfileMapsTab(),"register",[]);
var cordovaCalendar = CordovaCalendar();
gs.mc(AuditTrailComponent(),"register",[]);
var cordovaGoogleSignIn = CordovaGoogleSignIn();
gs.mc(I3PageHeader(),"register",[]);
gs.mc(AdminProfileDetailsComponent(),"register",[]);
gs.mc(UnitIOReadingsTab(),"register",[]);
gs.mc(MetricGraphComponent(),"register",[]);
var dymicoAuthService = DymicoAuthService();
gs.mc(I3Table(),"register",[]);
var sensorProfileDetailsTab = gs.mc(SensorProfileDetailsTab(),"register",[]);
gs.mc(CordovaProblemReporter(),"register",[]);
var cordovaScreenCapture = CordovaScreenCapture();
gs.mc(VueMediaUploadComponent(),"register",[]);
var adminOrganisationsListComponent = gs.mc(AdminOrganisationsListComponent(),"register",[]);
var sensorProfileEventsTab = gs.mc(SensorProfileEventsTab(),"register",[]);
var cordovaShare = CordovaShare();
gs.mc(OnboardingWizardComponent(),"register",[]);
var cordovaPushNotification = CordovaPushNotification();
gs.mc(AdminUsersListTab(),"register",[]);
gs.mc(UnitTemperatureReadingTab(),"register",[]);
gs.mc(AdminToolsComponent(),"register",[]);
gs.mc(CwMetricsComponent(),"register",[]);
gs.mc(I3Media(),"register",[]);
gs.mc(I3Page(),"register",[]);
var unitMapsTab = gs.mc(UnitMapsTab(),"register",[]);
gs.mc(AdminAppConfigComponent(),"register",[]);
gs.mc(AdminMyAccountComponent(),"register",[]);
gs.mc(CwDirtyFormGuard(),"register",[]);
gs.mc(AdminUnitsListTab(),"register",[]);
var sensorProfileGraphsTab = gs.mc(SensorProfileGraphsTab(),"register",[]);
var cordovaBrowser = CordovaBrowser();
gs.mc(AdminRelayDestinationsComponent(),"register",[]);
gs.mc(VueDocumentViewer(),"register",[]);
gs.mc(I3Select(),"register",[]);
gs.mc(SensorGraphComponent(),"register",[]);
gs.mc(VueAdComponent(),"register",[]);
gs.mc(I3Toolbar(),"register",[]);
var sensorProfileDetailsComponent = gs.mc(SensorProfileDetailsComponent(),"register",[]);
var sensorProfilesListComponent = gs.mc(SensorProfilesListComponent(),"register",[]);
gs.mc(AdminCwUsersComponent(),"register",[]);
gs.mc(AdminOrgThemeTab(),"register",[]);
gs.mc(AdminSensorProfilesListTab(),"register",[]);
var unitDetailsComponent = gs.mc(UnitDetailsComponent(),"register",[]);
var cordovaI3Health = CordovaI3Health();
gs.mc(AgentMyClientsComponent(),"register",[]);
var legionRegisterComponent = gs.mc(LegionRegisterComponent(),"register",[]);
gs.mc(I3HeaderButton(),"register",[]);
gs.mc(AdminProfilesListTab(),"register",[]);
gs.mc(CwChart(),"register",[]);
gs.mc(WizardUnitBindTab(),"register",[]);
var legionPinComponent = gs.mc(LegionPinComponent(),"register",[]);
gs.mc(I3FormContainer(),"register",[]);
gs.mc(I3PageBody(),"register",[]);
var mapComponent = gs.mc(MapComponent(),"register",[]);
var cordovaSimBridgeAuth = CordovaSimBridgeAuth();
gs.mc(CwBrandLoader(),"register",[]);
gs.mc(I3Chart(),"register",[]);
gs.mc(AdminSensorsListTab(),"register",[]);
gs.mc(UnitHumidityReadingsTab(),"register",[]);
var cwNotificationsComponent = gs.mc(CwNotificationsComponent(),"register",[]);
gs.mc(AdminAgentsComponent(),"register",[]);
var cordovaMedia = CordovaMedia();
var rootComponent = gs.mc(RootComponent(),"init",[]);
gs.mc(AdminOrganisationDetailsTab(),"register",[]);
gs.execStatic(DevReload,'init', this,[]);
gs.mc(MyOrganisationRedirect(),"register",[]);
var cordovaFile = CordovaFile();
gs.mc(I3Container(),"register",[]);
var unitGraphsTab = gs.mc(UnitGraphsTab(),"register",[]);
var cordovaLocalNotification = CordovaLocalNotification();
var adminUnitDetailsComponent = gs.mc(AdminUnitDetailsComponent(),"register",[]);
gs.mc(UnitStatusTab(),"register",[]);
gs.mc(CwNotificationBadge(),"register",[]);
gs.mc(CwAgentSwitcher(),"register",[]);
gs.mc(I3DatePicker(),"register",[]);
gs.mc(I3BottomContainer(),"register",[]);
var cordovaHealth = CordovaHealth();
var fullMapComponent = gs.mc(FullMapComponent(),"register",[]);
var sensorsListComponent = gs.mc(SensorsListComponent(),"register",[]);
TransmissionBootstrapEnd();
gs.println("GROOSCRIPT END");

//# sourceMappingURL=/convert/dymicoScriptV2Map