You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

472 lines
18 KiB

module Spree
CheckoutController.class_eval do
before_filter :redirect_to_paypal_express_form_if_needed, :only => [:update]
def paypal_checkout
load_order
opts = all_opts(@order, params[:payment_method_id], 'checkout')
opts.merge!(address_options(@order))
@gateway = paypal_gateway
if Spree::Config[:auto_capture]
@ppx_response = @gateway.setup_purchase(opts[:money], opts)
else
@ppx_response = @gateway.setup_authorization(opts[:money], opts)
end
unless @ppx_response.success?
gateway_error(@ppx_response)
redirect_to edit_order_url(@order)
return
end
redirect_to(@gateway.redirect_url_for(response.token, :review => payment_method.preferred_review))
rescue ActiveMerchant::ConnectionError => e
gateway_error I18n.t(:unable_to_connect_to_gateway)
redirect_to :back
end
def paypal_payment
load_order
opts = all_opts(@order,params[:payment_method_id], 'payment')
unless payment_method.preferred_cart_checkout
opts.merge!(address_options(@order))
else
opts.merge!(shipping_options)
end
@gateway = paypal_gateway
if Spree::Config[:auto_capture]
@ppx_response = @gateway.setup_purchase(opts[:money], opts)
else
@ppx_response = @gateway.setup_authorization(opts[:money], opts)
end
unless @ppx_response.success?
gateway_error(@ppx_response)
redirect_to edit_order_checkout_url(@order, :state => "payment")
return
end
redirect_to(@gateway.redirect_url_for(@ppx_response.token, :review => payment_method.preferred_review))
rescue ActiveMerchant::ConnectionError => e
gateway_error I18n.t(:unable_to_connect_to_gateway)
redirect_to :back
end
def paypal_confirm
load_order
opts = { :token => params[:token], :payer_id => params[:PayerID] }.merge all_opts(@order, params[:payment_method_id], 'payment')
gateway = paypal_gateway
@ppx_details = gateway.details_for params[:token]
if @ppx_details.success?
# now save the updated order info
#TODO Search for existing records
Spree::PaypalAccount.create(:email => @ppx_details.params["payer"],
:payer_id => @ppx_details.params["payer_id"],
:payer_country => @ppx_details.params["payer_country"],
:payer_status => @ppx_details.params["payer_status"])
@order.special_instructions = @ppx_details.params["note"]
unless payment_method.preferred_no_shipping
ship_address = @ppx_details.address
order_ship_address = Spree::Address.new :firstname => @ppx_details.params["first_name"],
:lastname => @ppx_details.params["last_name"],
:address1 => ship_address["address1"],
:address2 => ship_address["address2"],
:city => ship_address["city"],
:country => Spree::Country.find_by_iso(ship_address["country"]),
:zipcode => ship_address["zip"],
# phone is currently blanked in AM's PPX response lib
:phone => @ppx_details.params["phone"] || "(not given)"
state = Spree::State.find_by_abbr(ship_address["state"].upcase) if ship_address["state"].present?
if state
order_ship_address.state = state
else
order_ship_address.state_name = ship_address["state"]
end
order_ship_address.save!
@order.ship_address = order_ship_address
@order.bill_address ||= order_ship_address
#Add Instant Update Shipping
if payment_method.preferred_cart_checkout
add_shipping_charge
end
end
@order.state = "payment"
@order.save
if payment_method.preferred_review
@order.next
render 'spree/shared/paypal_express_confirm'
else
paypal_finish
end
else
gateway_error(@ppx_details)
#Failed trying to get payment details from PPX
redirect_to edit_order_checkout_url(@order, :state => "payment")
end
rescue ActiveMerchant::ConnectionError => e
gateway_error I18n.t(:unable_to_connect_to_gateway)
redirect_to edit_order_url(@order)
end
def paypal_finish
load_order
opts = { :token => params[:token], :payer_id => params[:PayerID] }.merge all_opts(@order, params[:payment_method_id], 'payment' )
gateway = paypal_gateway
method = Spree::Config[:auto_capture] ? :purchase : :authorize
ppx_auth_response = gateway.send(method, (@order.total*100).to_i, opts)
paypal_account = Spree::PaypalAccount.find_by_payer_id(params[:PayerID])
payment = @order.payments.create(
:amount => ppx_auth_response.params["gross_amount"].to_f,
:source => paypal_account,
:source_type => 'Spree::PaypalAccount',
:payment_method_id => params[:payment_method_id],
:response_code => ppx_auth_response.authorization,
:avs_response => ppx_auth_response.avs_result["code"])
payment.started_processing!
record_log payment, ppx_auth_response
if ppx_auth_response.success?
#confirm status
case ppx_auth_response.params["payment_status"]
when "Completed"
payment.complete!
when "Pending"
payment.pend!
else
payment.pend!
Rails.logger.error "Unexpected response from PayPal Express"
Rails.logger.error ppx_auth_response.to_yaml
end
@order.update_attributes({:state => "complete", :completed_at => Time.now}, :without_protection => true)
state_callback(:after) # So that after_complete is called, setting session[:order_id] to nil
# Since we dont rely on state machine callback, we just explicitly call this method for spree_store_credits
if @order.respond_to?(:consume_users_credit, true)
@order.send(:consume_users_credit)
end
@order.finalize!
flash[:notice] = I18n.t(:order_processed_successfully)
redirect_to completion_route
else
payment.failure!
order_params = {}
gateway_error(ppx_auth_response)
#Failed trying to complete pending payment!
redirect_to edit_order_checkout_url(@order, :state => "payment")
end
rescue ActiveMerchant::ConnectionError => e
gateway_error I18n.t(:unable_to_connect_to_gateway)
redirect_to edit_order_url(@order)
end
private
def asset_url(_path)
URI::HTTP.build(:path => ActionController::Base.helpers.asset_path(_path), :host => Spree::Config[:site_url].strip).to_s
end
def record_log(payment, response)
payment.log_entries.create(:details => response.to_yaml)
end
def redirect_to_paypal_express_form_if_needed
return unless (params[:state] == "payment")
return unless params[:order][:payments_attributes]
if @order.update_attributes(object_params)
if params[:order][:coupon_code] and !params[:order][:coupon_code].blank? and @order.coupon_code.present?
event_name = "spree.checkout.coupon_code_added"
if promo = Spree::Promotion.with_coupon_code(@order.coupon_code).where(:event_name => event_name).first
fire_event(event_name, :coupon_code => @order.coupon_code)
else
flash[:error] = t(:promotion_not_found)
render :edit and return
end
end
end
load_order
payment_method = Spree::PaymentMethod.find(params[:order][:payments_attributes].first[:payment_method_id])
if payment_method.kind_of?(Spree::BillingIntegration::PaypalExpress) || payment_method.kind_of?(Spree::BillingIntegration::PaypalExpressUk)
redirect_to(paypal_payment_order_checkout_url(@order, :payment_method_id => payment_method.id)) and return
end
end
def fixed_opts
if Spree::PaypalExpress::Config[:paypal_express_local_confirm].nil?
user_action = "continue"
else
user_action = Spree::PaypalExpress::Config[:paypal_express_local_confirm] == "t" ? "continue" : "commit"
end
#asset_url doesn't like Spree::Config[:logo] being an absolute url
#if statement didn't work within hash
if URI.parse(Spree::Config[:logo]).absolute?
chosen_image = Spree::Config[:logo]
else
chosen_image = asset_url(Spree::Config[:logo])
end
{ :description => "Goods from #{Spree::Config[:site_name]}", # site details...
#:page_style => "foobar", # merchant account can set named config
:background_color => "ffffff", # must be hex only, six chars
:header_background_color => "ffffff",
:header_border_color => "ffffff",
:header_image => chosen_image,
:allow_note => true,
:locale => user_locale,
:req_confirm_shipping => false, # for security, might make an option later
:user_action => user_action
# WARNING -- don't use :ship_discount, :insurance_offered, :insurance since
# they've not been tested and may trigger some paypal bugs, eg not showing order
# see http://www.pdncommunity.com/t5/PayPal-Developer-Blog/Displaying-Order-Details-in-Express-Checkout/bc-p/92902#C851
}
end
def user_locale
I18n.locale.to_s
end
# hook to override paypal site options
def paypal_site_opts
{:currency => payment_method.preferred_currency, :allow_guest_checkout => payment_method.preferred_allow_guest_checkout }
end
def order_opts(order, payment_method, stage)
items = order.line_items.map do |item|
price = (item.price * 100).to_i # convert for gateway
{ :name => item.variant.product.name,
:description => (item.variant.product.description[0..120] if item.variant.product.description),
:number => item.variant.sku,
:quantity => item.quantity,
:amount => price,
:weight => item.variant.weight,
:height => item.variant.height,
:width => item.variant.width,
:depth => item.variant.weight }
end
credits = order.adjustments.eligible.map do |credit|
if credit.amount < 0.00
{ :name => credit.label,
:description => credit.label,
:sku => credit.id,
:quantity => 1,
:amount => (credit.amount*100).to_i }
end
end
credits_total = 0
credits.compact!
if credits.present?
items.concat credits
credits_total = credits.map {|i| i[:amount] * i[:quantity] }.sum
end
unless @order.payment_method.preferred_cart_checkout
order_total = (order.total * 100).to_i
shipping_total = (order.ship_total*100).to_i
else
shipping_cost = shipping_options[:shipping_options].first[:amount]
order_total = (order.total * 100 + (shipping_cost)).to_i
shipping_total = (shipping_cost).to_i
end
opts = { :return_url => paypal_confirm_order_checkout_url(order, :payment_method_id => payment_method),
:cancel_return_url => edit_order_checkout_url(order, :state => :payment),
:order_id => order.number,
:custom => order.number,
:items => items,
:subtotal => ((order.item_total * 100) + credits_total).to_i,
:tax => (order.tax_total*100).to_i,
:shipping => shipping_total,
:money => order_total,
:max_amount => (order.total * 300).to_i}
if stage == "checkout"
opts[:handling] = 0
opts[:callback_url] = spree_root_url + "paypal_express_callbacks/#{order.number}"
opts[:callback_timeout] = 3
elsif stage == "payment"
#hack to add float rounding difference in as handling fee - prevents PayPal from rejecting orders
#because the integer totals are different from the float based total. This is temporary and will be
#removed once Spree's currency values are persisted as integers (normally only 1c)
if @order.payment_method.preferred_cart_checkout
opts[:handling] = 0
else
opts[:handling] = (order.total*100).to_i - opts.slice(:subtotal, :tax, :shipping).values.sum
end
end
opts
end
def shipping_options
#Uses users address if exists, if not uses first shipping method
if (current_user.present? && current_user.addresses.present?)
estimate_shipping_for_user
shipping_default = @rate_hash_user.map.with_index do |shipping_method, idx|
{ :default => (idx == 0 ? true : false),
:name => shipping_method.name,
:amount => (shipping_method.cost*100).to_i }
end
else
shipping_method = ShippingMethod.all.first
shipping_default = [{ :default => true,
:name => shipping_method.name,
:amount => ((shipping_method.calculator.compute(self).to_f) * 100).to_i }]
end
{
:callback_url => spree_root_url + "paypal_shipping_update",
:callback_timeout => 6,
:callback_version => '61.0',
:shipping_options => shipping_default
}
end
def address_options(order)
if payment_method.preferred_no_shipping
{ :no_shipping => true }
else
{
:no_shipping => false,
:address_override => true,
:address => {
:name => "#{order.ship_address.firstname} #{order.ship_address.lastname}",
:address1 => order.ship_address.address1,
:address2 => order.ship_address.address2,
:city => order.ship_address.city,
:state => order.ship_address.state.nil? ? order.ship_address.state_name.to_s : order.ship_address.state.abbr,
:country => order.ship_address.country.iso,
:zip => order.ship_address.zipcode,
:phone => order.ship_address.phone
}
}
end
end
def all_opts(order, payment_method, stage=nil)
opts = fixed_opts.merge(order_opts(order, payment_method, stage)).merge(paypal_site_opts)
if stage == "payment"
opts.merge! flat_rate_shipping_and_handling_options(order, stage)
end
# suggest current user's email or any email stored in the order
opts[:email] = spree_current_user ? spree_current_user.email : order.email
opts
end
# hook to allow applications to load in their own shipping and handling costs
def flat_rate_shipping_and_handling_options(order, stage)
# max_fallback = 0.0
# shipping_options = ShippingMethod.all.map do |shipping_method|
# { :name => "#{shipping_method.name}",
# :amount => (shipping_method.rate),
# :default => shipping_method.is_default }
# end
# default_shipping_method = ShippingMethod.find(:first, :conditions => {:is_default => true})
# opts = { :shipping_options => shipping_options,
# }
# #opts[:shipping] = (default_shipping_method.nil? ? 0 : default_shipping_method.fallback_amount) if stage == "checkout"
# opts
{}
end
def gateway_error(response)
if response.is_a? ActiveMerchant::Billing::Response
text = response.params['message'] ||
response.params['response_reason_text'] ||
response.message
else
text = response.to_s
end
msg = "#{I18n.t('gateway_error')}: #{text}"
logger.error(msg)
flash[:error] = msg
end
# create the gateway from the supplied options
def payment_method
@payment_method ||= Spree::PaymentMethod.find(params[:payment_method_id])
end
def paypal_gateway
payment_method.provider
end
def add_shipping_charge
# Replace with these changes once Active_Merchant pushes pending pull request
# shipment_name = @ppx_details.shipping['amount'].chomp(" Shipping")
# shipment_cost = @ppx_details.shipping['name'].to_f
shipment_name = @ppx_details.params['UserSelectedOptions']['ShippingOptionName'].chomp(" Shipping")
shipment_cost = @ppx_details.params['UserSelectedOptions']['ShippingOptionAmount'].to_f
if @order.shipping_method_id.blank? && @order.rate_hash.present?
selected_shipping = @order.rate_hash.detect { |v| v['name'] == shipment_name && v['cost'] == shipment_cost }
@order.shipping_method_id = selected_shipping.id
end
@order.shipments.each { |s| s.destroy unless s.shipping_method.available_to_order?(@order) }
@order.create_shipment!
@order.update!
end
def estimate_shipping_for_user
zipcode = current_user.addresses.first.zipcode
country = current_user.addresses.first.country.iso
shipping_methods = Spree::ShippingMethod.all
#TODO remove hard coded shipping
#Make a deep copy of the order object then stub out the parts required to get a shipping quote
@shipping_order = Marshal::load(Marshal.dump(@order)) #Make a deep copy of the order object
@shipping_order.ship_address = Spree::Address.new(:country => Spree::Country.find_by_iso(country), :zipcode => zipcode)
shipment = Spree::Shipment.new(:address => @shipping_order.ship_address)
@shipping_order.ship_address.shipments<<shipment
@shipping_order.shipments<<shipment
@rate_hash_user = @shipping_order.rate_hash
#TODO
end
end
end