goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/calculator/tiered_percent.rb

@@ -0,0 +1,44 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredPercent < Calculator
+    preference :base_percent, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = Hash[*preferred_tiers.flatten.map(&:to_f)]
+      end
+    end
+
+    validates :preferred_base_percent, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: 100
+    }
+    validate :preferred_tiers_content
+
+    def self.description
+      Spree.t(:tiered_percent)
+    end
+
+    def compute(object)
+      base, percent = preferred_tiers.sort.reverse.detect{ |b,_| object.amount >= b }
+      (object.amount * (percent || preferred_base_percent) / 100).round(2)
+    end
+
+    private
+    def preferred_tiers_content
+      if preferred_tiers.is_a? Hash
+        unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }
+          errors.add(:base, :keys_should_be_positive_number)
+        end
+        unless preferred_tiers.values.all?{ |k| k.is_a?(Numeric) && k >= 0 && k <= 100 }
+          errors.add(:base, :values_should_be_percent)
+        end
+      else
+        errors.add(:preferred_tiers, :should_be_hash)
+      end
+    end
+  end
+end

data/app/models/spree/calculator.rb

@@ -0,0 +1,47 @@
+module Spree
+  class Calculator < Spree::Base
+    # Conditional check for backwards compatibilty since acts as paranoid was added late https://github.com/spree/spree/issues/5858
+    if ActiveRecord::Base.connected? && connection.data_source_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
+      acts_as_paranoid
+    end
+
+    belongs_to :calculable, polymorphic: true
+
+    # This method calls a compute_<computable> method. must be overriden in concrete calculator.
+    #
+    # It should return amount computed based on #calculable and the computable parameter
+    def compute(computable)
+      # Spree::LineItem -> :compute_line_item
+      computable_name = computable.class.name.demodulize.underscore
+      method = "compute_#{computable_name}".to_sym
+      calculator_class = self.class
+      if respond_to?(method)
+        self.send(method, computable)
+      else
+        raise NotImplementedError, "Please implement '#{method}(#{computable_name})' in your calculator: #{calculator_class.name}"
+      end
+    end
+
+    # overwrite to provide description for your calculators
+    def self.description
+      'Base Calculator'
+    end
+
+    # Returns all calculators applicable for kind of work
+    def self.calculators
+      Rails.application.config.spree.calculators
+    end
+
+    def to_s
+      self.class.name.titleize.gsub("Calculator\/", "")
+    end
+
+    def description
+      self.class.description
+    end
+
+    def available?(object)
+      true
+    end
+  end
+end

data/app/models/spree/classification.rb

@@ -0,0 +1,15 @@
+module Spree
+  class Classification < Spree::Base
+    self.table_name = 'spree_products_taxons'
+    acts_as_list scope: :taxon
+
+    with_options inverse_of: :classifications, touch: true do
+      belongs_to :product, class_name: "Spree::Product"
+      belongs_to :taxon, class_name: "Spree::Taxon"
+    end
+
+    validates :taxon, :product, presence: true
+    # For #3494
+    validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked, allow_blank: true }
+  end
+end

data/app/models/spree/country.rb

@@ -0,0 +1,40 @@
+module Spree
+  class Country < Spree::Base
+    has_many :states, dependent: :destroy
+    has_many :addresses, dependent: :restrict_with_error
+
+    has_many :zone_members,
+             -> { where(zoneable_type: 'Spree::Country') },
+             class_name: 'Spree::ZoneMember',
+             dependent: :destroy,
+             foreign_key: :zoneable_id
+
+    has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
+
+    before_destroy :ensure_not_default
+
+    validates :name, :iso_name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+
+    def self.default
+      country_id = Spree::Config[:default_country_id]
+      country_id.present? ? find(country_id) : find_by!(iso: 'US')
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+
+    private
+
+    def ensure_not_default
+      if id.eql?(Spree::Config[:default_country_id])
+        errors.add(:base, Spree.t(:default_country_cannot_be_deleted))
+        false
+      end
+    end
+  end
+end

data/app/models/spree/credit_card.rb

@@ -0,0 +1,166 @@
+module Spree
+  class CreditCard < Spree::Base
+    belongs_to :payment_method
+    belongs_to :user, class_name: Spree.user_class, foreign_key: 'user_id'
+    has_many :payments, as: :source
+
+    before_save :set_last_digits
+
+    after_save :ensure_one_default
+
+    # As of rails 4.2 string columns always return strings, we can override it on model level.
+    attribute :month, ActiveRecord::Type::Integer.new
+    attribute :year,  ActiveRecord::Type::Integer.new
+
+    attr_reader :number
+    attr_accessor :encrypted_data,
+                  :imported,
+                  :verification_value
+
+    with_options if: :require_card_numbers?, on: :create do
+      validates :month, :year, numericality: { only_integer: true }
+      validates :number, :verification_value, presence: true, unless: :imported
+      validates :name, presence: true
+    end
+
+    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :default, -> { where(default: true) }
+
+    # needed for some of the ActiveMerchant gateways (eg. SagePay)
+    alias_attribute :brand, :cc_type
+
+    # ActiveMerchant::Billing::CreditCard added this accessor used by some gateways.
+    # More info: https://github.com/spree/spree/issues/6209
+    #
+    # Returns or sets the track data for the card
+    #
+    # @return [String]
+    attr_accessor :track_data
+
+    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})?$/
+    }
+
+    def expiry=(expiry)
+      return unless expiry.present?
+
+      self[:month], self[:year] =
+      if expiry.match(/\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] / 100 == 0
+        self[:year] = self[:year].to_i
+      end
+      self[:month] = self[:month].to_i if self[:month]
+    end
+
+    def number=(num)
+      @number = num.gsub(/[^0-9]/, '') rescue nil
+    end
+
+    # cc_type is set by jquery.payment, which helpfully provides different
+    # types from Active Merchant. Converting them is necessary.
+    def cc_type=(type)
+      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
+
+    def set_last_digits
+      number.to_s.gsub!(/\s/,'')
+      verification_value.to_s.gsub!(/\s/,'')
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
+    def try_type_from_number
+      numbers = number.delete(' ') if number
+      CARD_TYPES.find{|type, pattern| return type.to_s if numbers =~ pattern}.to_s
+    end
+
+    def verification_value?
+      verification_value.present?
+    end
+
+    # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
+    def display_number
+      "XXXX-XXXX-XXXX-#{last_digits}"
+    end
+
+    def actions
+      %w{capture void credit}
+    end
+
+    # Indicates whether its possible to capture the payment
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most gateways require that the
+    # payment be settled first which generally happens within 12-24 hours of the transaction.
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    def has_payment_profile?
+      gateway_customer_profile_id.present? || gateway_payment_profile_id.present?
+    end
+
+    # ActiveMerchant needs first_name/last_name because we pass it a Spree::CreditCard and it calls those methods on it.
+    # Looking at the ActiveMerchant source code we should probably be calling #to_active_merchant before passing
+    # the object to ActiveMerchant but this should do for now.
+    def first_name
+      name.to_s.split(/[[:space:]]/, 2)[0]
+    end
+
+    def last_name
+      name.to_s.split(/[[:space:]]/, 2)[1]
+    end
+
+    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?
+      !self.encrypted_data.present? && !self.has_payment_profile?
+    end
+
+    def ensure_one_default
+      if self.user_id && self.default
+        CreditCard.where(default: true, user_id: self.user_id).where.not(id: self.id)
+          .update_all(default: false)
+      end
+    end
+  end
+end

data/app/models/spree/customer_return.rb

@@ -0,0 +1,67 @@
+module Spree
+  class CustomerReturn < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'CR', length: 9)
+    belongs_to :stock_location
+
+    has_many :reimbursements, inverse_of: :customer_return
+    has_many :return_authorizations, through: :return_items
+    has_many :return_items, inverse_of: :customer_return
+
+    after_create :process_return!
+
+    validates :return_items, :stock_location, presence: true
+    validate :must_have_return_authorization, on: :create
+    validate :return_items_belong_to_same_order
+
+    accepts_nested_attributes_for :return_items
+
+    extend DisplayMoney
+    money_methods pre_tax_total: { currency: Spree::Config[:currency] }
+
+    self.whitelisted_ransackable_attributes = ['number']
+
+    delegate :id, to: :order, prefix: true, allow_nil: true
+
+    def completely_decided?
+      !return_items.undecided.exists?
+    end
+
+    def fully_reimbursed?
+      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
+    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 pre_tax_total
+      return_items.sum(:pre_tax_amount)
+    end
+
+    private
+
+    def inventory_units
+      return_items.flat_map(&:inventory_unit)
+    end
+
+    def must_have_return_authorization
+      if item = return_items.find { |ri| ri.return_authorization.blank? }
+        errors.add(:base, Spree.t(:missing_return_authorization, item_name: item.inventory_unit.variant.name))
+      end
+    end
+
+    def process_return!
+      return_items.each(&:receive!)
+      order.return! if order.all_inventory_units_returned?
+    end
+
+    def return_items_belong_to_same_order
+      if return_items.any? { |return_item| return_item.inventory_unit.order_id != order_id }
+        errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
+      end
+    end
+  end
+end

data/app/models/spree/exchange.rb

@@ -0,0 +1,46 @@
+module Spree
+  class Exchange
+    class UnableToCreateShipments < StandardError; end
+
+    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!
+      shipments = Spree::Stock::Coordinator.new(@order, @reimbursement_objects.map(&:build_exchange_inventory_unit)).shipments
+      if shipments.flat_map(&:inventory_units).size != @reimbursement_objects.size
+        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!(@order)
+        shipment.finalize!
+      end
+    end
+
+    def to_key
+      nil
+    end
+
+    def self.param_key
+      "spree_exchange"
+    end
+
+    def self.model_name
+      Spree::Exchange
+    end
+
+  end
+end

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

@@ -0,0 +1,91 @@
+module Spree
+  class Gateway::Bogus < Gateway
+    TEST_VISA = ['4111111111111111','4012888888881881','4222222222222']
+    TEST_MC   = ['5500000000000004','5555555555554444','5105105105105100','2223000010309703']
+    TEST_AMEX = ['378282246310005','371449635398431','378734493671000','340000000000009']
+    TEST_DISC = ['6011000000000004','6011111111111117','6011000990139424']
+
+    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
+
+    attr_accessor :test
+
+    def provider_class
+      self.class
+    end
+
+    def preferences
+      {}
+    end
+
+    def create_profile(payment)
+      return if payment.source.has_payment_profile?
+      # simulate the storage of credit card profile using remote service
+      if success = VALID_CCS.include?(payment.source.number)
+        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+      end
+    end
+
+    def authorize(money, credit_card, options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'D' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+      end
+    end
+
+    def purchase(money, credit_card, options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'M' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+      end
+    end
+
+    def credit(money, credit_card, response_code, options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    end
+
+    def capture(money, authorization, gateway_options)
+      if authorization == '12345'
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
+      end
+
+    end
+
+    def void(response_code, credit_card, options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+    end
+
+    def cancel(_response_code)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def test?
+      # Test mode is not really relevant with bogus gateway (no such thing as live server)
+      true
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def actions
+      %w(capture void credit)
+    end
+
+    private
+      def generate_profile_id(success)
+        record = true
+        prefix = success ? 'BGS' : 'FAIL'
+        while record
+          random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
+          record = CreditCard.where(:gateway_customer_profile_id => random).first
+        end
+        random
+      end
+  end
+end

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

@@ -0,0 +1,26 @@
+# Bogus Gateway that doesn't support payment profiles
+module Spree
+  class Gateway::BogusSimple < Gateway::Bogus
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def authorize(money, credit_card, options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+      end
+    end
+
+    def purchase(money, credit_card, options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+      end
+    end
+
+  end
+end

data/app/models/spree/gateway.rb

@@ -0,0 +1,80 @@
+module Spree
+  class Gateway < PaymentMethod
+    FROM_DOLLAR_TO_CENT_RATE = 100.0
+
+    delegate :authorize, :purchase, :capture, :void, :credit, to: :provider
+
+    validates :type, presence: true
+
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    def payment_source_class
+      CreditCard
+    end
+
+    def provider
+      gateway_options = options
+      gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
+      if gateway_options[:server]
+        ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+      end
+      @provider ||= provider_class.new(gateway_options)
+    end
+
+    def options
+      self.preferences.inject({}){ |memo, (key, value)| memo[key.to_sym] = value; memo }
+    end
+
+    def method_missing(method, *args)
+      if @provider.nil? || !@provider.respond_to?(method)
+        super
+      else
+        provider.send(method, *args)
+      end
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def method_type
+      'gateway'
+    end
+
+    def exchange_multiplier
+      FROM_DOLLAR_TO_CENT_RATE
+    end
+
+    def supports?(source)
+      return true unless provider_class.respond_to? :supports?
+      return false unless source.brand
+      provider_class.supports?(source.brand)
+    end
+
+    def disable_customer_profile(source)
+      if source.is_a? CreditCard
+        source.update_column :gateway_customer_profile_id, nil
+      else
+        raise 'You must implement disable_customer_profile method for this gateway.'
+      end
+    end
+
+    def sources_by_order(order)
+      source_ids = order.payments.where(source_type: payment_source_class.to_s, payment_method_id: self.id).pluck(:source_id).uniq
+      payment_source_class.where(id: source_ids).with_payment_profile
+    end
+
+    def reusable_sources(order)
+      if order.completed?
+        sources_by_order order
+      else
+        if order.user_id
+          self.credit_cards.where(user_id: order.user_id).with_payment_profile
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/app/models/spree/image.rb

@@ -0,0 +1,43 @@
+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,
+                      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
+    before_save :find_dimensions, if: :attachment_updated_at_changed?
+
+    #used by admin products autocomplete
+    def mini_url
+      attachment.url(:mini, false)
+    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