aleph_analytics 0.0.0.alpha

data/public/assets/angular/services/services.js-6225c5ea24a9082506d1932d7884b53b.es6

@@ -0,0 +1,140 @@
+!(angular => {
+  'use strict';
+
+  angular
+    .module('alephServices', [
+      'ngResource',
+
+      // query & query version
+      'alephServices.queryRequestTransformers',
+      'alephServices.queryResource',
+      'alephServices.queryHandler',
+      'alephServices.queryVersions',
+      'alephServices.queryTab',
+      'alephServices.query',
+      'alephServices.queryLoader',
+
+      // visualzations
+      'alephServices.visualizationService',
+      'alephServices.visualization',
+      'alephServices.visualizations',
+      'alephServices.sourceRenderer',
+
+      // results
+      'alephServices.results',
+      'alephServices.result',
+      'alephServices.resultRunner',
+      'alephServices.resultPoller',
+
+      // alerts
+      'alephServices.alertResource',
+      'alephServices.alert',
+
+      //snippets
+      'alephServices.aceSnippetManager',
+
+      //model framework
+      'models',
+      'modelGeneration',
+
+      // schema
+      'alephServices.schema.columns',
+      'alephServices.schema.columnResource',
+      'alephServices.schema.column',
+      'alephServices.schema.commentResource',
+
+      // roles
+      'alephServices.roleModel',
+
+      // general
+      'alephServices.schemaCompleter',
+      'alephServices.alertFlash',
+      'alephServices.pageTitleManager',
+      'alephServices.navigationGuard',
+      'alephServices.aceCompleters',
+      'alephServices.selectionTagInput',
+      'alephServices.paginationComponents',
+      'alephServices.pagination',
+      'alephServices.openReplService',
+      'alephServices.matcherRunner',
+      'alephServices.actionHandler',
+      'alephServices.aceSqlParse',
+      'alephServices.pollService',
+      'alephServices.lockService',
+      'alephServices.localResource',
+      'alephServices.githubUrlService',
+      'alephServices.defaultAceConfigurator',
+      'alephServices.parameterMethods',
+      'alephServices.tagResource',
+      'alephServices.keywordCompleter',
+      'alephServices.spinnerState',
+      'alephServices.serverConfigurations'
+    ])
+
+    .constant('defaultDateFormat', 'yyyy-MM-dd')
+    .constant('ApplicationTitle', 'Aleph')
+
+    /* N.B below is not a comprehensive list of all the models we use.
+       These are auto generated standard models */
+    .constant('ModelDefinitions', {
+      result: {
+        newItem: {
+          sample_data: [],
+          row_count: 0,
+          parameters: [],
+          headers: []
+        },
+        resource: {
+          path: '/results/:id.json',
+          parameters: {id: '@id'},
+          actions: {
+            index: {
+              method: 'GET',
+              isArray: true,
+              url: '/queries/:query_id/query_versions/:query_version_id/results.json'
+            }
+          }
+        }
+      },
+
+      snippet: {
+        newItem: { name: '', content: '' },
+        resource: {
+          path: '/snippets/:id.json',
+          parameters: {id: '@id'}
+        }
+      },
+
+      visualization: {
+        newItem: {
+          html_source: '',
+          title: ''
+        },
+        resource: {
+          path: '/visualizations/:id.json',
+          parameters: {id: '@id'},
+          actions: {
+            index: {
+              method: 'GET',
+              isArray: true,
+              url: '/queries/:query_id/query_versions/:query_version_id/visualizations.json'
+            }
+          }
+        }
+      }
+    })
+
+    .service('getResultCsv', ['$http', '$window', ($http, $window) => {
+      return function getResultCsv(resultId, failureMessage = 'The CSV file for this result was not found.') {
+        $http.get('/result_csvs/' + resultId + '.json')
+          .success(data => {
+            $window.open(data.url, '_self', '');
+            return data;
+          })
+          .error(() => {
+            $window.alert(failureMessage);
+          });
+      };
+    }]);
+
+}(angular));

data/public/assets/angular/services/snippet/ace_snippet_manager.js-dbbba5d8ad5040042b469b294c4d7228.es6

@@ -0,0 +1,44 @@
+!(function (angular) {
+  'use strict';
+
+  class AceSnippetManager {
+    constructor() {
+      this._context = 'pgsql';
+      this._aceSnippetManager = ace.require('ace/snippets').snippetManager;
+    }
+
+    set context(c) {
+      this._context = c;
+    }
+
+    get context() {
+      return this._context;
+    }
+
+    add(name, content) {
+      this._aceSnippetManager.register(this._parseSnippet(name, content), this._context);
+    }
+
+    remove(name, content) {
+      this._aceSnippetManager.unregister(this._parseSnippet(name, content), this._context);
+    }
+
+    reset() {
+      this._aceSnippetManager.snippetMap = {};
+      this._aceSnippetManager.snippetNameMap = {};
+    }
+
+    // private method
+
+    _parseSnippet(name, content) {
+      let composed = 'snippet ' + name + ' \n\t ' + this._transformNewlines(content);
+      return this._aceSnippetManager.parseSnippetFile(composed);
+    }
+
+    _transformNewlines(content) {
+      return content.replace(/(\r\n|\n|\r)/gm, '\n\t');
+    }
+  }
+
+  angular.module('alephServices.aceSnippetManager', []).service('AceSnippetManager', AceSnippetManager);
+}(angular));

data/public/assets/angular/services/visualization/source_renderer.js-d7274c88b067a35f2e91bf7f39be7d47.es6

@@ -0,0 +1,70 @@
+!(angular => {
+  'use strict';
+
+  class SourceRenderer {
+
+    constructor(visualization) {
+      this._visualization = visualization;
+    }
+
+    setTemplate(template) {
+      this._compiledTemplate = _.template(template);
+    }
+
+    setResults(results) {
+      this.results = results;
+    }
+
+    latestResult() {
+      let latestResult;
+
+      _(this.results.items())
+        .sortBy('id')
+        .reverse()
+        .forEach(result => {
+          if (!_.exists(latestResult) && result.status === 'complete') {
+            latestResult = result;
+          }
+        });
+
+      return latestResult;
+    }
+
+    isValid() {
+      return this._visualization.hasSource() && this.latestResult() && _.exists(this._compiledTemplate);
+    }
+
+    rendered() {
+      let result = this.latestResult();
+      if(this._visualization.hasSource() && result && _.exists(this._compiledTemplate)) {
+        this._internalizeToLocalStorage(result);
+        return this._compiledTemplate({
+          result_id: result.id,
+          panel: '#chart-panel',
+          body: this._visualization.item.html_source
+        });
+      } else {
+        return null;
+      }
+    }
+
+    // private methods
+
+    _internalizeToLocalStorage(result) {
+      SerializedStorage.set('DATASET', result.sample_data);
+      SerializedStorage.set('COLUMNS', this._toColumns(result.headers, result.sample_data));
+      SerializedStorage.set('HEADERS', result.headers);
+    }
+
+    _toColumns(headers, dataset) {
+      let arr = [];
+      headers.forEach((header, idx) => {
+        arr.push([header].concat(dataset.map(row => row[idx])));
+      });
+      return arr;
+    }
+  }
+
+  angular.module('alephServices.sourceRenderer', []).service('SourceRenderer', () => SourceRenderer);
+
+}(angular));

data/public/assets/angular/services/visualization/visualization.js-23e36c87721aa263dd3f99769027cabb.es6

@@ -0,0 +1,47 @@
+!(angular => {
+  'use strict';
+
+  function VisualizationImports(ModelManager) {
+
+    let VisualizationBase = ModelManager.forModelName('visualization').modelClass();
+    return class Visualization extends VisualizationBase {
+
+      constructor() {
+        super();
+        this.hasSource  = this.itemHas.bind(this, 'html_source');
+        this.hasTitle   = this.itemHas.bind(this, 'title');
+      }
+
+      itemHas(property) {
+        return Utils.stringHelpers.isPresent(this.item[property]);
+      }
+
+      save(queryId, queryVersionId) {
+        return this._save(queryId, queryVersionId);
+      }
+
+      destroy() {
+        return super.destroy().then(() => this.initItem());
+      }
+
+      // private methods
+
+      _save(queryId, queryVersionId) {
+        if(this.isPersisted()) {
+          return super.update(this.item);
+        } else {
+          let createParams = _.merge({
+            query_id: queryId,
+            query_version_id: queryVersionId
+          }, this.item);
+
+          return super.create(createParams);
+        }
+      }
+    };
+  }
+
+  VisualizationImports.$inject = ['ModelManager'];
+  angular.module('alephServices.visualization', []).service('Visualization', VisualizationImports);
+
+}(angular));

data/public/assets/angular/services/visualization/visualization_service.js-25de86b5ceef60cf2b1dfde5fb0e9216.es6

@@ -0,0 +1,67 @@
+!(angular => {
+  'use strict';
+
+  class VisualizationService {
+
+    constructor(SourceRenderer, Visualization, Visualizations, LocalResource, $q) {
+      this.visualization = new Visualization();
+      this.visualizations = new Visualizations();
+      this.sourceRenderer = new SourceRenderer(this.visualization);
+      this.setResults = this.sourceRenderer.setResults.bind(this.sourceRenderer);
+
+      this.presetDisplayList = [];
+      this.presets = {};
+
+      this._localResource = new LocalResource('visualization');
+      this._$q = $q;
+    }
+
+    load(queryId, queryVersionId) {
+      return this.visualizations
+        .initCollection({
+          query_id: queryId,
+          query_version_id: queryVersionId
+        })
+        .then(visualizations => {
+          if(_.exists(visualizations[0])) {
+            this.visualization.internalize(visualizations[0].item);
+          } else {
+            this.visualization.initItem();
+          }
+          return visualizations;
+        });
+    }
+
+    initService() {
+      return this._loadPresets().then(this._loadTemplate.bind(this));
+    }
+
+    // private method
+
+    _loadTemplate() {
+      let _this = this;
+      return this._localResource.get('template.json').then(response => {
+        _this.sourceRenderer.setTemplate(response.data.template.join('\n'));
+      });
+    }
+
+    _loadPresets() {
+      let _this = this;
+      return this._localResource.get('presets.json').then(response => {
+          _this.presetDisplayList = _.keys(response.data);
+          return response.data;
+        }).then(presets => {
+          return _this._$q.all(_.mapObject(presets, (file, name) => {
+            _this._localResource.get(file).then(response => {
+                _this.presets[name] = response.data;
+                return response.data;
+              });
+          }));
+        });
+    }
+  }
+
+  VisualizationService.$inject = ['SourceRenderer', 'Visualization', 'Visualizations', 'LocalResource', '$q'];
+  angular.module('alephServices.visualizationService', []).service('VisualizationService', VisualizationService);
+
+}(angular));

data/public/assets/angular/services/visualization/visualizations.js-1227bc3dcd67e85c8050d82360a26d53.es6

@@ -0,0 +1,11 @@
+!(angular => {
+  'use strict';
+
+  function VisualizationsImports(Visualization, ModelManager) {
+    return ModelManager.forModelName('visualization').collectionClass(Visualization);
+  }
+
+  VisualizationsImports.$inject = ['Visualization', 'ModelManager'];
+  angular.module('alephServices.visualizations', []).service('Visualizations', VisualizationsImports);
+
+}(angular));