effective_orders 2.2.2 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 965887ff8cbf3b7e8697439088668a0ac0aa90dc
-  data.tar.gz: e27ef24995d31be57f907f4d42e8b4961d888e48
+  metadata.gz: db90e7dfaecba0d3d95887bb7a165d45793210c7
+  data.tar.gz: d4cea5629dbba4dc153a56410912c5540740236f
 SHA512:
-  metadata.gz: 42885a3c34e5a3659a1a278f1f6630caa9bfb50899a4980e18b1643a8ac02f27e0b605d53a5fbd2c6de93d1ba5376475c7456916155f34aaf3ad5216b3fd9c33
-  data.tar.gz: c0196dc5405d9311ee385ac6ffccb561057ddbb627731965e6d606c8600d829788b5b000dd47e8983086e5547134d29b8daae7a318622de14bb0bde2180f229f
+  metadata.gz: 424ad971b23b9dd732a247dd05c252ed2d10a1aacb7fea47ce6533b79ed69256ad1b49a2c6662b87de858d6258f82f2146485fe2df7c24d9afd246851c35b7cd
+  data.tar.gz: 745f4d71411babbe7bfc97aeadd48647a9dc706b4dc4680f3829ea17296202f30463a888f7f4413c43d3aac99ea0db914c8af8024bd8ba3f5f1052d22a31fd61

data/app/controllers/admin/customers_controller.rb

@@ -5,7 +5,12 @@ module Admin
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_customers] : EffectiveOrders.layout)
 
     def index
-      @datatable = Effective::Datatables::Customers.new()
+      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+        @datatable = Effective::Datatables::Customers.new()
+      else
+        @datatable = EffectiveCustomersDatatable.new(self)
+      end
+
       @page_title = 'Customers'
 
       EffectiveOrders.authorized?(self, :admin, :effective_orders)

data/app/controllers/admin/order_items_controller.rb

@@ -5,7 +5,12 @@ module Admin
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_orders] : EffectiveOrders.layout)
 
     def index
-      @datatable = Effective::Datatables::OrderItems.new()
+      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+        @datatable = Effective::Datatables::OrderItems.new()
+      else
+        @datatable = EffectiveOrderItemsDatatable.new(self)
+      end
+
       @page_title = 'Order Items'
 
       EffectiveOrders.authorized?(self, :admin, :effective_orders)

data/app/controllers/admin/orders_controller.rb

@@ -5,7 +5,12 @@ module Admin
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_orders] : EffectiveOrders.layout)
 
     def index
-      @datatable = Effective::Datatables::Orders.new()
+      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+        @datatable = Effective::Datatables::Orders.new()
+      else
+        @datatable = EffectiveOrdersDatatable.new(self)
+      end
+
       @page_title = 'Orders'
 
       authorize_effective_order!

data/app/datatables/effective_customers_datatable.rb

@@ -0,0 +1,38 @@
+unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+  class EffectiveCustomersDatatable < Effective::Datatable
+     datatable do
+      order :email
+
+      col :id, visible: false
+      col :email, sql_column: 'users.email' do |user|
+        mail_to user.email, user.email
+      end
+
+      if EffectiveOrders.stripe_enabled
+        col :stripe_customer_id
+        col :stripe_active_card
+      end
+
+      if EffectiveOrders.stripe_connect_enabled
+        col :stripe_connect_access_token
+      end
+
+      col :subscription_types, sql_column: 'subscription_types'
+
+      actions_col partial: 'admin/customers/actions', partial_as: :customer
+    end
+
+    collection do
+      Effective::Customer.customers.uniq
+        .joins(:user, :subscriptions)
+        .select('customers.*, users.email AS email')
+        .select("array_to_string(array(#{Effective::Subscription.purchased.select('subscriptions.stripe_plan_id').where('subscriptions.customer_id = customers.id').to_sql}), ' ,') AS subscription_types")
+        .group('customers.id, subscriptions.stripe_plan_id, users.email')
+    end
+
+    # def search_column(collection, table_column, search_term)
+    #   return collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%") if table_column[:name] == 'subscription_types'
+    #   super
+    # end
+  end
+end

data/app/datatables/effective_order_items_datatable.rb

@@ -0,0 +1,100 @@
+unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+  class EffectiveOrderItemsDatatable < Effective::Datatable
+    datatable do
+      order :purchased_at, :desc
+
+      col(:purchased_at, sql_column: 'orders.purchased_at') do |order_item|
+        Time.at(order_item[:purchased_at]).in_time_zone if order_item[:purchased_at].present?
+      end
+
+      col :id, visible: false
+
+      col :order
+      # if effectiveorders.obfuscate_order_ids
+      #   col(:order, type: :obfuscated_id) do |order_item|
+      #     obfuscated_id = effective::order.obfuscate(order_item[:order_id])
+      #     link_to(obfuscated_id, (datatables_admin_path? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
+      #   end
+      # else
+      #   col(:order) do |order_item|
+      #     link_to(order_item.to_param, (datatables_admin_path? ? effective_orders.admin_order_path(order_item.to_param) : effective_orders.order_path(order_item.to_param)))
+      #   end
+      # end
+
+      unless attributes[:user_id]
+        col :email, sql_column: 'users.email', label: 'Buyer Email',  do |order_item|
+          link_to order_item[:email], (edit_admin_user_path(order_item[:user_id]) rescue admin_user_path(order_item[:user_id]) rescue '#')
+        end
+      end
+
+      if EffectiveOrders.require_billing_address && attributes[:user_id].blank?
+        col :buyer_name, sortable: false, label: 'Buyer Name', do |order_item|
+          (order_item[:buyer_name] || '').split('!!SEP!!').find(&:present?)
+        end
+      end
+
+      col :purchase_state, sql_column: 'orders.purchase_state', filter: { collection: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order_item|
+        order_item[:purchase_state] || 'abandoned'
+      end
+
+      col :title do |order_item|
+        order_item.quantity == 1 ? order_item.title : "#{order_item.title} (#{order_item.quantity} purchased)"
+      end
+
+      col :subtotal, as: :price
+      col :tax, as: :price
+      col :total, as: :price
+
+      col :created_at, visible: false
+      col :updated_at, visible: false
+    end
+
+    collection do
+      collection = Effective::OrderItem.unscoped
+        .joins(order: :user)
+        .select('order_items.*, orders.*, users.email AS email')
+        .select("#{query_subtotal} AS subtotal, #{query_tax} AS tax, #{query_total} AS total")
+        .group('order_items.id, orders.id, users.email')
+
+      if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
+        addresses_tbl = EffectiveAddresses.addresses_table_name
+
+        collection = collection
+          .joins("LEFT JOIN (SELECT addressable_id, string_agg(#{addresses_tbl}.full_name, '!!SEP!!') AS buyer_name FROM #{addresses_tbl} WHERE #{addresses_tbl}.category = 'billing' AND #{addresses_tbl}.addressable_type = 'Effective::Order' GROUP BY #{addresses_tbl}.addressable_id) #{addresses_tbl} ON orders.id = #{addresses_tbl}.addressable_id")
+          .group("#{addresses_tbl}.buyer_name")
+          .select("#{addresses_tbl}.buyer_name AS buyer_name")
+      end
+
+      attributes[:user_id].present? ? collection.where("#{EffectiveOrders.orders_table_name.to_s}.user_id = ?", attributes[:user_id]) : collection
+    end
+
+    def query_subtotal
+      'SUM(price * quantity)'
+    end
+
+    def query_total
+      'SUM((price * quantity) + (CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END))'
+    end
+
+    def query_tax
+      '(CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END)'
+    end
+
+    # def search_column(collection, table_column, search_term)
+    #   if table_column[:name] == 'order'
+    #     collection.where("#{EffectiveOrders.order_items_table_name.to_s}.order_id = ?", Effective::Order.deobfuscate(search_term))
+    #   elsif table_column[:name] == 'purchase_state' && search_term == 'abandoned'
+    #     collection.where("#{EffectiveOrders.orders_table_name.to_s}.purchase_state IS NULL")
+    #   elsif table_column[:name] == 'subtotal'
+    #     collection.having("#{query_subtotal} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
+    #   elsif table_column[:name] == 'tax'
+    #     collection.having("#{query_tax} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
+    #   elsif table_column[:name] == 'total'
+    #     collection.having("#{query_total} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
+    #   else
+    #     super
+    #   end
+    # end
+
+  end
+end

data/app/datatables/effective_orders_datatable.rb

@@ -0,0 +1,89 @@
+unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+  class EffectiveOrdersDatatable < Effective::Datatable
+    datatable do
+      order :created_at, :desc
+
+      col :purchased_at
+
+      col :id do |order|
+        link_to order.to_param, effective_orders.admin_order_path(order)
+      end
+
+      # Don't display email or buyer_name column if this is for a specific user
+      if attributes[:user_id].blank?
+        col :email, sql_column: 'users.email', label: 'Buyer Email' do |order|
+          link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
+        end
+
+        if EffectiveOrders.use_address_full_name
+          col :buyer_name, sql_column: 'addresses.full_name' do |order|
+            order.billing_address.try(:full_name)
+          end
+
+        elsif # Not using address full name
+          col :buyer_name, sql_column: 'users.*' do |order|
+            order.user.to_s
+          end
+        end
+      end
+
+      if EffectiveOrders.require_billing_address
+        col :billing_address
+      end
+
+      if EffectiveOrders.require_shipping_address
+        col :shipping_address
+      end
+
+      col :purchase_state, label: 'State', search: { collection: purchase_state_filter_values } do |order|
+        order.purchase_state || 'abandoned'
+      end
+
+      col :order_items
+
+      col :subtotal, as: :price
+      col :tax, as: :price
+
+      col :tax_rate, visible: false do |order|
+        tax_rate_to_percentage(order.tax_rate)
+      end
+
+      col :total, as: :price
+
+      col :payment_provider, label: 'Provider', visible: false, search: { collection: ['nil'] + (EffectiveOrders.payment_providers + EffectiveOrders.other_payment_providers).sort }
+      col :payment_card, label: 'Card'
+
+      col :note, visible: false
+      col :note_to_buyer, visible: false
+      col :note_internal, visible: false
+
+      col :created_at, visible: false
+      col :updated_at, visible: false
+
+      actions_col partial: 'admin/orders/actions', partial_as: :order
+    end
+
+    collection do
+      collection = Effective::Order.unscoped
+        .joins(:user)
+        .includes(:addresses)
+        .includes(:user)
+        .includes(:order_items)
+
+      if EffectiveOrders.orders_collection_scope.respond_to?(:call)
+        collection = EffectiveOrders.orders_collection_scope.call(collection)
+      end
+
+      attributes[:user_id].present? ? collection.where(user_id: attributes[:user_id]) : collection
+    end
+
+    def purchase_state_filter_values
+      [
+        %w(abandoned nil),
+        [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED],
+        [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED],
+        [EffectiveOrders::PENDING, EffectiveOrders::PENDING]
+      ]
+    end
+  end
+end

data/app/models/effective/datatables/customers.rb

@@ -1,37 +1,39 @@
-module Effective
-  module Datatables
-    class Customers < Effective::Datatable
-      datatable do
-        default_order :email, :asc
+if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+  module Effective
+    module Datatables
+      class Customers < Effective::Datatable
+        datatable do
+          default_order :email, :asc
 
-        table_column :id, visible: false
-        table_column(:email, column: 'users.email') { |user| mail_to user.email, user.email }
+          table_column :id, visible: false
+          table_column(:email, column: 'users.email') { |user| mail_to user.email, user.email }
 
-        if EffectiveOrders.stripe_enabled
-          table_column :stripe_customer_id
-          table_column :stripe_active_card
-        end
+          if EffectiveOrders.stripe_enabled
+            table_column :stripe_customer_id
+            table_column :stripe_active_card
+          end
 
-        if EffectiveOrders.stripe_connect_enabled
-          table_column :stripe_connect_access_token
-        end
+          if EffectiveOrders.stripe_connect_enabled
+            table_column :stripe_connect_access_token
+          end
 
-        table_column :subscription_types, column: 'subscription_types'
+          table_column :subscription_types, column: 'subscription_types'
 
-        actions_column partial: 'admin/customers/actions'
-      end
+          actions_column partial: 'admin/customers/actions'
+        end
 
-      def collection
-        Effective::Customer.customers.uniq
-          .joins(:user, :subscriptions)
-          .select('customers.*, users.email AS email')
-          .select("array_to_string(array(#{Effective::Subscription.purchased.select('subscriptions.stripe_plan_id').where('subscriptions.customer_id = customers.id').to_sql}), ' ,') AS subscription_types")
-          .group('customers.id, subscriptions.stripe_plan_id, users.email')
-      end
+        def collection
+          Effective::Customer.customers.uniq
+            .joins(:user, :subscriptions)
+            .select('customers.*, users.email AS email')
+            .select("array_to_string(array(#{Effective::Subscription.purchased.select('subscriptions.stripe_plan_id').where('subscriptions.customer_id = customers.id').to_sql}), ' ,') AS subscription_types")
+            .group('customers.id, subscriptions.stripe_plan_id, users.email')
+        end
 
-      def search_column(collection, table_column, search_term)
-        return collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%") if table_column[:name] == 'subscription_types'
-        super
+        def search_column(collection, table_column, search_term)
+          return collection.where('subscriptions.stripe_plan_id ILIKE ?', "%#{search_term}%") if table_column[:name] == 'subscription_types'
+          super
+        end
       end
     end
   end

data/app/models/effective/datatables/order_items.rb

@@ -1,99 +1,101 @@
-module Effective
-  module Datatables
-    class OrderItems < Effective::Datatable
-      datatable do
-        default_order :purchased_at, :desc
-
-        table_column(:purchased_at, type: :datetime, column: 'orders.purchased_at') do |order_item|
-          Time.at(order_item[:purchased_at]).in_time_zone if order_item[:purchased_at].present?
-        end
+if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
+  module Effective
+    module Datatables
+      class OrderItems < Effective::Datatable
+        datatable do
+          default_order :purchased_at, :desc
+
+          table_column(:purchased_at, type: :datetime, column: 'orders.purchased_at') do |order_item|
+            Time.at(order_item[:purchased_at]).in_time_zone if order_item[:purchased_at].present?
+          end
 
-        table_column :id, visible: false
+          table_column :id, visible: false
+
+          if EffectiveOrders.obfuscate_order_ids
+            table_column(:order, type: :obfuscated_id, sortable: false) do |order_item|
+              obfuscated_id = Effective::Order.obfuscate(order_item[:order_id])
+              link_to(obfuscated_id, (datatables_admin_path? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
+            end
+          else
+            table_column(:order, sortable: false) do |order_item|
+              link_to(order_item.to_param, (datatables_admin_path? ? effective_orders.admin_order_path(order_item.to_param) : effective_orders.order_path(order_item.to_param)))
+            end
+          end
 
-        if EffectiveOrders.obfuscate_order_ids
-          table_column(:order, type: :obfuscated_id, sortable: false) do |order_item|
-            obfuscated_id = Effective::Order.obfuscate(order_item[:order_id])
-            link_to(obfuscated_id, (datatables_admin_path? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
+          table_column :email, column: 'users.email', label: 'Buyer Email', if: proc { attributes[:user_id].blank? } do |order_item|
+            link_to order_item[:email], (edit_admin_user_path(order_item[:user_id]) rescue admin_user_path(order_item[:user_id]) rescue '#')
           end
-        else
-          table_column(:order, sortable: false) do |order_item|
-            link_to(order_item.to_param, (datatables_admin_path? ? effective_orders.admin_order_path(order_item.to_param) : effective_orders.order_path(order_item.to_param)))
+
+          if EffectiveOrders.require_billing_address
+            table_column :buyer_name, sortable: false, label: 'Buyer Name', if: proc { attributes[:user_id].blank? } do |order_item|
+              (order_item[:buyer_name] || '').split('!!SEP!!').find(&:present?)
+            end
           end
-        end
 
-        table_column :email, column: 'users.email', label: 'Buyer Email', if: proc { attributes[:user_id].blank? } do |order_item|
-          link_to order_item[:email], (edit_admin_user_path(order_item[:user_id]) rescue admin_user_path(order_item[:user_id]) rescue '#')
-        end
+          table_column :purchase_state, column: 'orders.purchase_state', filter: { type: :select, values: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order_item|
+            order_item[:purchase_state] || 'abandoned'
+          end
 
-        if EffectiveOrders.require_billing_address
-          table_column :buyer_name, sortable: false, label: 'Buyer Name', if: proc { attributes[:user_id].blank? } do |order_item|
-            (order_item[:buyer_name] || '').split('!!SEP!!').find(&:present?)
+          table_column :title do |order_item|
+            order_item.quantity == 1 ? order_item.title : "#{order_item.title} (#{order_item.quantity} purchased)"
           end
-        end
 
-        table_column :purchase_state, column: 'orders.purchase_state', filter: { type: :select, values: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order_item|
-          order_item[:purchase_state] || 'abandoned'
-        end
+          table_column(:subtotal) { |order_item| price_to_currency(order_item[:subtotal].to_i) }
+          table_column(:tax) { |order_item| price_to_currency(order_item[:tax].to_i) }
+          table_column(:total) { |order_item| price_to_currency(order_item[:total].to_i) }
 
-        table_column :title do |order_item|
-          order_item.quantity == 1 ? order_item.title : "#{order_item.title} (#{order_item.quantity} purchased)"
+          table_column :created_at, visible: false
+          table_column :updated_at, visible: false
         end
 
-        table_column(:subtotal) { |order_item| price_to_currency(order_item[:subtotal].to_i) }
-        table_column(:tax) { |order_item| price_to_currency(order_item[:tax].to_i) }
-        table_column(:total) { |order_item| price_to_currency(order_item[:total].to_i) }
+        def collection
+          collection = Effective::OrderItem.unscoped
+            .joins(order: :user)
+            .select('order_items.*, orders.*, users.email AS email')
+            .select("#{query_subtotal} AS subtotal, #{query_tax} AS tax, #{query_total} AS total")
+            .group('order_items.id, orders.id, users.email')
 
-        table_column :created_at, visible: false
-        table_column :updated_at, visible: false
-      end
-
-      def collection
-        collection = Effective::OrderItem.unscoped
-          .joins(order: :user)
-          .select('order_items.*, orders.*, users.email AS email')
-          .select("#{query_subtotal} AS subtotal, #{query_tax} AS tax, #{query_total} AS total")
-          .group('order_items.id, orders.id, users.email')
+          if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
+            addresses_tbl = EffectiveAddresses.addresses_table_name
 
-        if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
-          addresses_tbl = EffectiveAddresses.addresses_table_name
+            collection = collection
+              .joins("LEFT JOIN (SELECT addressable_id, string_agg(#{addresses_tbl}.full_name, '!!SEP!!') AS buyer_name FROM #{addresses_tbl} WHERE #{addresses_tbl}.category = 'billing' AND #{addresses_tbl}.addressable_type = 'Effective::Order' GROUP BY #{addresses_tbl}.addressable_id) #{addresses_tbl} ON orders.id = #{addresses_tbl}.addressable_id")
+              .group("#{addresses_tbl}.buyer_name")
+              .select("#{addresses_tbl}.buyer_name AS buyer_name")
+          end
 
-          collection = collection
-            .joins("LEFT JOIN (SELECT addressable_id, string_agg(#{addresses_tbl}.full_name, '!!SEP!!') AS buyer_name FROM #{addresses_tbl} WHERE #{addresses_tbl}.category = 'billing' AND #{addresses_tbl}.addressable_type = 'Effective::Order' GROUP BY #{addresses_tbl}.addressable_id) #{addresses_tbl} ON orders.id = #{addresses_tbl}.addressable_id")
-            .group("#{addresses_tbl}.buyer_name")
-            .select("#{addresses_tbl}.buyer_name AS buyer_name")
+          attributes[:user_id].present? ? collection.where("#{EffectiveOrders.orders_table_name.to_s}.user_id = ?", attributes[:user_id]) : collection
         end
 
-        attributes[:user_id].present? ? collection.where("#{EffectiveOrders.orders_table_name.to_s}.user_id = ?", attributes[:user_id]) : collection
-      end
-
-      def query_subtotal
-        'SUM(price * quantity)'
-      end
+        def query_subtotal
+          'SUM(price * quantity)'
+        end
 
-      def query_total
-        'SUM((price * quantity) + (CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END))'
-      end
+        def query_total
+          'SUM((price * quantity) + (CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END))'
+        end
 
-      def query_tax
-        '(CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END)'
-      end
+        def query_tax
+          '(CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END)'
+        end
 
-      def search_column(collection, table_column, search_term)
-        if table_column[:name] == 'order'
-          collection.where("#{EffectiveOrders.order_items_table_name.to_s}.order_id = ?", Effective::Order.deobfuscate(search_term))
-        elsif table_column[:name] == 'purchase_state' && search_term == 'abandoned'
-          collection.where("#{EffectiveOrders.orders_table_name.to_s}.purchase_state IS NULL")
-        elsif table_column[:name] == 'subtotal'
-          collection.having("#{query_subtotal} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-        elsif table_column[:name] == 'tax'
-          collection.having("#{query_tax} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-        elsif table_column[:name] == 'total'
-          collection.having("#{query_total} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-        else
-          super
+        def search_column(collection, table_column, search_term)
+          if table_column[:name] == 'order'
+            collection.where("#{EffectiveOrders.order_items_table_name.to_s}.order_id = ?", Effective::Order.deobfuscate(search_term))
+          elsif table_column[:name] == 'purchase_state' && search_term == 'abandoned'
+            collection.where("#{EffectiveOrders.orders_table_name.to_s}.purchase_state IS NULL")
+          elsif table_column[:name] == 'subtotal'
+            collection.having("#{query_subtotal} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
+          elsif table_column[:name] == 'tax'
+            collection.having("#{query_tax} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
+          elsif table_column[:name] == 'total'
+            collection.having("#{query_total} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
+          else
+            super
+          end
         end
-      end
 
+      end
     end
   end
 end

data/lib/effective_orders/version.rb

@@ -1,3 +1,3 @@
 module EffectiveOrders
-  VERSION = '2.2.2'.freeze
+  VERSION = '2.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_orders
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.2.3
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-03 00:00:00.000000000 Z
+date: 2017-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -297,6 +297,9 @@ files:
 - app/controllers/effective/providers/stripe_connect.rb
 - app/controllers/effective/subscriptions_controller.rb
 - app/controllers/effective/webhooks_controller.rb
+- app/datatables/effective_customers_datatable.rb
+- app/datatables/effective_order_items_datatable.rb
+- app/datatables/effective_orders_datatable.rb
 - app/helpers/effective_carts_helper.rb
 - app/helpers/effective_ccbill_helper.rb
 - app/helpers/effective_orders_helper.rb