effective_orders 1.8.1 → 2.0.0

data/app/assets/javascripts/effective_orders.js

@@ -1,2 +1,4 @@
+//= require effective_addresses
+
 //= require_tree ./effective_orders
 

data/app/assets/javascripts/effective_orders/{stripe_charges.js.coffee → providers/stripe_charges.js.coffee}

@@ -8,7 +8,7 @@ stripeCheckoutHandler = (key, form) ->
 
         alert("An error ocurred when contacting Stripe.  Your card has not been charged.  Please refresh the page and try again. #{token.error.message}")
       else
-        form.find('input#effective_stripe_charge_token').val('' + token['id'])
+        form.find('input#effective_providers_stripe_charge_token').val('' + token['id'])
 
         form.find("input[type='submit']").prop('disabled', true)
         $('input[data-disable-with]').each -> try $.rails.disableFormElement($(this))

data/app/assets/javascripts/effective_orders/{stripe_subscriptions.js.coffee → providers/stripe_subscriptions.js.coffee}

@@ -7,7 +7,7 @@ stripeCheckoutHandler = (key, form) ->
         alert("An error ocurred when contacting Stripe.  Your card has not been charged.  Please refresh the page and try again. #{token.error.message}")
       else
         form.find("input[type='submit']").prop('disabled', true)
-        form.find('input#effective_stripe_subscription_token').val('' + token['id'])
+        form.find('input#effective_providers_stripe_subscription_token').val('' + token['id'])
         form.submit()
 
 $(document).on 'click', "#effective-orders-new-subscription-form form input[type='submit']", (event) ->

data/app/assets/stylesheets/effective_orders/_order.scss

@@ -1,7 +1,6 @@
 .effective-order {
   table {
     clear: both;
-    width: 600px;
     margin-bottom: 25px;
 
     tfoot {
@@ -42,8 +41,15 @@
   }
 }
 
+form.new_effective_order {
+  .checkbox { margin-top: 30px; }
+  .remove-nested-fields { margin-top: 30px; }
+  a.remove_fields.dynamic { float: right; }
+}
+
 @media print {
+  .effective-orders-page-title { display: none; }
+  .effective-orders-page-content { display: none; }
+  .effective-order-actions { display: none; }
   .effective-order-purchase-actions { display: none; }
-  .print-button { display: none; }
-  .resend-receipt-button { display: none; }
 }

data/app/controllers/admin/orders_controller.rb

@@ -8,15 +8,99 @@ module Admin
       @datatable = Effective::Datatables::Orders.new() if defined?(EffectiveDatatables)
       @page_title = 'Orders'
 
-      EffectiveOrders.authorized?(self, :admin, :effective_orders)
-      EffectiveOrders.authorized?(self, :index, Effective::Order)
+      authorize_effective_order!
     end
 
     def show
       @order = Effective::Order.find(params[:id])
       @page_title = "Order ##{@order.to_param}"
 
-      EffectiveOrders.authorized?(self, :show, @order)
+      authorize_effective_order!
+    end
+
+    def new
+      @order = Effective::Order.new
+      @page_title = 'New Order'
+
+      authorize_effective_order!
+    end
+
+    def create
+      @user = User.find_by_id(order_params[:user_id])
+      @order = Effective::Order.new(user: @user)
+      @order.send_payment_request_to_buyer = order_params[:send_payment_request_to_buyer]
+
+      authorize_effective_order!
+
+      if order_params[:order_items_attributes].present?
+        order_params[:order_items_attributes].each do |_, item_attrs|
+          purchasable = Effective::Product.new(item_attrs[:purchasable_attributes])
+          @order.add(purchasable, quantity: item_attrs[:quantity])
+        end
+      end
+
+      if @order.create_as_pending
+        path_for_redirect = params[:commit] == 'Save and Add New' ? effective_orders.new_admin_order_path : effective_orders.admin_order_path(@order)
+        message = 'Successfully created order'
+        message << ". #{@order.user.email} has been sent a request for payment." if @order.send_payment_request_to_buyer?
+        flash[:success] = message
+        redirect_to path_for_redirect
+      else
+        @page_title = 'New Order'
+        flash.now[:danger] = 'Unable to create order'
+        render :new
+      end
+    end
+
+    def mark_as_paid
+      @order = Effective::Order.find(params[:id])
+      authorize_effective_order!
+
+      purchased = @order.purchase!(
+        details: 'Marked as paid by admin',
+        provider: 'admin',
+        card: 'none',
+        email: EffectiveOrders.mailer[:send_order_receipts_when_marked_paid_by_admin],
+        skip_buyer_validations: true  # This will allow a declined order to be marked purchased
+      )
+
+      if purchased
+        flash[:success] = 'Order marked as paid successfully'
+        redirect_to effective_orders.admin_order_path(@order)
+      else
+        flash[:danger] = 'Unable to mark order as paid'
+        request.referrer ? (redirect_to :back) : (redirect_to effective_orders.admin_orders_path)
+      end
+    end
+
+    def send_payment_request
+      @order = Effective::Order.find(params[:id])
+      authorize_effective_order!
+
+      if @order.send_payment_request_to_buyer!
+        flash[:success] = "Successfully sent payment request to #{@order.user.email}"
+      else
+        flash[:danger] = 'Unable to send payment request'
+      end
+
+      request.referrer ? (redirect_to :back) : (redirect_to effective_orders.admin_order_path(@order))
+    end
+
+    private
+
+    def order_params
+      params.require(:effective_order).permit(:user_id, :send_payment_request_to_buyer,
+        order_items_attributes: [
+          :quantity, :_destroy, purchasable_attributes: [
+            :title, :price, :tax_exempt
+          ]
+        ]
+      )
+    end
+
+    def authorize_effective_order!
+      EffectiveOrders.authorized?(self, :admin, :effective_orders)
+      EffectiveOrders.authorized?(self, action_name.to_sym, @order || Effective::Order)
     end
 
   end

data/app/controllers/concerns/acts_as_active_admin_controller.rb

@@ -27,9 +27,10 @@ module ActsAsActiveAdminController
       self.send(:define_method, :resource_path) { |resource| effective_orders.cart_path }
     else
       self.send(:define_method, :resource_path) { |resource| public_send(resource_path, resource) }
+      self.send(:define_method, :edit_resource_path) { |resource| effective_orders.edit_order_path(resource) }
     end
 
-    helper_method :resource, :resource_path
+    helper_method :resource, :resource_path, :edit_resource_path
   end
 
   module ClassMethods

data/app/controllers/effective/carts_controller.rb

@@ -6,7 +6,9 @@ module Effective
 
     def show
       @cart = current_cart
-      @page_title ||= 'Shopping Cart'
+      @pending_orders = Effective::Order.pending.where(user: current_user) if current_user.present?
+
+      @page_title ||= 'My Cart'
       EffectiveOrders.authorized?(self, :show, @cart)
     end
 
@@ -32,7 +34,7 @@ module Effective
       begin
         raise "Please select a valid #{add_to_cart_params[:purchasable_type] || 'item' }." unless @purchasable
 
-        current_cart.add_to_cart(@purchasable, [add_to_cart_params[:quantity].to_i, 1].max)
+        current_cart.add_to_cart(@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.'

data/app/controllers/effective/orders_controller.rb

@@ -2,20 +2,28 @@ module Effective
   class OrdersController < ApplicationController
     include EffectiveCartsHelper
 
+    include Providers::Cheque if EffectiveOrders.cheque_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?
+
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:orders] : EffectiveOrders.layout)
 
-    before_filter :authenticate_user!, :except => [:paypal_postback]
-    before_filter :set_page_title
+    if defined?(Devise)
+      before_filter :authenticate_user!, except: [:paypal_postback, :ccbill_postback]
+    end
+
+    before_filter :set_page_title, except: [:show]
 
     # This is the entry point for the "Checkout" buttons
     def new
-      @order ||= Order.new(current_cart, current_user)
+      @order ||= Effective::Order.new(current_cart, user: current_user)
 
       EffectiveOrders.authorized?(self, :new, @order)
 
@@ -25,16 +33,45 @@ module Effective
 
       if @order.errors[:order_items].present?
         flash[:danger] = @order.errors[:order_items].first
-        redirect_to effective_orders.cart_path
+        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))
-        redirect_to effective_orders.cart_path
+        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
+    end
+
+    def edit
+      @order ||= Effective::Order.find(params[:id])
+
+      EffectiveOrders.authorized?(self, :edit, @order)
+
+      render :checkout_step1
     end
 
     def create
-      @order ||= Order.new(current_cart, current_user)
+      @order ||= Effective::Order.new(current_cart, user: current_user)
+      save_order_and_redirect_to_step2
+    end
+
+    # If there is an existing order, it will be posted to the /update action, instead of /create
+    def update
+      @order ||= Effective::Order.find(params[:id])
+      save_order_and_redirect_to_step2
+    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
 
       if EffectiveOrders.require_shipping_address
         if @order.shipping_address_same_as_billing? && @order.billing_address.present?
@@ -42,74 +79,100 @@ module Effective
         end
       end
 
-      EffectiveOrders.authorized?(self, :create, @order)
+      EffectiveOrders.authorized?(self, (@order.persisted? ? :update : :create), @order)
 
       Effective::Order.transaction do
         begin
-          if @order.save_billing_address? && @order.user.respond_to?(:billing_address) && @order.billing_address.try(:empty?) == false
+          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.try(:empty?) == false
+          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('automatic purchase of free order.')
+            order_purchased(details: 'automatic purchase of free order', provider: 'free', card: 'none')
           else
-            redirect_to(effective_orders.order_path(@order))
+            redirect_to(effective_orders.order_path(@order))  # This goes to checkout_step2
           end
 
-          return
+          return true
         rescue => e
           Rails.logger.info e.message
-          flash.now[:danger] = "An error has occurred: #{e.message}. Please try again."
+          flash.now[:danger] = "Unable to save order: #{@order.errors.full_messages.to_sentence}.  Please try again."
           raise ActiveRecord::Rollback
         end
       end
 
-      render :action => :new
+      # Fall back to checkout step 1
+      render :checkout_step1
     end
 
     def show
-      @order = Order.find(params[:id])
+      @order = Effective::Order.find(params[:id])
       EffectiveOrders.authorized?(self, :show, @order)
 
-      if @order.purchased? == false
-        @page_title = 'Checkout'
-        render(:checkout) and return
-      end
+      @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
+      )
+
+      render(:checkout_step2) if @order.purchased? == false && @order.user == current_user
     end
 
     def index
-      redirect_to effective_orders.my_purchases_path
+      @orders = Effective::Order.purchased_by(current_user)
+
+      EffectiveOrders.authorized?(self, :index, Effective::Order.new(user: current_user))
+
+      render action: :my_purchases
     end
 
     # Basically an index page.
     # Purchases is an Order History page.  List of purchased orders
     def my_purchases
-      @orders = Order.purchased_by(current_user)
+      @orders = Effective::Order.purchased_by(current_user)
+
       EffectiveOrders.authorized?(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 = OrderItem.sold_by(current_user)
+      @order_items = Effective::OrderItem.sold_by(current_user)
       EffectiveOrders.authorized?(self, :index, Effective::Order.new(user: current_user))
     end
 
     # Thank you for Purchasing this Order.  This is where a successfully purchased order ends up
     def purchased # Thank You!
-      @order = Order.find(params[:id])
+      @order = if params[:id].present?
+        Effective::Order.find(params[:id])
+      elsif current_user.present?
+        Effective::Order.purchased_by(current_user).first
+      end
+
+      if @order.blank?
+        redirect_to(effective_orders.my_purchases_path) and return
+      end
+
       EffectiveOrders.authorized?(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!
-      @order = Order.find(params[:id])
+      @order = Effective::Order.find(params[:id])
       EffectiveOrders.authorized?(self, :show, @order)
+
+      redirect_to(effective_orders.order_path(@order)) unless @order.declined?
     end
 
     def resend_buyer_receipt
@@ -117,34 +180,21 @@ module Effective
       EffectiveOrders.authorized?(self, :show, @order)
 
       if @order.send_order_receipt_to_buyer!
-        flash[:success] = "Successfully resent order receipt to #{@order.user.email}"
+        flash[:success] = "Successfully sent receipt to #{@order.user.email}"
       else
-        flash[:danger] = "Unable to send order receipt."
-      end
-
-      redirect_to(:back) rescue effective_orders.order_path(@order)
-    end
-
-    def pretend_purchase
-      @order = Order.find(params[:id])
-      EffectiveOrders.authorized?(self, :update, @order)
-
-      if (Rails.env.production? == false && EffectiveOrders.allow_pretend_purchase_in_development)
-        order_purchased('for pretend', params[:purchased_redirect_url], params[:declined_redirect_url])
-      end
-
-      if (Rails.env.production? == true && EffectiveOrders.allow_pretend_purchase_in_production)
-        order_purchased('for pretend', params[:purchased_redirect_url], params[:declined_redirect_url])
+        flash[:danger] = "Unable to send receipt."
       end
 
+      redirect_to(request.referer.present? ? :back : effective_orders.order_path(@order))
     end
 
     protected
 
-    def order_purchased(details = nil, redirect_url = nil, declined_redirect_url = nil)
+    def order_purchased(details: 'none', provider:, card: 'none', redirect_url: nil, declined_redirect_url: nil)
       begin
-        @order.purchase!(details)
-        Cart.where(user_id: @order.user_id).try(:destroy_all) # current_cart won't work for provider post backs here
+        @order.purchase!(details: details, provider: provider, card: card)
+
+        Effective::Cart.where(user_id: @order.user_id).try(:destroy_all) # current_cart won't work for provider post backs here
 
         if EffectiveOrders.mailer[:send_order_receipt_to_buyer]
           flash[:success] = "Payment successful! Please check your email for a receipt."
@@ -155,19 +205,16 @@ module Effective
         redirect_to (redirect_url.presence || effective_orders.order_purchased_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_redirect_url.presence || effective_orders.cart_path).gsub(':id', @order.to_param.to_s)
+        redirect_to(declined_redirect_url.presence || effective_orders.cart_path).gsub(':id', @order.to_param.to_s)
       end
     end
 
-    # options:
-    # flash: What flash message should be displayed
-    def order_declined(details = nil, redirect_url = nil, options = {})
-      flash_msg = options.fetch(:flash, "Payment was unsuccessful. Your credit card was declined by the payment processor. Please try again.")
+    def order_declined(details: 'none', provider:, card: 'none', redirect_url: nil, message: nil)
+      @order.decline!(details: details, provider: provider, card: card) rescue nil
 
-      @order.decline!(details) rescue nil
-      flash[:danger] = flash_msg
+      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)
+      redirect_to(redirect_url.presence || effective_orders.order_declined_path(@order)).gsub(':id', @order.id.to_s)
     end
 
     private
@@ -175,13 +222,7 @@ module Effective
     # StrongParameters
     def order_params
       begin
-        params.require(:effective_order).permit(
-          :save_billing_address, :save_shipping_address, :shipping_address_same_as_billing,
-          :billing_address => [:full_name, :address1, :address2, :city, :country_code, :state_code, :postal_code],
-          :shipping_address => [:full_name, :address1, :address2, :city, :country_code, :state_code, :postal_code],
-          :user_attributes => (EffectiveOrders.collect_user_fields || []),
-          :order_items_attributes => [:stripe_coupon_id, :class, :id]
-        )
+        params.require(:effective_order).permit(EffectiveOrders.permitted_params)
       rescue => e
         params[:effective_order] || {}
       end
@@ -189,11 +230,11 @@ module Effective
 
     def set_page_title
       @page_title ||= case params[:action]
+        when 'index'        ; 'Order History'
         when 'my_purchases' ; 'Order History'
         when 'my_sales'     ; 'Sales History'
         when 'purchased'    ; 'Thank You'
         when 'declined'     ; 'Payment Declined'
-        when 'show'         ; 'Order Receipt'
         else 'Checkout'
       end
     end