goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/shipment.rb

@@ -0,0 +1,419 @@
+require 'ostruct'
+
+module Spree
+  class Shipment < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'H', length: 11)
+
+    extend FriendlyId
+    friendly_id :number, slug_column: :number, use: :slugged
+
+    with_options inverse_of: :shipments do
+      belongs_to :address, class_name: 'Spree::Address'
+      belongs_to :order, class_name: 'Spree::Order', touch: true
+    end
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+
+    with_options dependent: :delete_all do
+      has_many :adjustments, as: :adjustable
+      has_many :inventory_units, inverse_of: :shipment
+      has_many :shipping_rates, -> { order(:cost) }
+      has_many :state_changes, as: :stateful
+    end
+    has_many :shipping_methods, through: :shipping_rates
+
+    after_save :update_adjustments
+
+    before_validation :set_cost_zero_when_nil
+
+    validates :stock_location, presence: true
+
+    attr_accessor :special_instructions
+
+    accepts_nested_attributes_for :address
+    accepts_nested_attributes_for :inventory_units
+
+    scope :pending, -> { with_state('pending') }
+    scope :ready,   -> { with_state('ready') }
+    scope :shipped, -> { with_state('shipped') }
+    scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
+    scope :with_state, ->(*s) { where(state: s) }
+    # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
+    scope :reverse_chronological, -> { order('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc', id: :desc) }
+
+    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+    state_machine initial: :pending, use_transactions: false do
+      event :ready do
+        transition from: :pending, to: :ready, if: lambda { |shipment|
+          # Fix for #2040
+          shipment.determine_state(shipment.order) == 'ready'
+        }
+      end
+
+      event :pend do
+        transition from: :ready, to: :pending
+      end
+
+      event :ship do
+        transition from: [:ready, :canceled], to: :shipped
+      end
+      after_transition to: :shipped, do: :after_ship
+
+      event :cancel do
+        transition to: :canceled, from: [:pending, :ready]
+      end
+      after_transition to: :canceled, do: :after_cancel
+
+      event :resume do
+        transition from: :canceled, to: :ready, if: lambda { |shipment|
+          shipment.determine_state(shipment.order) == 'ready'
+        }
+        transition from: :canceled, to: :pending
+      end
+      after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
+
+      after_transition do |shipment, transition|
+        shipment.state_changes.create!(
+          previous_state: transition.from,
+          next_state:     transition.to,
+          name:           'shipment',
+        )
+      end
+    end
+
+    self.whitelisted_ransackable_attributes = ['number']
+
+    extend DisplayMoney
+    money_methods :cost, :discounted_cost, :final_price, :item_cost
+    alias display_amount display_cost
+
+    def add_shipping_method(shipping_method, selected = false)
+      shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
+    end
+
+    def after_cancel
+      manifest.each { |item| manifest_restock(item) }
+    end
+
+    def after_resume
+      manifest.each { |item| manifest_unstock(item) }
+    end
+
+    def backordered?
+      inventory_units.any? { |inventory_unit| inventory_unit.backordered? }
+    end
+
+    def currency
+      order ? order.currency : Spree::Config[:currency]
+    end
+
+    # Determines the appropriate +state+ according to the following logic:
+    #
+    # pending    unless order is complete and +order.payment_state+ is +paid+
+    # shipped    if already shipped (ie. does not change the state)
+    # ready      all other cases
+    def determine_state(order)
+      return 'canceled' if order.canceled?
+      return 'pending' unless order.can_ship?
+      return 'pending' if inventory_units.any? &:backordered?
+      return 'shipped' if shipped?
+      order.paid? || Spree::Config[:auto_capture_on_dispatch] ? 'ready' : 'pending'
+    end
+
+    def discounted_cost
+      cost + promo_total
+    end
+    alias discounted_amount discounted_cost
+
+    def editable_by?(user)
+      !shipped?
+    end
+
+    def final_price
+      cost + adjustment_total
+    end
+
+    def final_price_with_items
+      item_cost + final_price
+    end
+
+    def finalize!
+      InventoryUnit.finalize_units!(inventory_units)
+      after_resume
+    end
+
+    def include?(variant)
+      inventory_units_for(variant).present?
+    end
+
+    def inventory_units_for(variant)
+      inventory_units.where(variant_id: variant.id)
+    end
+
+    def inventory_units_for_item(line_item, variant = nil)
+      inventory_units.where(line_item_id: line_item.id, variant_id: line_item.variant.id || variant.id)
+    end
+
+    def item_cost
+      manifest.map { |m| (m.line_item.price + (m.line_item.adjustment_total / m.line_item.quantity)) * m.quantity }.sum
+    end
+
+    def line_items
+      inventory_units.includes(:line_item).map(&:line_item).uniq
+    end
+
+    ManifestItem = Struct.new(:line_item, :variant, :quantity, :states)
+
+    def manifest
+      # Grouping by the ID means that we don't have to call out to the association accessor
+      # This makes the grouping by faster because it results in less SQL cache hits.
+      inventory_units.group_by(&:variant_id).map do |variant_id, units|
+        units.group_by(&:line_item_id).map do |line_item_id, units|
+
+          states = {}
+          units.group_by(&:state).each { |state, iu| states[state] = iu.size }
+
+          line_item = units.first.line_item
+          variant = units.first.variant
+          ManifestItem.new(line_item, variant, units.length, states)
+        end
+      end.flatten
+    end
+
+    def process_order_payments
+      pending_payments =  order.pending_payments
+                            .sort_by(&:uncaptured_amount).reverse
+
+      shipment_to_pay = final_price_with_items
+      payments_amount = 0
+
+      payments_pool = pending_payments.each_with_object([]) do |payment, pool|
+        break if payments_amount >= shipment_to_pay
+        payments_amount += payment.uncaptured_amount
+        pool << payment
+      end
+
+      payments_pool.each do |payment|
+        capturable_amount = if payment.amount >= shipment_to_pay
+                              shipment_to_pay
+                            else
+                              payment.amount
+                            end
+
+        cents = (capturable_amount * 100).to_i
+        payment.capture!(cents)
+        shipment_to_pay -= capturable_amount
+      end
+    end
+
+    def ready_or_pending?
+      self.ready? || self.pending?
+    end
+
+    def refresh_rates(shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
+      return shipping_rates if shipped?
+      return [] unless can_get_rates?
+
+      # StockEstimator.new assigment below will replace the current shipping_method
+      original_shipping_method_id = shipping_method.try(:id)
+
+      self.shipping_rates = Stock::Estimator.new(order).
+      shipping_rates(to_package, shipping_method_filter)
+
+      if shipping_method
+        selected_rate = shipping_rates.detect { |rate|
+          rate.shipping_method_id == original_shipping_method_id
+        }
+        self.selected_shipping_rate_id = selected_rate.id if selected_rate
+      end
+
+      shipping_rates
+    end
+
+    def selected_shipping_rate
+      shipping_rates.where(selected: true).first
+    end
+
+    def selected_shipping_rate_id
+      selected_shipping_rate.try(:id)
+    end
+
+    def selected_shipping_rate_id=(id)
+      shipping_rates.update_all(selected: false)
+      shipping_rates.update(id, selected: true)
+      self.save!
+    end
+
+    def set_up_inventory(state, variant, order, line_item)
+      self.inventory_units.create(
+        state: state,
+        variant_id: variant.id,
+        order_id: order.id,
+        line_item_id: line_item.id
+      )
+    end
+
+    def shipped=(value)
+      return unless value == '1' && shipped_at.nil?
+      self.shipped_at = Time.current
+    end
+
+    def shipping_method
+      selected_shipping_rate.try(:shipping_method) || shipping_rates.first.try(:shipping_method)
+    end
+
+    def tax_category
+      selected_shipping_rate.try(:tax_rate).try(:tax_category)
+    end
+
+    # Only one of either included_tax_total or additional_tax_total is set
+    # This method returns the total of the two. Saves having to check if
+    # tax is included or additional.
+    def tax_total
+      included_tax_total + additional_tax_total
+    end
+
+    def to_package
+      package = Stock::Package.new(stock_location)
+      inventory_units.includes(:variant).joins(:variant).group_by(&:state).each do |state, state_inventory_units|
+        package.add_multiple state_inventory_units, state.to_sym
+      end
+      package
+    end
+
+    def tracking_url
+      @tracking_url ||= shipping_method.build_tracking_url(tracking)
+    end
+
+    def update_amounts
+      if selected_shipping_rate
+        self.update_columns(
+          cost: selected_shipping_rate.cost,
+          adjustment_total: adjustments.additional.map(&:update!).compact.sum,
+          updated_at: Time.current,
+        )
+      end
+    end
+
+    # Update Shipment and make sure Order states follow the shipment changes
+    def update_attributes_and_order(params = {})
+      if self.update_attributes params
+        if params.has_key? :selected_shipping_rate_id
+          # Changing the selected Shipping Rate won't update the cost (for now)
+          # so we persist the Shipment#cost before calculating order shipment
+          # total and updating payment state (given a change in shipment cost
+          # might change the Order#payment_state)
+          self.update_amounts
+
+          order.updater.update_shipment_total
+          order.updater.update_payment_state
+
+          # Update shipment state only after order total is updated because it
+          # (via Order#paid?) affects the shipment state (YAY)
+          self.update_columns(
+            state: determine_state(order),
+            updated_at: Time.current
+          )
+
+          # And then it's time to update shipment states and finally persist
+          # order changes
+          order.updater.update_shipment_state
+          order.updater.persist_totals
+        end
+
+        true
+      end
+    end
+
+    # Updates various aspects of the Shipment while bypassing any callbacks.  Note that this method takes an explicit reference to the
+    # Order object.  This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not
+    # yield the correct results.
+    def update!(order)
+      old_state = state
+      new_state = determine_state(order)
+      update_columns(
+        state: new_state,
+        updated_at: Time.current,
+      )
+      after_ship if new_state == 'shipped' and old_state != 'shipped'
+    end
+
+    def transfer_to_location(variant, quantity, stock_location)
+      if quantity <= 0
+        raise ArgumentError
+      end
+
+      transaction do
+        new_shipment = order.shipments.create!(stock_location: stock_location)
+
+        order.contents.remove(variant, quantity, {shipment: self})
+        order.contents.add(variant, quantity, {shipment: new_shipment})
+
+        refresh_rates
+        save!
+        new_shipment.save!
+      end
+    end
+
+    def transfer_to_shipment(variant, quantity, shipment_to_transfer_to)
+      quantity_already_shipment_to_transfer_to = shipment_to_transfer_to.manifest.find{|mi| mi.line_item.variant == variant}.try(:quantity) || 0
+      final_quantity = quantity + quantity_already_shipment_to_transfer_to
+
+      if (quantity <= 0 || self == shipment_to_transfer_to)
+        raise ArgumentError
+      end
+
+      transaction do
+        order.contents.remove(variant, quantity, {shipment: self})
+        order.contents.add(variant, quantity, {shipment: shipment_to_transfer_to})
+
+        refresh_rates
+        save!
+        shipment_to_transfer_to.refresh_rates
+        shipment_to_transfer_to.save!
+      end
+    end
+
+    private
+
+      def after_ship
+        ShipmentHandler.factory(self).perform
+      end
+
+      def can_get_rates?
+        order.ship_address && order.ship_address.valid?
+      end
+
+      def manifest_restock(item)
+        if item.states["on_hand"].to_i > 0
+         stock_location.restock item.variant, item.states["on_hand"], self
+        end
+
+        if item.states["backordered"].to_i > 0
+          stock_location.restock_backordered item.variant, item.states["backordered"]
+        end
+      end
+
+      def manifest_unstock(item)
+        stock_location.unstock item.variant, item.quantity, self
+      end
+
+      def recalculate_adjustments
+        Adjustable::AdjustmentsUpdater.update(self)
+      end
+
+      def send_shipped_email
+        ShipmentMailer.shipped_email(id).deliver_later
+      end
+
+      def set_cost_zero_when_nil
+        self.cost = 0 unless self.cost
+      end
+
+      def update_adjustments
+        if cost_changed? && state != 'shipped'
+          recalculate_adjustments
+        end
+      end
+
+  end
+end

data/app/models/spree/shipment_handler.rb

@@ -0,0 +1,43 @@
+module Spree
+  class ShipmentHandler
+    class << self
+      def factory(shipment)
+        # Do we have a specialized shipping-method-specific handler? e.g:
+        # Given shipment.shipping_method = Spree::ShippingMethod::DigitalDownload
+        # do we have Spree::ShipmentHandler::DigitalDownload?
+        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method.name.split('::').last}".safe_constantize
+          sm_handler.new(shipment)
+        else
+          new(shipment)
+        end
+      end
+    end
+
+    def initialize(shipment)
+      @shipment = shipment
+    end
+
+    def perform
+      @shipment.inventory_units.each &:ship!
+      @shipment.process_order_payments if Spree::Config[:auto_capture_on_dispatch]
+      @shipment.touch :shipped_at
+      update_order_shipment_state
+      send_shipped_email
+    end
+
+    private
+      def send_shipped_email
+        ShipmentMailer.shipped_email(@shipment.id).deliver_later
+      end
+
+      def update_order_shipment_state
+        order = @shipment.order
+
+        new_state = OrderUpdater.new(order).update_shipment_state
+        order.update_columns(
+                             shipment_state: new_state,
+                             updated_at: Time.current,
+                             )
+      end
+  end
+end

data/app/models/spree/shipping_calculator.rb

@@ -0,0 +1,22 @@
+module Spree
+  class ShippingCalculator < Calculator
+
+    def compute_shipment(shipment)
+      raise NotImplementedError, "Please implement 'compute_shipment(shipment)' in your calculator: #{self.class.name}"
+    end
+
+    def compute_package(package)
+      raise NotImplementedError, "Please implement 'compute_package(package)' in your calculator: #{self.class.name}"
+    end
+
+    def available?(package)
+      true
+    end
+
+    private
+    def total(content_items)
+      content_items.map(&:amount).sum
+    end
+  end
+end
+

data/app/models/spree/shipping_category.rb

@@ -0,0 +1,11 @@
+module Spree
+  class ShippingCategory < Spree::Base
+    validates :name, presence: true, uniqueness: { allow_blank: true }
+
+    with_options inverse_of: :shipping_category do
+      has_many :products
+      has_many :shipping_method_categories
+    end
+    has_many :shipping_methods, through: :shipping_method_categories
+  end
+end

data/app/models/spree/shipping_method.rb

@@ -0,0 +1,69 @@
+module Spree
+  class ShippingMethod < Spree::Base
+    acts_as_paranoid
+    include Spree::CalculatedAdjustments
+    DISPLAY = [:both, :front_end, :back_end]
+
+    # Used for #refresh_rates
+    DISPLAY_ON_FRONT_AND_BACK_END = 0
+    DISPLAY_ON_FRONT_END = 1
+    DISPLAY_ON_BACK_END = 2
+
+    default_scope { where(deleted_at: nil) }
+
+    has_many :shipping_method_categories, dependent: :destroy
+    has_many :shipping_categories, through: :shipping_method_categories
+    has_many :shipping_rates, inverse_of: :shipping_method
+    has_many :shipments, through: :shipping_rates
+
+    has_many :shipping_method_zones, class_name: 'Spree::ShippingMethodZone',
+                                     foreign_key: 'shipping_method_id'
+    has_many :zones, through: :shipping_method_zones, class_name: 'Spree::Zone'
+
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
+
+    validates :name, presence: true
+
+    validate :at_least_one_shipping_category
+
+    def include?(address)
+      return false unless address
+      zones.includes(:zone_members).any? do |zone|
+        zone.include?(address)
+      end
+    end
+
+    def build_tracking_url(tracking)
+      return if tracking.blank? || tracking_url.blank?
+      tracking_url.gsub(/:tracking/, ERB::Util.url_encode(tracking)) # :url_encode exists in 1.8.7 through 2.1.0
+    end
+
+    def self.calculators
+      spree_calculators.send(model_name_without_spree_namespace)
+        .select { |c| c.to_s.constantize < Spree::ShippingCalculator }
+    end
+
+    # Some shipping methods are only meant to be set via backend
+    def frontend?
+      self.display_on != "back_end"
+    end
+
+    def tax_category
+      Spree::TaxCategory.unscoped { super }
+    end
+
+    def available_to_display(display_filter)
+      display_filter == DISPLAY_ON_FRONT_AND_BACK_END ||
+      (frontend? && display_filter == DISPLAY_ON_FRONT_END) ||
+      (!frontend? && display_filter == DISPLAY_ON_BACK_END)
+    end
+
+    private
+
+    def at_least_one_shipping_category
+      if shipping_categories.empty?
+        errors.add(:base, :required_shipping_category)
+      end
+    end
+  end
+end

data/app/models/spree/shipping_method_category.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ShippingMethodCategory < Spree::Base
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories
+  end
+end

data/app/models/spree/shipping_method_zone.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ShippingMethodZone < Spree::Base
+    belongs_to :shipping_method
+    belongs_to :zone
+  end
+end

data/app/models/spree/shipping_rate.rb

@@ -0,0 +1,44 @@
+module Spree
+  class ShippingRate < Spree::Base
+    belongs_to :shipment, class_name: 'Spree::Shipment'
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
+    belongs_to :tax_rate, class_name: 'Spree::TaxRate'
+
+    delegate :order, :currency, to: :shipment
+    delegate :name, to: :shipping_method
+    delegate :code, to: :shipping_method, prefix: true
+
+    extend Spree::DisplayMoney
+
+    money_methods :base_price, :tax_amount
+
+    def base_price
+      cost
+    end
+
+    def display_price
+      price = display_base_price.to_s
+
+      return price if tax_rate.nil? || tax_amount == 0
+
+      Spree.t tax_rate.included_in_price? ? :including_tax : :excluding_tax,
+              scope: "shipping_rates.display_price",
+              price: price,
+              tax_amount: display_tax_amount,
+              tax_rate_name: tax_rate.name
+    end
+    alias_method :display_cost, :display_price
+
+    def tax_amount
+      @_tax_amount ||= tax_rate.calculator.compute_shipping_rate(self)
+    end
+
+    def shipping_method
+      Spree::ShippingMethod.unscoped { super }
+    end
+
+    def tax_rate
+      Spree::TaxRate.unscoped { super }
+    end
+  end
+end

data/app/models/spree/state.rb

@@ -0,0 +1,41 @@
+module Spree
+  class State < Spree::Base
+    belongs_to :country, class_name: 'Spree::Country'
+    has_many :addresses, dependent: :restrict_with_error
+
+    has_many :zone_members,
+             -> { where(zoneable_type: 'Spree::State') },
+             class_name: 'Spree::ZoneMember',
+             dependent: :destroy,
+             foreign_key: :zoneable_id
+
+    has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
+
+    validates :country, :name, presence: true
+    validates :name, :abbr, uniqueness: { case_sensitive: false, scope: :country_id }, allow_blank: true
+
+    self.whitelisted_ransackable_attributes = %w(abbr)
+
+    def self.find_all_by_name_or_abbr(name_or_abbr)
+      where('name = ? OR abbr = ?', name_or_abbr, name_or_abbr)
+    end
+
+    # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
+    # blank is added elsewhere, if needed
+    def self.states_group_by_country_id
+      state_info = Hash.new { |h, k| h[k] = [] }
+      self.order(:name).each { |state|
+        state_info[state.country_id.to_s].push [state.id, state.name]
+      }
+      state_info
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/app/models/spree/state_change.rb

@@ -0,0 +1,10 @@
+module Spree
+  class StateChange < Spree::Base
+    belongs_to :user, class_name: Spree.user_class
+    belongs_to :stateful, polymorphic: true
+
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+  end
+end