effective_orders 1.8.1 → 2.0.0

data/app/models/effective/cart_item.rb

@@ -5,14 +5,14 @@ module Effective
     belongs_to :cart
     belongs_to :purchasable, :polymorphic => true
 
-    structure do
-      quantity    :integer, :validates => [:presence]
-      timestamps
-    end
-
-    validates_presence_of :purchasable
+    # structure do
+    #   quantity    :integer
+    #
+    #   timestamps
+    # end
 
-    delegate :title, :tax_exempt, :tax_rate, :to => :purchasable
+    validates :purchasable, presence: true
+    validates :quantity, presence: true
 
     default_scope -> { order(:updated_at) }
 
@@ -25,16 +25,18 @@ module Effective
       end
     end
 
-    def subtotal
-      price * quantity
+    def title
+      purchasable.try(:title) || 'New Cart Item'
     end
 
-    def tax
-      tax_exempt ? 0 : (subtotal * tax_rate).round(0).to_i
+    def tax_exempt
+      purchasable.try(:tax_exempt) || false
     end
 
-    def total
-      subtotal + tax
+    def subtotal
+      price * quantity
     end
+    alias_method :total, :subtotal
+
   end
 end

data/app/models/effective/customer.rb

@@ -7,16 +7,16 @@ module Effective
     belongs_to :user
     has_many :subscriptions, :inverse_of => :customer
 
-    structure do
-      stripe_customer_id            :string  # cus_xja7acoa03
-      stripe_active_card            :string  # **** **** **** 4242 Visa 05/12
-      stripe_connect_access_token   :string  # If using StripeConnect and this user is a connected Seller
+    # structure do
+    #   stripe_customer_id            :string  # cus_xja7acoa03
+    #   stripe_active_card            :string  # **** **** **** 4242 Visa 05/12
+    #   stripe_connect_access_token   :string  # If using StripeConnect and this user is a connected Seller
+    #
+    #   timestamps
+    # end
 
-      timestamps
-    end
-
-    validates_presence_of :user
-    validates_uniqueness_of :user_id  # Only 1 customer per user may exist
+    validates :user, presence: true
+    validates :user_id, uniqueness: true
 
     scope :customers, -> { where("#{EffectiveOrders.customers_table_name.to_s}.stripe_customer_id IS NOT NULL") }
 

data/app/models/effective/datatables/order_items.rb

@@ -5,15 +5,21 @@ if defined?(EffectiveDatatables)
         datatable do
           default_order :purchased_at, :desc
 
-          table_column(:purchased_at, :type => :datetime, :column => 'orders.purchased_at') do |order_item|
+          table_column(:purchased_at, type: :datetime, column: 'orders.purchased_at') do |order_item|
             Time.at(order_item[:purchased_at]).in_time_zone if order_item[:purchased_at].present?
           end
 
-          table_column :id, :visible => false
+          table_column :id, visible: false
 
-          table_column(:order, :type => :obfuscated_id, :sortable => false) do |order_item|
-            obfuscated_id = Effective::Order.obfuscate(order_item[:order_id])
-            link_to(obfuscated_id, (datatables_admin_path? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
+          if EffectiveOrders.obfuscate_order_ids
+            table_column(:order, type: :obfuscated_id, sortable: false) do |order_item|
+              obfuscated_id = Effective::Order.obfuscate(order_item[:order_id])
+              link_to(obfuscated_id, (datatables_admin_path? ? effective_orders.admin_order_path(obfuscated_id) : effective_orders.order_path(obfuscated_id)))
+            end
+          else
+            table_column(:order, sortable: false) do |order_item|
+              link_to(order_item.to_param, (datatables_admin_path? ? effective_orders.admin_order_path(order_item.to_param) : effective_orders.order_path(order_item.to_param)))
+            end
           end
 
           table_column :email, column: 'users.email', label: 'Buyer Email', if: proc { attributes[:user_id].blank? } do |order_item|
@@ -38,13 +44,13 @@ if defined?(EffectiveDatatables)
           table_column(:tax) { |order_item| price_to_currency(order_item[:tax].to_i) }
           table_column(:total) { |order_item| price_to_currency(order_item[:total].to_i) }
 
-          table_column :created_at, :visible => false
-          table_column :updated_at, :visible => false
+          table_column :created_at, visible: false
+          table_column :updated_at, visible: false
         end
 
         def collection
           collection = Effective::OrderItem.unscoped
-            .joins(:order => :user)
+            .joins(order: :user)
             .select('order_items.*, orders.*, users.email AS email')
             .select("#{query_subtotal} AS subtotal, #{query_tax} AS tax, #{query_total} AS total")
             .group('order_items.id, orders.id, users.email')

data/app/models/effective/datatables/orders.rb

@@ -3,100 +3,87 @@ if defined?(EffectiveDatatables)
     module Datatables
       class Orders < Effective::Datatable
         datatable do
-          default_order :purchased_at, :desc
+          default_order :created_at, :desc
 
           table_column :purchased_at
-          table_column :id
 
-          table_column :email, column: 'users.email', label: 'Buyer Email', if: proc { attributes[:user_id].blank? } do |order|
-            link_to order[:email], (edit_admin_user_path(order.user_id) rescue admin_user_path(order.user_id) rescue '#')
+          table_column :id, label: 'ID' do |order|
+            link_to order.to_param, effective_orders.admin_order_path(order)
           end
 
-          if EffectiveOrders.require_billing_address
-            table_column :buyer_name, sortable: false, label: 'Buyer Name', if: proc { attributes[:user_id].blank? } do |order|
-              (order[:buyer_name] || '').split('!!SEP!!').find(&:present?)
+          # Don't display email or buyer_name column if this is for a specific user
+          if attributes[:user_id].blank?
+            table_column :email, column: 'users.email', label: 'Buyer Email' do |order|
+              link_to order.user.email, (edit_admin_user_path(order.user) rescue admin_user_path(order.user) rescue '#')
             end
-          end
 
-          table_column :purchase_state, filter: { type: :select, values: [%w(abandoned abandoned), [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED], [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED]], selected: EffectiveOrders::PURCHASED } do |order|
-            order.purchase_state || 'abandoned'
-          end
+            if EffectiveOrders.use_address_full_name
+              table_column :buyer_name, column: 'addresses.full_name' do |order|
+                order.billing_address.try(:full_name)
+              end
 
-          table_column :items, label: 'Order Items', sortable: false, column: query_items_list do |order|
-            content_tag(:ul) do
-              (order[:items] || '').split('!!SEP!!').map { |oi| content_tag(:li, oi.to_s.html_safe) }.join.html_safe
+            elsif # Not using address full name
+              table_column :buyer_name, column: 'users.*' do |order|
+                order.user.to_s
+              end
             end
           end
 
-          table_column(:total) { |order| price_to_currency(order[:total].to_i) }
-          table_column :payment_method
+          if EffectiveOrders.require_billing_address
+            table_column :billing_address
+          end
 
-          table_column :created_at, :visible => false
-          table_column :updated_at, :visible => false
+          if EffectiveOrders.require_shipping_address
+            table_column :shipping_address
+          end
 
-          table_column :actions, sortable: false, filter: false do |order|
-            link_to('View', (datatables_admin_path? ? effective_orders.admin_order_path(order) : effective_orders.order_path(order)))
+          table_column :purchase_state, label: 'State', filter: { values: purchase_state_filter_values } do |order|
+            order.purchase_state || 'abandoned'
           end
-        end
 
-        def collection
-          collection = Effective::Order.unscoped
-            .joins(:user, :order_items)
-            .group('users.email, orders.id')
-            .select('orders.*, users.email AS email')
-            .select("#{query_total} AS total")
-            .select("#{query_items_list} AS items")
-            .select("#{query_payment_method} AS payment_method")
-
-          if EffectiveOrders.require_billing_address && defined?(EffectiveAddresses)
-            addresses_tbl = EffectiveAddresses.addresses_table_name
-
-            collection = collection
-              .joins("LEFT JOIN (SELECT addressable_id, string_agg(#{addresses_tbl}.full_name, '!!SEP!!') AS buyer_name FROM #{addresses_tbl} WHERE #{addresses_tbl}.category = 'billing' AND #{addresses_tbl}.addressable_type = 'Effective::Order' GROUP BY #{addresses_tbl}.addressable_id) #{addresses_tbl} ON orders.id = #{addresses_tbl}.addressable_id")
-              .group("#{addresses_tbl}.buyer_name")
-              .select("#{addresses_tbl}.buyer_name AS buyer_name")
+          table_column :order_items, column: 'order_items.title', filter: :string
+
+          table_column :subtotal, as: :price
+          table_column :tax, as: :price
+
+          table_column :tax_rate, visible: false do |order|
+            tax_rate_to_percentage(order.tax_rate)
           end
 
-          attributes[:user_id].present? ? collection.where(user_id: attributes[:user_id]) : collection
-        end
+          table_column :total, as: :price
 
-        def query_subtotal
-          'SUM(order_items.price * order_items.quantity)'
-        end
+          table_column :payment_provider, label: 'Provider', visible: false, filter: { values: ['nil'] + EffectiveOrders.payment_providers }
+          table_column :payment_card, label: 'Card'
 
-        def query_tax
-          'SUM(CASE order_items.tax_exempt WHEN true THEN 0 ELSE ((order_items.price * order_items.quantity) * order_items.tax_rate) END)'
-        end
+          table_column :note, visible: false
 
-        def query_total
-          'SUM((order_items.price * order_items.quantity) + (CASE order_items.tax_exempt WHEN true THEN 0 ELSE ((order_items.price * order_items.quantity) * order_items.tax_rate) END))'
-        end
+          table_column :created_at, visible: false
+          table_column :updated_at, visible: false
 
-        def query_items_list
-          "string_agg(order_items.title, '!!SEP!!')"
+          table_column :actions, sortable: false, filter: false, partial: 'admin/orders/actions'
         end
 
-        def query_payment_method
-          "COALESCE(SUBSTRING(payment FROM 'card: (\\w{1,2})\\n'), SUBSTRING(payment FROM 'action: (\\w+)_postback\\n'))"
-        end
+        def collection
+          collection = Effective::Order.unscoped
+            .joins(:user)
+            .includes(:addresses)
+            .includes(:user)
+            .includes(:order_items)
 
-        def search_column(collection, table_column, search_term)
-          case table_column[:name]
-          when 'subtotal'
-            then collection.having("#{query_subtotal} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-          when 'tax'
-            then collection.having("#{query_tax} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-          when 'total'
-            then collection.having("#{query_total} = ?", (search_term.gsub(/[^0-9.]/, '').to_f * 100.0).to_i)
-          when 'purchase_state'
-            then search_term == 'abandoned' ? collection.where(purchase_state: nil) : super
-          when 'items'
-            then collection.having("#{query_items_list} ILIKE ?", "%#{search_term}%")
-          when 'payment_method'
-            then collection.having("#{query_payment_method} LIKE ?", "#{search_term}%")
-          else
-            super
+          if EffectiveOrders.orders_collection_scope.respond_to?(:call)
+            collection = EffectiveOrders.orders_collection_scope.call(collection)
           end
+
+          attributes[:user_id].present? ? collection.where(user_id: attributes[:user_id]) : collection
+        end
+
+        def purchase_state_filter_values
+          [
+            %w(abandoned nil),
+            [EffectiveOrders::PURCHASED, EffectiveOrders::PURCHASED],
+            [EffectiveOrders::DECLINED, EffectiveOrders::DECLINED],
+            [EffectiveOrders::PENDING, EffectiveOrders::PENDING]
+          ]
         end
       end
     end

data/app/models/effective/order.rb

@@ -3,52 +3,120 @@ module Effective
     self.table_name = EffectiveOrders.orders_table_name.to_s
 
     if EffectiveOrders.obfuscate_order_ids
-      acts_as_obfuscated :format => '###-####-###'
+      acts_as_obfuscated format: '###-####-###'
     end
 
-    acts_as_addressable :billing => {:singular => true, :presence => EffectiveOrders.require_billing_address, :use_full_name => EffectiveOrders.use_address_full_name}, :shipping => {:singular => true, :presence => EffectiveOrders.require_shipping_address, :use_full_name => EffectiveOrders.use_address_full_name}
-    attr_accessor :save_billing_address, :save_shipping_address, :shipping_address_same_as_billing # save these addresses to the user if selected
+    acts_as_addressable(
+      :billing => { singular: true, use_full_name: EffectiveOrders.use_address_full_name },
+      :shipping => { singular: true, use_full_name: EffectiveOrders.use_address_full_name }
+    )
 
-    belongs_to :user  # This is the user who purchased the order
-    has_many :order_items, :inverse_of => :order
+    attr_accessor :save_billing_address, :save_shipping_address, :shipping_address_same_as_billing # save these addresses to the user if selected
+    attr_accessor :send_payment_request_to_buyer # Used by the /admin/orders/new form. Should the payment request email be sent after creating an order?
+    attr_accessor :skip_buyer_validations # Enabled by the /admin/orders/create action
+
+    belongs_to :user, validate: false  # This is the user who purchased the order. We validate it below.
+    has_many :order_items, inverse_of: :order
+
+    # structure do
+    #   purchase_state    :string
+    #   purchased_at      :datetime
+    #
+    #   note              :text
+    #
+    #   payment           :text   # serialized hash containing all the payment details.  see below.
+    #
+    #   payment_provider  :string
+    #   payment_card      :string
+    #
+    #   tax_rate          :decimal, precision: 6, scale: 3
+    #
+    #   subtotal          :integer
+    #   tax               :integer
+    #   total             :integer
+    #
+    #   timestamps
+    # end
+
+    accepts_nested_attributes_for :order_items, allow_destroy: false, reject_if: :all_blank
+    accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
+
+    before_validation { assign_totals! }
+    before_save { assign_totals! unless self[:total].present? } # Incase we save!(validate: false)
 
-    structure do
-      payment         :text   # serialized hash, see below
-      purchase_state  :string, :validates => [:inclusion => {:in => [nil, EffectiveOrders::PURCHASED, EffectiveOrders::DECLINED]}]
-      purchased_at    :datetime, :validates => [:presence => {:if => Proc.new { |order| order.purchase_state == EffectiveOrders::PURCHASED}}]
+    unless EffectiveOrders.skip_user_validation
+      validates :user_id, presence: true, unless: Proc.new { |order| order.skip_buyer_validations? }
+      validates :user, associated: true, unless: Proc.new { |order| order.skip_buyer_validations? }
+    end
 
-      timestamps
+    if EffectiveOrders.collect_note_required
+      validates :note, presence: true, unless: Proc.new { |order| order.skip_buyer_validations? }
     end
 
-    accepts_nested_attributes_for :order_items, :allow_destroy => false, :reject_if => :all_blank
-    accepts_nested_attributes_for :user, :allow_destroy => false, :update_only => true
+    validates :tax_rate, presence: { message: "can't be determined based on billing address" }, unless: Proc.new { |order| order.skip_buyer_validations? }
+    validates :tax, presence: true, unless: Proc.new { |order| order.skip_buyer_validations? }
 
-    unless EffectiveOrders.skip_user_validation
-      validates_presence_of :user_id
-      validates_associated :user
+    if EffectiveOrders.require_billing_address  # An admin creating a new pending order should not be required to have addresses
+      validates :billing_address, presence: true, unless: Proc.new { |order| order.new_record? && order.pending? }
+    end
+
+    if EffectiveOrders.require_shipping_address  # An admin creating a new pending order should not be required to have addresses
+      validates :shipping_address, presence: true, unless: Proc.new { |order| order.new_record? && order.pending? }
     end
 
     if ((minimum_charge = EffectiveOrders.minimum_charge.to_i) rescue nil).present?
       if EffectiveOrders.allow_free_orders
-        validates_numericality_of :total, :greater_than_or_equal_to => minimum_charge, :unless => Proc.new { |order| order.total == 0 }, :message => "A minimum order of #{EffectiveOrders.minimum_charge} is required.  Please add additional items to your cart."
+        validates :total, numericality: {
+          greater_than_or_equal_to: minimum_charge,
+          message: "A minimum order of #{EffectiveOrders.minimum_charge} is required.  Please add additional items to your cart."
+        }, unless: Proc.new { |order| order.total == 0 }
       else
-        validates_numericality_of :total, :greater_than_or_equal_to => minimum_charge, :message => "A minimum order of #{EffectiveOrders.minimum_charge} is required.  Please add additional items to your cart."
+        validates :total, numericality: {
+          greater_than_or_equal_to: minimum_charge,
+          message: "A minimum order of #{EffectiveOrders.minimum_charge} is required.  Please add additional items to your cart."
+        }
       end
     end
 
-    validates_presence_of :order_items, :message => 'No items are present.  Please add one or more item to your cart.'
-    validates_associated :order_items
+    validates :purchase_state, inclusion: { in: [nil, EffectiveOrders::PURCHASED, EffectiveOrders::DECLINED, EffectiveOrders::PENDING] }
 
-    serialize :payment, Hash
+    validates :subtotal, presence: true
+    validates :total, presence: true
 
-    default_scope -> { includes(:user).includes(:order_items => :purchasable).order('created_at DESC') }
+    validates :order_items, presence: { message: 'No items are present.  Please add one or more item to your cart.' }
+    validates :order_items, associated: true
 
-    scope :purchased, -> { where(:purchase_state => EffectiveOrders::PURCHASED) }
-    scope :purchased_by, lambda { |user| purchased.where(:user_id => user.try(:id)) }
-    scope :declined, -> { where(:purchase_state => EffectiveOrders::DECLINED) }
+    with_options if: Proc.new { |order| order.purchased? } do |order|
+      order.validates :purchased_at, presence: true
+      order.validates :payment, presence: true
+
+      order.validates :payment_provider, presence: true, inclusion: { in: EffectiveOrders.payment_providers }
+      order.validates :payment_card, presence: true
+    end
 
-    # Can be an Effective::Cart, a single acts_as_purchasable, or an array of acts_as_purchasables
-    def initialize(items = {}, user = nil)
+    serialize :payment, Hash
+
+    default_scope -> { includes(:user).includes(order_items: :purchasable).order(created_at: :desc) }
+
+    scope :purchased, -> { 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 :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 }))
+    }
+
+    # Effective::Order.new()
+    # Effective::Order.new(Product.first)
+    # Effective::Order.new(Product.all)
+    # Effective::Order.new(Product.first, user: User.first)
+    # Effective::Order.new(Product.first, Product.second, user: User.first)
+    # Effective::Order.new(user: User.first)
+    # Effective::Order.new(current_cart)
+
+    # items can be an Effective::Cart, a single acts_as_purchasable, or an array of acts_as_purchasables
+    def initialize(*items, user: nil, billing_address: nil, shipping_address: nil)
       super() # Call super with no arguments
 
       # Set up defaults
@@ -56,36 +124,49 @@ module Effective
       self.save_shipping_address = true
       self.shipping_address_same_as_billing = true
 
-      self.user = (items.delete(:user) if items.kind_of?(Hash)) || user
-      add_to_order(items) if items.present?
+      self.user = user || (items.first.user if items.first.kind_of?(Effective::Cart))
+
+      if billing_address
+        self.billing_address = billing_address
+        self.billing_address.full_name ||= billing_name
+      end
+
+      if shipping_address
+        self.shipping_address = shipping_address
+        self.shipping_address.full_name ||= billing_name
+      end
+
+      add(items) if items.present?
     end
 
-    def add(item, quantity = 1)
+    # add(Product.first) => returns an Effective::OrderItem
+    # add(Product.first, current_cart) => returns an array of Effective::OrderItems
+    def add(*items, quantity: 1)
       raise 'unable to alter a purchased order' if purchased?
       raise 'unable to alter a declined order' if declined?
 
-      if item.kind_of?(Effective::Cart)
-        cart_items = item.cart_items
-      else
-        purchasables = [item].flatten
-
-        if purchasables.any? { |p| !p.respond_to?(:is_effectively_purchasable?) }
-          raise ArgumentError.new('Effective::Order.add() expects a single acts_as_purchasable item, or an array of acts_as_purchasable items')
-        end
-
-        cart_items = purchasables.map do |purchasable|
-          CartItem.new(:quantity => quantity).tap { |cart_item| cart_item.purchasable = purchasable }
+      cart_items = items.flatten.flat_map do |item|
+        if item.kind_of?(Effective::Cart)
+          item.cart_items.to_a
+        elsif item.kind_of?(ActsAsPurchasable)
+          Effective::CartItem.new(quantity: quantity.to_i).tap { |cart_item| cart_item.purchasable = item }
+        else
+          raise ArgumentError.new('Effective::Order.add() expects one or more acts_as_purchasable objects, or an Effective::Cart')
         end
       end
 
+      # Make sure to reset stored aggregates
+      self.total = nil
+      self.subtotal = nil
+      self.tax = nil
+
       retval = cart_items.map do |item|
         order_items.build(
-          :title => item.title,
-          :quantity => item.quantity,
-          :price => item.price,
-          :tax_exempt => item.tax_exempt,
-          :tax_rate => item.tax_rate,
-          :seller_id => (item.purchasable.try(:seller).try(:id) rescue nil)
+          title: item.title,
+          quantity: item.quantity,
+          price: item.price,
+          tax_exempt: item.tax_exempt || false,
+          seller_id: (item.purchasable.try(:seller).try(:id) rescue nil)
         ).tap { |order_item| order_item.purchasable = item.purchasable }
       end
 
@@ -99,11 +180,11 @@ module Effective
       super
 
       # Copy user addresses into this order if they are present
-      if user.respond_to?(:billing_address) && !user.billing_address.nil?
+      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.nil?
+      if user.respond_to?(:shipping_address) && user.shipping_address.present?
         self.shipping_address = user.shipping_address
       end
 
@@ -117,15 +198,30 @@ module Effective
       end
 
       # Ensure the Full Name is assigned when an address exists
-      if billing_address.nil? == false && billing_address.full_name.blank?
+      if billing_address.present? && billing_address.full_name.blank?
         self.billing_address.full_name = billing_name
       end
 
-      if shipping_address.nil? == false && shipping_address.full_name.blank?
+      if shipping_address.present? && shipping_address.full_name.blank?
         self.shipping_address.full_name = billing_name
       end
     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
+      self.purchase_state = EffectiveOrders::PENDING
+
+      self.skip_buyer_validations = true
+      self.addresses.clear if addresses.any? { |address| address.valid? == false }
+
+      return false unless save
+
+      send_payment_request_to_buyer! if send_payment_request_to_buyer?
+      true
+    end
+
     # This is used for updating Subscription codes.
     # We want to update the underlying purchasable object of an OrderItem
     # Passing the order_item_attributes using rails default acts_as_nested creates a new object instead of updating the temporary one.
@@ -144,27 +240,34 @@ module Effective
             order_item.title = order_item.purchasable.title
             order_item.price = order_item.purchasable.price
             order_item.tax_exempt = order_item.purchasable.tax_exempt
-            order_item.tax_rate = order_item.purchasable.tax_rate
             order_item.seller_id = (order_item.purchasable.try(:seller).try(:id) rescue nil)
           end
         end
       end
     end
 
-    def total
-      [order_items.map(&:total).sum, 0].max
+    def purchasables
+      order_items.map { |order_item| order_item.purchasable }
     end
 
-    def subtotal
-      order_items.map(&:subtotal).sum
+    def tax_rate
+      self[:tax_rate] || get_tax_rate()
     end
 
     def tax
-      [order_items.map(&:tax).sum, 0].max
+      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), 0].max
     end
 
     def num_items
-      order_items.map(&:quantity).sum
+      order_items.map { |oi| oi.quantity }.sum
     end
 
     def save_billing_address?
@@ -175,12 +278,16 @@ module Effective
       ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.save_shipping_address)
     end
 
+    def send_payment_request_to_buyer?
+      ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.send_payment_request_to_buyer)
+    end
+
     def shipping_address_same_as_billing?
-      if self.shipping_address_same_as_billing.nil?
-        true # Default value
-      else
-        ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.shipping_address_same_as_billing)
-      end
+      ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.shipping_address_same_as_billing)
+    end
+
+    def skip_buyer_validations?
+      ::ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include?(self.skip_buyer_validations)
     end
 
     def billing_name
@@ -193,103 +300,74 @@ module Effective
       name
     end
 
-    # :validate => false, :email => false
-    def purchase!(payment_details = nil, opts = {})
-      opts = {validate: true, email: true}.merge(opts)
-
+    # Effective::Order.new(Product.first, user: User.first).purchase!(details: 'manual purchase')
+    # order.purchase!(details: {key: value})
+    def purchase!(details: 'none', provider: 'admin', card: 'none', validate: true, email: true, skip_buyer_validations: false)
       return false if purchased?
-      raise EffectiveOrders::AlreadyDeclinedException.new('order already declined') if (declined? && opts[:validate])
 
       success = false
 
-      Order.transaction do
+      Effective::Order.transaction do
         begin
           self.purchase_state = EffectiveOrders::PURCHASED
           self.purchased_at ||= Time.zone.now
-          self.payment = payment_details.kind_of?(Hash) ? payment_details : {:details => (payment_details || 'none').to_s}
 
-          save!(validate: opts[:validate])
+          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'
+
+          save!(validate: validate)
 
           order_items.each { |item| (item.purchasable.purchased!(self, item) rescue nil) }
 
           success = true
         rescue => e
-          raise ActiveRecord::Rollback
+          raise ::ActiveRecord::Rollback
         end
       end
 
-      send_order_receipts! if success && opts[:email]
+      send_order_receipts! if (success && email)
 
+      raise "Failed to purchase Effective::Order: #{self.errors.full_messages.to_sentence}" unless success
       success
     end
 
-    def decline!(payment_details = nil)
+    def decline!(details: 'none', provider: 'admin', card: 'none', validate: true)
       return false if declined?
 
       raise EffectiveOrders::AlreadyPurchasedException.new('order already purchased') if purchased?
 
-      Order.transaction do
-        self.purchase_state = EffectiveOrders::DECLINED
-        self.payment = payment_details.kind_of?(Hash) ? payment_details : {:details => (payment_details || 'none').to_s}
-
-        order_items.each { |item| (item.purchasable.declined!(self, item) rescue nil) }
+      success = false
 
-        save!
-      end
-    end
+      Effective::Order.transaction do
+        begin
+          self.purchase_state = EffectiveOrders::DECLINED
+          self.purchased_at = nil
 
-    def purchase_method
-      return 'None' unless purchased?
+          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'
 
-      if purchased?(:stripe_connect)
-        'Stripe Connect'
-      elsif purchased?(:stripe)
-        'Stripe'
-      elsif purchased?(:moneris)
-        'Moneris'
-      elsif purchased?(:paypal)
-        'PayPal'
-      else
-        'Online'
-      end
-    end
-    alias_method :payment_method, :purchase_method
+          save!(validate: validate)
 
-    def purchase_card_type
-      return 'None' unless purchased?
+          order_items.each { |item| (item.purchasable.declined!(self, item) rescue nil) }
 
-      if purchased?(:stripe_connect)
-        ((payment[:charge] || payment['charge'])['card']['brand'] rescue 'Unknown')
-      elsif purchased?(:stripe)
-        ((payment[:charge] || payment['charge'])['card']['brand'] rescue 'Unknown')
-      elsif purchased?(:moneris)
-        payment[:card] || payment['card'] || 'Unknown'
-      elsif purchased?(:paypal)
-        payment[:payment_type] || payment['payment_type'] || 'Unknown'
-      else
-        'Online'
+          success = true
+        rescue => e
+          raise ::ActiveRecord::Rollback
+        end
       end
+
+      raise "Failed to decline! Effective::Order: #{self.errors.full_messages.to_sentence}" unless success
+      success
     end
-    alias_method :payment_card_type, :purchase_card_type
 
     def purchased?(provider = nil)
       return false if (purchase_state != EffectiveOrders::PURCHASED)
-      return true if provider == nil || payment.kind_of?(Hash) == false
-
-      case provider.to_sym
-      when :stripe_connect
-        charge = (payment[:charge] || payment['charge'] || {})
-        charge['id'] && charge['customer'] && charge['application_fee'].present?
-      when :stripe
-        charge = (payment[:charge] || payment['charge'] || {})
-        charge['id'] && charge['customer']
-      when :moneris
-        (payment[:response_code] || payment['response_code']) &&
-        (payment[:transactionKey] || payment['transactionKey'])
-      when :paypal
-        (payment[:payer_email] || payment['payer_email'])
-      else
-        raise "Unknown provider #{provider} passed to Effective::Order.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
 
@@ -297,41 +375,74 @@ module Effective
       purchase_state == EffectiveOrders::DECLINED
     end
 
+    def pending?
+      purchase_state == EffectiveOrders::PENDING
+    end
+
     def send_order_receipts!
-      send_order_receipt_to_admin!
-      send_order_receipt_to_buyer!
-      send_order_receipt_to_seller!
+      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!
-      return false unless purchased? && EffectiveOrders.mailer[:send_order_receipt_to_admin]
-      send_email(:order_receipt_to_admin, self)
+      send_email(:order_receipt_to_admin, to_param) if purchased?
     end
 
     def send_order_receipt_to_buyer!
-      return false unless purchased? && EffectiveOrders.mailer[:send_order_receipt_to_buyer]
-
-      send_email(:order_receipt_to_buyer, self)
+      send_email(:order_receipt_to_buyer, to_param) if purchased?
     end
 
     def send_order_receipt_to_seller!
-      return false unless purchased?(:stripe_connect) && EffectiveOrders.mailer[:send_order_receipt_to_seller]
+      return false unless (EffectiveOrders.stripe_connect_enabled && purchased?(:stripe_connect))
 
       order_items.group_by(&:seller).each do |seller, order_items|
-        send_email(:order_receipt_to_seller, self, seller, order_items)
+        send_email(:order_receipt_to_seller, to_param, seller, order_items)
       end
     end
 
-  private
+    def send_payment_request_to_buyer!
+      send_email(:payment_request_to_buyer, to_param) if !purchased?
+    end
+
+    def send_pending_order_invoice_to_buyer!
+      send_email(:pending_order_invoice_to_buyer, to_param) if !purchased?
+    end
+
+    protected
+
+    def get_tax_rate
+      self.instance_exec(self, &EffectiveOrders.order_tax_rate_method).tap do |rate|
+        rate = rate.to_f
+        if (rate > 100.0 || (rate < 0.25 && rate > 0.0000))
+          raise "expected EffectiveOrders.order_tax_rate_method to return a value between 100.0 (100%) and 0.25 (0.25%) or 0 or nil. Received #{rate}. Please return 5.25 for 5.25% tax."
+        end
+      end
+    end
+
+    def get_tax
+      return nil unless tax_rate.present?
+      amount = order_items.reject { |oi| oi.tax_exempt? }.map { |oi| (oi.subtotal * (tax_rate / 100.0)).round(0).to_i }.sum
+      [amount, 0].max
+    end
+
+    private
+
+    def assign_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), 0].max
+    end
 
     def send_email(email, *mailer_args)
       begin
         if EffectiveOrders.mailer[:delayed_job_deliver] && EffectiveOrders.mailer[:deliver_method] == :deliver_later
-          (OrdersMailer.delay.public_send(email, *mailer_args) rescue false)
+          Effective::OrdersMailer.delay.public_send(email, *mailer_args)
         elsif EffectiveOrders.mailer[:deliver_method].present?
-          (OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method]) rescue false)
+          Effective::OrdersMailer.public_send(email, *mailer_args).public_send(EffectiveOrders.mailer[:deliver_method])
         else
-          (OrdersMailer.public_send(email, *mailer_args).deliver_now) rescue false
+          Effective::OrdersMailer.public_send(email, *mailer_args).deliver_now
         end
       rescue => e
         raise e unless Rails.env.production?