redmine_extensions 0.0.13 → 0.0.14

data/lib/redmine_extensions/easy_query_adapter.rb

@@ -0,0 +1,142 @@
+require 'query'
+
+module RedmineExtensions
+  module QueryColumnAdapter
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+
+      base.class_eval do
+        attr_accessor :includes
+        attr_accessor :joins
+        attr_accessor :preload
+      end
+    end
+
+    module InstanceMethods
+    end
+
+    module ClassMethods
+    end
+  end
+end
+
+class EasyQueryAdapter < Query
+
+  after_initialize :after_initialize
+
+  def after_initialize
+    self.filters ||= {}
+  end
+
+  def default_find_include
+    [].freeze
+  end
+
+  def default_find_preload
+    [].freeze
+  end
+
+  def default_find_joins
+    [].freeze
+  end
+
+  def default_list_columns
+    [].freeze
+  end
+
+  def formatter
+    @formatter
+  end
+
+  def init_formatter(object)
+    return @formatter if @formatter
+
+    if entity
+      begin
+        formatter_klass = "#{entity}Formatter".constantize
+      rescue NameError
+      end
+    end
+
+    formatter_klass ||= EasyEntityFormatter
+    @formatter = formatter_klass.new(object)
+  end
+
+  def entity_scope
+    if @entity_scope.present?
+      @entity_scope
+    elsif entity.respond_to?(:visible)
+      entity.visible
+    else
+      entity
+    end
+  end
+
+  def create_entity_scope(options={})
+    scope = entity_scope.where(statement)
+
+    includes = default_find_include.dup
+    includes.concat(Array.wrap(options[:includes]))
+
+    preload = default_find_preload.dup
+    preload.concat(Array.wrap(options[:preload]))
+
+    joins = default_find_joins.dup
+    joins.concat(Array.wrap(options[:joins]))
+
+    filters.keys.each do |filter|
+      f = available_filters[filter]
+      next if f.blank?
+
+      includes.concat(Array.wrap(f[:includes])) if f[:includes]
+      joins.concat(Array.wrap(f[:joins])) if f[:joins]
+    end if filters
+
+    columns.each do |c|
+      includes.concat(Array.wrap(c.includes)) if c.includes
+      joins.concat(Array.wrap(c.joins)) if c.joins
+      preload.concat(Array.wrap(c.preload)) if c.preload
+    end
+
+    if project
+      includes << :project
+    end
+
+    includes.uniq!
+    joins.uniq!
+    preload.uniq!
+
+    scope.includes(includes).references(includes).joins(joins).preload(preload)
+  end
+
+  def entities(options={})
+    create_entity_scope(options).order(options[:order])
+  end
+
+  def add_available_column(name, options={})
+    @available_columns ||= []
+
+    @available_columns << QueryColumn.new(name.to_sym, options)
+  end
+
+  def to_partial_path
+    'easy_queries/index'
+  end
+
+  def default_columns_names
+    default_list_columns
+  end
+
+  def queried_table_name
+    entity.table_name
+  end
+
+end
+
+if Redmine::Plugin.installed?(:easy_extensions)
+  # EasyQuery exist
+else
+  QueryColumn.send(:include, RedmineExtensions::QueryColumnAdapter)
+  EasyQuery = EasyQueryAdapter
+end

data/lib/redmine_extensions/engine.rb

@@ -25,7 +25,7 @@ module RedmineExtensions
     #config.to_prepare goes after Reloader.to_prepare
     ActionDispatch::Reloader.to_prepare do
       RedmineExtensions::QueryOutput.register_output :table, RedmineExtensions::QueryOutputs::TableOutput
-      RedmineExtensions::BasePresenter.register 'RedmineExtensions::EasyQueryPresenter', 'EasyQuery'
+      # RedmineExtensions::BasePresenter.register 'RedmineExtensions::EasyQueryPresenter', 'EasyQuery'
       # ApplicationController.send :include, RedmineExtensions::RailsPatches::ControllerQueryHelpers
       ApplicationController.send :include, RedmineExtensions::RenderingHelper
     end
@@ -67,6 +67,9 @@ module RedmineExtensions
       unless Redmine::Plugin.installed?(:easy_extensions)
         ActiveSupport.run_load_hooks(:easyproject, self)
       end
+
+      require 'redmine_extensions/easy_query_adapter'
+      require 'redmine_extensions/easy_entity_formatters/easy_entity_formatter'
     end
 
     # initializer :add_html_formatting do |app|

data/lib/redmine_extensions/redmine_patches/controllers/application_controller_patch.rb

@@ -0,0 +1,55 @@
+module RedmineExtensions
+  module ApplicationControllerPatch
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+
+      base.class_eval do
+      end
+    end
+
+    module InstanceMethods
+
+      def index_for_easy_query(query_klass, *)
+        @query = query_klass.new(name: '_')
+        @query.project = @project
+        @query.build_from_params(params)
+
+        sort_init(@query.sort_criteria.empty? ? [['id', 'desc']] : @query.sort_criteria)
+        sort_update(@query.sortable_columns)
+
+        @entities = @query.entities
+      end
+
+      def easy_extensions?
+        self.class.easy_extensions?
+      end
+
+    end
+
+    module ClassMethods
+
+      def easy_extensions?
+        Redmine::Plugin.installed?(:easy_extensions)
+      end
+
+      def include_query_helpers
+        if easy_extensions?
+          helper :easy_query
+          include EasyQueryHelper
+        else
+          helper :queries
+          include QueriesHelper
+        end
+
+        helper :sort
+        include SortHelper
+      end
+
+    end
+
+  end
+end
+
+RedmineExtensions::PatchManager.register_controller_patch 'ApplicationController', 'RedmineExtensions::ApplicationControllerPatch'

data/lib/redmine_extensions/redmine_patches/patches.rb

@@ -0,0 +1,4 @@
+patch_path = File.join(File.dirname(__FILE__), '**', '*.rb')
+Dir.glob(patch_path).each do |file|
+  require_dependency file
+end

data/lib/redmine_extensions/version.rb

@@ -1,3 +1,3 @@
 module RedmineExtensions
-  VERSION = '0.0.13'
+  VERSION = '0.0.14'
 end