blazer 0.0.8 → 1.0.0

data/app/assets/stylesheets/blazer/application.css

@@ -16,11 +16,11 @@ body {
   padding-bottom: 20px;
 }
 
-#results th {
+.results-table th {
   cursor: pointer;
 }
 
-#results thead {
+.results-table thead {
   background-color: #fff;
 }
 
@@ -68,3 +68,18 @@ input.search:focus {
 .ace_gutter-cell.error {
   background-color: red;
 }
+
+.chart {
+  height: 300px;
+  text-align: center;
+  display: flex;
+  justify-content: center;
+  flex-direction: column;
+}
+
+.chart > .results-container {
+  height: 300px;
+  border: solid 1px #ddd;
+  overflow: scroll;
+  text-align: left;
+}

data/app/assets/stylesheets/blazer/selectize.default.css

@@ -1,6 +1,6 @@
 /**
- * selectize.default.css (v0.10.1) - Default Theme
- * Copyright (c) 2013 Brian Reavis & contributors
+ * selectize.default.css (v0.12.1) - Default Theme
+ * Copyright (c) 2013–2015 Brian Reavis & contributors
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
  * file except in compliance with the License. You may obtain a copy of the License at:
@@ -189,6 +189,7 @@
   border: 1px solid #aaaaaa;
 }
 .selectize-input > input {
+  display: inline-block !important;
   padding: 0 !important;
   min-height: 0 !important;
   max-height: none !important;

data/app/controllers/blazer/base_controller.rb

@@ -0,0 +1,48 @@
+module Blazer
+  class BaseController < ApplicationController
+    # skip all filters
+    skip_filter *_process_action_callbacks.map(&:filter)
+
+    protect_from_forgery with: :exception
+
+    if ENV["BLAZER_PASSWORD"]
+      http_basic_authenticate_with name: ENV["BLAZER_USERNAME"], password: ENV["BLAZER_PASSWORD"]
+    end
+
+    layout "blazer/application"
+
+    before_action :ensure_database_url
+
+    private
+
+    def ensure_database_url
+      render text: "BLAZER_DATABASE_URL required" if !ENV["BLAZER_DATABASE_URL"] && !Rails.env.development?
+    end
+
+    def process_vars(statement)
+      (@bind_vars ||= []).concat(extract_vars(statement)).uniq!
+      @success = @bind_vars.all? { |v| params[v] }
+
+      if @success
+        @bind_vars.each do |var|
+          value = params[var].presence
+          value = value.to_i if value.to_i.to_s == value
+          if var.end_with?("_at")
+            value = Blazer.time_zone.parse(value) rescue nil
+          end
+          statement.gsub!("{#{var}}", ActiveRecord::Base.connection.quote(value))
+        end
+      end
+    end
+
+    def extract_vars(statement)
+      statement.scan(/\{.*?\}/).map { |v| v[1...-1] }.uniq
+    end
+    helper_method :extract_vars
+
+    def variable_params
+      params.except(:controller, :action, :id, :host, :query, :table_names, :authenticity_token, :utf8, :_method, :commit, :statement, :data_source)
+    end
+    helper_method :variable_params
+  end
+end

data/app/controllers/blazer/checks_controller.rb

@@ -0,0 +1,51 @@
+module Blazer
+  class ChecksController < BaseController
+    before_action :set_check, only: [:edit, :update, :destroy, :run]
+
+    def index
+      @checks = Blazer::Check.joins(:query).includes(:query).order("state, blazer_queries.name, blazer_checks.id").to_a
+      @checks.select! { |c| "#{c.query.name} #{c.emails}".downcase.include?(params[:q]) } if params[:q]
+    end
+
+    def new
+      @check = Blazer::Check.new
+    end
+
+    def create
+      @check = Blazer::Check.new(check_params)
+
+      if @check.save
+        redirect_to run_check_path(@check)
+      else
+        render :new
+      end
+    end
+
+    def update
+      if @check.update(check_params)
+        redirect_to run_check_path(@check)
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @check.destroy
+      redirect_to checks_path
+    end
+
+    def run
+      @query = @check.query
+    end
+
+    private
+
+    def check_params
+      params.require(:check).permit(:query_id, :emails)
+    end
+
+    def set_check
+      @check = Blazer::Check.find(params[:id])
+    end
+  end
+end

data/app/controllers/blazer/dashboards_controller.rb

@@ -0,0 +1,94 @@
+module Blazer
+  class DashboardsController < BaseController
+    before_action :set_dashboard, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @dashboards = Blazer::Dashboard.order(:name)
+    end
+
+    def new
+      @dashboard = Blazer::Dashboard.new
+    end
+
+    def create
+      @dashboard = Blazer::Dashboard.new
+
+      if update_dashboard(@dashboard)
+        redirect_to dashboard_path(@dashboard)
+      else
+        render :new
+      end
+    end
+
+    def show
+      @queries = @dashboard.dashboard_queries.order(:position).preload(:query).map(&:query)
+      @queries.each do |query|
+        process_vars(query.statement)
+      end
+      @bind_vars ||= []
+
+      @smart_vars = {}
+      @sql_errors = []
+      data_sources = @queries.map { |q| Blazer.data_sources[q.data_source] }.uniq
+      @bind_vars.each do |var|
+        data_sources.each do |data_source|
+          query = data_source.smart_variables[var]
+          if query
+            rows, error = data_source.run_statement(query)
+            (@smart_vars[var] ||= []).concat rows.map { |v| v.values.reverse }
+            @sql_errors << error if error
+          end
+        end
+      end
+    end
+
+    def edit
+    end
+
+    def update
+      if update_dashboard(@dashboard)
+        redirect_to dashboard_path(@dashboard)
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @dashboard.destroy
+      redirect_to dashboards_path
+    end
+
+    protected
+
+    def dashboard_params
+      params.require(:dashboard).permit(:name)
+    end
+
+    def set_dashboard
+      @dashboard = Blazer::Dashboard.find(params[:id])
+    end
+
+    def update_dashboard(dashboard)
+      dashboard.assign_attributes(dashboard_params)
+      Blazer::Dashboard.transaction do
+        if params[:query_ids].is_a?(Array)
+          query_ids = params[:query_ids].map(&:to_i)
+          @queries = Blazer::Query.find(query_ids).sort_by { |q| query_ids.index(q.id) }
+        end
+        if dashboard.save
+          if @queries
+            @queries.each_with_index do |query, i|
+              dashboard_query = dashboard.dashboard_queries.where(query_id: query.id).first_or_initialize
+              dashboard_query.position = i
+              dashboard_query.save!
+            end
+            if dashboard.persisted?
+              dashboard.dashboard_queries.where.not(query_id: query_ids).destroy_all
+            end
+          end
+          true
+        end
+      end
+    end
+  end
+end

data/app/controllers/blazer/queries_controller.rb

@@ -1,27 +1,16 @@
 module Blazer
-  class QueriesController < ApplicationController
-    # skip all filters
-    skip_filter *_process_action_callbacks.map(&:filter)
-
-    protect_from_forgery with: :exception
-
-    if ENV["BLAZER_PASSWORD"]
-      http_basic_authenticate_with name: ENV["BLAZER_USERNAME"], password: ENV["BLAZER_PASSWORD"]
-    end
-
-    layout "blazer/application"
-
-    before_action :ensure_database_url
+  class QueriesController < BaseController
     before_action :set_query, only: [:show, :edit, :update, :destroy]
 
     def index
       @queries = Blazer::Query.order(:name)
       @queries = @queries.includes(:creator) if Blazer.user_class
       @trending_queries = Blazer::Audit.group(:query_id).where("created_at > ?", 2.days.ago).having("COUNT(DISTINCT user_id) >= 3").uniq.count(:user_id)
+      @checks = Blazer::Check.group(:query_id).count
     end
 
     def new
-      @query = Blazer::Query.new(statement: params[:statement])
+      @query = Blazer::Query.new(statement: params[:statement], data_source: params[:data_source])
     end
 
     def create
@@ -41,10 +30,11 @@ module Blazer
 
       @smart_vars = {}
       @sql_errors = []
+      data_source = Blazer.data_sources[@query.data_source]
       @bind_vars.each do |var|
-        query = smart_variables[var]
+        query = data_source.smart_variables[var]
         if query
-          rows, error = run_statement(query)
+          rows, error = data_source.run_statement(query)
           @smart_vars[var] = rows.map { |v| v.values.reverse }
           @sql_errors << error if error
         end
@@ -57,19 +47,31 @@ module Blazer
     def run
       @statement = params[:statement]
       process_vars(@statement)
+      @only_chart = params[:only_chart]
 
       if @success
         @query = Query.find_by(id: params[:query_id]) if params[:query_id]
 
+        data_source = params[:data_source]
+        data_source = @query.data_source if @query && @query.data_source
+
         # audit
         if Blazer.audit
           audit = Blazer::Audit.new(statement: @statement)
           audit.query = @query
+          audit.data_source = data_source
           audit.user = current_user if respond_to?(:current_user) && Blazer.user_class
           audit.save!
         end
 
-        @rows, @error = run_statement(@statement)
+        @data_source = Blazer.data_sources[data_source]
+        @rows, @error = @data_source.run_statement(@statement)
+
+        if @query && !@error.to_s.include?("canceling statement due to statement timeout")
+          @query.checks.each do |check|
+            check.update_state(@rows, @error)
+          end
+        end
 
         @columns = {}
         if @rows.any?
@@ -88,19 +90,19 @@ module Blazer
 
         @filename = @query.name.parameterize if @query
 
-        @min_width_types = (@rows.first || {}).select { |k, v| v.is_a?(Time) || v.is_a?(String) || smart_columns[k] }.keys
+        @min_width_types = (@rows.first || {}).select { |k, v| v.is_a?(Time) || v.is_a?(String) || @data_source.smart_columns[k] }.keys
 
         @boom = {}
         @columns.keys.each do |key|
-          query = smart_columns[key]
+          query = @data_source.smart_columns[key]
           if query
             values = @rows.map { |r| r[key] }.compact.uniq
-            rows, error = run_statement(ActiveRecord::Base.send(:sanitize_sql_array, [query.sub("{value}", "(?)"), values]))
+            rows, error = @data_source.run_statement(ActiveRecord::Base.send(:sanitize_sql_array, [query.sub("{value}", "(?)"), values]))
             @boom[key] = Hash[rows.map(&:values)]
           end
         end
 
-        @linked_columns = linked_columns
+        @linked_columns = @data_source.linked_columns
       end
 
       respond_to do |format|
@@ -126,18 +128,19 @@ module Blazer
       redirect_to root_url
     end
 
-    private
-
-    def ensure_database_url
-      render text: "BLAZER_DATABASE_URL required" if !ENV["BLAZER_DATABASE_URL"] && !Rails.env.development?
+    def tables
+      @tables = Blazer.data_sources[params[:data_source]].tables.keys
+      render partial: "tables", layout: false
     end
 
+    private
+
     def set_query
       @query = Blazer::Query.find(params[:id].to_s.split("-").first)
     end
 
     def query_params
-      params.require(:query).permit(:name, :description, :statement)
+      params.require(:query).permit(:name, :description, :statement, :data_source)
     end
 
     def csv_data(rows)
@@ -150,80 +153,5 @@ module Blazer
         end
       end
     end
-
-    def run_statement(statement)
-      rows = []
-      error = nil
-      begin
-        Blazer::Connection.transaction do
-          Blazer::Connection.connection.execute("SET statement_timeout = #{Blazer.timeout * 1000}") if Blazer.timeout && postgresql?
-          result = Blazer::Connection.connection.select_all(statement)
-          result.each do |untyped_row|
-            row = {}
-            untyped_row.each do |k, v|
-              row[k] = result.column_types.empty? ? v : result.column_types[k].send(:type_cast, v)
-            end
-            rows << row
-          end
-          raise ActiveRecord::Rollback
-        end
-      rescue ActiveRecord::StatementInvalid => e
-        error = e.message.sub(/.+ERROR: /, "")
-      end
-      [rows, error]
-    end
-
-    def extract_vars(statement)
-      statement.scan(/\{.*?\}/).map { |v| v[1...-1] }.uniq
-    end
-
-    def process_vars(statement)
-      @bind_vars = extract_vars(statement)
-      @success = @bind_vars.all? { |v| params[v] }
-
-      if @success
-        @bind_vars.each do |var|
-          value = params[var].presence
-          value = value.to_i if value.to_i.to_s == value
-          if var.end_with?("_at")
-            value = Blazer.time_zone.parse(value) rescue nil
-          end
-          statement.gsub!("{#{var}}", ActiveRecord::Base.connection.quote(value))
-        end
-      end
-    end
-
-    def variable_params
-      params.except(:controller, :action, :id, :host, :query, :table_names, :authenticity_token, :utf8, :_method, :commit, :statement)
-    end
-    helper_method :variable_params
-
-    def settings
-      YAML.load(File.read(Rails.root.join("config", "blazer.yml")))
-    end
-
-    def linked_columns
-      settings["linked_columns"] || {}
-    end
-
-    def smart_columns
-      settings["smart_columns"] || {}
-    end
-
-    def smart_variables
-      settings["smart_variables"] || {}
-    end
-
-    def tables
-      default_schema = postgresql? ? "public" : Blazer::Connection.connection_config[:database]
-      schema = Blazer::Connection.connection_config[:schema] || default_schema
-      rows, error = run_statement(Blazer::Connection.send(:sanitize_sql_array, ["SELECT table_name, column_name, ordinal_position, data_type FROM information_schema.columns WHERE table_schema = ?", schema]))
-      Hash[rows.group_by { |r| r["table_name"] }.map { |t, f| [t, f.sort_by { |f| f["ordinal_position"] }.map { |f| f.slice("column_name", "data_type") }] }.sort_by { |t, _f| t }]
-    end
-    helper_method :tables
-
-    def postgresql?
-      Blazer::Connection.connection.adapter_name == "PostgreSQL"
-    end
   end
 end