aleph_analytics 0.0.0.alpha

data/app/assets/javascripts/angular/controllers/controllers.js.es6

@@ -0,0 +1,65 @@
+ !(angular => {
+  'use strict';
+
+  angular
+    .module('alephControllers', [
+      'alephControllers.schemaIndexController',
+      'alephControllers.queryIndexController',
+      'alephControllers.queryShowController',
+      'alephControllers.queryReplController',
+      'alephControllers.alertIndexController',
+      'alephControllers.alertShowController',
+      'alephControllers.snippetIndexController',
+      'alephServices',
+      'ui.ace',
+      'ngRoute',
+      'ui.bootstrap.alert'
+    ])
+
+    .controller('BodyController', ['$scope', 'SpinnerState', 'ServerConfigurations',
+      function NavBarController($scope, SpinnerState, ServerConfigurations) {
+        $scope.SpinnerState = SpinnerState;
+        $scope.ServerConfigurations = ServerConfigurations;
+      }
+    ])
+
+    .controller('NavBarController', ['$scope', '$window', '$location',
+      function NavBarController($scope, $window, $location) {
+
+        $scope.pathIncludes = function pathIncludes(string) {
+          return ($location.path().indexOf(string) > -1);
+        };
+
+        $scope.signOut = function signOut() {
+          $window.location.href = '/sign_out';
+        };
+      }
+    ])
+
+    .controller('AlertBarController', ['$scope', '$rootScope',
+      function ($scope, $rootScope) {
+        $scope.alerts = [];
+
+        $scope.dismiss = function dismiss() {
+          $scope.alerts.length = 0;
+        };
+
+        $rootScope.$on('$routeChangeSuccess', () => {
+          if ($scope.scheduledAlert) {
+            $scope.alerts.push($scope.scheduledAlert);
+            $scope.scheduledAlert = null;
+          } else {
+            $scope.dismiss();
+          }
+        });
+
+        $rootScope.$on('scheduleAlert', (event, alert) => {
+          $scope.scheduledAlert = alert;
+        });
+
+        $rootScope.$on('setAlert', (event, alert) => {
+          $scope.alerts.push(alert);
+        });
+      }
+    ]);
+}(angular));

data/app/assets/javascripts/angular/controllers/query/query_index_controller.js.es6

@@ -0,0 +1,80 @@
+!(angular => {
+  'use strict';
+
+  class QueryIndexController {
+
+    constructor(QueryResource, Query, QueryHandler, defaultDateFormat, OpenReplService, PaginationComponents,
+      TagResource, RoleModel, SelectionTagInput, $q) {
+        this.selectedQueries = [];
+        this.defaultDateFormat = defaultDateFormat;
+        this._handler = QueryHandler;
+
+        this.tagsSelectionInput = new SelectionTagInput({
+          items: this.selectedQueries,
+          itemField: 'tags'
+        });
+
+        this.rolesSelectionInput = new SelectionTagInput({
+          items: this.selectedQueries,
+          itemField: 'roles'
+        });
+
+        this.pagination = new PaginationComponents('Paginated Queries', QueryResource.index, Query);
+
+        this._roleModel = RoleModel;
+        this._tagResource = TagResource;
+        this._$q = $q;
+        this._openReplService = OpenReplService;
+
+        RoleModel.initCollection();
+    }
+
+    loadTags(searchTerm) {
+      return this._tagResource.index({search: searchTerm}).$promise;
+    }
+
+    loadRoles() {
+      return this._roleModel.collection;
+    }
+
+    onSelection() {
+      this.tagsSelectionInput.onSelection();
+      this.rolesSelectionInput.onSelection();
+    }
+
+    deselectAll() {
+      _.each(this.selectedQueries, query => { query.selected = false; });
+      this.selectedQueries.length = 0;
+      this.onSelection();
+    }
+
+    save() {
+      this.pagination.save().then(() => {
+        this.deselectAll();
+        this.pagination.reload();
+      });
+    }
+
+    revert() {
+      this.pagination.revert();
+      this.onSelection();
+    }
+
+    openRepl() {
+      this._openReplService.open()
+        .then(({query, result}) => {
+          return query.save({ result_id: result.id });
+        })
+        .then(this._handler.navigateToLatestVersion.bind(this._handler))
+        .then(this._handler.success.bind(this._handler, 'create', true))
+        .catch(this._handler.handleReplExit.bind(this._handler));
+    }
+  }
+
+  QueryIndexController.$inject = ['QueryResource', 'Query', 'QueryHandler', 'defaultDateFormat', 'OpenReplService',
+  'PaginationComponents', 'TagResource', 'RoleModel', 'SelectionTagInput', '$q'];
+
+  angular
+    .module('alephControllers.queryIndexController', ['alephServices'])
+    .controller('QueryIndexController', QueryIndexController);
+}(angular));

data/app/assets/javascripts/angular/controllers/query/query_repl_controller.js.es6

@@ -0,0 +1,147 @@
+!(angular => {
+  'use strict';
+
+  class QueryReplController {
+    constructor($uibModalInstance, getResultCsv, DefaultAceConfigurator, ResultRunner, query,
+      Results, NavigationGuard, KeyBindings, hotkeys, $scope) {
+        this._modalInstance = $uibModalInstance;
+
+        this.results = new Results();
+        this.query = query;
+        this.resultRunner = new ResultRunner(this.query, this.results, {
+          sandbox: true,
+          enablePolling: true
+        });
+        this._queryBodyState = this._queryBody();
+        this._getResultCsv = getResultCsv;
+
+        /* FIXME: need to think what to do about keybindings and navigation guard and unpolling
+           in a scopeless angular 2.0 world */
+        $scope.$on('$destroy', () => {
+          _.each(this.results.collection, result => {
+            result.poller.unPoll();
+          });
+        });
+
+        this._initKeyBindings(KeyBindings, hotkeys, $scope);
+
+        this._navigationGuard = new NavigationGuard($scope)
+          .registerLocationChangeStart(NavigationGuard.defaultPreventer())
+          .registerOnBeforeUnload(() => {
+            if(this._queryBodyState !== this._queryBody() && !this.downloadFlag) {
+              return 'Query has unsaved changes!';
+            }
+            this.downloadFlag = false;
+          });
+
+        /* FIXME: work-around for the fact that ace-ui un-binds aceLoaded and destroy the `this`
+           there isn't a way to bind the function in the angular expression in ace-ui either */
+        let keysForAce = {
+          save: this._saveKb,
+          detectParameters: this._detectParametersKb,
+          run: this._runKb
+        };
+
+        this.aceLoaded = function aceLoaded(editor) {
+          new DefaultAceConfigurator(editor).snippetsConfig();
+          editor.focus();
+          editor.commands.addCommand(keysForAce.save.aceKeyCmd);
+          editor.commands.addCommand(keysForAce.detectParameters.aceKeyCmd);
+          editor.commands.bindKey(keysForAce.run.bindKey, keysForAce.run.keyFn);
+          editor.setOptions({
+            maxLines: 500,
+            minLines: 2
+          });
+        };
+
+    }
+
+    runQuery() {
+      this.resultRunner.run();
+    }
+
+    validToRun() {
+      let result = this.results.collection[0];
+      return !result || result.item.status === 'complete' || result.item.status === 'failed';
+    }
+
+    validToSave() {
+      return this.query.item.title !== '';
+    }
+
+    saveToolTipText() {
+      return (this.query.item.title === '') ? 'Please enter a query title' : '';
+    }
+
+    save() {
+      // need to explicity disable navigationGuard since it sometimes takes angular too long to destroy the scope
+      this._navigationGuard.disable();
+      this._setParameterDefaultValues(this.query.item.version.parameters, this.resultRunner.substitutionValues);
+      let result = this.results.collection.shift();
+
+      this._modalInstance.close({
+        query: this.query,
+        result: _.exists(result) ? result.item : {},
+      });
+    }
+
+    exit() {
+      // need to explicity disable navigationGuard since it sometimes takes angular too long to destroy the scope
+      this._navigationGuard.disable();
+      this._modalInstance.dismiss('QueryReplExit');
+    }
+
+    getCsv(resultId) {
+      // need to get past onbeforeunload function in navigation guard when downloading
+      this.downloadFlag = true;
+      return this._getResultCsv(resultId);
+    }
+
+    // private methods
+
+    _queryBody() {
+      return this.query.item.version.body;
+    }
+
+    _setParameterDefaultValues(parameters, substitutionValues) {
+      parameters.forEach(parameter => {
+        let val = substitutionValues[parameter.name];
+        if (_.exists(val)) {
+          parameter.default = val;
+        }
+      });
+    }
+
+    _initKeyBindings(KeyBindings, hotkeys, $scope) {
+      this._saveKb = KeyBindings.saveQuery.withKeyFn(() => {
+        if(this.validToSave()) {
+          this.save();
+        }
+      });
+
+      this._runKb = KeyBindings.runQuery.withKeyFn(() => {
+        if(this.validToRun()) {
+          this.runQuery();
+        }
+      });
+
+      this._detectParametersKb = KeyBindings.detectParameters.withKeyFn(() => {
+        this.query.detectParameters();
+        $scope.$digest();
+      });
+
+      hotkeys.bindTo($scope)
+        .add(this._saveKb.hotKey)
+        .add(this._runKb.hotKey)
+        .add(this._detectParametersKb.hotKey);
+    }
+  }
+
+  QueryReplController.$inject = ['$uibModalInstance', 'getResultCsv', 'DefaultAceConfigurator', 'ResultRunner',
+    'query', 'Results', 'NavigationGuard', 'KeyBindings', 'hotkeys', '$scope'];
+
+  angular
+    .module('alephControllers.queryReplController', ['alephServices'])
+    .controller('QueryReplController', QueryReplController);
+
+}(angular));

data/app/assets/javascripts/angular/controllers/query/query_show_controller.js.es6

@@ -0,0 +1,43 @@
+!(angular => {
+  'use strict';
+
+  class QueryShowController {
+    constructor($scope, QueryLoader, PageTitleManager, QueryTab, ResultRunner) {
+      this._tabs = QueryTab;
+      this._tabs.setActiveTabFromUrl();
+
+      this.componentCallbacks = [];
+      this._loader = QueryLoader;
+      this._loader.initialize();
+      this._loader.load().then(data => {
+        PageTitleManager.title = data.query.title;
+        PageTitleManager.onDestroy($scope);
+        this.resultRunner = new ResultRunner(this.query, this.results, {
+          enableAlert: true
+        });
+        _.each(this.componentCallbacks, callback => {
+          callback(data);
+        });
+      });
+    }
+
+    get query() { return this._loader.query; }
+    get queryVersions() { return this._loader.queryVersions; }
+    get results() { return this._loader.results; }
+    get queryId() { return this._loader.queryId; }
+    get queryVersionId() { return this._loader.queryVersionId; }
+    get tabs() { return this._tabs.state; }
+
+    setTabInUrl(tab) {
+      if(tab !== this._tabs.getTab()) {
+        this._tabs.setTab(tab);
+      }
+    }
+  }
+
+  QueryShowController.$inject = ['$scope', 'QueryLoader', 'PageTitleManager', 'QueryTab', 'ResultRunner'];
+
+  angular
+    .module('alephControllers.queryShowController', ['alephServices'])
+    .controller('QueryShowController', QueryShowController);
+}(angular));

data/app/assets/javascripts/angular/controllers/schema/schema_index_controller.js.es6

@@ -0,0 +1,61 @@
+!(angular => {
+  'use strict';
+
+  class SchemaIndexController {
+    constructor(SchemaColumnResource, SchemaColumn, SchemaColumns, PaginationComponents, SpinnerState) {
+      this.pagination = new PaginationComponents(
+        'Paginated Schema',
+        SchemaColumnResource.index,
+        SchemaColumn,
+        {
+          additionalParams: { with_comments: true },
+          limit: 150
+        }
+      );
+
+      this.columns = new SchemaColumns();
+      let spinner = SpinnerState.withContext('SchemaColumns');
+      spinner.on();
+      this.columns.initCollection().then(spinner.off.bind(spinner));
+    }
+
+    directory() {
+      return _.chain(this.columns.schemaTables).pairs()
+        .reduce((acc, entry) => {
+          return acc.concat(_.map(entry[1], table => {
+            return {
+              schema: entry[0],
+              table: table
+            };
+          }));
+        }, [])
+        .value();
+    }
+
+    typeAheadValues(search) {
+      let schemasRe = /^[A-z]+$/;
+      let tablesRe = /^[A-z]+\.[A-z]*$/;
+
+      if(schemasRe.test(search)) {
+        return _.filter(this.columns.uniqueSchemas, str => str.indexOf(search) > -1);
+      } else if(tablesRe.test(search)) {
+        let schema = search.split('.')[0];
+        let tables = this.columns.schemaTables[schema];
+        return _.chain(tables)
+          .map(table => schema + '.' + table)
+          .filter(str => str.indexOf(search) > -1)
+          .value();
+      } else {
+        return [];
+      }
+    }
+  }
+
+  SchemaIndexController.$inject = ['SchemaColumnResource', 'SchemaColumn', 'SchemaColumns', 'PaginationComponents',
+    'SpinnerState'];
+
+  angular
+    .module('alephControllers.schemaIndexController', ['alephServices'])
+    .controller('SchemaIndexController', SchemaIndexController);
+
+}(angular));

data/app/assets/javascripts/angular/controllers/snippet/snippet_index_controller.js.es6

@@ -0,0 +1,80 @@
+!(angular => {
+  'use strict';
+
+  class SnippetIndexController {
+
+    constructor($scope, ModelManager, DefaultAceConfigurator, NavigationGuard) {
+      this._snippetModelClasses = ModelManager.forModelName('snippet');
+
+      this._Snippet = ModelManager.forModelName('snippet').modelClass();
+      this._Snippets = ModelManager.forModelName('snippet').collectionClass(this._Snippet);
+      this.snippets = new this._Snippets();
+      this._loadSnippets();
+
+      this.aceLoaded = function aceLoaded(editor) {
+        new DefaultAceConfigurator(editor).autoCompleteConfig();
+        editor.setOptions({
+          maxLines: 10,
+          minLines: 10
+        });
+      };
+
+      // FIXME: if we move to angular 2.0 will need to figure out how to do this w/o scope
+      this._navigationGuard = new NavigationGuard($scope)
+        .registerOnBeforeUnload(() => {
+          if(this.revertableSnippetsExist()) {
+            return 'There are unsaved changes';
+          }
+        })
+        .registerLocationChangeStart((event) => {
+          if(this.revertableSnippetsExist()
+              && !confirm('There are unsaved changes. Leave the page?')) {
+            event.preventDefault();
+          }
+        });
+    }
+
+    addNewSnippet() {
+      let s = new this._Snippet();
+      s.initItem();
+      this.snippets.collection.unshift(s);
+    }
+
+    isValidForSave(snippet) {
+      return snippet.isValidForSave() && snippet.item.name !== '' && snippet.item.content !== '';
+    }
+
+    savableSnippetsExist() {
+      return _.some(this.snippets.collection, (snippet) => this.isValidForSave(snippet));
+    }
+
+    revertableSnippetsExist() {
+      return _.some(this.snippets.collection, (snippet) => snippet.isDirty() || !snippet.isPersisted());
+    }
+
+    updatedAt(snippet) {
+      return (_.exists(snippet.item.updated_at)) ? Date.parse(snippet.item.updated_at) : Number.MAX_SAFE_INTEGER;
+    }
+
+    shouldGrayout(snippet) {
+      return !_.every(this.snippets.collection, (snippet) => snippet.isPersisted()) && snippet.isPersisted();
+    }
+
+    deleteSnippet(snippet) {
+      snippet.destroy().then(this._loadSnippets.bind(this));
+    }
+
+    // private methods
+
+    _loadSnippets() {
+      this.snippets.initCollection();
+    }
+  }
+
+  SnippetIndexController.$inject = ['$scope', 'ModelManager', 'DefaultAceConfigurator', 'NavigationGuard'];
+
+  angular
+    .module('alephControllers.snippetIndexController', ['alephServices'])
+    .controller('SnippetIndexController', SnippetIndexController);
+
+}(angular));

data/app/assets/javascripts/angular/directives/directives.js.es6

@@ -0,0 +1,30 @@
+!(angular => {
+  'use strict';
+
+  angular
+    .module('alephDirectives', [
+      'alephDirectives.visualization',
+      'alephDirectives.result',
+      'alephDirectives.results',
+      'alephDirectives.queryVersionSidebar',
+      'alephDirectives.queryDetails'
+    ])
+
+    .directive('ngConfirmClick', [() => {
+        return {
+          priority: -1,
+          restrict: 'A',
+          link: function(scope, element, attrs){
+            element.bind('click', e => {
+              let message = attrs.ngConfirmClick;
+              if(message && !confirm(message)){
+                e.stopImmediatePropagation();
+                e.preventDefault();
+              }
+            });
+          }
+        };
+      }
+    ]);
+
+}(angular));

data/app/assets/javascripts/angular/directives/query/query_details_directive.js.es6

@@ -0,0 +1,87 @@
+!(angular => {
+  'use strict';
+
+  class QueryDetailsController {
+    constructor(QueryHandler, QueryTab, TagResource, defaultDateFormat, DefaultAceConfigurator, OpenReplService,
+      RoleModel) {
+        this._handler = QueryHandler;
+        this._repl = OpenReplService;
+        this._tags = TagResource;
+        this._roles = RoleModel;
+        this._tabs = QueryTab;
+        this.dateFormat = defaultDateFormat;
+        this.aceLoaded = editor => new DefaultAceConfigurator(editor).readOnlyConfig();
+
+        RoleModel.initCollection();
+        this._closeCommentDialog();
+    }
+
+    openRepl() {
+      this._repl.open( { query: this.query } )
+        .then(({query, result}) => query.save({ result_id: result.id }))
+        .then(this._handler.navigateToLatestVersion.bind(this._handler))
+        .then(this._handler.success.bind(this._handler, 'update', false))
+        .catch(this._handler.handleReplExit.bind(this._handler))
+        .finally(this._closeCommentDialog.bind(this));
+    }
+
+    updateQuery() {
+      this.query.save()
+        .then(this._setPristine.bind(this))
+        .then(this._handler.success.bind(this._handler, 'update', false))
+        .finally(this._closeCommentDialog.bind(this));
+    }
+
+    runQuery() {
+      this.resultRunner.run().then(this._tabs.navigateToTab.bind(this._tabs, 'results'));
+    }
+
+    deleteQuery() {
+      this.query.destroy().then(this._handler.navigateToIndex.bind(this._handler));
+    }
+
+    loadTags(searchTerm) {
+      return this._tags.index({search: searchTerm}).$promise;
+    }
+
+    loadRoles() {
+      return this._roles.collection;
+    }
+
+    toggleCommentDialog() {
+      this.commentDialogOpen = !this.commentDialogOpen;
+    }
+
+    // private methods
+    _closeCommentDialog() {
+      this.commentDialogOpen = false;
+    }
+
+    _setPristine(query) {
+      this.form.$setPristine();
+      return query;
+    }
+  }
+
+  QueryDetailsController.$inject = ['QueryHandler', 'QueryTab', 'TagResource', 'defaultDateFormat',
+    'DefaultAceConfigurator', 'OpenReplService', 'RoleModel'];
+
+  function queryDetailsComponent() {
+    return {
+      restrict: 'E',
+      scope: {
+        'resultRunner': '=',
+        'query': '='
+      },
+      templateUrl: 'queryDetails',
+      controller: 'QueryDetailsController',
+      controllerAs: 'queryDetailsCtrl',
+      bindToController: true
+    };
+  }
+
+  angular
+    .module('alephDirectives.queryDetails', ['alephServices'])
+    .controller('QueryDetailsController', QueryDetailsController)
+    .directive('queryDetails', queryDetailsComponent);
+}(angular));

data/app/assets/javascripts/angular/directives/query/query_version_sidebar_directive.js.es6

@@ -0,0 +1,65 @@
+!(angular => {
+  'use strict';
+
+  class QueryVersionSidebarController {
+    constructor(GithubUrlService, $location) {
+      this._gitUrl = GithubUrlService;
+      this._$location = $location;
+      this.selectedVersions = [];
+
+      this.componentCallbacks.unshift(data => {
+        let versionItems = _.map(data.queryVersions, qv => qv.item);
+        this.currentVersion = _.findWhere(versionItems, { id: this.query.item.version.id });
+        this.currentVersion.selected = true;
+        this.currentVersionCommitUrl = this._gitUrl.commit(this.currentVersion);
+        this.githubHistory = this._gitUrl.commits(this.query.item.id);
+      });
+    }
+
+    get githubCommit() { return this._githubCommitUrl || this.currentVersionCommitUrl; }
+    get githubCompare() { return this._githubCompareUrl; }
+
+    figureGithubUrl() {
+      if(this.selectedVersions.length === 2) {
+        let sorted = _.sortBy(this.selectedVersions, 'id');      // ensure base is always earlier version
+        this._githubCompareUrl = this._gitUrl.compare(sorted[0], sorted[1]);
+      } else if(this.selectedVersions.length === 1) {
+        this._githubCommitUrl = this._gitUrl.commit(this.selectedVersions[0]);
+      }
+    }
+
+    loadQueryByVersion(queryVersionId) {
+      this._$location.path('/queries/' + this.query.item.id + '/query_versions/' + queryVersionId);
+    }
+
+    hasComment(queryVersion) {
+      return Utils.stringHelpers.isPresent(queryVersion.comment);
+    }
+
+    githubIsEnabled() {
+      return this._gitUrl.isValid();
+    }
+  }
+
+  QueryVersionSidebarController.$inject = ['GithubUrlService', '$location'];
+
+  function queryVersionSidebarComponent() {
+    return {
+      restrict: 'E',
+      scope: {
+        'query': '=',
+        'versions': '=',
+        'componentCallbacks': '='
+      },
+      templateUrl: 'query-version-sidebar',
+      controller: 'QueryVersionSidebarController',
+      controllerAs: 'qvSidebarCtrl',
+      bindToController: true
+    };
+  }
+
+  angular
+    .module('alephDirectives.queryVersionSidebar', ['alephServices'])
+    .controller('QueryVersionSidebarController', QueryVersionSidebarController)
+    .directive('queryVersionSidebar', queryVersionSidebarComponent);
+}(angular));