solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/inventory_unit.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Spree
+  # Tracks the state of line items' fulfillment.
+  #
+  class InventoryUnit < Spree::Base
+    PRE_SHIPMENT_STATES = %w(backordered on_hand)
+    POST_SHIPMENT_STATES = %w(returned)
+    CANCELABLE_STATES = ['on_hand', 'backordered', 'shipped']
+
+    belongs_to :variant, -> { with_deleted }, class_name: "Spree::Variant", inverse_of: :inventory_units
+    belongs_to :shipment, class_name: "Spree::Shipment", touch: true, inverse_of: :inventory_units
+    belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization", inverse_of: :inventory_units
+    belongs_to :carton, class_name: "Spree::Carton", inverse_of: :inventory_units
+    belongs_to :line_item, class_name: "Spree::LineItem", inverse_of: :inventory_units
+
+    has_many :return_items, inverse_of: :inventory_unit, dependent: :destroy
+    has_one :original_return_item, class_name: "Spree::ReturnItem", foreign_key: :exchange_inventory_unit_id, dependent: :destroy
+    has_one :unit_cancel, class_name: "Spree::UnitCancel"
+    has_one :order, through: :shipment
+
+    delegate :order_id, to: :shipment
+
+    def order=(_)
+      raise "The order association has been removed from InventoryUnit. The order is now determined from the shipment."
+    end
+
+    validates_presence_of :shipment, :line_item, :variant
+
+    before_destroy :ensure_can_destroy
+
+    scope :pending, -> { where pending: true }
+    scope :backordered, -> { where state: 'backordered' }
+    scope :on_hand, -> { where state: 'on_hand' }
+    scope :pre_shipment, -> { where(state: PRE_SHIPMENT_STATES) }
+    scope :shipped, -> { where state: 'shipped' }
+    scope :post_shipment, -> { where(state: POST_SHIPMENT_STATES) }
+    scope :returned, -> { where state: 'returned' }
+    scope :canceled, -> { where(state: 'canceled') }
+    scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :cancelable, -> { where(state: Spree::InventoryUnit::CANCELABLE_STATES, pending: false) }
+    scope :backordered_per_variant, ->(stock_item) do
+      includes(:shipment, :order)
+        .where("spree_shipments.state != 'canceled'").references(:shipment)
+        .where(variant_id: stock_item.variant_id)
+        .where('spree_orders.completed_at is not null')
+        .backordered.order(Spree::Order.arel_table[:completed_at].asc)
+    end
+
+    # @method backordered_for_stock_item(stock_item)
+    # @param stock_item [Spree::StockItem] the stock item of the desired
+    #   inventory units
+    # @return [ActiveRecord::Relation<Spree::InventoryUnit>] backordered
+    #   inventory units for the given stock item
+    scope :backordered_for_stock_item, ->(stock_item) do
+      backordered_per_variant(stock_item)
+        .where(spree_shipments: { stock_location_id: stock_item.stock_location_id })
+    end
+
+    scope :shippable, -> { on_hand }
+
+    # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
+    state_machine initial: :on_hand do
+      event :fill_backorder do
+        transition to: :on_hand, from: :backordered
+      end
+      after_transition on: :fill_backorder, do: :fulfill_order
+
+      event :ship do
+        transition to: :shipped, if: :allow_ship?
+      end
+
+      event :return do
+        transition to: :returned, from: :shipped
+      end
+
+      event :cancel do
+        transition to: :canceled, from: CANCELABLE_STATES.map(&:to_sym)
+      end
+    end
+
+    # Updates the given inventory units to not be pending.
+    #
+    # @param inventory_units [<Spree::InventoryUnit>] the inventory to be
+    #   finalized
+    def self.finalize_units!(inventory_units)
+      inventory_units.map do |iu|
+        iu.update_columns(
+          pending: false,
+          updated_at: Time.current
+        )
+      end
+    end
+
+    # @return [Spree::StockItem] the first stock item from this shipment's
+    #   stock location that is associated with this inventory unit's variant
+    def find_stock_item
+      Spree::StockItem.where(stock_location_id: shipment.stock_location_id,
+        variant_id: variant_id).first
+    end
+
+    # @return [Spree::ReturnItem] a valid return item for this inventory unit
+    #   if one exists, or a new one if one does not
+    def current_or_new_return_item
+      Spree::ReturnItem.from_inventory_unit(self)
+    end
+
+    # @return [BigDecimal] the portion of the additional tax on the line item
+    #   this inventory unit belongs to that is associated with this individual
+    #   inventory unit
+    def additional_tax_total
+      line_item.additional_tax_total * percentage_of_line_item
+    end
+
+    # @return [BigDecimal] the portion of the included tax on the line item
+    #   this inventory unit belongs to that is associated with this
+    #   individual inventory unit
+    def included_tax_total
+      line_item.included_tax_total * percentage_of_line_item
+    end
+
+    # @return [Boolean] true if this inventory unit has any return items
+    #   which have requested exchanges
+    def exchange_requested?
+      return_items.not_expired.any?(&:exchange_requested?)
+    end
+
+    def allow_ship?
+      on_hand?
+    end
+
+    private
+
+    def fulfill_order
+      reload
+      order.fulfill!
+    end
+
+    def percentage_of_line_item
+      1 / BigDecimal(line_item.quantity)
+    end
+
+    def current_return_item
+      return_items.not_cancelled.first
+    end
+
+    def ensure_can_destroy
+      if !backordered? && !on_hand?
+        errors.add(:state, :cannot_destroy, state: state)
+        throw :abort
+      end
+
+      if shipment.shipped? || shipment.canceled?
+        errors.add(:base, :cannot_destroy_shipment_state, state: shipment.state)
+        throw :abort
+      end
+    end
+  end
+end

data/app/models/spree/legacy_user.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  # Default implementation of User.
+  #
+  # @note This class is intended to be modified by extensions (ex.
+  #   spree_auth_devise)
+  class LegacyUser < Spree::Base
+    include UserMethods
+
+    # devise_token_auth
+    devise :database_authenticatable, :registerable, :recoverable,
+           :rememberable, :trackable, :validatable
+
+    include DeviseTokenAuth::Concerns::User
+
+    self.table_name = 'spree_users'
+
+    def self.model_name
+      ActiveModel::Name.new Spree::LegacyUser, Spree, 'user'
+    end
+
+    attr_accessor :password
+    attr_accessor :password_confirmation
+  end
+end

data/app/models/spree/line_item.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Spree
+  # Variants placed in the Order at a particular price.
+  #
+  # `Spree::LineItem` is an ActiveRecord model which records which `Spree::Variant`
+  # a customer has chosen to place in their order. It also acts as the permenent
+  # record of the customer's order by recording relevant price, taxation, and inventory
+  # concerns. Line items can also have adjustments placed on them as part of the
+  # promotion system.
+  #
+  class LineItem < Spree::Base
+    class CurrencyMismatch < StandardError; end
+
+    belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items, touch: true
+    belongs_to :variant, -> { with_deleted }, class_name: "Spree::Variant", inverse_of: :line_items
+    belongs_to :tax_category, class_name: "Spree::TaxCategory"
+
+    has_one :product, through: :variant
+
+    has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :destroy
+    has_many :inventory_units, inverse_of: :line_item
+
+    has_many :line_item_actions, dependent: :destroy
+    has_many :actions, through: :line_item_actions
+
+    before_validation :normalize_quantity
+    before_validation :set_required_attributes
+
+    validates :variant, presence: true
+    validates :quantity, numericality: {
+      only_integer: true,
+      greater_than: -1
+    }
+    validates :price, numericality: true
+
+    after_save :update_inventory
+
+    before_destroy :update_inventory
+    before_destroy :destroy_inventory_units
+
+    delegate :name, :description, :sku, :should_track_inventory?, to: :variant
+    delegate :currency, to: :order, allow_nil: true
+
+    attr_accessor :target_shipment
+
+    self.whitelisted_ransackable_associations = ['variant']
+    self.whitelisted_ransackable_attributes = ['variant_id']
+
+    # @return [BigDecimal] the amount of this line item, which is the line
+    #   item's price multiplied by its quantity.
+    def amount
+      price * quantity
+    end
+    alias subtotal amount
+
+    # @return [BigDecimal] the amount of this line item, taking into
+    #   consideration line item promotions.
+    def discounted_amount
+      amount + promo_total
+    end
+    deprecate discounted_amount: :total_before_tax, deprecator: Spree::Deprecation
+
+    # @return [BigDecimal] the amount of this line item, taking into
+    #   consideration all its adjustments.
+    def total
+      amount + adjustment_total
+    end
+    alias final_amount total
+    deprecate final_amount: :total, deprecator: Spree::Deprecation
+
+    # @return [BigDecimal] the amount of this item, taking into consideration
+    #   all non-tax adjustments.
+    def total_before_tax
+      amount + adjustments.select { |a| !a.tax? && a.eligible? }.sum(&:amount)
+    end
+
+    # @return [BigDecimal] the amount of this line item before VAT tax
+    # @note just like `amount`, this does not include any additional tax
+    def total_excluding_vat
+      total_before_tax - included_tax_total
+    end
+    alias pre_tax_amount total_excluding_vat
+    deprecate pre_tax_amount: :total_excluding_vat, deprecator: Spree::Deprecation
+
+    extend Spree::DisplayMoney
+    money_methods :amount, :discounted_amount, :price,
+                  :included_tax_total, :additional_tax_total,
+                  :total, :total_before_tax, :total_excluding_vat
+    deprecate display_discounted_amount: :display_total_before_tax, deprecator: Spree::Deprecation
+    alias display_final_amount display_total
+    deprecate display_final_amount: :display_total, deprecator: Spree::Deprecation
+    alias display_pre_tax_amount display_total_excluding_vat
+    deprecate display_pre_tax_amount: :display_total_excluding_vat, deprecator: Spree::Deprecation
+    alias discounted_money display_discounted_amount
+    deprecate discounted_money: :display_total_before_tax, deprecator: Spree::Deprecation
+
+    # @return [Spree::Money] the price of this line item
+    alias money_price display_price
+    alias single_display_amount display_price
+    alias single_money display_price
+
+    # @return [Spree::Money] the amount of this line item
+    alias money display_amount
+    alias display_total display_amount
+    deprecate display_total: :display_amount, deprecator: Spree::Deprecation
+
+    # Sets price from a `Spree::Money` object
+    #
+    # @param [Spree::Money] money - the money object to obtain price from
+    def money_price=(money)
+      if !money
+        self.price = nil
+      elsif money.currency.iso_code != currency
+        raise CurrencyMismatch, "Line item price currency must match order currency!"
+      else
+        self.price = money.to_d
+      end
+    end
+
+    # @return [Boolean] true when it is possible to supply the required
+    #   quantity of stock of this line item's variant
+    def sufficient_stock?
+      Stock::Quantifier.new(variant).can_supply? quantity
+    end
+
+    # @return [Boolean] true when it is not possible to supply the required
+    #   quantity of stock of this line item's variant
+    def insufficient_stock?
+      !sufficient_stock?
+    end
+
+    # Sets options on the line item and updates the price.
+    #
+    # The options can be arbitrary attributes on the LineItem.
+    #
+    # @param options [Hash] options for this line item
+    def options=(options = {})
+      return unless options.present?
+
+      assign_attributes options
+
+      # When price is part of the options we are not going to fetch
+      # it from the variant. Please note that this always allows to set
+      # a price for this line item, even if there is no existing price
+      # for the associated line item in the order currency.
+      unless options.key?(:price) || options.key?('price')
+        self.money_price = variant.price_for(pricing_options)
+      end
+    end
+
+    def pricing_options
+      Spree::Config.pricing_options_class.from_line_item(self)
+    end
+
+    def currency=(_currency)
+      Spree::Deprecation.warn 'Spree::LineItem#currency= is deprecated ' \
+        'and will take no effect.',
+        caller
+    end
+
+    private
+
+    # Sets the quantity to zero if it is nil or less than zero.
+    def normalize_quantity
+      self.quantity = 0 if quantity.nil? || quantity < 0
+    end
+
+    # Sets tax category, price-related attributes from
+    # its variant if they are nil and a variant is present.
+    def set_required_attributes
+      return unless variant
+      self.tax_category ||= variant.tax_category
+      set_pricing_attributes
+    end
+
+    # Set price, cost_price and currency. This method used to be called #copy_price, but actually
+    # did more than just setting the price, hence renamed to #set_pricing_attributes
+    def set_pricing_attributes
+      # If the legacy method #copy_price has been overridden, handle that gracefully
+      return handle_copy_price_override if respond_to?(:copy_price)
+
+      self.cost_price ||= variant.cost_price
+      self.money_price = variant.price_for(pricing_options) if price.nil?
+      true
+    end
+
+    def handle_copy_price_override
+      copy_price
+      Spree::Deprecation.warn 'You have overridden Spree::LineItem#copy_price. ' \
+        'This method is now called Spree::LineItem#set_pricing_attributes. ' \
+        'Please adjust your override.',
+        caller
+    end
+
+    def update_inventory
+      if (saved_changes? || target_shipment.present?) && order.has_checkout_step?("delivery")
+        Spree::OrderInventory.new(order, self).verify(target_shipment)
+      end
+    end
+
+    def destroy_inventory_units
+      inventory_units.destroy_all
+    end
+  end
+end

data/app/models/spree/line_item_action.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class LineItemAction < Spree::Base
+    belongs_to :line_item
+    belongs_to :action, class_name: "Spree::PromotionAction"
+  end
+end

data/app/models/spree/log_entry.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  class LogEntry < Spree::Base
+    belongs_to :source, polymorphic: true
+
+    def parsed_details
+      @details ||= YAML.load(details)
+    end
+  end
+end

data/app/models/spree/option_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Spree
+  # Option types denote the different options for a variant. A typical option
+  # type would be a size, with that option type’s values being something such
+  # as "Small", "Medium" and "Large". Another typical option type could be a
+  # color, such as "Red", "Green", or "Blue".
+  #
+  # A product can be assigned many option types, but must be assigned at least
+  # one if you wish to create variants for that product.
+  class OptionType < Spree::Base
+    acts_as_list
+
+    has_many :option_values, -> { order(:position) }, dependent: :destroy, inverse_of: :option_type
+    has_many :product_option_types, dependent: :destroy, inverse_of: :option_type
+    has_many :products, through: :product_option_types
+
+    validates :name, presence: true, uniqueness: { allow_blank: true }
+    validates :presentation, presence: true
+
+    default_scope -> { order(:position) }
+
+    accepts_nested_attributes_for :option_values, reject_if: lambda { |ov| ov[:name].blank? && ov[:presentation].blank? }, allow_destroy: true
+
+    after_touch :touch_all_products
+    after_save :touch_all_products
+
+    def touch_all_products
+      products.find_each(&:touch)
+    end
+  end
+end

data/app/models/spree/option_value.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Spree
+  class OptionValue < Spree::Base
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :option_values
+    acts_as_list scope: :option_type
+
+    has_many :option_values_variants, dependent: :destroy
+    has_many :variants, through: :option_values_variants
+
+    validates :name, presence: true, uniqueness: { scope: :option_type_id, allow_blank: true }
+    validates :presentation, presence: true
+
+    after_save :touch, if: :saved_changes?
+    after_touch :touch_all_variants
+
+    delegate :name, :presentation, to: :option_type, prefix: :option_type
+
+    self.whitelisted_ransackable_attributes = ['presentation']
+
+    # Updates the updated_at column on all the variants associated with this
+    # option value.
+    def touch_all_variants
+      variants.find_each(&:touch)
+    end
+
+    # @return [String] a string representation of all option value and its
+    #   option type
+    def presentation_with_option_type
+      "#{option_type.presentation} - #{presentation}"
+    end
+  end
+end

data/app/models/spree/option_values_variant.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class OptionValuesVariant < Spree::Base
+    belongs_to :variant
+    belongs_to :option_value
+  end
+end