spree_core 3.0.9 → 3.2.0

data/app/models/spree/promotion_handler/cart.rb

@@ -24,6 +24,8 @@ module Spree
         promotions.each do |promotion|
           if (line_item && promotion.eligible?(line_item)) || promotion.eligible?(order)
             promotion.activate(line_item: line_item, order: order)
+          else
+            promotion.deactivate(line_item: line_item, order: order)
           end
         end
       end
@@ -31,23 +33,7 @@ module Spree
       private
 
       def promotions
-        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
-        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
-        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
-        # So this construct makes both happy.
-        select = Arel::SelectManager.new(
-          Promotion,
-          Promotion.arel_table.create_table_alias(
-            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
-            Promotion.table_name
-          ),
-        )
-        select.project(Arel.star)
-
-        Promotion.find_by_sql(
-          select,
-          order.promotions.bind_values
-        )
+        Promotion.find_by_sql("#{order.promotions.active.to_sql} UNION #{Promotion.active.where(code: nil, path: nil).to_sql}")
       end
     end
   end

data/app/models/spree/promotion_handler/coupon.rb

@@ -11,16 +11,13 @@ module Spree
       def apply
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
-            handle_present_promotion(promotion)
+            handle_present_promotion
+          elsif Promotion.with_coupon_code(order.coupon_code).try(:expired?)
+            set_error_code :coupon_code_expired
           else
-            if Promotion.with_coupon_code(order.coupon_code).try(:expired?)
-              set_error_code :coupon_code_expired
-            else
-              set_error_code :coupon_code_not_found
-            end
+            set_error_code :coupon_code_not_found
           end
         end
-
         self
       end
 
@@ -35,7 +32,9 @@ module Spree
       end
 
       def promotion
-        @promotion ||= Promotion.active.includes(:promotion_rules, :promotion_actions).with_coupon_code(order.coupon_code)
+        @promotion ||= Promotion.active.includes(
+          :promotion_rules, :promotion_actions
+        ).with_coupon_code(order.coupon_code)
       end
 
       def successful?
@@ -44,18 +43,17 @@ module Spree
 
       private
 
-      def handle_present_promotion(promotion)
+      def handle_present_promotion
         return promotion_usage_limit_exceeded if promotion.usage_limit_exceeded?(order)
-        return promotion_applied if promotion_exists_on_order?(order, promotion)
+        return promotion_applied if promotion_exists_on_order?
         unless promotion.eligible?(order)
           self.error = promotion.eligibility_errors.full_messages.first unless promotion.eligibility_errors.blank?
-          return (self.error || ineligible_for_this_order)
+          return (error || ineligible_for_this_order)
         end
 
         # If any of the actions for the promotion return `true`,
         # then result here will also be `true`.
-        result = promotion.activate(:order => order)
-        if result
+        if promotion.activate(order: order)
           determine_promotion_application_result
         else
           set_error_code :coupon_code_unknown_error
@@ -74,7 +72,7 @@ module Spree
         set_error_code :coupon_code_already_applied
       end
 
-      def promotion_exists_on_order?(order, promotion)
+      def promotion_exists_on_order?
         order.promotions.include? promotion
       end
 
@@ -85,21 +83,23 @@ module Spree
         end
 
         # Check for applied line items.
-        created_line_items = promotion.actions.detect { |a| a.type == 'Spree::Promotion::Actions::CreateLineItems' }
+        created_line_items = promotion.actions.detect do |a|
+          Object.const_get(a.type).ancestors.include?(
+            Spree::Promotion::Actions::CreateLineItems
+          )
+        end
 
         if discount || created_line_items
           order.update_totals
           order.persist_totals
           set_success_code :coupon_code_applied
-        else
+        elsif order.promotions.with_coupon_code(order.coupon_code)
           # if the promotion exists on an order, but wasn't found above,
           # we've already selected a better promotion
-          if order.promotions.with_coupon_code(order.coupon_code)
-            set_error_code :coupon_code_better_exists
-          else
-            # if the promotion was created after the order
-            set_error_code :coupon_code_not_found
-          end
+          set_error_code :coupon_code_better_exists
+        else
+          # if the promotion was created after the order
+          set_error_code :coupon_code_not_found
         end
       end
     end

data/app/models/spree/promotion_handler/page.rb

@@ -10,14 +10,14 @@ module Spree
 
       def activate
         if promotion && promotion.eligible?(order)
-          promotion.activate(:order => order)
+          promotion.activate(order: order)
         end
       end
 
       private
 
         def promotion
-          @promotion ||= Promotion.active.find_by(:path => path)
+          @promotion ||= Promotion.active.find_by(path: path)
         end
     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,10 +4,10 @@ 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)
+      find_by(name: RETURN_PROCESSING_REASON, mutable: false)
     end
   end
 end

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

data/app/models/spree/reimbursement_type.rb

@@ -2,7 +2,11 @@ module Spree
   class ReimbursementType < Spree::Base
     include Spree::NamedType
 
-    ORIGINAL = 'original'
+    KINDS = %w(Spree::ReimbursementType::Credit
+               Spree::ReimbursementType::Exchange
+               Spree::ReimbursementType::OriginalPayment
+               Spree::ReimbursementType::StoreCredit).freeze
+    ORIGINAL = 'original'.freeze
 
     has_many :return_items
 

data/app/models/spree/return_authorization.rb

@@ -1,22 +1,23 @@
 module Spree
   class ReturnAuthorization < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'RA', length: 9)
+
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
 
     has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
-    has_many :inventory_units, through: :return_items
-    has_many :customer_returns, through: :return_items
+    with_options through: :return_items do
+      has_many :inventory_units
+      has_many :customer_returns
+    end
 
     belongs_to :stock_location
     belongs_to :reason, class_name: 'Spree::ReturnAuthorizationReason', foreign_key: :return_authorization_reason_id
-    before_create :generate_number
 
     after_save :generate_expedited_exchange_reimbursements
 
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
-    validates :order, presence: true
-    validates :reason, presence: true
-    validates :stock_location, presence: true
+    validates :order, :reason, :stock_location, presence: true
     validate :must_have_shipped_units, on: :create
 
 
@@ -37,7 +38,7 @@ module Spree
     extend DisplayMoney
     money_methods :pre_tax_total
 
-    self.whitelisted_ransackable_attributes = ['memo']
+    self.whitelisted_ransackable_attributes = ['memo', 'number', 'state']
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
@@ -67,12 +68,6 @@ module Spree
         end
       end
 
-      def generate_number
-        self.number ||= loop do
-          random = "RA#{Array.new(9){rand(9)}.join}"
-          break random unless self.class.exists?(number: random)
-        end
-      end
 
       def cancel_return_items
         return_items.each { |item| item.cancel! if item.can_cancel? }

data/app/models/spree/return_authorization_reason.rb

@@ -2,6 +2,6 @@ module Spree
   class ReturnAuthorizationReason < Spree::Base
     include Spree::NamedType
 
-    has_many :return_authorizations
+    has_many :return_authorizations, dependent: :restrict_with_error
   end
 end

data/app/models/spree/return_item/eligibility_validator/time_since_purchase.rb

@@ -1,7 +1,7 @@
 module Spree
   class ReturnItem::EligibilityValidator::TimeSincePurchase < Spree::ReturnItem::EligibilityValidator::BaseValidator
     def eligible_for_return?
-      if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.now
+      if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.current
         return true
       else
         add_error(:number_of_days, Spree.t('return_item_time_period_ineligible'))

data/app/models/spree/return_item.rb

@@ -11,12 +11,14 @@ module Spree
     class_attribute :refund_amount_calculator
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
-    belongs_to :return_authorization, inverse_of: :return_items
-    belongs_to :inventory_unit, inverse_of: :return_items
+    with_options inverse_of: :return_items do
+      belongs_to :return_authorization
+      belongs_to :inventory_unit
+      belongs_to :customer_return
+      belongs_to :reimbursement
+    end
     belongs_to :exchange_variant, class_name: 'Spree::Variant'
     belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item
-    belongs_to :customer_return, inverse_of: :return_items
-    belongs_to :reimbursement, inverse_of: :return_items
     belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
     belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
 
@@ -100,7 +102,7 @@ module Spree
         transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
       end
 
-      after_transition any => any, :do => :persist_acceptance_status_errors
+      after_transition any => any, do: :persist_acceptance_status_errors
     end
 
     def self.from_inventory_unit(inventory_unit)
@@ -166,8 +168,11 @@ module Spree
 
     def process_inventory_unit!
       inventory_unit.return!
-
-      Spree::StockMovement.create!(stock_item_id: stock_item.id, quantity: 1) if should_restock?
+      Spree::StockMovement.create!(
+        stock_item_id: stock_item.id,
+        quantity: 1,
+        originator: return_authorization
+      ) if should_restock?
     end
 
     # This logic is also present in the customer return. The reason for the
@@ -220,12 +225,8 @@ module Spree
     end
 
     def cancel_others
-      Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id)
-                       .where.not(id: id)
-                       .where.not(reception_status: 'cancelled')
-                       .each do |return_item|
-        return_item.cancel!
-      end
+      Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id).where.not(id: id).
+        not_cancelled.each(&:cancel!)
     end
 
     def should_restock?

data/app/models/spree/role.rb

@@ -1,7 +1,8 @@
 module Spree
   class Role < Spree::Base
-    has_and_belongs_to_many :users, join_table: 'spree_roles_users', class_name: Spree.user_class.to_s
+    has_many :role_users, class_name: 'Spree::RoleUser', dependent: :destroy
+    has_many :users, through: :role_users, class_name: Spree.user_class.to_s
 
-    validates :name, presence: true
+    validates :name, presence: true, uniqueness: { allow_blank: true }
   end
 end

data/app/models/spree/role_user.rb

@@ -0,0 +1,6 @@
+module Spree
+  class RoleUser < Spree::Base
+    belongs_to :role, class_name: 'Spree::Role'
+    belongs_to :user, class_name: Spree.user_class
+  end
+end