effective_orders 3.2.3 → 4.0.0beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 031a1810c8fc9ae6aa2909a0ee16cf73ad9b90b6a0aee17a353aafa033a39d7a
-  data.tar.gz: 652fad3647b97f20d0f950fa9da4d989111eee33f98d5110ce9b70aa421208e0
+SHA1:
+  metadata.gz: e0cf749b4cef2660e59b16b802211c75e79e7400
+  data.tar.gz: c4c452a35a548596146b2fdf099916065361dd55
 SHA512:
-  metadata.gz: b1c8c8e6b0554a22e6a091ab4ba206a33e66ef775172961df346b10ac5898b0d16a04d7d1469cef3dc3bc77ec5b8137e6cb2b349c690eb46c67eb0d4c9bf78cc
-  data.tar.gz: c4187ce976881522ac9c45448c0c2f58cb8cb18211f8254f33e8e8dc1e9bfcee075e61e58e0dab36a375506f450665bb80888ae1a7b95a3e561754b35ea9336b
+  metadata.gz: af34590308483e7db60eb579b952167622809d2c0cfb9c1101221800e0a3ce51e5ffe6d8d7895755f7fe18282ac379e6de0406f47802c445e16a2492fd838a7a
+  data.tar.gz: c872866386ab0490fd154cb8caf59119c75ea61cb2f601049d92a75ec0d9a97a7f4e939563a13807b53f3440fe8a0d636c40326da2aa6b89f2858a4fa321f73e

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2019 Code and Effect Inc.
+Copyright 2018 Code and Effect Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -4,20 +4,19 @@ Carts, Orders, and collecting payment via Stripe, PayPal and Moneris.
 
 A Rails Engine to handle the purchase workflow in a Rails 3.2.x / Rails 4 application.
 
-Also works with Stripe Connect and Stripe Subscriptions with coupons.
+Also works with Stripe Subscriptions.
 
 Sends order receipt emails automatically.
 
 Has Order History, My Purchases, My Sales and Admin screens.
 
-## Bootstrap3
+## effective_orders 4.0
 
-This is the `bootstrap3` branch of effective_orders which supports Twitter Bootstrap 3.
+This is the 4.0 series of effective_orders.
 
-All published effective_orders 3.x gems will support Twitter Bootstrap 3 and SimpleForm.
-
-For Bootstrap 4 please see the master branch and/or effective_orders 4.x gems.
+This requires Twitter Bootstrap 4 and Rails 5.1+
 
+Please check out [Effective Orders 3.x](https://github.com/code-and-effect/effective_orders/tree/bootstrap3) for more information using this gem with Bootstrap 3.
 
 ## Getting Started
 
@@ -26,7 +25,7 @@ Please first install the [effective_addresses](https://github.com/code-and-effec
 Add to your Gemfile:
 
 ```ruby
-gem 'effective_orders', '~> 3.0'
+gem 'effective_orders'
 ```
 
 Run the bundle command to install it:
@@ -264,10 +263,6 @@ acts_as_purchsable provides the following scopes:
 
 `Product.purchased_by(user)` all the Products purchased by a given user.
 
-`Product.sold` all the Products that have been solid (same as purchased)
-
-`Product.sold_by(user)` all the Products that this user has sold via Stripe Connect
-
 `Product.not_purchased` all unpurchased Products
 
 ### Digital Downloads
@@ -464,7 +459,7 @@ And call `render_cart(current_cart)` to display the Cart anywhere.
 
 On the Checkout page (`effective_orders.new_order_path`) a new `Effective::Order` object is created and one or more `Effective::OrderItem`s are initialized based on the `current_cart`.
 
-If the configuration options `config.require_billing_address` and/or `config.require_shipping_address` options are `true` then the user will be prompted for the appropriate addresses, based on [effective_addresses](https://github.com/code-and-effect/effective_addresses/).
+If the configuration options `config.billing_address` and/or `config.shipping_address` options are `true` then the user will be prompted for the appropriate addresses, based on [effective_addresses](https://github.com/code-and-effect/effective_addresses/).
 
 If `config.use_address_full_name` is set to `true` then appropriate form field will be shown and the user will be prompted for the appropriate address full name during the checkout process, based on [effective_addresses](https://github.com/code-and-effect/effective_addresses/).
 
@@ -512,7 +507,7 @@ The `acts_as_purchasable` `.purchased?` and `.purchased_by?(user)` methods only
 To programatically purchase one or more `acts_as_purchasable` objects:
 
 ```ruby
-Effective::Order.new(items: [@product1, @product2], user: current_user).purchase!(details: 'from my rake task')
+Effective::Order.new(@product1, @product2, user: current_user).purchase!(details: 'from my rake task')
 ```
 
 Here the `billing_address` and `shipping_address` are copied from the `current_user` object if the `current_user` responds_to `billing_address` / `shipping_address` as per [effective_addresses](https://github.com/code-and-effect/effective_addresses/).
@@ -541,7 +536,7 @@ The one gotcha with the above two scenarios, is that when `purchase!` is called,
 You can skip validations with the following command, but be careful as this skips all validations:
 
 ```ruby
-Effective::Order.new(item: @product, user: @user).purchase!(validate: false)
+Effective::Order.new(@product, user: @user).purchase!(validate: false)
 ```
 
 The `@product` is now considered purchased.
@@ -554,32 +549,10 @@ There also exist the scopes: `Effective::Order.purchased` and `Effective::Order.
 
 ### My Purchases / Order History
 
-This screen displays all past purchases made by the current user.  You can add it to your site's main menu or User profile area:
-
-```ruby
-= link_to_my_purchases()  # To display My Purchases
-```
-
-or
-
-```ruby
-= link_to_my_purchases(label: 'Order History', class: 'btn btn-primary')
-```
-
-or
-
 ```ruby
-= link_to 'My Order History', effective_orders.my_purchases_orders_path
+= link_to 'Order History', effective_orders.orders_path
 ```
 
-or render it inline on an existing page with
-
-```ruby
-render_order_history(user_or_orders)
-```
-
-If a user is passed, a call to `Effective::Order.purchased_by(user)` will be made to assign all purchased orders.
-
 Totally optional, but another way of displaying the Order History is to use the included datatable, based on [effective_datatables](https://github.com/code-and-effect/effective_datatables/)
 
 In your controller:
@@ -829,58 +802,6 @@ You an find these keys from the Stripe Dashbaord -> Your Account (dropdown) -> A
 
 You're ready to accept payments.
 
-### Stripe Connect
-
-Stripe Connect allows effective_orders to collect payments on behalf of users.
-
-First register your application with Stripe
-
-Stripe Dashboard -> Your Account (dropdown) -> Account Settings -> Apps
-
-Register your application
-
-Name: Your Application Name
-Website URL:  root_url
-
-Development:
-
-client_id: given by stripe, we need to record this.
-redirect_uri: stripe_connect_redirect_uri_url  # http://www.example.com/effective/orders/stripe_connect_redirect_uri
-webhook_uri: none
-
-And add these values to the app/config/effective_orders.rb initializer:
-
-```ruby
-config.stripe = {
-  secret_key: 'sk_live_IKd6HDaYUfoRjflWQTXfFNfc',
-  publishable_key: 'pk_live_liEGn9f0mcxKmoSjoeNbbuE1',
-  currency: 'usd',
-  connect_client_id: 'ca_35jLok5G9kosyYF7quTOwcauJjTnUnud'
-}
-```
-
-There are a few additional steps you need to take on the rails application side of things:
-
-
-Before allowing one of your Users to create a Product for sale, you must enforce that they have a Stripe Connect account setup and configured.
-
-You can check if they have an account set up using the built in helper `is_stripe_connect_seller?(current_user)`
-
-If the above check returns false, you must send them to Stripe to set up their StripeConnect account, using the built in helper `link_to_new_stripe_connect_customer`
-
-Once they've registered their account on the Stripe side, Stripe sends a webhook request, which is processed by the `webhooks_controller.rb`
-
-In the webhook controller, an `Effective::Customer` object is created, and your user is now ready to sell stuff via StripeConnect.
-
-
-Your product model must also define a `seller` method so that effective_orders knows who is selling the Product.  Add the following to your `acts_as_purchasable` model:
-
-```ruby
-def seller
-  User.find(user_id)
-end
-```
-
 ### Stripe Subscriptions
 
 To set up stripe subscriptions:
@@ -935,7 +856,7 @@ To set up stripe:
 
 4.) Click API -> Webhooks and add an endpoint `root_url/webhooks/stripe`. You will need something like ngrok to test this.
 
-5.) Record the webhook Signing secret in `config.subscription[:webhook_secret]`
+5.) Record the webhook Signing secret in `config.subscriptions[:webhook_secret]`
 
 
 ## Paying Via PayPal
@@ -1154,15 +1075,6 @@ end
 
 MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
 
-## Testing
-
-Run tests by:
-
-```ruby
-rspec
-```
-
-
 ## Contributing
 
 1. Fork it

data/app/assets/stylesheets/effective_orders.scss

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

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

@@ -0,0 +1,4 @@
+.effective-cart {
+  .subtotal { text-align: right; }
+}
+

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

@@ -28,7 +28,11 @@
 // Print - Resend Receipt.  Ontop of order.
 .effective-order-actions {
   text-align: right;
-  margin-bottom: 10px;
+  margin-bottom: 0.5rem;
+}
+
+.effective-order-change-items {
+  margin-bottom: 1rem;
 }
 
 // Checkout buttons. Bottom of order.
@@ -41,7 +45,7 @@
 }
 
 .effective-order-admin-purchase-actions {
-  margin-top: 10px;
+  margin-top: 0.5rem;
 }
 
 form.new_effective_order {

data/app/controllers/admin/orders_controller.rb

@@ -4,6 +4,10 @@ module Admin
 
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:admin_orders] : EffectiveOrders.layout)
 
+    # def effective_resource
+    #   @_effective_resource ||= Effective::Resource.new('effective/order', namespace: :admin)
+    # end
+
     def new
       @order = Effective::Order.new
 
@@ -40,8 +44,7 @@ module Admin
           end
 
           @order.attributes = order_params.except(:order_items_attributes, :user_id)
-
-          @order.create_as_pending!
+          @order.pending!
 
           message = 'Successfully created order'
           message << ". A request for payment has been sent to #{@order.user.email}" if @order.send_payment_request_to_buyer?
@@ -55,7 +58,7 @@ module Admin
       end
 
       @page_title = 'New Order'
-      flash.now[:danger] = "Unable to create order: #{error || @order.errors.full_messages.to_sentence}"
+      flash.now[:danger] = flash_danger(@order)
       render :new
     end
 
@@ -68,7 +71,6 @@ module Admin
 
     def update
       @order = Effective::Order.find(params[:id])
-      @order.skip_minimum_charge_validation = true if @order.refund?
 
       @page_title ||= @order.to_s
 
@@ -90,7 +92,6 @@ module Admin
 
     def show
       @order = Effective::Order.find(params[:id])
-      @order.skip_minimum_charge_validation = true if @order.refund?
 
       @page_title ||= @order.to_s
 
@@ -101,24 +102,26 @@ module Admin
     # 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!
 
+      if request.get?
+        @order.assign_confirmed_if_valid!
+        render :checkout and return
+      end
+
       Effective::Order.transaction do
         begin
           @order.assign_attributes(checkout_params)
-          @order.save!
-          redirect_to(effective_orders.admin_order_path(@order)) and return
+          @order.confirm!
+          redirect_to(effective_orders.checkout_admin_order_path(@order)) and return
         rescue => e
           raise ActiveRecord::Rollback
         end
       end
 
-      flash.now[:danger] = "Unable to save order: #{@order.errors.full_messages.to_sentence}. Please try again."
-      render :show
+      flash.now[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
+      render :checkout
     end
 
     def index
@@ -130,7 +133,7 @@ module Admin
     end
 
     def destroy
-      @order = Effective::Order.find(params[:id])
+      @order = Effective::Order.all.not_purchased.find(params[:id])
 
       authorize_effective_order!
 
@@ -209,13 +212,10 @@ module Admin
       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)
+      when 'Checkout'           ; effective_orders.checkout_admin_order_path(@order.to_param)
 
       else effective_orders.admin_order_path(@order)
       end

data/app/controllers/effective/carts_controller.rb

@@ -1,7 +1,5 @@
 module Effective
   class CartsController < ApplicationController
-    include EffectiveCartsHelper
-
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:carts] : EffectiveOrders.layout)
 
     def show
@@ -61,6 +59,10 @@ module Effective
 
     private
 
+    def current_cart
+      view_context.current_cart
+    end
+
     def add_to_cart_params
       params.permit(:purchasable_type, :purchasable_id, :quantity)
     end

data/app/controllers/effective/orders_controller.rb

@@ -1,137 +1,105 @@
 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::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
+    include Providers::Cheque if EffectiveOrders.cheque?
+    include Providers::Free if EffectiveOrders.free?
+    include Providers::MarkAsPaid if EffectiveOrders.mark_as_paid?
+    include Providers::Moneris if EffectiveOrders.moneris?
+    include Providers::Paypal if EffectiveOrders.paypal?
+    include Providers::Pretend if EffectiveOrders.pretend?
+    include Providers::Refund if EffectiveOrders.refunds?
+    include Providers::Stripe if EffectiveOrders.stripe?
 
     layout (EffectiveOrders.layout.kind_of?(Hash) ? EffectiveOrders.layout[:orders] : EffectiveOrders.layout)
 
-    before_action :authenticate_user!, except: [:ccbill_postback, :free, :moneris_postback, :paypal_postback, :pretend]
+    before_action :authenticate_user!, except: [:ccbill_postback, :free, :paypal_postback, :pretend]
     before_action :set_page_title, except: [:show]
 
-    # This is the entry point for any Checkout button
+    # If you want to use the Add to Cart -> Checkout flow
+    # Add one or more items however you do.
+    # redirect_to effective_orders.new_order_path, which is here.
+    # This is the entry point for any Checkout button.
+    # It displayes an order based on the cart
+    # Always step1
     def new
-      @order ||= Effective::Order.new(item: current_cart, user: current_user)
+      @order ||= Effective::Order.new(view_context.current_cart)
 
       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
-      @order.valid?
-
-      if @order.errors[:order_items].present?
-        flash[:danger] = @order.errors[:order_items].first
-        redirect_to(effective_orders.cart_path)
-        return
-      elsif @order.errors[:total].present?
-        flash[:danger] = @order.errors[:total].first
+      unless @order.valid?
+        flash[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
         redirect_to(effective_orders.cart_path)
         return
       end
-
-      @order.errors.clear
-      @order.billing_address.errors.clear if @order.billing_address
-      @order.shipping_address.errors.clear if @order.shipping_address
     end
 
+    # Confirms an order from the cart.
     def create
-      @order ||= Effective::Order.new(item: current_cart, user: current_user)
+      @order ||= Effective::Order.new(view_context.current_cart)
       EffectiveOrders.authorize!(self, :create, @order)
 
-      @order.assign_attributes(checkout_params) if params[:effective_order]
+      @order.assign_attributes(checkout_params)
 
-      Effective::Order.transaction do
-        begin
-          @order.save!
-          set_redirect_cookie!
-          redirect_to(effective_orders.order_path(@order)) and return
-        rescue => e
-          raise ActiveRecord::Rollback
-        end
+      if (@order.confirm! rescue false)
+        redirect_to(effective_orders.order_path(@order))
+      else
+        flash.now[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
+        render :new
       end
+    end
 
-      flash.now[:danger] = "Unable to proceed: #{@order.errors.full_messages.to_sentence}. Please try again."
-      render :new
+    # If you want to use the order = Effective::Order.new(@thing); order.save! flow
+    # Add one or more items to the order.
+    # redirect_to effective_orders.order_path(order), which is here
+    # This is the entry point for an existing order.
+    # Might render step1 or step2
+    def show
+      @order = Effective::Order.find(params[:id])
+      EffectiveOrders.authorize!(self, :show, @order)
+
+      @page_title ||= ((@order.user == current_user && !@order.purchased?) ? 'Checkout' : @order.to_s)
     end
 
+    # Always step1
     def edit
       @order ||= Effective::Order.find(params[:id])
       EffectiveOrders.authorize!(self, :edit, @order)
     end
 
+    # Confirms the order from existing order
     def update
       @order ||= Effective::Order.find(params[:id])
       EffectiveOrders.authorize!(self, :update, @order)
 
       @order.assign_attributes(checkout_params)
 
-      Effective::Order.transaction do
-        begin
-          @order.save!
-          set_redirect_cookie!
-
-          redirect_to(effective_orders.order_path(@order)) and return
-        rescue => e
-          raise ActiveRecord::Rollback
-        end
+      if (@order.confirm! rescue false)
+        redirect_to(effective_orders.order_path(@order))
+      else
+        flash.now[:danger] = "Unable to proceed: #{flash_errors(@order)}. Please try again."
+        render :edit
       end
-
-      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.authorize!(self, :show, @order)
-
-      @page_title ||= ((@order.user == current_user && !@order.purchased?) ? 'Checkout' : @order.to_s)
     end
 
+    # My Orders History
     def index
-      @orders = Effective::Order.deep.purchased_by(current_user)
+      @orders = Effective::Order.deep.purchased.where(user: current_user)
       @pending_orders = Effective::Order.deep.pending.where(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.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.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
     def purchased # Thank You!
       @order = if params[:id].present?
         Effective::Order.find(params[:id])
       elsif current_user.present?
-        Effective::Order.purchased_by(current_user).first
+        Effective::Order.sorted.purchased_by(current_user).last
       end
 
-      clear_redirect_cookie!
-
       if @order.blank?
-        redirect_to(effective_orders.my_purchases_orders_path) and return
+        redirect_to(effective_orders.orders_path) and return
       end
 
       EffectiveOrders.authorize!(self, :show, @order)
@@ -143,8 +111,6 @@ module Effective
       @order = Effective::Order.find(params[:id])
       EffectiveOrders.authorize!(self, :show, @order)
 
-      clear_redirect_cookie!
-
       redirect_to(effective_orders.order_path(@order)) unless @order.declined?
     end
 
@@ -174,7 +140,7 @@ module Effective
         EffectiveOrders.authorize!(self, :index, Effective::Order.new(user: current_user))
 
         @orders.each do |order|
-          next unless (EffectiveOrders.authorize!(self, :show, order) rescue false)
+          next unless EffectiveOrders.authorized?(self, :show, order)
 
           order.send_order_receipt_to_buyer!
         end
@@ -187,25 +153,6 @@ module Effective
 
     private
 
-    def set_redirect_cookie!
-      return unless @order.present?
-
-      if params[:purchased_url]
-        session["effective_orders_#{@order.id}_purchased_url"] = params[:purchased_url]
-      end
-
-      if params[:declined_url]
-        session["effective_orders_#{@order.id}_declined_url"] = params[:declined_url]
-      end
-    end
-
-    def clear_redirect_cookie!
-      return unless @order.present?
-
-      session["effective_orders_#{@order.id}_purchased_url"] = nil
-      session["effective_orders_#{@order.id}_declined_url"] = nil
-    end
-
     # StrongParameters
     def checkout_params
       params.require(:effective_order).permit(EffectiveOrders.permitted_params)
@@ -213,9 +160,7 @@ module Effective
 
     def set_page_title
       @page_title ||= case params[:action]
-        when 'index'        ; 'Orders'
-        when 'my_purchases' ; 'Order History'
-        when 'my_sales'     ; 'Sales History'
+        when 'index'        ; 'Order History'
         when 'purchased'    ; 'Thank You'
         when 'declined'     ; 'Payment Declined'
         else 'Checkout'