effective_orders 1.8.1 → 2.0.0

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

@@ -3,17 +3,25 @@ module Effective
     module AppCheckout
       extend ActiveSupport::Concern
 
+      included do
+        if defined?(CanCan)
+          skip_authorization_check only: [:app_checkout]
+        end
+      end
+
       def app_checkout
         @order = Order.find(params[:id])
         checkout = EffectiveOrders.app_checkout[:service].call(order: @order)
         if checkout.success?
-          order_purchased(payment_details(checkout))
+          order_purchased(details: payment_details(checkout), provider: 'app_checkout', card: 'none')
         else
           flash = EffectiveOrders.app_checkout[:declined_flash]
-          order_declined(payment_details(checkout), nil, flash: flash)
+          order_declined(details: payment_details(checkout), message: flash, provider: 'app_checkout', card: 'none')
         end
       end
 
+      private
+
       def payment_details(checkout)
         default = 'App Checkout'
         if checkout.respond_to?(:payment_details)

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

@@ -0,0 +1,34 @@
+module Effective
+  module Providers
+    module Ccbill
+      extend ActiveSupport::Concern
+
+      included do
+        skip_before_filter :verify_authenticity_token, only: [:ccbill_postback]
+
+        if defined?(CanCan)
+          skip_authorization_check only: [:ccbill_postback]
+        end
+      end
+
+      def ccbill_postback
+        postback = Effective::Providers::CcbillPostback.new(params)
+        @order ||= Effective::Order.find(postback.order_id)
+
+        if @order.present? && postback.verified?
+          if @order.purchased?
+            order_purchased(details: postback.order_details, provider: 'ccbill')
+          elsif postback.approval? && postback.matches?(@order)
+            order_purchased(details: postback.order_details, provider: 'ccbill')
+          else
+            order_declined(details: postback.order_details, provider: 'ccbill')
+          end
+        end
+
+        head(:ok)
+      end
+    end
+
+  end
+end
+

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

@@ -0,0 +1,30 @@
+module Effective
+  module Providers
+    module Cheque
+      extend ActiveSupport::Concern
+
+      def pay_by_cheque
+        @order ||= Order.find(params[:id])
+
+        @order.purchase_state = EffectiveOrders::PENDING
+        @order.payment_provider = 'cheque'
+
+        EffectiveOrders.authorized?(self, :update, @order)
+
+        @page_title = 'Payment Required'
+
+        if @order.save
+          @order.send_pending_order_invoice_to_buyer!
+          current_cart.try(:destroy)
+          flash.now[:success] = 'Successfully indicated order will be payed by cheque.'
+        else
+          flash[:danger] = "Unable to save your order: #{@order.errors.full_messages.to_sentence}. Please try again."
+          redirect_to effective_orders.order_path(@order)
+          return
+        end
+
+        render 'effective/orders/cheque/pay_by_cheque'
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Effective
       extend ActiveSupport::Concern
 
       included do
-        prepend_before_filter :find_authenticity_token_from_moneris, :only => [:moneris_postback]
+        prepend_before_filter :find_authenticity_token_from_moneris, only: [:moneris_postback]
       end
 
       def moneris_postback
@@ -17,7 +17,7 @@ module Effective
         declined_redirect_url = params.delete(:rvar_declined_redirect_url)
 
         if @order.purchased?  # Fallback to a success condition of the Order is already purchased
-          order_purchased(params, purchased_redirect_url)
+          order_purchased(details: params, provider: 'moneris', card: params[:card], redirect_url: purchased_redirect_url)
           return
         end
 
@@ -27,19 +27,19 @@ module Effective
           response_code = verify_params[:response_code].to_i # Sometimes moneris sends us the string 'null'
 
           if response_code > 0 && response_code < 50  # Less than 50 means a successful validation
-            order_purchased(params.merge(verify_params), purchased_redirect_url)
+            order_purchased(details: params.merge(verify_params), provider: 'moneris', card: params[:card], redirect_url: purchased_redirect_url)
           else
-            order_declined(params.merge(verify_params), declined_redirect_url)
+            order_declined(details: params.merge(verify_params), provider: 'moneris', card: params[:card], redirect_url: declined_redirect_url)
           end
         else
-          order_declined(params, declined_redirect_url)
+          order_declined(details: params, provider: 'moneris', card: params[:card], redirect_url: declined_redirect_url)
         end
       end
 
       private
 
       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}
+        text.split("<br>").inject(Hash.new()) { |h, i| h[i.split(' ').first.to_sym] = i.split(' ').last ; h } rescue {response: text}
       end
 
       def send_moneris_verify_request(verify_key)
@@ -93,4 +93,4 @@ end
 # Sent to your server as a POST
 # Response URL:  http://ourwebsite.com/orders/moneris_postback
 
-# Displayed as key/value pairs on our server. ????
+# Displayed as key/value pairs on our server

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

@@ -5,20 +5,22 @@ module Effective
 
       included do
         skip_before_filter :verify_authenticity_token, :only => [:paypal_postback]
+
+        if defined?(CanCan)
+          skip_authorization_check only: [:paypal_postback]
+        end
       end
 
       def paypal_postback
         @order ||= Effective::Order.where(id: (params[:invoice].to_i rescue 0)).first
 
-        EffectiveOrders.authorized?(self, :update, @order)
-
         if @order.present?
           if @order.purchased?
-            order_purchased(params)
+            order_purchased(details: params, provider: 'paypal', card: params[:payment_type])
           elsif (params[:payment_status] == 'Completed' && params[:custom] == EffectiveOrders.paypal[:secret])
-            order_purchased(params)
+            order_purchased(details: params, provider: 'paypal', card: params[:payment_type])
           else
-            order_declined(params)
+            order_declined(details: params, provider: 'paypal', card: params[:payment_type])
           end
         end
 

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

@@ -0,0 +1,22 @@
+module Effective
+  module Providers
+    module Pretend
+      extend ActiveSupport::Concern
+
+      def pretend_purchase
+        @order ||= Order.find(params[:id])
+
+        EffectiveOrders.authorized?(self, :update, @order)
+
+        order_purchased(
+          details: 'for pretend',
+          provider: 'pretend',
+          card: 'none',
+          redirect_url: params[:purchased_redirect_url],
+          declined_redirect_url: params[:declined_redirect_url]
+        )
+      end
+
+    end
+  end
+end

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

@@ -3,21 +3,23 @@ module Effective
     module Stripe
       extend ActiveSupport::Concern
 
-      included do
-      end
-
       def stripe_charge
         @order ||= Effective::Order.find(stripe_charge_params[:effective_order_id])
-        @stripe_charge = Effective::StripeCharge.new(stripe_charge_params)
+        @stripe_charge = Effective::Providers::StripeCharge.new(stripe_charge_params)
         @stripe_charge.order = @order
 
         EffectiveOrders.authorized?(self, :update, @order)
 
         if @stripe_charge.valid? && (response = process_stripe_charge(@stripe_charge)) != false
-          order_purchased(response) # orders_controller#order_purchased
+          order_purchased(
+            details: response,
+            provider: (EffectiveOrders.stripe_connect_enabled ? 'stripe_connect' : 'stripe'),
+            card: (response['charge']['card']['brand'] rescue nil)
+          )
         else
-          flash[:danger] = @stripe_charge.errors.full_messages.join(',')
-          render 'checkout'
+          @page_title = 'Checkout'
+          flash.now[:danger] = @stripe_charge.errors.full_messages.to_sentence
+          render :checkout_step2
         end
       end
 
@@ -44,16 +46,16 @@ module Effective
       end
 
       def charge_with_stripe(charge, buyer)
-        results = {:subscriptions => {}, :charge => nil}
+        results = {subscriptions: {}, charge: nil}
 
         # Process subscriptions.
         charge.subscriptions.each do |subscription|
           next if subscription.stripe_plan_id.blank?
 
           stripe_subscription = if subscription.stripe_coupon_id.present?
-            buyer.stripe_customer.subscriptions.create({:plan => subscription.stripe_plan_id, :coupon => subscription.stripe_coupon_id})
+            buyer.stripe_customer.subscriptions.create({plan: subscription.stripe_plan_id, coupon: subscription.stripe_coupon_id})
           else
-            buyer.stripe_customer.subscriptions.create({:plan => subscription.stripe_plan.id})
+            buyer.stripe_customer.subscriptions.create({plan: subscription.stripe_plan.id})
           end
 
           subscription.stripe_subscription_id = stripe_subscription.id
@@ -63,15 +65,15 @@ module Effective
         end
 
         # Process regular order_items.
-        amount = (charge.order_items.collect(&:total).sum)  # A positive integer in cents representing how much to charge the card. The minimum amount is 50 cents.
+        amount = charge.order_items.map { |oi| oi.total }.sum # A positive integer in cents representing how much to charge the card. The minimum amount is 50 cents.
         description = "Charge for Order ##{charge.order.to_param}"
 
         if amount > 0
           results[:charge] = JSON.parse(::Stripe::Charge.create(
-            :amount => amount,
-            :currency => EffectiveOrders.stripe[:currency],
-            :customer => buyer.stripe_customer.id,
-            :description => description
+            amount: amount,
+            currency: EffectiveOrders.stripe[:currency],
+            customer: buyer.stripe_customer.id,
+            description: description
           ).to_json)
         end
 
@@ -85,22 +87,22 @@ module Effective
 
         # 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)
+          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.sum(&:total)
+          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
+              amount: amount,
+              currency: EffectiveOrders.stripe[:currency],
+              card: seller.token.id,
+              description: description,
+              application_fee: application_fee
             },
             seller.stripe_connect_access_token
           ).to_json)
@@ -112,9 +114,9 @@ module Effective
       # StrongParameters
       def stripe_charge_params
         begin
-          params.require(:effective_stripe_charge).permit(:token, :effective_order_id)
+          params.require(:effective_providers_stripe_charge).permit(:token, :effective_order_id)
         rescue => e
-          params[:effective_stripe_charge]
+          params[:effective_providers_stripe_charge]
         end
       end
 

data/app/controllers/effective/webhooks_controller.rb

@@ -68,7 +68,7 @@ module Effective
           # Now we have to purchase it
           @order = Effective::Order.new(subscription)
           @order.user = @customer.user
-          @order.purchase!("via Stripe webhook #{event.id}")
+          @order.purchase!(details: "Webhook #{event.id}", provider: 'stripe')
         end
 
       end

data/app/helpers/effective_carts_helper.rb

@@ -4,12 +4,12 @@ module EffectiveCartsHelper
       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|
+        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
+            session_cart = Effective::Cart.where('user_id IS NULL').where(id: session[:cart]).first
 
             if session_cart.present?
-              session_cart.cart_items.update_all(:cart_id => user_cart.id)
+              session_cart.cart_items.update_all(cart_id: user_cart.id)
               session_cart.destroy
               user_cart.reload
             end
@@ -18,7 +18,7 @@ module EffectiveCartsHelper
           end
         end
       elsif session[:cart].present?
-        Effective::Cart.where('user_id IS NULL').where(:id => session[:cart]).first_or_create
+        Effective::Cart.where('user_id IS NULL').where(id: session[:cart]).first_or_create
       else
         cart = Effective::Cart.create!
         session[:cart] = cart.id
@@ -28,73 +28,103 @@ module EffectiveCartsHelper
   end
 
   def link_to_current_cart(opts = {})
-    options = {:id => 'current_cart', :rel => :nofollow}.merge(opts)
+    options = {
+      label: 'My Cart',
+      id: 'current_cart',
+      rel: :nofollow,
+      class: 'btn btn-default'
+    }.merge(opts)
+
+    label = options.delete(:label)
+    options[:class] = ((options[:class] || '') + ' btn-current-cart')
 
-    label = options.delete(:label) || 'Cart'
     link_to (current_cart.size == 0 ? label : "#{label} (#{current_cart.size})"), effective_orders.cart_path, options
   end
 
   def link_to_add_to_cart(purchasable, opts = {})
-    raise ArgumentError.new('expecting an acts_as_purchasable object') unless purchasable.respond_to?(:is_effectively_purchasable?)
+    raise ArgumentError.new('expecting an acts_as_purchasable object') unless purchasable.kind_of?(ActsAsPurchasable)
 
-    options = {:class => 'btn', :rel => :nofollow, 'data-disable-with' => 'Adding...'}.merge(opts)
+    options = {
+      label: 'Add to Cart',
+      class: 'btn btn-primary',
+      rel: :nofollow,
+      data: {
+        disable_with: 'Adding...'
+      }
+    }.merge(opts)
+
+    label = options.delete(:label)
     options[:class] = ((options[:class] || '') + ' btn-add-to-cart')
 
-    link_to (options.delete(:label) || 'Add to Cart'), effective_orders.add_to_cart_path(:purchasable_type => purchasable.class.name, :purchasable_id => purchasable.id.to_i), options
+    link_to label, effective_orders.add_to_cart_path(purchasable_type: purchasable.class.name, purchasable_id: purchasable.id.to_i), options
   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)
 
     options = {
-      :rel => :nofollow,
-      :data => {
-        :confirm => 'Are you sure? This cannot be undone!',
-        :disable_with => 'Removing...'
+      label: 'Remove',
+      class: 'btn btn-primary',
+      rel: :nofollow,
+      data: {
+        confirm: 'Are you sure? This cannot be undone!',
+        disable_with: 'Removing...'
       },
-      :method => :delete
+      method: :delete
     }.merge(opts)
 
+    label = options.delete(:label)
     options[:class] = ((options[:class] || '') + ' btn-remove-from-cart')
 
-    link_to (options.delete(:label) || 'Remove'), effective_orders.remove_from_cart_path(cart_item), options
+    link_to(label, effective_orders.remove_from_cart_path(cart_item), options)
   end
 
   def link_to_empty_cart(opts = {})
     options = {
-      :rel => :nofollow,
-      :class => 'btn',
-      :data => {
-        :confirm => 'This will clear your entire cart.  Are you sure?  This cannot be undone!',
-        :disable_with => 'Emptying...'
+      label: 'Empty Cart',
+      class: 'btn btn-danger',
+      rel: :nofollow,
+      data: {
+        confirm: 'This will clear your entire cart.  Are you sure?',
+        disable_with: 'Emptying...'
       },
-      :method => :delete
+      method: :delete
     }.merge(opts)
 
-    options[:class] = ((options[:class] || '') + ' btn-empty-cart btn-danger')
+    label = options.delete(:label)
+    options[:class] = ((options[:class] || '') + ' btn-empty-cart')
 
-    link_to (options.delete(:label) || 'Empty Cart'), effective_orders.cart_path, options
+    link_to(label, effective_orders.cart_path, options)
   end
 
   def link_to_checkout(opts = {})
     options = {
-      :class => 'btn',
-      :rel => :nofollow,
-      :disable_with => 'Proceeding...'
+      label: 'Checkout',
+      class: 'btn btn-primary',
+      rel: :nofollow,
+      data: {
+        disable_with: 'Continuing...'
+      },
     }.merge(opts)
 
+    order = options.delete(:order)
+    label = options.delete(:label)
     options[:class] = ((options[:class] || '') + ' btn-checkout')
 
-    link_to (options.delete(:label) || 'Proceed to Checkout'), effective_orders.new_order_path, options
+    if order.present?
+      link_to(label, effective_orders.edit_order_path(order), options)
+    else
+      link_to(label, effective_orders.new_order_path, options)
+    end
   end
 
   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