effective_orders 3.2.3 → 4.0.0beta1

data/app/controllers/effective/providers/cheque.rb

@@ -9,7 +9,7 @@ module Effective
 
         EffectiveOrders.authorize!(self, :update, @order)
 
-        @order.purchase_state = EffectiveOrders::PENDING
+        @order.state = EffectiveOrders::PENDING
         @order.payment_provider = 'cheque'
 
         begin

data/app/controllers/effective/providers/moneris.rb

@@ -17,39 +17,33 @@ module Effective
         declined_url = params.delete(:rvar_declined_url)
 
         if @order.purchased?  # Fallback to a success condition of the Order is already purchased
-          return order_purchased(details: params, provider: 'moneris', card: params[:card], purchased_url: purchased_url)
+          order_purchased(details: params, provider: 'moneris', card: params[:card], purchased_url: purchased_url)
+          return
         end
 
-        # Invalid Result
-        if params[:result].to_s != '1' || params[:transactionKey].blank?
-          return order_declined(details: params, provider: 'moneris', card: params[:card], declined_url: declined_url)
-        end
+        if params[:result].to_s == '1' && params[:transactionKey].present?
+          verify_params = parse_moneris_response(send_moneris_verify_request(params[:transactionKey])) || {}
 
-        payment = params.merge(verify_moneris_transaction(params[:transactionKey]))
-        valid = (1..49).include?(payment[:response_code].to_i)  # Must be > 0 and < 50 to be valid. Sometimes we get the string 'null'
+          response_code = verify_params[:response_code].to_i # Sometimes moneris sends us the string 'null'
 
-        if valid == false
-          return order_declined(details: payment, provider: 'moneris', card: params[:card], declined_url: declined_url)
+          if response_code > 0 && response_code < 50  # Less than 50 means a successful validation
+            order_purchased(details: params.merge(verify_params), provider: 'moneris', card: params[:card], purchased_url: purchased_url)
+          else
+            order_declined(details: params.merge(verify_params), provider: 'moneris', card: params[:card], declined_url: declined_url)
+          end
+        else
+          order_declined(details: params, provider: 'moneris', card: params[:card], declined_url: declined_url)
         end
-
-        order_purchased(details: payment, provider: 'moneris', card: params[:card], purchased_url: purchased_url)
       end
 
       private
 
-      def verify_moneris_transaction(transactionKey)
-        # Send a verification POST request
-        uri = URI.parse(EffectiveOrders.moneris[:verify_url])
-        params = { ps_store_id: EffectiveOrders.moneris[:ps_store_id], hpp_key: EffectiveOrders.moneris[:hpp_key], transactionKey: transactionKey }
-        headers = { 'Referer': effective_orders.orders_url }
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-
-        body = http.post(uri.path, params.to_query, headers).body
+      def parse_moneris_response(text)
+        text.split("<br>").inject(Hash.new()) { |h, i| h[i.split(' ').first.to_sym] = i.split(' ').last ; h } rescue {response: text}
+      end
 
-        # Parse response into a Hash
-        body.split('<br>').inject({}) { |h, i| h[i.split(' ').first.to_sym] = i.split(' ').last; h }
+      def send_moneris_verify_request(verify_key)
+        `curl -F ps_store_id='#{EffectiveOrders.moneris[:ps_store_id]}' -F hpp_key='#{EffectiveOrders.moneris[:hpp_key]}' -F transactionKey='#{verify_key}' --referer #{effective_orders.moneris_postback_orders_url} #{EffectiveOrders.moneris[:verify_url]}`
       end
 
     end

data/app/controllers/effective/providers/stripe.rb

@@ -16,7 +16,7 @@ module Effective
         if @stripe_charge.valid? && (response = process_stripe_charge(@stripe_charge)) != false
           order_purchased(
             details: response,
-            provider: (EffectiveOrders.stripe_connect_enabled ? 'stripe_connect' : 'stripe'),
+            provider: 'stripe',
             card: (response[:charge]['source']['brand'] rescue nil)
           )
         else
@@ -34,11 +34,7 @@ module Effective
             subscripter = Effective::Subscripter.new(user: charge.order.user, stripe_token: charge.stripe_token)
             subscripter.save!
 
-            if EffectiveOrders.stripe_connect_enabled
-              return charge_with_stripe_connect(charge, subscripter.customer)
-            else
-              return charge_with_stripe(charge, subscripter.customer)
-            end
+            return charge_with_stripe(charge, subscripter.customer)
           rescue => e
             charge.errors.add(:base, "Unable to process order with Stripe. Your credit card has not been charged. Message: \"#{e.message}\".")
             raise ActiveRecord::Rollback
@@ -63,37 +59,6 @@ module Effective
         results
       end
 
-      def charge_with_stripe_connect(charge, buyer)
-        # Go through and create Stripe::Tokens for each seller
-        items = charge.order_items.group_by { |oi| oi.seller }
-        results = {}
-
-        # We do all these Tokens first, so if one throws an exception no charges are made
-        items.each do |seller, _|
-          seller.token = ::Stripe::Token.create({customer: buyer.stripe_customer.id}, seller.stripe_connect_access_token)
-        end
-
-        # Make one charge per seller, for all his order_items
-        items.each do |seller, order_items|
-          amount = order_items.map { |oi| oi.total }.sum
-          description = "Charge for Order ##{charge.order.to_param} with OrderItems ##{order_items.map(&:id).join(', #')}"
-          application_fee = order_items.sum(&:stripe_connect_application_fee)
-
-          results[seller.id] = JSON.parse(::Stripe::Charge.create(
-            {
-              amount: amount,
-              currency: EffectiveOrders.stripe[:currency],
-              card: seller.token.id,
-              description: description,
-              application_fee: application_fee
-            },
-            seller.stripe_connect_access_token
-          ).to_json)
-        end
-
-        results
-      end
-
       # StrongParameters
       def stripe_charge_params
         params.require(:effective_providers_stripe_charge).permit(:stripe_token, :effective_order_id)

data/app/datatables/effective_customers_datatable.rb

@@ -4,15 +4,11 @@ class EffectiveCustomersDatatable < Effective::Datatable
     col :id, visible: false
     #col 'user.email'
 
-    if EffectiveOrders.stripe_enabled
+    if EffectiveOrders.stripe?
       col :stripe_customer_id
       col :active_card
     end
 
-    if EffectiveOrders.stripe_connect_enabled
-      col :stripe_connect_access_token
-    end
-
     actions_col do |customer|
       link_to('Manage', "https://dashboard.stripe.com/#{'test/' if Rails.env.development?}customers/#{customer.stripe_customer_id}")
     end

data/app/datatables/effective_order_items_datatable.rb

@@ -27,14 +27,14 @@ class EffectiveOrderItemsDatatable < Effective::Datatable
       end
     end
 
-    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
+    # if EffectiveOrders.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 :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'
+    col :state, sql_column: 'orders.state', search: { collection: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order_item|
+      order_item[:state] || 'abandoned'
     end
 
     col :title do |order_item|
@@ -56,7 +56,7 @@ class EffectiveOrderItemsDatatable < Effective::Datatable
       .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)
+    if EffectiveOrders.billing_address && defined?(EffectiveAddresses)
       addresses_tbl = EffectiveAddresses.addresses_table_name
 
       collection = collection
@@ -83,8 +83,8 @@ class EffectiveOrderItemsDatatable < Effective::Datatable
   # 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] == 'state' && search_term == 'abandoned'
+  #     collection.where("#{EffectiveOrders.orders_table_name.to_s}.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'

data/app/datatables/effective_orders_datatable.rb

@@ -16,57 +16,45 @@ class EffectiveOrdersDatatable < Effective::Datatable
   end
 
   filters do
-    if admin_namespace?
-      filter :start_date, nil, as: :effective_date_picker
-      filter :end_date, nil, as: :effective_date_picker
-    end
+    scope :purchased, default: true
+    scope :not_purchased
+    scope :all
   end
 
   datatable do
-    order :created_at, :desc
+    order :id
 
     bulk_actions_col
 
-    col :purchased_at
+    col :created_at, visible: false
+    col :updated_at, visible: false
+    col :id, visible: false
 
-    if EffectiveOrders.obfuscate_order_ids
-      col(:id, sort: false) do |order|
-        obfuscated_id = order.to_param
-        link_to(obfuscated_id, (admin_namespace? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
-      end.search do |collection, term|
-        collection.where(id: Effective::Order.deobfuscate(term))
-      end
-    else
-      col :id
+    col :purchased_at do |order|
+      order.purchased_at&.strftime('%F %H:%M') || 'not purchased'
     end
 
     if attributes[:user_id].blank?
-      col :user, label: 'Buyer', search: :string, sort: :email do |order|
+      col :user
+
+      col :email, label: 'Email', visible: false, 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
 
-      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
+      col :billing_name, visible: false
     end
 
-    if EffectiveOrders.require_billing_address
-      col :billing_address
+    if EffectiveOrders.billing_address
+      col :billing_address, visible: false
     end
 
-    if EffectiveOrders.require_shipping_address
-      col :shipping_address
+    if EffectiveOrders.shipping_address
+      col :shipping_address, visible: false
     end
 
-    col :purchase_state, label: 'State', search: { collection: EffectiveOrders::PURCHASE_STATES.invert, value: 'purchased' } do |order|
-      EffectiveOrders::PURCHASE_STATES[order.purchase_state]
-    end
+    # col :state, label: 'State', search: { collection: EffectiveOrders::STATES.invert } do |order|
+    #   EffectiveOrders::STATES[order.state]
+    # end
 
     col :order_items, search: { as: :string }
 
@@ -79,16 +67,13 @@ class EffectiveOrdersDatatable < Effective::Datatable
 
     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 :payment_provider, label: 'Provider', visible: false, search: { collection: EffectiveOrders.payment_providers }
+    col :payment_card, label: 'Card', visible: false
 
-    col :note, visible: false
+    col :note, visible: EffectiveOrders.collect_note
     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
 
     aggregate :total
@@ -101,14 +86,6 @@ class EffectiveOrdersDatatable < Effective::Datatable
       scope = EffectiveOrders.orders_collection_scope.call(scope)
     end
 
-    if filters[:start_date].present?
-      scope = scope.where('created_at > ?', Time.zone.parse(filters[:start_date]).beginning_of_day)
-    end
-
-    if filters[:end_date].present?
-      scope = scope.where('created_at < ?', Time.zone.parse(filters[:end_date]).end_of_day)
-    end
-
     attributes[:user_id].present? ? scope.where(user_id: attributes[:user_id]) : scope
   end
 

data/app/helpers/effective_carts_helper.rb

@@ -47,14 +47,7 @@ module EffectiveCartsHelper
   def link_to_add_to_cart(purchasable, opts = {})
     raise 'expecting an acts_as_purchasable object' unless purchasable.kind_of?(ActsAsPurchasable)
 
-    options = {
-      label: 'Add to Cart',
-      class: 'btn btn-primary',
-      rel: :nofollow,
-      data: {
-        disable_with: 'Adding...'
-      }
-    }.merge(opts)
+    options = { label: 'Add to Cart', class: 'btn btn-primary', rel: :nofollow }.merge(opts)
 
     label = options.delete(:label)
     options[:class] = ((options[:class] || '') + ' btn-add-to-cart')
@@ -69,10 +62,7 @@ module EffectiveCartsHelper
       label: 'Remove',
       class: 'btn btn-primary',
       rel: :nofollow,
-      data: {
-        confirm: 'Are you sure? This cannot be undone!',
-        disable_with: 'Removing...'
-      },
+      data: { confirm: 'Are you sure? This cannot be undone!' },
       method: :delete
     }.merge(opts)
 
@@ -87,10 +77,7 @@ module EffectiveCartsHelper
       label: 'Empty Cart',
       class: 'btn btn-danger',
       rel: :nofollow,
-      data: {
-        confirm: 'This will clear your entire cart.  Are you sure?',
-        disable_with: 'Emptying...'
-      },
+      data: { confirm: 'This will clear your entire cart. Are you sure?' },
       method: :delete
     }.merge(opts)
 
@@ -101,14 +88,7 @@ module EffectiveCartsHelper
   end
 
   def link_to_checkout(opts = {})
-    options = {
-      label: 'Checkout',
-      class: 'btn btn-primary',
-      rel: :nofollow,
-      data: {
-        disable_with: 'Continuing...'
-      },
-    }.merge(opts)
+    options = { label: 'Checkout', class: 'btn btn-primary', rel: :nofollow }.merge(opts)
 
     order = options.delete(:order)
     label = options.delete(:label)
@@ -127,7 +107,7 @@ module EffectiveCartsHelper
   end
 
   def render_purchasables(*purchasables)
-    render(partial: 'effective/orders/order_items', locals: { order: Effective::Order.new(items: purchasables) })
+    render(partial: 'effective/orders/order_items', locals: { order: Effective::Order.new(purchasables) })
   end
 
 end

data/app/helpers/effective_orders_helper.rb

@@ -36,22 +36,22 @@ module EffectiveOrdersHelper
     return 'Checkout' if (EffectiveOrders.single_payment_processor? && ![:pretend, :mark_as_paid, :free, :refund].include?(processor))
 
     case processor
-    when :mark_as_paid
-      'Mark as paid'
+    when :cheque
+      'Pay by cheque'
     when :free
       'Checkout free'
-    when :refund
-      'Complete refund'
-    when :moneris, :stripe, :ccbill
+    when :mark_as_paid
+      'Mark as paid'
+    when :moneris
       'Checkout with credit card'
     when :paypal
       'Checkout with PayPal'
     when :pretend
-      EffectiveOrders.allow_pretend_purchase_in_production ? 'Purchase Order' : 'Purchase Order (development only)'
-    when :cheque
-      'Pay by cheque'
-    when :app_checkout
-      EffectiveOrders.app_checkout[:checkout_label].presence || 'Checkout'
+      EffectiveOrders.pretend_purchase_in_production_enabled ? 'Purchase Order' : 'Purchase Order (development only)'
+    when :refund
+      'Complete refund'
+    when :stripe
+      'Checkout with credit card'
     else
       'Checkout'
     end
@@ -63,25 +63,8 @@ module EffectiveOrdersHelper
   end
 
   def order_payment_to_html(order)
-    payment = order.payment
-
-    if order.purchased?(:stripe_connect) && order.payment.kind_of?(Hash)
-      payment = Hash[
-        order.payment.map do |seller_id, v|
-          if (user = Effective::Customer.find(seller_id).try(:user))
-            [link_to(user, admin_user_path(user)), order.payment[seller_id]]
-          else
-            [seller_id, order.payment[seller_id]]
-          end
-        end
-      ]
-    end
-
     content_tag(:pre) do
-      raw JSON.pretty_generate(payment).html_safe
-        .gsub('\"', '')
-        .gsub("[\n\n    ]", '[]')
-        .gsub("{\n    }", '{}')
+      raw JSON.pretty_generate(order.payment).html_safe.gsub('\"', '').gsub("[\n\n    ]", '[]').gsub("{\n    }", '{}')
     end
   end
 
@@ -89,28 +72,28 @@ module EffectiveOrdersHelper
     render(partial: 'effective/orders/order', locals: { order: order })
   end
 
-  def render_checkout_step1(order, namespace: nil, purchased_url: nil, declined_url: nil)
+  def render_checkout(order, namespace: nil, purchased_url: nil, declined_url: nil)
     raise 'unable to checkout an order without a user' unless order && order.user
 
     locals = { order: order, purchased_url: purchased_url, declined_url: declined_url, namespace: namespace }
 
-    render partial: 'effective/orders/checkout_step1', locals: locals
+    if order.purchased?
+      render(partial: 'effective/orders/order', locals: locals)
+    elsif order.confirmed? && order.errors.blank?
+      render(partial: 'effective/orders/checkout_step2', locals: locals)
+    else
+      render(partial: 'effective/orders/checkout_step1', locals: locals)
+    end
   end
-  alias_method :render_checkout, :render_checkout_step1
-
-  def render_checkout_step2(order, namespace: nil, purchased_url: nil, declined_url: nil)
-    raise 'unable to checkout an order without a user' unless order && order.user
-
-    purchased_url ||= session["effective_orders_#{order.id}_purchased_url"]
-    declined_url ||= session["effective_orders_#{order.id}_declined_url"]
 
+  def render_checkout_step1(order, namespace: nil, purchased_url: nil, declined_url: nil)
     locals = { order: order, purchased_url: purchased_url, declined_url: declined_url, namespace: namespace }
+    render(partial: 'effective/orders/checkout_step1', locals: locals)
+  end
 
-    if order.new_record? || !order.valid?
-      render(partial: 'effective/orders/checkout_step1', locals: locals)
-    else
-      render(partial: 'effective/orders/checkout_step2', locals: locals)
-    end
+  def render_checkout_step2(order, namespace: nil, purchased_url: nil, declined_url: nil)
+    locals = { order: order, purchased_url: purchased_url, declined_url: declined_url, namespace: namespace }
+    render(partial: 'effective/orders/checkout_step2', locals: locals)
   end
 
   def checkout_step1_form_url(order, namespace = nil)
@@ -124,21 +107,6 @@ module EffectiveOrdersHelper
     end
   end
 
-  def link_to_my_purchases(opts = {})
-    options = {
-      label: 'My Purchases',
-      class: 'btn btn-default',
-      rel: :nofollow
-    }.merge(opts)
-
-    label = options.delete(:label)
-    options[:class] = ((options[:class] || '') + ' btn-my-purchases')
-
-    link_to(label, effective_orders.my_purchases_orders_path, options)
-  end
-  alias_method :link_to_order_history, :link_to_my_purchases
-
-
   def render_orders(obj, opts = {})
     orders = Array(obj.kind_of?(User) ? Effective::Order.purchased_by(obj) : obj)
 
@@ -149,10 +117,6 @@ module EffectiveOrdersHelper
     render(partial: 'effective/orders/orders_table', locals: { orders: orders }.merge(opts))
   end
 
-  alias_method :render_purchases, :render_orders
-  alias_method :render_my_purchases, :render_orders
-  alias_method :render_order_history, :render_orders
-
   def payment_card_label(card)
     card = card.to_s.downcase.gsub(' ', '').strip
 
@@ -172,4 +136,8 @@ module EffectiveOrdersHelper
     end
   end
 
+  def checkout_icon_to(path, options = {})
+    icon_to('shopping-cart', path, { title: 'Checkout' }.merge(options))
+  end
+
 end