effective_orders 2.2.4 → 3.0.0

data/app/datatables/effective_customers_datatable.rb

@@ -1,38 +1,30 @@
-unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  class EffectiveCustomersDatatable < Effective::Datatable
-     datatable do
-      order :email
+class EffectiveCustomersDatatable < Effective::Datatable
+   datatable do
 
-      col :id, visible: false
-      col :email, sql_column: 'users.email' do |user|
-        mail_to user.email, user.email
-      end
+    col :id, visible: false
+    #col 'user.email'
 
-      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'
+    if EffectiveOrders.stripe_enabled
+      col :stripe_customer_id
+      col :active_card
+    end
 
-      actions_col partial: 'admin/customers/actions', partial_as: :customer
+    if EffectiveOrders.stripe_connect_enabled
+      col :stripe_connect_access_token
     end
 
-    collection do
-      Effective::Customer.customers.distinct
-        .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')
+    actions_col do |customer|
+      link_to('Manage', "https://dashboard.stripe.com/#{'test/' if Rails.env.development?}customers/#{customer.stripe_customer_id}")
     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
+
+  collection do
+    Effective::Customer.joins(:user).all
+  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

data/app/datatables/effective_order_items_datatable.rb

@@ -1,101 +1,99 @@
-unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  class EffectiveOrderItemsDatatable < Effective::Datatable
-    datatable do
-      order :purchased_at, :desc
+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(: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
+    col :id, visible: false
 
-      if EffectiveOrders.require_billing_address && attributes[:user_id].blank?
-        col :buyer_name, sort: false, label: 'Buyer Name' do |order_item|
-          (order_item[:buyer_name] || '').split('!!SEP!!').find(&:present?)
-        end
-      end
+    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
 
-      col :purchase_state, sql_column: 'orders.purchase_state', search: { collection: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order_item|
-        order_item[:purchase_state] || 'abandoned'
+    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
 
-      col :title do |order_item|
-        order_item.quantity == 1 ? order_item.title : "#{order_item.title} (#{order_item.quantity} purchased)"
+    if EffectiveOrders.require_billing_address && attributes[:user_id].blank?
+      col :buyer_name, sort: false, label: 'Buyer Name' do |order_item|
+        (order_item[:buyer_name] || '').split('!!SEP!!').find(&:present?)
       end
+    end
 
-      # col :subtotal, as: :price
-      # col :tax, as: :price
-      # col :total, as: :price
+    col :purchase_state, sql_column: 'orders.purchase_state', search: { 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 :created_at, visible: false
-      col :updated_at, visible: false
+    col :title do |order_item|
+      order_item.quantity == 1 ? order_item.title : "#{order_item.title} (#{order_item.quantity} purchased)"
     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')
+    # col :subtotal, as: :price
+    # col :tax, as: :price
+    # col :total, as: :price
 
-      if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
-        addresses_tbl = EffectiveAddresses.addresses_table_name
+    col :created_at, visible: false
+    col :updated_at, visible: false
+  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")
-      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')
 
-      attributes[:user_id].present? ? collection.where("#{EffectiveOrders.orders_table_name.to_s}.user_id = ?", attributes[:user_id]) : collection
-    end
+    if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
+      addresses_tbl = EffectiveAddresses.addresses_table_name
 
-    def query_subtotal
-      'SUM(price * quantity)'
+      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
 
-    def query_total
-      'SUM((price * quantity) + (CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END))'
-    end
+    attributes[:user_id].present? ? collection.where("#{EffectiveOrders.orders_table_name.to_s}.user_id = ?", attributes[:user_id]) : collection
+  end
 
-    def query_tax
-      '(CASE tax_exempt WHEN true THEN 0 ELSE ((price * quantity) * tax_rate) END)'
-    end
+  def query_subtotal
+    'SUM(price * quantity)'
+  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
+  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

data/app/datatables/effective_orders_datatable.rb

@@ -1,81 +1,91 @@
-unless Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-  class EffectiveOrdersDatatable < Effective::Datatable
-    datatable do
-      order :created_at, :desc
+class EffectiveOrdersDatatable < Effective::Datatable
+  bulk_actions do
+    if EffectiveOrders.authorized?(view.controller, :admin, :effective_orders)
+      bulk_action(
+      'Send payment request email to selected pending orders',
+        effective_orders.bulk_send_payment_request_admin_orders_path,
+        data: { confirm: 'Send payment request emails to pending orders?' }
+      )
+    end
 
-      col :purchased_at
+    bulk_action(
+    'Send receipt email to selected purchased orders',
+      effective_orders.bulk_send_buyer_receipt_orders_path,
+      data: { confirm: 'Send receipt emails to purchased orders?' }
+    )
+  end
 
-      col :id
+  datatable do
+    order :created_at, :desc
 
-      if attributes[:user_id].blank?
-        col :user, label: 'Buyer', search: :string, sort: :email do |order|
-          link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
-        end
+    bulk_actions_col
 
-        if EffectiveOrders.require_billing_address && EffectiveOrders.use_address_full_name
-          val :buyer_name, visible: false do |order|
-            order.billing_address.try(:full_name)
-          end
-        else
-          val :buyer_name, visible: false do |order|
-            order.user.to_s
-          end
-        end
-      end
+    col :purchased_at
 
-      if EffectiveOrders.require_billing_address
-        col :billing_address
-      end
+    col :id
 
-      if EffectiveOrders.require_shipping_address
-        col :shipping_address
+    if attributes[:user_id].blank?
+      col :user, label: 'Buyer', search: :string, sort: :email do |order|
+        link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
       end
 
-      col :purchase_state, label: 'State', search: { collection: purchase_state_filter_values } do |order|
-        order.purchase_state || EffectiveOrders::ABANDONED
+      if EffectiveOrders.require_billing_address && EffectiveOrders.use_address_full_name
+        val :buyer_name, visible: false do |order|
+          order.billing_address.try(:full_name)
+        end
+      else
+        val :buyer_name, visible: false do |order|
+          order.user.to_s
+        end
       end
+    end
+
+    if EffectiveOrders.require_billing_address
+      col :billing_address
+    end
 
-      col :order_items
+    if EffectiveOrders.require_shipping_address
+      col :shipping_address
+    end
 
-      col :subtotal, as: :price
-      col :tax, as: :price
+    col :purchase_state, label: 'State', search: { collection: EffectiveOrders::PURCHASE_STATES.invert } do |order|
+      EffectiveOrders::PURCHASE_STATES[order.purchase_state]
+    end
 
-      col :tax_rate, visible: false do |order|
-        tax_rate_to_percentage(order.tax_rate)
-      end
+    col :order_items, search: { as: :string }
 
-      col :total, as: :price
+    col :subtotal, as: :price
+    col :tax, 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 :tax_rate, visible: false do |order|
+      tax_rate_to_percentage(order.tax_rate)
+    end
 
-      col :note, visible: false
-      col :note_to_buyer, visible: false
-      col :note_internal, visible: false
+    col :total, as: :price
 
-      col :created_at, visible: false
-      col :updated_at, visible: false
+    col :payment_provider, label: 'Provider', visible: false, search: { collection: ['nil'] + (EffectiveOrders.payment_providers + EffectiveOrders.other_payment_providers).sort }
+    col :payment_card, label: 'Card'
 
-      actions_col partial: 'admin/orders/actions', partial_as: :order
-    end
+    col :note, visible: false
+    col :note_to_buyer, visible: false
+    col :note_internal, visible: false
 
-    collection do
-      scope = Effective::Order.unscoped.includes(:addresses, :order_items, :user)
+    col :created_at, visible: false
+    col :updated_at, visible: false
 
-      if EffectiveOrders.orders_collection_scope.respond_to?(:call)
-        scope = EffectiveOrders.orders_collection_scope.call(scope)
-      end
+    actions_col partial: 'admin/orders/actions', partial_as: :order
 
-      attributes[:user_id].present? ? scope.where(user_id: attributes[:user_id]) : scope
-    end
+    aggregate :total
+  end
+
+  collection do
+    scope = Effective::Order.unscoped.includes(:addresses, :order_items, :user)
 
-    def purchase_state_filter_values
-      [
-        [EffectiveOrders::ABANDONED, nil],
-        [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED],
-        [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED],
-        [EffectiveOrders::PENDING, EffectiveOrders::PENDING]
-      ]
+    if EffectiveOrders.orders_collection_scope.respond_to?(:call)
+      scope = EffectiveOrders.orders_collection_scope.call(scope)
     end
+
+    attributes[:user_id].present? ? scope.where(user_id: attributes[:user_id]) : scope
   end
+
 end

data/app/helpers/effective_carts_helper.rb

@@ -1,24 +1,27 @@
 module EffectiveCartsHelper
+  # TODO: Consider unique
   def current_cart(for_user = nil)
     @cart ||= (
       user = for_user || (current_user rescue nil) # rescue protects me against Devise not being installed
 
       if user.present?
-        Effective::Cart.where(user_id: user.id).first_or_create.tap do |user_cart|
-          if session[:cart].present?
-            session_cart = Effective::Cart.where('user_id IS NULL').where(id: session[:cart]).first
+        user_cart = Effective::Cart.where(user: user).first_or_create
 
-            if session_cart.present?
-              session_cart.cart_items.update_all(cart_id: user_cart.id)
-              session_cart.destroy
-              user_cart.reload
-            end
+        # Merge session cart into user cart.
+        if session[:cart].present?
+          session_cart = Effective::Cart.where(user: nil).where(id: session[:cart]).first
 
-            session[:cart] = nil
+          if session_cart
+            session_cart.cart_items.each { |i| user_cart.add(i.purchasable, quantity: i.quantity, unique: i.unique) }
+            session_cart.destroy
           end
+
+          session[:cart] = nil
         end
+
+        user_cart
       elsif session[:cart].present?
-        Effective::Cart.where('user_id IS NULL').where(id: session[:cart]).first_or_create
+        Effective::Cart.where(user_id: nil).where(id: session[:cart]).first_or_create
       else
         cart = Effective::Cart.create!
         session[:cart] = cart.id
@@ -42,7 +45,7 @@ module EffectiveCartsHelper
   end
 
   def link_to_add_to_cart(purchasable, opts = {})
-    raise ArgumentError.new('expecting an acts_as_purchasable object') unless purchasable.kind_of?(ActsAsPurchasable)
+    raise 'expecting an acts_as_purchasable object' unless purchasable.kind_of?(ActsAsPurchasable)
 
     options = {
       label: 'Add to Cart',
@@ -60,7 +63,7 @@ module EffectiveCartsHelper
   end
 
   def link_to_remove_from_cart(cart_item, opts = {})
-    raise ArgumentError.new('expecting an Effective::CartItem object') unless cart_item.kind_of?(Effective::CartItem)
+    raise 'expecting an Effective::CartItem object' unless cart_item.kind_of?(Effective::CartItem)
 
     options = {
       label: 'Remove',
@@ -120,11 +123,11 @@ module EffectiveCartsHelper
 
   def render_cart(cart = nil)
     cart ||= current_cart
-    render(partial: 'effective/carts/cart', locals: {cart: cart})
+    render(partial: 'effective/carts/cart', locals: { cart: cart })
   end
 
   def render_purchasables(*purchasables)
-    render(partial: 'effective/orders/order_items', locals: {order: Effective::Order.new(purchasables)})
+    render(partial: 'effective/orders/order_items', locals: { order: Effective::Order.new(purchasables) })
   end
 
 end