spree_core 3.0.10 → 3.1.0.rc1

data/app/models/spree/payment_method.rb

@@ -1,8 +1,14 @@
 module Spree
   class PaymentMethod < Spree::Base
     acts_as_paranoid
-    DISPLAY = [:both, :front_end, :back_end]
-    default_scope { where(deleted_at: nil) }
+    acts_as_list
+
+    DISPLAY = [:both, :front_end, :back_end].freeze
+
+    scope :active,                 -> { where(active: true) }
+    scope :available,              -> { active.where(display_on: [:front_end, :back_end, :both]) }
+    scope :available_on_front_end, -> { active.where(display_on: [:front_end, :both]) }
+    scope :available_on_back_end,  -> { active.where(display_on: [:back_end, :both]) }
 
     validates :name, presence: true
 
@@ -24,17 +30,6 @@ module Spree
       raise ::NotImplementedError, 'You must implement payment_source_class method for this gateway.'
     end
 
-    def self.available(display_on = 'both')
-      all.select do |p|
-        p.active &&
-        (p.display_on == display_on.to_s || p.display_on.blank?)
-      end
-    end
-
-    def self.active?
-      where(type: self.to_s, active: true).count > 0
-    end
-
     def method_type
       type.demodulize.downcase
     end
@@ -68,5 +63,9 @@ module Spree
     def cancel(response)
       raise ::NotImplementedError, 'You must implement cancel method for this payment method.'
     end
+
+    def store_credit?
+      self.class == Spree::PaymentMethod::StoreCredit
+    end
   end
 end

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

@@ -0,0 +1,130 @@
+module Spree
+  class PaymentMethod::StoreCredit < PaymentMethod
+    def payment_source_class
+      ::Spree::StoreCredit
+    end
+
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    def can_void?(payment)
+      payment.pending?
+    end
+
+    def authorize(amount_in_cents, store_credit, gateway_options = {})
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        action = -> (store_credit) do
+          store_credit.authorize(
+            amount_in_cents / 100.0.to_d,
+            gateway_options[:currency],
+            action_originator: gateway_options[:originator]
+          )
+        end
+        handle_action_call(store_credit, action, :authorize)
+      end
+    end
+
+    def capture(amount_in_cents, auth_code, gateway_options = {})
+      action = -> (store_credit) do
+        store_credit.capture(
+          amount_in_cents / 100.0.to_d,
+          auth_code,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator]
+        )
+      end
+      handle_action(action, :capture, auth_code)
+    end
+
+    def purchase(amount_in_cents, store_credit, gateway_options = {})
+      eligible_events = store_credit.store_credit_events.where(
+        amount: amount_in_cents / 100.0.to_d,
+        action: Spree::StoreCredit::ELIGIBLE_ACTION
+      )
+      event = eligible_events.detect do |eligible_event|
+        store_credit.store_credit_events.where(authorization_code: eligible_event.authorization_code).
+          where.not(action: Spree::StoreCredit::ELIGIBLE_ACTION).empty?
+      end
+
+      if event.blank?
+        ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        capture(amount_in_cents, event.authorization_code, gateway_options)
+      end
+    end
+
+    def void(auth_code, gateway_options = {})
+      action = -> (store_credit) do
+        store_credit.void(auth_code, action_originator: gateway_options[:originator])
+      end
+      handle_action(action, :void, auth_code)
+    end
+
+    def credit(amount_in_cents, auth_code, gateway_options)
+      action = -> (store_credit) do
+        currency = gateway_options[:currency] || store_credit.currency
+        originator = gateway_options[:originator]
+
+        store_credit.credit(amount_in_cents / 100.0.to_d, auth_code, currency, action_originator: originator)
+      end
+
+      handle_action(action, :credit, auth_code)
+    end
+
+    def cancel(auth_code)
+      store_credit_event = StoreCreditEvent.find_by(authorization_code: auth_code,
+                                                    action: Spree::StoreCredit::CAPTURE_ACTION)
+      store_credit = store_credit_event.try(:store_credit)
+
+      if !store_credit_event || !store_credit
+        handle_action(nil, :cancel, false)
+      else
+        action = -> (store_credit) do
+          store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
+        end
+        handle_action(action, :cancel, auth_code)
+      end
+    end
+
+    def source_required?
+      true
+    end
+
+    private
+
+    def handle_action_call(store_credit, action, action_name, auth_code = nil)
+      store_credit.with_lock do
+        if response = action.call(store_credit)
+          # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
+          ActiveMerchant::Billing::Response.new(
+            true,
+            Spree.t('store_credit_payment_method.successful_action', action: action_name),
+            {},
+            authorization: auth_code || response
+          )
+        else
+          ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.join, {}, {})
+        end
+      end
+    end
+
+    def handle_action(action, action_name, auth_code)
+      # Find first event with provided auth_code
+      store_credit = StoreCreditEvent.find_by_authorization_code(auth_code).try(:store_credit)
+
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(
+          false,
+          Spree.t('store_credit_payment_method.unable_to_find_for_action', auth_code: auth_code, action: action_name),
+          {},
+          {}
+        )
+      else
+        handle_action_call(store_credit, action, action_name, auth_code)
+      end
+    end
+  end
+end

data/app/models/spree/preference.rb

@@ -1,5 +1,5 @@
 class Spree::Preference < Spree::Base
   serialize :value
 
-  validates :key, presence: true, uniqueness: true
+  validates :key, presence: true, uniqueness: { allow_blank: true }
 end

data/app/models/spree/price.rb

@@ -1,12 +1,15 @@
 module Spree
   class Price < Spree::Base
+    include VatPriceCalculation
+
     acts_as_paranoid
 
     MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
 
     belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
 
-    validate :check_price
+    before_validation :ensure_currency
+
     validates :amount, allow_nil: true, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
@@ -21,12 +24,19 @@ module Spree
       Spree::Money.new(amount || 0, { currency: currency })
     end
 
-    def price
-      amount
+    def amount=(amount)
+      self[:amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
+    alias_attribute :price, :amount
+
+    def price_including_vat_for(price_options)
+      options = price_options.merge(tax_category: variant.tax_category)
+      gross_amount(price, options)
     end
 
-    def price=(price)
-      self[:amount] = Spree::LocalizedNumber.parse(price)
+    def display_price_including_vat_for(price_options)
+      Spree::Money.new(price_including_vat_for(price_options), currency: currency)
     end
 
     # Remove variant default_scope `deleted_at: nil`
@@ -36,7 +46,7 @@ module Spree
 
     private
 
-    def check_price
+    def ensure_currency
       self.currency ||= Spree::Config[:currency]
     end
   end

data/app/models/spree/product.rb

@@ -32,7 +32,15 @@ module Spree
 
     has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
-    has_and_belongs_to_many :promotion_rules, join_table: :spree_products_promotion_rules
+
+    has_many :product_promotion_rules, class_name: 'Spree::ProductPromotionRule'
+    has_many :promotion_rules, through: :product_promotion_rules, class_name: 'Spree::PromotionRule'
+
+    has_many :promotions, through: :promotion_rules, class_name: 'Spree::Promotion'
+
+    has_many :possible_promotions, -> { advertised.active }, through: :promotion_rules,
+                                                             class_name: 'Spree::Promotion',
+                                                             source: :promotion
 
     belongs_to :tax_category, class_name: 'Spree::TaxCategory'
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
@@ -43,12 +51,12 @@ module Spree
       class_name: 'Spree::Variant'
 
     has_many :variants,
-      -> { where(is_master: false).order("#{::Spree::Variant.quoted_table_name}.position ASC") },
+      -> { where(is_master: false).order(:position) },
       inverse_of: :product,
       class_name: 'Spree::Variant'
 
     has_many :variants_including_master,
-      -> { order("#{::Spree::Variant.quoted_table_name}.position ASC") },
+      -> { order(:position) },
       inverse_of: :product,
       class_name: 'Spree::Variant',
       dependent: :destroy
@@ -60,16 +68,13 @@ module Spree
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
-    delegate_belongs_to :master, :sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth, :is_master, :has_default_price?, :cost_currency, :price_in, :amount_in
+    delegate_belongs_to :master, :sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth,
+                        :is_master, :has_default_price?, :cost_currency, :price_in, :amount_in, :cost_price, :images
 
-    delegate_belongs_to :master, :cost_price
-
-    delegate :images, to: :master, prefix: true
-    alias_method :images, :master_images
+    alias_method :master_images, :images
 
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
 
-    after_create :set_master_variant_defaults
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
@@ -86,11 +91,15 @@ module Spree
     before_validation :normalize_slug, on: :update
     before_validation :validate_master
 
-    validates :meta_keywords, length: { maximum: 255 }
-    validates :meta_title, length: { maximum: 255 }
-    validates :name, presence: true
-    validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
-    validates :shipping_category_id, presence: true
+    with_options length: { maximum: 255 }, allow_blank: true do
+      validates :meta_keywords
+      validates :meta_title
+    end
+    with_options presence: true do
+      validates :name, :shipping_category
+      validates :price, if: proc { Spree::Config[:require_master_price] }
+    end
+
     validates :slug, length: { minimum: 3 }, allow_blank: true, uniqueness: true
 
     attr_accessor :option_values_hash
@@ -108,11 +117,7 @@ module Spree
     end
 
     def tax_category
-      if self[:tax_category_id].nil?
-        TaxCategory.where(is_default: true).first
-      else
-        TaxCategory.find(self[:tax_category_id])
-      end
+      super || TaxCategory.find_by(is_default: true)
     end
 
     # Adding properties and option types on creation based on a chosen prototype
@@ -124,9 +129,10 @@ module Spree
     # Ensures option_types and product_option_types exist for keys in option_values_hash
     def ensure_option_types_exist_for_values_hash
       return if option_values_hash.nil?
-      option_values_hash.keys.map(&:to_i).each do |id|
-        self.option_type_ids << id unless option_type_ids.include?(id)
-        product_option_types.create(option_type_id: id) unless product_option_types.pluck(:option_type_id).include?(id)
+      required_option_type_ids = option_values_hash.keys.map(&:to_i)
+      missing_option_type_ids = required_option_type_ids - option_type_ids
+      missing_option_type_ids.each do |id|
+        product_option_types.create(option_type_id: id)
       end
     end
 
@@ -148,7 +154,20 @@ module Spree
     # deleted products and products with nil or future available_on date
     # are not available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted?
+      !(available_on.nil? || available_on.future?) && !deleted? && !discontinued?
+    end
+
+    def discontinue!
+      update_attribute(:discontinue_on, Time.current)
+    end
+
+    def discontinued?
+      !!discontinue_on && discontinue_on <= Time.current
+    end
+
+    # determine if any variant (including master) can be supplied
+    def can_supply?
+      variants_including_master.any?(&:can_supply?)
     end
 
     # split variants list into hash which shows mapping of opt value onto matching variants
@@ -159,11 +178,10 @@ module Spree
     end
 
     def self.like_any(fields, values)
-      where fields.map { |field|
-        values.map { |value|
-          arel_table[field].matches("%#{value}%")
-        }.inject(:or)
-      }.inject(:or)
+      conditions = fields.product(values).map do |(field, value)|
+        arel_table[field].matches("%#{value}%")
+      end
+      where conditions.inject(:or)
     end
 
     # Suitable for displaying only variants that has at least one option value.
@@ -184,29 +202,19 @@ module Spree
     end
 
     def property(property_name)
-      return nil unless prop = properties.find_by(name: property_name)
-      product_properties.find_by(property: prop).try(:value)
+      product_properties.joins(:property).find_by(spree_properties: { name: property_name }).try(:value)
     end
 
-    def set_property(property_name, property_value)
+    def set_property(property_name, property_value, property_presentation = property_name)
       ActiveRecord::Base.transaction do
         # Works around spree_i18n #301
-        property = if Property.exists?(name: property_name)
-          Property.where(name: property_name).first
-        else
-          Property.create(name: property_name, presentation: property_name)
-        end
+        property = Property.create_with(presentation: property_presentation).find_or_create_by(name: property_name)
         product_property = ProductProperty.where(product: self, property: property).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end
     end
 
-    def possible_promotions
-      promotion_ids = promotion_rules.map(&:promotion_id).uniq
-      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:expired?)
-    end
-
     def total_on_hand
       if any_variants_not_track_inventory?
         Float::INFINITY
@@ -219,7 +227,7 @@ module Spree
     # which would make AR's default finder return nil.
     # This is a stopgap for that little problem.
     def master
-      super || variants_including_master.with_deleted.where(is_master: true).first
+      super || variants_including_master.with_deleted.find_by(is_master: true)
     end
 
     private
@@ -250,7 +258,7 @@ module Spree
       values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
 
       values.each do |ids|
-        variant = variants.create(
+        variants.create(
           option_value_ids: ids,
           price: master.price
         )
@@ -269,7 +277,7 @@ module Spree
 
     def punch_slug
       # punch slug with date prefix to allow reuse of original
-      update_column :slug, "#{Time.now.to_i}_#{slug}"[0..254] unless frozen?
+      update_column :slug, "#{Time.current.to_i}_#{slug}"[0..254] unless frozen?
     end
 
     def update_slug_history
@@ -320,11 +328,6 @@ module Spree
       end
     end
 
-    # ensures the master variant is flagged as such
-    def set_master_variant_defaults
-      master.is_master = true
-    end
-
     # Try building a slug based on the following fields in increasing order of specificity.
     def slug_candidates
       [

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

@@ -186,14 +186,19 @@ module Spree
       where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
     end
 
+    add_search_scope :not_discontinued do
+      where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
+    end
+
     # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil, currency = nil)
-      joins(:master => :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.now)
+      available_on ||= Time.current
+      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on).uniq
     end
     search_scopes << :available
 
     def self.active(currency = nil)
-      not_deleted.available(nil, currency)
+      not_discontinued.available(nil, currency)
     end
     search_scopes << :active