effective_orders 2.2.4 → 3.0.0

data/app/assets/javascripts/effective_orders/subscriptions.js.coffee

@@ -0,0 +1,73 @@
+stripeSubscriptionHandler = (key, form) ->
+  StripeCheckout.configure
+    key: key
+    closed: ->
+      form.find("input[type='submit']").removeAttr('disabled')
+      $('input[data-disable-with]').each -> try $.rails.enableFormElement($(this))
+    token: (token, args) ->
+      if token.error
+        form.find("input[type='submit']").removeAttr('disabled')
+        $('input[data-disable-with]').each -> try $.rails.enableFormElement($(this))
+
+        alert("An error ocurred when contacting Stripe. Your card has not been charged. Your subscription has not changed. Please refresh the page and try again. #{token.error.message}")
+      else
+        form.find("input[name$='[stripe_token]']").val('' + token['id'])
+
+        form.find("input[type='submit']").prop('disabled', true)
+        $('input[data-disable-with]').each -> try $.rails.disableFormElement($(this))
+        form.submit()
+
+$(document).on 'click', "input[type='submit'].effective-orders-subscripter-token-required", (event) ->
+  event.preventDefault()
+
+  $submit = $(event.currentTarget)
+  $form = $submit.closest('form')
+
+  # Disable the form
+  $submit.prop('disabled', true)
+  $('input[data-disable-with]').each -> try $.rails.disableFormElement($(this))
+
+  # Get the stripe data
+  $plans = $form.find('.effective-orders-stripe-plans').first()
+  selected_plan_id = $plans.find("input[name$='[subscripter][stripe_plan_id]']:checked").val()
+
+  stripe = $plans.data('stripe')
+  plan = stripe.plans.find (plan, _) => plan.id == selected_plan_id
+
+  stripeSubscriptionHandler(stripe.key, $form).open
+    image: stripe.image
+    name: stripe.name
+    description: plan.name
+    email: stripe.email
+    amount: plan.amount
+    panelLabel: "{{amount}}#{plan.occurrence} Go!"
+
+# When a plan is selected, toggle the selected-class on each plan.
+# Set the submit button's class if a customer token is required
+$(document).on 'change', "input[name$='[subscripter][stripe_plan_id]']", (event) ->
+  $plan = $(event.currentTarget)
+  return unless $plan.is(':checked')
+
+  $plans = $plan.closest('.effective-orders-stripe-plans').first()
+  selected_class = $plans.data('selected-class')
+  selected_plan_id = $plan.val()
+
+  $plans.find("input[name$='[subscripter][stripe_plan_id]']").each (_, item) =>
+    if $(item).is(':checked')
+      $(item).siblings('.panel').addClass(selected_class)
+    else
+      $(item).siblings('.panel').removeClass(selected_class)
+
+  plan = $plans.data('stripe').plans.find (plan, _) => plan.id == selected_plan_id
+  token_required = $plans.data('stripe').token_required
+
+  if (plan.amount || 0) > 0 && token_required
+    $plans.closest('form').find("input[type='submit']").addClass('effective-orders-subscripter-token-required')
+  else
+    $plans.closest('form').find("input[type='submit']").removeClass('effective-orders-subscripter-token-required')
+
+# When the 'Select' button is clicked, set the radio button input
+$(document).on 'click', '.effective-orders-stripe-plan .btn-select-plan', (event) ->
+  val = $(event.currentTarget).closest('.effective-orders-stripe-plan').find('input:radio').val()
+  $(event.currentTarget).closest('.effective-orders-stripe-plans').find('input:radio').val([val]).trigger('change')
+  false

data/app/assets/stylesheets/effective_orders.scss

@@ -1 +1,2 @@
-@import "effective_orders/order";
+@import 'effective_orders/order';
+@import 'effective_orders/subscriptions';

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

@@ -23,16 +23,15 @@
   }
 
   .price { text-align: right; }
+}
 
-  .effective-stripe-subscription {
-    input {
-      margin-top: 5px;
-      width: 30%;
-      min-width: 200px;
-    }
-  }
+// Print - Resend Receipt.  Ontop of order.
+.effective-order-actions {
+  text-align: right;
+  margin-bottom: 10px;
 }
 
+// Checkout buttons. Bottom of order.
 .effective-order-purchase-actions {
   text-align: right;
 
@@ -41,6 +40,10 @@
   }
 }
 
+.effective-order-admin-purchase-actions {
+  margin-top: 10px;
+}
+
 form.new_effective_order {
   .checkbox { margin-top: 30px; }
   .remove-nested-fields { margin-top: 30px; }
@@ -48,8 +51,13 @@ form.new_effective_order {
 }
 
 @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; }
+  .effective-order-admin-purchase-actions { display: none; }
+
+  .effective-heading { display: none; }
+  .effective-admin-heading { display: none; }
+  .effective-order-internal-note-form { display: none; }
 }

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

@@ -0,0 +1,14 @@
+// This is the radio button form input
+.effective-orders-stripe-plans {
+  input { display: none; }
+  label { width: 100%; padding-left: 0px; }
+  .radio + .radio { margin-top: 10px; }
+
+  .visible-when-selected { display: none; }
+  .visible-when-unselected { display: block; }
+
+  label > .selected {
+    .visible-when-selected { display: block; }
+    .visible-when-unselected { display: none; }
+  }
+}

data/app/controllers/admin/customers_controller.rb

@@ -1,20 +1,23 @@
 module Admin
   class CustomersController < ApplicationController
-    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
+    before_action :authenticate_user!
 
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_customers] : EffectiveOrders.layout)
 
     def index
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        @datatable = Effective::Datatables::Customers.new()
-      else
-        @datatable = EffectiveCustomersDatatable.new(self)
-      end
+      @datatable = EffectiveCustomersDatatable.new(self)
 
       @page_title = 'Customers'
 
-      EffectiveOrders.authorized?(self, :admin, :effective_orders)
-      EffectiveOrders.authorized?(self, :index, Effective::Customer)
+      EffectiveOrders.authorize!(self, :admin, :effective_orders)
+      EffectiveOrders.authorize!(self, :index, Effective::Customer)
+    end
+
+    def show
+      @customer = Effective::Customer.find(params[:id])
+
+      @page_title ||= @customer.to_s
+      EffectiveOrders.authorize!(self, :show, Effective::Customer)
     end
 
   end

data/app/controllers/admin/order_items_controller.rb

@@ -1,20 +1,16 @@
 module Admin
   class OrderItemsController < ApplicationController
-    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
+    before_action :authenticate_user!
 
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_orders] : EffectiveOrders.layout)
 
     def index
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        @datatable = Effective::Datatables::OrderItems.new()
-      else
-        @datatable = EffectiveOrderItemsDatatable.new(self)
-      end
+      @datatable = EffectiveOrderItemsDatatable.new(self)
 
       @page_title = 'Order Items'
 
-      EffectiveOrders.authorized?(self, :admin, :effective_orders)
-      EffectiveOrders.authorized?(self, :index, Effective::OrderItem)
+      EffectiveOrders.authorize!(self, :admin, :effective_orders)
+      EffectiveOrders.authorize!(self, :index, Effective::OrderItem)
     end
   end
 end

data/app/controllers/admin/orders_controller.rb

@@ -1,81 +1,132 @@
 module Admin
   class OrdersController < ApplicationController
-    respond_to?(:before_action) ? before_action(:authenticate_user!) : before_filter(:authenticate_user!) # Devise
+    before_action :authenticate_user!
 
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_orders] : EffectiveOrders.layout)
 
-    def index
-      if Gem::Version.new(EffectiveDatatables::VERSION) < Gem::Version.new('3.0')
-        @datatable = Effective::Datatables::Orders.new()
-      else
-        @datatable = EffectiveOrdersDatatable.new(self)
+    def new
+      @order = Effective::Order.new
+
+      if params[:user_id]
+        @order.user = User.where(id: params[:user_id]).first
       end
 
-      @page_title = 'Orders'
+      if params[:duplicate_id]
+        @duplicate = Effective::Order.deep.find(params[:duplicate_id])
+        EffectiveOrders.authorize!(self, :show, @duplicate)
+
+        @order.add(@duplicate)
+      end
+
+      @page_title = 'New Order'
+
+      raise 'please install cocoon gem to use this page' unless defined?(Cocoon)
 
       authorize_effective_order!
     end
 
-    # We use the show action as an edit screen too
-    def show
+    def create
+      @user = User.find_by_id(order_params[:user_id])
+      @order = Effective::Order.new(user: @user)
+
+      authorize_effective_order!
+      error = nil
+
+      Effective::Order.transaction do
+        begin
+          (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
+
+          @order.attributes = order_params.except(:order_items_attributes, :user_id)
+
+          @order.create_as_pending!
+
+          message = 'Successfully created order'
+          message << ". A request for payment has been sent to #{@order.user.email}" if @order.send_payment_request_to_buyer?
+          flash[:success] = message
+
+          redirect_to(admin_redirect_path) and return
+        rescue => e
+          error = e.message
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      @page_title = 'New Order'
+      flash.now[:danger] = "Unable to create order: #{error || @order.errors.full_messages.to_sentence}"
+      render :new
+    end
+
+    def edit
       @order = Effective::Order.find(params[:id])
-      @page_title = "Order ##{@order.to_param}"
+      @page_title ||= @order.to_s
 
       authorize_effective_order!
     end
 
     def update
       @order = Effective::Order.find(params[:id])
-      @page_title = "Order ##{@order.to_param}"
+      @order.skip_minimum_charge_validation = true if @order.refund?
+
+      @page_title ||= @order.to_s
 
       authorize_effective_order!
 
-      if @order.update_attributes(order_params)
-        if params[:commit].to_s.downcase == 'save internal note'
-          flash[:success] = 'Successfully updated internal note'
-        else
-          flash[:success] = 'Successfully updated order'
+      Effective::Order.transaction do
+        begin
+          @order.assign_attributes(order_params)
+          @order.save!
+          redirect_to(admin_redirect_path) and return
+        rescue => e
+          raise ActiveRecord::Rollback
         end
-
-        redirect_to(admin_redirect_path)
-      else
-        flash.now[:danger] = "Unable to update order: #{@order.errors.full_messages.to_sentence}"
-        render action: :show
       end
+
+      flash.now[:danger] = "Unable to update order: #{@order.errors.full_messages.to_sentence}"
+      render :edit
     end
 
-    def new
-      @order = Effective::Order.new
-      @order.user = (User.find(params[:user_id]) rescue nil) if params[:user_id]
+    def show
+      @order = Effective::Order.find(params[:id])
+      @order.skip_minimum_charge_validation = true if @order.refund?
 
-      @page_title = 'New Order'
+      @page_title ||= @order.to_s
 
       authorize_effective_order!
     end
 
-    def create
-      @user = User.find_by_id(order_params[:user_id])
-      @order = Effective::Order.new(user: @user)
+    # The show page posts to this action
+    # See Effective::OrdersController checkout
+    def checkout
+      @order = Effective::Order.find(params[:id])
+      @order.skip_minimum_charge_validation = true if @order.refund?
+
+      @page_title ||= 'Checkout'
 
       authorize_effective_order!
 
-      (order_params[:order_items_attributes] || {}).each do |_, item_attrs|
-        purchasable = Effective::Product.new(item_attrs[:purchasable_attributes])
-        @order.add(purchasable, quantity: item_attrs[:quantity])
+      Effective::Order.transaction do
+        begin
+          @order.assign_attributes(checkout_params)
+          @order.save!
+          redirect_to(effective_orders.admin_order_path(@order)) and return
+        rescue => e
+          raise ActiveRecord::Rollback
+        end
       end
 
-      @order.attributes = order_params.except(:order_items_attributes, :user_id)
+      flash.now[:danger] = "Unable to save order: #{@order.errors.full_messages.to_sentence}. Please try again."
+      render :show
+    end
 
-      if @order.create_as_pending
-        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(admin_redirect_path)
-      else
-        @page_title = 'New Order'
-        flash.now[:danger] = "Unable to create order: #{@order.errors.full_messages.to_sentence}"
-        render :new
-      end
+    def index
+      @datatable = EffectiveOrdersDatatable.new(self)
+
+      @page_title = 'Orders'
+
+      authorize_effective_order!
     end
 
     def destroy
@@ -92,50 +143,36 @@ module Admin
       redirect_to(effective_orders.admin_orders_path)
     end
 
-    def mark_as_paid
-      @order = Effective::Order.find(params[:id])
-      @page_title = 'Mark as Paid'
-
-      authorize_effective_order!
-
-      if request.patch? || request.post?  # They are submitting the form to mark an order as paid
-        purchased = false
-
-        @order.attributes = order_params.except(:payment, :payment_provider, :payment_card)
-
-        begin
-          purchased = @order.purchase!(
-            details: order_params[:payment],
-            provider: order_params[:payment_provider],
-            card: order_params[:payment_card],
-            email: @order.send_mark_as_paid_email_to_buyer?,
-            skip_buyer_validations: true
-          )
-        rescue => e
-          purchased = false
-        end
-
-        if purchased
-          flash[:success] = 'Order marked as paid successfully'
-          redirect_to(admin_redirect_path)
-        else
-          flash.now[:danger] = "Unable to mark order as paid: #{@order.errors.full_messages.to_sentence}"
-          render action: :mark_as_paid
-        end
-      end
-    end
-
     def send_payment_request
-      @order = Effective::Order.find(params[:id])
+      @order = Effective::Order.pending.find(params[:id])
       authorize_effective_order!
 
       if @order.send_payment_request_to_buyer!
-        flash[:success] = "Successfully sent payment request to #{@order.user.email}"
+        flash[:success] = "A request for payment has been sent 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))
+      if respond_to?(:redirect_back)
+        redirect_back(fallback_location: effective_orders.admin_order_path(@order))
+      elsif request.referrer.present?
+        redirect_to :back
+      else
+        redirect_to effective_orders.admin_order_path(@order)
+      end
+    end
+
+    def bulk_send_payment_request
+      @orders = Effective::Order.pending.where(id: params[:ids])
+
+      begin
+        authorize_effective_order!
+
+        @orders.each { |order| order.send_payment_request_to_buyer! }
+        render json: { status: 200, message: "Successfully sent #{@orders.length} payment request emails"}
+      rescue => e
+        render json: { status: 500, message: "Bulk send payment request error: #{e.message}" }
+      end
     end
 
     private
@@ -152,9 +189,13 @@ module Admin
       )
     end
 
+    def checkout_params
+      params.require(:effective_order).permit(EffectiveOrders.permitted_params)
+    end
+
     def authorize_effective_order!
-      EffectiveOrders.authorized?(self, :admin, :effective_orders)
-      EffectiveOrders.authorized?(self, action_name.to_sym, @order || Effective::Order)
+      EffectiveOrders.authorize!(self, :admin, :effective_orders)
+      EffectiveOrders.authorize!(self, action_name.to_sym, @order || Effective::Order)
     end
 
     def admin_redirect_path
@@ -165,13 +206,18 @@ module Admin
 
       return path if path.present?
 
-      case params[:commit]
-      when 'Save and Add New'
-        effective_orders.new_admin_order_path(user_id: @order.user.try(:to_param))
-      when 'Save and Mark as Paid'
-        effective_orders.mark_as_paid_admin_order_path(@order)
-      else
-        effective_orders.admin_order_path(@order)
+      case params[:commit].to_s
+      when 'Save'               ; effective_orders.admin_order_path(@order)
+
+      when 'Save and Continue'  ; effective_orders.admin_orders_path
+      when 'Save and Add New'   ; effective_orders.new_admin_order_path(user_id: @order.user.try(:to_param))
+      when 'Save and Duplicate' ; effective_orders.new_admin_order_path(duplicate_id: @order.to_param)
+
+      when 'Continue'           ; effective_orders.admin_orders_path
+      when 'Add New'            ; effective_orders.new_admin_order_path(user_id: @order.user.try(:to_param))
+      when 'Duplicate'          ; effective_orders.new_admin_order_path(duplicate_id: @order.to_param)
+
+      else effective_orders.admin_order_path(@order)
       end
     end