@qikdev/sdk 0.1.169 → 0.1.180

package/src/api/qik.utils.js

@@ -0,0 +1,1410 @@
+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(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;
+}