adapt-authoring-ui 0.0.1

package/app/core/origin.js

@@ -0,0 +1,189 @@
+define([
+  'underscore', 
+  'backbone', 
+  'core/l10n',
+  'core/router',
+  'core/browserStorage',
+  'core/models/sessionModel'
+], function(_, Backbone, l10n, Router, BrowserStorage, SessionModel) {
+  var initialized = false;
+  var eventTaps = [];
+  var $loading;
+  /**
+   * Global singleton class
+   * @class Origin
+   */
+  var Origin = _.extend({}, Backbone.Events, {
+    /**
+     * Flag used to determine if debug features should be enabled
+     * @member Origin#debug
+     * @type {Boolean}
+     */
+    debug: false,
+    /**
+     * Performs setup of the application, will only run once
+     * @function Origin#initialize
+     */
+    initialize: _.once(function(callback) {
+      listenToWindowEvents();
+      new Router(this);
+      initialized = true;
+      this.trigger('origin:dataReady');
+    }),
+    /**
+     * Initialises the application utilities
+     * @function Origin#loadUtilities
+     */
+    loadUtilities: _.once(async function(callback) {
+      try {
+        /**
+         * Reference to the constant attributes
+         * @member Origin#constants
+         * @type {Object}
+         */
+        this.constants = await $.get('/api/config');
+        /**
+         * Global reference to the l10n translation utilities
+         * @member Origin#l10n
+         * @type {l10n}
+         */
+        this.l10n = new l10n(this);
+        /**
+         * Global reference to the l10n translation utilities
+         * @member Origin#l10n
+         * @type {l10n}
+         */
+        this.browserStorage = new BrowserStorage(this);
+
+        await this.l10n.load();
+        callback();
+      } catch(e) {
+        console.error(e.message);
+      }
+    }),
+    /**
+     * Initialises the current session and caches for use
+     * @function Origin#
+     */
+    startSession: _.once(function(callback) {
+      initLoading();
+      this.loadUtilities((function() {
+        /**
+         * Current session instance
+         * @member Origin#sessionModel
+         * @type {SessionModel}
+         */
+        Origin.sessionModel = new SessionModel(this);
+        Origin.sessionModel.fetch({
+          success: () => callback(),
+          error: (m, jqXhr) => callback(new Error(jqXhr.responseJSON.message))
+        });
+      }).bind(this));
+    }),
+    /**
+     * Whether the Origin object has loaded
+     * @function Origin#hasInitialized
+     * @return {Boolean}
+     */
+    hasInitialized: function() {
+      return initialized;
+    },
+    /**
+     * Overrides Backbone.Events#trigger to allow for tapping and debug logging
+     * @function Origin#
+     */
+    trigger: function(eventName, data) {
+      var args = arguments;
+      callTaps(eventName, function() {
+        if(Origin.debug){
+          console.log('Origin.trigger:', eventName, (data ? data : ''));
+        }
+        Backbone.Events.trigger.apply(Origin, args);
+      });
+    },
+    /**
+     * Register a function to tap into a certain event before it fires
+     * @function Origin#tap
+     */
+    tap: function(event, callback) {
+      eventTaps.push({ event: event, callback: callback });
+    },
+    /**
+     * Tells views to clean themselves up
+     * @function Origin#removeViews
+     */
+    removeViews: function() {
+      Origin.trigger('remove:views');
+    }
+  });
+
+  // Private functions
+
+  function initLoading() {
+    $loading = $('.loading');
+    hideLoading();
+
+    Origin.on('origin:hideLoading', hideLoading, Origin);
+    Origin.on('origin:showLoading', showLoading, Origin);
+  }
+
+  // abstracted window events
+  function listenToWindowEvents() {
+    $(document).on('keydown', onKeyDown);
+    $(window).on('resize', onResize);
+    $(window).on('blur focus', onFocusBlur);
+  }
+
+  function showLoading(shouldHideTopBar) {
+    $loading
+      .removeClass('display-none fade-out')
+      .toggleClass('cover-top-bar', shouldHideTopBar);
+  }
+
+  function hideLoading() {
+    $loading.addClass('fade-out');
+    _.delay(_.bind(function() {
+      $loading
+        .addClass('display-none')
+        .removeClass('cover-top-bar');
+    }, this), 300);
+  }
+
+  // Calls all 'tapped' functions before continuing
+  function callTaps(event, callback) {
+    var taps = _.where(eventTaps, { event: event });
+    // recurse
+    function callTap() {
+      var tap = taps.pop();
+      if(!tap) return callback();
+      tap.callback.call(Origin, callTap);
+    }
+    callTap();
+  }
+
+  // Event handling
+
+  function onKeyDown(event) {
+    if($(event.target).is('input,textarea,.ck')) return;
+    Origin.trigger('key:down', event);
+  }
+
+  function onResize(event) {
+    var $window = $(this);
+    var windowWidth = $window.width();
+    var windowHeight = $window.height();
+    Origin.trigger('window:resize', windowWidth, windowHeight);
+  }
+
+  function onFocusBlur(event) {
+    var $win = $('window');
+    var prevType = $win.data("prevType");
+    // prevent double-firing
+    if(prevType === event.type) return;
+    // send out Origin events
+    var eventName = (event.type === 'focus') ? 'active' : 'inactive';
+    Origin.trigger('window:' + eventName, event);
+  }
+
+  return Origin;
+});

package/app/core/router.js

@@ -0,0 +1,135 @@
+// LICENCE https://github.com/adaptlearning/adapt_authoring/blob/master/LICENSE
+define(['underscore', 'backbone'], function(_, Backbone) {
+  var Origin;
+  var Router = Backbone.Router.extend({
+    routes: {
+      '': 'handleIndex',
+      '_=_': 'handleIndex',
+      ':module(/*route1)(/*route2)(/*route3)(/*route4)': 'handleRoute'
+    },
+    restrictedRoutes: {},
+    dashboardHandlers: [],
+
+    initialize: function(origin) {
+      Origin = origin;
+      Origin.router = this;
+      Origin.trigger('router:initialize');
+      this.locationKeys = ['module', 'route1', 'route2', 'route3', 'route4'];
+      this.resetLocation();
+      Origin.on('origin:dataReady', () => Backbone.history.start());
+    },
+
+    updateLocation: function(routeArgs) {
+      // save the previous location
+      Origin.previousLocation = Origin.location;
+
+      this.resetLocation();
+      this.locationKeys.forEach((k,i) => Origin.location[k] = routeArgs[i]);
+
+      var [mod, route1] = routeArgs;
+      $('body')
+        .removeClass()
+        .addClass(`module-${mod}${route1 ? ` location-${route1}` : ''}`);
+
+      Origin.trigger('location:change', Origin.location);
+    },
+
+    resetLocation: function() {
+      Origin.location = {};
+    },
+    // Allows modules/plugins to customise dashboard routing
+    addDashboardHandler: function(handler) {
+      this.dashboardHandlers.push(handler);
+    },
+
+    restrictRoute: function(route, scopes) {
+      if(this.restrictedRoutes[route]) {
+        return console.warn(`Route '${route}' already restricted`);
+      }
+      this.restrictedRoutes[route] = scopes;
+    },
+    // Checks user permissions for route
+    verifyRoute: function(mod, route1) {
+      // Authentication error
+      if(!Origin.sessionModel.get('isAuthenticated') && (mod !== 'user' && route1 !== 'login')) {
+        return this.blockUserAccess(Origin.sessionModel.get('error'), true);
+      }
+      // Check this user has permissions
+      var requiredScopes = this.restrictedRoutes[Backbone.history.fragment];
+      if(requiredScopes && !Origin.sessionModel.hasScopes(requiredScopes)) {
+        return this.blockUserAccess();
+      }
+      return true;
+    },
+
+    // Boots user to the login screen with an error message
+    blockUserAccess: function(message, hideUI) {
+      if(hideUI) {
+        $('body').addClass('no-ui');
+        Origin.trigger('remove:views');
+      }
+      Origin.Notify.alert({
+        type: 'error',
+        title: Origin.l10n.t('app.errorpagenoaccesstitle'),
+        text: message || Origin.l10n.t('app.errorpagenoaccess'),
+        confirmButtonText: Origin.l10n.t('app.ok'),
+        callback: this.navigateToLogin.bind(this)
+      });
+    },
+
+    // Routing
+
+    formatRoute: function(route) {
+      /**
+      * We remove leading slashes as they force trigger:true regardless of the
+      * options passed to Backbone.Router.navigate
+      * See https://github.com/jashkenas/backbone/issues/786
+      */
+      if(route[0] === '/') return route.slice(1);
+      return route;
+    },
+
+    persistRoute: function(route) {
+      this.navigate(this.formatRoute(route));
+    },
+
+    navigateBack: function() {
+      Backbone.history.history.back();
+    },
+
+    navigateTo: function(route) {
+      // use Origin.router.navigate in case we don't have a valid 'this' reference
+      this.navigate(this.formatRoute(route), { trigger: true });
+    },
+
+    navigateToLogin: function() {
+      // use Origin.router.navigate in case we don't have a valid 'this' reference
+      this.navigateTo('user/login');
+    },
+
+    navigateToDashboard: function() {
+      for (const h of this.dashboardHandlers) {
+        const route = h();
+        if(route) return this.navigateTo(route);
+      }
+      Origin.Notify.alert({ type: 'error', text: 'Router.navigateToDashboard: cannot load dashboard, no valid dashboard handler' });
+    },
+
+    handleIndex: function() {
+      Origin.trigger('origin:showLoading');
+      Origin.sessionModel.get('isAuthenticated') ? this.navigateToDashboard() : this.navigateToLogin();
+    },
+
+    handleRoute: function(module, route1, route2, route3, route4) {
+      Origin.removeViews();
+      if(!this.verifyRoute(module, route1)) {
+        return;
+      }
+      this.updateLocation(arguments);
+      Origin.trigger('router', module, route1, route2, route3, route4);
+      Origin.trigger('router:' + module, route1, route2, route3, route4);
+    }
+  });
+
+  return Router;
+});

package/app/core/views/originView.js

@@ -0,0 +1,92 @@
+// LICENCE https://github.com/adaptlearning/adapt_authoring/blob/master/LICENSE
+define(function(require){
+  var Backbone = require('backbone');
+  var Origin = require('core/origin');
+
+  var OriginView = Backbone.View.extend({
+    settings: {
+      autoRender: true,
+      preferencesKey: ''
+    },
+
+    initialize: function(options) {
+      this.preRender(options);
+      if (this.constructor.template) {
+        Origin.trigger(this.constructor.template + ':preRender', this);
+      }
+      if (this.settings.autoRender) {
+        this.render();
+      }
+      this.listenTo(Origin, 'remove:views', this.remove);
+    },
+
+    preRender: function() {
+
+    },
+
+    render: function() {
+      var data = this.model ? this.model.toJSON() : null;
+      var template = Handlebars.templates[this.constructor.template];
+      this.$el.html(template(data));
+      _.defer(_.bind(function() {
+        this.postRender();
+        this.onReady();
+        if (this.constructor.template) {
+          Origin.trigger(this.constructor.template + ':postRender', this);
+        }
+      }, this));
+      return this;
+    },
+
+    postRender: function() {
+      this.setViewToReady();
+    },
+
+    onReady: function() {
+
+    },
+
+    setViewToReady: function() {
+      Origin.trigger('origin:hideLoading');
+    },
+
+    setUserPreference: function(key, value, sessionOnly) {
+      if (this.settings.preferencesKey) {
+        var preferences = (Origin.sessionModel.get(this.settings.preferencesKey) || {});
+        preferences[key] = value;
+        // Store in session model
+        Origin.sessionModel.set(this.settings.preferencesKey, preferences);
+        // set in browser storage
+        var data = {};
+        data[key] = value;
+        Origin.browserStorage.set(this.settings.preferencesKey, data, sessionOnly || false, false);
+      }
+    },
+
+    getUserPreferences: function() {
+      if (this.settings.preferencesKey) {
+        var saveData = Origin.browserStorage.get(this.settings.preferencesKey);
+        return saveData || {};
+      }
+    },
+
+    sortArrayByKey: function (arr, key) {
+      return arr.sort(function(a, b){
+        var keyA = a[key],
+        keyB = b[key];
+        if(keyA < keyB) return -1;
+        if(keyA > keyB) return 1;
+        return 0;
+      });
+    },
+
+    remove: function() {
+      if (this.form) {
+        this.form.remove();
+      }
+      Backbone.View.prototype.remove.apply(this, arguments);
+    }
+  });
+
+  return OriginView;
+});