effective_orders 2.2.4 → 3.0.0

data/app/models/effective/order.rb

@@ -7,90 +7,88 @@ module Effective
     end
 
     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 }
+      billing: { singular: true, use_full_name: EffectiveOrders.use_address_full_name },
+      shipping: { singular: true, use_full_name: EffectiveOrders.use_address_full_name }
     )
 
-    attr_accessor :save_billing_address, :save_shipping_address # save these addresses to the user if selected
     attr_accessor :terms_and_conditions # Yes, I agree to the terms and conditions
 
     # Settings in the /admin action forms
-    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 :send_mark_as_paid_email_to_buyer  # Used by the /admin/orders/mark_as_paid action
-    attr_accessor :skip_buyer_validations # Enabled by the /admin/orders/create action
+    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 user who purchased the order. We validate it below.
-    has_many :order_items, inverse_of: :order
+    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'
 
-    # structure do
-    #   purchase_state    :string
-    #   purchased_at      :datetime
+    accepts_nested_attributes_for :order_items, allow_destroy: false, reject_if: :all_blank
+    accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
+
+    # Attributes
+    # purchase_state    :string
+    # purchased_at      :datetime
     #
-    #   note              :text
+    # note_to_buyer     :text
+    # note_internal     :text
     #
-    #   payment           :text   # serialized hash containing all the payment details.  see below.
+    # payment           :text   # serialized hash containing all the payment details.  see below.
     #
-    #   payment_provider  :string
-    #   payment_card      :string
+    # payment_provider  :string
+    # payment_card      :string
     #
-    #   tax_rate          :decimal, precision: 6, scale: 3
+    # tax_rate          :decimal, precision: 6, scale: 3
     #
-    #   subtotal          :integer
-    #   tax               :integer
-    #   total             :integer
+    # subtotal          :integer
+    # tax               :integer
+    # total             :integer
     #
-    #   timestamps
-    # end
+    # timestamps
 
-    accepts_nested_attributes_for :order_items, allow_destroy: false, reject_if: :all_blank
-    accepts_nested_attributes_for :user, allow_destroy: false, update_only: true
+    serialize :payment, Hash
 
     before_validation { assign_totals! }
-    before_save { assign_totals! unless self[:total].present? } # Incase we save!(validate: false)
-
-    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
-
-    if EffectiveOrders.collect_note_required
-      validates :note, presence: true, unless: Proc.new { |order| order.skip_buyer_validations? }
-    end
 
-    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? }
+    # Order validations
+    validates :order_items, presence: { message: 'No items are present. Please add additional items.' }
+    validates :purchase_state, inclusion: { in: EffectiveOrders::PURCHASE_STATES.keys }
+    validates :subtotal, presence: true
 
-    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?) || order.skip_buyer_validations? }
+    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?)
+      }
     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?) || order.skip_buyer_validations? }
-    end
+    # User validations -- An admin skips these when working in the admin/ namespace
+    with_options unless: -> { skip_buyer_validations? } do |order|
+      order.validates :tax_rate, presence: { message: "can't be determined based on billing address" }
+      order.validates :tax, presence: true
 
-    if ((minimum_charge = EffectiveOrders.minimum_charge.to_i) rescue nil).present?
-      if EffectiveOrders.allow_free_orders
-        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 :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 EffectiveOrders.skip_user_validation
+        order.validates :user_id, presence: true
+        order.validates :user, associated: true
       end
-    end
 
-    validates :purchase_state, inclusion: { in: [nil, EffectiveOrders::PURCHASED, EffectiveOrders::DECLINED, EffectiveOrders::PENDING] }
+      if EffectiveOrders.require_billing_address
+        order.validates :billing_address, presence: true
+      end
 
-    validates :subtotal, presence: true
-    validates :total, presence: true
+      if EffectiveOrders.require_shipping_address
+        order.validates :shipping_address, presence: true
+      end
 
-    validates :order_items, presence: { message: 'No items are present.  Please add one or more item to your cart.' }
-    validates :order_items, associated: true
+      if EffectiveOrders.collect_note_required
+        order.validates :note, presence: true
+      end
+    end
 
-    with_options if: Proc.new { |order| order.purchased? } do |order|
+    # When Purchased
+    with_options if: -> { purchased? } do |order|
       order.validates :purchased_at, presence: true
       order.validates :payment, presence: true
 
@@ -98,14 +96,17 @@ module Effective
       order.validates :payment_card, presence: true
     end
 
-    serialize :payment, Hash
+    before_save { assign_totals! unless self[:total].present? } # Incase we save!(validate: false)
+    before_save :save_addresses
 
-    default_scope -> { includes(:user).includes(order_items: :purchasable).order(created_at: :desc) }
+    scope :deep, -> { includes(:user).includes(order_items: :purchasable) }
+    scope :sorted, -> { order(created_at: :desc) }
 
-    scope :purchased, -> { where(purchase_state: EffectiveOrders::PURCHASED) }
+    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 :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 }))
@@ -123,21 +124,12 @@ module Effective
     def initialize(*items, user: nil, billing_address: nil, shipping_address: nil)
       super() # Call super with no arguments
 
-      # Set up defaults
-      self.save_billing_address = true
-      self.save_shipping_address = true
-
+      # Assign user
       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
+      # Assign addresses
+      self.billing_address = billing_address if billing_address
+      self.shipping_address = shipping_address if shipping_address
 
       add(items) if items.present?
     end
@@ -152,11 +144,20 @@ module Effective
         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 }
+          Effective::CartItem.new(quantity: quantity, purchasable: item)
+        elsif item.kind_of?(Effective::Order)
+          # Duplicate an existing order
+          self.note_to_buyer ||= item.note_to_buyer
+          self.note_internal ||= item.note_internal
+
+          item.order_items.select { |oi| oi.purchasable.kind_of?(Effective::Product) }.map do |oi|
+            product = Effective::Product.new(title: oi.purchasable.title, price: oi.purchasable.price, tax_exempt: oi.purchasable.tax_exempt)
+            Effective::CartItem.new(quantity: oi.quantity, purchasable: product)
+          end
         else
-          raise ArgumentError.new('Effective::Order.add() expects one or more acts_as_purchasable objects, or an Effective::Cart')
+          raise 'add() expects one or more acts_as_purchasable objects, or an Effective::Cart'
         end
-      end
+      end.compact
 
       # Make sure to reset stored aggregates
       self.total = nil
@@ -175,13 +176,12 @@ module Effective
 
       retval.size == 1 ? retval.first : retval
     end
-    alias_method :add_to_order, :add
 
     def user=(user)
-      return if user.nil?
-
       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
@@ -191,64 +191,47 @@ module Effective
         self.shipping_address = user.shipping_address
       end
 
-      # If our addresses are required, make sure they exist
-      if EffectiveOrders.require_billing_address
-        self.billing_address ||= Effective::Address.new()
-      end
-
-      if EffectiveOrders.require_shipping_address
-        self.shipping_address ||= Effective::Address.new()
-      end
-
-      # Ensure the Full Name is assigned when an address exists
-      if billing_address.present? && billing_address.full_name.blank?
-        self.billing_address.full_name = billing_name
-      end
-
-      if shipping_address.present? && shipping_address.full_name.blank?
-        self.shipping_address.full_name = billing_name
-      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
+    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 }
 
-      return false unless save
+      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.
-    # So we override this method to do the updates on the non-persisted OrderItem objects
-    # Right now strong_paramaters only lets through stripe_coupon_id
-    # {"0"=>{"class"=>"Effective::Subscription", "stripe_coupon_id"=>"50OFF", "id"=>"2"}}}
-    def order_items_attributes=(order_item_attributes)
-      if self.persisted? == false
-        (order_item_attributes || {}).each do |_, atts|
-          order_item = self.order_items.find { |oi| oi.purchasable.class.name == atts[:class] && oi.purchasable.id == atts[:id].to_i }
-
-          if order_item
-            order_item.purchasable.attributes = atts.except(:id, :class)
-
-            # Recalculate the OrderItem based on the updated purchasable object
-            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.seller_id = (order_item.purchasable.try(:seller).try(:id) rescue nil)
-          end
-        end
+    def to_s
+      if refund?
+        "Refund ##{to_param}"
+      elsif purchased?
+        "Receipt ##{to_param}"
+      elsif pending?
+        "Pending Order ##{to_param}"
+      else
+        "Order ##{to_param}"
       end
     end
 
+    def free?
+      total == 0
+    end
+
+    def refund?
+      total.to_i < 0
+    end
+
     def purchasables
       order_items.map { |order_item| order_item.purchasable }
     end
@@ -266,31 +249,27 @@ module Effective
     end
 
     def total
-      self[:total] || [(subtotal + tax.to_i), 0].max
+      (self[:total] || (subtotal + tax.to_i)).to_i
     end
 
     def num_items
       order_items.map { |oi| oi.quantity }.sum
     end
 
-    def save_billing_address?
-      truthy?(self.save_billing_address)
-    end
-
-    def save_shipping_address?
-      truthy?(self.save_shipping_address)
-    end
-
     def send_payment_request_to_buyer?
-      truthy?(self.send_payment_request_to_buyer)
+      truthy?(send_payment_request_to_buyer)
     end
 
     def send_mark_as_paid_email_to_buyer?
-      truthy?(self.send_mark_as_paid_email_to_buyer)
+      truthy?(send_mark_as_paid_email_to_buyer)
     end
 
     def skip_buyer_validations?
-      truthy?(self.skip_buyer_validations)
+      truthy?(skip_buyer_validations)
+    end
+
+    def skip_minimum_charge_validation?
+      truthy?(skip_minimum_charge_validation) || skip_buyer_validations?
     end
 
     def billing_name
@@ -309,6 +288,7 @@ module Effective
       return false if purchased?
 
       success = false
+      error = nil
 
       Effective::Order.transaction do
         begin
@@ -321,23 +301,27 @@ module Effective
 
           self.skip_buyer_validations = skip_buyer_validations
 
-          save!(validate: validate)
+          run_purchasable_callbacks(:before_purchase)
 
-          order_items.each { |item| (item.purchasable.purchased!(self, item) rescue nil) }
+          save!(validate: validate)
 
           success = true
         rescue => e
           self.purchase_state = purchase_state_was
           self.purchased_at = purchased_at_was
 
+          error = e.message
           raise ::ActiveRecord::Rollback
         end
       end
 
-      send_order_receipts! if (success && email)
+      raise "Failed to purchase Effective::Order: #{error || errors.full_messages.to_sentence}" unless success
+
+      send_order_receipts! if email
 
-      raise "Failed to purchase Effective::Order: #{self.errors.full_messages.to_sentence}" unless success
-      success
+      run_purchasable_callbacks(:after_purchase)
+
+      true
     end
 
     def decline!(details: 'none', provider: 'none', card: 'none', validate: true)
@@ -346,6 +330,7 @@ module Effective
       raise EffectiveOrders::AlreadyPurchasedException.new('order already purchased') if purchased?
 
       success = false
+      error = nil
 
       Effective::Order.transaction do
         begin
@@ -358,16 +343,25 @@ module Effective
 
           save!(validate: validate)
 
-          order_items.each { |item| (item.purchasable.declined!(self, item) rescue nil) }
-
           success = true
         rescue => e
+          self.purchase_state = purchase_state_was
+          self.purchased_at = purchased_at_was
+
+          error = e.message
           raise ::ActiveRecord::Rollback
         end
       end
 
-      raise "Failed to decline! Effective::Order: #{self.errors.full_messages.to_sentence}" unless success
-      success
+      raise "Failed to decline! Effective::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)
@@ -404,17 +398,17 @@ module Effective
     def 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|
+      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) if !purchased?
+      send_email(:payment_request_to_buyer, to_param) unless purchased?
     end
 
     def send_pending_order_invoice_to_buyer!
-      send_email(:pending_order_invoice_to_buyer, to_param) if !purchased?
+      send_email(:pending_order_invoice_to_buyer, to_param) unless purchased?
     end
 
     protected
@@ -430,8 +424,7 @@ module Effective
 
     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
+      order_items.reject { |oi| oi.tax_exempt? }.map { |oi| (oi.subtotal * (tax_rate / 100.0)).round(0).to_i }.sum
     end
 
     private
@@ -440,7 +433,27 @@ module Effective
       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
+      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
+      end
+
+      if user.respond_to?(:shipping_address=) && shipping_address.present?
+        user.shipping_address = shipping_address
+        user.shipping_address.save
+      end
+    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
     end
 
     def send_email(email, *mailer_args)