aleph_analytics 0.0.0.alpha

data/public/assets/angular/controllers/query/query_repl_controller.js-3c4bac22e41766e2e83e720d53acade3.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/public/assets/angular/controllers/query/query_show_controller.js-020c83fd94ece7d55bd94b9981a40083.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/public/assets/angular/controllers/schema/schema_index_controller.js-d0d790d168b49caefa4b8f7993c928f1.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/public/assets/angular/controllers/snippet/snippet_index_controller.js-9191ee2e37d16d5807b8a7f45530a6c2.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/public/assets/angular/directives/directives.js-44fda752585bddc5d026feaab8b14108.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/public/assets/angular/directives/query/query_details_directive.js-2dd979e2463826558f166d9dc9e2c8a9.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/public/assets/angular/directives/query/query_version_sidebar_directive.js-b19ba8a9bf4e66c5740e9b9f9495cee1.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));

data/public/assets/angular/directives/result/result_directive.js-76c151e9277e35578f92b076c2fa5b06.es6

@@ -0,0 +1,59 @@
+!(angular => {
+  'use strict';
+
+  class ResultController {
+    constructor($scope, getResultCsv, AlertFlash, $window) {
+      this._alertFlash = AlertFlash;
+      this._$window = $window;
+      this.getCsv = () => getResultCsv(this.result.item.id);
+
+      /* Need to poll in the directive otherwise wonky-ness occurs in the UI
+         When we run from the query details tab */
+      this.result.poller.poll();
+      $scope.$on('$destroy', () => {
+        this.result.poller.unPoll();
+      });
+    }
+
+    resultHasParameters() {
+      if (!this.result.item.parameters) {
+        return false;
+      } else {
+        return _.keys(this.result.item.parameters).length > 0;
+      }
+    }
+
+    deleteResult() {
+      return this.result.destroy().then(result => {
+        this._alertFlash.emitInfo('Result id = ' + result.id + ' has be deleted!');
+        if (this.results) {
+          this.results.remove(result);
+        } else {
+          return result;
+        }
+      });
+    }
+  }
+
+  ResultController.$inject = ['$scope', 'getResultCsv', 'AlertFlash', '$window'];
+
+  function resultComponent() {
+    return {
+      restrict: 'E',
+      scope: {
+        'result': '=',
+        'results': '='
+      },
+      templateUrl: 'result',
+      controller: 'ResultController',
+      controllerAs: 'resultCtrl',
+      bindToController: true
+    };
+  }
+
+  angular
+    .module('alephDirectives.result', ['alephServices'])
+    .controller('ResultController', ResultController)
+    .directive('result', resultComponent);
+
+}(angular));

data/public/assets/angular/directives/result/results_directive.js-fcbf9750790823a11ca313e630bd2b0f.es6

@@ -0,0 +1,30 @@
+!(angular => {
+  'use strict';
+
+  class ResultsController {
+    runQuery() {
+      this.resultRunner.run();
+    }
+  }
+
+  function resultsComponent() {
+    return {
+      restrict: 'E',
+      scope: {
+        'query': '=',
+        'results': '=',
+        'resultRunner': '='
+      },
+      templateUrl: 'results',
+      controller: 'ResultsController',
+      controllerAs: 'resultsCtrl',
+      bindToController: true
+    };
+  }
+
+  angular
+    .module('alephDirectives.results', ['alephServices'])
+    .controller('ResultsController', ResultsController)
+    .directive('results', resultsComponent);
+
+}(angular));