spree 0.10.2 → 0.11.0

data/vendor/extensions/api/app/controllers/api/orders_controller.rb

@@ -6,11 +6,11 @@ class Api::OrdersController < Api::BaseController
 
     def object_serialization_options
       { :include => {
-          :bill_address => {},
-          :ship_address => {},
-          :shipments => {:include => [:shipping_method, :address]}, 
+          :bill_address => {:include => [:country, :state]},
+          :ship_address => {:include => [:country, :state]},
+          :shipments => {:include => [:shipping_method, :address]},
           :line_items => {:include => [:variant]}
-          } 
+          }
       }
     end
 

data/vendor/extensions/api/app/controllers/api/products_controller.rb

@@ -1,8 +1,12 @@
 class Api::ProductsController < Api::BaseController
   resource_controller_for_api
-  actions :index, :show
+  actions :index, :show, :create, :update
+  include Spree::Search
 
   private
+    define_method :collection do
+      @collection = retrieve_products
+    end
 
     def object_serialization_options
       { :include => [:master, :variants, :taxons] }

data/vendor/extensions/api/app/controllers/api/shipments_controller.rb

@@ -12,24 +12,24 @@ class Api::ShipmentsController < Api::BaseController
 
     def object_serialization_options
       { :include =>  {
-        :shipping_method => {}, 
-        :address => {}, 
+        :shipping_method => {},
+        :address => {:include => [:country, :state]},
         :inventory_units => {
           :include => {
             :variant => {
               :include => {
                 :product => {:only => [:name]}
-                } 
+                }
               }
             }
           }
         },
-        :except => [:shipping_method_id, :address_id] 
+        :except => [:shipping_method_id, :address_id]
       }
     end
-    
+
     def eager_load_associations
-      [:shipping_method, :address, {:inventory_units => [:variant]}]
+      [:shipping_method, {:shipping_charge => :order}, :address, {:inventory_units => [:variant]}]
     end
-      
+
 end

data/vendor/extensions/api/app/controllers/api/states_controller.rb

@@ -0,0 +1,5 @@
+class Api::StatesController < Api::BaseController
+  resource_controller_for_api
+  actions :index, :show
+  belongs_to :country
+end

data/vendor/extensions/api/config/locales/{en-US.yml → en.yml}

@@ -1,4 +1,4 @@
-en-US:
+en:
   api: "API"
   api:
     access: "API Access"
@@ -13,4 +13,4 @@ en-US:
     no_key: "No key defined"
     key_generated: "API key generated"
     key_cleared: "API key cleared"
-      
+

data/vendor/extensions/api/config/routes.rb

@@ -12,4 +12,9 @@ map.namespace :api do |api|
   end
   api.resources :inventory_units, :except => [:new,:edit], :member => {:event => :put}
   api.resources :products, :except => [:new,:edit]
+
+  api.resources :countries, :except => [:new,:edit] do |countries|
+    countries.resources :states, :except => [:new,:edit]
+  end
+  api.resources :states, :except => [:new,:edit]
 end

data/vendor/extensions/api/test/integration/orders_api_test.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/../test_helper'
 class OrdersApiTest < ActionController::IntegrationTest
   include ApiIntegrationHelper
   fixtures :payment_methods
-  
+
   context "orders" do
     setup do
       setup_user
@@ -45,7 +45,7 @@ class OrdersApiTest < ActionController::IntegrationTest
         end
       end
       context "create" do
-        setup do          
+        setup do
           @attributes = {
             :shipment => {
               :shipping_method_id => @order.shipment.shipping_method_id,
@@ -65,7 +65,7 @@ class OrdersApiTest < ActionController::IntegrationTest
         end
       end
     end
-    
+
     context "line_items" do
       context "list" do
         setup do
@@ -119,7 +119,7 @@ class OrdersApiTest < ActionController::IntegrationTest
         end
       end
     end
-      
+
   end
 
 end

data/vendor/extensions/overview_dashboard/app/views/admin/overview/index.html.erb

@@ -79,7 +79,7 @@
             <%= select_tag "orders_by_day_reports", options_for_select([[t('last_7_days'), "7_days"], [t('last_14_days'), "14_days"], [t('this_month'), "this_month"],
                                                     [t('last_month'), "last_month"], [t('this_year'), "this_year"], [t('last_year'), "last_year"] ], "7_days") %>
             <label><%= t('value') %>:</label>
-            <%= select_tag "orders_by_day_value", options_for_select([t('count'), t('value')], t('count')) %>
+            <%= select_tag "orders_by_day_value", options_for_select({t('count') => 'Count', t('value') => 'Value'}, 'Count') %>
           </div>
         </div>
       </div>

data/vendor/extensions/payment_gateway/app/models/gateway.rb

@@ -12,7 +12,7 @@ class Gateway < PaymentMethod
   
   # instantiates the selected gateway and configures with the options stored in the database
   def self.current
-    Gateway.find(:first, :conditions => {:active => true, :environment => ENV['RAILS_ENV']}) 
+    super
 	end	
   
   def provider

data/vendor/extensions/payment_gateway/app/models/gateway/authorize_net_cim.rb

@@ -1,6 +1,6 @@
 class Gateway::AuthorizeNetCim < Gateway
-	preference :login, :string
-	preference :password, :string
+  preference :login, :string
+  preference :password, :string
   preference :test_mode, :boolean, :default => false
 
   ActiveMerchant::Billing::Response.class_eval do
@@ -9,12 +9,12 @@ class Gateway::AuthorizeNetCim < Gateway
 
   def provider_class
     self.class
-  end	
+  end
 
   def authorize(amount, creditcard, gateway_options)
     create_transaction(amount, creditcard, :auth_only)
   end
-  
+
   def purchase(amount, creditcard, gateway_options)
     create_transaction(amount, creditcard, :auth_capture)
   end
@@ -22,24 +22,32 @@ class Gateway::AuthorizeNetCim < Gateway
   def capture(authorization, creditcard, gateway_options)
     create_transaction((authorization.amount * 100).round, creditcard, :prior_auth_capture, :trans_id => authorization.response_code)
   end
-  
+
   def credit(amount, creditcard, response_code, gateway_options)
     create_transaction(amount, creditcard, :refund, :trans_id => response_code)
   end
-  
+
   def void(response_code, creditcard, gateway_options)
     create_transaction(nil, creditcard, :void, :trans_id => response_code)
   end
-  
+
   def payment_profiles_supported?
-	  true
+    true
   end
 
   # Create a new CIM customer profile ready to accept a payment
-  def create_profile(creditcard, gateway_options)
-    if creditcard.gateway_customer_profile_id.nil?
-      profile_hash = create_customer_profile(creditcard, gateway_options)
-      creditcard.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
+  def create_profile(payment)
+    if payment.source.gateway_customer_profile_id.nil?
+      profile_hash = create_customer_profile(payment)
+      payment.source.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
+    end
+  end
+
+  # simpler form
+  def create_profile_from_card(card)
+    if card.gateway_customer_profile_id.nil?
+      profile_hash = create_customer_profile(card)
+      card.update_attributes(:gateway_customer_profile_id => profile_hash[:customer_profile_id], :gateway_payment_profile_id => profile_hash[:customer_payment_profile_id])
     end
   end
 
@@ -56,7 +64,7 @@ class Gateway::AuthorizeNetCim < Gateway
         amount = "%.2f" % (amount/100.0) # This gateway requires formated decimal, not cents
       end
       transaction_options = {
-        :type => transaction_type, 
+        :type => transaction_type,
         :amount => amount,
         :customer_profile_id => creditcard.gateway_customer_profile_id,
         :customer_payment_profile_id => creditcard.gateway_payment_profile_id,
@@ -67,27 +75,31 @@ class Gateway::AuthorizeNetCim < Gateway
       logger.debug("  response: #{t.inspect}\n")
       t
     end
-  
+
     # Create a new CIM customer profile ready to accept a payment
-    def create_customer_profile(creditcard, gateway_options)
-      options = options_for_create_customer_profile(creditcard, gateway_options)
+    def create_customer_profile(payment)
+      options = options_for_create_customer_profile(payment)
       response = cim_gateway.create_customer_profile(options)
       if response.success?
-        { :customer_profile_id => response.params["customer_profile_id"], 
+        { :customer_profile_id => response.params["customer_profile_id"],
           :customer_payment_profile_id => response.params["customer_payment_profile_id_list"].values.first }
       else
-        creditcard.gateway_error(response)
+        payment.gateway_error(response) if payment.respond_to? :gateway_error
+        payment.source.gateway_error(response)
       end
     end
 
-    def options_for_create_customer_profile(creditcard, gateway_options)
-        {:profile => { :merchant_customer_id => "#{Time.now.to_f}",
-          #:ship_to_list => generate_address_hash(creditcard.checkout.ship_address),
-          :payment_profiles => {
-            #:bill_to => generate_address_hash(creditcard.checkout.bill_address),
-            :payment => { :credit_card => creditcard}
-          }
-        }}
+    def options_for_create_customer_profile(payment)
+      if payment.is_a? Creditcard
+        info = { :bill_to => generate_address_hash(payment.address), :payment => { :credit_card => payment } }
+      else
+        info = { :bill_to => generate_address_hash(payment.order.bill_address),
+                 :payment => { :credit_card => payment.source } }
+      end
+      { :profile => { :merchant_customer_id => "#{Time.now.to_f}",
+                      #:ship_to_list => generate_address_hash(creditcard.checkout.ship_address),
+                      :payment_profiles => info }
+      }
     end
 
     # As in PaymentGateway but with separate name fields
@@ -100,7 +112,7 @@ class Gateway::AuthorizeNetCim < Gateway
     def cim_gateway
       ActiveMerchant::Billing::Base.gateway_mode = preferred_server.to_sym
       gateway_options = options
-  		ActiveMerchant::Billing::AuthorizeNetCimGateway.new(gateway_options)
-    end 
-    
+      ActiveMerchant::Billing::AuthorizeNetCimGateway.new(gateway_options)
+    end
+
 end

data/vendor/extensions/payment_gateway/app/models/gateway/bogus.rb

@@ -16,10 +16,10 @@ class Gateway::Bogus < Gateway
     {}
   end
   
-  def create_profile(creditcard, options = {})
+  def create_profile(payment)
     # simulate the storage of credit card profile using remote service
-    success = VALID_CCS.include? creditcard.number
-    creditcard.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+    success = VALID_CCS.include? payment.source.number
+    payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
   end
 
   def authorize(money, creditcard, options = {})

data/vendor/extensions/payment_gateway/app/models/gateway/eway.rb

@@ -0,0 +1,11 @@
+class Gateway::Eway < Gateway
+  preference :login, :string
+  
+  # Note: EWay supports purchase method only (no authorize method).
+  # Ensure Spree::Config[:auto_capture] is set to true
+  
+  def provider_class
+    ActiveMerchant::Billing::EwayGateway
+  end
+  
+end

data/vendor/extensions/payment_gateway/app/models/gateway/sage_pay.rb

@@ -0,0 +1,9 @@
+class Gateway::SagePay < Gateway
+  preference :login, :string
+  preference :password, :string
+  preference :account, :string
+
+  def provider_class
+    ActiveMerchant::Billing::SagePayGateway
+  end	
+end

data/vendor/extensions/payment_gateway/config/locales/{en-US.yml → en.yml}

@@ -1,4 +1,4 @@
-en-US:
+en:
   login: Login
   signature: Signature
   currency_code: "Currency Code"

data/vendor/extensions/payment_gateway/lib/spree/payment_gateway.rb

@@ -1,15 +1,15 @@
 module Spree
-  module PaymentGateway    
-    
+  module PaymentGateway
+
     def self.included(base)
       base.named_scope :with_payment_profile, :conditions => "gateway_customer_profile_id IS NOT NULL"
     end
-    
+
     def authorize(amount, payment)
       # ActiveMerchant is configured to use cents so we need to multiply order total by 100
-      response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))      
-      gateway_error_from_response(response) unless response.success?
-      
+      response = payment_gateway.authorize((amount * 100).round, self, gateway_options(payment))
+      gateway_error(response) unless response.success?
+
       # create a transaction to reflect the authorization
       save
       payment.txns << CreditcardTxn.create(
@@ -19,7 +19,7 @@ module Spree
         :avs_response => response.avs_result['code']
       )
     rescue ActiveMerchant::ConnectionError => e
-      gateway_error I18n.t(:unable_to_connect_to_gateway)      
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
     end
 
     def capture(payment)
@@ -32,7 +32,7 @@ module Spree
         # Standard ActiveMerchant capture usage
         response = payment_gateway.capture((transaction.amount * 100).round, transaction.response_code, minimal_gateway_options(payment))
       end
-      gateway_error_from_response(response) unless response.success?          
+      gateway_error(response) unless response.success?
 
       # create a transaction to reflect the capture
       save
@@ -43,14 +43,14 @@ module Spree
       )
       payment.finalize!
     rescue ActiveMerchant::ConnectionError => e
-      gateway_error I18n.t(:unable_to_connect_to_gateway)      
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
     end
 
     def purchase(amount, payment)
       #combined Authorize and Capture that gets processed by the ActiveMerchant gateway as one single transaction.
-      response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment)) 
-      
-      gateway_error_from_response(response) unless response.success?
+      response = payment_gateway.purchase((amount * 100).round, self, gateway_options(payment))
+
+      gateway_error(response) unless response.success?
 
       # create a transaction to reflect the purchase
       save
@@ -63,12 +63,12 @@ module Spree
     rescue ActiveMerchant::ConnectionError => e
       gateway_error t(:unable_to_connect_to_gateway)
     end
-    
+
     def void(payment)
       return unless transaction = purchase_or_authorize_transaction_for_payment(payment)
 
       response = payment_gateway.void(transaction.response_code, self, minimal_gateway_options(payment))
-      gateway_error_from_response(response) unless response.success?
+      gateway_error(response) unless response.success?
 
       # create a transaction to reflect the void
       save
@@ -82,17 +82,17 @@ module Spree
       payment.finalize!
     end
 
-    def credit(payment, amount=nil)      
+    def credit(payment, amount=nil)
       return unless transaction = purchase_or_authorize_transaction_for_payment(payment)
 
       amount ||= payment.order.outstanding_credit
-      
+
       if payment_gateway.payment_profiles_supported?
         response = payment_gateway.credit((amount * 100).round, self, transaction.response_code, minimal_gateway_options(payment))
       else
         response = payment_gateway.credit((amount * 100).round, transaction.response_code, minimal_gateway_options(payment))
       end
-      gateway_error_from_response(response) unless response.success?
+      gateway_error(response) unless response.success?
 
       # create a transaction to reflect the purchase
       save
@@ -104,7 +104,7 @@ module Spree
       payment.update_attribute(:amount, payment.amount - amount)
       payment.order.update_totals!
     rescue ActiveMerchant::ConnectionError => e
-      gateway_error I18n.t(:unable_to_connect_to_gateway)      
+      gateway_error I18n.t(:unable_to_connect_to_gateway)
     end
 
     # find the transaction associated with the original authorization/capture
@@ -135,71 +135,61 @@ module Spree
 
     # Can only refund a captured transaction but if transaction hasn't been cleared by merchant, refund may still fail
     def can_credit?(payment)
-      has_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) && 
-      has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID) and payment.order.credit_owed?
+      has_transaction_of_types?(payment, CreditcardTxn::TxnType::PURCHASE, CreditcardTxn::TxnType::CAPTURE) &&
+      has_no_transaction_of_types?(payment, CreditcardTxn::TxnType::VOID) and payment.order.outstanding_credit?
     end
 
     def has_payment_profile?
       gateway_customer_profile_id.present?
     end
 
+    def gateway_error(error)
+      if error.is_a? ActiveMerchant::Billing::Response
+        text = error.params['message'] ||
+               error.params['response_reason_text'] ||
+               error.message
+      else
+        text = error.to_s
+      end
 
-    
-    def gateway_error_from_response(response)
-      text = response.params['message'] || 
-             response.params['response_reason_text'] ||
-             response.message
-      gateway_error(text)
-    end
-    
-    def gateway_error(text)
-      msg = "#{I18n.t('gateway_error')} ... #{text}"
-      logger.error(msg)
-      raise Spree::GatewayError.new(msg)
+      logger.error(I18n.t('gateway_error'))
+      logger.error("  #{error.to_yaml}")
+      raise Spree::GatewayError.new(text)
     end
-        
+
     def gateway_options(payment)
-      options = {:billing_address  => generate_address_hash(payment.order.bill_address), 
+      options = {:billing_address  => generate_address_hash(payment.order.bill_address),
                  :shipping_address => generate_address_hash(payment.order.shipment.address)}
       options.merge minimal_gateway_options(payment)
-    end    
-    
+    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.  
+
+    # 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)
-      {:email    => payment.order.email, 
-       :customer => payment.order.email, 
-       :ip       => payment.order.ip_address, 
+      {:email    => payment.order.email,
+       :customer => payment.order.email,
+       :ip       => payment.order.ip_address,
        :order_id => payment.order.number,
        :shipping => payment.order.ship_total * 100,
-       :tax      => payment.order.tax_total * 100, 
-       :subtotal => payment.order.item_total * 100}  
+       :tax      => payment.order.tax_total * 100,
+       :subtotal => payment.order.item_total * 100}
     end
-    
+
     def spree_cc_type
-      return "visa" if ENV['RAILS_ENV'] == "development" 
+      return "visa" if ENV['RAILS_ENV'] == "development"
       self.class.type?(number)
     end
 
     def payment_gateway
       @payment_gateway ||= Gateway.current
-    end  
-    
-    # TODO: Want to do this after_save but there is a possible danger of infinite loop which number_changed? check is intended to prevent.
-    # Removed the check to number_changed? and relying on the !has_payment_profile? to not re-create if we have a profile
-    def create_payment_profile
-      return unless payment_gateway.payment_profiles_supported? and number and !has_payment_profile?
-      payment_gateway.create_profile(self, {})
-    rescue ActiveMerchant::ConnectionError => e
-      gateway_error I18n.t(:unable_to_connect_to_gateway)
     end
 
     private