effective_datatables 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed64f666d0e25311df8bd6d261f91561ff5a4b06
-  data.tar.gz: 80cbfdb2f683497fdbfff4f373068ee254fefb69
+  metadata.gz: 1a2b9ae410c6e532a465c32336482e9970f13e53
+  data.tar.gz: 368a0929e034ef902d2a0bde8eb3a7748c49929b
 SHA512:
-  metadata.gz: c5f12a41603c30fdbaea17b0eabcdf801baada748aca0b020e0d570911389b599fb1c10a1b09b4b5a4cfa77346c85c70940435ddf7cac64d567c786c2336f2be
-  data.tar.gz: 149fcbcf5c3e48bf996db130b649b84acbfceac7f77b47a34a2db90e76c4228bedf96e9e9db6f96ace6826a17695c64c3ad0246942b5b2edd3a7d614b0211a9c
+  metadata.gz: d013b3eabb65c821560fe91db66f8cdbb7b1c07671fa7b973d2bd57cf51a9f31d98190955e659a7b492b8b9237af1ebffccbd846e9b4b71e60c553267dbf2105
+  data.tar.gz: b76751d9fe31c78f7e0d4fc54bbd8878d46efd2a070216216e157841dbad951aec9aa1996a0dcc58dd345b406189dfe6026d675cd130aa5b4af9d88d253fda49

data/README.md

@@ -136,7 +136,7 @@ class PostsDatatable < Effective::Datatable
   # It has access to the attributes and filters Hashes, representing the current state
   # It must return an ActiveRecord::Relation or an Array of Arrays
   collection do
-    scope = Post.all.where(created_at: filters[:start_date]...filters[:end_date])
+    scope = Post.all.joins(:user).where(created_at: filters[:start_date]...filters[:end_date])
     scope = scope.where(user_id: attributes[:user_id]) if attributes[:user_id]
     scope
   end
@@ -209,6 +209,8 @@ class PostsDatatable < Effective::Datatable
 
     if attributes[:user_id].nil?  # Show all users, otherwise this table is meant for one user only
       col :user, search: { collection: User.authors }
+
+      col 'user.first_name'  # Using the joined syntax
     end
 
     if can?(:index, Comment)
@@ -484,6 +486,14 @@ end
 
 You can also set custom search and sort on a per-column basis. See Advanced Search and Sort below.
 
+If the column name matches a `belongs_to`, `has_many` or other association on your collection class, like `col :user`, the column will be created as a resource column.
+
+A resource column will try to link to the show/edit/destroy actions of its objects, based on permissions and routes. You can alter this behaviour with the `action:` variable.
+
+You can also use the joined syntax, `col 'user.email'` to create a column for just this one field.
+
+This feature is only working with `belongs_to` and you need to add the `.joins(:user)` to the collection do ... end block yourself.
+
 ### val
 
 Shorthand for value, this command also creates a column on the datatable.

data/app/controllers/effective/datatables_controller.rb

@@ -14,7 +14,8 @@ module Effective
       rescue => e
         (EffectiveDatatables.authorized?(self, :index, @datatable.try(:collection_class)) rescue false)
 
-        render json: error_json(message: e.message)
+        render json: error_json(e)
+        raise e
       end
     end
 
@@ -25,11 +26,11 @@ module Effective
       id.classify.safe_constantize || id.classify.pluralize.safe_constantize
     end
 
-    def error_json(message:)
+    def error_json(e)
       {
         data: [],
         draw: params[:draw].to_i,
-        effective_datatables_error: message.presence || 'unknown error',
+        effective_datatables_error: (e.message.presence unless e.class.name.include?('ActiveRecord::')) || 'unexpected operation',
         recordsTotal: 0,
         recordsFiltered: 0,
         aggregates: [],

data/app/models/effective/effective_datatable/compute.rb

@@ -60,10 +60,23 @@ module Effective
           columns.map do |name, opts|
             if state[:visible][name] == false && (name != order_name)  # Sort by invisible array column
               BLANK
-            elsif opts[:partial] || (opts[:format] && !opts[:compute])
+            elsif opts[:partial]
               active_record_collection? ? obj : obj[opts[:index]]
             elsif opts[:compute]
               dsl_tool.instance_exec(obj, (active_record_collection? ? collection : obj[opts[:index]]), &opts[:compute])
+            elsif opts[:format]
+              active_record_collection? ? obj : obj[opts[:index]]
+            elsif opts[:resource]
+              resource = active_record_collection? ? obj : obj[opts[:index]]
+
+              if opts[:resource_field]
+                (associated, field) = name.to_s.split('.').first(2)
+                values = Array(resource.send(associated)).map { |obj| obj.send(field) }.flatten.compact
+                values.length == 1 ? values.first : values
+              else
+                value.send(name)
+              end
+
             elsif opts[:as] == :effective_obfuscation
               obj.to_param
             elsif array_collection?

data/app/models/effective/effective_datatable/dsl/datatable.rb

@@ -22,15 +22,17 @@ module Effective
         def col(name, action: nil, as: nil, col_class: nil, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: nil, th: nil, th_append: nil, visible: true, &format)
           raise 'You cannot use partial: ... with the block syntax' if partial && block_given?
 
-          datatable._columns[name.to_sym] = Effective::DatatableColumn.new(
+          name = name.to_sym unless name.to_s.include?('.')
+
+          datatable._columns[name] = Effective::DatatableColumn.new(
             action: action,  # resource columns only
             as: as,
             compute: nil,
             col_class: col_class,
             format: (format if block_given?),
             index: datatable.columns.length,
-            label: label || name.to_s.titleize,
-            name: name.to_sym,
+            label: label || name.to_s.split('.').last.titleize,
+            name: name,
             partial: partial,
             partial_as: partial_as,
             responsive: responsive,
@@ -48,15 +50,17 @@ module Effective
         def val(name, action: nil, as: nil, col_class: nil, label: nil, partial: nil, partial_as: nil, responsive: 10000, search: {}, sort: true, sql_column: false, th: nil, th_append: nil, visible: true, &compute)
           raise 'You cannot use partial: ... with the block syntax' if partial && block_given?
 
-          datatable._columns[name.to_sym] = Effective::DatatableColumn.new(
+          name = name.to_sym unless name.to_s.include?('.')
+
+          datatable._columns[name] = Effective::DatatableColumn.new(
             action: action, # Resource columns only
             as: as,
             compute: (compute if block_given?),
             col_class: col_class,
             format: nil,
             index: datatable.columns.length,
-            label: label || name.to_s.titleize,
-            name: name.to_sym,
+            label: label || name.to_s.split('.').last.titleize,
+            name: name,
             partial: partial,
             partial_as: partial_as,
             responsive: responsive,

data/app/models/effective/effective_datatable/resource.rb

@@ -18,12 +18,42 @@ module Effective
 
         if active_record_collection?
           columns.each do |name, opts|
+
+            if name.kind_of?(String) && name.include?('.')
+              raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
+
+              (associated, field) = name.split('.').first(2)
+
+              unless resource.macros.include?(resource.sql_type(associated))
+                raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{resource}'."
+              end
+
+              unless collection.joined_includes_values.include?(associated) || collection.joined_includes_values.include?(associated.to_sym)
+                raise "your datatables collection must .joins(:#{associated}) to work with the joined syntax"
+              end
+
+              opts[:resource] = Effective::Resource.new(resource.associated(associated), namespace: controller_namespace)
+
+              if opts[:resource].column(field)
+                opts[:as] ||= opts[:resource].sql_type(field)
+                opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
+
+                opts[:resource].sort_column = field
+                opts[:resource].search_columns = field
+              end
+
+              opts[:resource_field] = field
+
+              next
+            end
+
+            # Regular fields
             opts[:as] ||= resource.sql_type(name)
             opts[:sql_column] = resource.sql_column(name) if opts[:sql_column].nil?
 
             case opts[:as]
             when *resource.macros
-              opts[:resource] = Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
+              opts[:resource] ||= Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
               (opts[:sql_column] = name) if opts[:sql_column].nil?
             when Class
               if opts[:as].ancestors.include?(ActiveRecord::Base)
@@ -63,9 +93,11 @@ module Effective
 
         columns.each do |name, opts|
           opts[:as] ||= :string
-          opts[:as] = :email if (opts[:as] == :string && name == :email)
+          opts[:as] = :email if (opts[:as] == :string && name.to_s.end_with?('email'))
 
-          opts[:partial] ||= '/effective/datatables/resource_column' if (opts[:resource] && opts[:as] != :effective_addresses)
+          if opts[:resource] && !opts[:resource_field] && opts[:as] != :effective_addresses
+            opts[:partial] ||= '/effective/datatables/resource_column'
+          end
 
           opts[:col_class] = "col-#{opts[:as]} col-#{name.to_s.parameterize} #{opts[:col_class]}".strip
         end

data/app/models/effective/effective_datatable/state.rb

@@ -113,7 +113,7 @@ module Effective
         state[:visible] = {}
 
         params[:columns].values.each do |params|
-          name = params[:name].to_sym
+          name = (params[:name].include?('.') ? params[:name] : params[:name].to_sym)
 
           if params[:search][:value].present? && !['null'].include?(params[:search][:value])
             state[:search][name] = params[:search][:value]

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '3.1.0'.freeze
+  VERSION = '3.1.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_datatables
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-12 00:00:00.000000000 Z
+date: 2017-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails