spree_core 0.70.7 → 1.0.0.rc1

data/app/models/spree/asset.rb

@@ -0,0 +1,6 @@
+module Spree
+  class Asset < ActiveRecord::Base
+    belongs_to :viewable, :polymorphic => true
+    acts_as_list :scope => :viewable
+  end
+end

data/app/models/spree/billing_integration.rb

@@ -0,0 +1,24 @@
+module Spree
+  class BillingIntegration < PaymentMethod
+    validates :name, :presence => true
+
+    preference :server, :string, :default => 'test'
+    preference :test_mode, :boolean, :default => true
+
+    def provider
+      integration_options = options
+      ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
+      integration_options = options
+      integration_options[:test] = true if integration_options[:test_mode]
+      @provider ||= provider_class.new(integration_options)
+    end
+
+    def options
+      options_hash = {}
+      self.preferences.each do |key,value|
+        options_hash[key.to_sym] = value
+      end
+      options_hash
+    end
+  end
+end

data/app/models/spree/calculator.rb

@@ -0,0 +1,39 @@
+module Spree
+  class Calculator < ActiveRecord::Base
+    belongs_to :calculable, :polymorphic => true
+
+    # This method must be overriden in concrete calculator.
+    #
+    # It should return amount computed based on #calculable and/or optional parameter
+    def compute(something=nil)
+      raise(NotImplementedError, 'please use concrete calculator')
+    end
+
+    # overwrite to provide description for your calculators
+    def self.description
+      "Base Caclulator"
+    end
+
+    ###################################################################
+
+    def self.register(*klasses)
+    end
+
+    # Returns all calculators applicable for kind of work
+    def self.calculators
+      Rails.application.config.spree.calculators.all
+    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/calculator/default_tax.rb

@@ -0,0 +1,45 @@
+module Spree
+  class Calculator::DefaultTax < Calculator
+    def self.description
+      I18n.t(:default_tax)
+    end
+
+    def compute(computable)
+      case computable
+        when Spree::Order
+          compute_order(computable)
+        when Spree::LineItem
+          compute_line_item(computable)
+      end
+    end
+
+
+    private
+
+      def rate
+        rate = self.calculable
+      end
+
+      def compute_order(order)
+        matched_line_items = order.line_items.select do |line_item|
+          line_item.product.tax_category == rate.tax_category
+        end
+
+        line_items_total = matched_line_items.sum(&:total)
+        round_to_two_places(line_items_total * rate.amount)
+      end
+
+      def compute_line_item(line_item)
+        if line_item.product.tax_category == rate.tax_category
+          round_to_two_places(line_item.total * rate.amount)
+        else
+          0
+        end
+      end
+
+      def round_to_two_places(amount)
+        BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+      end
+
+  end
+end

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

@@ -0,0 +1,16 @@
+module Spree
+  class Calculator::FlatPercentItemTotal < Calculator
+    preference :flat_percent, :decimal, :default => 0
+
+    def self.description
+      I18n.t(:flat_percent)
+    end
+
+    def compute(object)
+      return unless object.present? and object.line_items.present?
+      item_total = object.line_items.map(&:amount).sum
+      value = item_total * BigDecimal(self.preferred_flat_percent.to_s) / 100.0
+      (value * 100).round.to_f / 100
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Spree
+  class Calculator::FlatRate < Calculator
+    preference :amount, :decimal, :default => 0
+
+    def self.description
+      I18n.t(:flat_rate_per_order)
+    end
+
+    def compute(object=nil)
+      self.preferred_amount
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Spree
+  class Calculator::FlexiRate < Calculator
+    preference :first_item,      :decimal, :default => 0.0
+    preference :additional_item, :decimal, :default => 0.0
+    preference :max_items,       :decimal, :default => 0.0
+
+    def self.description
+      I18n.t(:flexible_rate)
+    end
+
+    def self.available?(object)
+      true
+    end
+
+    def compute(object)
+      sum = 0
+      max = self.preferred_max_items
+      items_count = object.line_items.map(&:quantity).sum
+      items_count.times do |i|
+        # check max value to avoid divide by 0 errors
+        if (max == 0 && i == 0) || (max > 0) && (i % max == 0)
+          sum += self.preferred_first_item
+        else
+          sum += self.preferred_additional_item
+        end
+      end
+
+      sum
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Spree
+  class Calculator::PerItem < Calculator
+    preference :amount, :decimal, :default => 0
+
+    def self.description
+      I18n.t(:flat_rate_per_item)
+    end
+
+    def compute(object=nil)
+      self.preferred_amount * object.line_items.length
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Spree
+  class Calculator::PriceBucket < Calculator
+    preference :minimal_amount, :decimal, :default => 0
+    preference :normal_amount, :decimal, :default => 0
+    preference :discount_amount, :decimal, :default => 0
+
+    def self.description
+      I18n.t(:price_bucket)
+    end
+
+    # as object we always get line items, as calculable we have Coupon, ShippingMethod
+    def compute(object)
+      if object.is_a?(Array)
+        base = object.map { |o| o.respond_to?(:amount) ? o.amount : o.to_d }.sum
+      else
+        base = object.respond_to?(:amount) ? object.amount : object.to_d
+      end
+
+      if base >= self.preferred_minimal_amount
+        self.preferred_normal_amount
+      else
+        self.preferred_discount_amount
+      end
+    end
+  end
+end

data/app/models/spree/configuration.rb

@@ -0,0 +1,5 @@
+module Spree
+  class Configuration < ActiveRecord::Base
+
+  end
+end

data/app/models/spree/country.rb

@@ -0,0 +1,18 @@
+module Spree
+  class Country < ActiveRecord::Base
+    has_many :states
+
+    has_one :zone_member, :as => :zoneable
+    has_one :zone, :through => :zone_member
+
+    validates :name, :iso_name, :presence => true
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/app/models/spree/creditcard.rb

@@ -0,0 +1,273 @@
+module Spree
+  class Creditcard < ActiveRecord::Base
+    has_many :payments, :as => :source
+
+    before_save :set_last_digits
+    after_validation :set_card_type
+
+    attr_accessor :number, :verification_value
+
+    validates :month, :year, :numericality => { :only_integer => true }
+    validates :number, :presence => true, :unless => :has_payment_profile?, :on => :create
+    validates :verification_value, :presence => true, :unless => :has_payment_profile?, :on => :create
+
+    def process!(payment)
+      if Spree::Config[:auto_capture]
+        purchase(payment.amount.to_f, payment)
+      else
+        authorize(payment.amount.to_f, payment)
+      end
+    end
+
+    def set_last_digits
+      number.to_s.gsub!(/\s/,'') unless number.nil?
+      verification_value.to_s.gsub!(/\s/,'') unless number.nil?
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
+    # cheap hack to get to the type? method from deep within ActiveMerchant without stomping on
+    # potentially existing methods in CreditCard
+    class CardDetector
+      class << self
+        include ActiveMerchant::Billing::CreditCardMethods::ClassMethods
+      end
+    end
+
+    # sets self.cc_type while we still have the card number
+    def set_card_type
+      self.cc_type ||= CardDetector.type?(self.number)
+    end
+
+    def name?
+      first_name? && last_name?
+    end
+
+    def first_name?
+      first_name.present?
+    end
+
+    def last_name?
+      last_name.present?
+    end
+
+    def name
+      "#{first_name} #{last_name}"
+    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
+
+    #RAILS 3 TODO
+    #alias :attributes_with_quotes_default :attributes_with_quotes
+
+    # needed for some of the ActiveMerchant gateways (eg. SagePay)
+    def brand
+      cc_type
+    end
+
+    scope :with_payment_profile, where('gateway_customer_profile_id IS NOT NULL')
+
+    def authorize(amount, payment)
+      # ActiveMerchant is configured to use cents so we need to multiply order total by 100
+      payment_gateway = payment.payment_method
+      check_environment(payment_gateway)
+
+      response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))
+      record_log payment, response
+
+      if response.success?
+        payment.response_code = response.authorization
+        payment.avs_response = response.avs_result['code']
+        payment.pend
+      else
+        payment.failure
+        gateway_error(response)
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error e
+    end
+
+    def purchase(amount, payment)
+      #combined Authorize and Capture that gets processed by the ActiveMerchant gateway as one single transaction.
+      payment_gateway = payment.payment_method
+      check_environment(payment_gateway)
+
+      response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment))
+      record_log payment, response
+
+      if response.success?
+        payment.response_code = response.authorization
+        payment.avs_response = response.avs_result['code']
+        payment.complete
+      else
+        payment.failure
+        gateway_error(response) unless response.success?
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error e
+    end
+
+    def capture(payment)
+      return unless payment.pending?
+      payment_gateway = payment.payment_method
+      check_environment(payment_gateway)
+
+      if payment_gateway.payment_profiles_supported?
+        # Gateways supporting payment profiles will need access to creditcard object because this stores the payment profile information
+        # so supply the authorization itself as well as the creditcard, rather than just the authorization code
+        response = payment_gateway.capture(payment, self, minimal_gateway_options(payment, false))
+      else
+        # Standard ActiveMerchant capture usage
+        response = payment_gateway.capture((payment.amount * 100).round, payment.response_code, minimal_gateway_options(payment, false))
+      end
+
+      record_log payment, response
+
+      if response.success?
+        payment.response_code = response.authorization
+        payment.complete
+      else
+        payment.failure
+        gateway_error(response)
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error e
+    end
+
+    def void(payment)
+      payment_gateway = payment.payment_method
+      check_environment(payment_gateway)
+
+      response = payment_gateway.void(payment.response_code, minimal_gateway_options(payment, false))
+      record_log payment, response
+
+      if response.success?
+        payment.response_code = response.authorization
+        payment.void
+      else
+        gateway_error(response)
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error e
+    end
+
+    def credit(payment)
+      payment_gateway = payment.payment_method
+      check_environment(payment_gateway)
+
+      amount = payment.credit_allowed >= payment.order.outstanding_balance.abs ? payment.order.outstanding_balance.abs : payment.credit_allowed.abs
+      if payment_gateway.payment_profiles_supported?
+        response = payment_gateway.credit((amount * 100).round, self, payment.response_code, minimal_gateway_options(payment, false))
+      else
+        response = payment_gateway.credit((amount * 100).round, payment.response_code, minimal_gateway_options(payment, false))
+      end
+
+      record_log payment, response
+
+      if response.success?
+        Payment.create(:order => payment.order,
+                              :source => payment,
+                              :payment_method => payment.payment_method,
+                              :amount => amount.abs * -1,
+                              :response_code => response.authorization,
+                              :state => 'completed')
+      else
+        gateway_error(response)
+      end
+    rescue ActiveMerchant::ConnectionError => e
+      gateway_error e
+    end
+
+    def actions
+      %w{capture void credit}
+    end
+
+    # Indicates whether its possible to capture the payment
+    def can_capture?(payment)
+      payment.state == 'pending'
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      payment.state == 'void' ? false : true
+    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)
+      return false unless payment.state == 'completed'
+      return false unless payment.order.payment_state == 'credit_owed'
+      payment.credit_allowed > 0
+    end
+
+    def has_payment_profile?
+      gateway_customer_profile_id.present?
+    end
+
+    def record_log(payment, response)
+      payment.log_entries.create(:details => response.to_yaml)
+    end
+
+    def gateway_error(error)
+      if error.is_a? ActiveMerchant::Billing::Response
+        text = error.params['message'] || error.params['response_reason_text'] || error.message
+      elsif error.is_a? ActiveMerchant::ConnectionError
+        text = I18n.t(:unable_to_connect_to_gateway)
+      else
+        text = error.to_s
+      end
+      logger.error(I18n.t(:gateway_error))
+      logger.error("  #{error.to_yaml}")
+      raise Core::GatewayError.new(text)
+    end
+
+    def gateway_options(payment)
+      options = { :billing_address  => generate_address_hash(payment.order.bill_address),
+                  :shipping_address => generate_address_hash(payment.order.ship_address) }
+      options.merge minimal_gateway_options(payment)
+    end
+
+    # Generates an ActiveMerchant compatible address hash from one of Spree's address objects
+    def generate_address_hash(address)
+      return {} if address.nil?
+      { :name => address.full_name, :address1 => address.address1, :address2 => address.address2, :city => address.city,
+        :state => address.state_text, :zip => address.zipcode, :country => address.country.iso, :phone => address.phone }
+    end
+
+    # Generates a minimal set of gateway options.  There appears to be some issues with passing in
+    # a billing address when authorizing/voiding a previously captured transaction.  So omits these
+    # options in this case since they aren't necessary.
+    def minimal_gateway_options(payment, totals=true)
+
+      options = { :email    => payment.order.email,
+                  :customer => payment.order.email,
+                  :ip       => payment.order.ip_address,
+                  :order_id => payment.order.number }
+      if totals
+        options.merge!({ :shipping => payment.order.ship_total * 100,
+                         :tax      => payment.order.tax_total * 100,
+                         :subtotal => payment.order.item_total * 100 })
+      end
+      options
+    end
+
+    def spree_cc_type
+      return 'visa' if Rails.env == 'development'
+      self.cc_type
+    end
+
+    # Saftey check to make sure we're not accidentally performing operations on a live gateway.
+    # Ex. When testing in staging environment with a copy of production data.
+    def check_environment(gateway)
+      return if gateway.environment == Rails.env
+      message = I18n.t(:gateway_config_unavailable) + " - #{Rails.env}"
+      raise Core::GatewayError.new(message)
+    end
+  end
+end