spree_core 3.0.10 → 3.1.0.rc1

data/app/models/spree/product_option_type.rb

@@ -1,7 +1,12 @@
 module Spree
   class ProductOptionType < Spree::Base
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types
-    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    with_options inverse_of: :product_option_types do
+      belongs_to :product, class_name: 'Spree::Product'
+      belongs_to :option_type, class_name: 'Spree::OptionType'
+    end
     acts_as_list scope: :product
+
+    validates :product, :option_type, presence: true
+    validates :product_id, uniqueness: { scope: :option_type_id }, allow_nil: true
   end
 end

data/app/models/spree/product_promotion_rule.rb

@@ -0,0 +1,9 @@
+module Spree
+  class ProductPromotionRule < Spree::Base
+    belongs_to :product, class_name: 'Spree::Product'
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+
+    validates :product, :promotion_rule, presence: true
+    validates :product_id, uniqueness: { scope: :promotion_rule_id }, allow_nil: true
+  end
+end

data/app/models/spree/product_property.rb

@@ -2,28 +2,26 @@ module Spree
   class ProductProperty < Spree::Base
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
-    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+    with_options inverse_of: :product_properties do
+      belongs_to :product, touch: true, class_name: 'Spree::Product'
+      belongs_to :property, class_name: 'Spree::Property'
+    end
 
     validates :property, presence: true
 
-    validates_with Spree::Validations::DbMaximumLengthValidator, field: :value
+    validates :value, db_maximum_length: true
 
-    default_scope { order("#{self.table_name}.position") }
+    default_scope { order(:position) }
 
     self.whitelisted_ransackable_attributes = ['value']
 
     # virtual attributes for use with AJAX completion stuff
-    def property_name
-      property.name if property
-    end
+    delegate :name, to: :property, prefix: true, allow_nil: true
 
     def property_name=(name)
       if name.present?
         # don't use `find_by :name` to workaround globalize/globalize#423 bug
-        property = Property.where(name: name).first ||
-                   Property.create(name: name, presentation: name)
-        self.property = property
+        self.property = Property.where(name: name).first_or_create(presentation: name)
       end
     end
   end

data/app/models/spree/promotion.rb

@@ -13,7 +13,8 @@ module Spree
     has_many :promotion_actions, autosave: true, dependent: :destroy
     alias_method :actions, :promotion_actions
 
-    has_and_belongs_to_many :orders, join_table: 'spree_orders_promotions'
+    has_many :order_promotions, class_name: 'Spree::OrderPromotion'
+    has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
 
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
@@ -22,29 +23,28 @@ module Spree
     validates :name, presence: true
     validates :path, uniqueness: { allow_blank: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
-    validates :description, length: { maximum: 255 }
+    validates :description, length: { maximum: 255 }, allow_blank: true
 
     before_save :normalize_blank_values
 
-    scope :coupons, ->{ where("#{table_name}.code IS NOT NULL") }
+    scope :coupons, -> { where.not(code: nil) }
+    scope :advertised, -> { where(advertise: true) }
+    scope :applied, lambda {
+      joins(<<-SQL).uniq
+        INNER JOIN spree_order_promotions
+        ON spree_order_promotions.promotion_id = #{table_name}.id
+      SQL
+    }
 
-    order_join_table = reflect_on_association(:orders).join_table
-
-    scope :applied, -> { joins("INNER JOIN #{order_join_table} ON #{order_join_table}.promotion_id = #{table_name}.id").uniq }
-
-    self.whitelisted_ransackable_attributes = ['code', 'path', 'promotion_category_id']
-
-    def self.advertised
-      where(advertise: true)
-    end
+    self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id', 'code']
 
     def self.with_coupon_code(coupon_code)
-      where("lower(#{self.table_name}.code) = ?", coupon_code.strip.downcase).first
+      where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).first
     end
 
     def self.active
-      where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.now).
-        where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.now)
+      where('spree_promotions.starts_at IS NULL OR spree_promotions.starts_at < ?', Time.current).
+        where('spree_promotions.expires_at IS NULL OR spree_promotions.expires_at > ?', Time.current)
     end
 
     def self.order_activatable?(order)
@@ -52,7 +52,7 @@ module Spree
     end
 
     def expired?
-      !!(starts_at && Time.now < starts_at || expires_at && Time.now > expires_at)
+      !!(starts_at && Time.current < starts_at || expires_at && Time.current > expires_at)
     end
 
     def activate(payload)
@@ -77,10 +77,10 @@ module Spree
         self.save
       end
 
-      return action_taken
+      action_taken
     end
 
-    # called anytime order.update! happens
+    # called anytime order.update_with_updater! happens
     def eligible?(promotable)
       return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
       !!eligible_rules(promotable, {})
@@ -128,7 +128,7 @@ module Spree
 
     def adjusted_credits_count(promotable)
       adjustments = promotable.is_a?(Order) ? promotable.all_adjustments : promotable.adjustments
-      credits_count - adjustments.promotion.where(:source_id => actions.pluck(:id)).count
+      credits_count - adjustments.promotion.where(source_id: actions.pluck(:id)).size
     end
 
     def credits

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

@@ -5,7 +5,9 @@ module Spree
   class Promotion
     module Rules
       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, through: :product_promotion_rules, class_name: 'Spree::Product'
 
         MATCH_POLICIES = %w(any all none)
         preference :match_policy, :string, default: MATCH_POLICIES.first

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

@@ -2,7 +2,8 @@ module Spree
   class Promotion
     module Rules
       class Taxon < PromotionRule
-        has_and_belongs_to_many :taxons, class_name: '::Spree::Taxon', join_table: 'spree_taxons_promotion_rules', foreign_key: 'promotion_rule_id'
+        has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', foreign_key: 'promotion_rule_id'
+        has_many :taxons, through: :promotion_rule_taxons, class_name: 'Spree::Taxon'
 
         MATCH_POLICIES = %w(any all)
         preference :match_policy, default: MATCH_POLICIES.first

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

@@ -4,10 +4,10 @@ module Spree
       class User < PromotionRule
         belongs_to :user, class_name: "::#{Spree.user_class.to_s}"
 
-        has_and_belongs_to_many :users, class_name: "::#{Spree.user_class.to_s}",
-          join_table: 'spree_promotion_rules_users',
-          foreign_key: 'promotion_rule_id',
-          association_foreign_key: :user_id
+        has_many :promotion_rule_users, class_name: 'Spree::PromotionRuleUser',
+                                        foreign_key: :promotion_rule_id,
+                                        dependent: :destroy
+        has_many :users, through: :promotion_rule_users, class_name: "::#{Spree.user_class.to_s}"
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)

data/app/models/spree/promotion_action.rb

@@ -1,4 +1,4 @@
-# Base class for all types of promotion action.
+## Base class for all types of promotion action.
 # PromotionActions perform the necessary tasks when a promotion is activated by an event and determined to be eligible.
 module Spree
   class PromotionAction < Spree::Base
@@ -18,8 +18,8 @@ module Spree
 
     protected
 
-    def label(amount)
-      "#{Spree.t(:promotion)} (#{promotion.name})"
+    def label
+      Spree.t(:promotion_label, name: promotion.name)
     end
   end
 end

data/app/models/spree/promotion_category.rb

@@ -1,6 +1,6 @@
 module Spree
   class PromotionCategory < Spree::Base
-    validates_presence_of :name
+    validates :name, presence: true
     has_many :promotions
   end
 end

data/app/models/spree/promotion_rule_taxon.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PromotionRuleTaxon < Spree::Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :taxon, class_name: 'Spree::Taxon'
+
+    validates :promotion_rule, :taxon, presence: true
+    validates :promotion_rule_id, uniqueness: { scope: :taxon_id }, allow_nil: true
+  end
+end

data/app/models/spree/promotion_rule_user.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PromotionRuleUser < Spree::Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :user, class_name: Spree.user_class
+
+    validates :user, :promotion_rule, presence: true
+    validates :user_id, uniqueness: { scope: :promotion_rule_id }, allow_nil: true
+  end
+end

data/app/models/spree/property.rb

@@ -1,6 +1,7 @@
 module Spree
   class Property < Spree::Base
-    has_and_belongs_to_many :prototypes, join_table: 'spree_properties_prototypes'
+    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
+    has_many :prototypes, through: :property_prototypes, class_name: 'Spree::Prototype'
 
     has_many :product_properties, dependent: :delete_all, inverse_of: :property
     has_many :products, through: :product_properties

data/app/models/spree/property_prototype.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PropertyPrototype < Spree::Base
+    belongs_to :prototype, class_name: 'Spree::Prototype'
+    belongs_to :property, class_name: 'Spree::Property'
+
+    validates :prototype, :property, presence: true
+    validates :prototype_id, uniqueness: { scope: :property_id }, allow_nil: true
+  end
+end

data/app/models/spree/prototype.rb

@@ -1,8 +1,13 @@
 module Spree
   class Prototype < Spree::Base
-    has_and_belongs_to_many :properties, join_table: :spree_properties_prototypes
-    has_and_belongs_to_many :option_types, join_table: :spree_option_types_prototypes
-    has_and_belongs_to_many :taxons, join_table: :spree_taxons_prototypes
+    has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
+    has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
+
+    has_many :option_type_prototypes, class_name: 'Spree::OptionTypePrototype'
+    has_many :option_types, through: :option_type_prototypes, class_name: 'Spree::OptionType'
+
+    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon'
+    has_many :taxons, through: :prototype_taxons, class_name: 'Spree::Taxon'
 
     validates :name, presence: true
   end

data/app/models/spree/prototype_taxon.rb

@@ -0,0 +1,9 @@
+module Spree
+  class PrototypeTaxon < Spree::Base
+    belongs_to :taxon, class_name: 'Spree::Taxon'
+    belongs_to :prototype, class_name: 'Spree::Prototype'
+
+    validates :prototype, :taxon, presence: true
+    validates :prototype_id, uniqueness: { scope: :taxon_id }, allow_nil: true
+  end
+end

data/app/models/spree/refund.rb

@@ -1,16 +1,19 @@
 module Spree
   class Refund < Spree::Base
-    belongs_to :payment, inverse_of: :refunds
+    with_options inverse_of: :refunds do
+      belongs_to :payment
+      belongs_to :reimbursement
+    end
     belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
-    belongs_to :reimbursement, inverse_of: :refunds
 
     has_many :log_entries, as: :source
 
-    validates :payment, presence: true
-    validates :reason, presence: true
-    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}
-
+    with_options presence: true do
+      validates :payment, :reason
+      # can't require this on create because the perform! in after_create needs to run first
+      validates :transaction_id, on: :update
+      validates :amount, numericality: { greater_than: 0, allow_nil: true }
+    end
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
     after_create :perform!

data/app/models/spree/refund_reason.rb

@@ -4,7 +4,7 @@ module Spree
 
     RETURN_PROCESSING_REASON = 'Return processing'
 
-    has_many :refunds
+    has_many :refunds, dependent: :restrict_with_error
 
     def self.return_processing_reason
       find_by!(name: RETURN_PROCESSING_REASON, mutable: false)

data/app/models/spree/reimbursement.rb

@@ -1,22 +1,25 @@
 module Spree
   class Reimbursement < Spree::Base
-    class IncompleteReimbursementError < StandardError; end
+    include Spree::Core::NumberGenerator.new(prefix: 'RI', length: 9)
 
-    belongs_to :order, inverse_of: :reimbursements
-    belongs_to :customer_return, inverse_of: :reimbursements, touch: true
+    class IncompleteReimbursementError < StandardError; end
 
-    has_many :refunds, inverse_of: :reimbursement
-    has_many :credits, inverse_of: :reimbursement, class_name: 'Spree::Reimbursement::Credit'
+    with_options inverse_of: :reimbursements do
+      belongs_to :order
+      belongs_to :customer_return, touch: true
+    end
 
-    has_many :return_items, inverse_of: :reimbursement
+    with_options inverse_of: :reimbursement do
+      has_many :refunds
+      has_many :credits, class_name: 'Spree::Reimbursement::Credit'
+      has_many :return_items
+    end
 
     validates :order, presence: true
     validate :validate_return_items_belong_to_same_order
 
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
-    before_create :generate_number
-
     scope :reimbursed, -> { where(reimbursement_status: 'reimbursed') }
 
     # The reimbursement_tax_calculator property should be set to an object that responds to "call"
@@ -130,13 +133,6 @@ module Spree
 
     private
 
-    def generate_number
-      self.number ||= loop do
-        random = "RI#{Array.new(9){rand(9)}.join}"
-        break random unless self.class.exists?(number: random)
-      end
-    end
-
     def validate_return_items_belong_to_same_order
       if return_items.any? { |ri| ri.inventory_unit.order_id != order_id }
         errors.add(:base, :return_items_order_id_does_not_match)
@@ -154,7 +150,7 @@ module Spree
     # payments and credits have already been processed, we should allow the
     # reimbursement to show as 'reimbursed' and not 'errored'.
     def unpaid_amount_within_tolerance?
-      reimbursement_count = reimbursement_models.count do |model|
+      reimbursement_count = reimbursement_models.size do |model|
         model.total_amount_reimbursed_for(self) > 0
       end
       leniency = if reimbursement_count > 0

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -10,7 +10,7 @@ module Spree
         unpaid_amount -= amount
       end
 
-      return reimbursement_list, unpaid_amount
+      [reimbursement_list, unpaid_amount]
     end
 
     def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [])
@@ -18,17 +18,17 @@ module Spree
       unpaid_amount -= credits.sum(&:amount)
       reimbursement_list += credits
 
-      return reimbursement_list, unpaid_amount
+      [reimbursement_list, unpaid_amount]
     end
 
     private
 
     def create_refund(reimbursement, payment, amount, simulate)
-      refund = reimbursement.refunds.build({
+      refund = reimbursement.refunds.build(
         payment: payment,
         amount: amount,
-        reason: Spree::RefundReason.return_processing_reason,
-      })
+        reason: Spree::RefundReason.return_processing_reason
+      )
 
       simulate ? refund.readonly! : refund.save!
       refund
@@ -44,7 +44,24 @@ module Spree
     end
 
     def create_creditable(reimbursement, unpaid_amount)
-      Spree::Reimbursement::Credit.default_creditable_class.new(reimbursement: reimbursement, amount: unpaid_amount)
+      category = Spree::StoreCreditCategory.default_reimbursement_category(category_options(reimbursement))
+      Spree::StoreCredit.new(store_credit_params(category, reimbursement, unpaid_amount))
+    end
+
+    def store_credit_params(category, reimbursement, unpaid_amount)
+      {
+        user: reimbursement.order.user,
+        amount: unpaid_amount,
+        category: category,
+        created_by: Spree::StoreCredit.default_created_by,
+        memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
+        currency: reimbursement.order.currency
+      }
+    end
+
+    # overwrite if you need options for the default reimbursement category
+    def category_options(_reimbursement)
+      {}
     end
   end
 end

data/app/models/spree/reimbursement_type/store_credit.rb

@@ -0,0 +1,28 @@
+class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
+  extend Spree::ReimbursementType::ReimbursementHelpers
+
+  class << self
+    def reimburse(reimbursement, return_items, simulate)
+      unpaid_amount = return_items.sum(&:total).to_d.round(2, :down)
+      payments = store_credit_payments(reimbursement)
+      reimbursement_list = []
+
+      # Credit each store credit that was used on the order
+      reimbursement_list, unpaid_amount = create_refunds(reimbursement, payments, unpaid_amount,
+                                                         simulate, reimbursement_list)
+
+      # If there is any amount left to pay out to the customer, then create credit with that amount
+      if unpaid_amount > 0.0
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list)
+      end
+
+      reimbursement_list
+    end
+
+    private
+
+    def store_credit_payments(reimbursement)
+      reimbursement.order.payments.completed.store_credits
+    end
+  end
+end