solidus_core 1.0.7 → 1.1.0.beta1

data/app/models/spree/product/scopes.rb

@@ -9,24 +9,6 @@ module Spree
       search_scopes << name.to_sym
     end
 
-    def self.simple_scopes
-      [
-        :ascend_by_updated_at,
-        :descend_by_updated_at,
-        :ascend_by_name,
-        :descend_by_name
-      ]
-    end
-
-    def self.add_simple_scopes(scopes)
-      scopes.each do |name|
-        # We should not define price scopes here, as they require something slightly different
-        next if name.to_s.include?("master_price")
-        parts = name.to_s.match(/(.*)_by_(.*)/)
-        self.scope(name.to_s, -> { order("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ?  "ASC" : "DESC"}") })
-      end
-    end
-
     def self.property_conditions(property)
       properties = Property.table_name
       conditions = case property
@@ -36,14 +18,17 @@ module Spree
       end
     end
 
-    add_simple_scopes simple_scopes
+    scope :ascend_by_updated_at, -> { order(updated_at: :asc) }
+    scope :descend_by_updated_at, -> { order(updated_at: :desc) }
+    scope :ascend_by_name, -> { order(name: :asc) }
+    scope :descend_by_name, -> { order(name: :desc) }
 
     add_search_scope :ascend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount ASC")
+      joins(:master => :default_price).order(Spree::Price.arel_table[:amount].asc)
     end
 
     add_search_scope :descend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount DESC")
+      joins(:master => :default_price).order(Spree::Price.arel_table[:amount].desc)
     end
 
     add_search_scope :price_between do |low, high|
@@ -78,7 +63,7 @@ module Spree
     add_search_scope :in_taxon do |taxon|
       includes(:classifications).
       where("spree_products_taxons.taxon_id" => taxon.self_and_descendants.pluck(:id)).
-      order("spree_products_taxons.position ASC")
+      order(Spree::Classification.arel_table[:position].asc)
     end
 
     # This scope selects products in all taxons AND all its descendants

data/app/models/spree/product_option_type.rb

@@ -1,6 +1,6 @@
 module Spree
   class ProductOptionType < Spree::Base
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true
     belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
     acts_as_list scope: :product
   end

data/app/models/spree/product_promotion_rule.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ProductPromotionRule < Spree::Base
+    belongs_to :product
+    belongs_to :promotion_rule
+  end
+end

data/app/models/spree/product_property.rb

@@ -1,28 +1,10 @@
 module Spree
   class ProductProperty < Spree::Base
-    acts_as_list
+    include Spree::OrderedPropertyValueList
+
     belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
     belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
 
-    validates :property, presence: true
-    validates :value, length: { maximum: 255 }
-
-    default_scope -> { order("#{self.table_name}.position") }
-
     self.whitelisted_ransackable_attributes = ['value']
-
-    # virtual attributes for use with AJAX completion stuff
-    def property_name
-      property.name if property
-    end
-
-    def property_name=(name)
-      unless name.blank?
-        unless property = Property.find_by(name: name)
-          property = Property.create(name: name, presentation: name)
-        end
-        self.property = property
-      end
-    end
   end
 end

data/app/models/spree/promotion/rules/product.rb

@@ -6,7 +6,8 @@ module Spree
       # either come from assigned product group or are assingned directly to
       # the rule.
       class Product < PromotionRule
-        has_and_belongs_to_many :products, class_name: '::Spree::Product', join_table: 'spree_products_promotion_rules', foreign_key: 'promotion_rule_id'
+        has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule', foreign_key: :promotion_rule_id
+        has_many :products, class_name: 'Spree::Product', through: :product_promotion_rules
 
         MATCH_POLICIES = %w(any all none)
         preference :match_policy, :string, default: MATCH_POLICIES.first

data/app/models/spree/refund.rb

@@ -11,7 +11,6 @@ module Spree
     validates :transaction_id, presence: true, on: :update # can't require this on create because the before_create needs to run first
     validates :amount, presence: true, numericality: {greater_than: 0}
 
-    validate :check_payment_environment, on: :create, if: :payment
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
     after_create :perform!
@@ -70,15 +69,6 @@ module Spree
       raise Core::GatewayError.new(Spree.t(:unable_to_connect_to_gateway))
     end
 
-    # Saftey check to make sure we're not accidentally performing operations on a live gateway.
-    # Ex. When testing in staging environment with a copy of production data.
-    def check_payment_environment
-      if payment.payment_method.environment != Rails.env
-        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
-        errors.add(:base, message)
-      end
-    end
-
     def create_log_entry
       log_entries.create!(details: @response.to_yaml)
     end

data/app/models/spree/reimbursement.rb

@@ -152,7 +152,7 @@ module Spree
     end
 
     def send_reimbursement_email
-      Spree::ReimbursementMailer.reimbursement_email(self.id).deliver_now
+      Spree::ReimbursementMailer.reimbursement_email(self.id).deliver_later
     end
 
     # If there are multiple different reimbursement types for a single

data/app/models/spree/return_item.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ReturnItem < ActiveRecord::Base
+  class ReturnItem < Spree::Base
 
     INTERMEDIATE_RECEPTION_STATUSES = %i(given_to_customer lost_in_transit shipped_wrong_item short_shipped in_transit)
     COMPLETED_RECEPTION_STATUSES = INTERMEDIATE_RECEPTION_STATUSES + [:received]
@@ -89,6 +89,7 @@ module Spree
       event(:lost) { transition to: :lost_in_transit, from: :awaiting }
       event(:wrong_item_shipped) { transition to: :shipped_wrong_item, from: :awaiting }
       event(:short_shipped) { transition to: :short_shipped, from: :awaiting }
+      event(:in_transit) { transition to: :in_transit, from: :awaiting }
       event(:expired) { transition to: :expired, from: :awaiting }
     end
 
@@ -161,10 +162,11 @@ module Spree
     end
 
     # @note This uses the exchange_variant_engine configured on the class.
+    # @param stock_locations [Array<Spree::StockLocation>] the stock locations to check
     # @return [ActiveRecord::Relation<Spree::Variant>] the variants eligible
     #   for exchange for this return item
-    def eligible_exchange_variants
-      exchange_variant_engine.eligible_variants(variant)
+    def eligible_exchange_variants(stock_locations = nil)
+      exchange_variant_engine.eligible_variants(variant, stock_locations: stock_locations)
     end
 
     # Builds the exchange inventory unit for this return item, only if an

data/app/models/spree/return_item/exchange_variant_eligibility/same_option_value.rb

@@ -19,12 +19,21 @@ module Spree
       # green pants with 32 waist and 30 inseam
       # blue pants with 34 waist and 32 inseam
 
-      def self.eligible_variants(variant)
-        product_variants = SameProduct.eligible_variants(variant).includes(option_values: :option_type)
-
+      def self.eligible_variants(variant, options = {})
+        product_variants = SameProduct.eligible_variants(variant, options).includes(option_values: :option_type)
         relevant_option_values = variant.option_values.select { |ov| option_type_restrictions.include? ov.option_type.name }
+
         if relevant_option_values.present?
-          product_variants.select { |v| (relevant_option_values & v.option_values) == relevant_option_values }
+          # Finds all the OptionValueVariants that have any of the
+          # relevant option values, groups by variant and ensures the variant
+          # has ALL of the relevant option values.
+          variant_ids = Spree::OptionValuesVariant.
+            where(variant_id: product_variants.distinct.pluck(:id)).
+            where(option_value: relevant_option_values).
+            group(:variant_id).
+            having('COUNT(*) = ?', relevant_option_values.size).
+            pluck(:variant_id)
+          product_variants.where(id: variant_ids)
         else
           product_variants
         end

data/app/models/spree/return_item/exchange_variant_eligibility/same_product.rb

@@ -1,8 +1,8 @@
 module Spree
   module ReturnItem::ExchangeVariantEligibility
     class SameProduct
-      def self.eligible_variants(variant)
-        Spree::Variant.where(product_id: variant.product_id, is_master: variant.is_master?).in_stock
+      def self.eligible_variants(variant, stock_locations: nil)
+        Spree::Variant.where(product_id: variant.product_id, is_master: variant.is_master?).in_stock(stock_locations)
       end
     end
   end

data/app/models/spree/return_reason.rb

@@ -1,5 +1,5 @@
 module Spree
-  class ReturnReason < ActiveRecord::Base
+  class ReturnReason < Spree::Base
     include Spree::NamedType
 
     has_many :return_authorizations

data/app/models/spree/role.rb

@@ -1,6 +1,6 @@
 module Spree
   class Role < Spree::Base
-    has_many :role_users, class_name: "Spree::RoleUser"
+    has_many :role_users, class_name: "Spree::RoleUser", dependent: :destroy
     has_many :users, through: :role_users
 
     def admin?

data/app/models/spree/role_user.rb

@@ -1,5 +1,5 @@
 module Spree
-  class RoleUser < ActiveRecord::Base
+  class RoleUser < Spree::Base
     self.table_name = "spree_roles_users"
     belongs_to :role, class_name: "Spree::Role"
     belongs_to :user, class_name: Spree::UserClassHandle.new

data/app/models/spree/shipment.rb

@@ -3,12 +3,12 @@ require 'ostruct'
 module Spree
   class Shipment < Spree::Base
     belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
-    belongs_to :address, class_name: 'Spree::Address', inverse_of: :shipments
+    belongs_to :address, class_name: 'Spree::Address'
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
     has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :delete_all
     has_many :inventory_units, dependent: :destroy, inverse_of: :shipment
-    has_many :shipping_rates, -> { order('cost ASC') }, dependent: :delete_all
+    has_many :shipping_rates, -> { order(:cost) }, dependent: :delete_all
     has_many :shipping_methods, through: :shipping_rates
     has_many :state_changes, as: :stateful
     has_many :cartons, -> { uniq }, through: :inventory_units
@@ -72,6 +72,7 @@ module Spree
       end
     end
 
+    self.whitelisted_ransackable_associations = ['order']
     self.whitelisted_ransackable_attributes = ['number']
 
     def can_transition_from_pending_to_shipped?
@@ -129,9 +130,17 @@ module Spree
       item_cost + final_price
     end
 
+    # Decrement the stock counts for all pending inventory units in this
+    # shipment and mark.
+    # Any previous non-pending inventory units are skipped as their stock had
+    # already been allocated.
     def finalize!
-      InventoryUnit.finalize_units!(inventory_units)
-      manifest.each { |item| manifest_unstock(item) }
+      transaction do
+        pending_units = inventory_units.select(&:pending?)
+        pending_manifest = ShippingManifest.new(inventory_units: pending_units)
+        pending_manifest.items.each { |item| manifest_unstock(item) }
+        InventoryUnit.finalize_units!(pending_units)
+      end
     end
 
     def include?(variant)

data/app/models/spree/shipping_manifest.rb

@@ -2,14 +2,20 @@ class Spree::ShippingManifest
   ManifestItem = Struct.new(:line_item, :variant, :quantity, :states)
 
   def initialize(inventory_units:)
-    @inventory_units = inventory_units
+    @inventory_units = inventory_units.to_a
+  end
+
+  def for_order(order)
+    Spree::ShippingManifest.new(
+      inventory_units: @inventory_units.select {|iu| iu.order_id == order.id }
+    )
   end
 
   def items
     # 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|
+    @inventory_units.group_by(&:variant_id).map do |variant_id, variant_units|
+      variant_units.group_by(&:line_item_id).map do |line_item_id, units|
 
         states = {}
         units.group_by(&:state).each { |state, iu| states[state] = iu.count }

data/app/models/spree/shipping_method.rb

@@ -12,9 +12,8 @@ module Spree
     has_many :shipments, :through => :shipping_rates
     has_many :cartons, inverse_of: :shipping_method
 
-    has_and_belongs_to_many :zones, :join_table => 'spree_shipping_methods_zones',
-                                    :class_name => 'Spree::Zone',
-                                    :foreign_key => 'shipping_method_id'
+    has_many :shipping_method_zones
+    has_many :zones, through: :shipping_method_zones
 
     belongs_to :tax_category, :class_name => 'Spree::TaxCategory'
 

data/app/models/spree/shipping_method_zone.rb

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

data/app/models/spree/state.rb

@@ -13,7 +13,7 @@ module Spree
     # blank is added elsewhere, if needed
     def self.states_group_by_country_id
       state_info = Hash.new { |h, k| h[k] = [] }
-      self.order('name ASC').each { |state|
+      self.order(:name).each { |state|
         state_info[state.country_id.to_s].push [state.id, state.name]
       }
       state_info

data/app/models/spree/stock_item.rb

@@ -98,11 +98,23 @@ module Spree
       end
 
       def conditional_variant_touch
+        variant.touch if inventory_cache_threshold.nil? || should_touch_variant?
+      end
+
+      def should_touch_variant?
         # the variant_id changes from nil when a new stock location is added
-        stock_changed = (count_on_hand_changed? && count_on_hand_change.any? { |c| c < 1 }) || variant_id_changed?
+        inventory_cache_threshold &&
+        (count_on_hand_changed? && count_on_hand_change.any? { |c| c < inventory_cache_threshold }) ||
+        variant_id_changed?
+      end
 
-        if !Spree::Config.binary_inventory_cache || stock_changed
-          variant.touch
+      def inventory_cache_threshold
+        # only warn if store is setting binary_inventory_cache (default = false)
+        @cache_threshold ||= if Spree::Config.binary_inventory_cache
+          ActiveSupport::Deprecation.warn "Spree::Config.binary_inventory_cache=true is DEPRECATED. Instead use Spree::Config.inventory_cache_threshold=1"
+          1
+        else
+          Spree::Config.inventory_cache_threshold
         end
       end
   end

data/app/models/spree/stock_movement.rb

@@ -8,7 +8,7 @@ module Spree
     validates :stock_item, presence: true
     validates :quantity, presence: true
 
-    scope :recent, -> { order('created_at DESC') }
+    scope :recent, -> { order(created_at: :desc) }
 
     self.whitelisted_ransackable_attributes = ['quantity']
 

data/app/models/spree/store.rb

@@ -1,5 +1,8 @@
 module Spree
   class Store < Spree::Base
+    has_many :store_payment_methods, inverse_of: :store
+    has_many :payment_methods, through: :store_payment_methods
+
     validates :code, presence: true, uniqueness: { allow_blank: true }
     validates :name, presence: true
     validates :url, presence: true

data/app/models/spree/store_credit.rb

@@ -1,4 +1,4 @@
-class Spree::StoreCredit < ActiveRecord::Base
+class Spree::StoreCredit < Spree::Base
   acts_as_paranoid
 
   VOID_ACTION       = 'void'

data/app/models/spree/store_credit_category.rb

@@ -1,4 +1,4 @@
-class Spree::StoreCreditCategory < ActiveRecord::Base
+class Spree::StoreCreditCategory < Spree::Base
   class_attribute :non_expiring_credit_types
   self.non_expiring_credit_types = [Spree.t("store_credit.non_expiring")]
 

data/app/models/spree/store_credit_event.rb

@@ -1,5 +1,5 @@
 module Spree
-  class StoreCreditEvent < ActiveRecord::Base
+  class StoreCreditEvent < Spree::Base
     acts_as_paranoid
 
     belongs_to :store_credit

data/app/models/spree/store_credit_type.rb

@@ -1,5 +1,5 @@
 module Spree
-  class StoreCreditType < ActiveRecord::Base
+  class StoreCreditType < Spree::Base
     DEFAULT_TYPE_NAME = Spree.t("store_credit.expiring")
     has_many :store_credits, class_name: 'Spree::StoreCredit', foreign_key: 'type_id'
   end

data/app/models/spree/store_credit_update_reason.rb

@@ -1,2 +1,2 @@
-class Spree::StoreCreditUpdateReason < ActiveRecord::Base
+class Spree::StoreCreditUpdateReason < Spree::Base
 end

data/app/models/spree/store_payment_method.rb

@@ -0,0 +1,6 @@
+module Spree
+  class StorePaymentMethod < Spree::Base
+    belongs_to :store, inverse_of: :store_payment_methods
+    belongs_to :payment_method, inverse_of: :store_payment_methods
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -51,17 +51,10 @@ module Spree
       # This little bit of code at the end stops the Spanish refund from appearing.
       #
       # For further discussion, see #4397 and #4327.
-
-      remaining_rates = rates.dup
-      rates.each do |rate|
-        if rate.included_in_price?
-          if remaining_rates.any?{|r| r != rate && r.tax_category == rate.tax_category }
-            remaining_rates.delete(rate)
-          end
-        end
+      rates.delete_if do |rate|
+        rate.included_in_price? &&
+        (rates - [rate]).map(&:tax_category).include?(rate.tax_category)
       end
-
-      remaining_rates
     end
 
     # Pre-tax amounts must be stored so that we can calculate