RubyGems - simple_drilldown - Versions diffs - 0.0.3 → 0.1.0 - Mend

simple_drilldown 0.0.3 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (62) hide show

checksums.yaml +5 -5
data/{LICENSE.txt → MIT-LICENSE} +1 -3
data/README.md +15 -16
data/Rakefile +32 -0
data/app/assets/config/simple_drilldown_manifest.js +1 -0
data/app/assets/stylesheets/simple_drilldown/application.css +121 -0
data/app/controllers/simple_drilldown/application_controller.rb +7 -0
data/app/helpers/simple_drilldown/application_helper.rb +6 -0
data/app/jobs/simple_drilldown/application_job.rb +6 -0
data/app/mailers/simple_drilldown/application_mailer.rb +8 -0
data/app/models/simple_drilldown/application_record.rb +7 -0
data/app/views/drilldown/_chart.html.erb +57 -0
data/app/views/drilldown/_excel_record_list.builder +7 -0
data/app/views/drilldown/_excel_row.builder +24 -0
data/app/views/drilldown/_excel_row_header.builder +10 -0
data/app/views/drilldown/_excel_styles.builder +69 -0
data/app/views/drilldown/_excel_summary_row.builder +16 -0
data/app/views/drilldown/_excel_summary_total_row.builder +14 -0
data/app/views/drilldown/_field.html.erb +39 -0
data/app/views/drilldown/_fields.html.erb +12 -0
data/app/views/drilldown/_filter.html.erb +20 -0
data/app/views/drilldown/_record_list.html.erb +12 -0
data/app/views/drilldown/_row.html.erb +13 -0
data/app/views/drilldown/_row_header.html.erb +8 -0
data/app/views/drilldown/_summary_row.html.erb +18 -0
data/app/views/drilldown/_summary_table.html.erb +12 -0
data/app/views/drilldown/_summary_total_row.html.erb +4 -0
data/app/views/drilldown/_tab_buttons.html.erb +5 -0
data/app/views/drilldown/data_0.builder +10 -0
data/app/views/drilldown/data_1.builder +11 -0
data/app/views/drilldown/data_2.builder +37 -0
data/app/views/drilldown/data_3.builder +37 -0
data/app/views/drilldown/excel_export.builder +42 -0
data/app/views/drilldown/excel_export_transactions.builder +90 -0
data/app/views/drilldown/html_export.html.erb +6 -0
data/app/views/drilldown/index.html.erb +107 -0
data/app/views/drilldown/print.html.erb +18 -0
data/app/views/layouts/simple_drilldown/application.html.erb +15 -0
data/config/locales/en.yml +23 -0
data/config/locales/nb.yml +20 -0
data/config/routes.rb +4 -0
data/lib/generators/drilldown_controller/USAGE +8 -0
data/lib/generators/drilldown_controller/drilldown_controller_generator.rb +8 -0
data/lib/generators/drilldown_controller/templates/drilldown_controller.rb.erb +41 -0
data/lib/simple_drilldown.rb +3 -3
data/lib/simple_drilldown/drilldown_controller.rb +389 -274
data/lib/simple_drilldown/drilldown_helper.rb +68 -0
data/lib/simple_drilldown/engine.rb +11 -0
data/lib/simple_drilldown/search.rb +12 -1
data/lib/simple_drilldown/version.rb +1 -1
data/lib/tasks/simple_drilldown_tasks.rake +5 -0
metadata +85 -34
data/.document +0 -5
data/.gitignore +0 -22
data/Gemfile +0 -3
data/Gemfile.lock +0 -89
data/README.rdoc +0 -19
data/lib/sample_drilldown_controller.rb +0 -95
data/lib/simple_drilldown/simple_drilldown_helper.rb +0 -66
data/simple_drilldown.gemspec +0 -24
data/test/helper.rb +0 -18
data/test/test_simple_drilldown.rb +0 -7

data/app/views/drilldown/print.html.erb ADDED Viewed

@@ -0,0 +1,18 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<%= render 'layouts/headers' %>
+<%= stylesheet_link_tag 'drilldown' %>
+<body>
+<style type="text/css">
+    @media print {#print_link {display: none}}
+</style>
+<div class="container">
+  <div id="print_link" class="pull-right">
+    <%= link_to '<i class="btn btn-primary glyphicon glyphicon-print"> Print</i>'.html_safe, '#', onclick: 'window.print();' %>
+  </div>
+  <%= yield %>
+</div>
+</body>
+</html>

data/app/views/layouts/simple_drilldown/application.html.erb ADDED Viewed

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Simple drilldown</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+  <%= stylesheet_link_tag    "simple_drilldown/application", media: "all" %>
+</head>
+<body>
+<%= yield %>
+</body>
+</html>

data/config/locales/en.yml ADDED Viewed

@@ -0,0 +1,23 @@
+en:
+  all: All
+  bar: Bar
+  chart_type: Chart type
+  count: Count
+  fields: Fields
+  filter: Filter
+  from_date: From date
+  group_by: Group by
+  line: Line
+  list: List
+  none: None
+  order_by_value: Order by value
+  pie: Pie
+  reset: Reset
+  search: Search
+  show: Show
+  then_by: then by
+  title: Title
+  to_date: To date

data/config/locales/nb.yml ADDED Viewed

@@ -0,0 +1,20 @@
+nb:
+  all: Alle
+  bar: Stolper
+  chart_type: Graftype
+  count: Antall
+  fields: Felt
+  filter: Filter
+  from_date: Fra dato
+  group_by: Grupper på
+  line: Linje
+  list: Liste
+  none: Ingen
+  order_by_value: Sorter på verdi
+  pie: Pai
+  reset: Nullstill
+  search: Søk
+  show: Vis
+  then_by: så på
+  title: Tittel
+  to_date: Til dato

data/config/routes.rb ADDED Viewed

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+SimpleDrilldown::Engine.routes.draw do
+end

data/lib/generators/drilldown_controller/USAGE ADDED Viewed

@@ -0,0 +1,8 @@
+Description:
+    Create a DrilldownController.
+Example:
+    rails generate drilldown_controller Thing
+    This will create:
+        app/controllers/thing_drilldown_controller.rb

data/lib/generators/drilldown_controller/drilldown_controller_generator.rb ADDED Viewed

@@ -0,0 +1,8 @@
+class DrilldownControllerGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+  def copy_drilldown_controller_file
+    template "drilldown_controller.rb.erb", "app/controllers/#{file_name}_drilldown_controller.rb"
+    route "resources(:#{singular_name}_drilldown, only: :index){collection{get :excel_export;get :html_export}}"
+  end
+end

data/lib/generators/drilldown_controller/templates/drilldown_controller.rb.erb ADDED Viewed

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+class <%= class_name %>DrilldownController < DrilldownController
+  # What fields should be displayed as default when listing actual <%= class_name %> records.
+  default_fields %w[created_at updated_at] # TODO(uwe): Read fields from schema?
+  # The main focus of the drilldown
+  target_class <%= class_name %>
+  # How should we count the reords?
+  select 'count(*) as count'
+  # When listing records, what relations should be included for optimization?
+  # list_includes :user, :comments # TODO(uwe): Read relations from schema?
+  # In what order should records be listed?
+  list_order '<%= plural_name %>.created_at'
+  # Field definitions when listing records
+  field :created_at
+  field :updated_at
+  # The "attr_method" option transforms the value from the database to a
+  # readable form.
+  # field :user, attr_method: ->(post) { post.user.name }
+  # field :body, attr_method: ->(post) { post.body[0..32] }
+  # field :comments, attr_method: ->(post) { post.comments.count }
+  dimension :calendar_date, 'DATE(<%= plural_name %>.created_at)', interval: true
+  dimension :day_of_month, "date_part('day', <%= plural_name %>.created_at)"
+  dimension :day_of_week, "CASE WHEN date_part('dow', <%= plural_name %>.created_at) = 0 THEN 7 ELSE date_part('dow', <%= plural_name %>.created_at) END",
+            label_method: ->(day_no) { Date::DAYNAMES[day_no.to_i % 7] }
+  dimension :hour_of_day, "date_part('hour', <%= plural_name %>.created_at)"
+  dimension :month, "date_part('month', <%= plural_name %>.created_at)",
+            label_method: ->(month_no) { Date::MONTHNAMES[month_no.to_i] }
+  dimension :week, "date_part('week', <%= plural_name %>.created_at)"
+  dimension :year, "date_part('year', <%= plural_name %>.created_at)"
+  # dimension :comments, 'SELECT count(*) FROM comments c WHERE c.<%= singular_name %>_id = <%= plural_name %>.id'
+  # dimension :user, 'users.name', includes: :user
+end

data/lib/simple_drilldown.rb CHANGED Viewed

@@ -1,6 +1,6 @@
-require "simple_drilldown/version"
-require 'simple_drilldown/search'
-require 'simple_drilldown/drilldown_controller'
+# frozen_string_literal: true
+require 'simple_drilldown/engine'
 module SimpleDrilldown
   # Your code goes here...

data/lib/simple_drilldown/drilldown_controller.rb CHANGED Viewed

@@ -1,318 +1,433 @@
-module DrilldownController
-  def initialize(fields, default_fields, target_class, select, list_includes, list_order)
-    super()
-    @fields = fields
-    @default_fields = default_fields
-    @target_class = target_class
-    @select = select
-    @list_includes = list_includes
-    @list_order = list_order
-  end
+# frozen_string_literal: true
-  def xml_export
-    params[:search][:list] = '1'
-    index(false)
-    @transactions = get_transactions(@result)
-    headers['Content-Type'] = "text/xml"
-    headers['Content-Disposition'] = 'attachment; filename="transactions.xml"'
-    render :template => '/transaction_drilldown/xml_export', :layout => false
-  end
+require 'simple_drilldown/drilldown_helper'
+require 'simple_drilldown/search'
-  # ?dimension[0]=supplier&dimension[1]=transaction_type&
-  # filter[year]=2009&filter[supplier][0]=Shell&filter[supplier][1]=Statoil
-  def index(do_render = true)
-    @search = Search.new(params[:search], @default_fields)
+module SimpleDrilldown
+  class DrilldownController < ::ApplicationController
+    helper DrilldownHelper
-    @transaction_fields = (@search.fields + ((@fields.keys.map { |field_name| field_name.to_s }) - @search.fields))
-    @transaction_fields_map = @fields
+    LIST_LIMIT = 10_000
-    select = @select.dup
-    includes = []
+    class << self
+      def base_condition(base_condition)
+        @@base_condition = base_condition
+      end
-    @dimensions = []
-    select << ", 'All' as value0"
-    @dimensions += @search.dimensions.map do |dn|
-      raise "Unknown distribution field: #{@search.dimensions.inspect}" if @dimension_defs[dn].nil?
-      @dimension_defs[dn]
-    end
-    @dimensions.each_with_index do |d, i|
-      select << ", #{d[:select_expression]} as value#{i + 1}"
-      includes << d[:includes] if d[:includes]
-    end
+      def base_includes(base_includes)
+        @@base_includes = base_includes
+      end
-    conditions, @filter_text, filter_includes = make_conditions(@search.filter)
-    includes += filter_includes
-    includes.uniq!
-    if @search.order_by_value && @dimensions.size <= 1
-      order = @search.select_value == Search::SelectValue::VOLUME ? 'volume DESC' : 'count DESC'
-    else
-      order = @dimensions.map { |d| d[:select_expression] }.join(', ')
-      order = nil if order.empty?
-    end
-    group = @dimensions.map { |d| d[:select_expression] }.join(', ')
-    group = nil if group.empty?
-    rows = @target_class.find(
-        :all, :select => select, :conditions => conditions,
-        :joins => make_join(@target_class.name.underscore.to_sym, includes), :group => group,
-        :order => order
-    )
-    if rows.empty?
-      @result = {:value => "All", :count => 0, :volume => 0, :volume_compensated => 0, :row_count => 0, :nodes => 0, :rows => []}
-    else
-      @result = result_from_rows(rows, 0, 0, ['All'])
-    end
-    @search.list = false if @result[:count] > 10000
+      def base_group(base_group)
+        @@base_group = base_group
+      end
-    @remaining_dimensions = @dimension_defs.dup.delete_if { |dim_name, dimension| @search.filter[dim_name] && @search.filter[dim_name].size == 1 }
-    populate_list(conditions, includes, @result, []) if @search.list
-    render :template => '/transaction_drilldown/index' if do_render
-  end
+      def default_fields(fields)
+        @@default_fields = fields
+      end
-  # Empty summary rows are needed to plot zero points in the charts
-  def add_zero_results(result_rows, dimension)
-    legal_values = legal_values_for(@dimensions[dimension][:url_param_name], true).call(@search).map { |lv| lv[1] }
-    current_values = result_rows.map { |r| r[:value] }.compact
-    empty_values = legal_values - current_values
-    unless empty_values.empty?
-      empty_values.each do |v|
-        sub_result = {
-            :value => v,
-            :count => 0,
-            :volume => 0,
-            :volume_compensated => 0,
-            :row_count => 0,
-            :nodes => 0,
-        }
-        if dimension < @dimensions.size - 1
-          sub_result[:rows] = add_zero_results([], dimension + 1)
-        end
-        result_rows << sub_result
+      def target_class(target_class)
+        @@target_class = target_class
       end
-      result_rows = result_rows.sort_by { |r| legal_values.index(r[:value]) }
-    end
-    result_rows
-  end
-  def result_from_rows(rows, row_index, dimension, previous_values)
-    row = rows[row_index]
-    return nil if row.nil?
-    values = (0..dimension).to_a.map { |i| row["value#{i}"] }
-    return nil if values != previous_values
-    if dimension == @dimensions.size
-      return {
-          :value => values[-1],
-          :count => row[:count].to_i,
-          :volume => row[:volume].to_i,
-          :volume_compensated => row[:volume_compensated].to_i,
-          :row_count => 1,
-          :nodes => 1,
-      }
-    end
+      def select(select)
+        @@select = select
+      end
-    result_rows = []
-    loop do
-      sub_result = result_from_rows(rows, row_index, dimension + 1, values + [rows[row_index]["value#{dimension + 1}"]])
-      break if sub_result.nil?
-      result_rows << sub_result
-      row_index += sub_result[:row_count]
-      break if rows[row_index].nil?
-    end
+      def list_includes(list_includes)
+        @@list_includes = list_includes
+      end
-    result_rows = add_zero_results(result_rows, dimension)
-    {
-        :value => values[-1],
-        :count => result_rows.inject(0) { |t, r| t + r[:count].to_i },
-        :volume => result_rows.inject(0) { |t, r| t + r[:volume] },
-        :volume_compensated => result_rows.inject(0) { |t, r| t + r[:volume_compensated] },
-        :row_count => result_rows.inject(0) { |t, r| t + r[:row_count] },
-        :nodes => result_rows.inject(0) { |t, r| t + r[:nodes] } + 1,
-        :rows => result_rows,
-    }
-  end
+      def list_order(list_order)
+        @@list_order = list_order
+      end
-  def html_export
-    index(false)
-    render :template => '/transaction_drilldown/html_export', :layout => 'print'
-  end
+      def field(name, **options)
+        @@fields ||= {}
+        @@fields[name] = options
+      end
-  def excel_export
-    index(false)
-    headers['Content-Type'] = "application/vnd.ms-excel"
-    headers['Content-Disposition'] = 'attachment; filename="transactions.xml"'
-    headers['Cache-Control'] = ''
-    render :template => '/transaction_drilldown/excel_export', :layout => false
-  end
+      def dimension(name, select_expression = name.to_s, options = {})
+        includes = options.delete(:includes)
+        interval = options.delete(:interval)
+        label_method = options.delete(:label_method) || ->(f) { f.to_s }
+        legal_values = options.delete(:legal_values) || legal_values_for(name)
+        reverse = options.delete(:reverse)
-  def excel_export_transactions
-    params[:search][:list] = '1'
-    index(false)
-    @transactions = get_transactions(@result)
-    headers['Content-Type'] = "application/vnd.ms-excel"
-    headers['Content-Disposition'] = 'attachment; filename="transactions.xml"'
-    render :template => '/transaction_drilldown/excel_export_transactions', :layout => false
-  end
+        raise "Unknown options: #{options.keys.inspect}" unless options.empty?
-  private
+        @@dimension_defs ||= Concurrent::Hash.new
-  def populate_list(conditions, includes, result, values)
-    if result[:rows]
-      result[:rows].each do |r|
-        populate_list(conditions, includes, r, values + [r[:value]])
+        @@dimension_defs[name.to_s] = {
+            select_expression: select_expression,
+            pretty_name: I18n.t(name),
+            url_param_name: name.to_s,
+            legal_values: legal_values,
+            label_method: label_method,
+            reverse: reverse,
+            includes: includes,
+            interval: interval
+        }
       end
-    else
-      options = {:include => includes + @list_includes, :order => @list_order}
-      @search.fields.each do |field|
-        field_def = @transaction_fields_map[field.to_sym]
-        raise "Field definition missing for: #{field.inspect}" unless field_def
-        field_includes = field_def[:include]
-        if field_includes
-          options[:include] += field_includes.is_a?(Array) ? field_includes : [field_includes]
+      def legal_values_for(field, preserve_filter = false)
+        lambda do |search|
+          my_filter = search.filter.dup
+          my_filter.delete(field.to_s) unless preserve_filter
+          conditions, t, includes = make_conditions(my_filter)
+          dimension = @@dimension_defs[field.to_s]
+          if dimension[:includes]
+            if dimension[:includes].is_a?(Array)
+              includes += dimension[:includes]
+            else
+              includes << dimension[:includes]
+            end
+            includes.uniq!
+          end
+          rows = @@target_class.unscoped.where(@@base_condition)
+              .select("#{dimension[:select_expression]} AS value")
+              .where(conditions)
+              .joins(make_join([], @@target_class.name.underscore.to_sym, includes))
+              .order('value')
+              .group('value').all.to_a
+          search.filter[field.to_s]&.each do |selected_value|
+            unless rows.find { |r| dimension[:label_method].call(r[:value]) == selected_value }
+              rows << { value: selected_value }
+            end
+          end
+          values = rows.map { |r| [dimension[:label_method]&.call(r[:value]) || r[:value], r[:value]] }.sort_by { |a| a[0].upcase }
+          values.reverse! if dimension[:reverse]
+          values
         end
       end
-      options[:include].uniq!
-      if @search.last_change_time
-        options[:include] << {:assignment => {:order => :last_aircraft_registration_change}} if @search.fields.include? 'aircraft_registration'
-        options[:include] << {:assignment => {:order => :last_fuel_request_change}} if @search.fields.include? 'fuel_request'
+      def make_conditions(search_filter)
+        includes = @@base_includes.dup
+        if search_filter
+          condition_strings = []
+          condition_values = []
+          filter_texts = []
+          search_filter.each do |field, values|
+            dimension_def = @@dimension_defs[field]
+            raise "Unknown filter field: #{field.inspect}" if dimension_def.nil?
+            values = [*values]
+            if dimension_def[:interval]
+              values *= 2 if values.size == 1
+              if values.size != 2
+                raise "Need 2 values for interval filter: #{values.inspect}"
+              end
+              if !values[0].blank? && !values[1].blank?
+                condition_strings << "#{dimension_def[:select_expression]} BETWEEN ? AND ?"
+                condition_values += values
+                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "from #{values[0]} to #{values[1]}"}"
+              elsif !values[0].blank?
+                condition_strings << "#{dimension_def[:select_expression]} >= ?"
+                condition_values < values[0]
+                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "from #{values[0]}"}"
+              elsif !values[1].blank?
+                condition_strings << "#{dimension_def[:select_expression]} <= ?"
+                condition_values < values[1]
+                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "to #{values[1]}"}"
+              end
+              includes << dimension_def[:includes] if dimension_def[:includes]
+            else
+              condition_strings << values.map do |value|
+                if dimension_def[:condition_values_method]
+                  condition_values += dimension_def[:condition_values_method].call(value)
+                else
+                  condition_values << value
+                end
+                filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(value) : value}"
+                includes << dimension_def[:includes] if dimension_def[:includes]
+                "(#{dimension_def[:select_expression]}) = ?"
+              end.join(' OR ')
+            end
+          end
+          filter_text = filter_texts.join(' and ')
+          conditions = [condition_strings.map { |c| "(#{c})" }.join(' AND '), *condition_values]
+          includes.uniq!
+        else
+          filter_text = nil
+          conditions = nil
+        end
+        [conditions, filter_text, includes]
       end
-      result[:transactions] = @target_class.all(options.update(:conditions => list_conditions(conditions, values)))
-    end
-  end
-  def list_conditions(conditions, values)
-    list_conditions_string = conditions[0].dup
-    @dimensions.each do |d|
-      list_conditions_string << "#{' AND ' unless list_conditions_string.empty?}#{d[:select_expression]} = ?"
-    end
-    [list_conditions_string, *(conditions[1..-1] + values)]
-  end
+      def make_join(joins, model, include, model_class = model.to_s.camelize.constantize)
+        case include
+        when Array
+          include.map { |i| make_join(joins, model, i) }.join(' ')
+        when Hash
+          sql = ''
+          include.each do |parent, child|
+            sql << make_join(joins, model, parent) + ' '
+            ass = model.to_s.camelize.constantize.reflect_on_association parent
+            sql << make_join(joins, parent, child, ass.class_name.constantize)
+          end
+          sql
+        when Symbol
+          return '' if joins.include?(include)
+          joins << include
+          ass = model_class.reflect_on_association include
+          raise "Unknown association: #{model} => #{include}" unless ass
-  def make_conditions(search_filter)
-    includes = []
-    if search_filter
-      condition_strings = []
-      condition_values = []
-      filter_texts = []
-      search_filter.each do |field, values|
-        dimension_def = @dimension_defs[field]
-        raise "Unknown filter field: #{field.inspect}" if dimension_def.nil?
-        values = [*values]
-        if dimension_def[:interval]
-          if dimension_def[:condition_values_method]
-            condition_values += dimension_def[:condition_values_method].call(values)
+          model_table = model.to_s.pluralize
+          include_table = ass.table_name
+          include_alias = include.to_s.pluralize
+          case ass.macro
+          when :belongs_to
+            "LEFT JOIN #{include_table} #{include_alias} ON #{include_alias}.id = #{model_table}.#{include}_id"
+          when :has_one, :has_many
+            fk_col = ass.options[:foreign_key] || "#{model}_id"
+            sql = "LEFT JOIN #{include_table} #{include_alias} ON #{include_alias}.#{fk_col} = #{model_table}.id"
+            if (ass_order = ass.options[:order].try(:to_s))
+              ass_order.sub!(/ DESC\s*$/i, '')
+              ass_order_prefixed = ass_order.dup
+              ActiveRecord::Base.connection.columns(include_table).map(&:name).each do |cname|
+                ass_order_prefixed.gsub!(/\b#{cname}\b/, "#{include_alias}.#{cname}")
+              end
+              sql << " AND  #{ass_order_prefixed} = (SELECT MIN(#{ass_order}) FROM #{include_table} t2 WHERE t2.#{fk_col} = #{model_table}.id #{
+              if ass.klass.paranoid?
+                'AND t2.deleted_at IS NULL'
+              end})"
+            end
+            sql
           else
-            condition_values += [*values]
+            raise "Unknown association type: #{ass.macro}"
           end
-          filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(values) : "from #{values[0]} to #{values[1] || values[0]}"}"
-          includes << dimension_def[:includes] if dimension_def[:includes]
-          condition_strings << dimension_def[:condition_string]
+        when String
+          include
+        when nil
+          ''
         else
-          condition_strings << values.map do |value|
-            if dimension_def[:condition_values_method]
-              condition_values += dimension_def[:condition_values_method].call(value)
-            else
-              condition_values << value
-            end
-            filter_texts << "#{dimension_def[:pretty_name]} #{dimension_def[:label_method] ? dimension_def[:label_method].call(value) : value}"
-            includes << dimension_def[:includes] if dimension_def[:includes]
-            dimension_def[:condition_string]
-          end.join(' OR ')
+          raise "Unknown join class: #{include.inspect}"
         end
       end
-      filter_text = filter_texts.join(' and ')
-      conditions = [condition_strings.map { |c| "(#{c})" }.join(" AND "), *condition_values]
+    end
+    def initialize
+      super()
+      @fields = @@fields
+      @default_fields = @@default_fields
+      @default_select_value = SimpleDrilldown::Search::SelectValue::COUNT
+      @target_class = @@target_class
+      @select = @@select
+      @@base_condition = '1 = 1' unless defined?(@@base_condition)
+      @base_condition = @@base_condition
+      @@base_includes = [] unless defined?(@@base_includes)
+      @base_includes = @@base_includes
+      @base_group = defined?(@@base_group) ? @@base_group : []
+      @@list_includes = [] unless defined?(@@list_includes)
+      @list_includes = @@list_includes
+      @list_order = @@list_order
+      @dimension_defs = @@dimension_defs
+      @summary_fields = []
+    end
+    # ?dimension[0]=supplier&dimension[1]=transaction_type&
+    # filter[year]=2009&filter[supplier][0]=Shell&filter[supplier][1]=Statoil
+    def index(do_render = true)
+      @search = Search.new(params[:search]&.to_unsafe_h, @default_fields, @default_select_value)
+      @transaction_fields = (@search.fields + (@fields.keys.map(&:to_s) - @search.fields))
+      @transaction_fields_map = @fields
+      select = @select.dup
+      includes = @base_includes.dup
+      @dimensions = []
+      select << ", 'All' as value0"
+      @dimensions += @search.dimensions.map do |dn|
+        if @dimension_defs[dn].nil?
+          raise "Unknown distribution field: #{@search.dimensions.inspect}"
+        end
+        @dimension_defs[dn]
+      end
+      @dimensions.each_with_index do |d, i|
+        select << ", #{d[:select_expression]} as value#{i + 1}"
+        includes << d[:includes] if d[:includes]
+      end
+      conditions, @filter_text, filter_includes = self.class.make_conditions(@search.filter)
+      includes += filter_includes
       includes.uniq!
-    else
-      filter_text = nil
-      conditions = nil
+      if @search.order_by_value && @dimensions.size <= 1
+        order = 'count DESC'
+      else
+        order = @dimensions.map { |d| d[:select_expression] }.join(', ')
+        order = nil if order.empty?
+      end
+      group = (@base_group + @dimensions.map { |d| d[:select_expression] }).join(', ')
+      group = nil if group.empty?
+      rows = @target_class.unscoped.where(@base_condition).select(select).where(conditions)
+                          .joins(self.class.make_join([], @target_class.name.underscore.to_sym, includes))
+                          .group(group)
+                          .order(order).all.to_a
+      if rows.empty?
+        @result = { value: 'All', count: 0, row_count: 0, nodes: 0, rows: [] }
+      else
+        if do_render && @search.list && rows.inject(0) { |sum, r| sum + r[:count].to_i } > LIST_LIMIT
+          @search.list = false
+          flash[:notice] = "More than #{LIST_LIMIT} records.  List disabled."
+        end
+        @result = result_from_rows(rows, 0, 0, ['All'])
+      end
+      remove_duplicates(@result) unless @base_group.empty?
+      @remaining_dimensions = @dimension_defs.dup.delete_if do |dim_name, _dimension|
+        (@search.filter[dim_name] && @search.filter[dim_name].size == 1) ||
+          (@dimensions.any? { |d| d[:url_param_name] == dim_name })
+      end
+      populate_list(conditions, includes, @result, []) if @search.list
+      render template: '/drilldown/index' if do_render
     end
-    return conditions, filter_text, includes
-  end
-  def legal_values_for(field, preserve_filter = false)
-    lambda do |search|
-      my_filter = search.filter.dup
-      my_filter.delete(field.to_s) unless preserve_filter
-      conditions, t, includes = make_conditions(my_filter)
-      dimension = @dimension_defs[field.to_s]
-      if dimension[:includes]
-        if dimension[:includes].is_a?(Array)
-          includes += dimension[:includes]
-        else
-          includes << dimension[:includes]
+    def remove_duplicates(result)
+      rows = result[:rows]
+      return 0 unless rows
+      removed_rows = 0
+      prev_row = nil
+      rows.each do |r|
+        if prev_row
+          if prev_row[:value] == r[:value]
+            prev_row[:count] += r[:count]
+            prev_row[:row_count] = [prev_row[:row_count], r[:row_count]].max
+            prev_row[:nodes] = [prev_row[:nodes], r[:nodes]].max
+            prev_row[:rows] += r[:rows] if prev_row[:rows] || r[:rows]
+            r[:value] = nil
+            removed_rows += r[:nodes]
+          end
         end
-        includes.uniq!
+        prev_row = r unless r[:value].nil?
+      end
+      rows.delete_if { |r| r[:value].nil? }
+      rows.each do |r|
+        removed_child_rows = remove_duplicates(r)
+        removed_rows += removed_child_rows
       end
-      rows = @target_class.find(
-          :all,
-          :select => "DISTINCT(#{dimension[:select_expression]}) AS value",
-          :conditions => conditions,
-          :joins => make_join(@target_class.name.underscore.to_sym, includes),
-          :order => 'value'
-      )
-      if search.filter[field.to_s]
-        search.filter[field.to_s].each do |selected_value|
-          unless rows.find { |r| r[:value] == selected_value }
-            rows << {:value => selected_value}
+      result[:row_count] -= removed_rows
+      result[:nodes] -= removed_rows
+      removed_rows
+    end
+    # Empty summary rows are needed to plot zero points in the charts
+    def add_zero_results(result_rows, dimension)
+      legal_values = self.class.legal_values_for(@dimensions[dimension][:url_param_name], true).call(@search).map { |lv| lv[1] }
+      legal_values.reverse! if @dimensions[dimension][:reverse]
+      current_values = result_rows.map { |r| r[:value] }.compact
+      empty_values = legal_values - current_values
+      unless empty_values.empty?
+        empty_values.each do |v|
+          sub_result = {
+            value: v,
+            count: 0,
+            row_count: 0,
+            nodes: 0
+          }
+          if dimension < @dimensions.size - 1
+            sub_result[:rows] = add_zero_results([], dimension + 1)
           end
+          result_rows << sub_result
         end
-        rows.sort_by { |r| r[:value] }
+        result_rows = result_rows.sort_by { |r| legal_values.index(r[:value]) }
       end
-      values = rows.map { |r| [dimension[:label_method] && dimension[:label_method].call(r[:value]) || r[:value], r[:value]] }
-      values
+      result_rows
     end
-  end
-  def dimension(name, select_expression, options = {})
-    includes = options.delete(:includes)
-    interval = options.delete(:interval)
-    label_method = options.delete(:label_method)
-    legal_values = options.delete(:legal_values) || legal_values_for(name)
-    raise "Unknown options: #{options.keys.inspect}" unless options.empty?
-    @dimension_defs[name.to_s] = {
-        :select_expression => select_expression,
-        :condition_string => interval ? "#{select_expression} BETWEEN ? AND ?" : "(#{select_expression}) = ?",
-        :condition_values_method => interval ? lambda { |values| [values[0], values[1] || values[0]] } : nil,
-        :pretty_name => t(name),
-        :url_param_name => name.to_s,
-        :legal_values => legal_values,
-        :label_method => label_method,
-        :includes => includes,
-        :interval => interval,
-    }
-  end
+    def result_from_rows(rows, row_index, dimension, previous_values)
+      row = rows[row_index]
+      return nil if row.nil?
-  def get_transactions(tree)
-    return tree[:transactions] if tree[:transactions]
-    tree[:rows].map { |r| get_transactions(r) }.flatten
-  end
+      values = (0..dimension).to_a.map { |i| row["value#{i}"] }
+      return nil if values != previous_values
-  def make_join(model, include)
-    case include
-    when Array
-      include.map { |i| make_join(model, i) }.join(' ')
-    when Hash
-      sql = ''
-      include.each do |parent, child|
-        parent_table = parent.to_s.pluralize
-        sql << make_join(model, parent) + ' '
-        sql << make_join(parent, child)
+      if dimension == @dimensions.size
+        return {
+          value: values[-1],
+          count: row[:count].to_i,
+          row_count: 1,
+          nodes: @search.list ? 2 : 1
+        }
+      end
+      result_rows = []
+      loop do
+        sub_result = result_from_rows(rows, row_index, dimension + 1, values + [rows[row_index]["value#{dimension + 1}"]])
+        break if sub_result.nil?
+        result_rows << sub_result
+        row_index += sub_result[:row_count]
+        break if rows[row_index].nil?
       end
-      sql
-    when Symbol
-      ass = model.to_s.camelize.constantize.reflect_on_association include
-      include_table = ass.table_name
-      "LEFT JOIN #{include_table} ON #{include_table}.id = #{model.to_s.pluralize}.#{include}_id"
-    else
-      raise 'Unknown join class: #{include.inspect}'
+      result_rows = add_zero_results(result_rows, dimension)
+      {
+        value: values[-1],
+        count: result_rows.inject(0) { |t, r| t + r[:count].to_i },
+        row_count: result_rows.inject(0) { |t, r| t + r[:row_count] },
+        nodes: result_rows.inject(0) { |t, r| t + r[:nodes] } + 1,
+        rows: result_rows
+      }
     end
-  end
+    def html_export
+      index(false)
+      render template: '/drilldown/html_export', layout: '../drilldown/print'
+    end
+    def excel_export
+      index(false)
+      headers['Content-Type'] = 'application/vnd.ms-excel'
+      headers['Content-Disposition'] = 'attachment; filename="elections.xls"'
+      headers['Cache-Control'] = ''
+      render template: '/drilldown/excel_export', layout: false
+    end
+    private
+    def populate_list(conditions, includes, result, values)
+      if result[:rows]
+        result[:rows].each do |r|
+          populate_list(conditions, includes, r, values + [r[:value]])
+        end
+      else
+        options = { include: includes + @list_includes, order: @list_order }
+        @search.fields.each do |field|
+          field_def = @transaction_fields_map[field.to_sym]
+          raise "Field definition missing for: #{field.inspect}" unless field_def
+          field_includes = field_def[:include]
+          if field_includes
+            options[:include] += field_includes.is_a?(Array) ? field_includes : [field_includes]
+          end
+        end
+        options[:include].uniq!
+        joins = self.class.make_join([], @target_class.name.underscore.to_sym, options.delete(:include))
+        result[:transactions] = @target_class.joins(joins).where(@base_condition).where(list_conditions(conditions, values)).includes(options[:include]).order(options[:order]).all
+      end
+    end
+    def list_conditions(conditions, values)
+      list_conditions_string = conditions[0].dup
+      @dimensions.each do |d|
+        list_conditions_string << "#{unless list_conditions_string.empty?
+                                       ' AND '
+                                     end}#{d[:select_expression]} = ?"
+      end
+      [list_conditions_string, *(conditions[1..-1] + values)]
+    end
+  end
 end