spree_core 3.0.10 → 3.1.0.rc1

data/app/models/spree/stock/coordinator.rb

@@ -20,26 +20,25 @@ module Spree
         packages = estimate_packages(packages)
       end
 
-      # Build packages as per stock location
-      #
-      # It needs to check whether each stock location holds at least one stock
-      # item for the order. In case none is found it wouldn't make any sense
-      # to build a package because it would be empty. Plus we avoid errors down
-      # the stack because it would assume the stock location has stock items
-      # for the given order
-      # 
-      # Returns an array of Package instances
       def build_packages(packages = Array.new)
-        StockLocation.active.each do |stock_location|
-          next unless stock_location.stock_items.where(:variant_id => inventory_units.map(&:variant_id).uniq).exists?
-
-          packer = build_packer(stock_location, inventory_units)
-          packages += packer.packages
+        stock_locations_with_requested_variants.each do |stock_location|
+          packages += build_packer(stock_location, inventory_units).packages
         end
+
         packages
       end
 
       private
+
+      def stock_locations_with_requested_variants
+        Spree::StockLocation.active.joins(:stock_items).
+          where(spree_stock_items: { variant_id: requested_variant_ids })
+      end
+
+      def requested_variant_ids
+        inventory_units.map(&:variant_id).uniq
+      end
+
       def prioritize_packages(packages)
         prioritizer = Prioritizer.new(inventory_units, packages)
         prioritizer.prioritized_packages

data/app/models/spree/stock/estimator.rb

@@ -1,6 +1,8 @@
 module Spree
   module Stock
     class Estimator
+      include VatPriceCalculation
+
       attr_reader :order, :currency
 
       def initialize(order)
@@ -28,44 +30,40 @@ module Spree
       def calculate_shipping_rates(package, ui_filter)
         shipping_methods(package, ui_filter).map do |shipping_method|
           cost = shipping_method.calculator.compute(package)
-          tax_category = shipping_method.tax_category
-          if tax_category
-            tax_rate = tax_category.tax_rates.detect do |rate|
-              # If the rate's zone matches the order's zone, a positive adjustment will be applied.
-              # If the rate is from the default tax zone, then a negative adjustment will be applied.
-              # See the tests in shipping_rate_spec.rb for an example of this.d
-              rate.zone == order.tax_zone || rate.zone.default_tax?
-            end
-          end
-
-          if cost
-            rate = shipping_method.shipping_rates.new(cost: cost)
-            rate.tax_rate = tax_rate if tax_rate
-          end
 
-          rate
+          shipping_method.shipping_rates.new(
+            cost: gross_amount(cost, taxation_options_for(shipping_method)),
+            tax_rate: first_tax_rate_for(shipping_method.tax_category)
+          ) if cost
         end.compact
       end
 
+      # Override this if you need the prices for shipping methods to be handled just like the
+      # prices for products in terms of included tax manipulation.
+      #
+      def taxation_options_for(shipping_method)
+        {
+          tax_category: shipping_method.tax_category,
+          tax_zone: @order.tax_zone
+        }
+      end
+
+      def first_tax_rate_for(tax_category)
+        return unless @order.tax_zone && tax_category
+        Spree::TaxRate.for_tax_category(tax_category).
+          potential_rates_for_zone(@order.tax_zone).first
+      end
+
       def shipping_methods(package, display_filter)
         package.shipping_methods.select do |ship_method|
           calculator = ship_method.calculator
-          begin
-            ship_method.available_to_display(display_filter) &&
-            ship_method.include?(order.ship_address) &&
-            calculator.available?(package) &&
-            (calculator.preferences[:currency].blank? ||
-             calculator.preferences[:currency] == currency)
-          rescue Exception => exception
-            log_calculator_exception(ship_method, exception)
-          end
-        end
-      end
 
-      def log_calculator_exception(ship_method, exception)
-        Rails.logger.info("Something went wrong calculating rates with the #{ship_method.name} (ID=#{ship_method.id}) shipping method.")
-        Rails.logger.info("*" * 50)
-        Rails.logger.info(exception.backtrace.join("\n"))
+          ship_method.available_to_display(display_filter) &&
+          ship_method.include?(order.ship_address) &&
+          calculator.available?(package) &&
+          (calculator.preferences[:currency].blank? ||
+           calculator.preferences[:currency] == currency)
+        end
       end
     end
   end

data/app/models/spree/stock/inventory_unit_builder.rb

@@ -8,15 +8,7 @@ module Spree
       def units
         @order.line_items.flat_map do |line_item|
           line_item.quantity.times.map do |i|
-            @order.inventory_units.includes(
-              variant: {
-                product: {
-                  shipping_category: {
-                    shipping_methods: [:calculator, { zones: :zone_members }]
-                  }
-                }
-              }
-            ).build(
+            @order.inventory_units.build(
               pending: true,
               variant: line_item.variant,
               line_item: line_item,

data/app/models/spree/stock/packer.rb

@@ -24,7 +24,7 @@ module Spree
           if variant.should_track_inventory?
             next unless stock_location.stock_item(variant)
 
-            on_hand, backordered = stock_location.fill_status(variant, units.count)
+            on_hand, backordered = stock_location.fill_status(variant, units.size)
             package.add_multiple units.slice!(0, on_hand), :on_hand if on_hand > 0
             package.add_multiple units.slice!(0, backordered), :backordered if backordered > 0
           else

data/app/models/spree/stock/quantifier.rb

@@ -1,15 +1,15 @@
 module Spree
   module Stock
     class Quantifier
-      attr_reader :stock_items
+      attr_reader :stock_items, :variant
 
       def initialize(variant)
         @variant = variant
-        @stock_items = Spree::StockItem.joins(:stock_location).where(variant_id: @variant, Spree::StockLocation.table_name => { active: true })
+        @stock_items = @variant.stock_items.with_active_stock_location
       end
 
       def total_on_hand
-        if @variant.should_track_inventory?
+        if variant.should_track_inventory?
           stock_items.sum(:count_on_hand)
         else
           Float::INFINITY
@@ -20,8 +20,8 @@ module Spree
         stock_items.any?(&:backorderable)
       end
 
-      def can_supply?(required)
-        total_on_hand >= required || backorderable?
+      def can_supply?(required = 1)
+        variant.available? && (total_on_hand >= required || backorderable?)
       end
 
     end

data/app/models/spree/stock/splitter/backordered.rb

@@ -6,11 +6,11 @@ module Spree
         def split(packages)
           split_packages = []
           packages.each do |package|
-            if package.on_hand.count > 0
+            if package.on_hand.size > 0
               split_packages << build_package(package.on_hand)
             end
 
-            if package.backordered.count > 0
+            if package.backordered.size > 0
               split_packages << build_package(package.backordered)
             end
           end

data/app/models/spree/stock_item.rb

@@ -2,39 +2,37 @@ module Spree
   class StockItem < Spree::Base
     acts_as_paranoid
 
-    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
-    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :stock_items, counter_cache: true
+    with_options inverse_of: :stock_items do
+      belongs_to :stock_location, class_name: 'Spree::StockLocation'
+      belongs_to :variant, class_name: 'Spree::Variant', counter_cache: true
+    end
     has_many :stock_movements, inverse_of: :stock_item
 
-    validates_presence_of :stock_location, :variant
-    validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
+    validates :stock_location, :variant, presence: true
+    validates :variant_id, uniqueness: { scope: [:stock_location_id, :deleted_at] }, allow_blank: true
 
-    validates_numericality_of :count_on_hand,
+    validates :count_on_hand, numericality: {
                               greater_than_or_equal_to: 0,
                               less_than_or_equal_to: 2**31 - 1,
-                              only_integer: true, if: :verify_count_on_hand?
+                              only_integer: true }, if: :verify_count_on_hand?
 
     delegate :weight, :should_track_inventory?, to: :variant
+    delegate :name, to: :variant, prefix: true
 
     after_save :conditional_variant_touch, if: :changed?
     after_touch { variant.touch }
 
     self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
 
+    scope :with_active_stock_location, -> { joins(:stock_location).merge(Spree::StockLocation.active) }
+
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
 
-    def variant_name
-      variant.name
-    end
-
     def adjust_count_on_hand(value)
       self.with_lock do
-        self.count_on_hand = self.count_on_hand + value
-        process_backorders(count_on_hand - count_on_hand_was)
-
-        self.save!
+        set_count_on_hand(count_on_hand + value)
       end
     end
 
@@ -67,10 +65,6 @@ module Spree
         count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
       end
 
-      def count_on_hand=(value)
-        write_attribute(:count_on_hand, value)
-      end
-
       # Process backorders based on amount of stock received
       # If stock was -20 and is now -15 (increase of 5 units), then we should process 5 inventory orders.
       # If stock was -20 but then was -25 (decrease of 5 units), do nothing.

data/app/models/spree/stock_location.rb

@@ -7,12 +7,12 @@ module Spree
     belongs_to :state, class_name: 'Spree::State'
     belongs_to :country, class_name: 'Spree::Country'
 
-    validates_presence_of :name
+    validates :name, presence: true
 
     scope :active, -> { where(active: true) }
     scope :order_default, -> { order(default: :desc, name: :asc) }
 
-    after_create :create_stock_items, :if => "self.propagate_all_variants?"
+    after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default
 
     def state_text
@@ -68,7 +68,7 @@ module Spree
       item = stock_item_or_create(variant)
       item.update_columns(
         count_on_hand: item.count_on_hand + quantity,
-        updated_at: Time.now
+        updated_at: Time.current
       )
     end
 
@@ -108,10 +108,7 @@ module Spree
 
       def ensure_one_default
         if self.default
-          StockLocation.where(default: true).where.not(id: self.id).each do |stock_location|
-            stock_location.default = false
-            stock_location.save!
-          end
+          StockLocation.where(default: true).where.not(id: self.id).update_all(default: false)
         end
       end
   end

data/app/models/spree/stock_movement.rb

@@ -5,15 +5,17 @@ module Spree
 
     after_create :update_stock_item_quantity
 
-    validates :stock_item, presence: true
-    validates :quantity, presence: true, numericality: {
-                 greater_than_or_equal_to: -2**31,
-                 less_than_or_equal_to: 2**31-1,
-                 only_integer: true,
-                 allow_nil: true
-              }
-
-    scope :recent, -> { order('created_at DESC') }
+    with_options presence: true do
+      validates :stock_item
+      validates :quantity, numericality: {
+                                            greater_than_or_equal_to: -2**31,
+                                            less_than_or_equal_to: 2**31 - 1,
+                                            only_integer: true,
+                                            allow_nil: true
+                                          }
+    end
+
+    scope :recent, -> { order(created_at: :desc) }
 
     self.whitelisted_ransackable_attributes = ['quantity']
 

data/app/models/spree/stock_transfer.rb

@@ -1,34 +1,27 @@
 module Spree
   class StockTransfer < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'T')
+
     extend FriendlyId
     friendly_id :number, slug_column: :number, use: :slugged
 
-    include Spree::NumberGenerator
-
-    def generate_number(options = {})
-      options[:prefix] ||= 'T'
-      super(options)
-    end
-
     has_many :stock_movements, as: :originator
 
     belongs_to :source_location, class_name: 'StockLocation'
     belongs_to :destination_location, class_name: 'StockLocation'
 
-    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id closed_at created_at number]
+    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id created_at number]
 
     def to_param
       number
     end
 
     def source_movements
-      stock_movements.joins(:stock_item)
-        .where('spree_stock_items.stock_location_id' => source_location_id)
+      find_stock_location_with_location_id(source_location_id)
     end
 
     def destination_movements
-      stock_movements.joins(:stock_item)
-        .where('spree_stock_items.stock_location_id' => destination_location_id)
+      find_stock_location_with_location_id(destination_location_id)
     end
 
     def transfer(source_location, destination_location, variants)
@@ -47,5 +40,11 @@ module Spree
     def receive(destination_location, variants)
       transfer(nil, destination_location, variants)
     end
+
+    private
+
+    def find_stock_location_with_location_id(location_id)
+      stock_movements.joins(:stock_item).where('spree_stock_items.stock_location_id' => location_id)
+    end
   end
 end

data/app/models/spree/store.rb

@@ -2,23 +2,27 @@ module Spree
   class Store < Spree::Base
     has_many :orders, class_name: "Spree::Order"
 
-    validates :code, presence: true, uniqueness: { allow_blank: true }
-    validates :name, presence: true
-    validates :url, presence: true
-    validates :mail_from_address, presence: true
+    with_options presence: true do
+      validates :code, uniqueness: { allow_blank: true }
+      validates :name, :url, :mail_from_address
+    end
 
     before_save :ensure_default_exists_and_is_unique
     before_destroy :validate_not_default
 
     scope :by_url, lambda { |url| where("url like ?", "%#{url}%") }
 
+    after_commit :clear_cache
+
     def self.current(domain = nil)
       current_store = domain ? Store.by_url(domain).first : nil
       current_store || Store.default
     end
 
     def self.default
-      where(default: true).first || new
+      Rails.cache.fetch("default_store") do
+        where(default: true).first_or_initialize
+      end
     end
 
     private
@@ -26,7 +30,7 @@ module Spree
     def ensure_default_exists_and_is_unique
       if default
         Store.where.not(id: id).update_all(default: false)
-      elsif Store.where(default: true).count == 0
+      elsif Store.where(default: true).count.zero?
         self.default = true
       end
     end
@@ -36,5 +40,9 @@ module Spree
         errors.add(:base, :cannot_destroy_default_store)
       end
     end
+
+    def clear_cache
+      Rails.cache.delete("default_store")
+    end
   end
 end

data/app/models/spree/store_credit.rb

@@ -0,0 +1,252 @@
+module Spree
+  class StoreCredit < Spree::Base
+    acts_as_paranoid
+
+    VOID_ACTION       = 'void'.freeze
+    CANCEL_ACTION     = 'cancel'.freeze
+    CREDIT_ACTION     = 'credit'.freeze
+    CAPTURE_ACTION    = 'capture'.freeze
+    ELIGIBLE_ACTION   = 'eligible'.freeze
+    AUTHORIZE_ACTION  = 'authorize'.freeze
+    ALLOCATION_ACTION = 'allocation'.freeze
+
+    DEFAULT_CREATED_BY_EMAIL = 'spree@example.com'.freeze
+
+    belongs_to :user, class_name: Spree.user_class.to_s, foreign_key: 'user_id'
+    belongs_to :category, class_name: "Spree::StoreCreditCategory"
+    belongs_to :created_by, class_name: Spree.user_class.to_s, foreign_key: 'created_by_id'
+    belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id'
+    has_many :store_credit_events
+
+    validates_presence_of :user, :category, :credit_type, :created_by, :currency
+    validates_numericality_of :amount, greater_than: 0
+    validates_numericality_of :amount_used, greater_than_or_equal_to: 0
+    validate :amount_used_less_than_or_equal_to_amount
+    validate :amount_authorized_less_than_or_equal_to_amount
+
+    delegate :name, to: :category, prefix: true
+    delegate :email, to: :created_by, prefix: true
+
+    scope :order_by_priority, -> { includes(:credit_type).order('spree_store_credit_types.priority ASC') }
+
+    before_validation :associate_credit_type
+    after_save :store_event
+    before_destroy :validate_no_amount_used
+
+    attr_accessor :action, :action_amount, :action_originator, :action_authorization_code
+
+    def display_amount
+      Spree::Money.new(amount)
+    end
+
+    def display_amount_used
+      Spree::Money.new(amount_used)
+    end
+
+    def amount_remaining
+      amount - amount_used - amount_authorized
+    end
+
+    def authorize(amount, order_currency, options = {})
+      authorization_code = options[:action_authorization_code]
+      if authorization_code
+        if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+          # Don't authorize again on capture
+          return true
+        end
+      else
+        authorization_code = generate_authorization_code
+      end
+
+      if validate_authorization(amount, order_currency)
+        update_attributes!(
+          action: AUTHORIZE_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code,
+          amount_authorized: amount_authorized + amount
+        )
+        authorization_code
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.insufficient_authorized_amount'))
+        false
+      end
+    end
+
+    def validate_authorization(amount, order_currency)
+      if amount_remaining.to_d < amount.to_d
+        errors.add(:base, Spree.t('store_credit_payment_method.insufficient_funds'))
+      elsif currency != order_currency
+        errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))
+      end
+      errors.blank?
+    end
+
+    def capture(amount, authorization_code, order_currency, options = {})
+      return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)
+
+      if amount <= amount_authorized
+        if currency != order_currency
+          errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))
+          false
+        else
+          update_attributes!(
+            action: CAPTURE_ACTION,
+            action_amount: amount,
+            action_originator: options[:action_originator],
+            action_authorization_code: authorization_code,
+            amount_used: amount_used + amount,
+            amount_authorized: amount_authorized - amount
+          )
+          authorization_code
+        end
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.insufficient_authorized_amount'))
+        false
+      end
+    end
+
+    def void(authorization_code, options = {})
+      if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+        update_attributes!(
+          action: VOID_ACTION,
+          action_amount: auth_event.amount,
+          action_authorization_code: authorization_code,
+          action_originator: options[:action_originator],
+          amount_authorized: amount_authorized - auth_event.amount
+        )
+        true
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.unable_to_void', auth_code: authorization_code))
+        false
+      end
+    end
+
+    def credit(amount, authorization_code, order_currency, options = {})
+      # Find the amount related to this authorization_code in order to add the store credit back
+      capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
+
+      if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
+        errors.add(:base, Spree.t('store_credit_payment_method.currency_mismatch'))
+        false
+      elsif capture_event && amount <= capture_event.amount
+        action_attributes = {
+          action: CREDIT_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code
+        }
+        create_credit_record(amount, action_attributes)
+        true
+      else
+        errors.add(:base, Spree.t('store_credit_payment_method.unable_to_credit', auth_code: authorization_code))
+        false
+      end
+    end
+
+    def actions
+      [CAPTURE_ACTION, VOID_ACTION, CREDIT_ACTION]
+    end
+
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    def can_void?(payment)
+      payment.pending?
+    end
+
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    def generate_authorization_code
+      "#{id}-SC-#{Time.now.utc.strftime('%Y%m%d%H%M%S%6N')}"
+    end
+
+    class << self
+      def default_created_by
+        Spree.user_class.find_by(email: DEFAULT_CREATED_BY_EMAIL)
+      end
+    end
+
+    private
+
+    def create_credit_record(amount, action_attributes = {})
+      # Setting credit_to_new_allocation to true will create a new allocation anytime #credit is called
+      # If it is not set, it will update the store credit's amount in place
+      credit = if Spree::Config.credit_to_new_allocation
+                 Spree::StoreCredit.new(create_credit_record_params(amount))
+               else
+                 self.amount_used = amount_used - amount
+                 self
+               end
+
+      credit.assign_attributes(action_attributes)
+      credit.save!
+    end
+
+    def create_credit_record_params(amount)
+      {
+        amount: amount,
+        user_id: user_id,
+        category_id: category_id,
+        created_by_id: created_by_id,
+        currency: currency,
+        type_id: type_id,
+        memo: credit_allocation_memo
+      }
+    end
+
+    def credit_allocation_memo
+      "This is a credit from store credit ID #{id}"
+    end
+
+    def store_event
+      return unless amount_changed? || amount_used_changed? || amount_authorized_changed? || action == ELIGIBLE_ACTION
+
+      event = if action
+                store_credit_events.build(action: action)
+              else
+                store_credit_events.where(action: ALLOCATION_ACTION).first_or_initialize
+              end
+
+      event.update_attributes!(
+        amount: action_amount || amount,
+        authorization_code: action_authorization_code || event.authorization_code || generate_authorization_code,
+        user_total_amount: user.total_available_store_credit,
+        originator: action_originator
+      )
+    end
+
+    def amount_used_less_than_or_equal_to_amount
+      return true if amount_used.nil?
+
+      if amount_used > amount
+        errors.add(:amount_used, :cannot_be_greater_than_amount)
+        false
+      end
+    end
+
+    def amount_authorized_less_than_or_equal_to_amount
+      if (amount_used + amount_authorized) > amount
+        errors.add(:amount_authorized, :exceeds_total_credits)
+        false
+      end
+    end
+
+    def validate_no_amount_used
+      if amount_used > 0
+        errors.add(:amount_used, :greater_than_zero_restrict_delete)
+        false
+      end
+    end
+
+    def associate_credit_type
+      unless type_id
+        credit_type_name = category.try(:non_expiring?) ? 'Non-expiring' : 'Expiring'
+        self.credit_type = Spree::StoreCreditType.find_by_name(credit_type_name)
+      end
+    end
+  end
+end