Breaking: ES6 Upgrade (fixes: issue/13)

README.md

@@ -8,7 +8,7 @@ Please refer to [example.json](example.json) for the JSON snippet which should b
 
 | Property | Type | Default | Description |
 |--|--|--|--|
-| \_isEnabled | Boolean | `false` | Set to `true` to enable the extension.
+| \_isEnabled | Boolean | `true` | Set to `true` to enable the extension.
 | \_activityId | String | `""` | Used to populate the Activity id included in _tincan.xml_ and for use in the Statement and State API. The value will be overriden if changed on the hosting environment.
 | \_revision | String | `""` | This helps identify users running particular versions of the content, should functionality have been changed or issues found which require updates/voided statements for users running a specific revision. Where data has changed significantly, a new Activity id is recommended.
 | \_tracking | Object | `{ _storeQuestionResponses: true, _questionInteractions: true, _assessmentsCompletion: false, _assessmentCompletion: true }` | <ul><li>\_storeQuestionResponses: Restore question responses across browser sessions.</li><li>\_questionInteractions: Record statements for questions.</li><li>\_assessmentsCompletion: Record a completed statement on completion of individual assessments.</li><li>\_assessmentCompletion: Record a completed statement on completion of all assessments combined.</li></ul>

bower.json

@@ -1,11 +1,12 @@
 {
   "name": "adapt-xAPI",
   "version": "2.1.4",
-  "framework": ">=3.0.0",
+  "framework": ">=5.19.1",
   "homepage": "https://github.com/cgkineo/adapt-xAPI",
-  "issues": "https://github.com/cgkineo/adapt-xAPI/issues",
-  "displayName": "xAPI",
+  "bugs": "https://github.com/cgkineo/adapt-xAPI/issues",
   "extension": "xapi",
+  "targetAttribute": "_xapi",
+  "displayName": "xAPI",
   "description": "An extension which allows the Experience API (xAPI) to collect data on human performance, stored within a suitable Learning Record Store (LRS).",
   "main": "/js/adapt-xapi.js",
   "keywords": [
@@ -17,7 +18,6 @@
     "experience api",
     "tracking"
   ],
-  "targetAttribute": "_xapi",
   "license": "GPL-3.0",
   "private": true,
   "devDependencies": {

example.json

@@ -3,8 +3,8 @@
 	"_xapi": {
         "_isEnabled": true,
         "_comment": "included in tincan.xml. _activityId will be overriden if changed on the hosting environment.",
-	    "_activityId": "https://example.com/unique_identifier",
-	    "_revision": "",
+	"_activityId": "https://example.com/unique_identifier",
+	"_revision": "",
         "_tracking": {
             "_storeQuestionResponses": true,
             "_questionInteractions": true,
@@ -32,4 +32,4 @@
             }
         }
     }
-}
+}

js/ErrorNotificationModel.js

@@ -0,0 +1,117 @@
+import Adapt from "core/js/adapt";
+import notify from 'core/js/notify';
+import wait from "core/js/wait";
+import logging from "core/js/logging";
+
+const LAUNCH_ERROR_ID = 'launch-error';
+const ACTIVITYID_ERROR_ID = 'activityId-error';
+const LRS_ERROR_ID = 'lrs-error';
+
+class ErrorNotificationModel extends Backbone.Model {
+
+  defaults() {
+    return {
+      _isReady: false,
+      _isNotifyOpen: false,
+      _isDeferredLoadingError: false,
+      _currentNotifyId: null
+    };
+  }
+
+  initialize() {
+    this.listenToOnce(Adapt, {
+      'app:dataLoaded': this.onDataLoaded
+    });
+
+    this.listenTo(Adapt, {
+      'xapi:launchError': this.onShowLaunchError,
+      'xapi:activityIdError': this.onShowActivityIdError,
+      'xapi:lrsError': this.onShowLRSError,
+      'notify:closed': this.onNotifyClosed
+    });
+  }
+
+  _showNotification(config, id) {
+    if (this._isReady) {
+      if (!this._isNotifyOpen) {
+        logging.error(config?.title);
+
+        const notifyConfig = this._getNotifyConfig(config, id);
+
+        notify.popup(notifyConfig);
+
+        this._isNotifyOpen = true;
+        this._currentNotifyId = id;
+      } else if (this._currentNotifyId !== id) {
+        this.listenToOnce(Adapt, 'notify:closed', this._showNotification.bind(this, config, id));
+      }
+    } else {
+      this._isDeferredLoadingError = true;
+
+      this.listenToOnce(Adapt, 'app:dataLoaded', this._showNotification.bind(this, config, id));
+    }
+  }
+
+  _getNotifyConfig(config, id) {
+    const notifyConfig = {
+      title: config?.title,
+      body: config?.body,
+      _classes: `xAPIError ${id} ${config._classes}`,
+      _isxAPIError: true
+    };
+
+    let isCancellable = true;
+
+    if (config.hasOwnProperty('_isCancellable')) {
+      isCancellable = config._isCancellable;
+      notifyConfig._isCancellable = isCancellable;
+      notifyConfig._closeOnShadowClick = !isCancellable;
+    }
+
+    return notifyConfig;
+  }
+
+  /**
+   * Can't show notify until data has loaded due to `import_globals` in template
+   */
+  onDataLoaded() {
+    this._isReady = true;
+
+    if (this._isDeferredLoadingError) {
+      wait.begin();
+
+      $('.loading').hide();
+    }
+  }
+
+  onShowLaunchError() {
+    this._showNotification(this.get('_launch'), LAUNCH_ERROR_ID);
+  }
+
+  onShowActivityIdError() {
+    this._showNotification(this.get('_activityId'), ACTIVITYID_ERROR_ID);
+  }
+
+  onShowLRSError() {
+    this._showNotification(this.get('_lrs'), LRS_ERROR_ID);
+  }
+
+  onNotifyClosed(notify) {
+    if (!notify.model.get('_isxAPIError')) return;
+
+    if (this._isDeferredLoadingError) {
+      wait.end();
+
+      this._isDeferredLoadingError = false;
+
+      // cancel other errors if launch failed and user dismissed, as it won't track regardless
+      this.stopListening();
+    }
+
+    this._isNotifyOpen = false;
+    this._currentNotifyId = null;
+  }
+
+}
+
+export default ErrorNotificationModel;

js/LaunchModel.js

@@ -0,0 +1,132 @@
+import Adapt from "core/js/adapt";
+
+class LaunchModel extends Backbone.Model {
+
+  defaults() {
+    return {
+      _xAPIWrapper: null,
+      _retryCount: 0,
+      _retryLimit: 1,
+      registration: null,
+      actor: null,
+      contextActivities: {
+        grouping: []
+      }
+    };
+  }
+
+  initialize() {
+    this.initializeLaunch();
+  }
+
+  initializeLaunch() {
+    const { lrs } = ADL.XAPIWrapper;
+
+    /**
+     * can auth be sent through in a different process, e.g. OAuth?
+     * lrs.endpoint && lrs.auth have defaults in the ADL xAPIWrapper, so can't assume their existence means they are the correct credentials - errors will be handled when communicating with the LRS
+     */
+    if (lrs.endpoint && lrs.auth && lrs.actor) {
+      this._xAPIWrapper = ADL.XAPIWrapper;
+
+      // add trailing slash if missing in endpoint
+      lrs.endpoint = lrs.endpoint.replace(/\/?$/, '/');
+
+      // @todo: capture grouping URL params - unsure what data this actually contains based on specs - unlike contextActivities for ADL Launch
+      const launchData = {
+        registration: lrs.registration || null,
+        actor: JSON.parse(lrs.actor)
+      };
+
+      this.set(launchData);
+
+      this.triggerLaunchInitialized();
+    } else {
+      ADL.launch(this.onADLLaunchAttempt.bind(this), false);
+    }
+  }
+
+  getWrapper() {
+    return this._xAPIWrapper;
+  }
+
+  showErrorNotification() {
+    Adapt.trigger('xapi:launchError');
+  }
+
+  triggerLaunchInitialized() {
+    setTimeout(function() {
+      Adapt.trigger('xapi:launchInitialized');
+    }, 0);
+  }
+
+  onADLLaunchAttempt(err, launchdata, wrapper) {
+    /*
+      200 = OK
+      400 = launch already initialized
+      404 = launch removed
+    */
+    if (err) {
+      if (performance.navigation.type === 1) {
+        this.onReload();
+        return;
+      }
+
+      if (this._retryCount < this._retryLimit) {
+        this._retryCount++;
+        this.initializeLaunch();
+        return;
+      }
+
+      this.onLaunchFail();
+      return;
+    }
+
+    this._xAPIWrapper = wrapper;
+
+    // can ADL launch include registration?
+    const launchData = {
+      registration: launchdata.registration || null,
+      actor: launchdata.actor
+    };
+
+    const contextActivities = launchdata.contextActivities;
+    if (contextActivities && Object.keys(contextActivities).length > 0) {
+      launchData.contextActivities = contextActivities;
+    }
+
+    this.set(launchData);
+
+    // store launch server details should browser be reloaded and launch server session still initialized
+    sessionStorage.setItem('lrs', JSON.stringify(wrapper.lrs));
+    sessionStorage.setItem('launchData', JSON.stringify(launchData));
+
+    this.triggerLaunchInitialized();
+  }
+
+  // if launch session expired, will the next request to the launch server produce an error notification for the user?
+  onReload() {
+    const lrs = JSON.parse(sessionStorage.getItem('lrs'));
+    const launchData = JSON.parse(sessionStorage.getItem('launchData'));
+
+    if (!lrs || !launchData) {
+      this.onLaunchFail();
+      return;
+    }
+
+    this._xAPIWrapper = ADL.XAPIWrapper;
+    this._xAPIWrapper.changeConfig(lrs);
+
+    this.set(launchData);
+
+    this.triggerLaunchInitialized();
+  }
+
+  onLaunchFail() {
+    Adapt.trigger('xapi:launchFailed');
+
+    this.showErrorNotification();
+  }
+}
+
+export default LaunchModel;

js/OfflineStorageHandler.js

@@ -0,0 +1,48 @@
+const OfflineStorageHandler = {
+
+  // will be set to StateModel once ready - store values until then
+  model: new Backbone.Model(),
+
+  get(name) {
+    switch (name.toLowerCase()) {
+      case 'student':// for backwards-compatibility. learnerInfo is preferred and will give more information
+        return this.model.get('actor').name;
+      case 'learnerinfo':
+        return this._getActorData();
+      default:
+        return this.model.get(name);
+    }
+  },
+
+  set(name, value) {
+    this.model.set(name, value);
+  },
+
+  _getActorData: function() {
+    const actor = this.model.get('actor');
+    const id = this._getIdFromActor(actor);
+
+    /*
+      * don't think we should make any judgement on name format for firstname or lastname, as there is no standard for this in xAPI
+      * if actor.name not provided, use id IFI
+      */
+    return {
+      id,
+      name: actor.name || id
+    };
+  },
+
+  _getIdFromActor(actor) {
+    const { openid, mbox, mbox_sha1sum, account } = actor;
+    if (openid) return openid;
+    if (mbox) return mbox;
+    if (mbox_sha1sum) return mbox_sha1sum;
+    if (account?.homePage && account?.name) {
+      return `${account.homePage}:${account.name}`;
+    }
+    return null;
+  }
+
+}
+
+export default OfflineStorageHandler;