goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/order_contents.rb

@@ -0,0 +1,120 @@
+module Spree
+  class OrderContents
+    attr_accessor :order, :currency
+
+    def initialize(order)
+      @order = order
+    end
+
+    def add(variant, quantity = 1, options = {})
+      timestamp = Time.current
+      line_item = add_to_line_item(variant, quantity, options)
+      options[:line_item_created] = true if timestamp <= line_item.created_at
+      after_add_or_remove(line_item, options)
+    end
+
+    def remove(variant, quantity = 1, options = {})
+      line_item = remove_from_line_item(variant, quantity, options)
+      after_add_or_remove(line_item, options)
+    end
+
+    def remove_line_item(line_item, options = {})
+      line_item.destroy!
+      after_add_or_remove(line_item, options)
+    end
+
+    def update_cart(params)
+      if order.update_attributes(filter_order_items(params))
+        order.line_items = order.line_items.select { |li| li.quantity > 0 }
+        # Update totals, then check if the order is eligible for any cart promotions.
+        # If we do not update first, then the item total will be wrong and ItemTotal
+        # promotion rules would not be triggered.
+        persist_totals
+        PromotionHandler::Cart.new(order).activate
+        order.ensure_updated_shipments
+        persist_totals
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def after_add_or_remove(line_item, options = {})
+      persist_totals
+      shipment = options[:shipment]
+      shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
+      PromotionHandler::Cart.new(order, line_item).activate
+      Adjustable::AdjustmentsUpdater.update(line_item)
+      TaxRate.adjust(order, [line_item]) if options[:line_item_created]
+      persist_totals
+      line_item
+    end
+
+    def filter_order_items(params)
+      filtered_params = params.symbolize_keys
+      return filtered_params if filtered_params[:line_items_attributes].nil? || filtered_params[:line_items_attributes][:id]
+
+      line_item_ids = order.line_items.pluck(:id)
+
+      params[:line_items_attributes].each_pair do |id, value|
+        unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
+          filtered_params[:line_items_attributes].delete(id)
+        end
+      end
+      filtered_params
+    end
+
+    def order_updater
+      @updater ||= OrderUpdater.new(order)
+    end
+
+    def persist_totals
+      order_updater.update_item_count
+      order_updater.update
+    end
+
+    def add_to_line_item(variant, quantity, options = {})
+      line_item = grab_line_item_by_variant(variant, false, options)
+
+      if line_item
+        line_item.quantity += quantity.to_i
+        line_item.currency = currency unless currency.nil?
+      else
+        opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
+                                            permit(PermittedAttributes.line_item_attributes)
+        line_item = order.line_items.new(quantity: quantity,
+                                          variant: variant,
+                                          options: opts)
+      end
+      line_item.target_shipment = options[:shipment] if options.has_key? :shipment
+      line_item.save!
+      line_item
+    end
+
+    def remove_from_line_item(variant, quantity, options = {})
+      line_item = grab_line_item_by_variant(variant, true, options)
+      line_item.quantity -= quantity
+      line_item.target_shipment= options[:shipment]
+
+      if line_item.quantity.zero?
+        order.line_items.destroy(line_item)
+      else
+        line_item.save!
+      end
+
+      line_item
+    end
+
+    def grab_line_item_by_variant(variant, raise_error = false, options = {})
+      line_item = order.find_line_item_by_variant(variant, options)
+
+      if !line_item.present? && raise_error
+        raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
+      end
+
+      line_item
+    end
+  end
+end

data/app/models/spree/order_inventory.rb

@@ -0,0 +1,103 @@
+module Spree
+  class OrderInventory
+    attr_accessor :order, :line_item, :variant
+
+    def initialize(order, line_item)
+      @order = order
+      @line_item = line_item
+      @variant = line_item.variant
+    end
+
+    delegate :inventory_units, to: :line_item
+
+    # Only verify inventory for completed orders (as orders in frontend checkout
+    # have inventory assigned via +order.create_proposed_shipment+) or when
+    # shipment is explicitly passed
+    #
+    # In case shipment is passed the stock location should only unstock or
+    # restock items if the order is completed. That is so because stock items
+    # are always unstocked when the order is completed through +shipment.finalize+
+    def verify(shipment = nil)
+      if order.completed? || shipment.present?
+
+        if inventory_units.size < line_item.quantity
+          quantity = line_item.quantity - inventory_units.size
+
+          shipment = determine_target_shipment unless shipment
+          add_to_shipment(shipment, quantity)
+        elsif inventory_units.size > line_item.quantity
+          remove(inventory_units, shipment)
+        end
+      end
+    end
+
+    private
+      def remove(item_units, shipment = nil)
+        quantity = item_units.size - line_item.quantity
+
+        if shipment.present?
+          remove_from_shipment(shipment, quantity)
+        else
+          order.shipments.each do |shipment|
+            break if quantity == 0
+            quantity -= remove_from_shipment(shipment, quantity)
+          end
+        end
+      end
+
+      # Returns either one of the shipment:
+      #
+      # first unshipped that already includes this variant
+      # first unshipped that's leaving from a stock_location that stocks this variant
+      def determine_target_shipment
+        shipment = order.shipments.detect do |shipment|
+          shipment.ready_or_pending? && shipment.include?(variant)
+        end
+
+        shipment ||= order.shipments.detect do |shipment|
+          shipment.ready_or_pending? && variant.stock_location_ids.include?(shipment.stock_location_id)
+        end
+      end
+
+      def add_to_shipment(shipment, quantity)
+        if variant.should_track_inventory?
+          on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
+
+          on_hand.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+          back_order.times { shipment.set_up_inventory('backordered', variant, order, line_item) }
+        else
+          quantity.times { shipment.set_up_inventory('on_hand', variant, order, line_item) }
+        end
+
+        # adding to this shipment, and removing from stock_location
+        if order.completed?
+          shipment.stock_location.unstock(variant, quantity, shipment)
+        end
+
+        quantity
+      end
+
+      def remove_from_shipment(shipment, quantity)
+        return 0 if quantity == 0 || shipment.shipped?
+
+        shipment_units = shipment.inventory_units_for_item(line_item, variant).reject(&:shipped?).sort_by(&:state)
+
+        removed_quantity = 0
+
+        shipment_units.each do |inventory_unit|
+          break if removed_quantity == quantity
+          inventory_unit.destroy
+          removed_quantity += 1
+        end
+
+        shipment.destroy if shipment.inventory_units.count.zero?
+
+        # removing this from shipment, and adding to stock_location
+        if order.completed?
+          shipment.stock_location.restock variant, removed_quantity, shipment
+        end
+
+        removed_quantity
+      end
+  end
+end

data/app/models/spree/order_merger.rb

@@ -0,0 +1,65 @@
+module Spree
+  class OrderMerger
+    attr_accessor :order
+    delegate :updater, to: :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    def merge!(other_order, user = nil)
+      other_order.line_items.each do |other_order_line_item|
+        next unless other_order_line_item.currency == order.currency
+
+        current_line_item = find_matching_line_item(other_order_line_item)
+        handle_merge(current_line_item, other_order_line_item)
+      end
+
+      set_user(user)
+      persist_merge
+
+      # So that the destroy doesn't take out line items which may have been re-assigned
+      other_order.line_items.reload
+      other_order.destroy
+    end
+
+    # Compare the line item of the other order with mine.
+    # Make sure you allow any extensions to chime in on whether or
+    # not the extension-specific parts of the line item match
+    def find_matching_line_item(other_order_line_item)
+      order.line_items.detect do |my_li|
+        my_li.variant == other_order_line_item.variant &&
+          order.line_item_comparison_hooks.all? do |hook|
+            order.send(hook, my_li, other_order_line_item.serializable_hash)
+          end
+      end
+    end
+
+    def set_user(user = nil)
+      order.associate_user!(user) if !order.user && !user.blank?
+    end
+
+    # The idea is the end developer can choose to override the merge
+    # to their own choosing. Default is merge with errors.
+    def handle_merge(current_line_item, other_order_line_item)
+      if current_line_item
+        current_line_item.quantity += other_order_line_item.quantity
+        handle_error(current_line_item) unless current_line_item.save
+      else
+        other_order_line_item.order_id = order.id
+        handle_error(other_order_line_item) unless other_order_line_item.save
+      end
+    end
+
+    # Change the error messages as you choose.
+    def handle_error(line_item)
+      order.errors[:base] << line_item.errors.full_messages
+    end
+
+    def persist_merge
+      updater.update_item_count
+      updater.update_item_total
+      updater.persist_totals
+    end
+  end
+end

data/app/models/spree/order_promotion.rb

@@ -0,0 +1,6 @@
+module Spree
+  class OrderPromotion < Spree::Base
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :promotion, class_name: 'Spree::Promotion'
+  end
+end

data/app/models/spree/order_updater.rb

@@ -0,0 +1,177 @@
+module Spree
+  class OrderUpdater
+    attr_reader :order
+    delegate :payments, :line_items, :adjustments, :all_adjustments, :shipments, :update_hooks, :quantity, to: :order
+
+    def initialize(order)
+      @order = order
+    end
+
+    # This is a multi-purpose method for processing logic related to changes in the Order.
+    # It is meant to be called from various observers so that the Order is aware of changes
+    # that affect totals and other values stored in the Order.
+    #
+    # This method should never do anything to the Order that results in a save call on the
+    # object with callbacks (otherwise you will end up in an infinite recursion as the
+    # associations try to save and then in turn try to call +update!+ again.)
+    def update
+      update_item_count
+      update_totals
+      if order.completed?
+        update_payment_state
+        update_shipments
+        update_shipment_state
+        update_shipment_total
+      end
+      run_hooks
+      persist_totals
+    end
+
+    def run_hooks
+      update_hooks.each { |hook| order.send hook }
+    end
+
+    def recalculate_adjustments
+      all_adjustments.includes(:adjustable).map(&:adjustable).uniq.each do |adjustable|
+        Adjustable::AdjustmentsUpdater.update(adjustable)
+      end
+    end
+
+    # Updates the following Order total values:
+    #
+    # +payment_total+      The total value of all finalized Payments (NOTE: non-finalized Payments are excluded)
+    # +item_total+         The total value of all LineItems
+    # +adjustment_total+   The total value of all adjustments (promotions, credits, etc.)
+    # +promo_total+        The total value of all promotion adjustments
+    # +total+              The so-called "order total."  This is equivalent to +item_total+ plus +shipment_total+ plus +adjustment_total+.
+    def update_totals
+      update_payment_total
+      update_item_total
+      update_shipment_total
+      update_adjustment_total
+    end
+
+
+    # give each of the shipments a chance to update themselves
+    def update_shipments
+      shipments.each do |shipment|
+        next unless shipment.persisted?
+        shipment.update!(order)
+        shipment.refresh_rates
+        shipment.update_amounts
+      end
+    end
+
+    def update_payment_total
+      order.payment_total = payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }
+    end
+
+    def update_shipment_total
+      order.shipment_total = shipments.sum(:cost)
+      update_order_total
+    end
+
+    def update_order_total
+      order.total = order.item_total + order.shipment_total + order.adjustment_total
+    end
+
+    def update_adjustment_total
+      recalculate_adjustments
+      order.adjustment_total = line_items.sum(:adjustment_total) +
+                               shipments.sum(:adjustment_total)  +
+                               adjustments.eligible.sum(:amount)
+      order.included_tax_total = line_items.sum(:included_tax_total) + shipments.sum(:included_tax_total)
+      order.additional_tax_total = line_items.sum(:additional_tax_total) + shipments.sum(:additional_tax_total)
+
+      order.promo_total = line_items.sum(:promo_total) +
+                          shipments.sum(:promo_total) +
+                          adjustments.promotion.eligible.sum(:amount)
+
+      update_order_total
+    end
+
+    def update_item_count
+      order.item_count = quantity
+    end
+
+    def update_item_total
+      order.item_total = line_items.sum('price * quantity')
+      update_order_total
+    end
+
+    def persist_totals
+      order.update_columns(
+        payment_state: order.payment_state,
+        shipment_state: order.shipment_state,
+        item_total: order.item_total,
+        item_count: order.item_count,
+        adjustment_total: order.adjustment_total,
+        included_tax_total: order.included_tax_total,
+        additional_tax_total: order.additional_tax_total,
+        payment_total: order.payment_total,
+        shipment_total: order.shipment_total,
+        promo_total: order.promo_total,
+        total: order.total,
+        updated_at: Time.current,
+      )
+    end
+
+    # Updates the +shipment_state+ attribute according to the following logic:
+    #
+    # shipped   when all Shipments are in the "shipped" state
+    # partial   when at least one Shipment has a state of "shipped" and there is another Shipment with a state other than "shipped"
+    #           or there are InventoryUnits associated with the order that have a state of "sold" but are not associated with a Shipment.
+    # ready     when all Shipments are in the "ready" state
+    # backorder when there is backordered inventory associated with an order
+    # pending   when all Shipments are in the "pending" state
+    #
+    # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_shipment_state
+      if order.backordered?
+        order.shipment_state = 'backorder'
+      else
+        # get all the shipment states for this order
+        shipment_states = shipments.states
+        if shipment_states.size > 1
+          # multiple shiment states means it's most likely partially shipped
+          order.shipment_state = 'partial'
+        else
+          # will return nil if no shipments are found
+          order.shipment_state = shipment_states.first
+          # TODO inventory unit states?
+          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
+          #   shipments exist but there are unassigned inventory units
+          #   order.shipment_state = 'partial'
+          # end
+        end
+      end
+
+      order.state_changed('shipment')
+      order.shipment_state
+    end
+
+    # Updates the +payment_state+ attribute according to the following logic:
+    #
+    # paid          when +payment_total+ is equal to +total+
+    # balance_due   when +payment_total+ is less than +total+
+    # credit_owed   when +payment_total+ is greater than +total+
+    # failed        when most recent payment is in the failed state
+    # void          when order is canceled and +payment_total+ is equal to zero
+    #
+    # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
+    def update_payment_state
+      last_state = order.payment_state
+      if payments.present? && payments.valid.size == 0
+        order.payment_state = 'failed'
+      elsif order.canceled? && order.payment_total == 0
+        order.payment_state = 'void'
+      else
+        order.payment_state = 'balance_due' if order.outstanding_balance > 0
+        order.payment_state = 'credit_owed' if order.outstanding_balance < 0
+        order.payment_state = 'paid' if !order.outstanding_balance?
+      end
+      order.state_changed('payment') if last_state != order.payment_state
+      order.payment_state
+    end
+  end
+end

data/app/models/spree/payment/gateway_options.rb

@@ -0,0 +1,90 @@
+module Spree
+  class Payment
+    class GatewayOptions
+      def initialize(payment)
+        @payment = payment
+      end
+
+      def email
+        order.email
+      end
+
+      def customer
+        order.email
+      end
+
+      def customer_id
+        order.user_id
+      end
+
+      def ip
+        order.last_ip_address
+      end
+
+      def order_id
+        "#{order.number}-#{@payment.number}"
+      end
+
+      def shipping
+        order.ship_total * exchange_multiplier
+      end
+
+      def tax
+        order.additional_tax_total * exchange_multiplier
+      end
+
+      def subtotal
+        order.item_total * exchange_multiplier
+      end
+
+      def discount
+        order.promo_total * exchange_multiplier
+      end
+
+      def currency
+        @payment.currency
+      end
+
+      def billing_address
+        order.bill_address.try(:active_merchant_hash)
+      end
+
+      def shipping_address
+        order.ship_address.try(:active_merchant_hash)
+      end
+
+      def hash_methods
+        [
+          :email,
+          :customer,
+          :customer_id,
+          :ip,
+          :order_id,
+          :shipping,
+          :tax,
+          :subtotal,
+          :discount,
+          :currency,
+          :billing_address,
+          :shipping_address
+        ]
+      end
+
+      def to_hash
+        Hash[hash_methods.map do |method|
+          [method, send(method)]
+        end]
+      end
+
+      private
+
+      def order
+        @payment.order
+      end
+
+      def exchange_multiplier
+        @payment.payment_method.try(:exchange_multiplier) || 1.0
+      end
+    end
+  end
+end