solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/credit_card.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Spree
+  # The default `source` of a `Spree::Payment`.
+  #
+  class CreditCard < Spree::PaymentSource
+    belongs_to :user, class_name: Spree::UserClassHandle.new, foreign_key: 'user_id'
+    belongs_to :address
+
+    before_save :set_last_digits
+
+    accepts_nested_attributes_for :address
+
+    attr_reader :number, :verification_value
+    attr_accessor :encrypted_data
+
+    validates :month, :year, numericality: { only_integer: true }, if: :require_card_numbers?, on: :create
+    validates :number, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
+    validates :name, presence: true, if: :require_card_numbers?, on: :create
+    validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
+
+    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+
+    def self.default
+      Spree::Deprecation.warn("CreditCard.default is deprecated. Please use Spree::Wallet instead.")
+      joins(:wallet_payment_sources).where(spree_wallet_payment_sources: { default: true })
+    end
+
+    # needed for some of the ActiveMerchant gateways (eg. SagePay)
+    alias_attribute :brand, :cc_type
+
+    # Taken from ActiveMerchant
+    # https://github.com/activemerchant/active_merchant/blob/2f2acd4696e8de76057b5ed670b9aa022abc1187/lib/active_merchant/billing/credit_card_methods.rb#L5
+    CARD_TYPES = {
+      'visa'               => /^4\d{12}(\d{3})?(\d{3})?$/,
+      'master'             => /^(5[1-5]\d{4}|677189|222[1-9]\d{2}|22[3-9]\d{3}|2[3-6]\d{4}|27[01]\d{3}|2720\d{2})\d{10}$/,
+      'discover'           => /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/,
+      'american_express'   => /^3[47]\d{13}$/,
+      'diners_club'        => /^3(0[0-5]|[68]\d)\d{11}$/,
+      'jcb'                => /^35(28|29|[3-8]\d)\d{12}$/,
+      'switch'             => /^6759\d{12}(\d{2,3})?$/,
+      'solo'               => /^6767\d{12}(\d{2,3})?$/,
+      'dankort'            => /^5019\d{12}$/,
+      'maestro'            => /^(5[06-8]|6\d)\d{10,17}$/,
+      'forbrugsforeningen' => /^600722\d{10}$/,
+      'laser'              => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
+    }.freeze
+
+    def default
+      Spree::Deprecation.warn("CreditCard.default is deprecated. Please use user.wallet.default_wallet_payment_source instead.", caller)
+      return false if user.nil?
+      user.wallet.default_wallet_payment_source.try!(:payment_source) == self
+    end
+
+    def default=(set_as_default)
+      Spree::Deprecation.warn("CreditCard.default= is deprecated. Please use user.wallet.default_wallet_payment_source= instead.", caller)
+      if user.nil?
+        raise "Cannot set 'default' on a credit card without a user"
+      elsif set_as_default # setting this card as default
+        wallet_payment_source = user.wallet.add(self)
+        user.wallet.default_wallet_payment_source = wallet_payment_source
+        true
+      else # removing this card as default
+        if user.wallet.default_wallet_payment_source.try!(:payment_source) == self
+          user.wallet.default_wallet_payment_source = nil
+        end
+        false
+      end
+    end
+
+    def address_attributes=(attributes)
+      self.address = Spree::Address.immutable_merge(address, attributes)
+    end
+
+    # Sets the expiry date on this credit card.
+    #
+    # @param expiry [String] the desired new expiry date in one of the
+    #   following formats: "mm/yy", "mm / yyyy", "mmyy", "mmyyyy"
+    def expiry=(expiry)
+      return unless expiry.present?
+
+      self[:month], self[:year] =
+        if expiry =~ /\d{2}\s?\/\s?\d{2,4}/ # will match mm/yy and mm / yyyy
+          expiry.delete(' ').split('/')
+        elsif match = expiry.match(/(\d{2})(\d{2,4})/) # will match mmyy and mmyyyy
+          [match[1], match[2]]
+        end
+      if self[:year]
+        self[:year] = "20" + self[:year] if self[:year].length == 2
+        self[:year] = self[:year].to_i
+      end
+      self[:month] = self[:month].to_i if self[:month]
+    end
+
+    # Sets the credit card number, removing any non-numeric characters.
+    #
+    # @param num [String] the desired credit card number
+    def number=(num)
+      @number =
+        if num.is_a?(String)
+          num.gsub(/[^0-9]/, '')
+        end
+    end
+
+    def verification_value=(value)
+      @verification_value = value.to_s.gsub(/\s/, '')
+    end
+
+    # Sets the credit card type, converting it to the preferred internal
+    # representation from jquery.payment's representation when appropriate.
+    #
+    # @param type [String] the desired credit card type
+    def cc_type=(type)
+      # cc_type is set by jquery.payment, which helpfully provides different
+      # types from Active Merchant. Converting them is necessary.
+      self[:cc_type] = case type
+                       when 'mastercard', 'maestro' then 'master'
+                       when 'amex' then 'american_express'
+                       when 'dinersclub' then 'diners_club'
+                       when '' then try_type_from_number
+      else type
+      end
+    end
+
+    # Sets the last digits field based on the assigned credit card number.
+    def set_last_digits
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
+    # @return [String] the credit card type if it can be determined from the
+    #   number, otherwise the empty string
+    def try_type_from_number
+      CARD_TYPES.each do |type, pattern|
+        return type if number =~ pattern
+      end
+      ''
+    end
+
+    # @return [Boolean] true when a verification value is present
+    def verification_value?
+      verification_value.present?
+    end
+
+    # @return [String] the card number, with all but last 4 numbers replace
+    #   with "X", as in "XXXX-XXXX-XXXX-4338"
+    def display_number
+      "XXXX-XXXX-XXXX-#{last_digits}"
+    end
+
+    def reusable?
+      has_payment_profile?
+    end
+
+    # @return [Boolean] true when there is a gateway customer or payment
+    #   profile id present
+    def has_payment_profile?
+      gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
+    end
+
+    # @note ActiveMerchant needs first_name/last_name because we pass it a
+    #   Spree::CreditCard and it calls those methods on it.
+    # @todo We should probably be calling #to_active_merchant before passing
+    #   the object to ActiveMerchant.
+    # @return [String] the first name on this credit card
+    def first_name
+      name.to_s.split(/[[:space:]]/, 2)[0]
+    end
+
+    # @note ActiveMerchant needs first_name/last_name because we pass it a
+    #   Spree::CreditCard and it calls those methods on it.
+    # @todo We should probably be calling #to_active_merchant before passing
+    #   the object to ActiveMerchant.
+    # @return [String] the last name on this credit card
+    def last_name
+      name.to_s.split(/[[:space:]]/, 2)[1]
+    end
+
+    # @return [ActiveMerchant::Billing::CreditCard] an ActiveMerchant credit
+    #   card that represents this credit card
+    def to_active_merchant
+      ActiveMerchant::Billing::CreditCard.new(
+        number: number,
+        month: month,
+        year: year,
+        verification_value: verification_value,
+        first_name: first_name,
+        last_name: last_name
+      )
+    end
+
+    private
+
+    def require_card_numbers?
+      !encrypted_data.present? && !has_payment_profile?
+    end
+  end
+end

data/app/models/spree/customer_return.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Spree
+  class CustomerReturn < Spree::Base
+    belongs_to :stock_location
+
+    has_many :return_items, inverse_of: :customer_return
+    has_many :return_authorizations, through: :return_items
+    has_many :reimbursements, inverse_of: :customer_return
+
+    after_create :process_return!
+    before_create :generate_number
+
+    validates :return_items, presence: true
+    validates :stock_location, presence: true
+    validate :return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items
+
+    extend DisplayMoney
+    money_methods :pre_tax_total, :total, :total_excluding_vat, :amount
+    deprecate display_pre_tax_total: :display_total_excluding_vat, deprecator: Spree::Deprecation
+
+    delegate :currency, to: :order
+    delegate :id, to: :order, prefix: true, allow_nil: true
+
+    def total
+      return_items.map(&:total).sum
+    end
+
+    def total_excluding_vat
+      return_items.map(&:total_excluding_vat).sum
+    end
+    alias pre_tax_total total_excluding_vat
+    deprecate pre_tax_total: :total_excluding_vat, deprecator: Spree::Deprecation
+
+    def amount
+      return_items.sum(:amount)
+    end
+
+    # Temporarily tie a customer_return to one order
+    def order
+      return nil if return_items.blank?
+      return_items.first.inventory_unit.order
+    end
+
+    def fully_reimbursed?
+      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
+    end
+
+    def completely_decided?
+      !return_items.undecided.exists?
+    end
+
+    def process_return!
+      order.return! if order.all_inventory_units_returned?
+    end
+
+    private
+
+    def generate_number
+      self.number ||= loop do
+        random = "CR#{Array.new(9){ rand(9) }.join}"
+        break random unless self.class.exists?(number: random)
+      end
+    end
+
+    def return_items_belong_to_same_order
+      if return_items.reject{ |return_item| return_item.inventory_unit.order_id == order_id }.any?
+        errors.add(:base, I18n.t('spree.return_items_cannot_be_associated_with_multiple_orders'))
+      end
+    end
+
+    def inventory_units
+      return_items.flat_map(&:inventory_unit)
+    end
+  end
+end

data/app/models/spree/distributed_amounts_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Spree
+  class DistributedAmountsHandler
+    attr_reader :line_items, :total_amount
+
+    def initialize(line_items, total_amount)
+      @line_items = line_items
+      @total_amount = total_amount
+    end
+
+    # @param line_item [LineItem] one of the line_items distributed over
+    # @return [BigDecimal] the weighted adjustment for this line_item
+    def amount(line_item)
+      distributed_amounts[line_item.id].to_d
+    end
+
+    private
+
+    # @private
+    # @return [Hash<Integer, BigDecimal>] a hash of line item IDs and their
+    #   corresponding weighted adjustments
+    def distributed_amounts
+      Hash[line_item_ids.zip(allocated_amounts)]
+    end
+
+    def line_item_ids
+      line_items.map(&:id)
+    end
+
+    def elligible_amounts
+      line_items.map(&:amount)
+    end
+
+    def subtotal
+      elligible_amounts.sum
+    end
+
+    def allocated_amounts
+      total_amount.to_money.allocate(elligible_amounts).map(&:to_money)
+    end
+  end
+end

data/app/models/spree/exchange.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Spree
+  class Exchange
+    class UnableToCreateShipments < StandardError; end
+    extend ActiveModel::Naming
+
+    def initialize(order, reimbursement_objects)
+      @order = order
+      @reimbursement_objects = reimbursement_objects
+    end
+
+    def description
+      @reimbursement_objects.map do |reimbursement_object|
+        "#{reimbursement_object.variant.options_text} => #{reimbursement_object.exchange_variant.options_text}"
+      end.join(" | ")
+    end
+
+    def display_amount
+      Spree::Money.new @reimbursement_objects.map(&:total).sum
+    end
+
+    def perform!
+      begin
+        shipments = Spree::Config.stock.coordinator_class.new(@order, @reimbursement_objects.map(&:build_exchange_inventory_unit)).shipments
+      rescue Spree::Order::InsufficientStock
+        raise UnableToCreateShipments.new("Could not generate shipments for all items. Out of stock?")
+      end
+      @order.shipments += shipments
+      @order.save!
+      shipments.each do |shipment|
+        shipment.update_state
+        shipment.finalize!
+      end
+    end
+
+    def to_key
+      nil
+    end
+
+    def self.param_key
+      "spree_exchange"
+    end
+  end
+end

data/app/models/spree/fulfilment_changer.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Spree
+  # Service class to change fulfilment of inventory units of a particular variant
+  # to another shipment. The other shipment would typically have a different
+  # shipping method, stock location or delivery date, such that we actually change
+  # the planned fulfilment for the items in question.
+  #
+  # Can be used to merge shipments by moving all items to another shipment, because
+  # this class will delete any empty original shipment.
+  #
+  # @attr [Spree::Shipment] current_shipment The shipment we transfer units from
+  # @attr [Spree::Shipment] desired_shipment The shipment we want to move units onto
+  # @attr [Spree::StockLocation] current_stock_location The stock location of the current shipment
+  # @attr [Spree::StockLocation] desired_stock_location The stock location of the desired shipment
+  # @attr [Spree::Variant] variant We only move units that represent this variant
+  # @attr [Integer] quantity How many units we want to move
+  #
+  class FulfilmentChanger
+    include ActiveModel::Validations
+
+    attr_accessor :current_shipment, :desired_shipment
+    attr_reader :variant, :quantity, :current_stock_location, :desired_stock_location
+
+    def initialize(current_shipment:, desired_shipment:, variant:, quantity:)
+      @current_shipment = current_shipment
+      @desired_shipment = desired_shipment
+      @current_stock_location = current_shipment.stock_location
+      @desired_stock_location = desired_shipment.stock_location
+      @variant = variant
+      @quantity = quantity
+    end
+
+    validates :quantity, numericality: { greater_than: 0 }
+    validate :current_shipment_not_already_shipped
+    validate :desired_shipment_different_from_current
+    validates :desired_stock_location, presence: true
+    validate :enough_stock_at_desired_location, if: :handle_stock_counts?
+
+    # Performs the change of fulfilment
+    # @return [true, false] Whether the requested fulfilment change was successful
+    def run!
+      # Validations here are intended to catch all necessary prerequisites.
+      # We return early so all checks have happened already.
+      return false if invalid?
+      desired_shipment.save! if desired_shipment.new_record?
+
+      # Retrieve how many on hand items we can take from desired stock location
+      available_quantity = [desired_shipment.stock_location.count_on_hand(variant), 0].max
+
+      new_on_hand_quantity = [available_quantity, quantity].min
+      unstock_quantity = desired_shipment.stock_location.backorderable?(variant) ? quantity : new_on_hand_quantity
+
+      ActiveRecord::Base.transaction do
+        if handle_stock_counts?
+          # We only run this query if we need it.
+          current_on_hand_quantity = [current_shipment.inventory_units.pre_shipment.size, quantity].min
+
+          # Restock things we will not fulfil from the current shipment anymore
+          current_stock_location.restock(variant, current_on_hand_quantity, current_shipment)
+          # Unstock what we will fulfil with the new shipment
+          desired_stock_location.unstock(variant, unstock_quantity, desired_shipment)
+        end
+
+        # These two statements are the heart of this class. We change the number
+        # of inventory units requested from one shipment to the other.
+        # We order by state, because `'backordered' < 'on_hand'`.
+        current_shipment.
+          inventory_units.
+          where(variant: variant).
+          order(state: :asc).
+          limit(new_on_hand_quantity).
+          update_all(shipment_id: desired_shipment.id, state: :on_hand)
+
+        current_shipment.
+          inventory_units.
+          where(variant: variant).
+          order(state: :asc).
+          limit(quantity - new_on_hand_quantity).
+          update_all(shipment_id: desired_shipment.id, state: :backordered)
+      end
+
+      # We modified the inventory units at the database level for speed reasons.
+      # The downside of that is that we need to reload the associations.
+      current_shipment.inventory_units.reload
+      desired_shipment.inventory_units.reload
+
+      # If the current shipment now has no inventory units left, we won't need it any longer.
+      if current_shipment.inventory_units.length.zero?
+        current_shipment.destroy!
+      else
+        # The current shipment has changed, so we need to make sure that shipping rates
+        # have the correct amount.
+        current_shipment.refresh_rates
+      end
+
+      # The desired shipment has also change, so we need to make sure shipping rates
+      # are up-to-date, too.
+      desired_shipment.refresh_rates
+
+      # In order to reflect the changes in the order totals
+      desired_shipment.order.reload
+      desired_shipment.order.recalculate
+
+      true
+    end
+
+    private
+
+    # We don't need to handle stock counts for incomplete orders. Also, if
+    # the new shipment and the desired shipment will ship from the same stock location,
+    # unstocking and restocking will not be necessary.
+    def handle_stock_counts?
+      current_shipment.order.completed? && current_stock_location != desired_stock_location
+    end
+
+    def current_shipment_not_already_shipped
+      if current_shipment.shipped?
+        errors.add(:current_shipment, :has_already_been_shipped)
+      end
+    end
+
+    def enough_stock_at_desired_location
+      unless Spree::Stock::Quantifier.new(variant, desired_stock_location).can_supply?(quantity)
+        errors.add(:desired_shipment, :not_enough_stock_at_desired_location)
+      end
+    end
+
+    def desired_shipment_different_from_current
+      if desired_shipment.id == current_shipment.id
+        errors.add(:desired_shipment, :can_not_transfer_within_same_shipment)
+      end
+    end
+  end
+end

data/app/models/spree/gallery/product_gallery.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Spree
+  module Gallery
+    class ProductGallery
+      def initialize(product)
+        @product = product
+      end
+
+      # A list of all images associated with this gallery
+      #
+      # @return [Enumerable<Spree::Image>] all images in the gallery
+      def images
+        @images ||= @product.variant_images
+      end
+    end
+  end
+end

data/app/models/spree/gallery/variant_gallery.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Spree
+  module Gallery
+    class VariantGallery
+      def initialize(variant)
+        @variant = variant
+      end
+
+      # A list of all images associated with this gallery
+      #
+      # @return [Enumerable<Spree::Image>] all images in the gallery
+      def images
+        @images ||= @variant.images
+      end
+    end
+  end
+end

data/app/models/spree/gateway/bogus.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  # @deprecated Use Spree::PaymentMethod::BogusCreditCard instead
+  class Gateway::Bogus < PaymentMethod::BogusCreditCard
+    def initialize(*args)
+      Spree::Deprecation.warn \
+        'Spree::Gateway::Bogus is deprecated. ' \
+        'Please use Spree::PaymentMethod::BogusCreditCard instead'
+      super
+    end
+  end
+end

data/app/models/spree/gateway/bogus_simple.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  # @deprecated Use Spree::PaymentMethod::SimpleBogusCreditCard instead
+  class Gateway::BogusSimple < Spree::PaymentMethod::SimpleBogusCreditCard
+    def initialize(*args)
+      Spree::Deprecation.warn \
+        'Spree::Gateway::BogusSimple is deprecated. ' \
+        'Please use Spree::PaymentMethod::SimpleBogusCreditCard instead'
+      super
+    end
+  end
+end

data/app/models/spree/gateway.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Spree
+  # @deprecated Use Spree::PaymentMethod::CreditCard or Spree::PaymentMethod instead
+  class Gateway < PaymentMethod::CreditCard
+    def initialize(*args)
+      Spree::Deprecation.warn \
+        "Using Spree::Gateway as parent class of payment methods is deprecated. " \
+        "Please use Spree::PaymentMethod::CreditCard for credit card based payment methods " \
+        "or Spree::PaymentMethod for non credit card payment methods instead."
+      super
+    end
+  end
+end

data/app/models/spree/image.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Spree
+  class Image < Asset
+    validate :no_attachment_errors
+
+    has_attached_file :attachment,
+                      styles: { mini: '48x48>', small: '100x100>', product: '240x240>', large: '600x600>' },
+                      default_style: :product,
+                      default_url: 'noimage/:style.png',
+                      url: '/spree/products/:id/:style/:basename.:extension',
+                      path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
+                      convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
+    validates_attachment :attachment,
+      presence: true,
+      content_type: { content_type: %w(image/jpeg image/jpg image/png image/gif) }
+
+    # save the w,h of the original image (from which others can be calculated)
+    # we need to look at the write-queue for images which have not been saved yet
+    after_post_process :find_dimensions, if: :valid?
+
+    def mini_url
+      Spree::Deprecation.warn(
+        'Spree::Image#mini_url is DEPRECATED. Use Spree::Image#url(:mini) instead.'
+      )
+      attachment.url(:mini, false)
+    end
+
+    def url(size)
+      attachment.url(size)
+    end
+
+    def filename
+      attachment_file_name
+    end
+
+    def find_dimensions
+      temporary = attachment.queued_for_write[:original]
+      filename = temporary.path unless temporary.nil?
+      filename = attachment.path if filename.blank?
+      geometry = Paperclip::Geometry.from_file(filename)
+      self.attachment_width  = geometry.width
+      self.attachment_height = geometry.height
+    end
+
+    # if there are errors from the plugin, then add a more meaningful message
+    def no_attachment_errors
+      unless attachment.errors.empty?
+        # uncomment this to get rid of the less-than-useful interim messages
+        # errors.clear
+        errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
+        false
+      end
+    end
+  end
+end