effective_orders 2.2.4 → 3.0.0

data/app/controllers/effective/carts_controller.rb

@@ -9,13 +9,13 @@ module Effective
       @pending_orders = Effective::Order.pending.where(user: current_user) if current_user.present?
 
       @page_title ||= 'My Cart'
-      EffectiveOrders.authorized?(self, :show, @cart)
+      EffectiveOrders.authorize!(self, :show, @cart)
     end
 
     def destroy
       @cart = current_cart
 
-      EffectiveOrders.authorized?(self, :destroy, @cart)
+      EffectiveOrders.authorize!(self, :destroy, @cart)
 
       if @cart.destroy
         flash[:success] = 'Successfully emptied cart.'
@@ -23,18 +23,18 @@ module Effective
         flash[:danger] = 'Unable to destroy cart.'
       end
 
-      request.referrer ? (redirect_to :back) : (redirect_to effective_orders.cart_path)
+      redirect_back_or_to_cart
     end
 
     def add_to_cart
       @purchasable = (add_to_cart_params[:purchasable_type].constantize.find(add_to_cart_params[:purchasable_id].to_i) rescue nil)
 
-      EffectiveOrders.authorized?(self, :update, current_cart)
+      EffectiveOrders.authorize!(self, :update, current_cart)
 
       begin
         raise "Please select a valid #{add_to_cart_params[:purchasable_type] || 'item' }." unless @purchasable
 
-        current_cart.add_to_cart(@purchasable, quantity: [add_to_cart_params[:quantity].to_i, 1].max)
+        current_cart.add(@purchasable, quantity: [add_to_cart_params[:quantity].to_i, 1].max)
         flash[:success] = 'Successfully added item to cart.'
       rescue EffectiveOrders::SoldOutException
         flash[:warning] = 'This item is sold out.'
@@ -42,13 +42,13 @@ module Effective
         flash[:danger] = 'Unable to add item to cart: ' + e.message
       end
 
-      request.referrer ? (redirect_to :back) : (redirect_to effective_orders.cart_path)
+      redirect_back_or_to_cart
     end
 
     def remove_from_cart
       @cart_item = current_cart.cart_items.find(remove_from_cart_params[:id])
 
-      EffectiveOrders.authorized?(self, :update, current_cart)
+      EffectiveOrders.authorize!(self, :update, current_cart)
 
       if @cart_item.destroy
         flash[:success] = 'Successfully removed item from cart.'
@@ -56,7 +56,7 @@ module Effective
         flash[:danger] = 'Unable to remove item from cart.'
       end
 
-      request.referrer ? (redirect_to :back) : (redirect_to effective_orders.cart_path)
+      redirect_back_or_to_cart
     end
 
     private
@@ -69,5 +69,15 @@ module Effective
       params.permit(:id)
     end
 
+    def redirect_back_or_to_cart
+      if respond_to?(:redirect_back)
+        redirect_back(fallback_location: effective_orders.cart_path)
+      elsif request.referrer.present?
+        redirect_to(:back)
+      else
+        redirect_to(effective_orders.cart_path)
+      end
+    end
+
   end
 end

data/app/controllers/effective/concerns/purchase.rb

@@ -0,0 +1,39 @@
+module Effective
+  module Concerns
+    module Purchase
+      extend ActiveSupport::Concern
+
+      protected
+
+      def order_purchased(provider:, card: 'none', details: 'none', email: true, skip_buyer_validations: false, purchased_url: nil, declined_url: nil)
+        begin
+          @order.purchase!(provider: provider, card: card, details: details, email: email, skip_buyer_validations: skip_buyer_validations)
+
+          Effective::Cart.where(user_id: @order.user_id).destroy_all
+
+          if EffectiveOrders.mailer[:send_order_receipt_to_buyer] && email
+            flash[:success] = "Payment successful! A receipt has been sent to #{@order.user.email}"
+          elsif @order.free?
+            # Nothing
+          else
+            flash[:success] = 'Payment successful! An email receipt has not been sent.'
+          end
+
+          redirect_to (purchased_url.presence || effective_orders.purchased_order_path(':id')).gsub(':id', @order.to_param.to_s)
+        rescue => e
+          flash[:danger] = "An error occurred while processing your payment: #{e.message}. Please try again."
+          redirect_to(declined_url.presence || effective_orders.cart_path).gsub(':id', @order.to_param.to_s)
+        end
+      end
+
+      def order_declined(provider:, card: 'none', details: 'none', message: nil, declined_url: nil)
+        @order.decline!(provider: provider, card: card, details: details) rescue nil
+
+        flash[:danger] = message.presence || 'Payment was unsuccessful. Your credit card was declined by the payment processor. Please try again.'
+
+        redirect_to(declined_url.presence || effective_orders.declined_order_path(@order)).gsub(':id', @order.to_param.to_s)
+      end
+
+    end
+  end
+end

data/app/controllers/effective/customers_controller.rb

@@ -0,0 +1,43 @@
+module Effective
+  class CustomersController < ApplicationController
+    layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:customers] : EffectiveOrders.layout)
+
+    before_action :authenticate_user!
+
+    # Get here by visiting /customer/settings
+    def edit
+      @customer = Effective::Customer.where(user: current_user).first!
+      EffectiveOrders.authorize!(self, :edit, @customer)
+
+      @subscripter = Effective::Subscripter.new(customer: @customer, user: @customer.user)
+
+      @page_title ||= "Customer #{current_user.to_s}"
+    end
+
+    def update
+      @customer = Effective::Customer.where(user: current_user).first!
+      EffectiveOrders.authorize!(self, :update, @customer)
+
+      @subscripter = Effective::Subscripter.new(customer: @customer, user: @customer.user)
+      @subscripter.assign_attributes(subscripter_params)
+
+      @page_title ||= "Customer #{current_user.to_s}"
+
+      if (@subscripter.save! rescue false)
+        flash[:success] = "Successfully updated customer settings"
+        redirect_to(effective_orders.customer_settings_path)
+      else
+        flash.now[:danger] = "Unable to update customer settings: #{@subscripter.errors.full_messages.to_sentence}"
+        render :edit
+      end
+    end
+
+    private
+
+    # StrongParameters
+    def subscripter_params
+      params.require(:effective_subscripter).permit(:stripe_token)
+    end
+
+  end
+end

data/app/controllers/effective/orders_controller.rb

@@ -2,38 +2,31 @@ module Effective
   class OrdersController < ApplicationController
     include EffectiveCartsHelper
 
+    include Concerns::Purchase
+
+    include Providers::AppCheckout if EffectiveOrders.app_checkout_enabled
+    include Providers::Ccbill if EffectiveOrders.ccbill_enabled
     include Providers::Cheque if EffectiveOrders.cheque_enabled
+    include Providers::Free if EffectiveOrders.allow_free_orders
+    include Providers::MarkAsPaid if EffectiveOrders.mark_as_paid_enabled
     include Providers::Moneris if EffectiveOrders.moneris_enabled
     include Providers::Paypal if EffectiveOrders.paypal_enabled
-    include Providers::Stripe if EffectiveOrders.stripe_enabled
-    include Providers::StripeConnect if EffectiveOrders.stripe_connect_enabled
-    include Providers::Ccbill if EffectiveOrders.ccbill_enabled
-    include Providers::AppCheckout if EffectiveOrders.app_checkout_enabled
-
     include Providers::Pretend if EffectiveOrders.allow_pretend_purchase_in_development && !Rails.env.production?
     include Providers::Pretend if EffectiveOrders.allow_pretend_purchase_in_production && Rails.env.production?
+    include Providers::Refund if EffectiveOrders.allow_refunds
+    include Providers::Stripe if EffectiveOrders.stripe_enabled
+    include Providers::StripeConnect if EffectiveOrders.stripe_connect_enabled
 
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:orders] : EffectiveOrders.layout)
 
-    if defined?(Devise)
-      if respond_to?(:before_action)
-        before_action :authenticate_user!, except: [:paypal_postback, :ccbill_postback]
-      else
-        before_filter :authenticate_user!, except: [:paypal_postback, :ccbill_postback]
-      end
-    end
-
-    if respond_to?(:before_action)
-      before_action :set_page_title, except: [:show]
-    else
-      before_filter :set_page_title, except: [:show]
-    end
+    before_action :authenticate_user!, except: [:ccbill_postback, :free, :paypal_postback, :pretend]
+    before_action :set_page_title, except: [:show]
 
-    # This is the entry point for the "Checkout" buttons
+    # This is the entry point for any Checkout button
     def new
       @order ||= Effective::Order.new(current_cart, user: current_user)
 
-      EffectiveOrders.authorized?(self, :new, @order)
+      EffectiveOrders.authorize!(self, :new, @order)
 
       # We're only going to check for a subset of errors on this step,
       # with the idea that we don't want to create an Order object if the Order is totally invalid
@@ -44,116 +37,87 @@ module Effective
         redirect_to(effective_orders.cart_path)
         return
       elsif @order.errors[:total].present?
-        flash[:danger] = @order.errors[:total].first.gsub(EffectiveOrders.minimum_charge.to_i.to_s, view_context.price_to_currency(EffectiveOrders.minimum_charge.to_i))
+        flash[:danger] = @order.errors[:total].first
         redirect_to(effective_orders.cart_path)
         return
       end
 
       @order.errors.clear
-      @order.billing_address.try(:errors).try(:clear)
-      @order.shipping_address.try(:errors).try(:clear)
-
-      render :checkout_step1
+      @order.billing_address.errors.clear if @order.billing_address
+      @order.shipping_address.errors.clear if @order.shipping_address
     end
 
-    def edit
-      @order ||= Effective::Order.find(params[:id])
+    def create
+      @order ||= Effective::Order.new(current_cart, user: current_user)
+      EffectiveOrders.authorize!(self, :create, @order)
 
-      EffectiveOrders.authorized?(self, :edit, @order)
+      @order.assign_attributes(checkout_params) if params[:effective_order]
 
-      render :checkout_step1
-    end
+      Effective::Order.transaction do
+        begin
+          @order.save!
+          redirect_to(effective_orders.order_path(@order)) and return
+        rescue => e
+          raise ActiveRecord::Rollback
+        end
+      end
 
-    def create
-      @order ||= Effective::Order.new(current_cart, user: current_user)
-      save_order_and_redirect_to_step2
+      flash.now[:danger] = "Unable to proceed: #{@order.errors.full_messages.to_sentence}. Please try again."
+      render :new
     end
 
-    # If there is an existing order, it will be posted to the /update action, instead of /create
-    def update
+    def edit
       @order ||= Effective::Order.find(params[:id])
-      save_order_and_redirect_to_step2
+      EffectiveOrders.authorize!(self, :edit, @order)
     end
 
-    def save_order_and_redirect_to_step2
-      (redirect_to effective_orders.cart_path and return) if (@order.blank? || current_user.blank?)
-
-      @order.attributes = order_params
-      @order.user_id = current_user.id
-
-      EffectiveOrders.authorized?(self, (@order.persisted? ? :update : :create), @order)
+    def update
+      @order ||= Effective::Order.find(params[:id])
+      EffectiveOrders.authorize!(self, :update, @order)
 
-      @order.valid?  # This makes sure the correct shipping_address is copied from billing_address if shipping_address_same_as_billing
+      @order.assign_attributes(checkout_params)
 
       Effective::Order.transaction do
         begin
-          if @order.save_billing_address? && @order.user.respond_to?(:billing_address=) && @order.billing_address.present?
-            @order.user.billing_address = @order.billing_address
-          end
-
-          if @order.save_shipping_address? && @order.user.respond_to?(:shipping_address=) && @order.shipping_address.present?
-            @order.user.shipping_address = @order.shipping_address
-          end
-
           @order.save!
-
-          if @order.total == 0 && EffectiveOrders.allow_free_orders
-            order_purchased(details: 'automatic purchase of free order', provider: 'free', card: 'none')
-          else
-            redirect_to(effective_orders.order_path(@order))  # This goes to checkout_step2
-          end
-
-          return true
+          redirect_to(effective_orders.order_path(@order)) and return
         rescue => e
-          Rails.logger.info e.message
-          flash.now[:danger] = "Unable to save order: #{@order.errors.full_messages.to_sentence}.  Please try again."
           raise ActiveRecord::Rollback
         end
       end
 
-      # Fall back to checkout step 1
-      render :checkout_step1
+      flash.now[:danger] = "Unable to proceed: #{@order.errors.full_messages.to_sentence}. Please try again."
+      render :edit
     end
 
     def show
       @order = Effective::Order.find(params[:id])
-      EffectiveOrders.authorized?(self, :show, @order)
-
-      @page_title ||= (
-        if @order.purchased?
-          'Receipt'
-        elsif @order.user != current_user
-          @order.pending? ? "Pending Order ##{@order.to_param}" : "Order ##{@order.to_param}"
-        else
-          'Checkout'
-        end
-      )
+      EffectiveOrders.authorize!(self, :show, @order)
 
-      render(:checkout_step2) if @order.purchased? == false && @order.user == current_user
+      @page_title ||= ((@order.user == current_user && !@order.purchased?) ? 'Checkout' : @order.to_s)
     end
 
     def index
-      @orders = Effective::Order.purchased_by(current_user)
-      @pending_orders = Effective::Order.pending.where(user: current_user)
+      @orders = Effective::Order.deep.purchased_by(current_user)
+      @pending_orders = Effective::Order.deep.pending.where(user: current_user)
 
-      EffectiveOrders.authorized?(self, :index, Effective::Order.new(user: current_user))
+      EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
     end
 
     # Basically an index page.
     # Purchases is an Order History page.  List of purchased orders
     def my_purchases
-      @orders = Effective::Order.purchased_by(current_user)
-
-      EffectiveOrders.authorized?(self, :index, Effective::Order.new(user: current_user))
+      @orders = Effective::Order.deep.purchased_by(current_user)
+      EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
     end
 
     # Sales is a list of what products beign sold by me have been purchased
     def my_sales
-      @order_items = Effective::OrderItem.sold_by(current_user)
-      EffectiveOrders.authorized?(self, :index, Effective::Order.new(user: current_user))
+      @order_items = Effective::OrderItem.deep.sold_by(current_user)
+      EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
     end
 
-    # Thank you for Purchasing this Order.  This is where a successfully purchased order ends up
+    # Thank you for Purchasing this Order. This is where a successfully purchased order ends up
     def purchased # Thank You!
       @order = if params[:id].present?
         Effective::Order.find(params[:id])
@@ -162,73 +126,63 @@ module Effective
       end
 
       if @order.blank?
-        redirect_to(effective_orders.my_purchases_path) and return
+        redirect_to(effective_orders.my_purchases_orders_path) and return
       end
 
-      EffectiveOrders.authorized?(self, :show, @order)
+      EffectiveOrders.authorize!(self, :show, @order)
 
       redirect_to(effective_orders.order_path(@order)) unless @order.purchased?
     end
 
-    # An error has occurred, please try again
-    def declined # An error occurred!
+    def declined
       @order = Effective::Order.find(params[:id])
-      EffectiveOrders.authorized?(self, :show, @order)
+      EffectiveOrders.authorize!(self, :show, @order)
 
       redirect_to(effective_orders.order_path(@order)) unless @order.declined?
     end
 
-    def resend_buyer_receipt
+    def send_buyer_receipt
       @order = Effective::Order.find(params[:id])
-      EffectiveOrders.authorized?(self, :show, @order)
+      EffectiveOrders.authorize!(self, :show, @order)
 
       if @order.send_order_receipt_to_buyer!
-        flash[:success] = "Successfully sent receipt to #{@order.user.email}"
+        flash[:success] = "A receipt has been sent to #{@order.user.email}"
       else
         flash[:danger] = "Unable to send receipt."
       end
 
-      redirect_to(request.referer.present? ? :back : effective_orders.order_path(@order))
+      if respond_to?(:redirect_back)
+        redirect_back(fallback_location: effective_orders.order_path(@order))
+      elsif request.referrer.present?
+        redirect_to :back
+      else
+        redirect_to effective_orders.order_path(@order)
+      end
     end
 
-    protected
+    def bulk_send_buyer_receipt
+      @orders = Effective::Order.purchased.where(id: params[:ids])
 
-    def order_purchased(details: 'none', provider:, card: 'none', redirect_url: nil, declined_redirect_url: nil)
       begin
-        @order.purchase!(details: details, provider: provider, card: card)
+        EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
 
-        Effective::Cart.where(user_id: @order.user_id).try(:destroy_all) # current_cart won't work for provider post backs here
+        @orders.each do |order|
+          next unless (EffectiveOrders.authorize!(self, :show, order) rescue false)
 
-        if EffectiveOrders.mailer[:send_order_receipt_to_buyer]
-          flash[:success] = "Payment successful! Please check your email for a receipt."
-        else
-          flash[:success] = "Payment successful!"
+          order.send_order_receipt_to_buyer!
         end
 
-        redirect_to (redirect_url.presence || effective_orders.order_purchased_path(':id')).gsub(':id', @order.to_param.to_s)
+        render json: { status: 200, message: "Successfully sent #{@orders.length} receipt emails"}
       rescue => e
-        flash[:danger] = "An error occurred while processing your payment: #{e.message}.  Please try again."
-        redirect_to(declined_redirect_url.presence || effective_orders.cart_path).gsub(':id', @order.to_param.to_s)
+        render json: { status: 500, message: "Bulk send buyer receipt error: #{e.message}" }
       end
     end
 
-    def order_declined(details: 'none', provider:, card: 'none', redirect_url: nil, message: nil)
-      @order.decline!(details: details, provider: provider, card: card) rescue nil
-
-      flash[:danger] = message.presence || 'Payment was unsuccessful. Your credit card was declined by the payment processor. Please try again.'
-
-      redirect_to(redirect_url.presence || effective_orders.order_declined_path(@order)).gsub(':id', @order.id.to_s)
-    end
-
     private
 
     # StrongParameters
-    def order_params
-      begin
-        params.require(:effective_order).permit(EffectiveOrders.permitted_params)
-      rescue => e
-        params[:effective_order] || {}
-      end
+    def checkout_params
+      params.require(:effective_order).permit(EffectiveOrders.permitted_params)
     end
 
     def set_page_title