@zzish/sdk-js 0.5.3 → 0.5.7

package/zzish.js

@@ -1,53 +1,51 @@
 // Global Zzish object
 (function () {
-
-
     Zzish = {};
 
-/**** FRONT END JAVASCRIPT STUFF (WITH STATE) ***/
+/** ** FRONT END JAVASCRIPT STUFF (WITH STATE) ** */
 
-//STATE THAT NEEDS TO BE TRACK PER USER (ON THE CLIENT SIDE)
+// STATE THAT NEEDS TO BE TRACK PER USER (ON THE CLIENT SIDE)
 
-    //appConfig
-    var appConfig;
-    //tracks this device
-    var deviceId;
-    //tracks a session (resets when a new user is selected)
-    var sessionId;
-    //the app Id (sandbox or production) generated from developer console (https://developer.zzish.com)
-    var appId;
-    //keep track of the current user (so we know when session needs to be updated)
-    var currentUser = null;
+    // appConfig
+    let appConfig;
+    // tracks this device
+    let deviceId;
+    // tracks a session (resets when a new user is selected)
+    let sessionId;
+    // the app Id (sandbox or production) generated from developer console (https://developer.zzish.com)
+    let appId;
+    // keep track of the current user (so we know when session needs to be updated)
+    let currentUser = null;
 
-    //store for storage
-    var dataStorage = {};
+    // store for storage
+    const dataStorage = {};
 
-    //Socket Info
-    var WebSocket;
+    // Socket Info
+    let WebSocket;
     if (stateful() && window !== undefined) {
         WebSocket = window.WebSocket || window.MozWebSocket;
     }
-    var opencallback;
-    var errorcallback;
-    var messagecallback;
-    var connection;
-
-
-/**** CONFIGURATION ******/
-
-    var defaultProtocol = "https://";
-    var baseUrl = "zapi.zzish.com/";
-    var webUrl = "https://live.zzish.com/";
-    var logEnabled = false;
-    var header = "X-api-key";
-    var headerprefix = "";
-    var makeStateless = false;
-    var socketUrl = "socket.zzish.com";
-    var connectedToSocket;
-    var currentSocketRetry = 0;
-    var maxSocketRetry = 10;
-
-    var getDataValue = function(key) {
+    let opencallback;
+    let errorcallback;
+    let messagecallback;
+    let connection;
+
+
+/** ** CONFIGURATION ***** */
+
+    let defaultProtocol = "https://";
+    let baseUrl = "zapi.zzish.com/";
+    let webUrl = "https://live.zzish.com/";
+    let logEnabled = false;
+    let header = "X-api-key";
+    let headerprefix = "";
+    const makeStateless = false;
+    let socketUrl = "socket.zzish.com";
+    let connectedToSocket;
+    let currentSocketRetry = 0;
+    const maxSocketRetry = 10;
+
+    const getDataValue = function (key) {
         if (dataStorage[key]) {
             return dataStorage[key];
         }
@@ -55,47 +53,43 @@
             if (typeof localStorage !== "undefined") {
                 return localStorage.getItem(key);
             }
-        }
-        catch (err) {
+        } catch (err) {
 
         }
         return undefined;
     };
 
-    var setDataValue = function(key, value) {
+    const setDataValue = function (key, value) {
         dataStorage[key] = value;
         try {
             if (typeof localStorage !== "undefined") {
                 return localStorage.setItem(key, value);
             }
-        }
-        catch (err) {
+        } catch (err) {
 
         }
     };
 
-    var removeDataValue = function(key) {
+    const removeDataValue = function (key) {
         delete dataStorage[key];
         try {
             if (typeof localStorage !== "undefined") {
                 localStorage.removeItem(key);
             }
-        }
-        catch (err) {
+        } catch (err) {
 
         }
     };
 
-    var clearDataValue = function() {
-        for (var i in dataStorage) {
+    const clearDataValue = function () {
+        for (const i in dataStorage) {
             delete dataStorage[i];
         }
         try {
             if (typeof localStorage !== "undefined") {
                 localStorage.clear();
             }
-        }
-        catch (err) {
+        } catch (err) {
 
         }
     };
@@ -104,9 +98,9 @@
      * Checks to see if localStorage is defined. Then it's a stateful session
      */
     function stateful() {
-        //if localstorage is not defined
-        if (makeStateless) return false;
-        return (typeof localStorage != 'undefined');
+        // if localstorage is not defined
+        // if (makeStateless) return false;
+        return (typeof localStorage !== "undefined");
     }
 
 
@@ -124,14 +118,14 @@
 
 
     function getQueryParams() {
-        var params = {}, tokens,
+        let params = {},
+            tokens,
             re = /[?&]?([^=]+)=([^&]*)/g;
         try {
-            var qs = "";
+            let qs = "";
             if (location.search!="") {
                 qs = location.search;
-            }
-            else if (location.hash!="") {
+            } else if (location.hash!="") {
                 qs = location.hash;
                 indexOf = qs.indexOf("?");
                 qs = qs.substring(indexOf+1);
@@ -141,68 +135,51 @@
                 params[decodeURIComponent(tokens[1])]
                     = decodeURIComponent(tokens[2]);
             }
-        }
-        catch (err) {
+        } catch (err) {
 
         }
         return params;
     }
 
-    function getConfigValue(config,field,originalValue) {
+    function getConfigValue(config, field, originalValue) {
         if (config[field]!=undefined) return config[field];
         return originalValue;
     }
 
-    var sendEvent = function(event, callback) {
-        var request = {
-            method: "POST",
-            url: getBaseUrl() + "statements/events",
-            data: {
-                platform : "js",
-                action: "START",
-                appId: appId
-            }
-        };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, callback);
-        });
-    }
+    // REMOVED: sendEvent() function - AppEvents functionality disabled to reduce MongoDB costs
+    // const sendEvent = function (event, callback) { ... } // No longer needed
 
     /**
      * Initialise Zzish instance
      */
     Zzish.init = function (config) {
-        //generate a device if we don't have one
+        // generate a device if we don't have one
         appConfig = config;
         deviceId = getDataValue("deviceId");
         if (deviceId == null) {
             deviceId = v4();
             setDataValue("deviceId", deviceId);
         }
-        if (typeof config =='string') {
-            try
-            {
+        if (typeof config ==="string") {
+            try {
                 config = JSON.parse(config);
                 Zzish.init(config);
-            }
-            catch (err) {
+            } catch (err) {
                 appId = config;
-                setDataValue("appConfig",config);
+                setDataValue("appConfig", config);
             }
-
-        }
-        else if (typeof config =='object') {
-            appId = getConfigValue(config,'api');
-            defaultProtocol = getConfigValue(config,'protocol',defaultProtocol);
-            baseUrl = getConfigValue(config,'baseUrl',baseUrl);
-            webUrl = getConfigValue(config,'webUrl',webUrl);
-            header = getConfigValue(config,'header',header);
-            headerprefix = getConfigValue(config,'headerprefix',headerprefix);
-            logEnabled = getConfigValue(config,'logEnabled',logEnabled);
-            socketUrl = getConfigValue(config,'socketUrl',socketUrl);
-            setDataValue("appConfig",JSON.stringify(config));
+        } else if (typeof config ==="object") {
+            appId = getConfigValue(config, "api");
+            defaultProtocol = getConfigValue(config, "protocol", defaultProtocol);
+            baseUrl = getConfigValue(config, "baseUrl", baseUrl);
+            webUrl = getConfigValue(config, "webUrl", webUrl);
+            header = getConfigValue(config, "header", header);
+            headerprefix = getConfigValue(config, "headerprefix", headerprefix);
+            logEnabled = getConfigValue(config, "logEnabled", logEnabled);
+            socketUrl = getConfigValue(config, "socketUrl", socketUrl);
+            setDataValue("appConfig", JSON.stringify(config));
         }
-        sendEvent("START");
+        // REMOVED: sendEvent("START") - AppEvents disabled to reduce MongoDB costs
     };
 
 
@@ -210,32 +187,31 @@
      * Stop Zzish instance
      */
     Zzish.stop = function (callback) {
-        //generate a device if we don't have one
-        sendEvent("STOP");
+        // generate a device if we don't have one
+        // REMOVED: sendEvent("STOP") - AppEvents disabled to reduce MongoDB costs
     };
 
-    var params = getQueryParams();
-    if (params["zzishtoken"]!=null) {
-        Zzish.init(params["zzishtoken"]);
+    const params = getQueryParams();
+    if (params.zzishtoken!=null) {
+        Zzish.init(params.zzishtoken);
     }
-    if (params["cancel"]!=undefined) {
+    if (params.cancel!=undefined) {
         removeDataValue("token");
     }
 
 
-
-/**** SERVER SIDE (NO STATE) *****/
+/** ** SERVER SIDE (NO STATE) **** */
 
     /**
      * Presets the deviceId and SessionId which the developer stores if there is not state to store that info
      */
-    Zzish.initState = function(iDeviceId,iSessionId) {
+    Zzish.initState = function (iDeviceId, iSessionId) {
         deviceId = iDeviceId;
         sessionId = iSessionId;
         return zzish;
     };
 
-/**** CLIENT SIDE (REQUIRE STATE) *****/
+/** ** CLIENT SIDE (REQUIRE STATE) **** */
 
     /**
      * Get the User (if the id is the same as the current one, returns the current user)
@@ -248,23 +224,21 @@
     Zzish.getUser = function (id, name, callback) {
         if (id==undefined) id = v4();
         if (stateful()) {
-            //that means we have a front end service so we can check state
+            // that means we have a front end service so we can check state
             if (currentUser==undefined || currentUser.id != id) {
                 sessionId = v4();
-                Zzish.createUser(id,name,function(err,message) {
+                Zzish.createUser(id, name, (err, message) => {
                     if (!err) {
-                        //set the current user if we don't have an error
+                        // set the current user if we don't have an error
                         currentUser = message;
                     }
-                    callCallBack(err, {status: 200, payload: message}, callback);
+                    callCallBack(err, { status: 200, payload: message }, callback);
                 });
+            } else {
+                callCallBack(null, { status: 200, payload: currentUser }, callback);
             }
-            else {
-                callCallBack(null, {status: 200, payload: currentUser}, callback);
-            }
-        }
-        else {
-            Zzish.createUser(id,name,callback);
+        } else {
+            Zzish.createUser(id, name, callback);
         }
     };
 
@@ -276,13 +250,13 @@
      * @return The user (returns a server user if it already exists). If it's the current User, returns that user
      */
     Zzish.getUserByCode = function (code, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/code/" + code
+            url: `${getBaseUrl()}profiles/code/${code}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -293,31 +267,30 @@
      * @return The user (returns a server user if it already exists). If it's the current User, returns that user
      */
     Zzish.getUsers = function (ids, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/list/" + encodeURIComponent(ids.join(";"))
+            url: `${getBaseUrl()}profiles/list/${encodeURIComponent(ids.join(";"))}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
-     * Get a list of users (POST)
+     * Get a list of users via POST (batched lookup beyond URL length cliff)
      *
-     * @param ids - A unique Id for the user (required)
-     * @param callback - An optional callback after user has been saved on server
-     * @return The user (returns a server user if it already exists). If it's the current User, returns that user
+     * @param ids - Array of user IDs (required)
+     * @param callback - An optional callback after the request completes
      */
     Zzish.getUsersByList = function (ids, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/listusers/",
-            data: ids
+            url: `${getBaseUrl()}profiles/listusers/`,
+            data: ids,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -329,14 +302,14 @@
      * @return The user (returns a server user if it already exists). If it's the current User, returns that user
      */
     Zzish.saveUser = function (id, user, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles",
-            data: user
+            url: `${getBaseUrl()}profiles`,
+            data: user,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -348,14 +321,14 @@
      * @return The group (returns a server user if it already exists). If it's the current User, returns that user
      */
     Zzish.saveGroup = function (id, group, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + id  + "/groups",
-            data: group
+            url: `${getBaseUrl()}profiles/${id}/groups`,
+            data: group,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
 
@@ -371,19 +344,18 @@
         if (game.uuid === undefined) {
             game.uuid = v4();
         }
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "statements/" + userId + "/games",
-            data: game
+            url: `${getBaseUrl()}statements/${userId}/games`,
+            data: game,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
         return game.uuid;
     };
 
 
-
     /**
      * Get results of a game
      *
@@ -391,14 +363,14 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      * @return The game uuid
      */
-    Zzish.getGameActivities = function (userId,gameId, callback) {
-        var request = {
+    Zzish.getGameActivities = function (userId, gameId, callback) {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "statements/" + userId + "/games/" + gameId + "/activities"
+            url: `${getBaseUrl()}statements/${userId}/games/${gameId}/activities`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -409,14 +381,14 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      * @return The game uuid
      */
-    Zzish.getGameActivity = function (userId,gameId, uuid, callback) {
-        var request = {
+    Zzish.getGameActivity = function (userId, gameId, uuid, callback) {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "statements/" + userId + "/games/" + gameId + "/activities/" + uuid
+            url: `${getBaseUrl()}statements/${userId}/games/${gameId}/activities/${uuid}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -437,15 +409,15 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      */
     Zzish.startActivity = function (userId, activityName, code, callback) {
-        var parameters = {
+        const parameters = {
             activityDefinition: {
-                type: activityName
+                type: activityName,
             },
             extensions: {
-                groupCode: code
-            }
+                groupCode: code,
+            },
         };
-        Zzish.startActivityWithObjects(userId,parameters, callback);
+        Zzish.startActivityWithObjects(userId, parameters, callback);
     };
 
     /**
@@ -456,19 +428,23 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      */
     Zzish.startActivityWithObjects = function (userId, parameters, callback) {
-        sendEvent("START_ACTIVITY");
-        if (!currentUser || !stateful() || userId!=currentUser.id) {
-            currentUser = {
-                uuid: userId
-            };
-        }
-        var message = {
+        // REMOVED: sendEvent("START_ACTIVITY") - AppEvents disabled
+        Zzish.setCurrentUser(userId);
+        const message = {
             verb: "http://activitystrea.ms/schema/1.0/start",
-            activityUuid: parameters.activityId || v4()
+            activityUuid: parameters.activityId || v4(),
         };
         sendMessage(message, parameters, callback);
     };
 
+    Zzish.setCurrentUser = function (userId) {
+        if (!currentUser || !stateful() || userId != currentUser.id) {
+            currentUser = {
+                uuid: userId,
+            };
+        }
+    };
+
     /**
      * stop Activity with aid
      *
@@ -478,16 +454,16 @@
      *
      */
     Zzish.stopActivity = function (activityId, states, callback) {
-        sendEvent("STOP_ACTIVITY");
-        var pro = undefined;
-        var haveState = false;
+        // REMOVED: sendEvent("STOP_ACTIVITY") - AppEvents disabled
+        let pro;
+        let haveState = false;
         if (states!=undefined && states.proficiency!=undefined) {
             pro = states.proficiency;
             delete states.proficiency;
         }
-        var stateMap = {
-            states: states
-        }
+        const stateMap = {
+            states,
+        };
         if (pro!=undefined) {
             stateMap.proficiency = pro;
             haveState = true;
@@ -496,9 +472,33 @@
             haveState = true;
         }
         sendMessage({
-             verb: "http://activitystrea.ms/schema/1.0/complete",
-             activityUuid: activityId
-        }, { states: haveState?stateMap:undefined},callback)
+            verb: "http://activitystrea.ms/schema/1.0/complete",
+            activityUuid: activityId,
+        }, { states: haveState?stateMap:undefined }, callback);
+    };
+
+    /**
+     * Stop Activity with full parameters object (preserves activityDefinition)
+     *
+     * @param activityId - The activity id (returned from startActivity) (required)
+     * @param parameters - Object that may contain activityDefinition, states, extensions
+     * @param callback - A callback to be called after message is sent (returns error, message)
+     *
+     * Prefer this over stopActivity({}) so the resulting xAPI Statement carries
+     * object.definition.type. Spring Data 4.x strict mode rejects POST /api/statements
+     * payloads where definition.type is null when the historical ActivityDef
+     * collection contains multiple type=null rows for the app.
+     */
+    Zzish.stopActivityWithObjects = function (activityId, parameters, callback) {
+        const params = parameters || {};
+        sendMessage({
+            verb: "http://activitystrea.ms/schema/1.0/complete",
+            activityUuid: activityId,
+        }, {
+            activityDefinition: params.activityDefinition,
+            states: params.states,
+            extensions: params.extensions,
+        }, callback);
     };
 
     /** *  Update an activity instance with images
@@ -508,14 +508,14 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      */
     Zzish.updateActivityImages = function (activityId, images, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "statements/activityinstances/" + activityId + "/images",
+            url: `${getBaseUrl()}statements/activityinstances/${activityId}/images`,
             data: images,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -526,11 +526,49 @@
      *
      */
     Zzish.cancelActivity = function (activityId, callback) {
-        sendEvent("CANCEL_ACTIVITY");
+        // REMOVED: sendEvent("CANCEL_ACTIVITY") - AppEvents disabled
+        sendMessage({
+            verb: "http://activitystrea.ms/schema/1.0/cancel",
+            activityUuid: activityId,
+        }, {}, callback);
+    };
+
+    /**
+     * Cancel Activity with full parameters object (preserves activityDefinition)
+     *
+     * @param activityId - The activity id (returned from startActivity) (required)
+     * @param parameters - Object that may contain activityDefinition, states, extensions
+     * @param callback - A callback to be called after message is sent (returns error, message)
+     */
+    Zzish.cancelActivityWithObjects = function (activityId, parameters, callback) {
+        const params = parameters || {};
         sendMessage({
             verb: "http://activitystrea.ms/schema/1.0/cancel",
-            activityUuid: activityId
-        }, {}, callback)
+            activityUuid: activityId,
+        }, {
+            activityDefinition: params.activityDefinition,
+            states: params.states,
+            extensions: params.extensions,
+        }, callback);
+    };
+
+    /**
+     * Get incomplete Activity by profile ID and group content ID
+     *
+     * @param profileId - The profile ID of the user (required)
+     * @param groupContentId - The group content ID associated with the activity (required)
+     * @param callback - A callback to be called after message is sent (returns error,message)
+     *
+     */
+    Zzish.getIncompleteActivity = function (profileId, groupContentId, callback) {
+        const incompleteStatus = "ACTIVITY_INSTANCE_STARTED";
+        const request = {
+            method: "GET",
+            url: `${getBaseUrl()}statements/activityinstances/user/${profileId.trim()}?groupContentId=${groupContentId.trim()}&status=${incompleteStatus}`,
+        };
+        sendData(request, (err, data) => {
+            callCallBack(err, data, callback);
+        });
     };
 
     /**
@@ -539,6 +577,7 @@
      * @param activityId - The activity id (returned from startActivity) (required)
      * @param actionName - The name of the action (required)
      * @param response - A string representation of the action (optional)
+     * @param responseOption - A string representation of the action option, e.g. "A", "B", etc (optional)
      * @param score - A float score (optional)
      * @param duration - A long duration (optional)
      * @param attempts - The number of attempts
@@ -546,44 +585,47 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      *
      */
-    Zzish.logAction = function (activityId, actionName, response, score, correct, duration, attempts, attributes, callback) {
-        var definition = {
-            type: actionName
+    Zzish.logAction = function (activityId, actionName, response, responseOption, score, correct, duration, attempts, attributes, callback) {
+        const definition = {
+            type: actionName,
         };
-        var result = {};
+        const result = {};
         if (response != undefined) {
-            result["response"] = response;
+            result.response = response;
+        }
+        if (responseOption != undefined) {
+            result.responseOption = responseOption;
         }
         if (score != undefined) {
-            result["score"] = parseFloat(score);
+            result.score = parseFloat(score);
         }
         if (correct != undefined) {
-            result["correct"] = correct;
+            result.correct = correct;
         }
         if (duration != undefined) {
-            result["duration"] = parseInt(duration);
+            result.duration = parseInt(duration);
         }
         if (attempts != undefined) {
-            result["attempts"] = parseInt(attempts);
+            result.attempts = parseInt(attempts);
         }
-        Zzish.logActionWithObjects(activityId,{definition:definition, result: result},callback);
+        Zzish.logActionWithObjects(activityId, { definition, result }, callback);
     };
 
     Zzish.logActionWithObjects = function (activityId, parameters, callback) {
-        sendEvent("ACTION");
+        // REMOVED: sendEvent("ACTION") - AppEvents disabled
         if (parameters.definition==undefined) {
             parameters.definition = {};
         }
-        var action = createActionObject(parameters);
+        const action = createActionObject(parameters);
         sendMessage({
             verb: "http://activitystrea.ms/schema/1.0/start",
             activityUuid: activityId,
-            actions: [action]
+            actions: [action],
         }, parameters, callback);
-    }
+    };
 
     function createActionObject(parameters) {
-        var action = parameters.result;
+        let action = parameters.result;
         if (action == undefined) {
             action = {};
         }
@@ -592,22 +634,36 @@
         action.state = parameters.state;
         if (typeof parameters.attributes === "string") {
             action.attributes = JSON.parse(parameters.attributes);
-        }
-        else {
+        } else {
             action.attributes = parameters.attributes;
         }
         return action;
     }
 
-    Zzish.logActions = function (activityId, parameters, actionObjects, callback) {
-        sendEvent("ACTION");
-        var actions = actionObjects.map(function(action) {
-            return createActionObject(action);
-        });
+    /**
+     * Log a batch of Actions for the activity
+     *
+     * @param activityId - The activity id (returned from startActivity) (required)
+     * @param parameters - The parameters Object (must include activityDefinition.type)
+     * @param actionObjects - Array of action objects
+     * @param isQuizComplete - If true, emits verb=complete; otherwise verb=start (optional)
+     * @param callback - A callback to be called after message is sent (returns error, message)
+     *
+     * Accepts both the legacy 4-arg shape (callback at position 4) and the
+     * modern 5-arg shape (isQuizComplete at position 4, callback at position 5).
+     */
+    Zzish.logActions = function (activityId, parameters, actionObjects, isQuizComplete, callback) {
+        // Arity tolerance: if 4th arg is a function, treat it as the callback.
+        if (typeof isQuizComplete === "function") {
+            callback = isQuizComplete;
+            isQuizComplete = false;
+        }
+        const actions = actionObjects.map((action) => createActionObject(action));
+        const verb = isQuizComplete ? "complete" : "start";
         sendMessage({
-            verb: "http://activitystrea.ms/schema/1.0/start",
+            verb: `http://activitystrea.ms/schema/1.0/${verb}`,
             activityUuid: activityId,
-            actions: actions
+            actions,
         }, parameters, callback);
     };
 
@@ -620,26 +676,27 @@
      */
     var sendMessage = function (data, parameters, callback) {
         if (currentUser) {
-        data.userUuid = currentUser.uuid;
+            data.userUuid = currentUser.uuid;
         }
         if (parameters.extensions==undefined) {
             parameters.extensions = {};
         }
-        parameters.extensions["deviceId"] = deviceId;
-        parameters.extensions["sessionId"] = sessionId;
-        var message = buildSimulationMessage(data,parameters);
-        var headers = {
-            'Content-Type': 'application/json'
+        parameters.extensions.deviceId = deviceId;
+        parameters.extensions.sessionId = sessionId;
+        const message = buildSimulationMessage(data, parameters);
+        const headers = {
+            "Content-Type": "application/json",
         };
         headers[header] = headerprefix + appId;
-        var request = {
+        if (logEnabled) console.log(`Sending${JSON.stringify(message)}`);
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "statements",
-            data: message
+            url: `${getBaseUrl()}statements`,
+            data: message,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -647,27 +704,27 @@
      * @param data
      * @returns partially built TinCan message
      */
-    var buildSimulationMessage = function (data,parameters) {
+    var buildSimulationMessage = function (data, parameters) {
         if (parameters.activityDefinition==undefined) {
             parameters.activityDefinition = {};
         }
-        var message = {
+        const message = {
             actor: {
                 account: {
-                    homePage: "http://www.zzish.com/" + appId,
-                    name: data.userUuid
-                }
+                    homePage: `http://www.zzish.com/${appId}`,
+                    name: data.userUuid,
+                },
             },
             verb: {
-                id: data.verb
+                id: data.verb,
             },
             object: {
-                definition: parameters.activityDefinition
+                definition: parameters.activityDefinition,
             },
             id: data.activityUuid,
             context: {
-                extensions: {}
-            }
+                extensions: {},
+            },
         };
         if (parameters.states!=undefined) {
             message.object.state = parameters.states;
@@ -680,7 +737,7 @@
         }
         if (parameters.extensions) {
             for (i in parameters.extensions) {
-                message.context.extensions["http://www.zzish.com/context/extension/"+i] = parameters.extensions[i];
+                message.context.extensions[`http://www.zzish.com/context/extension/${i}`] = parameters.extensions[i];
             }
         }
         if (data.actions !== undefined) {
@@ -690,7 +747,6 @@
     };
 
 
-
     /**
      * Simple replaceAll method
      *
@@ -700,8 +756,8 @@
      * @return The result after the replace is done
      */
     function replaceAll(find, replace, str) {
-        if (str){
-            return str.replace(new RegExp(find, 'g'), replace);
+        if (str) {
+            return str.replace(new RegExp(find, "g"), replace);
         }
     }
 
@@ -712,33 +768,29 @@
      * callback - callback method
      */
     function callCallBack(err, data, callback) {
-        //check if callback exists
+        // check if callback exists
         if (callback != undefined) {
-            if (err != undefined) { console.error(err); }
-            if (err != undefined && isObject(err) && err.status) {
-                //an error has ocurred when trying to get response
+            if (err != undefined) {
+                // an error has ocurred when trying to get response
                 callback(err.status, err.message);
-            }
-            else if (data != undefined) {
-                //check if api returns 200
+            } else if (data != undefined) {
+                // check if api returns 200
                 if (data.status == 200) {
-                    //return payload as message will be null
+                    // return payload as message will be null
                     callback(undefined, data.payload);
-                }
-                else {
-                    //return message
+                } else {
+                    // return message
                     callback(data.status, data.message);
                 }
-            }
-            else {
+            } else {
                 callback(400, "Zzish error");
             }
         }
     }
 
-/**** BACK END STUFF TO SEND DATA ***/
+/** ** BACK END STUFF TO SEND DATA ** */
 
-/**** LOGINSTUFF ***/
+/** ** LOGINSTUFF ** */
 
     /**
      * Returns true if it's a valid class code (not necessarily whether it exists)
@@ -747,12 +799,12 @@
      */
     Zzish.validateClassCode = function (code) {
         if (code!=undefined && code.length>1) {
-            var charLast = code.slice(-1);
-            var total = 0;
-            for (counter=0;counter<code.length-1;counter++) {
+            const charLast = code.slice(-1);
+            let total = 0;
+            for (counter=0; counter<code.length-1; counter++) {
                 total+=code.charCodeAt(counter);
             }
-            total = total%10;
+            total %=10;
             if (charLast==total) {
                 return true;
             }
@@ -771,24 +823,24 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.authUser = function (id, name, code, callback) {
-        var message = {
-            uuid : id,
-            username : name,
-            passwordText: code
+        const message = {
+            uuid: id,
+            username: name,
+            passwordText: code,
         };
-        //create new session
+        // create new session
         sessionId = uuid.v4();
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/auth",
-            data: message
+            url: `${getBaseUrl()}profiles/auth`,
+            data: message,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             if (!err) {
                 currentUser = data;
             }
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -798,15 +850,15 @@
      * @param callback - An optional callback after user has been saved on server
      */
 
-    Zzish.unauthUser = function (id,  callback) {
-        var request = {
+    Zzish.unauthUser = function (id, callback) {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/"+id+"/logout",
-            data: {}
+            url: `${getBaseUrl()}profiles/${id}/logout`,
+            data: {},
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -817,18 +869,18 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.createUser = function (id, name, callback) {
-        var message = {
-            uuid : id,
-            name : name
+        const message = {
+            uuid: id,
+            name,
         };
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles",
-            data: message
+            url: `${getBaseUrl()}profiles`,
+            data: message,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
 
@@ -839,16 +891,16 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.listGroups = function (profileId, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/"+profileId+"/groups"
+            url: `${getBaseUrl()}profiles/${profileId}/groups`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             if (!err && data && data.payload) {
-                for (var i in data.payload) {
-                    var link = replaceAll("/","-----",data.payload[i].link);
-                    link = replaceAll("\\\\","=====",link)
-                    data.payload[i].link = webUrl + "learning-hub/tclassroom/" + link +"/live";
+                for (const i in data.payload) {
+                    let link = replaceAll("/", "-----", data.payload[i].link);
+                    link = replaceAll("\\\\", "=====", link);
+                    data.payload[i].link = `${webUrl}learning-hub/tclassroom/${link}/live`;
                 }
             }
             callCallBack(err, data, callback);
@@ -863,13 +915,13 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.listStudents = function (profileId, groupCode, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/"+profileId+"/groups/code/"+groupCode+"/students"
+            url: `${getBaseUrl()}profiles/${profileId}/groups/code/${groupCode}/students`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
 
@@ -880,17 +932,17 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.listGroupContentForProfile = function (id, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/"+id+"/groups/contents",
+            url: `${getBaseUrl()}profiles/${id}/groups/contents`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
 
-/**** USER MANAGEMENT *****/
+/** ** USER MANAGEMENT **** */
 
     /**
      * Authenticate based on user and password (which is md5') for app
@@ -903,21 +955,20 @@
      */
     Zzish.authenticate = function (email, password, callback) {
         if ((password==undefined || password =="") && (email=="" || email==undefined)) {
-            callback(400,"Email and Password are required");
-        }
-        else {
-            var message = {
-                email : email,
-                password: password
+            callback(400, "Email and Password are required");
+        } else {
+            const message = {
+                email,
+                password,
             };
-            var request = {
+            const request = {
                 method: "POST",
-                url: getBaseUrl() + "profiles/authenticate",
-                data: message
+                url: `${getBaseUrl()}profiles/authenticate`,
+                data: message,
             };
-            sendData(request, function (err, data) {
+            sendData(request, (err, data) => {
                 callCallBack(err, data, callback);
-            })
+            });
         }
     };
 
@@ -928,13 +979,13 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.user = function (uuid, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/authenticate/"+uuid,
+            url: `${getBaseUrl()}profiles/authenticate/${uuid}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -944,14 +995,14 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.userByAttributes = function (attributes, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/authenticate/search",
-            data: attributes
+            url: `${getBaseUrl()}profiles/authenticate/search`,
+            data: attributes,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -962,18 +1013,18 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.registerUser = function (email, password, callback) {
-        var message = {
-            email : email,
-            password: password
+        const message = {
+            email,
+            password,
         };
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/authenticate/register",
-            data: message
+            url: `${getBaseUrl()}profiles/authenticate/register`,
+            data: message,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -983,14 +1034,14 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.updateUser = function (user, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/authenticate/update",
-            data: user
+            url: `${getBaseUrl()}profiles/authenticate/update`,
+            data: user,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -1001,14 +1052,14 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.updatePassword = function (uuid, password, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/authenticate/" + uuid + "/password",
-            data: {password: password}
+            url: `${getBaseUrl()}profiles/authenticate/${uuid}/password`,
+            data: { password },
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
     /**
@@ -1020,19 +1071,19 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.registerUserWithZzish = function (userId, email, name, callback) {
-        var message = {
-            email: email,
+        const message = {
+            email,
             profile: {
                 uuid: userId,
-                name: name
-            }
+                name,
+            },
         };
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/authenticate/eregister",
-            data: message
+            url: `${getBaseUrl()}profiles/authenticate/eregister`,
+            data: message,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1044,23 +1095,23 @@
      * @param callback - An optional callback after user has been saved on server
      */
     Zzish.getTokenForUser = function (userId, callback) {
-        var message = {
-            uuid: userId
+        const message = {
+            uuid: userId,
         };
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/authenticate/token",
-            data: message
+            url: `${getBaseUrl()}profiles/authenticate/token`,
+            data: message,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function(err, message) {
-                var url = webUrl + "account/app/" + message + "/token";
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (err, message) => {
+                const url = `${webUrl}account/app/${message}/token`;
                 callback(err, url);
             });
         });
     };
 
-    /**** BACKEND CONTENT STUFF ***/
+    /** ** BACKEND CONTENT STUFF ** */
 
     /**
      * Save a Zzish content object
@@ -1071,19 +1122,18 @@
      * @param content - The JSON object to save
      * @param callback - An optional callback to call when done (returns error,message)
      */
-    Zzish.postContent = function (profileId, type, uuid,meta, tags, content, callback) {
-        var data = {
-            uuid: uuid,
-            meta: meta,
-            tags: tags,
-            payload: JSON.stringify(content)
+    Zzish.postContent = function (profileId, type, uuid, meta, content, callback) {
+        const data = {
+            uuid,
+            meta,
+            payload: JSON.stringify(content),
         };
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + uuid,
-            data: data
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${uuid}`,
+            data,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1099,18 +1149,18 @@
      * @param callback - An optional callback to call when done (returns error,message)
      */
     Zzish.postContentTagged = function (profileId, type, uuid, meta, content, tags, callback) {
-        var data = {
-            uuid: uuid,
-            meta: meta,
+        const data = {
+            uuid,
+            meta,
             payload: JSON.stringify(content),
-            tags: tags
+            tags,
         };
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + uuid,
-            data: data
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${uuid}`,
+            data,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1123,47 +1173,48 @@
      * @param callback - An optional callback to call when done (returns error,message)
      */
     Zzish.deleteContent = function (profileId, type, id, callback) {
-        var request = {
+        const request = {
             method: "DELETE",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + id
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${id}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
 
-    var formatContentObject = function(content,includePayload) {
+    const formatContentObject = function (content, includePayload) {
         if (content) {
-            var result = {
-                uuid: content.uuid,
-                type: content.type,
-                tags: content.tags || [],
-                meta : content.meta,
-                attributes: content.attributes
+            const { uuid, type, meta, attributes, payload, gameSessionStatus } = content;
+            const result = {
+                uuid,
+                type,
+                meta,
+                attributes,
+                gameSessionStatus,
             };
-            if (includePayload && content.payload!==undefined && content.payload!="") {
-                result.payload = JSON.parse(content.payload);
+            if (includePayload && payload!==undefined && payload!="") {
+                result.payload = JSON.parse(payload);
             }
             return result;
         }
         return null;
     };
 
-    var formatListContents = function(data,includePayload) {
-        var list = [];
-        if (data){
-            for (var i in data.payload) {
-                list.push(formatContentObject(data.payload[i],includePayload));
+    const formatListContents = function (data, includePayload) {
+        const list = [];
+        if (data) {
+            for (const i in data.payload) {
+                list.push(formatContentObject(data.payload[i], includePayload));
             }
         }
         return list;
     };
 
-    var formatListCategoryContents = function(data) {
-        if (data && data.payload.contents){
-            var list = [];
-            for (var i in data.payload.contents) {
-                var result = formatContentObject(data.payload.contents[i],false);
+    const formatListCategoryContents = function (data) {
+        if (data && data.payload.contents) {
+            const list = [];
+            for (const i in data.payload.contents) {
+                const result = formatContentObject(data.payload.contents[i], false);
                 list.push(result);
             }
             data.payload.contents = list;
@@ -1180,21 +1231,19 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.getContent = function (profileId, type, uuid, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + uuid
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${uuid}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     if (data && data.payload!==undefined && data.payload!=null) {
-                        callback(err,formatContentObject(data.payload,true));
-                    }
-                    else {
+                        callback(err, formatContentObject(data.payload, true));
+                    } else {
                         callback("Invalid Data");
                     }
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
@@ -1209,27 +1258,51 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.getAssignment = function (profileId, type, uuid, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/assignments/" + uuid
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/assignments/${uuid}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     if (data && data.payload!==undefined && data.payload!=null) {
-                        callback(err,formatContentObject(data.payload,true));
-                    }
-                    else {
+                        callback(err, formatContentObject(data.payload, true));
+                    } else {
                         callback("Invalid Data");
                     }
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
         });
     };
 
+    /**
+     * Get the Zzish assignment's associated game session status
+     * @param profileId - The id of the profile to which to get the content for
+     * @param type - The content type
+     * @param uuid - THe uuid of the student assignement
+     * @param callback - A callback to call when done (returns error AND (message or data))
+     */
+    Zzish.getAssignmentGameSessionStatus = function (profileId, type, uuid, callback) {
+        const request = {
+            method: "GET",
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/assignments/${uuid}/status`,
+        };
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
+                if (!err) {
+                    if (data) {
+                        callback(err, data);
+                    } else {
+                        callback("Invalid Data");
+                    }
+                } else {
+                    callback(status, message);
+                }
+            });
+        });
+    };
 
 
     /**
@@ -1240,22 +1313,19 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.getContents = function (profileId, type, uuids, callback) {
-        var request = {
-            method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/list",
-            data: uuids
+        const request = {
+            method: "GET",
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/list/${encodeURIComponent(uuids.join(";"))}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     if (data && data.payload!==undefined && data.payload!=null) {
-                        callback(err, formatListContents(data,true));
-                    }
-                    else {
+                        callback(err, formatListContents(data, true));
+                    } else {
                         callback("Invalid Data");
                     }
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
@@ -1264,18 +1334,17 @@
 
 
     function convertToParameters(obj) {
-        var str = "";
-        for (var key in obj) {
+        let str = "";
+        for (const key in obj) {
             if (str != "") {
                 str += "&";
             }
             if (Array.isArray(obj[key])) {
-                for (var i in obj[key]) {
-                    str += key + "=" + encodeURIComponent(JSON.stringify(obj[key][i]));
+                for (const i in obj[key]) {
+                    str += `${key}=${encodeURIComponent(JSON.stringify(obj[key][i]))}`;
                 }
-            }
-            else {
-                str += key + "=" + encodeURIComponent(JSON.stringify(obj[key]));
+            } else {
+                str += `${key}=${encodeURIComponent(JSON.stringify(obj[key]))}`;
             }
         }
         return str;
@@ -1288,16 +1357,15 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.searchPublicContent = function (type, meta, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/publicconsumers/" + type + "/search?" + convertToParameters(meta)
+            url: `${getBaseUrl()}profiles/publicconsumers/${type}/search?${convertToParameters(meta)}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
-                    callback(err, formatListContents(data,false));
-                }
-                else {
+                    callback(err, formatListContents(data, false));
+                } else {
                     callback(status, message);
                 }
             });
@@ -1312,16 +1380,15 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.searchContent = function (profileId, type, meta, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/search?" + convertToParameters(meta)
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/search?${convertToParameters(meta)}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
-                    callback(err, formatListContents(data,false));
-                }
-                else {
+                    callback(err, formatListContents(data, false));
+                } else {
                     callback(status, message);
                 }
             });
@@ -1335,16 +1402,15 @@
      * @param callback - A callback to call when done (returns error AND (message or list of zzish,name))
      */
     Zzish.listContent = function (profileId, type, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
-                    callback(err, formatListContents(data,false));
-                }
-                else {
+                    callback(err, formatListContents(data, false));
+                } else {
                     callback(status, message);
                 }
             });
@@ -1365,12 +1431,12 @@
      * @param callback - A callback to call when done (returns error AND (message or list of zzish,name))
      */
     Zzish.publishContent = function (profileId, type, uuid, options, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + uuid + "/publish",
-            data: options
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${uuid}/publish`,
+            data: options,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1383,13 +1449,13 @@
      * @param groupCode - The Zzish code of an existing class
      * @param callback - A callback to call when done (returns error AND (message or list of zzish,name))
      */
-    Zzish.unpublishContent  = function (profileId, type, uuid, groupCode, callback) {
-        var request = {
+    Zzish.unpublishContent = function (profileId, type, uuid, groupCode, callback) {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + uuid + "/" + groupCode + "/unpublish",
-            data: {}
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${uuid}/${groupCode}/unpublish`,
+            data: {},
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1402,21 +1468,20 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      *
      */
-    Zzish.listContentForGroup = function(profileId, code, callback) {
-        var request = {
+    Zzish.listContentForGroup = function (profileId, code, callback) {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/consumers/"+code,
+            url: `${getBaseUrl()}profiles/${profileId}/consumers/${code}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     callback(err, formatListCategoryContents(data));
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
-        })
+        });
     };
 
     /**
@@ -1427,22 +1492,21 @@
      * @param callback - A callback to be called after message is sent (returns error,message)
      *
      */
-    Zzish.registerUserWithGroup = function(profileId, code, callback) {
-        var request = {
+    Zzish.registerUserWithGroup = function (profileId, code, callback) {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/consumers/" + code + "/register",
-            data: {}
+            url: `${getBaseUrl()}profiles/${profileId}/consumers/${code}/register`,
+            data: {},
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     callback(err, formatListCategoryContents(data));
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
-        })
+        });
     };
 
     /**
@@ -1466,11 +1530,11 @@
 
      */
     Zzish.getUserResults = function (profileId, parameters, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "statements/" + profileId + "/results?" + convertToParameters(parameters)
+            url: `${getBaseUrl()}statements/${profileId}/results?${convertToParameters(parameters)}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1492,17 +1556,16 @@
 
      */
     Zzish.loadPracticeQuiz = function (profileId, parameters, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/consumers/practice?" + convertToParameters(parameters)
+            url: `${getBaseUrl()}profiles/${profileId}/consumers/practice?${convertToParameters(parameters)}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
 
 
-
     /**
      * Get results for Zzish content object
      * @param profileId - The id of the profile to which to get the content for
@@ -1511,11 +1574,11 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.getContentResults = function (profileId, type, uuid, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/contents/" + type + "/" + uuid+"/results"
+            url: `${getBaseUrl()}profiles/${profileId}/contents/${type}/${uuid}/results`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1527,11 +1590,11 @@
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
     Zzish.getPublicContentResults = function (type, uuid, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/publicconsumers/" + type + "/" + uuid+"/results"
+            url: `${getBaseUrl()}profiles/publicconsumers/${type}/${uuid}/results`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1542,22 +1605,20 @@
      * @param uuid - The Zzish content (JSON)
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
-    Zzish.getPublicContent = function (type,uuid, callback) {
-        var request = {
+    Zzish.getPublicContent = function (type, uuid, callback) {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/publicconsumers/" + type + "/" + uuid
+            url: `${getBaseUrl()}profiles/publicconsumers/${type}/${uuid}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     if (data) {
-                        callback(err,formatContentObject(data.payload,true));
-                    }
-                    else {
+                        callback(err, formatContentObject(data.payload, true));
+                    } else {
                         callback(status, message);
                     }
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
@@ -1570,17 +1631,16 @@
      * @param code - The Zzish content code
      * @param callback - A callback to call when done (returns error AND (message or data))
      */
-    Zzish.getPublicContentByCode = function (type,code, callback) {
-        var request = {
+    Zzish.getPublicContentByCode = function (type, code, callback) {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/publicconsumers/" + type + "/code/" + code
+            url: `${getBaseUrl()}profiles/publicconsumers/${type}/code/${code}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
-                    callback(err,formatContentObject(data.payload,true));
-                }
-                else {
+                    callback(err, formatContentObject(data.payload, true));
+                } else {
                     callback(status, message);
                 }
             });
@@ -1592,17 +1652,16 @@
      * @param type - The content type
      * @param callback - A callback to call when done (returns error AND (message or list of zzish,name))
      */
-    Zzish.listPublicContent = function (type,callback) {
-        var request = {
+    Zzish.listPublicContent = function (type, callback) {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/publicconsumers/" + type
+            url: `${getBaseUrl()}profiles/publicconsumers/${type}`,
         };
-        sendData(request, function (err, data) {
-            callCallBack(err, data, function (status, message) {
+        sendData(request, (err, data) => {
+            callCallBack(err, data, (status, message) => {
                 if (!err) {
                     callback(err, formatListCategoryContents(data));
-                }
-                else {
+                } else {
                     callback(status, message);
                 }
             });
@@ -1616,12 +1675,12 @@
      * @param callback - An optional callback to call when done (returns error,message)
      */
     Zzish.postCategory = function (profileId, category, callback) {
-        var request = {
+        const request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/" + profileId + "/categories/",
-            data: category
+            url: `${getBaseUrl()}profiles/${profileId}/categories/`,
+            data: category,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1633,11 +1692,11 @@
      * @param callback - An optional callback to call when done (returns error,message)
      */
     Zzish.deleteCategory = function (profileId, id, callback) {
-        var request = {
+        const request = {
             method: "DELETE",
-            url: getBaseUrl() + "profiles/" + profileId + "/categories/" + id
+            url: `${getBaseUrl()}profiles/${profileId}/categories/${id}`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
@@ -1648,36 +1707,35 @@
      * @param callback - A callback to call when done (returns error AND (message or list of zzish,name))
      */
     Zzish.listCategories = function (profileId, callback) {
-        var request = {
+        const request = {
             method: "GET",
-            url: getBaseUrl() + "profiles/" + profileId + "/categories"
+            url: `${getBaseUrl()}profiles/${profileId}/categories`,
         };
-        sendData(request, function (err, data) {
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
     };
 
-/**** USER STUFF ***/
+/** ** USER STUFF ** */
 
 
-    function loadLoginWithToken(type,params,callback) {
-        sendEvent("LOGIN");
-        var url = webUrl + 'account/applogin?token='+params.token;
+    function loadLoginWithToken(type, params, callback) {
+        // REMOVED: sendEvent("LOGIN") - AppEvents disabled
+        const url = `${webUrl}account/applogin?token=${params.token}`;
         if (type=="pop") {
-            var win = window.open(url, 'Zzish Login', 'width=800, height=600');
+            const win = window.open(url, "Zzish Login", "width=800, height=600");
             var pollTimer = window.setInterval(
-                function() {
-                  try {
-                    if (win.document.URL.indexOf(webUrl) === -1) {
-                      window.clearInterval(pollTimer);
-                      win.close();
-                      Zzish.getCurrentUser(token,callback);
+                () => {
+                    try {
+                        if (win.document.URL.indexOf(webUrl) === -1) {
+                            window.clearInterval(pollTimer);
+                            win.close();
+                            Zzish.getCurrentUser(token, callback);
+                        }
+                    } catch (e) {
                     }
-                  } catch(e) {
-                  }
                 }, 500);
-        }
-        else {
+        } else {
             window.location.href = url;
         }
     }
@@ -1688,46 +1746,44 @@
      * @param options - a list of optinos for token
      * @param callback - A callback to call when done (returns error AND (message or user))
      */
-    Zzish.createToken = function (type,options,callback) {
-        var token_request = {
+    Zzish.createToken = function (type, options, callback) {
+        const token_request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/tokens",
-            data: { options: options }
+            url: `${getBaseUrl()}profiles/tokens`,
+            data: { options },
         };
-        //create a token first
+        // create a token first
         sendData(token_request, callback);
     };
 
     /**
-     * Upate a Token
-     * @param uuid - The uuid of the token
-     * @param options - a list of optinos for token
+     * Get a Token
+     * @param uuid - The token uuid
      * @param callback - A callback to call when done (returns error AND (message or user))
      */
-    Zzish.updateToken = function (uuid, options,callback) {
-        var token_request = {
-            method: "POST",
-            url: getBaseUrl() + "profiles/tokens/" + uuid,
-            data: { options: options }
+    Zzish.getToken = function (uuid, callback) {
+        const token_request = {
+            method: "GET",
+            url: `${getBaseUrl()}profiles/tokens/${uuid}`,
         };
-        //create a token first
+        // create a token first
         sendData(token_request, callback);
     };
 
-
-
     /**
-     * Get a Token
-     * @param uuid - The token uuid
-     * @param callback - A callback to call when done (returns error AND (message or user))
+     * Update a token's options
+     *
+     * @param uuid - The token UUID (required)
+     * @param options - Options object to merge (required)
+     * @param callback - An optional callback after the request completes
      */
-    Zzish.getToken = function (uuid,callback) {
-        var token_request = {
-            method: "GET",
-            url: getBaseUrl() + "profiles/tokens/" + uuid
-        }
-        //create a token first
-        sendData(token_request, callback);
+    Zzish.updateToken = function (uuid, options, callback) {
+        const tokenRequest = {
+            method: "POST",
+            url: `${getBaseUrl()}profiles/tokens/${uuid}`,
+            data: { options: options },
+        };
+        sendData(tokenRequest, callback);
     };
 
 
@@ -1738,86 +1794,84 @@
           redirectURL -  A URL hosted on the domain you are calling so that it can monitor success (will redirect to this page after succesful login and then close the page)
      * @param callback - A callback to call when done (returns error AND (message or user))
      */
-    Zzish.login = function (type,options,callback) {
-        var token_request = {
+    Zzish.login = function (type, options, callback) {
+        const token_request = {
             method: "POST",
-            url: getBaseUrl() + "profiles/tokens",
-            data: { options: options }
+            url: `${getBaseUrl()}profiles/tokens`,
+            data: { options },
         };
-        //create a token first
-        sendData(token_request, function (err, data) {
-                callCallBack(err, data, function(err,token) {
-                options['token']=token;
+        // create a token first
+        sendData(token_request, (err, data) => {
+            callCallBack(err, data, (err, token) => {
+                options.token=token;
                 setDataValue("token", token);
-                loadLoginWithToken(type,options,callback);
+                loadLoginWithToken(type, options, callback);
             });
         });
     };
 
-    Zzish.getCurrentUser = function(token,callback) {
-        sendEvent("LAUNCH");
+    Zzish.getCurrentUser = function (token, callback) {
+        // REMOVED: sendEvent("LAUNCH") - AppEvents disabled
         if (token==undefined) {
-            //see if we can get token from query params
-            token = getQueryParams()["token"];
+            // see if we can get token from query params
+            token = getQueryParams().token;
         }
         if (token==undefined) {
             token = getDataValue("token");
         }
         if (token !== undefined && token!="Zzish error" && token!="undefined") {
-            var token_request = {
+            const token_request = {
                 method: "GET",
-                url: getBaseUrl() + "profiles/tokens/" + token
-            }
-            //create a token first
-            sendData(token_request, function (err, data) {
-                callCallBack(err, data, function(err,data) {
+                url: `${getBaseUrl()}profiles/tokens/${token}`,
+            };
+            // create a token first
+            sendData(token_request, (err, data) => {
+                callCallBack(err, data, (err, data) => {
                     if (data) {
                         data.token = token;
                     }
-                    callback(err,data);
+                    callback(err, data);
                 });
             });
-        }
-        else {
+        } else {
             callback();
         }
-    }
+    };
 
     /**
-     * Logout from Zzish
-     * @param callback - A callback to call when done (returns error AND (message or user))
+     * Get a profile with attached metadata
+     *
+     * @param uuid - The profile UUID (required)
+     * @param callback - An optional callback after the request completes
      */
-    Zzish.logout = function (token,callback) {
-        var request = {
-            method: "DELETE",
-            url: getBaseUrl() + "profiles/tokens/" + token
-        }
-        removeDataValue("token");
-        sendData(request, function (err, data) {
+    Zzish.getProfileWithMeta = function (uuid, callback) {
+        const request = {
+            method: "GET",
+            url: `${getBaseUrl()}profiles/${uuid}/meta`,
+        };
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
         });
-    }
+    };
 
     /**
-     * Gets a user profile with Zzish meta data
-     *
-     * @param uuid - The profile User Id
-     * @param callback - An optional callback after user profile has been fetched
+     * Logout from Zzish
+     * @param callback - A callback to call when done (returns error AND (message or user))
      */
-    Zzish.getProfileWithMeta = function (uuid, callback) {
-        var request = {
-            method: "GET",
-            url: getBaseUrl() + "profiles/"+uuid+"/meta",
+    Zzish.logout = function (token, callback) {
+        const request = {
+            method: "DELETE",
+            url: `${getBaseUrl()}profiles/tokens/${token}`,
         };
-        sendData(request, function (err, data) {
+        removeDataValue("token");
+        sendData(request, (err, data) => {
             callCallBack(err, data, callback);
-        })
+        });
     };
 
-    Zzish.connectToSocket = function(opencallback, errorcallback, messagecallback, msg) {
-
-        var start = function() {
-            connection = new WebSocket('ws://' + socketUrl);
+    Zzish.connectToSocket = function (opencallback, errorcallback, messagecallback, msg) {
+        const start = function () {
+            connection = new WebSocket(`ws://${socketUrl}`);
             connection.onopen = function () {
                 if (connection.readyState === 1) {
                     Zzish.connectedToSocket = true;
@@ -1846,57 +1900,57 @@
                     errorcallback("Invalid JSON");
                 }
             };
-        }
+        };
 
-        setInterval(function() {
+        setInterval(() => {
             if (connection.readyState !== 1) {
                 Zzish.connectedToSocket = false;
                 if (currentSocketRetry < maxSocketRetry) {
-                    currentSocketRetry ++;
+                    currentSocketRetry++;
                     start();
-                }
-                else {
+                } else {
                     errorcallback("Socket disconnected");
                 }
             }
         }, 3000);
 
         start();
-    }
+    };
 
-    Zzish.postToSocket = function(message) {
+    Zzish.postToSocket = function (message) {
         if (connection) {
             connection.send(JSON.stringify(message));
         }
-    }
+    };
 
-    /**** PROXY STUFF TO SEND DATA ***/
-    /*** REQUEST has 3 attributes (method, url and data) ****/
+    /** ** PROXY STUFF TO SEND DATA ** */
+    /** * REQUEST has 3 attributes (method, url and data) *** */
 
-    if (typeof window === 'undefined') {
+    if (typeof window === "undefined") {
         // we running in node so use https://www.npmjs.org/package/xmlhttprequest
-        XMLHttpRequest = require('xmlhttprequest').XMLHttpRequest;
+        XMLHttpRequest = require("xmlhttprequest").XMLHttpRequest;
     }
 
 
-    var req;
-    var ocallback;
+    let req;
+    let ocallback;
 
 
     function sendData(request, callback) {
-        if (typeof request.method === 'undefined') {
+        if (typeof request.method === "undefined") {
             request.method = "POST";
         }
+        if (logEnabled) console.log("Proxy.request ", request);
         req = new XMLHttpRequest();
-        if(req.addEventListener){
-            req.addEventListener('load', function () {
-            response(this, callback, logEnabled);
+        if (req.addEventListener) {
+            req.addEventListener("load", function () {
+                response(this, callback, logEnabled);
             }, false);
 
-            req.addEventListener('error', function () {
+            req.addEventListener("error", function () {
                 error(this, callback, logEnabled);
             }, false);
-        }else{
+        } else {
             ocallback = callback;
             req.onload = outputResult;
         }
@@ -1904,53 +1958,70 @@
 
         req.open(request.method, request.url, true);
         req.setRequestHeader(header, headerprefix+appId);
-        req.setRequestHeader('Content-Type', 'application/json');
+        req.setRequestHeader("Content-Type", "application/json");
         req.send(JSON.stringify(request.data));
     }
 
     function outputResult() {
-        if (typeof ocallback === 'function') {
-            var responseText = typeof req.responseText === 'string' ? JSON.parse(req.responseText) : req.responseText;
+        if (logEnabled) console.log("Proxy.response callback", req.responseText !== undefined, ocallback);
+        if (typeof ocallback === "function") {
+            const responseText = typeof req.responseText === "string" ? JSON.parse(req.responseText) : req.responseText;
             ocallback(null, responseText);
         }
     }
 
     function response(resp, callback, log) {
-        var err = null, res = null;
+        let err = null,
+            res = null;
+
         try {
-            if (resp.status >= 200 && resp.status < 300) {
-                res = JSON.parse(resp.responseText);
+            const response = JSON.parse(resp.responseText);
+            if (
+                resp.status >= 200 &&
+                resp.status < 300 &&
+                (
+                    response.status == null ||
+                    (
+                        response.status >= 200 &&
+                        response.status < 300
+                    )
+                )
+            ) {
+                res = response;
             } else {
-                err = JSON.parse(resp.responseText);
+                err = response;
             }
         } catch (e) {
             err = resp.responseText;
         }
-        if (typeof callback === 'function') {
+        if (log) console.log("Proxy.response callback", err, res);
+        if (err && window._LTracker) window._LTracker.push({ location: window.location.href, err });
+        if (typeof callback === "function") {
             callback(err, res);
         }
     }
 
     function error(evt, callback, log) {
+        console.error("Proxy.error", evt);
         callback(evt.currentTarget, null);
     }
 
-    /*** UUID STUFF from zzish.js ***/
+    /** * UUID STUFF from zzish.js ** */
 
 
-    var _global = this;
+    const _global = this;
 
     // Unique ID creation requires a high quality random # generator.  We feature
     // detect to determine the best RNG source, normalizing to a function that
     // returns 128-bits of randomness, since that's what's usually required
-    var _rng;
+    let _rng;
 
     // Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
     //
     // Moderately fast, high quality
-    if (typeof(_global.require) == 'function') {
+    if (typeof (_global.require) === "function") {
         try {
-            var _rb = _global.require('crypto').randomBytes;
+            const _rb = _global.require("crypto").randomBytes;
             _rng = _rb && function () {
                 return _rb(16);
             };
@@ -1962,7 +2033,7 @@
         // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
         //
         // Moderately fast, high quality
-        var _rnds8 = new Uint8Array(16);
+        const _rnds8 = new Uint8Array(16);
         _rng = function whatwgRNG() {
             crypto.getRandomValues(_rnds8);
             return _rnds8;
@@ -1974,7 +2045,7 @@
         //
         // If all else fails, use Math.random().  It's fast, but is of unspecified
         // quality.
-        var _rnds = new Array(16);
+        const _rnds = new Array(16);
         _rng = function () {
             for (var i = 0, r; i < 16; i++) {
                 if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
@@ -1986,11 +2057,11 @@
     }
 
     // Buffer class to use
-    var BufferClass = typeof(_global.Buffer) == 'function' ? _global.Buffer : Array;
+    const BufferClass = typeof (_global.Buffer) === "function" ? _global.Buffer : Array;
 
     // Maps for number <-> hex string conversion
-    var _byteToHex = [];
-    var _hexToByte = {};
+    const _byteToHex = [];
+    const _hexToByte = {};
     for (var i = 0; i < 256; i++) {
         _byteToHex[i] = (i + 0x100).toString(16).substr(1);
         _hexToByte[_byteToHex[i]] = i;
@@ -1998,10 +2069,11 @@
 
     // **`parse()` - Parse a UUID into it's component bytes**
     function parse(s, buf, offset) {
-        var i = (buf && offset) || 0, ii = 0;
+        let i = (buf && offset) || 0,
+            ii = 0;
 
         buf = buf || [];
-        s.toLowerCase().replace(/[0-9a-f]{2}/g, function (oct) {
+        s.toLowerCase().replace(/[0-9a-f]{2}/g, (oct) => {
             if (ii < 16) { // Don't overflow!
                 buf[i + ii++] = _hexToByte[oct];
             }
@@ -2017,15 +2089,16 @@
 
     // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
     function unparse(buf, offset) {
-        var i = offset || 0, bth = _byteToHex;
-        return bth[buf[i++]] + bth[buf[i++]] +
-            bth[buf[i++]] + bth[buf[i++]] + '-' +
-            bth[buf[i++]] + bth[buf[i++]] + '-' +
-            bth[buf[i++]] + bth[buf[i++]] + '-' +
-            bth[buf[i++]] + bth[buf[i++]] + '-' +
-            bth[buf[i++]] + bth[buf[i++]] +
-            bth[buf[i++]] + bth[buf[i++]] +
-            bth[buf[i++]] + bth[buf[i++]];
+        let i = offset || 0,
+            bth = _byteToHex;
+        return `${bth[buf[i++]] + bth[buf[i++]] +
+            bth[buf[i++]] + bth[buf[i++]]}-${
+            bth[buf[i++]]}${bth[buf[i++]]}-${
+            bth[buf[i++]]}${bth[buf[i++]]}-${
+            bth[buf[i++]]}${bth[buf[i++]]}-${
+            bth[buf[i++]]}${bth[buf[i++]]
+            }${bth[buf[i++]]}${bth[buf[i++]]
+            }${bth[buf[i++]]}${bth[buf[i++]]}`;
     }
 
     // **`v1()` - Generate time-based UUID**
@@ -2034,41 +2107,42 @@
     // and http://docs.python.org/library/zzish.html
 
     // random #'s we need to init node and clockseq
-    var _seedBytes = _rng();
+    const _seedBytes = _rng();
 
     // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
-    var _nodeId = [
+    const _nodeId = [
         _seedBytes[0] | 0x01,
-        _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
+        _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5],
     ];
 
     // Per 4.2.2, randomize (14 bit) clockseq
-    var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
+    let _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
 
     // Previous zzish creation time
-    var _lastMSecs = 0, _lastNSecs = 0;
+    let _lastMSecs = 0,
+        _lastNSecs = 0;
 
     // See https://github.com/broofa/node-zzish for API details
     function v1(options, buf, offset) {
-        var i = buf && offset || 0;
-        var b = buf || [];
+        let i = buf && offset || 0;
+        const b = buf || [];
 
         options = options || {};
 
-        var clockseq = options.clockseq != null ? options.clockseq : _clockseq;
+        let clockseq = options.clockseq != null ? options.clockseq : _clockseq;
 
         // UUID timestamps are 100 nano-second units since the Gregorian epoch,
         // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
         // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
         // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
-        var msecs = options.msecs != null ? options.msecs : new Date().getTime();
+        let msecs = options.msecs != null ? options.msecs : new Date().getTime();
 
         // Per 4.2.1.2, use count of zzish's generated during the current clock
         // cycle to simulate higher resolution clock
-        var nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
+        let nsecs = options.nsecs != null ? options.nsecs : _lastNSecs + 1;
 
         // Time since last zzish creation (in msecs)
-        var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
+        const dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs) / 10000;
 
         // Per 4.2.1.2, Bump clockseq on clock regression
         if (dt < 0 && options.clockseq == null) {
@@ -2083,7 +2157,7 @@
 
         // Per 4.2.1.2 Throw error if too many uuids are requested
         if (nsecs >= 10000) {
-            throw new Error('zzish.v1(): Can\'t create more than 10M uuids/sec');
+            throw new Error("zzish.v1(): Can't create more than 10M uuids/sec");
         }
 
         _lastMSecs = msecs;
@@ -2094,14 +2168,14 @@
         msecs += 12219292800000;
 
         // `time_low`
-        var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+        const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
         b[i++] = tl >>> 24 & 0xff;
         b[i++] = tl >>> 16 & 0xff;
         b[i++] = tl >>> 8 & 0xff;
         b[i++] = tl & 0xff;
 
         // `time_mid`
-        var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
+        const tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
         b[i++] = tmh >>> 8 & 0xff;
         b[i++] = tmh & 0xff;
 
@@ -2116,12 +2190,12 @@
         b[i++] = clockseq & 0xff;
 
         // `node`
-        var node = options.node || _nodeId;
-        for (var n = 0; n < 6; n++) {
+        const node = options.node || _nodeId;
+        for (let n = 0; n < 6; n++) {
             b[i + n] = node[n];
         }
 
-        return buf ? buf : unparse(b);
+        return buf || unparse(b);
     }
 
     // **`v4()` - Generate random UUID**
@@ -2129,15 +2203,15 @@
     // See https://github.com/broofa/node-zzish for API details
     function v4(options, buf, offset) {
         // Deprecated - 'format' argument, as supported in v1.2
-        var i = buf && offset || 0;
+        const i = buf && offset || 0;
 
-        if (typeof(options) == 'string') {
-            buf = options == 'binary' ? new BufferClass(16) : null;
+        if (typeof (options) === "string") {
+            buf = options == "binary" ? new BufferClass(16) : null;
             options = null;
         }
         options = options || {};
 
-        var rnds = options.random || (options.rng || _rng)();
+        const rnds = options.random || (options.rng || _rng)();
 
         // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
         rnds[6] = (rnds[6] & 0x0f) | 0x40;
@@ -2145,7 +2219,7 @@
 
         // Copy bytes to buffer, if provided
         if (buf) {
-            for (var ii = 0; ii < 16; ii++) {
+            for (let ii = 0; ii < 16; ii++) {
                 buf[i + ii] = rnds[ii];
             }
         }
@@ -2153,26 +2227,22 @@
         return buf || unparse(rnds);
     }
 
-    function isObject(obj) {
-        return Object.prototype.toString.call(obj) === "[object Object]";
-    }
-
     // Export public API
 
 
     var zzish = Zzish;
 
-    if (typeof define === 'function' && define.amd) {
+    if (typeof define === "function" && define.amd) {
         // Publish as AMD module
-        define(function () {
+        define(() => {
             return zzish;
         });
-    } else if (typeof(module) != 'undefined' && module.exports) {
+    } else if (typeof (module) !== "undefined" && module.exports) {
         // Publish as node.js module
         module.exports = zzish;
     } else {
         // Publish as global (in browsers)
-        var _previousRoot = _global.uuid;
+        const _previousRoot = _global.uuid;
 
         // **`noConflict()` - (browser only) to reset global 'zzish' var**
         zzish.noConflict = function () {
@@ -2182,5 +2252,4 @@
 
         _global.zzish = zzish;
     }
-
-})();
+}());