aleph_analytics 0.0.0.alpha

data/public/assets/angular/services/query/query.js-7b6228d0a5c1a6ea76242f4aa49aafd0.es6

@@ -0,0 +1,55 @@
+!(angular => {
+  'use strict';
+
+  function QueryModelImports(QueryResource, ParameterMethods, StandardModel, $q) {
+
+    return class Query extends StandardModel {
+
+      constructor() {
+        super(
+          'query',
+          QueryResource,
+          {
+            title: '',
+            tags: [],
+            version: {
+              body: '',
+              parameters: []
+            }
+          },
+          [
+            'title',
+            'version.body',
+            'roles',
+            'tags'
+          ]
+        );
+      }
+
+      initItem(queryId, queryVersionId) {
+        if (queryId && queryVersionId) {
+          return super.fetch({
+            id: queryId,
+            version_id: queryVersionId
+          });
+        } else {
+          this.item = this._newItem();
+          return $q.when(this.item);
+        }
+      }
+
+      detectParameters() {
+        ParameterMethods.detectParameters(this.item.version.body, this.item.version.parameters);
+      }
+
+      addParameter(name) {
+        let parameter = ParameterMethods.constructParameter(name);
+        this.item.version.parameters.push(parameter);
+      }
+    };
+  }
+
+  QueryModelImports.$inject = ['QueryResource', 'ParameterMethods', 'StandardModel', '$q'];
+  angular.module('alephServices.query', []).service('Query', QueryModelImports);
+
+}(angular));

data/public/assets/angular/services/query/query_handler.js-d8cb3c66bcf6d16cd13bb5bcd0921496.es6

@@ -0,0 +1,40 @@
+!(angular => {
+  'use strict';
+
+  class QueryHandler {
+    constructor($location, AlertFlash, $q) {
+      this._alertFlash = AlertFlash;
+      this._$location = $location;
+      this._$q = $q;
+    }
+
+    success(action, schedule, query) {
+      let _action =  action || 'action';
+      let _schedule = _.exists(schedule) ? schedule : false;
+
+      this._alertFlash.emitSuccess('Query "' + query.title + '" ' + _action + 'd!', _schedule);
+      return query;
+    }
+
+    handleReplExit(error) {
+      if(error === 'QueryReplExit') {
+        // consume the error
+        this._alertFlash.emitInfo('Exited editing REPL without saving', false);
+      } else {
+        return this._$q.reject(error);
+      }
+    }
+
+    navigateToLatestVersion(query) {
+      this._$location.path('/queries/' + query.id + '/query_versions/' + query.version.id);
+      return query;
+    }
+
+    navigateToIndex() {
+      this._$location.path('/queries');
+    }
+  }
+
+  QueryHandler.$inject = ['$location', 'AlertFlash', '$q'];
+  angular.module('alephServices.queryHandler', []).service('QueryHandler', QueryHandler);
+}(angular));

data/public/assets/angular/services/query/query_loader.js-1fbc8b859778d46b73b9adc300984851.es6

@@ -0,0 +1,54 @@
+!(angular => {
+  'use strict';
+
+  class QueryLoader {
+    constructor($routeParams, Query, QueryVersions, Results, VisualizationService) {
+      this._Query = Query;
+      this._QueryVersion = QueryVersions;
+      this._Results = Results;
+      this._VisualizationService = VisualizationService;
+      this._$routeParams = $routeParams;
+    }
+
+    initialize() {
+      this.query = new this._Query();
+      this.queryVersions = new this._QueryVersion();
+      this.results = new this._Results();
+      this.queryId = this._$routeParams.query_id;
+      this.queryVersionId = this._$routeParams.query_version_id || 'latest';
+    }
+
+    load() {
+      return this.query.initItem(this.queryId, this.queryVersionId)
+        .then(this.loadQueryVersions.bind(this))
+        .then(this.loadResults.bind(this))
+        .then(this.loadVisualizations.bind(this));
+    }
+
+    loadQueryVersions(query) {
+      return this.queryVersions.initCollection(query.id).then(versions => {
+        return { query: query, queryVersions: versions };
+      });
+    }
+
+    loadResults(prev) {
+      let query = prev.query;
+      return this.results.initCollection({
+        query_id: query.id,
+        query_version_id: query.version.id
+      }).then(results => {
+        return _.merge(prev, { results: results });
+      });
+    }
+
+    loadVisualizations(prev) {
+      let query = prev.query;
+      return this._VisualizationService.load(query.id, query.version.id).then(visualizations => {
+        return _.merge(prev, { visualizations: visualizations });
+      });
+    }
+  }
+
+  QueryLoader.$inject = ['$routeParams', 'Query', 'QueryVersions', 'Results', 'VisualizationService'];
+  angular.module('alephServices.queryLoader', []).service('QueryLoader', QueryLoader);
+}(angular));

data/public/assets/angular/services/query/query_request_transformers.js-522901477c7848324cd5c014005a85c8.es6

@@ -0,0 +1,26 @@
+!(angular => {
+  'use strict';
+
+  function QueryRequestTransformers() {
+    const saveFields =  ['id', 'title', 'body', 'tags', 'result_id', 'version', 'roles'];
+
+    // see https://github.com/mbenford/ngTagsInput
+    function transformNgTagsInput(fieldName, query) {
+      let ngTags = query[fieldName];
+      if (_.exists(ngTags)) {
+        query[fieldName] = _.map(ngTags, ngTagItem =>  _.exists(ngTagItem.text) ? ngTagItem.text : ngTagItem);
+      }
+      return query;
+    }
+
+    return [
+      query => transformNgTagsInput('tags', query),
+      query => transformNgTagsInput('roles', query),
+      query => { return { query: _.selectKeys(query, saveFields) }; },
+      angular.toJson
+    ];
+  }
+
+  angular.module('alephServices.queryRequestTransformers', [])
+    .service('QueryRequestTransformers', QueryRequestTransformers);
+}(angular));

data/public/assets/angular/services/query/query_resource.js-b809fbfd1c379619fa07ef8e52509810.es6

@@ -0,0 +1,21 @@
+!(angular => {
+  'use strict';
+
+  function QueryResource(ResourceFactory, QueryRequestTransformers) {
+    return ResourceFactory.make('/queries/:id.json', {id: '@id'},
+      {
+        update: {
+          method: 'PUT',
+          transformRequest: QueryRequestTransformers
+        },
+        create: {
+          method: 'POST',
+          transformRequest: QueryRequestTransformers
+        }
+      }
+    );
+  }
+
+  QueryResource.$inject = ['ResourceFactory', 'QueryRequestTransformers'];
+  angular.module('alephServices.queryResource', []).service('QueryResource', QueryResource);
+}(angular));

data/public/assets/angular/services/query/query_tab.js-fe34f5e6d0c813d2d92838be14cd6783.es6

@@ -0,0 +1,63 @@
+!(angular => {
+  'use strict';
+
+  /* QueryTab does the following:
+    - Activate tabs
+    - Access tab info from url parameter
+    - Keeps state about which tab is active
+    - Programatically 'navigate' to tabs by setting activity and url parameters
+  */
+
+  class QueryTab {
+    constructor($location) {
+      this._initTabs();
+      this.$location = $location;
+      this._defaultTab = 'query';
+    }
+
+    set defaultTag(dt) {
+      this._defaultTab = dt;
+    }
+
+    get defaultTag() {
+      return this._defaultTab;
+    }
+
+    setActiveTabFromUrl() {
+      this._activateTab(this.getTab());
+    }
+
+    navigateToTab(tab) {
+      this._activateTab(tab);
+      this.setTab(tab);
+    }
+
+    setTab(s) {
+      this.$location.search('tab', s);
+    }
+
+    getTab() {
+      let rawTab = this.$location.search().tab;
+      return (rawTab === 'visualizations' || rawTab === 'results') ? rawTab : 'query';
+    }
+
+    // private methods
+
+    _initTabs() {
+      this.state = {
+        query: { active: false },
+        results: { active: false },
+        visualizations: { active: false }
+      };
+    }
+
+    _activateTab(tab) {
+      this._initTabs();
+      this.state[tab].active = true;
+    }
+  }
+
+  QueryTab.$inject = ['$location'];
+  angular.module('alephServices.queryTab', []).service('QueryTab', QueryTab);
+
+}(angular));

data/public/assets/angular/services/query/query_versions.js-aa3aec9021354a7394797101ea500887.es6

@@ -0,0 +1,21 @@
+!(angular => {
+  'use strict';
+
+  function QueryVersionsImports($resource, CollectionModelBase, UnpersistedModel) {
+
+    return class QueryVersions extends CollectionModelBase {
+
+      constructor() {
+        super(
+          { index: $resource('/queries/:id/query_versions/:query_version_id.json').query },
+          UnpersistedModel
+        );
+      }
+
+      initCollection(queryId) { return super.initCollection({id: queryId}); }
+    };
+  }
+
+  QueryVersionsImports.$inject = ['$resource', 'CollectionModelBase', 'UnpersistedModel'];
+  angular.module('alephServices.queryVersions', []).service('QueryVersions', QueryVersionsImports);
+}(angular));

data/public/assets/angular/services/result/result.js-be8178c80c767a651a97537b2b0149d5.es6

@@ -0,0 +1,26 @@
+!(angular => {
+  'use strict';
+
+  function ResultImport(ModelManager, ResultPoller) {
+
+    let ResultBase = ModelManager.forModelName('result').modelClass();
+    return class Result extends ResultBase {
+      constructor() {
+        super();
+        this.poller = new ResultPoller(this);
+      }
+
+      save(queryId, queryVersionId, options) {
+        let params = _.merge({
+          query_id: queryId,
+          query_version_id: queryVersionId
+        }, (options || {}));
+
+        return super.create(params);
+      }
+    };
+  }
+
+  ResultImport.$inject = ['ModelManager', 'ResultPoller'];
+  angular.module('alephServices.result', []).service('Result', ResultImport);
+}(angular));

data/public/assets/angular/services/result/result_poller.js-b15617d53f164cbe5636bb5573a70504.es6

@@ -0,0 +1,30 @@
+!(angular => {
+  'use strict';
+
+  function ResultPollerImports(PollService) {
+
+    return class ResultPoller {
+      constructor(result) {
+        this._result = result;
+      }
+
+      poll() {
+        let result = this._result.item;
+        this.pollingKey = 'result_' + result.id + '_' + new Date().getTime();
+
+        PollService.poll(
+          result,
+          this.pollingKey,
+          () => (result.status === 'complete' || result.status === 'failed') ? true : false
+        );
+      }
+
+      unPoll() {
+        PollService.unPoll(this.pollingKey);
+      }
+    };
+  }
+
+  ResultPollerImports.$inject = ['PollService'];
+  angular.module('alephServices.resultPoller', []).service('ResultPoller', ResultPollerImports);
+}(angular));

data/public/assets/angular/services/result/result_runner.js-ce2c5b3121c8e67903c302e600749c14.es6

@@ -0,0 +1,48 @@
+!(angular => {
+  'use strict';
+
+  function ResultRunnerImports(AlertFlash) {
+
+    return class ResultRunner {
+
+      constructor(query, results, options = {}) {
+        this.sandbox = options.sandbox ;
+        this.substitutionValues = options.substitutionValues || {};
+        this.results = results;
+        this.query = query;
+
+        this.enableAlert = options.enableAlert || false;
+        this.enablePolling = options.enablePolling || false;
+      }
+
+      get queryId() { return this.sandbox ? undefined : this.query.item.id; }
+      get queryVersionId() { return this.sandbox ? undefined : this.query.item.version.id; }
+      get body() { return this.sandbox ? this.query.item.version.body : undefined; }
+      get parameters() { return this.sandbox ? this.query.item.version.parameters : undefined; }
+
+      run() {
+        let Result = this.results.Model;
+        let result = new Result();
+        return result.save(this.queryId, this.queryVersionId, {
+          substitution_values: this.substitutionValues,
+          body: this.body,
+          parameters: this.parameters,
+          sandbox: this.sandbox
+        }).then(result => {
+          if(this.enableAlert) {
+            AlertFlash.emitInfo('Started running result, id = ' + result.id);
+          }
+
+          let resultModel = this.results.add(result);
+          if(this.enablePolling) {
+            resultModel.poller.poll();
+          }
+          return result;
+        });
+      }
+    };
+  }
+
+  ResultRunnerImports.$inject = ['AlertFlash'];
+  angular.module('alephServices.resultRunner', []).service('ResultRunner', ResultRunnerImports);
+}(angular));

data/public/assets/angular/services/result/results.js-53088d6088f6b4783b274a64322d361c.es6

@@ -0,0 +1,10 @@
+!(angular => {
+  'use strict';
+
+  function ResultsImports(Result, ModelManager) {
+    return ModelManager.forModelName('result').collectionClass(Result);
+  }
+
+  ResultsImports.$inject = ['Result', 'ModelManager'];
+  angular.module('alephServices.results', []).service('Results', ResultsImports);
+}(angular));

data/public/assets/angular/services/schema/schema_column.js-3908faecc9874fa08484d7490701a7d4.es6

@@ -0,0 +1,93 @@
+!(angular => {
+  'use strict';
+
+  /*
+    DirtyAwareModel-ish model with no concept isNew() (since there is no initItem).
+    Provides a facade via the composition of the schema column and schema comments
+  */
+
+  function SchemaColumnImports(SchemaCommentResource, ModelState, AlertFlash) {
+
+    return class SchemaColumn {
+
+      constructor() {
+        this.modelState = new ModelState(['comment_text']);
+        this.item = {};
+      }
+
+      internalize(item) {
+        this.item = item;
+      }
+
+      set item(item) {
+        this._item = item;
+        this.modelState.snapshotItem(this._item);
+      }
+
+      get item() {
+        return this._item;
+      }
+
+      isPersisted() {
+        return _.exists(this.item.comment_id);
+      }
+
+      isNew() {
+        return !_.exists(this.item.comment_text) || this.item.comment_text.length === 0;
+      }
+
+      isPristine() {
+        if(this.isNew()) return true;
+        if(!this.isPersisted()) return false;
+        return this.modelState.isPristine(this.item);
+      }
+
+      isDirty() {
+        return !this.isPristine();
+      }
+
+      isValidForSave() {
+        return !this.isPersisted() || this.modelState.isDirty(this.item);
+      }
+
+      save() {
+        let comment = this._toCommentObject();
+        let err = AlertFlash.emitError.bind(AlertFlash, 'Failed to save comment, id = ' + comment.id);
+
+        if(this.isPersisted()) {
+          return SchemaCommentResource.update(comment).$promise
+            .then(this._internalizeCommentInfo.bind(this))
+            .catch(err);
+        } else if(this.modelState.isDirty(this.item)) {
+          return SchemaCommentResource.create(comment).$promise
+            .then(this._internalizeCommentInfo.bind(this))
+            .catch(err);
+        }
+      }
+
+      //private methods
+
+      _internalizeCommentInfo(comment) {
+        this._item.comment_id = comment.id;
+        this._item.comment_text = comment.text;
+        this.modelState.snapshotItem(this._item);
+        return comment;
+      }
+
+      _toCommentObject() {
+        return {
+          id: this.item.comment_id,
+          text: this.item.comment_text,
+          schema: this.item.schema,
+          table: this.item.table,
+          column: this.item.column,
+          target_type: this.item.type // Comment field called 'target_type' because 'type' is special for for Rails STI
+        };
+      }
+    };
+  }
+
+  SchemaColumnImports.$inject = ['SchemaCommentResource', 'ModelState', 'AlertFlash'];
+  angular.module('alephServices.schema.column', []).service('SchemaColumn', SchemaColumnImports);
+
+}(angular));

data/public/assets/angular/services/schema/schema_column_resource.js-a6982ce9698b104192c4e455300df455.es6

@@ -0,0 +1,12 @@
+!(angular => {
+  'use strict';
+
+  function SchemaColumnResource(ResourceFactory) {
+    return ResourceFactory.make('/columns/:id.json', {id: '@id'});
+  }
+
+  SchemaColumnResource.$inject = ['ResourceFactory'];
+  angular.module('alephServices.schema.columnResource', [])
+    .service('SchemaColumnResource', SchemaColumnResource);
+
+}(angular));

data/public/assets/angular/services/schema/schema_columns.js-c63a16e2e0778a885bd27c7cf2ed7d88.es6

@@ -0,0 +1,57 @@
+!(angular => {
+  'use strict';
+
+  function ColumnModelImports(SchemaColumnResource, CollectionModelBase, UnpersistedModel) {
+
+    return class SchemaColumns extends CollectionModelBase {
+
+      constructor() {
+        super(SchemaColumnResource, UnpersistedModel);
+        this.uniqueSchemas = [];
+        this.uniqueTables = [];
+        this.uniqueColumns = [];
+        this.schemaTables = {};
+      }
+
+      initCollection() {
+        return super.initCollection().then(this._processUniqueAttributes.bind(this));
+      }
+
+      // private methods
+
+      _processUniqueAttributes(columns) {
+        let columnNames = [];
+        let tables = [];
+        let schemas = [];
+
+        _.each(columns, column => {
+          columnNames.push(column.item.column);
+          tables.push(column.item.table);
+          schemas.push(column.item.schema);
+          this._addToSchemaTables(column);
+        });
+
+        this.uniqueColumns = _.uniq(columnNames);
+        this.uniqueTables = _.uniq(tables);
+        this.uniqueSchemas = _.uniq(schemas);
+        return columns;
+      }
+
+      _addToSchemaTables(column) {
+        let tables = this.schemaTables[column.item.schema];
+        if(!tables) {
+          tables = [];
+          this.schemaTables[column.item.schema] = tables;
+        }
+
+        if(!_.contains(tables, column.item.table)) {
+          tables.push(column.item.table);
+        }
+      }
+    };
+  }
+
+  ColumnModelImports.$inject = ['SchemaColumnResource', 'CollectionModelBase', 'UnpersistedModel'];
+  angular.module('alephServices.schema.columns', []).service('SchemaColumns', ColumnModelImports);
+
+}(angular));

data/public/assets/angular/services/schema/schema_comment_resource.js-20254ea1a4e7b4850c9f21f9619130ce.es6

@@ -0,0 +1,12 @@
+!(angular => {
+  'use strict';
+
+  function SchemaCommentResource(ResourceFactory) {
+    return ResourceFactory.make('/schema_comments/:id.json', {id: '@id'});
+  }
+
+  SchemaCommentResource.$inject = ['ResourceFactory'];
+  angular.module('alephServices.schema.commentResource', [])
+    .service('SchemaCommentResource', SchemaCommentResource);
+
+}(angular));