spree_core 1.1.0.rc1 → 1.1.0.rc2

data/app/models/spree/mail_method.rb

@@ -16,7 +16,12 @@ module Spree
     preference :mail_bcc, :string, :default => 'spree@example.com'
     preference :intercept_email, :string, :default => nil
 
-    attr_accessible :environment, :preferred_enable_mail_delivery, :preferred_mails_from, :preferred_mail_bcc, :preferred_intercept_email, :preferred_mail_domain, :preferred_mail_host, :preferred_mail_port, :preferred_secure_connection_type, :preferred_mail_auth_type, :preferred_smtp_username, :preferred_smtp_password
+    attr_accessible :environment, :preferred_enable_mail_delivery,
+                    :preferred_mails_from, :preferred_mail_bcc,
+                    :preferred_intercept_email, :preferred_mail_domain,
+                    :preferred_mail_host, :preferred_mail_port,
+                    :preferred_secure_connection_type, :preferred_mail_auth_type,
+                    :preferred_smtp_username, :preferred_smtp_password
 
     validates :environment, :presence => true
 

data/app/models/spree/payment/processing.rb

@@ -0,0 +1,179 @@
+module Spree
+  class Payment < ActiveRecord::Base
+    module Processing
+      def process!
+        if payment_method && payment_method.source_required?
+          if source
+            if !processing?
+              if Spree::Config[:auto_capture]
+                purchase!
+              else
+                authorize!
+              end
+            end
+          else
+            raise Core::GatewayError.new(I18n.t(:payment_processing_failed))
+          end
+        end
+      end
+
+      def authorize!
+        started_processing!
+        gateway_action(source, :authorize, :pend)
+      end
+
+      def purchase!
+        started_processing!
+        gateway_action(source, :purchase, :complete)
+      end
+
+      def capture!
+        return unless pending?
+        protect_from_connection_error do
+          check_environment
+
+          if payment_method.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_method.capture(self, source, gateway_options)
+          else
+            # Standard ActiveMerchant capture usage
+            response = payment_method.capture((amount * 100).round,
+                                              response_code,
+                                              gateway_options)
+          end
+
+          handle_response(response, :complete, :failure)
+        end
+      end
+
+      def void_transaction!
+        protect_from_connection_error do
+          check_environment
+
+          response = payment_method.void(self.response_code, gateway_options)
+          record_response(response)
+
+          if response.success?
+            self.response_code = response.authorization
+            self.void
+          else
+            gateway_error(response)
+          end
+        end
+      end
+    end
+
+    def credit!(credit_amount=nil)
+      protect_from_connection_error do
+        check_environment
+
+        credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
+        credit_amount = credit_amount.to_f
+
+        if payment_method.payment_profiles_supported?
+          response = payment_method.credit((credit_amount * 100).round, source, response_code, gateway_options)
+        else
+          response = payment_method.credit((credit_amount * 100).round, response_code, gateway_options)
+        end
+
+        record_response(response)
+
+        if response.success?
+          self.class.create({ :order => order,
+                              :source => self,
+                              :payment_method => payment_method,
+                              :amount => credit_amount.abs * -1,
+                              :response_code => response.authorization,
+                              :state => 'completed' }, :without_protection => true)
+        else
+          gateway_error(response)
+        end
+      end
+    end
+
+    def partial_credit(amount)
+      return if amount > credit_allowed
+      started_processing!
+      credit!(amount)
+    end
+
+    private
+
+    def gateway_action(source, action, success_state)
+      protect_from_connection_error do
+        check_environment
+
+        response = payment_method.send(action, (amount * 100).round,
+                                       source,
+                                       gateway_options)
+        handle_response(response, success_state, :failure)
+      end
+    end
+
+    def handle_response(response, success_state, failure_state)
+      record_response(response)
+
+      if response.success?
+        self.response_code = response.authorization
+        self.avs_response = response.avs_result['code']
+        self.send(success_state)
+      else
+        self.send("#{failure_state}!")
+        gateway_error(response)
+      end
+    end
+
+    def record_response(response)
+      log_entries.create({:details => response.to_yaml}, :without_protection => true)
+    end
+
+    def gateway_options
+      options = { :email    => order.email,
+                  :customer => order.email,
+                  :ip       => order.ip_address,
+                  :order_id => order.number }
+
+      options.merge!({ :shipping => order.ship_total * 100,
+                       :tax      => order.tax_total * 100,
+                       :subtotal => order.item_total * 100 })
+
+      options.merge({ :billing_address  => order.bill_address.try(:active_merchant_hash),
+                      :shipping_address => order.ship_address.try(:active_merchant_hash) })
+    end
+
+    def protect_from_connection_error
+      begin
+        yield
+      rescue ActiveMerchant::ConnectionError => e
+        gateway_error(e)
+      end
+    end
+
+    def record_log(response)
+      log_entries.create({:details => response.to_yaml}, :without_protection => true)
+    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
+
+    # 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
+      return if payment_method.environment == Rails.env
+      message = I18n.t(:gateway_config_unavailable) + " - #{Rails.env}"
+      raise Core::GatewayError.new(message)
+    end
+
+  end
+end

data/app/models/spree/payment.rb

@@ -1,5 +1,6 @@
 module Spree
   class Payment < ActiveRecord::Base
+    include Spree::Payment::Processing
     belongs_to :order
     belongs_to :source, :polymorphic => true, :validate => true
     belongs_to :payment_method
@@ -27,11 +28,11 @@ module Spree
     state_machine :initial => 'checkout' do
       # With card payments, happens before purchase or authorization happens
       event :started_processing do
-        transition :from => ['checkout', 'pending', 'completed'], :to => 'processing'
+        transition :from => ['checkout', 'pending', 'completed', 'processing'], :to => 'processing'
       end
       # When processing during checkout fails
       event :failure do
-        transition :from => 'processing', :to => 'failed'
+        transition :from => ['processing', 'pending'], :to => 'failed'
       end
       # With card payments this represents authorizing the payment
       event :pend do
@@ -58,34 +59,14 @@ module Spree
       credit_allowed > 0
     end
 
-    def credit(amount)
-      return if amount > credit_allowed
-      started_processing!
-      source.credit(self, amount)
-    end
-    
     # see https://github.com/spree/spree/issues/981
     def build_source
       return if source_attributes.nil?
-
       if payment_method and payment_method.payment_source_class
         self.source = payment_method.payment_source_class.new(source_attributes)
       end
     end
 
-    def process!
-      if payment_method && payment_method.source_required?
-        if source
-          if !processing? && source.respond_to?(:process!)
-            started_processing!
-            source.process!(self) # source is responsible for updating the payment state when it's done processing
-          end
-        else
-          raise Core::GatewayError.new(I18n.t(:payment_processing_failed))
-        end
-      end
-    end
-
     def actions
       return [] unless payment_source and payment_source.respond_to? :actions
       payment_source.actions.select { |action| !payment_source.respond_to?("can_#{action}?") or payment_source.send("can_#{action}?", self) }

data/app/models/spree/payment_method.rb

@@ -1,6 +1,6 @@
 module Spree
   class PaymentMethod < ActiveRecord::Base
-    DISPLAY =  [:both, :front_end, :back_end]
+    DISPLAY = [:both, :front_end, :back_end]
     default_scope where(:deleted_at => nil)
 
     scope :production, where(:environment => 'production')
@@ -22,7 +22,7 @@ module Spree
       raise 'You must implement payment_source_class method for this gateway.'
     end
 
-    def self.available(display_on='both')
+    def self.available(display_on = 'both')
       all.select { |p| p.active && (p.display_on == display_on.to_s || p.display_on.blank?) && (p.environment == Rails.env || p.environment.blank?) }
     end
 

data/app/models/spree/product.rb

@@ -71,7 +71,8 @@ module Spree
     attr_accessible :name, :description, :available_on, :permalink, :meta_description,
                     :meta_keywords, :price, :sku, :deleted_at, :prototype_id,
                     :option_values_hash, :on_hand, :weight, :height, :width, :depth,
-                    :shipping_category_id, :tax_category_id
+                    :shipping_category_id, :tax_category_id, :product_properties_attributes,
+                    :variants_attributes
 
     attr_accessible :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
 
@@ -85,7 +86,7 @@ module Spree
     after_initialize :ensure_master
 
     def ensure_master
-      return unless self.new_record?
+      return unless new_record?
       self.master ||= Variant.new
     end
 
@@ -132,8 +133,8 @@ module Spree
     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 self.option_type_ids.include?(id)
-        self.product_option_types.create({:option_type_id => id}, :without_protection => true) unless product_option_types.map(&:option_type_id).include?(id)
+        self.option_type_ids << id unless option_type_ids.include?(id)
+        product_option_types.create({:option_type_id => id}, :without_protection => true) unless product_option_types.map(&:option_type_id).include?(id)
       end
     end
 
@@ -141,12 +142,12 @@ module Spree
     # define "duplicate_extra" for site-specific actions, eg for additional fields
     def duplicate
       p = self.dup
-      p.name = 'COPY OF ' + self.name
+      p.name = 'COPY OF ' + name
       p.deleted_at = nil
       p.created_at = p.updated_at = nil
-      p.taxons = self.taxons
+      p.taxons = taxons
 
-      p.product_properties = self.product_properties.map { |q| r = q.dup; r.created_at = r.updated_at = nil; r }
+      p.product_properties = product_properties.map { |q| r = q.dup; r.created_at = r.updated_at = nil; r }
 
       image_dup = lambda { |i| j = i.dup; j.attachment = i.attachment.clone; j }
 
@@ -157,7 +158,7 @@ module Spree
       p.master = variant
 
       # don't dup the actual variants, just the characterising types
-      p.option_types = self.option_types if self.has_variants?
+      p.option_types = option_types if has_variants?
         
       # allow site to do some customization
       p.send(:duplicate_extra, self) if p.respond_to?(:duplicate_extra)
@@ -180,7 +181,7 @@ module Spree
     end
 
     def effective_tax_rate
-      if self.tax_category
+      if tax_category
         tax_category.effective_amount
       else
         TaxRate.default
@@ -207,7 +208,7 @@ module Spree
         values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
 
         values.each do |ids|
-          variant = self.variants.create({:option_value_ids => ids, :price => self.master.price}, :without_protection => true)
+          variant = variants.create({ :option_value_ids => ids, :price => master.price }, :without_protection => true)
         end
         save
       end

data/app/models/spree/product_property.rb

@@ -6,6 +6,8 @@ module Spree
     validates :property, :presence => true
     validates_length_of :value, :maximum => 255
 
+    attr_accessible :property_name, :value
+
     # virtual attributes for use with AJAX completion stuff
     def property_name
       property.name if property

data/app/models/spree/return_authorization.rb

@@ -9,6 +9,8 @@ module Spree
     validates :amount, :numericality => true
     validate :must_have_shipped_units
 
+    attr_accessible :amount, :reason
+
     state_machine :initial => 'authorized' do
       after_transition :to => 'received', :do => :process_return
 
@@ -21,8 +23,8 @@ module Spree
     end
 
     def add_variant(variant_id, quantity)
-      order_units = self.order.inventory_units.group_by(&:variant_id)
-      returned_units = self.inventory_units.group_by(&:variant_id)
+      order_units = order.inventory_units.group_by(&:variant_id)
+      returned_units = inventory_units.group_by(&:variant_id)
 
       count = 0
 
@@ -44,7 +46,7 @@ module Spree
         end
       end
 
-      self.order.authorize_return! if self.inventory_units.reload.size > 0 && !self.order.awaiting_return?
+      order.authorize_return! if inventory_units.reload.size > 0 && !order.awaiting_return?
     end
 
     private
@@ -53,7 +55,7 @@ module Spree
       end
 
       def generate_number
-        return if self.number
+        return if number
 
         record = true
         while record
@@ -65,8 +67,8 @@ module Spree
 
       def process_return
         inventory_units.each &:return!
-        credit = Adjustment.create(:source => self, :adjustable => order, :amount => self.amount.abs * -1, :label => I18n.t(:rma_credit))
-        self.order.update!
+        credit = Adjustment.create(:source => self, :adjustable => order, :amount => amount.abs * -1, :label => I18n.t(:rma_credit))
+        order.update!
       end
 
       def allow_receive?
@@ -74,7 +76,7 @@ module Spree
       end
 
       def force_positive_amount
-        self.amount = self.amount.abs
+        self.amount = amount.abs
       end
   end
 end

data/app/models/spree/shipment.rb

@@ -14,7 +14,8 @@ module Spree
 
     attr_accessor :special_instructions
 
-    attr_accessible :order, :state, :shipping_method, :special_instructions, :shipping_method_id, :tracking
+    attr_accessible :order, :state, :shipping_method, :special_instructions,
+                    :shipping_method_id, :tracking
 
     accepts_nested_attributes_for :address
     accepts_nested_attributes_for :inventory_units
@@ -29,9 +30,9 @@ module Spree
     scope :pending, where(:state => 'pending')
 
     def to_param
-      self.number if self.number
-      generate_shipment_number unless self.number
-      self.number.to_s.to_url.upcase
+      number if number
+      generate_shipment_number unless number
+      number.to_s.to_url.upcase
     end
 
     def shipped=(value)
@@ -83,7 +84,7 @@ module Spree
     # Order object.  This is necessary because the association actually has a stale (and unsaved) copy of the Order and so it will not
     # yield the correct results.
     def update!(order)
-      old_state = self.state
+      old_state = state
       new_state = determine_state(order)
       update_attribute_without_callbacks 'state', determine_state(order)
       after_ship if new_state == 'shipped' and old_state != 'shipped'
@@ -91,7 +92,7 @@ module Spree
 
     private
       def generate_shipment_number
-        return self.number unless self.number.blank?
+        return number unless number.blank?
         record = true
         while record
           random = "H#{Array.new(11){rand(9)}.join}"

data/app/models/spree/shipping_method.rb

@@ -1,22 +1,23 @@
 module Spree
   class ShippingMethod < ActiveRecord::Base
-    DISPLAY =  [:both, :front_end, :back_end]
+    DISPLAY = [:both, :front_end, :back_end]
     belongs_to :zone
     has_many :shipments
     validates :name, :calculator, :zone, :presence => true
     belongs_to :shipping_category
 
-    attr_accessible :name, :zone_id, :display_on, :shipping_category_id, :match_none, :match_one, :match_all, :calculator_type
+    attr_accessible :name, :zone_id, :display_on, :shipping_category_id, 
+                    :match_none, :match_one, :match_all, :calculator_type
 
     calculated_adjustments
 
-    def available?(order, display_on=nil)
+    def available?(order, display_on = nil)
       display_check = (self.display_on == display_on.to_s || self.display_on.blank?)
       calculator_check = calculator.available?(order)
       display_check && calculator_check
     end
 
-    def available_to_order?(order, display_on=nil)
+    def available_to_order?(order, display_on = nil)
       availability_check = available?(order,display_on)
       zone_check = zone && zone.include?(order.ship_address)
       category_check = category_match?(order)
@@ -37,7 +38,7 @@ module Spree
       end
     end
 
-    def self.all_available(order, display_on=nil)
+    def self.all_available(order, display_on = nil)
       all.select { |method| method.available_to_order?(order,display_on) }
     end
   end

data/app/models/spree/shipping_rate.rb

@@ -1,7 +1,7 @@
 module Spree
   class ShippingRate < Struct.new(:id, :shipping_method, :name, :cost)
-    def initialize(attributes={})
-      attributes.each do |k,v|
+    def initialize(attributes = {})
+      attributes.each do |k, v|
         self.send("#{k}=", v)
       end
     end

data/app/models/spree/state.rb

@@ -8,7 +8,7 @@ module Spree
     validates :country, :name, :presence => true
 
     def self.find_all_by_name_or_abbr(name_or_abbr)
-      where("name = ? OR abbr = ?", name_or_abbr, name_or_abbr)
+      where('name = ? OR abbr = ?', name_or_abbr, name_or_abbr)
     end
 
     # table of { country.id => [ state.id , state.name ] }, arrays sorted by name

data/app/models/spree/tax_category.rb

@@ -14,13 +14,13 @@ module Spree
       #set existing default tax category to false if this one has been marked as default
 
       if is_default && tax_category = self.class.where(:is_default => true).first
-        tax_category.update_attribute(:is_default, false)
+        tax_category.update_attribute(:is_default, false) unless tax_category == self
       end
     end
 
     def mark_deleted!
       self.deleted_at = Time.now
-      self.save
+      save
     end
   end
 end

data/app/models/spree/tax_rate.rb

@@ -20,7 +20,7 @@ module Spree
     calculated_adjustments
     scope :by_zone, lambda { |zone| where(:zone_id => zone) }
 
-    attr_accessible :amount, :tax_category_id, :calculator
+    attr_accessible :amount, :tax_category_id, :calculator, :zone_id, :included_in_price
 
     # Gets the array of TaxRates appropriate for the specified order
     def self.match(order)
@@ -46,17 +46,17 @@ module Spree
     # Creates necessary tax adjustments for the order.
     def adjust(order)
       label = "#{tax_category.name} #{amount * 100}%"
-      if self.included_in_price
+      if included_in_price
         if Zone.default_tax.contains? order.tax_zone
           order.line_items.each { |line_item| create_adjustment(label, line_item, line_item) }
         else
           amount = -1 * calculator.compute(order)
           label = I18n.t(:refund) + label
-          order.adjustments.create({:amount => amount,
-                                   :source => order,
-                                   :originator => self,
-                                   :locked => true,
-                                   :label => label}, :without_protection => true)
+          order.adjustments.create({ :amount => amount,
+                                     :source => order,
+                                     :originator => self,
+                                     :locked => true,
+                                     :label => label }, :without_protection => true)
         end
       else
         create_adjustment(label, order, order)

data/app/models/spree/taxon.rb

@@ -6,7 +6,7 @@ module Spree
     has_and_belongs_to_many :products, :join_table => 'spree_products_taxons'
     before_create :set_permalink
 
-    attr_accessible :name, :parent_id, :position
+    attr_accessible :name, :parent_id, :position, :description, :permalink
 
     validates :name, :presence => true
     has_attached_file :icon,
@@ -33,15 +33,15 @@ module Spree
     # Creates permalink based on Stringex's .to_url method
     def set_permalink
       if parent_id.nil?
-        self.permalink = name.to_url if self.permalink.blank?
+        self.permalink = name.to_url if permalink.blank?
       else
         parent_taxon = Taxon.find(parent_id)
-        self.permalink = [parent_taxon.permalink, (self.permalink.blank? ? name.to_url : self.permalink.split('/').last)].join('/')
+        self.permalink = [parent_taxon.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
       end
     end
 
     def active_products
-      scope = self.products.active
+      scope = products.active
       scope = scope.on_hand unless Spree::Config[:show_zero_stock_products]
       scope
     end

data/app/models/spree/taxonomy.rb

@@ -12,10 +12,10 @@ module Spree
 
     private
       def set_name
-        if self.root
-          self.root.update_attribute(:name, self.name)
+        if root
+          root.update_attribute(:name, name)
         else
-          self.root = Taxon.create!({ :taxonomy_id => self.id, :name => self.name }, :without_protection => true)
+          self.root = Taxon.create!({ :taxonomy_id => id, :name => name }, :without_protection => true)
         end
       end