aleph_analytics 0.0.0.alpha

data/app/controllers/application_controller.rb

@@ -0,0 +1,38 @@
+class ApplicationController < ActionController::Base
+  ALLOWABLE_CONFIGS = %w(github_ref github_owner github_app_name github_repo)
+
+  if Authentication.type.disabled?
+    before_action :set_guest_user
+  else
+    before_action :authenticate_user!
+  end
+  before_filter :set_hostname
+  before_filter :set_cache_buster
+  helper_method :app_config
+
+  rescue_from CanCan::AccessDenied do
+    #redirect_to unauthorized_path
+    render :unauthorized, layout: false, status: :unauthorized
+  end
+
+  private
+
+  def app_config
+    APP_CONFIG.select { |k, _| ALLOWABLE_CONFIGS.include?(k) }.to_json
+  end
+
+  def set_hostname
+    @hostname = request.host
+  end
+
+  def set_cache_buster
+    response.headers["Cache-Control"] = "no-cache, no-store, max-age=0, must-revalidate"
+    response.headers["Pragma"] = "no-cache"
+    response.headers["Expires"] = "#{1.year.ago}"
+  end
+
+  def set_guest_user
+    logger.warn('AUTHENTICATION DISABLED: SIGNING IN GUEST USER') if Rails.env.production?
+    sign_in(User.guest_user)
+  end
+end

data/app/controllers/columns_controller.rb

@@ -0,0 +1,21 @@
+class ColumnsController < ApplicationController
+  respond_to :json
+
+  def index
+    respond_to do |format|
+      if Role.configured_connections.include?(current_user.role)
+        items = Schemas::Descriptors.instance.get(current_user.role).columns
+        SchemaCommentMatcher.enrich(items) if params[:with_comments]
+        format.json { render json: JSON.pretty_generate(paginate(items)) }
+      else
+        format.json { head :ok }
+      end
+    end
+  end
+
+  private
+
+  def paginate(items)
+    Schemas::Paginate.new([:schema, :table, :column, :comment_text]).page(items, params)
+  end
+end

data/app/controllers/queries_controller.rb

@@ -0,0 +1,85 @@
+class QueriesController < ApplicationController
+  respond_to :html, :json
+
+  load_and_authorize_resource only: [:index, :show, :update, :destroy]
+  before_filter :set_query_version, only: [:show]
+  before_filter :set_query_version_from_query, only: [:update]
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        @paginated_queries = Query.paginated(@queries, query_pagination_params)
+        render json: @paginated_queries, each_serializer: QueryIndexSerializer
+      end
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.html { render :index }
+      format.json { render json: @query }
+    end
+  end
+
+  def create
+    respond_to do |format|
+      format.json do
+        interaction = Interaction::QueryCreation.new(params[:query].merge(user: current_user))
+        @query = interaction.execute
+
+        if interaction.errors.any?
+          render json: { success: false, errors: interaction.errors }, status: :unprocessable_entity
+        else
+          render json: @query, status: :created
+        end
+      end
+    end
+  end
+
+  def update
+    respond_to do |format|
+      format.json do
+        interaction = Interaction::QueryUpdate.new(@query, params[:query].merge(user: current_user))
+        updated_query = interaction.execute
+
+        if interaction.errors.any?
+          render json: { success: false, errors: interaction.errors }, status: :unprocessable_entity
+        else
+          render json: updated_query, status: :ok
+        end
+      end
+    end
+  end
+
+  def destroy
+    respond_to do |format|
+      format.json do
+        @query.destroy!
+        render json: @query
+      end
+    end
+  end
+
+  private
+
+  def retrieve_query
+    @query = Query.find(params[:id])
+  end
+
+  def query_pagination_params
+    params.permit(:limit, :offset, :search, :sort_by, :sort_descending, :reset)
+  end
+
+  def set_query_version
+    if params[:version_id] && params[:version_id] != 'latest'
+      @query.version = QueryVersion.find(params[:version_id])
+    end
+  end
+
+  def set_query_version_from_query
+    if params[:query][:version] && params[:query][:version][:id]
+      @query.version = QueryVersion.find(params[:query][:version][:id])
+    end
+  end
+end

data/app/controllers/query_versions_controller.rb

@@ -0,0 +1,38 @@
+class QueryVersionsController < ApplicationController
+  respond_to :html, :json
+
+  before_filter :retrieve_query_version, only: :show
+  authorize_resource only: [:show]
+
+  def index
+    respond_to do |format|
+      format.json do
+        @query_versions = query_versions.accessible_by(current_ability)
+        render json: @query_versions
+      end
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.html { render :index }
+      format.json do
+        render json: @query_version
+      end
+    end
+  end
+
+  private
+
+  def retrieve_query_version
+    @query_version ||= if params[:id] == 'latest'
+      query_versions.first
+    else
+      QueryVersion.find(params[:id])
+    end
+  end
+
+  def query_versions
+    QueryVersion.where(query_id: params[:query_id]).order('version DESC')
+  end
+end

data/app/controllers/result_csvs_controller.rb

@@ -0,0 +1,29 @@
+class ResultCsvsController < ApplicationController
+  respond_to :json
+  before_filter :authorize_from_result, only: [:show]
+  before_filter :log_download, only: [:show]
+
+  def show
+    respond_to do |format|
+      format.json do
+        url = CsvService.new(params[:id]).url
+        if url
+          render json: { url: url }
+        else
+          render nothing: true, status: 404
+        end
+      end
+    end
+  end
+
+  private
+
+  def authorize_from_result
+    authorize! :read, Result.find(params[:id])
+  end
+
+  def log_download
+    Rails.logger.info("Result CSV download requested for result #{params[:id]} by user_id #{current_user.id}")
+  end
+
+end

data/app/controllers/results_controller.rb

@@ -0,0 +1,53 @@
+class ResultsController < ApplicationController
+  include QueryVersionSupport
+
+  respond_to :json, :html
+  load_and_authorize_resource only: [:show, :destroy]
+  before_filter :retrieve_query_version, if: -> { params[:query_id] }, only: [:index]
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        @results = @query_version.results.accessible_by(current_ability)
+        render json: @results
+      end
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.json { render json: @result }
+    end
+  end
+
+  def destroy
+    respond_to do |format|
+      format.json do
+        @result.destroy!
+        render json: @result
+      end
+    end
+  end
+
+  def create
+    interaction = Interaction::ResultCreation.new(result_params)
+    result = interaction.execute
+
+    if interaction.errors.any?
+      render json: interaction.errors, status: :unprocessable_entity
+    else
+      Resque.enqueue(QueryExecution, result.id, current_user.role)
+      render json: result, status: :created
+    end
+  end
+
+  private
+
+  def result_params
+    params.permit(:body, :query_version_id, :query_id).tap do |whitelisted|
+      whitelisted[:substitution_values] = params[:substitution_values]
+      whitelisted[:parameters] = params[:parameters]
+    end.merge(owner: current_user)
+  end
+end

data/app/controllers/roles_controller.rb

@@ -0,0 +1,9 @@
+class RolesController < ApplicationController
+  respond_to :json
+
+  def index
+    respond_to do |format|
+      format.json { render json: User.distinct.pluck(:role) }
+    end
+  end
+end

data/app/controllers/schema_comments_controller.rb

@@ -0,0 +1,47 @@
+class SchemaCommentsController < ApplicationController
+  respond_to :json
+  before_filter :fetch_schema_comment, only: [:update, :destroy]
+
+  def create
+    respond_to do |format|
+      format.json do
+        schema_comment = SchemaComment.create(schema_comment_params)
+
+        if schema_comment.errors.any?
+          render json: { success: false, errors: schema_comment.errors }, status: :unprocessable_entity
+        else
+          render json: schema_comment
+        end
+      end
+    end
+  end
+
+  def update
+    respond_to do |format|
+      format.json do
+        @schema_comment.update(schema_comment_params)
+
+        if @schema_comment.errors.any?
+          render json: { success: false, errors: @schema_comment.errors }, status: :unprocessable_entity
+        else
+          render json: @schema_comment
+        end
+      end
+    end
+  end
+
+  def destroy
+    @schema_comment.destroy
+    redirect_to queries_path
+  end
+
+  private
+
+  def fetch_schema_comment
+    @schema_comment = SchemaComment.find(params[:id])
+  end
+
+  def schema_comment_params
+    params.permit(:table, :schema, :column, :target_type, :text).merge(user: current_user)
+  end
+end

data/app/controllers/snippets_controller.rb

@@ -0,0 +1,67 @@
+class SnippetsController < ApplicationController
+  respond_to :json
+
+  wrap_parameters :snippet, include: [:name, :content]
+  before_filter :retrieve_snippet, only: [:update, :show, :destroy]
+
+  def create
+    respond_to do |format|
+      format.json do
+        snippet = Snippet.create(snippet_params.merge(user_id: current_user.id))
+
+        if snippet.errors.any?
+          render json: snippet.errors.full_messages, status: :unprocessable_entity
+        else
+          render json: snippet, status: :created
+        end
+      end
+    end
+  end
+
+  def update
+    respond_to do |format|
+      format.json do
+        @snippet.update_attributes!(snippet_params)
+
+        if @snippet.errors.any?
+          render json: @snippet.errors.full_messages, status: :unprocessable_entity
+        else
+          render json: @snippet
+        end
+      end
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.json { render json: @snippet }
+      format.html { render template: 'application/index' }
+    end
+  end
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json { render json: Snippet.all }
+    end
+  end
+
+  def destroy
+    respond_to do |format|
+      format.json do
+        @snippet.destroy!
+        render json: @snippet
+      end
+    end
+  end
+
+  private
+
+  def retrieve_snippet
+    @snippet = Snippet.find(params[:id])
+  end
+
+  def snippet_params
+    params.require(:snippet).permit(:name, :content)
+  end
+end

data/app/controllers/tags_controller.rb

@@ -0,0 +1,19 @@
+class TagsController < ApplicationController
+  respond_to :json
+
+  def index
+    respond_to do |format|
+      format.json do
+        tags = begin
+          if params[:search]
+            ActsAsTaggableOn::Tag.distinct.where('name LIKE ?', "%#{params[:search]}%").pluck(:name)
+          else
+            ActsAsTaggableOn::Tag.distinct.pluck(:name)
+          end
+        end
+
+        render json: tags
+      end
+    end
+  end
+end

data/app/controllers/visualizations_controller.rb

@@ -0,0 +1,61 @@
+class VisualizationsController < ApplicationController
+  include QueryVersionSupport
+
+  respond_to :json, :html
+  load_and_authorize_resource only: [:update, :destroy]
+  before_filter :retrieve_query_version, if: -> { params[:query_id] }
+
+  def index
+    respond_to do |format|
+      format.html
+      format.json do
+        @visualizations = @query_version.visualizations.accessible_by(current_ability)
+        render json: @visualizations
+      end
+    end
+  end
+
+  def update
+    respond_to do |format|
+      format.json do
+        @visualization.update(visualization_params)
+
+        if @visualization.errors.any?
+          render json: { success: false, errors: @visualization.errors.full_messages }, status: :unprocessable_entity
+        else
+          render json: @visualization
+        end
+      end
+    end
+  end
+
+  def destroy
+    respond_to do |format|
+      format.json do
+        @visualization.destroy
+        render json: @visualization
+      end
+    end
+  end
+
+  def create
+    respond_to do |format|
+      format.json do
+        visualization = Visualization.create(visualization_params)
+
+        if visualization.errors.any?
+          render json: { success: false, errors: visualization.errors.full_messages }, status: :unprocessable_entity
+        else
+          @query_version.visualizations << visualization
+          render json: visualization, status: :created
+        end
+      end
+    end
+  end
+
+  private
+
+  def visualization_params
+    params.permit(:html_source, :title)
+  end
+end

data/app/mailers/alert_mailer.rb

@@ -0,0 +1,8 @@
+class AlertMailer < ActionMailer::Base
+  default from: ALERTS_CONFIG['from']
+
+  def alert_failing_email(alert)
+    @alert = alert
+    mail(to: @alert.email, subject: "Your Aleph alert '#{@alert.query_title}' has triggered")
+  end
+end

data/app/models/ability.rb

@@ -0,0 +1,31 @@
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    user ||= User.new
+
+    can :manage, Query, Query.with_role(user.role) do |query|
+      query.roles.include?(user.role)
+    end
+
+    can :manage, Alert, Alert.with_role(user.role) do |alert|
+      alert.query.roles.include?(user.role)
+    end
+
+    can :manage, QueryVersion, QueryVersion.with_role(user.role) do |query_version|
+      query_version.query.roles.include?(user.role)
+    end
+
+    can :manage, Result, Result.with_role(user.role) do |result|
+      if result.query
+        result.query.roles.include?(user.role)
+      else
+        user == result.owner
+      end
+    end
+
+    can :manage, Visualization, Visualization.with_role(user.role) do |visualization|
+      visualization.query.roles.include?(user.role)
+    end
+  end
+end

data/app/models/alert.rb

@@ -0,0 +1,139 @@
+require 'ostruct'
+
+class Alert < ActiveRecord::Base
+  extend PaginationSearch::Pagination
+
+  has_paper_trail
+  attr_accessor :query_title
+  cattr_accessor :cache
+  belongs_to :query
+  has_many :query_roles, through: :query
+  belongs_to :last_alert_result, class_name: 'Result'
+  has_many :query_versions, through: :query
+  has_many :users, through: :query
+  validates :email, :query, :target, :comparator, :query, presence: true
+  before_create :set_pending_status
+  before_save :update_query_title
+
+  delegate :latest_query_version, to: :query
+  delegate :user, to: :latest_query_version
+
+  scope :with_role, ->(role) { joins(:query).includes(:query_roles).where(query_roles: { role: role }) }
+
+  LOCATIONS_FOR_ATTRIBUTES = {
+    title:       { association: :query, column: :title, type: :text },
+    status:      { association: :base, column: :status, type: :text },
+    description: { association: :base, column: :description, type: :text },
+    author:      { association: :users, column: :name, type: :text },
+    updated_at:  { association: :base, column: :updated_at, type: :time },
+    created_at:  { association: :base, column: :created_at, type: :time }
+  }.freeze
+
+  INCLUDES_MODELS = [:query_versions, :query, :last_alert_result, :users].freeze
+
+  paginate_with LOCATIONS_FOR_ATTRIBUTES
+
+  STATUSES = OpenStruct.new(
+    {
+      pending: 'Pending',
+      errored: 'Errored',
+      passing: 'Passing',
+      failing: 'Failing',
+      paused:  'Paused'
+    }
+  )
+
+  COMPARISON_FUNCTIONS = {
+    '<' => :result_is_less_than_target,
+    '>' => :result_is_greater_than_target,
+    '=' => :result_is_equal_to_target
+  }
+
+  BAD_DATA_SIZE_MESSAGE = 'An alert result must return only a single row and a single column'
+  BAD_DATA_TYPE_MESSAGE = 'An alert must return a number'
+
+  def self.run_all
+    all.each(&:run)
+  end
+
+  def run
+    unless status == STATUSES.paused
+      Resque.enqueue(AlertExecution, id, user.role)
+    end
+  end
+
+  def error(message)
+    self.status = STATUSES.errored
+    self.error_message = message
+    save!
+    send_failing_email
+  end
+
+  def check_last_result
+    last_alert_result.reload
+    return if error_from_result_failure
+    data = last_alert_result.sample_data
+    return if error_from_data_size(data)
+    return unless value = to_number(data.first.first)
+    set_status_from_outcome(value)
+  end
+
+  def query_title
+    @query_title ||= query.title
+  end
+
+  private
+
+  def update_query_title
+    return query.update_attribute(:title, @query_title) if @query_title && !@query_title.empty?
+    true
+  end
+
+  def set_status_from_outcome(outcome_value)
+    failing = send(COMPARISON_FUNCTIONS.fetch(comparator), outcome_value)
+    if failing
+      self.status = STATUSES.failing
+      send_failing_email
+    else
+      self.status = STATUSES.passing
+    end
+    save!
+  end
+
+  def send_failing_email
+    AlertMailer.alert_failing_email(self).deliver_now!
+  rescue
+    # note: this code is typically called in a resque_worker, so you may not see the below
+    Rails.logger.warn("Could not send alert failing email, please check your alerts configuration's smtp settings")
+  end
+
+  def result_is_less_than_target(result)
+    result < target
+  end
+
+  def result_is_greater_than_target(result)
+    result > target
+  end
+
+  def result_is_equal_to_target(result)
+    result == target
+  end
+
+  def set_pending_status
+    self.status = STATUSES.pending
+  end
+
+  def error_from_result_failure
+    error(last_alert_result.error_message) if last_alert_result.status == 'failed'
+  end
+
+  def error_from_data_size(data)
+    error(BAD_DATA_SIZE_MESSAGE) if data.length != 1 || data.first.length != 1
+  end
+
+  def to_number(string)
+    float = Float(string) rescue false
+    error(BAD_DATA_TYPE_MESSAGE) unless float
+    float
+  end
+end

data/app/models/alert_execution.rb

@@ -0,0 +1,25 @@
+class AlertExecution
+  @queue = :alert_exec
+
+  def self.perform(alert_id, role)
+    alert = Alert.find(alert_id)
+    alert.status = Alert::STATUSES.pending
+    alert.save!
+
+    interaction = Interaction::ResultCreation.new(
+      query_version_id: alert.latest_query_version.id,
+      owner: alert.user
+    )
+
+    result = interaction.execute
+
+    if interaction.errors.any?
+      alert.error(interaction.errors.join(', '))
+    else
+      alert.last_alert_result = result
+      alert.save!
+      QueryExecution.perform(result.id, role)
+      alert.check_last_result
+    end
+  end
+end