gem 'effective_datatables'

# For use with Bootstrap3 (which is not included in this gem):
//= require effective_datatables

# For use with Bootstrap2 (which is not includled in this gem):
//= require effective_datatables.bootstrap2

# For use with Bootstrap3 (which is not included in this gem):
*= require effective_datatables

# For use with Bootstrap2 (which is not not included in this gem):
*= require effective_datatables.bootstrap2

module Effective
  module Datatables
    class Posts < Effective::Datatable
      table_column :id
      table_column :user    # if Post belongs_to :user
      table_column :title
      table_column :created_at

      def collection
        Post.all
      end

    end
  end
end

class PostsController < ApplicationController
  def index
    @datatable = Effective::Datatables::Posts.new()
  end
end

module Effective
  module Datatables
    class Posts < Effective::Datatable
      default_order :created_at, :desc
      default_entries 25

      table_column :id, :visible => false

      table_column :created_at, :width => '25%'

      table_column :updated_at, :proc => Proc.new { |post| nicetime(post.updated_at) } # just a standard helper as defined in helpers/application_helper.rb

      table_column :user

      table_column :post_category_id, :filter => {:type => :select, :values => Proc.new { PostCategory.all } } do |post|
        post.post_category.name.titleize
      end

      array_column :comments do |post|
        content_tag(:ul) do
          post.comments.where(:archived => false).map do |comment|
            content_tag(:li, comment.title)
          end.join('').html_safe
        end
      end

      table_column :title, :label => 'Post Title', :class => 'col-title'
      table_column :actions, :sortable => false, :filter => false, :partial => '/posts/actions'

      def collection
        Post.where(:archived => false).includes(:post_category)
      end

    end
  end
end

def collection
  Posts.all
end

def collection
  collection = Effective::Order.unscoped.purchased
    .joins(:user)
    .joins(:order_items)
    .group('users.email')
    .group('orders.id')
    .select('users.email AS email')
    .select('orders.*')
    .select("#{query_total} AS total")
    .select("string_agg(order_items.title, '!!OI!!') AS order_items")

  if attributes[:user_id].present?
    collection.where(:user_id => attributes[:user_id])
  else
    collection
  end
end

def query_total
  "SUM((order_items.price * order_items.quantity) + (CASE order_items.tax_exempt WHEN true THEN 0 ELSE ((order_items.price * order_items.quantity) * order_items.tax_rate) END))"
end

# The name of the table column as per the Database
# This column is detected as an Integer, therefore it is :type => :integer
# Any SQL used to search this field will take the form of "id = ?"
table_column :id

# As per our 'complex' example above, using the .select('customers.stripe_customer_id AS stripe_customer_id') syntax to create a faux database table
# This column is detected as a String, therefore it is :type => :string
# Any SQL used to search this field will take the form of "customers.stripe_customer_id ILIKE %?%"
table_column :stripe_customer_id, :column => 'customers.stripe_customer_id'

# The name of the table column as per the Database
# This column is detected as a DateTime, therefore it is :type => :datetime
# Any SQL used to search this field will take the form of
# "to_char(#{column} AT TIME ZONE 'GMT', 'YYYY-MM-DD HH24:MI') ILIKE '%?%'"
table_column :created_at

# If the name of the table column matches a belongs_to in our collection's main class
# This column will be detected as a belongs_to and some predefined filters will be set up
# So declaring the following
table_column :user

# Will have the same behaviour as declaring
table_column :user_id, :if => Proc.new { attributes[:user_id].blank? }, :filter => {:type => :select, :values => Proc.new { User.all.map { |user| [user.id, user.to_s] }.sort { |x, y| x[1] <=> y[1] } } } do |post|
  post.user.to_s
end

:column => 'users.id'     # Set this if you're doing something tricky with the database.  Used internally for .order() and .where() clauses
:type => :string          # Derived from the ActiveRecord attribute default datatype.  Controls searching behaviour.  Valid options include :string, :text, :datetime, :integer, :boolean, :year
:if => Proc.new { attributes[:user_id].blank? }  # Excludes this table_column entirely if false. See "Initialize with attributes" section of this README below

:label => 'Nice Label'    # Override the default column header label
:sortable => true|false   # Allow sorting of this column.  Otherwise the up/down arrows on the frontend will be disabled.
:visible => true|false    # Hide this column at startup.  Column visbility can be changed on the frontend.  By default, hidden column filter terms are ignored.
:width => '100%'|'100px'  # Set the width of this column.  Can be set on one, all or some of the columns.  If using percentages, should never add upto more than 100%
:class => 'col-example'   # Adds an html class to the column's TH and all TD elements.  Add more than one class with 'example col-example something'

table_column :created_at, :filter => false    # Disable filtering on this column entirely
table_column :created_at, :filter => {...}    # Enable filtering with these options

:filter => {:type => :number}
:filter => {:type => :text}

:filter => {:type => :select, :values => ['One', 'Two'], :selected => 'Two'}
:filter => {:type => :select, :values => [*2010..(Time.zone.now.year+6)]}
:filter => {:type => :select, :values => Proc.new { PostCategory.all } }
:filter => {:type => :select, :values => Proc.new { User.all.order(:email).map { |obj| [obj.id, obj.email] } } }

:filter => {:when_hidden => true}  # By default a hidden column's search filter will be ignored, unless this is true.  Can be used for scoping.
:filter => {:fuzzy => true} # Will use an ILIKE/includes rather than = when filtering.  Use this for selects.

table_column :created_at do |post|
  if post.created_at > (Time.zone.now-1.year)
    link_to('this year', post_path(post))
  else
    link_to(post.created_at.strftime("%Y-%m-%d %H:%M:%S"), post_path(post))
  end
end

table_column :created_at, :proc => Proc.new { |post| link_to(post.created_at, post_path(post)) }

table_column :actions, :partial => '/posts/actions'  # render this partial for each row of the table

table_column :actions, :partial => '/posts/actions', :partial_local => 'the_post'

table_column :created_at do |post|
  if datatables_admin_path?
    link_to admin_posts_path(post)
  else
    link_to posts_path(post)
  end
end

request.referer.include?('/admin/')

table_columns :id, :created_at, :updated_at, :category, :title

default_order :created_at, :asc|:desc

default_entries :all

def collection
  User.unscoped.uniq
    .joins('LEFT JOIN customers ON customers.user_id = users.id')
    .select('users.*')
    .select('customers.stripe_customer_id AS stripe_customer_id')
    .includes(:addresses)
end

def search_column(collection, table_column, search_term)
  if table_column[:name] == 'subscription_types'
    collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%")
  else
    super
  end
end

class PostsController < ApplicationController
  def index
    @datatable = Effective::Datatables::Posts.new(:user_id => current_user.try(:id))
  end
end

def collection
  if attributes[:user_id]
    Post.where(:user_id => attributes[:user_id])
  else
    Post.all
  end
end

table_column :user_id, :if => Proc.new { attributes[:user_id].blank? } do |post|
  post.user.email
end

module Effective
  module Datatables
    class Posts < Effective::Datatable
      table_column :title do |post|
        format_post_title(post)
      end

      def collection
        Post.all
      end

      def format_post_title(post)
        if post.title.start_with?('important')
          link_to(post.title.upcase, post_path(post))
        else
          link_to(post.title, post_path(post))
        end
      end

    end
  end
end

module PostHelper
end

module Effective
  module Datatables
    class Posts < Effective::Datatable
      include PostsHelper

    end
  end
end

module Effective
  module Datatables
    class ArrayBackedDataTable < Effective::Datatable
      array_column :id
      array_column :first_name
      array_column :last_name
      array_column :email

      def collection
        [
          [1, 'Dana', 'Janssen', '[email protected]'],
          [2, 'Ashley', 'Janssen', '[email protected]'],
          [3, 'Matthew', 'Riemer', '[email protected]'],
          [4, 'Stephen', 'Brown', '[email protected]'],
          [5, 'Warren', 'Uhrich', '[email protected]'],
          [6, 'Dallas', 'Meidinger', '[email protected]'],
          [7, 'Nathan', 'Feaver', '[email protected]']
        ]
      end

    end
  end
end

def finalize(collection)
  collection.each do |row|
    row.each do |column|
      column.gsub!('horse', 'force') if column.kind_of?(String)
    end
  end
end

def collection_class
  NotPost
end

# As a Proc (with CanCan)
config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) }

# As a Custom Method
config.authorization_method = :my_authorization_method

def my_authorization_method(action, resource)
  current_user.is?(:admin) || EffectivePunditPolicy.new(current_user, resource).send('#{action}?')
end

config.authorization_method = false

rescue_from Effective::AccessDenied do |exception|
  respond_to do |format|
    format.html { render 'static_pages/access_denied', :status => 403 }
    format.any { render :text => 'Access Denied', :status => 403 }
  end
end

rake spec