effective_orders 3.2.3 → 4.0.0beta1

data/app/helpers/effective_paypal_helper.rb

@@ -2,22 +2,24 @@ module EffectivePaypalHelper
   class ConfigReader
     def self.cert_or_key(config)
       if File.exist?(EffectiveOrders.paypal[config])
-        File.read(EffectiveOrders.paypal[config]) rescue {}
+        (File.read(EffectiveOrders.paypal[config]) rescue nil)
       else
-        EffectiveOrders.paypal[config] || {}
+        EffectiveOrders.paypal[config]
       end
     end
   end
 
   # These're constants so they only get read once, not every order request
-  PAYPAL_CERT_PEM = ConfigReader.cert_or_key(:paypal_cert)
-  APP_CERT_PEM    = ConfigReader.cert_or_key(:app_cert)
-  APP_KEY_PEM     = ConfigReader.cert_or_key(:app_key)
+  if EffectiveOrders.paypal?
+    PAYPAL_CERT_PEM = ConfigReader.cert_or_key(:paypal_cert)
+    APP_CERT_PEM    = ConfigReader.cert_or_key(:app_cert)
+    APP_KEY_PEM     = ConfigReader.cert_or_key(:app_key)
+  end
 
   def paypal_encrypted_payload(order)
-    raise "unable to read EffectiveOrders PayPal paypal_cert #{EffectiveOrders.paypal[:paypal_cert]}" unless PAYPAL_CERT_PEM.present?
-    raise "unable to read EffectiveOrders PayPal app_cert #{EffectiveOrders.paypal[:app_cert]}" unless APP_CERT_PEM.present?
-    raise "unable to read EffectiveOrders PayPal app_key #{EffectiveOrders.paypal[:app_key]}" unless APP_KEY_PEM.present?
+    raise 'required paypal paypal_cert is missing' unless PAYPAL_CERT_PEM.present?
+    raise 'required paypal app_cert is missing' unless APP_CERT_PEM.present?
+    raise 'required paypal app_key is missing' unless APP_KEY_PEM.present?
 
     values = {
       business: EffectiveOrders.paypal[:seller_email],

data/app/helpers/effective_stripe_helper.rb

@@ -1,36 +1,5 @@
 module EffectiveStripeHelper
 
-  STRIPE_CONNECT_AUTHORIZE_URL = 'https://connect.stripe.com/oauth/authorize'
-  STRIPE_CONNECT_TOKEN_URL = 'https://connect.stripe.com/oauth/token'
-
-  def is_stripe_connect_seller?(user)
-    Effective::Customer.for_buyer(user).stripe_connect_access_token.present?
-  end
-
-  def link_to_new_stripe_connect_customer(opts = {})
-    client_id = EffectiveOrders.stripe[:connect_client_id]
-
-    raise 'effective_orders config: stripe.connect_client_id has not been set' unless client_id.present?
-
-    authorize_params = {
-      response_type: :code,
-      client_id: client_id,            # This is the Application's ClientID
-      scope: :read_write,
-      state: {
-        form_authenticity_token: form_authenticity_token,   # Rails standard CSRF
-        redirect_to: URI.encode(request.original_url)  # TODO: Allow this to be customized
-      }.to_json
-    }
-
-    # Add the stripe_user parameter if it's possible
-    stripe_user_params = opts.delete :stripe_user
-    authorize_params.merge!({stripe_user: stripe_user_params}) if stripe_user_params.is_a?(Hash)
-
-    authorize_url = STRIPE_CONNECT_AUTHORIZE_URL + '?' + authorize_params.to_query
-    options = {}.merge(opts)
-    link_to image_tag('/assets/effective_orders/stripe_connect.png'), authorize_url, options
-  end
-
   def stripe_plan_description(obj)
     plan = (
       case obj
@@ -58,7 +27,7 @@ module EffectiveStripeHelper
   end
 
   def stripe_coupon_description(coupon)
-    amount = coupon.amount_off.present? ? ActionController::Base.helpers.price_to_currency(coupon.amount_off) : "#{coupon.percent_off}%"
+    amount = coupon.amount_off.present? ? price_to_currency(coupon.amount_off) : "#{coupon.percent_off}%"
 
     if coupon.duration_in_months.present?
       "#{coupon.id} - #{amount} off for #{coupon.duration_in_months} months"
@@ -68,7 +37,7 @@ module EffectiveStripeHelper
   end
 
   def stripe_site_image_url
-    return nil unless EffectiveOrders.stripe && (url = EffectiveOrders.stripe[:site_image].to_s).present?
+    return nil unless EffectiveOrders.stripe? && (url = EffectiveOrders.stripe[:site_image].to_s).present?
     url.start_with?('http') ? url : asset_url(url)
   end
 

data/app/models/concerns/acts_as_purchasable.rb

@@ -7,36 +7,40 @@ module ActsAsPurchasable
     def acts_as_purchasable(*options)
       @acts_as_purchasable = options || []
       include ::ActsAsPurchasable
-      (ActsAsPurchasable.descendants ||= []) << self
+
+      instance = new()
+      raise 'must respond_to price' unless instance.respond_to?(:price)
+      raise 'must respond_to purchased_order_id' unless instance.respond_to?(:purchased_order_id)
     end
   end
 
   included do
+    belongs_to :purchased_order, class_name: 'Effective::Order' # Set when purchased
+
     has_many :cart_items, as: :purchasable, dependent: :delete_all, class_name: 'Effective::CartItem'
 
     has_many :order_items, as: :purchasable, class_name: 'Effective::OrderItem'
     has_many :orders, -> { order(:id) }, through: :order_items, class_name: 'Effective::Order'
 
-    has_many :purchased_orders, -> { where(purchase_state: EffectiveOrders::PURCHASED).order(:purchased_at) },
+    has_many :purchased_orders, -> { where(state: EffectiveOrders::PURCHASED).order(:purchased_at) },
       through: :order_items, class_name: 'Effective::Order', source: :order
 
-    validates_with Effective::SoldOutValidator, on: :create
-
     # Database max integer value is 2147483647.  So let's round that down and use a max/min of $20 million (2000000000)
     validates :price, presence: true, numericality: { less_than_or_equal_to: 2000000000, message: 'maximum price is $20,000,000' }
-
     validates :tax_exempt, inclusion: { in: [true, false] }
 
-    # These are breaking on the check for quanitty_enabled?.  More research is due
-    validates :quantity_purchased, numericality: { allow_nil: true }, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
-    validates :quantity_max, numericality: { allow_nil: true }, if: proc { |purchasable| (purchasable.quantity_enabled? rescue false) }
+    with_options(if: -> { quantity_enabled? }) do
+      validates :quantity_purchased, numericality: { allow_nil: true }
+      validates :quantity_max, numericality: { allow_nil: true }
+      validates_with Effective::SoldOutValidator, on: :create
+    end
 
-    scope :purchased, -> { joins(order_items: :order).where(orders: {purchase_state: EffectiveOrders::PURCHASED}).distinct }
-    scope :purchased_by, lambda { |user| joins(order_items: :order).where(orders: {user_id: user.try(:id), purchase_state: EffectiveOrders::PURCHASED}).distinct }
-    scope :sold, -> { purchased() }
-    scope :sold_by, lambda { |user| joins(order_items: :order).where(order_items: {seller_id: user.try(:id)}).where(orders: {purchase_state: EffectiveOrders::PURCHASED}).distinct }
+    scope :purchased, -> { where.not(purchased_order_id: nil) }
+    scope :not_purchased, -> { where(purchased_order_id: nil) }
 
-    scope :not_purchased, -> { where('id NOT IN (?)', purchased.pluck(:id).presence || [0]) }
+    # scope :purchased, -> { joins(order_items: :order).where(orders: {state: EffectiveOrders::PURCHASED}).distinct }
+    # scope :not_purchased, -> { where('id NOT IN (?)', purchased.pluck(:id).presence || [0]) }
+    scope :purchased_by, lambda { |user| joins(order_items: :order).where(orders: { user_id: user.try(:id), state: EffectiveOrders::PURCHASED }).distinct }
     scope :not_purchased_by, lambda { |user| where('id NOT IN (?)', purchased_by(user).pluck(:id).presence || [0]) }
   end
 
@@ -56,10 +60,6 @@ module ActsAsPurchasable
 
   # Regular instance methods
 
-  def price
-    self[:price] || 0
-  end
-
   # If I have a column type of Integer, and I'm passed a non-Integer, convert it here
   def price=(value)
     if value.kind_of?(Integer)
@@ -79,43 +79,32 @@ module ActsAsPurchasable
     self[:tax_exempt] || false
   end
 
-  def seller
-    if EffectiveOrders.stripe_connect_enabled
-      raise 'acts_as_purchasable object requires the seller be defined to return the User selling this item. This is only a requirement when using StripeConnect.'
-    end
-  end
-
-  def purchased_order
-    @purchased_order ||= purchased_orders.first
+  def purchased?
+    purchased_order_id.present?
   end
 
-  def purchased?
-    @is_purchased ||= purchased_order.present?
+  def purchased_at
+    purchased_order.try(:purchased_at)
   end
 
   def purchased_by?(user)
     purchased_orders.any? { |order| order.user_id == user.id }
   end
 
-  def purchased_at
-    purchased_order.try(:purchased_at)
+  def purchased_download_url # Override me if this is a digital purchase.
+    false
   end
 
   def quantity_enabled?
-    self.respond_to?(:quantity_enabled) ? quantity_enabled == true : false
+    false
   end
 
   def quantity_remaining
-    (quantity_max - quantity_purchased) rescue 0
+    quantity_max - quantity_purchased if quantity_enabled?
   end
 
   def sold_out?
-    quantity_enabled? ? (quantity_remaining == 0) : false
-  end
-
-  # Override me if this is a digital purchase.
-  def purchased_download_url
-    false
+    quantity_enabled? ? (quantity_remaining <= 0) : false
   end
 
 end

data/app/models/concerns/acts_as_subscribable.rb

@@ -57,7 +57,7 @@ module ActsAsSubscribable
 
   def trial_expires_at
     # The rake task send_trial_expiring_emails depends on this beginning_of_day
-    ((created_at || Time.zone.now) + EffectiveOrders.subscription[:trial_period]).beginning_of_day
+    ((created_at || Time.zone.now) + EffectiveOrders.subscriptions[:trial_period]).beginning_of_day
   end
 
   def buyer

data/app/models/effective/cart.rb

@@ -2,9 +2,8 @@ module Effective
   class Cart < ActiveRecord::Base
     self.table_name = EffectiveOrders.carts_table_name.to_s
 
-    # Optional. We want non-logged-in users to have carts too.
-    belongs_to :user, optional: true
-    has_many :cart_items, -> { includes(:purchasable).order(:updated_at) }, dependent: :delete_all, class_name: 'Effective::CartItem'
+    belongs_to :user    # Optional. We want non-logged-in users to have carts too.
+    has_many :cart_items, -> { order(:id) }, dependent: :delete_all, class_name: 'Effective::CartItem'
 
     accepts_nested_attributes_for :cart_items
 
@@ -43,13 +42,13 @@ module Effective
         raise EffectiveOrders::SoldOutException, "#{item.title} is sold out"
       end
 
-      existing ||= cart_items.build(purchasable: item, quantity: quantity, unique: (unique.to_s if unique.kind_of?(Symbol) || unique.kind_of?(String) || unique == true))
+      existing ||= cart_items.build(purchasable: item, quantity: quantity, unique: (unique.to_s unless unique.kind_of?(Proc)))
       save!
     end
 
     def clear!
       cart_items.each { |cart_item| cart_item.mark_for_destruction }
-      save!
+      cart_items.present? ? save! : true
     end
 
     def remove(item)

data/app/models/effective/customer.rb

@@ -2,7 +2,6 @@ module Effective
   class Customer < ActiveRecord::Base
     self.table_name = EffectiveOrders.customers_table_name.to_s
 
-    attr_accessor :stripe_token # This is a convenience method so we have a place to store StripeConnect temporary access tokens
     attr_accessor :stripe_customer, :stripe_subscription
 
     belongs_to :user
@@ -18,8 +17,6 @@ module Effective
     # stripe_subscription_id        :string  # Each user gets one stripe subscription object, which can contain many items
     # status                        :string
 
-    # stripe_connect_access_token   :string  # If using StripeConnect and this user is a connected Seller
-    #
     # timestamps
 
     scope :deep, -> { includes(subscriptions: :subscribable) }
@@ -32,7 +29,7 @@ module Effective
     validates :stripe_customer_id, presence: true
     validates :status, if: -> { stripe_subscription_id.present? }, inclusion: { in: %w(active past_due) }
 
-    def self.for_buyer(user)
+    def self.for_user(user)
       Effective::Customer.where(user: user).first_or_initialize
     end
 

data/app/models/effective/order.rb

@@ -1,3 +1,12 @@
+# When an Order is first initialized it is done in the pending state
+# - when it's in the pending state, none of the buyer entered information is required
+# - when a pending order is rendered:
+# - if the user has a billing address, go to step 2
+# - if the user has no billing address, go to step 1
+#
+# After Step1, we go to the confirmed state
+# After Step2, we are in the purchased or declined state
+
 module Effective
   class Order < ActiveRecord::Base
     self.table_name = EffectiveOrders.orders_table_name.to_s
@@ -17,7 +26,6 @@ module Effective
     attr_accessor :send_payment_request_to_buyer # Set by Admin::Orders#new. Should the payment request email be sent after creating an order?
     attr_accessor :send_mark_as_paid_email_to_buyer  # Set by Admin::Orders#mark_as_paid
     attr_accessor :skip_buyer_validations # Set by Admin::Orders#create
-    attr_accessor :skip_minimum_charge_validation # Set by Admin::Orders#show
 
     belongs_to :user, validate: false  # This is the buyer/user of the order. We validate it below.
     has_many :order_items, -> { order(:id) }, inverse_of: :order, class_name: 'Effective::OrderItem'
@@ -26,13 +34,15 @@ module Effective
     accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
 
     # Attributes
-    # purchase_state    :string
+    # state             :string
     # purchased_at      :datetime
     #
-    # note_to_buyer     :text
-    # note_internal     :text
+    # note              :text   # From buyer to admin
+    # note_to_buyer     :text   # From admin to buyer
+    # note_internal     :text   # Internal admin only
     #
-    # payment           :text   # serialized hash containing all the payment details.  see below.
+    # billing_name      :string # name of buyer
+    # payment           :text   # serialized hash containing all the payment details.
     #
     # payment_provider  :string
     # payment_card      :string
@@ -47,38 +57,38 @@ module Effective
 
     serialize :payment, Hash
 
-    before_validation { assign_totals! }
+    before_validation { assign_order_totals }
+    before_validation { assign_billing_name }
+    before_validation { assign_last_address }
 
     # Order validations
+    validates :user_id, presence: true
     validates :order_items, presence: { message: 'No items are present. Please add additional items.' }
-    validates :purchase_state, inclusion: { in: EffectiveOrders::PURCHASE_STATES.keys }
+    validates :state, inclusion: { in: EffectiveOrders::STATES.keys }
     validates :subtotal, presence: true
 
     if EffectiveOrders.minimum_charge.to_i > 0
       validates :total, presence: true, numericality: {
         greater_than_or_equal_to: EffectiveOrders.minimum_charge.to_i,
         message: "must be $#{'%0.2f' % (EffectiveOrders.minimum_charge.to_i / 100.0)} or more. Please add additional items."
-      }, unless: -> {
-        (total == 0 && EffectiveOrders.allow_free_orders) ||
-        (total < 0 && EffectiveOrders.allow_refunds && skip_minimum_charge_validation?)
-      }
+      }, unless: -> { (free? && EffectiveOrders.free?) || (refund? && EffectiveOrders.refunds?) }
     end
 
     # User validations -- An admin skips these when working in the admin/ namespace
-    with_options unless: -> { skip_buyer_validations? } do |order|
+    with_options unless: -> { pending? || skip_buyer_validations? } do |order|
       order.validates :tax_rate, presence: { message: "can't be determined based on billing address" }
       order.validates :tax, presence: true
 
       unless EffectiveOrders.skip_user_validation
-        order.validates :user_id, presence: true
+        order.validates :billing_name, presence: true
         order.validates :user, associated: true
       end
 
-      if EffectiveOrders.require_billing_address
+      if EffectiveOrders.billing_address
         order.validates :billing_address, presence: true
       end
 
-      if EffectiveOrders.require_shipping_address
+      if EffectiveOrders.shipping_address
         order.validates :shipping_address, presence: true
       end
 
@@ -92,25 +102,20 @@ module Effective
       order.validates :purchased_at, presence: true
       order.validates :payment, presence: true
 
-      order.validates :payment_provider, presence: true, inclusion: { in: EffectiveOrders.payment_providers + EffectiveOrders.other_payment_providers }
+      order.validates :payment_provider, presence: true, inclusion: { in: EffectiveOrders.payment_providers }
       order.validates :payment_card, presence: true
     end
 
-    before_save { assign_totals! unless self[:total].present? } # Incase we save!(validate: false)
-    before_save :save_addresses
-
-    scope :deep, -> { includes(:user).includes(order_items: :purchasable) }
-    scope :sorted, -> { order(created_at: :desc) }
+    scope :deep, -> { includes(:user, order_items: :purchasable) }
+    scope :sorted, -> { order(:id) }
 
-    scope :purchased, -> { sorted.where(purchase_state: EffectiveOrders::PURCHASED) }
-    scope :purchased_by, lambda { |user| purchased.where(user_id: user.try(:id)) }
-    scope :declined, -> { where(purchase_state: EffectiveOrders::DECLINED) }
-    scope :pending, -> { where(purchase_state: EffectiveOrders::PENDING) }
+    scope :purchased, -> { where(state: EffectiveOrders::PURCHASED) }
+    scope :purchased_by, lambda { |user| purchased.where(user: user) }
+    scope :not_purchased, -> { where.not(state: EffectiveOrders::PURCHASED) }
 
-    scope :for_users, -> (users) {   # Expects a Users relation, an Array of ids, or Array of users
-      users = users.kind_of?(::ActiveRecord::Relation) ? users.pluck(:id) : Array(users)
-      where(user_id: (users.first.kind_of?(Integer) ? users : users.map { |user| user.id }))
-    }
+    scope :pending, -> { where(state: EffectiveOrders::PENDING) }
+    scope :confirmed, -> { where(state: EffectiveOrders::CONFIRMED) }
+    scope :declined, -> { where(state: EffectiveOrders::DECLINED) }
 
     # Effective::Order.new()
     # Effective::Order.new(Product.first)
@@ -122,27 +127,29 @@ module Effective
     # Effective::Order.new(items: Product.first, user: User.first, billing_address: Effective::Address.new, shipping_address: Effective::Address.new)
 
     def initialize(atts = nil, &block)
-      super(purchase_state: EffectiveOrders::PENDING) # Initialize with state: PENDING
+      super(state: EffectiveOrders::PENDING) # Initialize with state: PENDING
 
       return unless atts.present?
 
       if atts.kind_of?(Hash)
-        items = Array(atts.delete(:item)) + Array(atts.delete(:items))
+        if (keywords = (atts.keys - [:item, :items, :user, :billing_address, :shipping_address])).present?
+          raise ArgumentError.new("unknown keyword: #{keywords.join(' ')}")
+        end
+
+        items = Array(atts[:item]) + Array(atts[:items])
 
-        self.user = atts.delete(:user) || (items.first.user if items.first.respond_to?(:user))
+        self.user = atts[:user] || (items.first.user if items.first.respond_to?(:user))
 
-        if (address = atts.delete(:billing_address)).present?
-          self.billing_address = address
+        if atts.key?(:billing_address)
+          self.billing_address = atts[:billing_address]
           self.billing_address.full_name ||= user.to_s.presence
         end
 
-        if (address = atts.delete(:shipping_address)).present?
-          self.shipping_address = address
+        if atts.key?(:shipping_address)
+          self.shipping_address = atts[:shipping_address]
           self.shipping_address.full_name ||= user.to_s.presence
         end
 
-        atts.each { |key, value| self.send("#{key}=", value) }
-
         add(items) if items.present?
       else # Attributes are not a Hash
         self.user = atts.user if atts.respond_to?(:user)
@@ -150,6 +157,7 @@ module Effective
       end
     end
 
+    # Items can be an Effective::Cart, an Effective::order, a single acts_as_purchasable, or multiple acts_as_purchasables
     # add(Product.first) => returns an Effective::OrderItem
     # add(Product.first, current_cart) => returns an array of Effective::OrderItems
     def add(*items, quantity: 1)
@@ -192,41 +200,6 @@ module Effective
       retval.size == 1 ? retval.first : retval
     end
 
-    def user=(user)
-      super
-
-      return unless user.present?
-
-      # Copy user addresses into this order if they are present
-      if user.respond_to?(:billing_address) && user.billing_address.present?
-        self.billing_address = user.billing_address
-      end
-
-      if user.respond_to?(:shipping_address) && user.shipping_address.present?
-        self.shipping_address = user.shipping_address
-      end
-
-      user
-    end
-
-    # This is called from admin/orders#create
-    # This is intended for use as an admin action only
-    # It skips any address or bad user validations
-    def create_as_pending!
-      return false unless new_record?
-
-      self.purchase_state = EffectiveOrders::PENDING
-
-      self.skip_buyer_validations = true
-      self.addresses.clear if addresses.any? { |address| address.valid? == false }
-
-      save!
-
-      send_payment_request_to_buyer! if send_payment_request_to_buyer?
-
-      true
-    end
-
     def to_s
       if refund?
         "Refund ##{to_param}"
@@ -239,18 +212,32 @@ module Effective
       end
     end
 
-    def free?
-      total == 0
+    def pending?
+      state == EffectiveOrders::PENDING
     end
 
-    def refund?
-      total.to_i < 0
+    def confirmed?
+      state == EffectiveOrders::CONFIRMED
+    end
+
+    def purchased?(provider = nil)
+      return false if (state != EffectiveOrders::PURCHASED)
+      return true if provider.nil? || payment_provider == provider.to_s
+      false
+    end
+
+    def declined?
+      state == EffectiveOrders::DECLINED
     end
 
     def purchasables
       order_items.map { |order_item| order_item.purchasable }
     end
 
+    def subtotal
+      self[:subtotal] || order_items.map { |oi| oi.subtotal }.sum
+    end
+
     def tax_rate
       self[:tax_rate] || get_tax_rate()
     end
@@ -259,20 +246,24 @@ module Effective
       self[:tax] || get_tax()
     end
 
-    def subtotal
-      self[:subtotal] || order_items.map { |oi| oi.subtotal }.sum
-    end
-
     def total
       (self[:total] || (subtotal + tax.to_i)).to_i
     end
 
+    def free?
+      total == 0
+    end
+
+    def refund?
+      total.to_i < 0
+    end
+
     def num_items
       order_items.map { |oi| oi.quantity }.sum
     end
 
     def send_payment_request_to_buyer?
-      truthy?(send_payment_request_to_buyer)
+      truthy?(send_payment_request_to_buyer) && !free? && !refund?
     end
 
     def send_mark_as_paid_email_to_buyer?
@@ -283,18 +274,34 @@ module Effective
       truthy?(skip_buyer_validations)
     end
 
-    def skip_minimum_charge_validation?
-      truthy?(skip_minimum_charge_validation) || skip_buyer_validations?
+    # This is called from admin/orders#create
+    # This is intended for use as an admin action only
+    # It skips any address or bad user validations
+    # It's basically the same as save! on a new order, except it might send the payment request to buyer
+    def pending!
+      self.state = EffectiveOrders::PENDING
+      self.addresses.clear if addresses.any? { |address| address.valid? == false }
+      save!
+
+      send_payment_request_to_buyer! if send_payment_request_to_buyer?
+      true
     end
 
-    def billing_name
-      name ||= billing_address.try(:full_name).presence
-      name ||= user.try(:full_name).presence
-      name ||= (user.try(:first_name).to_s + ' ' + user.try(:last_name).to_s).presence
-      name ||= user.try(:email).presence
-      name ||= user.to_s
-      name ||= "User #{user.try(:id)}"
-      name
+    def confirm!
+      self.state = EffectiveOrders::CONFIRMED
+      save!
+    end
+
+    # This lets us skip to the confirmed workflow for an admin...
+    def assign_confirmed_if_valid!
+      return unless pending?
+
+      self.state = EffectiveOrders::CONFIRMED
+      return true if valid?
+
+      self.errors.clear
+      self.state = EffectiveOrders::PENDING
+      false
     end
 
     # Effective::Order.new(Product.first, user: User.first).purchase!(details: 'manual purchase')
@@ -307,31 +314,24 @@ module Effective
 
       Effective::Order.transaction do
         begin
-          self.purchase_state = EffectiveOrders::PURCHASED
+          self.state = EffectiveOrders::PURCHASED
           self.purchased_at ||= Time.zone.now
 
-          self.payment = (
-            if details.kind_of?(Hash)
-              details
-            elsif details.respond_to?(:to_unsafe_h)
-              details.to_unsafe_h
-            else
-              { details: details.to_s }
-            end
-          )
-
+          self.payment = details.kind_of?(Hash) ? details : { details: details.to_s }
           self.payment_provider = provider.to_s
           self.payment_card = card.to_s.presence || 'none'
 
           self.skip_buyer_validations = skip_buyer_validations
 
+          assign_purchased_order_to_purchasables
+
           run_purchasable_callbacks(:before_purchase)
 
           save!(validate: validate)
 
           success = true
         rescue => e
-          self.purchase_state = purchase_state_was
+          self.state = state_was
           self.purchased_at = purchased_at_was
 
           error = e.message
@@ -339,7 +339,7 @@ module Effective
         end
       end
 
-      raise "Failed to purchase Effective::Order: #{error || errors.full_messages.to_sentence}" unless success
+      raise "Failed to purchase order: #{error || errors.full_messages.to_sentence}" unless success
 
       send_order_receipts! if email
 
@@ -358,7 +358,7 @@ module Effective
 
       Effective::Order.transaction do
         begin
-          self.purchase_state = EffectiveOrders::DECLINED
+          self.state = EffectiveOrders::DECLINED
           self.purchased_at = nil
 
           self.payment = details.kind_of?(Hash) ? details : { details: details.to_s }
@@ -369,7 +369,7 @@ module Effective
 
           success = true
         rescue => e
-          self.purchase_state = purchase_state_was
+          self.state = state_was
           self.purchased_at = purchased_at_was
 
           error = e.message
@@ -377,38 +377,16 @@ module Effective
         end
       end
 
-      raise "Failed to decline! Effective::Order: #{error || errors.full_messages.to_sentence}" unless success
+      raise "Failed to decline order: #{error || errors.full_messages.to_sentence}" unless success
 
       run_purchasable_callbacks(:after_decline)
 
       true
     end
 
-    def abandoned?
-      purchase_state == EffectiveOrders::ABANDONED
-    end
-
-    def purchased?(provider = nil)
-      return false if (purchase_state != EffectiveOrders::PURCHASED)
-      return true if provider.nil? || payment_provider == provider.to_s
-
-      unless EffectiveOrder.payment_providers.include?(provider.to_s)
-        raise "Unknown provider #{provider}. Known providers are #{EffectiveOrders.payment_providers}"
-      end
-    end
-
-    def declined?
-      purchase_state == EffectiveOrders::DECLINED
-    end
-
-    def pending?
-      purchase_state == EffectiveOrders::PENDING
-    end
-
     def send_order_receipts!
       send_order_receipt_to_admin! if EffectiveOrders.mailer[:send_order_receipt_to_admin]
       send_order_receipt_to_buyer! if EffectiveOrders.mailer[:send_order_receipt_to_buyer]
-      send_order_receipt_to_seller! if EffectiveOrders.mailer[:send_order_receipt_to_seller]
     end
 
     def send_order_receipt_to_admin!
@@ -419,14 +397,6 @@ module Effective
       send_email(:order_receipt_to_buyer, to_param) if purchased?
     end
 
-    def send_order_receipt_to_seller!
-      return false unless (EffectiveOrders.stripe_connect_enabled && purchased?(:stripe_connect))
-
-      order_items.group_by { |oi| oi.seller }.each do |seller, order_items|
-        send_email(:order_receipt_to_seller, to_param, seller, order_items)
-      end
-    end
-
     def send_payment_request_to_buyer!
       send_email(:payment_request_to_buyer, to_param) unless purchased?
     end
@@ -453,46 +423,45 @@ module Effective
 
     private
 
-    def assign_totals!
+    def assign_order_totals
       self.subtotal = order_items.map { |oi| oi.subtotal }.sum
       self.tax_rate = get_tax_rate()
       self.tax = get_tax()
       self.total = subtotal + (tax || 0)
     end
 
-    def save_addresses
-      if user.respond_to?(:billing_address=) && billing_address.present?
-        user.billing_address = billing_address
-        user.billing_address.save
+    def assign_billing_name
+      self.billing_name = [(billing_address.full_name.presence if billing_address.present?), (user.to_s.presence)].compact.first
+    end
+
+    def assign_last_address
+      return unless user.present?
+      return unless (EffectiveOrders.billing_address || EffectiveOrders.shipping_address)
+      return if EffectiveOrders.billing_address && billing_address.present?
+      return if EffectiveOrders.shipping_address && shipping_address.present?
+
+      last_order = Effective::Order.sorted.where(user: user).last
+      return unless last_order.present?
+
+      if EffectiveOrders.billing_address && last_order.billing_address.present?
+        self.billing_address = last_order.billing_address
       end
 
-      if user.respond_to?(:shipping_address=) && shipping_address.present?
-        user.shipping_address = shipping_address
-        user.shipping_address.save
+      if EffectiveOrders.shipping_address && last_order.shipping_address.present?
+        self.shipping_address = last_order.shipping_address
       end
     end
 
+    def assign_purchased_order_to_purchasables
+      order_items.each { |oi| oi.purchasable.purchased_order = self }
+    end
+
     def run_purchasable_callbacks(name)
-      begin
-        order_items.each { |oi| oi.purchasable.public_send(name, self, oi) if oi.purchasable.respond_to?(name) }
-      rescue => e
-        raise e unless Rails.env.production?
-      end
+      order_items.each { |oi| oi.purchasable.public_send(name, self, oi) if oi.purchasable.respond_to?(name) }
     end
 
     def send_email(email, *mailer_args)
-      begin
-        if EffectiveOrders.mailer[:delayed_job_deliver] && EffectiveOrders.mailer[:deliver_method] == :deliver_later
-          Effective::OrdersMailer.delay.public_send(email, *mailer_args)
-        elsif EffectiveOrders.mailer[:deliver_method].present?
-          Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
-        else
-          Effective::OrdersMailer.public_send(email, *mailer_args).deliver_now
-        end
-      rescue => e
-        raise e unless Rails.env.production?
-        return false
-      end
+      Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
     end
 
     def truthy?(value)