aleph_analytics 0.0.0.alpha

data/app/assets/javascripts/angular/directives/result/result_directive.js.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/app/assets/javascripts/angular/directives/result/results_directive.js.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));

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

@@ -0,0 +1,101 @@
+!(angular => {
+  'use strict';
+
+  class VisualizationController {
+
+    constructor($sce, VisualizationService, DefaultAceConfigurator) {
+      /* initialize visualization components and expose in controller */
+      VisualizationService.initService();
+      this.visualization = VisualizationService.visualization;
+      this.visualizations = VisualizationService.visualizations;
+      this.sourceRenderer = VisualizationService.sourceRenderer;
+      VisualizationService.sourceRenderer.setResults(this.results);
+      this.presetDisplayList = () => VisualizationService.presetDisplayList;
+      this._service = VisualizationService;
+
+      /* aceLoaded is bound to ui-ace config object */
+      let _this = this;
+      this.aceLoaded = function aceLoaded(editor) {
+        new DefaultAceConfigurator(editor);
+        editor.setOptions({
+          maxLines: 40,
+          minLines: 2
+        });
+        _this.aceEditor = editor;
+      };
+
+      this._$sce = $sce;
+    }
+
+    toggleEditor() {
+      this.editorSelected = !this.editorSelected;
+
+      // FIXME: we have to do this because ng-model on ace does not work while hidden
+      if (this.editorSelected) {
+        this.aceEditor.setValue(this.visualization.item.html_source, -1);
+      }
+    }
+
+    renderedSource() {
+      return this.sourceRenderer.isValid() ? this._$sce.trustAsHtml(this.sourceRenderer.rendered()) : '';
+    }
+
+    save() {
+      // TODO: use bootbox.js to dress this up
+      if(!this.visualization.hasTitle()) {
+        let answer = prompt("Please enter a title for this visualization:");
+        if (answer === null || answer === '') {
+          return;
+        }
+        this.visualization.item.title = answer;
+      }
+
+      this.visualization.save(this.queryId, this.queryVersionId).then(() => {
+        this.visualizations.initCollection({ query_id: this.queryId, query_version_id: this.queryVersionId });
+      });
+    }
+
+    destroy() {
+      this.visualization.destroy().then(() => {
+        this._service.load(this.queryId, this.queryVersionId);
+      });
+    }
+
+    selectVisualization(visualization) {
+      this.visualization.internalize(visualization);
+    }
+
+    selectPreset(presetName) {
+      if(this.visualization.isDirty()) {
+        let answer = confirm('You are about to overwrite some unsaved changes, proceed?');
+        if (!answer) return;
+      }
+      this.visualization.initItem().then(() => {
+        this.visualization.item.html_source = this._service.presets[presetName];
+      });
+    }
+  }
+
+  VisualizationController.$inject = ['$sce', 'VisualizationService', 'DefaultAceConfigurator'];
+
+  function visualizationComponent() {
+    return {
+      restrict: 'E',
+      scope: {
+        'queryId': '=',
+        'queryVersionId': '=',
+        'results': '='
+      },
+      templateUrl: 'visualization',
+      controller: 'VisualizationController',
+      controllerAs: 'vizShowCtrl',
+      bindToController: true
+    };
+  }
+
+  angular
+    .module('alephDirectives.visualization', ['alephServices'])
+    .controller('VisualizationController', VisualizationController)
+    .directive('visualization', visualizationComponent);
+
+}(angular));

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

@@ -0,0 +1,27 @@
+!(angular => {
+  'use strict';
+
+  angular
+    .module('alephFilters', [])
+    .filter('objectDotKeys', () => {
+      // this is literally only needed because of https://github.com/angular/angular.js/issues/6210
+      return input => {
+        return Object.keys(input);
+      };
+    })
+
+    .filter('humanReadableDuration', () => {
+      return (original_seconds) => {
+        let SECONDS_IN_HOUR = 3600;
+        let SECONDS_IN_MINUTE = 60;
+
+        let hours = Math.floor(original_seconds / SECONDS_IN_HOUR);
+        let minutes = Math.floor((original_seconds % SECONDS_IN_HOUR) / SECONDS_IN_MINUTE);
+        let seconds = Math.round(original_seconds % SECONDS_IN_MINUTE);
+
+        return ((original_seconds > SECONDS_IN_HOUR) ? hours + ' hours ' : '') +
+               ((original_seconds > SECONDS_IN_MINUTE) ? minutes + ' minutes ' : '') +
+               seconds + ' seconds';
+      };
+    });
+}(angular));

data/app/assets/javascripts/angular/services/alert/alert.js.es6

@@ -0,0 +1,51 @@
+!(angular => {
+  'use strict';
+
+  function AlertModelImports(AlertResource, StandardModel, PollService) {
+
+    return class Alert extends StandardModel {
+
+      constructor() {
+        super(
+          'alert',
+          AlertResource,
+          {
+            email: '',
+            query_title: '',
+            target: NaN,
+            comparator: '',
+            status: '',
+            description: ''
+          },
+          [
+            'email',
+            'comparator',
+            'target',
+            'description',
+            'query_title'
+          ]
+         );
+        this._pollItemKey = 'alertItem_' + new Date().getTime();
+      }
+
+      save() {
+        if (this.item.status !== 'Paused') {
+          this.item.status = 'Pending';
+        }
+
+        return super.save().then(this._pollItem.bind(this));
+      }
+
+      //private methods
+
+      _pollItem(item) {
+        PollService.unPoll(this._pollItemKey);
+        PollService.poll(item, this._pollItemKey, () => item.status !== 'Pending');
+        return item;
+      }
+    };
+  }
+
+  AlertModelImports.$inject = ['AlertResource', 'StandardModel', 'PollService'];
+  angular.module('alephServices.alert', []).service('Alert', AlertModelImports);
+}(angular));

data/app/assets/javascripts/angular/services/alert/alert_resource.js.es6

@@ -0,0 +1,10 @@
+!(angular => {
+  'use strict';
+
+  function AlertResource(ResourceFactory) {
+    return ResourceFactory.make('/alerts/:id.json', {id: '@id'});
+  }
+
+  AlertResource.$inject = ['ResourceFactory'];
+  angular.module('alephServices.alertResource', []).service('AlertResource', AlertResource);
+}(angular));

data/app/assets/javascripts/angular/services/lib/ace_completers.js.es6

@@ -0,0 +1,29 @@
+!(angular => {
+  'use strict';
+
+  class AceCompleters {
+    constructor(SchemaCompleter, KeywordCompleter) {
+      this.langTools = ace.require('ace/ext/language_tools');
+      this.schemaCompleter = new SchemaCompleter();
+      this.keywordCompleter = new KeywordCompleter();
+    }
+
+    ensureSchemasData() {
+      if (!this.schemaCompleter.isLoaded()) {
+        return this.schemaCompleter.loadColumnData();
+      }
+    }
+
+    setCompleters() {
+      this.langTools.setCompleters([
+        this.schemaCompleter,
+        this.keywordCompleter,
+        this.langTools.textCompleter,
+        this.langTools.snippetCompleter
+      ]);
+    }
+  }
+
+  AceCompleters.$inject = ['SchemaCompleter', 'KeywordCompleter'];
+  angular.module('alephServices.aceCompleters', []).service('AceCompleters', AceCompleters);
+}(angular));

data/app/assets/javascripts/angular/services/lib/ace_sql_parse.js.es6

@@ -0,0 +1,156 @@
+!(angular => {
+  'use strict';
+
+  function AceSqlParse(session, cursorPos) {
+    let Search = ace.require('ace/search').Search;
+    let search = new Search();
+    let Range = ace.require('ace/range').Range;
+    let previousOccurances = [];
+    let nextOccurances = [];
+    let locationsInitialized = false;
+    let relevantFromBoundariesForClause = {
+      select: {
+        start: {
+          location: nextOccurances,
+          type: 'from'
+        },
+        end: {
+          location: nextOccurances,
+          type: 'where'
+        }
+      },
+      from: {
+        start: {
+          location: previousOccurances,
+          type: 'from'
+        },
+        end: {
+          location: nextOccurances,
+          type: 'where'
+        }
+      },
+      where: {
+        start: {
+          location: previousOccurances,
+          type: 'from'
+        },
+        end: {
+          location: previousOccurances,
+          type: 'where'
+        }
+      }
+    };
+    let currentClause;
+
+    function previousOccurance(word) {
+      search.set({needle: word, start: cursorPos, wholeWord: true, backwards: true,  wrap: false});
+      return findResult(word);
+    }
+
+    function nextOccurance(word) {
+      search.set({needle: word, start: cursorPos, wholeWord: true, backwards: false, wrap: false});
+      return findResult(word);
+    }
+
+    function findResult(word) {
+      let result = search.find(session);
+      if (_.exists(result)) {
+        return _.merge(result, {type: word});
+      }
+    }
+
+    function sortPositions(positionObjects) {
+      return positionObjects.sort(function (a, b) {
+        let aRow = a.start.row;
+        let bRow = b.start.row;
+        let aColumn = a.start.column;
+        let bColumn = b.start.column;
+
+        if (aRow === bRow) {
+          return (aColumn < bColumn) ? -1 : (aColumn > bColumn) ? 1 : 0;
+        } else {
+          return (aRow < bRow) ? -1 : 1;
+        }
+      });
+    }
+
+    function initLocations() {
+      _.each(['select', 'from', 'where'], function(clause) {
+        previousOccurances.push(previousOccurance(clause));
+        nextOccurances.push(nextOccurance(clause));
+      });
+
+      previousOccurances = _.compact(previousOccurances);
+      nextOccurances = _.compact(nextOccurances);
+      locationsInitialized = true;
+    }
+
+    function parseCurrentClause() {
+      if (locationsInitialized === false) { initLocations(); }
+      if (previousOccurances.length === 0) { return false; }
+
+      let locationsWithCursor = _.union(previousOccurances, [{start: cursorPos, type: 'cursor'}]);
+
+      let sorted = sortPositions(locationsWithCursor);
+      let cursorIndex = _.findIndex(sorted, {type: 'cursor'});
+      let recentObject = sorted[cursorIndex - 1];
+
+      currentClause = recentObject.type;
+      return currentClause;
+    }
+
+    function parseFromClause() {
+      if (locationsInitialized === false) { initLocations(); }
+      if (!_.exists(currentClause)) { parseCurrentClause(); }
+
+      let rangeStartWord,
+        rangeEndWord,
+        fromLocation = relevantFromBoundariesForClause[currentClause];
+
+      if (_.exists(fromLocation)) {
+        rangeStartWord = _.findWhere(fromLocation.start.location, {type: fromLocation.start.type});
+        rangeEndWord = _.findWhere(fromLocation.end.location, {type: fromLocation.end.type}) ||
+          _.findWhere(nextOccurances, {type: 'select'});
+      }
+
+      if (!_.exists(rangeStartWord)) {
+        rangeStartWord = defaultFromRangeStart();
+      }
+
+      if (!_.exists(rangeEndWord)) {
+        rangeEndWord = defaultFromRangeEnd();
+      }
+
+      let range = new Range(rangeStartWord.end.row, rangeStartWord.end.column,
+        rangeEndWord.start.row, rangeEndWord.start.column);
+      return session.getTextRange(range);
+    }
+
+    function defaultFromRangeStart() {
+      return {
+        end: {
+          row: 0,
+          column: 0
+        }
+      };
+    }
+
+    function defaultFromRangeEnd() {
+      let aceDocument = session.getDocument();
+      let rows = aceDocument.getLength();
+      let lastLine = aceDocument.getLine(rows - 1);
+      let width = lastLine.length;
+
+      return {
+        start: {
+          row: rows,
+          column: width
+        }
+      };
+    }
+
+    return {currentClause: parseCurrentClause(), fromClause: parseFromClause()};
+  }
+
+  angular.module('alephServices.aceSqlParse', []).service('aceSqlParse', () => AceSqlParse);
+}(angular));

data/app/assets/javascripts/angular/services/lib/action_handler.js.es6

@@ -0,0 +1,73 @@
+!(angular => {
+  'use strict';
+
+  function ActionHandlerImports(AlertFlash, SpinnerState, $q) {
+
+    return class ActionHandler {
+
+      constructor(modelName, options = {}) {
+        let noop = () => undefined;
+        this._modelName = modelName;
+        this._modelItem = options.modelItem || noop;
+        this._modelCollection = options.modelCollection || noop;
+
+        this.wrapFetch = _.partial(this.wrapAction, 'fetching');
+        this.wrapUpdate = _.partial(this.wrapAction, 'updating');
+        this.wrapCreate = _.partial(this.wrapAction, 'creating');
+        this.wrapDestroy = _.partial(this.wrapAction, 'deleting');
+
+        // handlers for collection models
+        this.wrapInitCollection = _.partial(this.wrapAction, 'loading');
+        this.wrapCollectionSave = _.partial(this.wrapAction, 'saving');
+      }
+
+      wrapAction(actionName, f) {
+        let spinner = SpinnerState.withContext(this._modelName + '.' + actionName);
+        spinner.on();
+        return f()
+          .then(this.onSuccess.bind(this, actionName))
+          .catch(this.onError.bind(this, actionName))
+          .finally(spinner.off.bind(spinner));
+      }
+
+      // protected methods
+
+      onError(action, e) {
+        AlertFlash.emitDanger(this._msg('Failed', action));
+        return $q.reject(e);
+      }
+
+      onSuccess(action, o) {
+        // TODO: implement something sweet if we only had like a status bar or something
+        return o;
+      }
+
+      // private
+
+      _msg(status, action) {
+        return status + ' ' + action + ' ' + this._modelName + this._itemSuffix();
+      }
+
+      _itemSuffix() {
+        let item = this._modelItem();
+        let collection = this._modelCollection();
+
+        let suffix = '';
+        if(_.exists(item)) {
+          if(_.exists(item.title) && item.title.length !== 0) {
+            suffix = ', title = ' + item.title;
+          } else if (_.exists(item.id) && item.id > 0) {
+            suffix = ', id = ' + item.id;
+          }
+        } else if(_.exists(collection)) {
+          suffix = ', count = ' + collection.length;
+        }
+        return suffix;
+      }
+    };
+  }
+
+  ActionHandlerImports.$inject = ['AlertFlash', 'SpinnerState', '$q'];
+  angular.module('alephServices.actionHandler', []).service('ActionHandler', ActionHandlerImports);
+
+}(angular));

data/app/assets/javascripts/angular/services/lib/alert_flash.js.es6

@@ -0,0 +1,30 @@
+!(angular => {
+  'use strict';
+
+  class AlertFlash {
+    constructor($rootScope) {
+      this._$rootScope = $rootScope;
+      this.emitSuccess = _.partial(this.emit, 'success');
+      this.emitInfo = _.partial(this.emit, 'info');
+      this.emitWarning = _.partial(this.emit, 'warning');
+      this.emitDanger = _.partial(this.emit, 'danger');
+    }
+
+    emit(type, message, schedule) {
+      this._$rootScope.$broadcast(schedule ? 'scheduleAlert' : 'setAlert', {
+        type: type,
+        message: message
+      });
+    }
+
+    // use this if you need to surface raw error to user
+    emitError(message, error) {
+      let e =  ' => ' + (_.exists(error) ? error : '');
+      this.emitDanger(message + e);
+    }
+  }
+
+  AlertFlash.$inject = ['$rootScope'];
+  angular.module('alephServices.alertFlash', []).service('AlertFlash', AlertFlash);
+
+}(angular));

data/app/assets/javascripts/angular/services/lib/default_ace_configurator_service.js.es6

@@ -0,0 +1,74 @@
+!(angular => {
+  'use strict';
+
+  function DefaultAceConfiguratorImports(ModelManager, AceSnippetManager) {
+
+    return class DefaultAceConfigurator {
+
+      constructor(editor) {
+        this._editor = editor;
+        this._defaultConfig();
+
+        this._Snippet = ModelManager.forModelName('snippet').modelClass();
+        this._Snippets = ModelManager.forModelName('snippet').collectionClass(this._Snippet);
+        this._snippets = new this._Snippets();
+      }
+
+      readOnlyConfig() {
+        this._editor.setReadOnly(true);
+        this._editor.renderer.$cursorLayer.element.style.opacity=0;
+        this._editor.setOptions({
+          highlightActiveLine: false,
+          highlightGutterLine: false,
+          maxLines: 25,
+          minLines: 2
+        });
+        return this;
+      }
+
+      autoCompleteConfig() {
+        this._editor.setOptions({
+          enableSnippets: true,
+          enableBasicAutocompletion: true,
+          enableLiveAutocompletion: true
+        });
+        return this;
+      }
+
+      snippetsConfig() {
+        AceSnippetManager.reset();
+        this._snippets.initCollection().then(snippets => {
+          _.each(snippets, snippet => {
+            AceSnippetManager.add(snippet.item.name, snippet.item.content);
+          });
+        });
+
+        this.autoCompleteConfig();
+
+        return this;
+      }
+
+      // private method
+
+      _defaultConfig() {
+        let session = this._editor.getSession();
+        session.setTabSize(2);
+        session.setUseSoftTabs(true);
+        this._editor.setPrintMarginColumn(100);
+        this._editor.setShowPrintMargin(true);
+        this._editor.setBehavioursEnabled(true);
+        this._editor.$blockScrolling = Infinity;
+        this._editor.setOptions({
+          maxLines: 25,
+          minLines: 2
+        });
+      }
+    };
+  }
+
+  DefaultAceConfiguratorImports.$inject = ['ModelManager', 'AceSnippetManager'];
+  angular
+    .module('alephServices.defaultAceConfigurator', [])
+    .service('DefaultAceConfigurator', DefaultAceConfiguratorImports);
+
+}(angular));