effective_datatables 3.7.10 → 4.0.0

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

@@ -8,148 +8,108 @@ module Effective
       end
 
       def controller_namespace
-        @attributes[:namespace]
-      end
-
-      def association_macros
-        [:belongs_to, :belongs_to_polymorphic, :has_many, :has_and_belongs_to_many, :has_one]
+        @attributes[:_n]
       end
 
       private
 
-      def load_effective_resource!
-        @effective_resource = if active_record_collection?
-          Effective::Resource.new(collection_class, namespace: controller_namespace)
-        end
-      end
-
       # This looks at all the columns and figures out the as:
       def load_resource!
-        load_effective_resource!
+        @resource = Effective::Resource.new(collection_class, namespace: controller_namespace)
 
-        load_active_record_collection!
-        load_active_record_array_collection!
-        load_array_collection!
+        if active_record_collection?
+          columns.each do |name, opts|
 
-        load_resource_columns!
-        load_resource_belongs_tos!
-        load_resource_search!
-      end
+            # col 'comments.title'
+            if name.kind_of?(String) && name.include?('.')
+              raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
 
-      def load_effective_resource!
-        @effective_resource = if active_record_collection?
-          Effective::Resource.new(collection_class, namespace: controller_namespace)
-        end
-      end
-
-      def load_active_record_collection!
-        return unless active_record_collection?
+              (associated, field) = name.split('.').first(2)
 
-        columns.each do |name, opts|
-          # col 'comments.title'
-          if name.kind_of?(String) && name.include?('.')
-            raise "invalid datatables column '#{name}'. the joined syntax only supports one dot." if name.scan(/\./).count > 1
+              unless resource.macros.include?(resource.sql_type(associated))
+                raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{resource}'."
+              end
 
-            (associated, field) = name.split('.').first(2)
+              joins_values = (collection.joins_values + collection.left_outer_joins_values)
 
-            unless association_macros.include?(effective_resource.sql_type(associated))
-              raise "invalid datatables column '#{name}'. unable to find '#{name.split('.').first}' association on '#{effective_resource}'."
-            end
+              unless joins_values.include?(associated.to_sym)
+                raise "your datatables collection must .joins(:#{associated}) or .left_outer_joins(:#{associated}) to work with the joined syntax"
+              end
 
-            joins_values = (collection.joins_values + collection.left_outer_joins_values)
+              opts[:resource] = Effective::Resource.new(resource.associated(associated), namespace: controller_namespace)
 
-            unless joins_values.include?(associated.to_sym)
-              raise "your datatables collection must .joins(:#{associated}) or .left_outer_joins(:#{associated}) to work with the joined syntax"
-            end
+              if opts[:resource].column(field)
+                opts[:as] ||= opts[:resource].sql_type(field)
+                opts[:as] = :integer if opts[:resource].sql_type(field) == :belongs_to && field.end_with?('_id')
+                opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
 
-            opts[:resource] = Effective::Resource.new(effective_resource.associated(associated), namespace: controller_namespace)
+                opts[:resource].sort_column = field
+                opts[:resource].search_columns = field
+              end
 
-            if opts[:resource].column(field)
-              opts[:as] ||= opts[:resource].sql_type(field)
-              opts[:as] = :integer if opts[:resource].sql_type(field) == :belongs_to && field.end_with?('_id')
-              opts[:sql_column] = opts[:resource].sql_column(field) if opts[:sql_column].nil?
+              opts[:resource_field] = field
 
-              opts[:resource].sort_column = field
-              opts[:resource].search_columns = field
+              next
             end
 
-            opts[:resource_field] = field
-
-            next
-          end
-
-          # Regular fields
-          opts[:as] ||= effective_resource.sql_type(name)
-          opts[:sql_column] = effective_resource.sql_column(name) if opts[:sql_column].nil?
+            # Regular fields
+            opts[:as] ||= resource.sql_type(name)
+            opts[:sql_column] = resource.sql_column(name) if opts[:sql_column].nil?
 
-          case opts[:as]
-          when *association_macros
-            opts[:resource] ||= Effective::Resource.new(effective_resource.associated(name), namespace: controller_namespace)
-            opts[:sql_column] = name if opts[:sql_column].nil?
-          when Class
-            if opts[:as].ancestors.include?(ActiveRecord::Base)
-              opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
-              opts[:as] = :resource
+            case opts[:as]
+            when *resource.macros
+              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)
+                opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
+                opts[:as] = :resource
+                opts[:sql_column] = name if opts[:sql_column].nil?
+              end
+            when :effective_addresses
+              opts[:resource] = Effective::Resource.new(resource.associated(name), namespace: controller_namespace)
+              opts[:sql_column] = :effective_addresses
+            when :effective_roles
+              opts[:sql_column] = :effective_roles
+            when :string  # This is the fallback
+              # Anything that doesn't belong to the model or the sql table, we assume is a SELECT SUM|AVG|RANK() as fancy
+              opts[:sql_as_column] = true if (resource.table && resource.column(name).blank?)
             end
-          when :effective_addresses
-            opts[:resource] = Effective::Resource.new(effective_resource.associated(name), namespace: controller_namespace)
-            opts[:sql_column] = :effective_addresses
-          when :effective_roles
-            opts[:sql_column] = :effective_roles
-          when :string  # This is the fallback
-            # Anything that doesn't belong to the model or the sql table, we assume is a SELECT SUM|AVG|RANK() as fancy
-            opts[:sql_as_column] = true if (effective_resource.table && effective_resource.column(name).blank?)
-          end
 
-          if opts[:sql_column].present? && AGGREGATE_SQL_FUNCTIONS.any? { |str| opts[:sql_column].to_s.start_with?(str) }
-            opts[:sql_as_column] = true
+            if opts[:sql_column].present? && AGGREGATE_SQL_FUNCTIONS.any? { |str| opts[:sql_column].to_s.start_with?(str) }
+              opts[:sql_as_column] = true
+            end
           end
         end
-      end
-
-      def load_active_record_array_collection!
-        return unless active_record_array_collection?
-      end
-
-      def load_array_collection!
-        return unless array_collection?
 
-        row = collection.first
+        if array_collection?
+          row = collection.first
 
-        columns.each do |name, opts|
-          if opts[:as].kind_of?(Class) && opts[:as].ancestors.include?(ActiveRecord::Base)
-            opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
-            opts[:as] = :resource
-          elsif opts[:as] == nil && row.present?
-            if (value = Array(row[opts[:index]]).first).kind_of?(ActiveRecord::Base)
-              opts[:resource] = Effective::Resource.new(value, namespace: controller_namespace)
+          columns.each do |name, opts|
+            if opts[:as].kind_of?(Class) && opts[:as].ancestors.include?(ActiveRecord::Base)
+              opts[:resource] = Effective::Resource.new(opts[:as], namespace: controller_namespace)
               opts[:as] = :resource
+            elsif opts[:as] == nil
+              if (value = Array(row[opts[:index]]).first).kind_of?(ActiveRecord::Base)
+                opts[:resource] = Effective::Resource.new(value, namespace: controller_namespace)
+                opts[:as] = :resource
+              end
             end
           end
         end
-      end
 
-      def load_resource_columns!
         columns.each do |name, opts|
           opts[:as] ||= :string
           opts[:as] = :email if (opts[:as] == :string && name.to_s.end_with?('email'))
 
-          if opts[:action]
-            opts[:resource] ||= effective_resource
-          end
-
           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}",
-            ('colvis-default' if opts[:visible]),
-            opts[:col_class].presence
-          ].compact.join(' ')
+          opts[:col_class] = "col-#{opts[:as]} col-#{name.to_s.parameterize} #{opts[:col_class]}".strip
         end
+
+        load_resource_search!
       end
 
       def load_resource_search!
@@ -161,7 +121,7 @@ module Effective
           when Symbol
             opts[:search] = { as: opts[:search] }
           when Array, ActiveRecord::Relation
-            opts[:search] = { as: :select, collection: opts[:search] }
+            opts[:search] = { collection: opts[:search] }
           when Hash
             # Nothing
           else
@@ -170,35 +130,31 @@ module Effective
 
           search = opts[:search]
 
-          # Parameterize collection
           if search[:collection].kind_of?(ActiveRecord::Relation)
             search[:collection] = search[:collection].map { |obj| [obj.to_s, obj.to_param] }
           elsif search[:collection].kind_of?(Array) && search[:collection].first.kind_of?(ActiveRecord::Base)
             search[:collection] = search[:collection].map { |obj| [obj.to_s, obj.to_param] }
+          elsif search[:collection].kind_of?(Array)
+            search[:collection].each { |obj| obj[1] = 'nil' if obj[1] == nil }
+          elsif search[:collection].kind_of?(Hash)
+            search[:collection].each { |k, v| search[:collection][k] = 'nil' if v == nil }
           end
 
-          search[:as] ||= :select if search.key?(:collection)
-          search[:fuzzy] ||= true unless search.key?(:fuzzy)
           search[:value] ||= search.delete(:selected) if search.key?(:selected)
 
-          # Merge with defaults
-          search_resource = [opts[:resource], effective_resource, fallback_effective_resource].compact
-          search_resource = search_resource.find { |res| res.klass.present? } || search_resource.first
+          search[:as] ||= :select if (search.key?(:collection) && opts[:as] != :belongs_to_polymorphic)
 
-          if array_collection? && opts[:resource].present?
-            search.reverse_merge!(search_resource.search_form_field(name, collection.first[opts[:index]]))
-          elsif search[:as] != :string
-            search.reverse_merge!(search_resource.search_form_field(name, opts[:as]))
-          end
+          search[:fuzzy] = true unless search.key?(:fuzzy)
 
-          # Assign default include_null
-          if search[:as] == :select && !search.key?(:include_null)
-            search[:include_null] = true
+          if array_collection? && opts[:resource].present?
+            search.reverse_merge!(resource.search_form_field(name, collection.first[opts[:index]]))
+          else
+            search.reverse_merge!(resource.search_form_field(name, opts[:as]))
           end
         end
       end
 
-      def load_resource_belongs_tos!
+      def apply_belongs_to_attributes!
         return unless active_record_collection?
 
         changed = attributes.select do |attribute, value|
@@ -206,27 +162,10 @@ module Effective
           next unless attribute.ends_with?('_id')
 
           associated = attribute.gsub(/_id\z/, '').to_sym  # Replace last _id
+          next unless columns[associated] && columns[associated][:as] == :belongs_to
 
-          next unless columns[associated]
-
-          if columns[associated][:as] == :belongs_to
-            if @_collection_apply_belongs_to && !@_collection.where_values_hash.include?(attribute)
-              @_collection = @_collection.where(attribute => value)
-            end
-
-            columns.delete(associated)
-          elsif columns[associated][:as] == :belongs_to_polymorphic
-            associated_type = attributes["#{associated}_type".to_sym] || raise("Expected #{associated}_type attribute to be present when #{associated}_id is present on a polymorphic belongs to")
-
-            if @_collection_apply_belongs_to
-              if !@_collection.where_values_hash.include?(attribute) && !@_collection.where_values_hash.include?("#{associated}_type")
-                @_collection = @_collection.where(attribute => value).where("#{associated}_type" => associated_type)
-              end
-            end
-
-            columns.delete(associated)
-          end
-
+          @_collection = @_collection.where(attribute => value)
+          columns.delete(associated)
         end.present?
 
         load_columns! if changed

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

@@ -55,6 +55,7 @@ module Effective
       # This is called first. Our initial state is set.
       def initial_state
         {
+          attributes: {},
           filter: {},
           length: nil,
           order_name: nil,
@@ -88,27 +89,23 @@ module Effective
 
       def load_state!
         if datatables_ajax_request?
-          load_cookie! # but not state.
           load_filter_params!
           load_ajax_state!
-        elsif datatables_inline_request?
-          load_filter_params!
+        elsif cookie.present? && cookie[:params] == params.length
+          load_cookie_state!
         else
-          load_cookie!
-          load_cookie_state! if cookie.present? && cookie[:params] == cookie_state_params
-          load_filter_params!
+          # Nothing to do for default state
         end
 
+        load_filter_params! unless datatables_ajax_request?
         fill_empty_filters!
       end
 
       def load_ajax_state!
         state[:length] = params[:length].to_i
 
-        if params[:order]
-          state[:order_dir] = (params[:order]['0'][:dir] == 'desc' ? :desc : :asc)
-          state[:order_index] = params[:order]['0'][:column].to_i
-        end
+        state[:order_dir] = (params[:order]['0'][:dir] == 'desc' ? :desc : :asc)
+        state[:order_index] = params[:order]['0'][:column].to_i
 
         state[:scope] = _scopes.keys.find { |name| params[:scope] == name.to_s }
         state[:start] = params[:start].to_i
@@ -133,7 +130,7 @@ module Effective
           state[:filter][name] = parse_filter_value(_filters[name], value)
         end
 
-        state[:params] = cookie[:params] if cookie.present?
+        state[:params] = cookie[:params]
       end
 
       def load_cookie_state!
@@ -143,21 +140,14 @@ module Effective
       def load_columns!
         state[:length] ||= EffectiveDatatables.default_length
 
-        (columns || {}).each_with_index { |(_, column), index| column[:index] = index }
-
         if columns.present?
-          state[:order_name] = (
-            if columns.key?(:_reorder)
-              :_reorder
-            elsif order_index.present?
-              columns.keys[order_index]
-            elsif state[:order_name].present?
-              state[:order_name]
-            else
-              columns.find { |name, opts| opts[:sort] }.first
-            end
-          )
+          columns.each_with_index { |(_, column), index| column[:index] = index }
 
+          if order_index.present?
+            state[:order_name] = columns.keys[order_index]
+          end
+
+          state[:order_name] ||= columns.find { |name, opts| opts[:sort] }.first
           raise "order column :#{order_name} must exist as a col or val" unless columns[order_name]
 
           state[:order_index] = columns[order_name][:index]
@@ -186,7 +176,7 @@ module Effective
 
         unless datatables_ajax_request?
           search_params.each { |name, value| state[:search][name] = value }
-          state[:params] = cookie_state_params
+          state[:params] = params.length
         end
 
         state[:visible].delete_if { |name, _| columns.key?(name) == false }
@@ -197,14 +187,9 @@ module Effective
       # When we parse an incoming filter term for this filter.
       def parse_filter_value(filter, value)
         return filter[:parse].call(value) if filter[:parse]
-        return nil if value.blank? && !filter[:required]
         Effective::Attribute.new(filter[:value]).parse(value, name: filter[:name])
       end
 
-      def cookie_state_params
-        params.hash.abs.to_s.last(12)
-      end
-
     end
   end
 end

data/app/views/effective/datatables/_actions_column.html.haml

@@ -1 +1,8 @@
-= render_resource_actions(resource, **actions_col_locals)
+- if show_action && EffectiveDatatables.authorized?(self, :show, resource)
+  = show_icon_to effective_resource.action_path(:show, resource)
+
+- if edit_action && EffectiveDatatables.authorized?(self, :edit, resource)
+  = edit_icon_to effective_resource.action_path(:edit, resource)
+
+- if destroy_action && EffectiveDatatables.authorized?(self, :destroy, resource)
+  = destroy_icon_to effective_resource.action_path(:destroy, resource), data: { method: :delete, confirm: "Delete #{resource}?" }

data/app/views/effective/datatables/_bulk_actions_column.html.haml

@@ -1,2 +1,2 @@
 - id = (resource.try(:to_param) || resource.try(:id) || resource.object_id)
-= check_box_tag 'bulk_actions_resources[]', id, false, autocomplete: 'off', id: "datatable_bulk_actions_resource_#{id}", data: { role: 'bulk-action' }, onClick: 'event.stopPropagation();'
+= check_box_tag 'bulk_actions_resources[]', id, false, autocomplete: 'off', id: "datatable_bulk_actions_resource_#{id}", data: { role: 'bulk-actions-resource' }, onClick: 'event.stopPropagation();'

data/app/views/effective/datatables/_filters.html.haml

@@ -1,17 +1,16 @@
 .effective-datatables-filters{'aria-controls': datatable.to_param}
-  = simple_form_for :filters, url: (datatable._form[:url] || '#'), method: datatable._form[:verb], html: { class: 'form-inline' } do |form|
-    - if datatable._scopes.present?
-      .effective-datatables-filters-scopes
-        = datatable_scope_tag(form, datatable)
+  = effective_form_with(scope: :filters, url: (datatable._form[:url] || '#'), method: datatable._form[:verb]) do |form|
+    .form-row.align-items-center
+      - if datatable._scopes.present?
+        = form.radios :scope, datatable._scopes.map { |name, opts| [opts[:label], name] },
+          label: false, required: false, checked: datatable.state[:scope], buttons: true,
+          wrapper: { class: 'form-group col-auto' }
 
-    - if datatable._filters.present?
-      .effective-datatables-filters-inputs
-        - datatable._filters.each do |name, opts|
-          = datatable_filter_tag(form, datatable, name, opts)
+      - datatable._filters.each do |name, opts|
+        = datatable_filter_tag(form, datatable, name, opts)
 
-    - if datatable._scopes.present? || datatable._filters.present?
-      .effective-datatables-filters-btn
+      .form-group.col-auto
         - if datatable._filters_form_required?
-          = form.button :submit, t('effective_datatables.apply'), 'data-disable-with': t('effective_datatables.applying')
+          = form.save 'Apply', 'data-disable-with': 'Applying...'
         - else
-          = link_to t('effective_datatables.apply'), '#', class: 'btn btn-primary btn-sm btn-effective-datatables-filters', 'data-apply-effective-datatables-filters': true
+          = link_to 'Apply', '#', class: 'btn btn-primary btn-effective-datatables-filters', 'data-apply-effective-datatables-filters': true

data/app/views/effective/datatables/_resource_column.html.haml

@@ -1,11 +1,8 @@
-- Array(local_assigns[:resource_name] ? resource.public_send(resource_name) : resource).each do |resource|
-  - resource_to_s = ((local_assigns[:resource_to_s] && resource) ? resource.public_send(resource_to_s) : resource.to_s)
-
-  - if resource_to_s.present?
-    .col-resource_item
-      - if edit_action && EffectiveDatatables.authorized?(controller, :edit, resource) && (path = effective_resource.action_path(:edit, resource)).present?
-        = link_to resource_to_s, path, title: resource_to_s
-      - elsif show_action && EffectiveDatatables.authorized?(controller, :show, resource) && (path = effective_resource.action_path(:show, resource)).present?
-        = link_to resource_to_s, path, title: resource_to_s
-      - else
-        = resource_to_s.to_s.html_safe
+- Array(datatable.array_collection? ? resource : resource.send(name)).each do |resource|
+  .col-resource_item
+    - if show_action
+      = link_to resource.to_s, effective_resource.action_path(:show, resource), title: resource.to_s
+    - elsif edit_action
+      = link_to resource.to_s, effective_resource.action_path(:edit, resource), title: resource.to_s
+    - else
+      = resource.to_s.html_safe

data/config/effective_datatables.rb

@@ -28,19 +28,21 @@ EffectiveDatatables.setup do |config|
   # Default class used on the <table> tag
   config.html_class = 'table table-hover'
 
+  # When using the actions_column DSL method, apply the following behavior
+  # Valid values for each action are:
+  # true - display this action if authorized?(:show, Post)
+  # false - do not display this action
+  # :authorize - display this action if authorized?(:show, Post<3>)  (every instance is checked)
+  #
+  # You can override these defaults on a per-table basis
+  # by calling `actions_column(show: false, edit: true, destroy: :authorize)`
+  config.actions_column = {
+    show: true,
+    edit: true,
+    destroy: true
+  }
+
   # Log search/sort information to the console
   config.debug = true
 
-  # Use a cookie to save and restore state from previous page visits.
-  config.save_state = true
-
-  # Configure the _effective_dt cookie.
-  config.cookie_max_size = 2000       # String size. Final byte size is about 1.5 times bigger, after rails signs it
-  config.cookie_domain = :all         # Should usually be :all
-  config.cookie_tld_length = nil      # Leave nil to autodetect, or set to probably 2
-
-  # Date formatting
-  config.format_datetime = '%F %H:%M'
-  config.format_date = '%F'
-  config.format_time = '%H:%M'
 end

data/config/routes.rb

@@ -1,7 +1,6 @@
 EffectiveDatatables::Engine.routes.draw do
   scope :module => 'effective' do
     match 'datatables/:id(.:format)', to: 'datatables#show', via: [:get, :post], as: :datatable
-    match 'datatables/:id/reorder(.:format)', to: 'datatables#reorder', via: [:post], as: :reorder_datatable
   end
 end
 

data/lib/effective_datatables/engine.rb

@@ -1,26 +1,16 @@
-require_relative '../../app/helpers/effective_datatables_controller_helper'
-require_relative '../../app/helpers/effective_datatables_helper'
-require_relative '../../app/helpers/effective_datatables_private_helper'
-
 module EffectiveDatatables
   class Engine < ::Rails::Engine
     engine_name 'effective_datatables'
 
     config.autoload_paths += Dir["#{config.root}/app/models/concerns", '/app/datatables/**/']
 
-    initializer 'effective_datatables.assets' do |app|
-      app.config.assets.precompile += ['effective_datatables_manifest.js', 'images/*']
-    end
-
     # Include Helpers to base application
     initializer 'effective_datatables.action_controller' do |app|
-      app.config.to_prepare do
-        ActiveSupport.on_load :action_controller_base do
-          helper EffectiveDatatablesHelper
-          helper EffectiveDatatablesPrivateHelper
+      ActiveSupport.on_load :action_controller do
+        helper EffectiveDatatablesHelper
+        helper EffectiveDatatablesPrivateHelper
 
-          ActionController::Base.send :include, ::EffectiveDatatablesControllerHelper
-        end
+        ActionController::Base.send :include, ::EffectiveDatatablesControllerHelper
       end
     end
 

data/lib/effective_datatables/version.rb

@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = '3.7.10'.freeze
+  VERSION = '4.0.0'.freeze
 end

data/lib/effective_datatables.rb

@@ -1,30 +1,17 @@
-require 'simple_form'
+require 'effective_bootstrap'
 require 'effective_resources'
 require 'effective_datatables/engine'
 require 'effective_datatables/version'
 
 module EffectiveDatatables
-  AVAILABLE_LOCALES = %w(en es nl)
-
   mattr_accessor :authorization_method
 
   mattr_accessor :default_length
   mattr_accessor :html_class
-  mattr_accessor :save_state
-
-  mattr_accessor :cookie_max_size
-  mattr_accessor :cookie_domain
-  mattr_accessor :cookie_tld_length
-
-  mattr_accessor :format_datetime
-  mattr_accessor :format_date
-  mattr_accessor :format_time
 
+  mattr_accessor :actions_column # A Hash
   mattr_accessor :debug
 
-  alias_method :max_cookie_size, :cookie_max_size
-  alias_method :max_cookie_size=, :cookie_max_size=
-
   def self.setup
     yield self
   end
@@ -33,7 +20,7 @@ module EffectiveDatatables
     @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact
 
     return !!authorization_method unless authorization_method.respond_to?(:call)
-    controller = controller.controller if controller.respond_to?(:controller)
+    controller = controller.controller if controller.respond_to?(:controller) # Do the right thing with a view
 
     begin
       !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
@@ -43,47 +30,7 @@ module EffectiveDatatables
   end
 
   def self.authorize!(controller, action, resource)
-    raise Effective::AccessDenied.new('Access Denied', action, resource) unless authorized?(controller, action, resource)
-  end
-
-  def self.find(id, attributes = nil)
-    id = id.to_s.gsub(/-\d+\z/, '').gsub('-', '/')
-    klass = (id.classify.safe_constantize || id.classify.pluralize.safe_constantize)
-    attributes = decrypt(attributes) || {}
-
-    klass.try(:new, **attributes) || raise('unable to find datatable')
-  end
-
-  # Locale is coming from view. I think it can be dynamic.
-  # We currently support: en, es, nl
-  def self.language(locale)
-    @_languages ||= {}
-
-    locale = :en unless AVAILABLE_LOCALES.include?(locale.to_s)
-
-    @_languages[locale] ||= begin
-      path = Gem::Specification.find_by_name('effective_datatables').gem_dir + "/app/assets/javascripts/dataTables/locales/#{locale}.lang"
-      JSON.parse(File.read(path)).to_json
-    end
-  end
-
-  def self.encrypt(attributes)
-    payload = message_encrypter.encrypt_and_sign(attributes)
-  end
-
-  def self.decrypt(payload)
-    return unless payload.present?
-    return payload if payload.kind_of?(Hash)
-
-    attributes = message_encrypter.decrypt_and_verify(payload)
-
-    raise 'invalid decoded inline payload' unless attributes.kind_of?(Hash)
-
-    attributes
-  end
-
-  def self.message_encrypter
-    ActiveSupport::MessageEncryptor.new(Rails.application.secret_key_base.to_s.first(32))
+    raise Effective::AccessDenied unless authorized?(controller, action, resource)
   end
 
 end