solidus_core 1.0.0.pre

data/app/models/spree/item_adjustments.rb

@@ -0,0 +1,85 @@
+module Spree
+  # Manage (recalculate) item (LineItem or Shipment) adjustments
+  class ItemAdjustments
+    attr_reader :item
+
+    # @param item [Order, LineItem, Shipment] the item whose adjustments should be updated
+    def initialize(item)
+      @item = item
+    end
+
+    # Update the item's adjustments and totals
+    #
+    # If the item is an {Order}, this will update and select the best
+    # promotion adjustment.
+    #
+    # If it is a {LineItem} or {Shipment}, it will update and select the best
+    # promotion adjustment, update tax adjustments, update cancellation
+    # adjustments, and then update the total fields (promo_total,
+    # included_tax_total, additional_tax_total, and adjustment_total) on the
+    # item.
+    #
+    # This is a noop if the item is not persisted.
+    def update
+      return @item unless item.persisted?
+
+      # Promotion adjustments must be applied first, then tax adjustments.
+      # This fits the criteria for VAT tax as outlined here:
+      # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
+      #
+      # It also fits the criteria for sales tax as outlined here:
+      # http://www.boe.ca.gov/formspubs/pub113/
+      #
+      # Tax adjustments come in not one but *two* exciting flavours:
+      # Included & additional
+
+      # Included tax adjustments are those which are included in the price.
+      # These ones should not affect the eventual total price.
+      #
+      # Additional tax adjustments are the opposite, affecting the final total.
+
+      promotion_adjustments = adjustments.select(&:promotion?)
+      promotion_adjustments.each(&:update!)
+
+      promo_total = PromotionChooser.new(promotion_adjustments).update
+
+      # Calculating the totals for the order here would be incorrect. Order's
+      # totals are the sum of the adjustments on all child models, as well as
+      # its own.
+      #
+      # We want to select the best promotion for the order, but the remainder
+      # of the calculations here are done in the OrderUpdater instead.
+      return if Spree::Order === item
+
+      @item.promo_total = promo_total
+
+      tax = adjustments.select(&:tax?)
+
+      @item.included_tax_total = tax.select(&:included?).map(&:update!).compact.sum
+      @item.additional_tax_total = tax.reject(&:included?).map(&:update!).compact.sum
+
+      item_cancellation_total = adjustments.select(&:cancellation?).map(&:update!).compact.sum
+
+      @item.adjustment_total = @item.promo_total + @item.additional_tax_total + item_cancellation_total
+
+      @item.update_columns(
+        :promo_total => @item.promo_total,
+        :included_tax_total => @item.included_tax_total,
+        :additional_tax_total => @item.additional_tax_total,
+        :adjustment_total => @item.adjustment_total,
+        :updated_at => Time.now,
+      ) if @item.changed?
+
+      @item
+    end
+
+    private
+    def adjustments
+      # This is done intentionally to avoid loading the association. If the
+      # association is loaded, the records may become stale due to code
+      # elsewhere in spree. When that is remedied, this should be changed to
+      # just item.adjustments
+      @adjustments ||= item.adjustments.all.to_a
+    end
+  end
+end

data/app/models/spree/item_adjustments.rb.orig

@@ -0,0 +1,93 @@
+module Spree
+  # Manage (recalculate) item (LineItem or Shipment) adjustments
+  class ItemAdjustments
+    attr_reader :item
+
+    # @param item [Order, LineItem, Shipment] the item whose adjustments should be updated
+    def initialize(item)
+      @item = item
+    end
+
+    # Update the item's adjustments and totals
+    #
+    # If the item is an {Order}, this will update and select the best
+    # promotion adjustment.
+    #
+    # If it is a {LineItem} or {Shipment}, it will update and select the best
+    # promotion adjustment, update tax adjustments, update cancellation
+    # adjustments, and then update the total fields (promo_total,
+    # included_tax_total, additional_tax_total, and adjustment_total) on the
+    # item.
+    #
+    # This is a noop if the item is not persisted.
+    def update
+      return @item unless item.persisted?
+
+      # Promotion adjustments must be applied first, then tax adjustments.
+      # This fits the criteria for VAT tax as outlined here:
+      # http://www.hmrc.gov.uk/vat/managing/charging/discounts-etc.htm#1
+      #
+      # It also fits the criteria for sales tax as outlined here:
+      # http://www.boe.ca.gov/formspubs/pub113/
+      #
+      # Tax adjustments come in not one but *two* exciting flavours:
+      # Included & additional
+
+      # Included tax adjustments are those which are included in the price.
+      # These ones should not affect the eventual total price.
+      #
+      # Additional tax adjustments are the opposite, affecting the final total.
+
+      promotion_adjustments = adjustments.select(&:promotion?)
+      promotion_adjustments.each(&:update!)
+
+      promo_total = PromotionChooser.new(promotion_adjustments).update
+
+      # Calculating the totals for the order here would be incorrect. Order's
+      # totals are the sum of the adjustments on all child models, as well as
+      # its own.
+      #
+      # We want to select the best promotion for the order, but the remainder
+      # of the calculations here are done in the OrderUpdater instead.
+      return if Spree::Order === item
+
+      @item.promo_total = promo_total
+
+      tax = adjustments.select(&:tax?)
+
+      @item.included_tax_total = tax.select(&:included?).map(&:update!).compact.sum
+      @item.additional_tax_total = tax.reject(&:included?).map(&:update!).compact.sum
+
+      item_cancellation_total = adjustments.select(&:cancellation?).map(&:update!).compact.sum
+
+      @item.adjustment_total = @item.promo_total + @item.additional_tax_total + item_cancellation_total
+
+      @item.update_columns(
+        :promo_total => @item.promo_total,
+        :included_tax_total => @item.included_tax_total,
+        :additional_tax_total => @item.additional_tax_total,
+        :adjustment_total => @item.adjustment_total,
+        :updated_at => Time.now,
+      ) if @item.changed?
+
+      @item
+    end
+
+<<<<<<< HEAD
+    private
+    def adjustments
+      # This is done intentionally to avoid loading the association. If the
+      # association is loaded, the records may become stale due to code
+      # elsewhere in spree. When that is remedied, this should be changed to
+      # just item.adjustments
+      @adjustments ||= item.adjustments.all.to_a
+||||||| parent of 12bada8... Replace order strings with symbols/arel_table.
+    def best_promotion_adjustment
+      @best_promotion_adjustment ||= adjustments.promotion.eligible.reorder("amount ASC, created_at DESC, id DESC").first
+=======
+    def best_promotion_adjustment
+      @best_promotion_adjustment ||= adjustments.promotion.eligible.reorder(:amount, created_at: :desc, id: :desc).first
+>>>>>>> 12bada8... Replace order strings with symbols/arel_table.
+    end
+  end
+end

data/app/models/spree/legacy_user.rb

@@ -0,0 +1,38 @@
+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 UserAddress
+    include UserPaymentSource
+
+    self.table_name = 'spree_users'
+
+    # for url generation
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "User")
+    end
+
+    has_many :orders, foreign_key: :user_id
+
+    before_destroy :check_completed_orders
+
+    def has_spree_role?(role)
+      true
+    end
+
+    def self.model_name
+      ActiveModel::Name.new Spree::LegacyUser, Spree, 'user'
+    end
+
+    attr_accessor :password
+    attr_accessor :password_confirmation
+
+    private
+
+      def check_completed_orders
+        raise Spree::Core::DestroyWithOrdersError if orders.complete.present?
+      end
+  end
+end

data/app/models/spree/line_item.rb

@@ -0,0 +1,183 @@
+module Spree
+  class LineItem < Spree::Base
+    before_validation :invalid_quantity_check
+    belongs_to :order, class_name: "Spree::Order", inverse_of: :line_items, touch: true
+    belongs_to :variant, 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 :copy_price
+    before_validation :copy_tax_category
+
+    validates :variant, presence: true
+    validates :quantity, numericality: {
+      only_integer: true,
+      greater_than: -1,
+      message: Spree.t('validation.must_be_int')
+    }
+    validates :price, numericality: true
+
+    validate :ensure_proper_currency
+    before_destroy :update_inventory
+    before_destroy :destroy_inventory_units
+
+    after_save :update_inventory
+    after_save :update_adjustments
+
+    after_create :update_tax_charge
+
+    delegate :name, :description, :sku, :should_track_inventory?, to: :variant
+
+    attr_accessor :target_shipment
+
+    # Sets this line item's price, cost price, and currency from this line
+    # item's variant if they are nil and a variant is present.
+    def copy_price
+      if variant
+        self.price = variant.price if price.nil?
+        self.cost_price = variant.cost_price if cost_price.nil?
+        self.currency = variant.currency if currency.nil?
+      end
+    end
+
+    # Sets this line item's tax category from this line item's variant if a
+    # variant is present.
+    def copy_tax_category
+      if variant
+        self.tax_category = variant.tax_category
+      end
+    end
+
+    # @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
+
+    # @return [Spree::Money] the amount of this line item, taking into
+    #   consideration line item promotions.
+    def discounted_money
+      Spree::Money.new(discounted_amount, { currency: currency })
+    end
+
+    # @return [BigDecimal] the amount of this line item, taking into
+    #   consideration all its adjustments.
+    def final_amount
+      amount + adjustment_total
+    end
+    alias total final_amount
+
+    # @return [Spree::Money] the price of this line item
+    def single_money
+      Spree::Money.new(price, { currency: currency })
+    end
+    alias single_display_amount single_money
+
+    # @return [Spree::Moeny] the amount of this line item
+    def money
+      Spree::Money.new(amount, { currency: currency })
+    end
+    alias display_total money
+    alias display_amount money
+
+    # Sets the quantity to zero if it is nil or less than zero.
+    def invalid_quantity_check
+      self.quantity = 0 if quantity.nil? || quantity < 0
+    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
+
+    # @note This will return the product even if it has been deleted.
+    # @return [Spree::Product, nil] the product associated with this line
+    #   item, if there is one
+    def product
+      variant.product
+    end
+
+    # @note This will return the variant even if it has been deleted.
+    # @return [Spree::Variant, nil] the variant associated with this line
+    #   item, if there is one
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
+    # Sets the options on the line item according to the order's currency or
+    # one passed in.
+    #
+    # @param options [Hash] options for this line item
+    def options=(options={})
+      return unless options.present?
+
+      opts = options.dup # we will be deleting from the hash, so leave the caller's copy intact
+
+      currency = opts.delete(:currency) || order.try(:currency)
+
+      if currency
+        self.currency = currency
+        self.price    = variant.price_in(currency).amount +
+                        variant.price_modifier_amount_in(currency, opts)
+      else
+        self.price    = variant.price +
+                        variant.price_modifier_amount(opts)
+      end
+
+      self.assign_attributes opts
+    end
+
+    private
+      def update_inventory
+        if (changed? || target_shipment.present?) && self.order.has_checkout_step?("delivery")
+          Spree::OrderInventory.new(self.order, self).verify(target_shipment)
+        end
+      end
+
+      def destroy_inventory_units
+        inventory_units.destroy_all
+      end
+
+      def update_adjustments
+        if quantity_changed?
+          update_tax_charge # Called to ensure pre_tax_amount is updated.
+          recalculate_adjustments
+        end
+      end
+
+      def recalculate_adjustments
+        Spree::ItemAdjustments.new(self).update
+      end
+
+      def update_tax_charge
+        Spree::TaxRate.adjust(order.tax_zone, [self])
+      end
+
+      def ensure_proper_currency
+        unless currency == order.currency
+          errors.add(:currency, :must_match_order_currency)
+        end
+      end
+  end
+end

data/app/models/spree/line_item_action.rb

@@ -0,0 +1,6 @@
+module Spree
+  class LineItemAction < ActiveRecord::Base
+    belongs_to :line_item
+    belongs_to :action, class_name: "Spree::PromotionAction"
+  end
+end

data/app/models/spree/log_entry.rb

@@ -0,0 +1,20 @@
+module Spree
+  class LogEntry < Spree::Base
+    belongs_to :source, polymorphic: true
+
+    # Fix for #1767
+    # If a payment fails, we want to make sure we keep the record of it failing
+    after_rollback :save_anyway
+
+    def save_anyway
+      log = Spree::LogEntry.new
+      log.source  = source
+      log.details = details
+      log.save!
+    end
+
+    def parsed_details
+      @details ||= YAML.load(details)
+    end
+  end
+end

data/app/models/spree/option_type.rb

@@ -0,0 +1,30 @@
+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
+    has_and_belongs_to_many :prototypes, join_table: 'spree_option_types_prototypes'
+
+    validates :name, presence: true, uniqueness: true
+    validates :presentation, presence: true
+
+    default_scope -> { order("#{self.table_name}.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
+
+    def touch_all_products
+      products.update_all(updated_at: Time.current)
+    end
+  end
+end