@qikdev/sdk 0.1.168 → 0.1.169

package/src/api/qik.utils.js

@@ -1,1412 +0,0 @@
-import _get from 'lodash/get.js';
-import _isDate from 'lodash/isDate.js';
-import _startsWith from 'lodash/startsWith.js';
-import _isObject from 'lodash/isObject.js';
-import _camelCase from 'lodash/camelCase.js';
-import axios from 'axios';
-import { isBrowser, isNode } from 'browser-or-node';
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-const service = {};
-
-////////////////////////////////////
-
-const loadedExternalScripts = {}
-
-
-/**
- * A function that dynamically include an external javascript resource
- * ensuring that it will only be included once
- * @alias utils.loadExternalScript
- * @param  {String} url The url of the external script
- * @return {Promise}    A promise that will be resolved once the script has been loaded
- * @example 
- * 
- * await sdk.utils.loadExternalScript('https://cdn.javascript.com/external/script.js');
- */
-
-
-service.loadExternalScript = function(url) {
-
-    // If we already have a promise
-    if (loadedExternalScripts[url]) {
-        // return the existing promise
-        return loadedExternalScripts[url];
-    }
-
-
-    // Create a new promise
-    const promise = loadedExternalScripts[url] = new Promise(createNewScript);
-
-    function createNewScript(resolve, reject) {
-
-        if (!document) {
-            delete loadedExternalScripts[url];
-            return reject('document is undefined')
-        }
-
-        //////////////////////////////////////
-
-        var script = document.createElement('script');
-        script.type = 'text/javascript';
-        script.async = true;
-        script.onload = function() {
-            console.log('Loaded external script', url);
-            return resolve(url);
-        };
-        script.src = url;
-
-        // Inject it into the document's <head> tag
-        document.head.appendChild(script);
-
-    }
-
-    return promise;
-}
-
-
-const loadedExternalStyles = {}
-
-
-/**
- * A function that dynamically include an external css resource
- * ensuring that it will only be included once
- * @alias utils.loadExternalStyle
- * @param  {String} url The url of the external css
- * @return {Promise}    A promise that will be resolved once the css has been loaded
- * @example 
- * 
- * await sdk.utils.loadExternalStyle('https://cdn.css.com/external/style.css');
- */
-service.loadExternalStyle = function(url) {
-
-    const promise = new Promise(createNewScript);
-
-    function createNewScript(resolve, reject) {
-
-        if (!document) {
-            return reject('document is undefined')
-        }
-
-        if (loadedExternalStyles[url]) {
-            return resolve(url);
-        }
-
-        // Avoid duplicate scripts
-        loadedExternalStyles[url] = true;
-
-        //////////////////////////////////////
-
-        var script = document.createElement('link');
-        script.setAttribute('rel', 'stylesheet')
-        script.setAttribute('type', 'text/css')
-        script.setAttribute('href', url)
-        script.onload = function() {
-            console.log('Loaded external stylesheet', url);
-            return resolve(url);
-        };
-
-        // Inject it into the document's <head> tag
-        document.head.appendChild(script);
-
-    }
-
-    return promise;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-service.exists = function(value) {
-    var isUndefinedOrNull;
-
-    ////////////////////////
-
-    if (Array.isArray(value)) {
-        return true;
-    }
-
-    ////////////////////////
-
-    if (value === 0) {
-        return true;
-    }
-
-    ////////////////////////
-
-    switch (typeof value) {
-        case 'undefined':
-        case 'null':
-            isUndefinedOrNull = true;
-            break;
-        default:
-            var string = String(value).toLowerCase();
-            switch (string) {
-                case '':
-                case 'undefined':
-                case 'null':
-                    isUndefinedOrNull = true;
-                    break;
-            }
-            break;
-    }
-
-    return !!!isUndefinedOrNull;
-}
-
-//////////////////////////////////
-
-service.parseDate = function(input) {
-
-    if (!input) {
-        return;
-    }
-
-    if (_isDate(input)) {
-        return input;
-    }
-
-    //Attempt to create a date
-    var d = new Date(input);
-    var isValid = d instanceof Date && !isNaN(d);
-
-    if (isValid) {
-        return d;
-    }
-
-    return;
-}
-
-service.parseURL = function(string) {
-
-    if (!string) {
-        return false;
-    }
-
-    const relative = _startsWith(string, '/');
-    if (relative) {
-        return string;
-    }
-
-    if (_startsWith(string, '://')) {
-        return string;
-    }
-
-    if (_startsWith(string, 'mailto:')) {
-        return string;
-    }
-
-    if (_startsWith(string, 'tel:')) {
-        return string;
-    }
-
-    if (_startsWith(string, 'sms:')) {
-        return string;
-    }
-
-    //////////////////////////////////
-    //If someone entered an email by accident
-    var email = service.parseEmail(string);
-    //Convert it to a mailto link
-    if (email && email === string) {
-        return `mailto:${email}`
-    }
-
-    //////////////////////////////////
-
-    const withHttp = string => !/^https?:\/\//i.test(string) ? `http://${string}` : string;
-    string = withHttp(string);
-    //TODO: test this more.
-    string = string.replace(/\s/g, '');
-
-
-
-
-
-
-    var valid = RegExp('(https?:\\/\\/)?((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|((\\d{1,3}\\.){3}\\d{1,3}))(\\:\\d+)?(\\/[-a-z\\d%_.~+@]*)*(\\?[;&a-z\\d%_.~+=-@]*)?(\\#[-a-z\\d_@]*)?$', 'i').test(string);
-
-    if (!valid) {
-        return false;
-    }
-
-
-
-    ///////////////////////////
-
-    return withHttp(string)
-}
-
-
-///////////////////////////////////////////////
-
-service.parseNumber = function(input, decimalPoints) {
-    if (!input) {
-        return 0;
-    }
-
-    input = Number(input);
-    if (isNaN(input)) {
-        return 0;
-    }
-
-    if (decimalPoints) {
-        var str = input.toFixed(decimalPoints);
-        input = service.parseNumber(str);
-    }
-
-    return input;
-}
-
-
-service.isValidEmailAddress = function(email) {
-
-    var tester = /^[-!#$%&'*+\/0-9=?A-Z^_a-z`{|}~](\.?[-!#$%&'*+\/0-9=?A-Z^_a-z`{|}~])*@[a-zA-Z0-9](-*\.?[a-zA-Z0-9])*\.[a-zA-Z](-?[a-zA-Z0-9])+$/;
-
-    if (!email) return false;
-
-    var emailParts = email.split('@');
-
-    if (emailParts.length !== 2) return false
-
-    var account = emailParts[0];
-    var address = emailParts[1];
-
-    if (account.length > 64) return false
-
-    else if (address.length > 255) return false
-
-    var domainParts = address.split('.');
-    if (domainParts.some(function(part) {
-            return part.length > 63;
-        })) return false;
-
-
-    if (!tester.test(email)) return false;
-
-    return true;
-}
-
-
-service.parseEmail = function(input) {
-
-    if (!input) {
-        return false;
-    }
-
-    var lowercase = String(input).toLowerCase();
-    var valid = service.isValidEmailAddress(lowercase);
-
-    if (!valid) {
-        return false;
-    } else {
-        return lowercase;
-    }
-}
-
-//////////////////////////////////
-
-service.parseInt = function(input) {
-    if (!input) {
-        return 0;
-    }
-
-    input = parseInt(input);
-    if (isNaN(input)) {
-        return 0;
-    }
-
-    return input;
-}
-
-
-
-service.cleanValue = function(data, type, options) {
-
-    if (!options) {
-        options = {};
-    }
-
-    ////////////////////////
-
-    var noInputValue = service.exists(data);
-    if (options.strict && noInputValue && type != 'boolean') {
-        return data;
-    }
-
-    ////////////////////////
-
-    switch (type) {
-        case 'reference':
-            return service.id(data, true);
-            break;
-        case 'boolean':
-            return service.parseBoolean(data);
-            break;
-        case 'url':
-            return service.parseURL(data);
-            break;
-        case 'key':
-            return service.machineName(data);
-            break;
-        case 'email':
-            return service.parseEmail(data);
-            break;
-        case 'date':
-            var parsed = service.parseDate(data, options);
-
-            if (parsed === undefined) {
-                return;
-            } else {
-                return parsed;
-            }
-            break;
-        case 'number':
-        case 'decimal':
-        case 'float':
-            var val = service.parseNumber(data);
-            if (String(val) == String(Number(data))) {
-                return val;
-            }
-            return;
-            break;
-        case 'integer':
-            var val = service.parseInt(data);
-            if (String(val) == String(parseInt(data))) {
-                return val;
-            }
-            return;
-            break;
-        case 'group':
-            return data;
-            break;
-        case 'object':
-            if (_isObject(data) && !Array.isArray(data)) {
-                return data
-            }
-
-            return;
-            break;
-        case 'string':
-            if (service.exists(data)) {
-                var stringed = String(data);
-                if (stringed == '[object Object]') {
-                    return;
-                }
-
-                return stringed
-            } else {
-                return;
-            }
-
-            // if(!data) {
-            //     return '';
-            // }
-
-            // if(Array.isArray(data)) {
-            //      return JSON.stringify(data);
-            // }
-
-            // if(Object.isObject(data)) {
-            //     return JSON.stringify(data);
-            // }
-
-            // return String(data);
-
-            // break;
-        default:
-            return String(data)
-            break;
-    }
-}
-
-
-
-service.isValidValue = function(value, dataType, strict) {
-
-    var isValue = service.exists(value);
-    var valueIsNumber = (typeof value == 'number')
-
-    ////////////////////////
-
-    var isValidEntry = false;
-
-    if (!isValue) {
-        return false;
-    }
-
-    ////////////////////////
-
-    switch (dataType) {
-
-        case 'url':
-            if (strict) {
-                isValidEntry = _startsWith(value, '/') || _startsWith(value, '://') || _startsWith(value, 'http://') || _startsWith(value, 'https://');
-            } else {
-                isValidEntry = String(value) === service.parseURL(value);
-            }
-            break;
-        case 'key':
-            isValidEntry = String(value) === service.machineName(value);
-            break;
-        case 'date':
-
-            //If we are being strict
-            if (strict) {
-                //And the input is not a javascript date object
-                if (typeof value != 'object' || !_isDate(value)) {
-                    return false;
-                }
-            }
-
-            ///////////////////////////////
-            var parsed = service.parseDate(value);
-            return parsed !== undefined;
-            break;
-        case 'email':
-
-            if (strict) {
-                isValidEntry = value === service.parseEmail(value);
-            } else {
-                isValidEntry = String(value).toLowerCase() === service.parseEmail(value);
-            }
-
-            break;
-        case 'number':
-        case 'decimal':
-        case 'float':
-            if (strict) {
-                isValidEntry = valueIsNumber && (Number(value) === service.parseNumber(value));
-            } else {
-                isValidEntry = Number(value) === service.parseNumber(value);
-            }
-            break;
-        case 'integer':
-            if (strict) {
-                isValidEntry = valueIsNumber && (Number(value) === service.parseInt(value));
-            } else {
-                isValidEntry = Number(value) === service.parseInt(value);
-            }
-            break;
-        case 'boolean':
-
-            var parsed = service.parseBoolean(value);
-
-            //Only accept true booleans
-            if (strict) {
-                if (value === true || value === false) {
-                    isValidEntry = value === parsed;
-                }
-            } else {
-                isValidEntry = parsed === true || parsed === false;
-            }
-            break;
-        case 'reference':
-            if (strict) {
-                isValidEntry = String(value) === service.id(value);
-            } else {
-                isValidEntry = !!service.id(value);
-            }
-            break;
-        case 'string':
-            var checkString = String(value);
-            if (strict) {
-                if (typeof value != 'string') {
-                    return false;
-                }
-            }
-
-            if (checkString == '[object Object]') {
-                return false;
-            }
-
-            isValidEntry = true;
-            break;
-            // case 'group':
-            //     isValidEntry = _isObject(value);
-            //     break;
-        case 'object':
-
-
-            isValidEntry = _isObject(value) && !Array.isArray(value);
-            break;
-        case 'array':
-            isValidEntry = Array.isArray(value);
-            break;
-    }
-
-    ////////////////////////
-
-    return isValidEntry
-}
-
-service.parseBoolean = function(value) {
-    switch (String(value).toLowerCase()) {
-        case 'true':
-        case 'y':
-        case 'yes':
-        case '1':
-        case 't':
-            value = true;
-            break;
-        case 'false':
-        case 'n':
-        case 'no':
-        case '0':
-        case 'f':
-        case 'undefined':
-        case 'null':
-        case '':
-        case '-1':
-            value = false;
-            break;
-    }
-
-    return !!value;
-}
-
-
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-service.clone = function(input) {
-    return JSON.parse(JSON.stringify(input));
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-service.mapFields = function(fields, options) {
-
-    if (!options) {
-        options = {};
-    }
-
-    //////////////////////////////
-
-    var output = [];
-    var trail = [];
-    var titles = [];
-    var currentDepth = 1;
-    var depthLimit = options.depth;
-    var delimiter = options.arrayDelimeter || '[]';
-
-
-    //Loop through each field
-    fields.forEach(mapField);
-
-    //////////////////////////////
-
-    //Recursively map the fields
-    function mapField(field, i) {
-        var fieldKey = field.key;
-        var isGroup = field.type == 'group';
-        var singleValue = (field.minimum === field.maximum) && field.minimum === 1;
-        var asObject = field.asObject; // || (isGroup && singleValue);
-        var isLayout = isGroup && !asObject;
-
-        //////////////////////////////////
-
-        // Whether to clone the field or use the existing reference
-        var mapped = options.original ? field : service.clone(field);
-
-        mapped.trail = trail.slice();
-        mapped.trail.push(fieldKey)
-
-        mapped.path = mapped.trail.join('.');
-        mapped.titles = titles.slice();
-        mapped.titles.push(field.title || '')
-
-
-        const isNotLayoutOrIsAllowed = (!isLayout || options.includeLayout);
-
-        //If its an actual element or we've asked to include
-        //layout only elements
-        if (isNotLayoutOrIsAllowed) {
-            //Add it to the mix
-            output.push(mapped);
-        }
-
-        //////////////////////////////////
-
-        //Now see if there are child fields and should we go further
-        var limitHit = depthLimit && (currentDepth >= depthLimit);
-
-        //If there are child fields for this field
-        if (field.fields && field.fields.length) {
-            //If it's just a group with no extra key
-            if (isLayout) {
-                //Loop through fields as if they are at the same depth
-                field.fields.forEach(mapField)
-            } else {
-
-                //We don't need to traverse any further
-                //because we hit the limit
-                if (limitHit) {
-                    return;
-                }
-
-                //Move down a level and add to the object
-                //Include the key in the path trail
-                currentDepth++;
-
-                let injectKey = fieldKey;
-                if (options.includeArrayDelimeter) {
-                    if (!singleValue) {
-                        injectKey = `${fieldKey}${delimiter}`
-                    }
-                }
-                trail.push(injectKey)
-                titles.push(field.title);
-
-                //Loop through each field
-                field.fields.forEach(mapField)
-
-                //Move back up a level before we go to the next field
-                currentDepth--;
-                trail.pop();
-                titles.pop();
-            }
-
-        }
-
-    }
-
-    return output;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * A helpful function that can take a keyed object literal and map it to url query string parameters
- * @alias utils.mapParameters
- * @param  {Object} parameters The object you want to transalte
- * @return {String}            The query string
- * @example 
- * //Returns &this=that&hello=world
- * sdk.utils.mapParameters({"this":"that", "hello":"world"})
- */
-service.mapParameters = function(parameters) {
-
-    parameters = parameters || {}
-
-    var array = [];
-
-    Object.entries(parameters)
-    .forEach(function([key, value]) {
-
-        if (value === undefined || value === null || value == false) {
-            return;
-        }
-
-
-
-        if (Array.isArray(value)) {
-            value.forEach(function(v) {
-                array.push(`${key}=${encodeURIComponent(v)}`);
-            })
-        } else {
-            array.push(encodeURIComponent(key) + '=' + encodeURIComponent(String(value)));
-        }
-
-    })
-
-    return array.join('&');
-
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * A function that will take an integer and a currency string and return a formatted numeric amount rounded to 2 decimal places
- * @alias utils.formatCurrency
- * @param  {Integer} value The amount in cents
- * @param  {String} currency The currency to format
- * @return {String}            The formatted value
- * @example 
- * 
- * //Returns £10.00
- * sdk.utils.formatCurrency(1000, 'gbp');
- * 
- * //Returns $10.00
- * sdk.utils.formatCurrency(1000, 'usd');
- * 
- */
-service.formatCurrency = function(value, currency, decimalPoints) {
-
-    if (!value || isNaN(value)) {
-        value = 0;
-    }
-
-    decimalPoints = decimalPoints || 2;
-
-    var currencyPrefix = service.currencySymbol(currency);
-    return `${currencyPrefix}${parseFloat(Number(value) / 100).toFixed(decimalPoints)}`;
-
-}
-
-
-
-/**
- * A function that will take an id and return the type key
- * @alias utils.getTypeFromID
- * @param  {String} id The id of an object
- * @return {String}    The key
- * @example 
- * 
- * // Returns 'user'
- * sdk.utils.getTypeFromID('52b523f775beea960013f6cd');
- *
- * // Returns 'role'
- * sdk.utils.getTypeFromID('62b59cb572fb4772e7b5fa93');
- * 
- */
-service.getTypeFromID = function(id) {
-
-    id = service.id(id);
-
-    if (!id) {
-        return;
-    }
-
-    const lookup = {
-        "21": "organisation",
-        "23": "comment",
-        "24": "persona",
-        "25": "audio",
-        "26": "campaign",
-        "28": "smartlist",
-        "29": "cache",
-        "40": "application",
-        "41": "action",
-        "42": "billinginvoice",
-        "43": "componentsnapshot",
-        "44": "diff",
-        "45": "email",
-        "46": "submission",
-        "49": "import",
-        "53": "socket",
-        "54": "timetrigger",
-        "61": "article",
-        "63": "component",
-        "65": "event",
-        "66": "file",
-        "67": "tag",
-        "69": "image",
-        "70": "profile",
-        "72": "role",
-        "73": "scope",
-        "74": "transaction",
-        "75": "user",
-        "76": "video",
-        "77": "workflowcard",
-        "78": "variable",
-        "3c": "patoken",
-        "7b": "uatoken",
-        "7d": "urtoken",
-        "2d": "systemtask",
-        "3d": "export",
-        "5f": "systemflag",
-        "2b": "batch",
-        "3a": "log",
-        "2e": "stat",
-        "2f": "unsubscribe",
-        "6b": "intent",
-        "7c": "upload",
-        "2c": "systemtrigger",
-        "6e": "interface",
-        "4e": "interfacesnapshot",
-        "4f": "notification",
-        "2a": "definition",
-        "7e": "definitionsnapshot",
-        "5e": "integration",
-        "4c": "listener",
-        "6d": "topic",
-        "7a": "code",
-        "4d": "paymentmethod",
-        "6c": "sslcertificate"
-    }
-
-    var hexKey = id.slice(8, 10);
-    return lookup[hexKey];
-}
-
-
-/**
- * A function that will take a currency string and return the symbol
- * @alias utils.currencySymbol
- * @param  {String} currency The currency
- * @return {String}            The symbol
- * @example 
- * 
- * //Returns £
- * sdk.utils.currencySymbol('gbp');
- * 
- * //Returns $
- * sdk.utils.currencySymbol('usd');
- * 
- */
-service.currencySymbol = function(currency) {
-    //Ensure lowercase currency
-    currency = String(currency).toLowerCase();
-
-    switch (String(currency).toLowerCase()) {
-        case 'gbp':
-            return '£';
-            break;
-        case 'eur':
-            return '€';
-            break;
-        default:
-            return '$';
-            break;
-    }
-}
-
-
-
-service.getAvailableCurrencies = function(DefaultCountryID) {
-
-
-    var array = [];
-
-    array.push({
-        name: `USD (${service.currencySymbol("usd")})`,
-        value: "usd",
-        countryCode: { 'US': true },
-    });
-
-    array.push({
-        name: `GBP (${service.currencySymbol("gbp")})`,
-        value: "gbp",
-        countryCode: { 'GB': true, 'UK': true },
-    });
-
-    array.push({
-        name: `CAD (${service.currencySymbol("cad")})`,
-        value: "cad",
-        countryCode: { 'CA': true },
-    });
-
-    array.push({
-        name: `AUD (${service.currencySymbol("aud")})`,
-        value: "aud",
-        countryCode: { 'AU': true },
-    });
-
-
-    array.push({
-        name: `NZD (${service.currencySymbol("nzd")})`,
-        value: "nzd",
-        countryCode: { 'NZ': true },
-    });
-
-    array.push({
-        name: `SGD (${service.currencySymbol("sgd")})`,
-        value: "sgd",
-        countryCode: { 'SG': true },
-    });
-
-
-    if (DefaultCountryID) {
-
-        var findMatch = array.findIndex(function(currency) {
-            return currency.countryCode[DefaultCountryID];
-        })
-
-        const moveArrayItem = (array, fromIndex, toIndex) => {
-            const arr = [...array];
-            arr.splice(toIndex, 0, ...arr.splice(fromIndex, 1));
-            return arr;
-        }
-
-        if (findMatch != -1) {
-            array = moveArrayItem(array, findMatch, 0)
-        }
-    }
-
-    return array;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Creates a fast keyed hash object from an array of items
- * @alias utils.hash
- * @param  {Array} array The array of items to convert into a hash
- * @param  {String} key The key or path to the property on each item to use as the hashed key
- * @return {Object} A key/value paired object
- * @example 
- * //Returns { jimbo:{id:'jimbo', title:'Jim Jones'}, {id:'roger', title:'Roger Fellow'} }
- * sdk.utils.hash([{id:'jimbo', title:'Jim Jones'}, {id:'roger', title:'Roger Fellow'}], 'id');
- * 
- */
-service.hash = function(items, key) {
-    items = !Array.isArray(items) ? [] : items;
-    return items.reduce(function(memo, item) {
-        const k = _get(item, key);
-        memo[k] = item;
-        return memo;
-    }, {});
-}
-
-
-
-
-//////////////////////////////////////////////////
-
-/**
- * Returns a subset of values in an array that match a provided rule
- * @alias utils.extractFromArray
- * @param  {Array} array The array you want to extract values from
- * @param  {String} key The path to the child property you want to extract
- * @param  {Boolean} sum Whether to sum the extracted values together in total
- * @param  {Boolean} flatten Whether to flatten nested child arrays
- * @param  {Boolean} unique Whether to only return unique values
- * @param  {Boolean} exclude Whether to exclude null or undefined values
- * @param  {Object} options Pass through extra options for how to extract the values
- * @return {Array} An array of all values retrieved from the array, unless provided arguments require otherwise
- * @example 
- * //Returns [12, 45] as all the values
- * sdk.utils.extractFromArray([{name:'Wendy', age:12}, {name:'Roger', age:45}], 'age');
- * 
- * //Returns 32
- * sdk.utils.extractFromArray([{name:'Wendy', age:12}, {name:'Roger', age:20}], 'age', {sum:true});
- * 
- */
-service.extractFromArray = function(array, key, sum, flatten, unique, exclude, options) {
-
-    options = options || {}
-
-    if (sum) {
-        options.sum = sum;
-    }
-
-    if (flatten) {
-        options.flatten = true;
-    }
-
-    if (unique) {
-        options.unique = true;
-    }
-
-    if (exclude) {
-        options.excludeNull = true;
-    }
-
-    /////////////////
-
-    //Filter the array options by a certain value and operator
-    var extractedValues = array.reduce(function(set, entry) {
-        //Get the value from the object
-        var retrievedValue = _get(entry, key);
-
-        var isNull = (!retrievedValue && (retrievedValue !== false && retrievedValue !== 0));
-        if (options.excludeNull && isNull) {
-            return set;
-        }
-
-        set.push(retrievedValue);
-        return set;
-    }, [])
-
-    if (options.flatten) {
-        extractedValues = _.flatten(extractedValues);
-    }
-
-    if (options.unique) {
-        extractedValues = _.uniq(extractedValues);
-    }
-
-    if (options.sum) {
-        extractedValues = extractedValues.reduce(function(a, b) {
-            return a + b;
-        }, 0);
-    }
-
-    return extractedValues;
-}
-
-
-//////////////////////////////////////////////////////
-
-/**
- * A function that can return a selection of values that were found in an array that match a specific rule,
- * This is often used to evaluate expressions within form fields
- * @alias utils.matchInArray
- * @param  {Array} array The array to check
- * @param  {String} key The javascript dot notation path to extract
- * @param  {String} value The value to compare against
- * @param  {String} comparator The logical operator to use to compare the extracted value with the provided value ('>', '<', '>=', '<=', 'in', '==') Defaults to '==' (Is equal to)
- * @return {Array} Returns an array of matching values
- * @example 
- * //Returns [{name:'Michael', age:45}] as that is only item in the array that matches the criteria
- * sdk.utils.matchInArray([{name:'Wendy', age:12}, {name:'Michael', age:45}], 'age', 45, '>=');
- * 
- */
-service.matchInArray = function(array, key, v, comparator) {
-
-    //Filter the array options by a certain v and comparator
-    var matches = array.filter(function(entry) {
-        //Get the v from the object
-        var extracted = _get(entry, key);
-        var found;
-
-        switch (comparator) {
-            case 'in':
-                found = extracted.includes(v);
-                break;
-            case '>=':
-                found = (extracted >= v);
-                break;
-            case '<=':
-                found = (extracted <= v);
-                break;
-            case '<':
-                found = (extracted < v);
-                break;
-            case '>':
-                found = (extracted > v);
-                break;
-            case '==':
-            default:
-                if (v === undefined) {
-                    found = extracted;
-                } else {
-                    found = (extracted == v);
-                }
-                break;
-        }
-
-        return found;
-    })
-
-    return matches;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * A helpful class that can take an array of values and return them as a comma seperated
- * string, If the values are objects, then a property to use as the string representation can be specified
- * @alias utils.comma
- * @param  {Array} array The array of values to translate
- * @param  {String} path  An optional property key to use for each value
- * @return {String}       The resulting comma seperated string
- * @example
- * //Returns 'cat, dog, bird'
- * sdk.utils.comma(['cat', 'dog', 'bird']);
- * 
- * //Returns 'cat, dog, bird'
- * sdk.utils.comma([{title:'cat'}, {title:'dog'}, {title:'bird'}], 'title');
- */
-service.comma = function(array, path, limit) {
-
-    if (limit) {
-        array = array.slice(0, limit);
-    }
-
-    return _.chain(array)
-        .compact()
-        .map(function(item) {
-            if (path && path.length) {
-                return _get(item, path);
-            }
-
-            return item;
-        })
-        .value()
-        .join(', ');
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-//Helper function to get an id of an object
-
-/**
- * Returns a specified _id for an object
- * @alias utils.id
- * @param  {Object} input      An object that is or has an _id property
- * @param  {Boolean} asObjectID Whether to convert to a Mongo ObjectId
- * @return {String}            Will return either a string or a Mongo ObjectId
- *
- * @example
- *
- * //Returns '5cb3d8b3a2219970e6f86927'
- * sdk.utils.id('5cb3d8b3a2219970e6f86927')
- *
- * //Returns true
- * typeof service.id({_id:'5cb3d8b3a2219970e6f86927', title, ...}) == 'string';
-
- * //Returns true
- * typeof service.id({_id:'5cb3d8b3a2219970e6f86927'}, true) == 'object';
- */
-service.id = function(source) {
-
-    if (!source) {
-        return;
-    }
-
-    /////////////////////////////////
-
-    var output;
-
-    if (source._id) {
-        output = String(source._id);
-    } else {
-        output = String(source);
-    }
-
-
-    var isValid = service.isValidID(output);
-    if (!isValid) {
-        return;
-    }
-
-    return output;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Cleans and maps an array of objects to an array of IDs  
- * @alias utils.ids      
- * @param  {Array} array      An array of objects or object ids
- * @param  {Boolean} asObjectID Whether or not to map the ids as Mongo ObjectIds
- * @return {Array}            An array of Ids
- *
- * @example
- * //Returns ['5cb3d8b3a2219970e6f86927', '5cb3d8b3a2219970e6f86927', '5cb3d8b3a2219970e6f86927']
- * sdk.utils.ids([{_id:'5cb3d8b3a2219970e6f86927'}, {_id:'5cb3d8b3a2219970e6f86927'}, null, '5cb3d8b3a2219970e6f86927'])
- */
-
-service.ids = function(array) {
-
-    if (!array) {
-        return [];
-    }
-
-    /////////////////////////////////
-
-    var ids = Object.keys(array.reduce(function(set, entry) {
-
-        if (!entry) {
-            return set;
-        }
-
-        var cleaned = service.id(entry)
-
-        if (cleaned) {
-            set[cleaned] = 1;
-        }
-
-        return set;
-    }, {}))
-
-    ///////////////////////////////
-
-    return ids;
-}
-
-
-///////////////////////////////////////////////////////////////////////////////
-
-service.isValidID = function(input) {
-    var checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$")
-    return checkForHexRegExp.test(String(input));
-
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- * Helper function for retrieving a human readable error message from server error response objects
- * @alias utils.errorMessage
- * @param  {Object} error The error object to translate    
- * @return {String}     The resulting human readable error message
- */
-service.errorMessage = function(err) {
-
-    if (!err) {
-        return;
-    }
-
-
-    if (Array.isArray(err)) {
-        err = err[0];
-    }
-
-    ////////////////////////////////////
-
-
-    var candidates = [
-        'response.data.message',
-        'response.data',
-        'message',
-    ]
-
-    var message;
-
-    candidates.forEach(function(path) {
-        if (message) {
-            return;
-        }
-
-        var m = _get(err, path);
-        if (m) {
-            message = m;
-        }
-    })
-
-    if (Array.isArray(message)) {
-        message = message[0];
-    }
-
-    ////////////////////////////////////
-
-    message = message || JSON.stringify(err);
-
-    ////////////////////////////////////
-
-    return message;
-}
-
-////////////////////////////////////
-
-/**
- * Generates a globally unique ID, helpful for adding unique keys for iterable loops
- * @alias utils.guid
- * @return {String}            The new globally unique identifier
- * @example 
- * //Returns 4323a78br-z16h-289j-zwl1-938lda334asd
- * sdk.utils.guid()
- */
-service.guid = function() {
-    var u = (new Date()).getTime().toString(16) + Math.random().toString(16).substring(2) + "0".repeat(16);
-    return u.substr(0, 8) + '-' + u.substr(8, 4) + '-4000-8' + u.substr(12, 3) + '-' + u.substr(15, 12);
-}
-
-
-
-
-////////////////////////////////////
-////////////////////////////////////
-////////////////////////////////////
-
-/**
- * Helper function for cleaning strings to use as database ids
- * @alias utils.machineName
- * @param  {String} string The string to clean eg. (Awesome Event!)
- * @return {String}     A cleaned and formatted string eg. (awesomeEvent)
- */
-service.machineName = function(string) {
-
-    if (!string || !string.length) {
-        return;
-    }
-
-    var regexp = /[^a-zA-Z0-9-_]+/g;
-    var cleaned = String(string).replace(regexp, ' ').trim();
-    return _camelCase(cleaned);
-}
-
-/////////////////////////////////////////////
-/////////////////////////////////////////////
-/////////////////////////////////////////////
-
-
-export default service;
-
-
-/////////////////////////////////////////////
-
-//Export the event dispatcher
-export function EventDispatcher() {
-
-    var listeners = {};
-
-    /////////////////////////////////////////////
-
-    var dispatcher = {}
-
-    /////////////////////////////////////////////
-
-    //Remove all listeners
-    dispatcher.removeAllListeners = function() {
-        listeners = {};
-    }
-
-    /////////////////////////////////////////////
-
-    dispatcher.dispatch = function(event, details) {
-
-        if (listeners[event]) {
-            //For each listener
-            listeners[event].forEach(function(callback) {
-                return callback(details);
-            });
-        }
-    }
-
-    /////////////////////////////////////////////
-
-    dispatcher.addEventListener = function(event, callback) {
-
-        if (!listeners[event]) {
-            listeners[event] = [];
-        }
-
-        const type = typeof callback;
-        if (type !== 'function') {
-            throw new Error(`addEventListener() requires a function but ${type} was added`);
-        } else {
-            if (listeners[event].indexOf(callback) == -1) {
-                //Add to the listeners
-                listeners[event].push(callback)
-            } else {
-                //A
-                //lready listening
-            }
-        }
-    }
-
-    /////////////////////////////////////////////
-
-    dispatcher.removeEventListener = function(event, callback) {
-
-        if (!listeners[event]) {
-            listeners[event] = [];
-        }
-
-        //Get the index of the listener
-        var index = listeners[event].indexOf(callback);
-
-        if (index != -1) {
-            //Remove from the listeners
-            listeners[event].splice(index, 1);
-        }
-    }
-
-
-    /////////////////////////////////////////////
-
-    //Wrap the event listener functionality
-    dispatcher.bootstrap = function(service) {
-        if (!service) {
-            // console.log('No service to bootstrap to')
-            return;
-        }
-
-        service.dispatch = dispatcher.dispatch;
-        service.addEventListener = dispatcher.addEventListener;
-        service.removeEventListener = dispatcher.removeEventListener;
-        service.removeAllListeners = dispatcher.removeAllListeners;
-    }
-
-    /////////////////////////////////////////////
-
-    return dispatcher;
-}