payson_api 0.0.6 → 0.1.0

data/README.rdoc

@@ -42,7 +42,7 @@ You can configure the following default values by overriding these values using
   )
 
   sender = PaysonAPI::Sender.new(
-    email = 'mycustomer@mydomain.com,
+    email = 'mycustomer@mydomain.com',
     first_name = 'My',
     last_name = 'Customer'
   )
@@ -56,7 +56,7 @@ You can configure the following default values by overriding these values using
     sku = 'MY-ITEM-1'
   )
 
-  pay_data = PaysonAPI::PayData.new(
+  payment = PaysonAPI::Request::Payment.new(
     return_url,
     cancel_url,
     ipn_url,
@@ -64,9 +64,9 @@ You can configure the following default values by overriding these values using
     sender,
     receivers
   )
-  pay_data.order_items = order_items
+  payment.order_items = order_items
 
-  response = PaysonAPI::Client.pay(pay_data)
+  response = PaysonAPI::Client.initiate_payment(payment)
 
   if response.success?
     # Redirect to response.forward_url
@@ -75,12 +75,67 @@ You can configure the following default values by overriding these values using
   end
 
 
+=== Requesting payment details
+
+  token = 'token-received-from-payment-request'
+
+  payment_details = PaysonAPI::Request::PaymentDetails.new(token)
+
+  response = PaysonAPI::Client.get_payment_details(payment_details)
+
+  if response.success?
+    # Do stuff with response object
+  else
+    puts response.errors
+  end
+
+
+=== Updating a payment
+
+  token = 'token-received-from-payment-request'
+  action = 'CANCELORDER'
+
+  payment_update = PaysonAPI::Request::PaymentUpdate.new(token, action)
+
+  response = PaysonAPI::Client.update_payment(payment_update)
+
+  if response.success?
+    # Do stuff with response object
+  else
+    puts response.errors
+  end
+
+
+=== Validating an IPN response
+
+This example assumes the use of the Rails web framework.
+
+  class Payson < ApplicationController
+    def ipn_responder
+      request_body = request.body.read
+      ipn_response = PaysonAPI::Response::IPN.new(request_body)
+
+      # Do business stuff, e.g. update the corresponding order:
+      #   order = Order.find_by_payson_token(ipn.token)
+      #   order.payson_status = ipn.status
+      #   order.save!
+
+      # Create a new IPN request object containing the raw response from above
+      ipn_request = PaysonAPI::Request::IPN.new(ipn_response.raw)
+
+      validate = PaysonAPI::Client.validate_ipn(ipn_request)
+
+      unless validate.verified?
+        raise "Something went terribly wrong."
+      end
+    end
+  end
+
+
 == Todo
 
 Implement the following requests:
 
-* PaymentDetails - Get details on a payment.
-* PaymentUpdate - Update a payment.
 * Validate - Validate an IPN (Instant Payment Notification).
 
 

data/lib/payson_api/client.rb

@@ -1,37 +1,82 @@
 require 'net/https'
 
 module PaysonAPI
-  class Client
-    def self.pay(pay_data)
-      action = '/%s/%s/' % [PAYSON_API_VERSION, PAYSON_API_PAY_ACTION]
-      response = post(PAYSON_API_ENDPOINT + action, pay_data.to_hash)
-      Response.new(response.body)
-    end
+class Client
+  def self.initiate_payment(payment_data)
+    response = payson_request(
+      PAYSON_API_PAY_ACTION,
+      payment_data.to_hash
+    )
+    response_hash = params_to_hash(response.body)
+    PaysonAPI::Response::Payment.new(response_hash)
+  end
+
+  def self.get_payment_details(payment_details_data)
+    response = payson_request(
+      PAYSON_API_PAYMENT_DETAILS_ACTION,
+      payment_details_data.to_hash
+    )
+    response_hash = params_to_hash(response.body)
+    PaysonAPI::Response::PaymentDetails.new(response_hash)
+  end
+
+  def self.update_payment(payment_update_data)
+    response = payson_request(
+      PAYSON_API_PAYMENT_DETAILS_ACTION,
+      payment_update_data.to_hash
+    )
+    response_hash = params_to_hash(response.body)
+    PaysonAPI::Response::PaymentUpdate.new(response_hash)
+  end
+
+  def self.validate_ipn(ipn_data)
+    response = payson_request(
+      PAYSON_API_PAYMENT_VALIDATE_ACTION,
+      ipn_data.to_s
+    )
+    PaysonAPI::Response::Validate.new(response.body)
+  end
 
-  private
-
-    def self.post(url, data)
-      headers = {
-        'PAYSON-SECURITY-USERID' => PaysonAPI.config.api_user_id,
-        'PAYSON-SECURITY-PASSWORD' => PaysonAPI.config.api_password,
-        'Content-Type' => 'application/x-www-form-urlencoded'
-      }
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      http.use_ssl = uri.scheme == 'https'
-      req = Net::HTTP::Post.new(uri.path)
-      req.body = hash_to_params(data)
-      headers.each do |name, value|
-        req[name] = value
+  def self.hash_to_params(hash)
+    out = ""
+    hash.each { |k, v| out << "#{k}=#{v}&" }
+    out.chop
+  end
+
+  def self.params_to_hash(params)
+    {}.tap do |hash|
+      parts = params.split(/&/)
+      parts.each do |part|
+        key, val = part.split(/=/)
+        hash[key] = val
       end
-      http.request(req)
     end
+  end
+
+private
 
-    def self.hash_to_params(hash)
-      out = ""
-      hash.each { |k, v| out << "#{k}=#{v}&" }
-      out.chop
+  def self.payson_request(action, data)
+    action = '/%s/%s/' % [PAYSON_API_VERSION, action]
+    url = PAYSON_API_ENDPOINT + action
+    headers = {
+      'PAYSON-SECURITY-USERID' => PaysonAPI.config.api_user_id,
+      'PAYSON-SECURITY-PASSWORD' => PaysonAPI.config.api_password,
+      'Content-Type' => 'application/x-www-form-urlencoded'
+    }
+    post(url, data, headers)
+  end
+
+  def self.post(url, data, headers)
+    uri = URI.parse(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    http.use_ssl = uri.scheme == 'https'
+    req = Net::HTTP::Post.new(uri.path)
+    req.body = data.is_a?(Hash) ? hash_to_params(data) : data
+    headers.each do |name, value|
+      req[name] = value
     end
+    http.request(req)
   end
 end
+end

data/lib/payson_api/config.rb

@@ -14,10 +14,6 @@ module PaysonAPI
   LOCALES = %w[SV FI EN]
   CURRENCIES = %w[SEK EUR]
 
-  # Configures global settings for Payson
-  # PaysonAPI.configure do |config|
-  #   config.api_user = 12345
-  # end
   def configure(&block)
     yield @config ||= Configuration.new
   end
@@ -34,5 +30,4 @@ module PaysonAPI
     config.api_user_id = 'XXXX'
     config.api_password = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
   end
-
 end

data/lib/payson_api/envelope.rb

@@ -0,0 +1,21 @@
+require 'cgi'
+
+module PaysonAPI
+class Envelope
+  attr_accessor :ack, :timestamp, :correlation_id
+  FORMAT_STRING = "responseEnvelope.%s"
+
+  def initialize(ack, timestamp, correlation_id)
+    @ack = ack
+    @timestamp = timestamp
+    @correlation_id = correlation_id
+  end
+
+  def self.parse(data)
+    ack = data[FORMAT_STRING % 'ack']
+    timestamp = DateTime.parse(CGI.unescape(data[FORMAT_STRING % 'timestamp']))
+    correlation_id = data[FORMAT_STRING % 'correlationId']
+    self.new(ack, timestamp, correlation_id)
+  end
+end
+end

data/lib/payson_api/funding.rb

@@ -0,0 +1,31 @@
+module PaysonAPI
+class Funding
+  FORMAT_STRING = "fundingList.fundingConstraint(%d).%s"
+  attr_accessor :constraint
+
+  def initialize(constraint)
+    @constraint = constraint
+  end
+
+  def self.to_hash(fundings)
+    {}.tap do |hash|
+      fundings.each_with_index do |funding, index|
+        hash.merge!({
+          FORMAT_STRING % [index, 'email'] => funding.constraint
+        })
+      end
+    end
+  end
+
+  def self.parse(data)
+    [].tap do |fundings|
+      i = 0
+      while data[FORMAT_STRING % [i, 'constraint']]
+        constraint = data[FORMAT_STRING % [i, 'constraint']]
+        fundings << self.new(constraint)
+        i += 1
+      end
+    end
+  end
+end
+end

data/lib/payson_api/order_item.rb

@@ -1,7 +1,9 @@
+require 'cgi'
+
 module PaysonAPI
 class OrderItem
-  FORMAT_STRING = "orderItemList.orderItem(%d).%s"
   attr_accessor :description, :quantity, :unit_price, :sku, :tax
+  FORMAT_STRING = "orderItemList.orderItem(%d).%s"
 
   def initialize(description, unit_price, quantity, tax, sku)
     @description = description
@@ -14,7 +16,6 @@ class OrderItem
   def self.to_hash(order_items)
     {}.tap do |hash|
       order_items.each_with_index do |item, index|
-        raise "Invalid order item" unless item.instance_of?(self)
         hash.merge!({
           FORMAT_STRING % [index, 'description'] => item.description,
           FORMAT_STRING % [index, 'unitPrice'] => item.unit_price,
@@ -26,21 +27,26 @@ class OrderItem
     end
   end
 
-  def self.parse_order_items(data)
-    i = 0
+  def self.parse(data)
     [].tap do |order_items|
+      i = 0
       while data[FORMAT_STRING % [i, 'description']]
-        description = data[FORMAT_STRING % [i, 'description']]
+        description = CGI.unescape(data[FORMAT_STRING % [i, 'description']])
         unit_price = data[FORMAT_STRING % [i, 'unitPrice']]
         quantity = data[FORMAT_STRING % [i, 'quantity']]
         tax = data[FORMAT_STRING % [i, 'taxPercentage']]
         sku = data[FORMAT_STRING % [i, 'sku']]
 
-        order_items << OrderItem.new(description, unit_price, quantity, tax, sku)
+        order_items << OrderItem.new(
+          description,
+          unit_price,
+          quantity,
+          tax,
+          sku
+        )
         i += 1
       end
     end
   end
-
 end
 end

data/lib/payson_api/receiver.rb

@@ -1,3 +1,5 @@
+require 'cgi'
+
 module PaysonAPI
 class Receiver
   FORMAT_STRING = "receiverList.receiver(%d).%s"
@@ -20,13 +22,13 @@ class Receiver
     end
   end
 
-  def self.parse_receivers(data)
-    i = 0
+  def self.parse(data)
     [].tap do |receivers|
+      i = 0
       while data[FORMAT_STRING % [i, 'email']]
-        email = data[FORMAT_STRING % [i, 'email']]
+        email = CGI.unescape(data[FORMAT_STRING % [i, 'email']])
         amount = data[FORMAT_STRING % [i, 'amount']]
-        receivers << Receiver.new(email, amount)
+        receivers << self.new(email, amount)
         i += 1
       end
     end

data/lib/payson_api/remote_error.rb

@@ -0,0 +1,31 @@
+require 'cgi'
+
+module PaysonAPI
+class RemoteError
+  attr_accessor :id, :message, :parameter
+  FORMAT_STRING = "errorList.error(%d).%s"
+
+  def initialize(id, message, parameter)
+    @id = id
+    @message = message
+    @parameter = parameter
+  end
+
+  def self.parse(data)
+    [].tap do |errors|
+      i = 0
+      while data[FORMAT_STRING % [i, 'errorId']]
+        id = data[FORMAT_STRING % [i, 'errorId']]
+        message = CGI.unescape(data[FORMAT_STRING % [i, 'message']])
+        parameter = CGI.unescape(data[FORMAT_STRING % [i, 'parameter']])
+        errors << self.new(id, message, parameter)
+        i += 1
+      end
+    end
+  end
+
+  def to_s
+    "ID: #{@id}, Message: #{@message}, Parameter: #{@parameter}"
+  end
+end
+end

data/lib/payson_api/request/ipn.rb

@@ -0,0 +1,15 @@
+module PaysonAPI
+module Request
+class IPN
+  attr_accessor :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def to_s
+    @data
+  end
+end
+end
+end

data/lib/payson_api/{pay_data.rb → request/payment.rb}

@@ -1,5 +1,6 @@
 module PaysonAPI
-class PayData
+module Request
+class Payment
   attr_accessor :return_url, :cancel_url, :ipn_url, :memo, :sender, :receivers,
     :locale, :currency, :tracking_id, :invoice_fee, :order_items
 
@@ -29,9 +30,6 @@ class PayData
       hash['trackingId'] = @tracking_id if @tracking_id
     end
   end
-
-  def to_s
-    to_hash.to_s
-  end
+end
 end
 end

data/lib/payson_api/request/payment_details.rb

@@ -0,0 +1,15 @@
+module PaysonAPI
+module Request
+class PaymentDetails
+  attr_accessor :token
+
+  def initialize(token)
+    @token = token
+  end
+
+  def to_hash
+    { 'token' => @token }
+  end
+end
+end
+end

data/lib/payson_api/request/payment_update.rb

@@ -0,0 +1,19 @@
+module PaysonAPI
+module Request
+class PaymentUpdate
+  attr_accessor :token, :action
+
+  def initialize(token, action)
+    @token = token
+    @action = action
+  end
+
+  def to_hash
+    {}.tap do |hash|
+      hash['token'] = @token
+      hash['action'] = @action
+    end
+  end
+end
+end
+end

data/lib/payson_api/response/ipn.rb

@@ -0,0 +1,36 @@
+module PaysonAPI
+module Response
+class IPN
+  attr_accessor :purchase_id, :sender_email, :status,
+    :payment_type, :guarantee_status, :guarantee_deadline_at,
+    :invoice_status, :custom, :tracking_id, :receivers, :currency,
+    :order_items, :fundings, :token, :shipping_address, :raw, :hash
+
+  def initialize(raw_data)
+    @raw = raw_data
+    data_hash = PaysonAPI::Client.params_to_hash(raw_data)
+    @purchase_id = data_hash['purchaseId']
+    @payment_type = data_hash['type']
+    @comment = data_hash['custom']
+    @tracking_id = data_hash['trackingId']
+    @currency = data_hash['currencyCode']
+    @sender_email = data_hash['senderEmail']
+    @status = data_hash['status']
+    @token = data_hash['token']
+    @fundings = Funding.parse(data_hash)
+    @receivers = Receiver.parse(data_hash)
+    @order_items = OrderItem.parse(data_hash)
+    @hash = data_hash['HASH']
+
+    case @payment_type
+    when 'GUARANTEE'
+      @guarantee_status = data_hash['guaranteeStatus']
+      @guarantee_deadline_at = Time.at(data_hash['guaranteeDeadlineTimestamp'])
+    when 'INVOICE'
+      @invoice_status = data_hash['invoiceStatus']
+      @shipping_address = ShippingAddress.parse(data_hash)
+    end
+  end
+end
+end
+end

data/lib/payson_api/response/payment.rb

@@ -0,0 +1,21 @@
+module PaysonAPI
+module Response
+class Payment
+  attr_accessor :envelope, :token, :errors
+
+  def initialize(data)
+    @envelope = Envelope.parse(data)
+    @token = data['TOKEN']
+    @errors = RemoteError.parse(data)
+  end
+
+  def success?
+    @envelope.ack == 'SUCCESS'
+  end
+
+  def forward_url
+    PAYSON_WWW_HOST + PAYSON_WWW_PAY_FORWARD_URL % @token
+  end
+end
+end
+end

data/lib/payson_api/response/payment_details.rb

@@ -0,0 +1,39 @@
+module PaysonAPI
+module Response
+class PaymentDetails
+  attr_accessor :envelope, :purchase_id, :sender_email, :status,
+    :payment_type, :guarantee_status, :guarantee_deadline_at,
+    :invoice_status, :custom, :tracking_id, :receivers, :currency,
+    :order_items, :errors, :fundings, :token, :shipping_address
+
+  def initialize(data)
+    @envelope = Envelope.parse(data)
+    @purchase_id = data['purchaseId']
+    @payment_type = data['type']
+    @comment = data['custom']
+    @tracking_id = data['trackingId']
+    @currency = data['currencyCode']
+    @sender_email = data['senderEmail']
+    @status = data['status']
+    @token = data['token']
+    @fundings = Funding.parse(data)
+    @receivers = Receiver.parse(data)
+    @order_items = OrderItem.parse(data)
+    @errors = RemoteError.parse(data)
+
+    case @payment_type
+    when 'GUARANTEE'
+      @guarantee_status = data['guaranteeStatus']
+      @guarantee_deadline_at = Time.at(data['guaranteeDeadlineTimestamp'])
+    when 'INVOICE'
+      @invoice_status = data['invoiceStatus']
+      @shipping_address = ShippingAddress.parse(data)
+    end
+  end
+
+  def success?
+    @envelope.ack == 'SUCCESS'
+  end
+end
+end
+end

data/lib/payson_api/response/payment_update.rb

@@ -0,0 +1,16 @@
+module PaysonAPI
+module Response
+class PaymentUpdate
+  attr_accessor :envelope, :errors
+
+  def initialize(data)
+    @envelope = Envelope.parse(data)
+    @errors = RemoteError.parse(data)
+  end
+
+  def success?
+    @envelope.ack == 'SUCCESS'
+  end
+end
+end
+end

data/lib/payson_api/response/validate.rb

@@ -0,0 +1,15 @@
+module PaysonAPI
+module Response
+class Validate
+  attr_accessor :data
+
+  def initialize(data)
+    @data = data
+  end
+
+  def verified?
+    @data == 'VERIFIED'
+  end
+end
+end
+end

data/lib/payson_api/sender.rb

@@ -1,5 +1,8 @@
+require 'cgi'
+
 module PaysonAPI
 class Sender
+  FORMAT_STRING = "sender%s"
   attr_accessor :email, :first_name, :last_name
 
   def initialize(email, first_name, last_name)
@@ -10,10 +13,17 @@ class Sender
 
   def to_hash
     {}.tap do |hash|
-      hash['senderEmail'] = @email
-      hash['senderFirstName'] = @first_name
-      hash['senderLastName'] = @last_name
+      hash[FORMAT_STRING % 'Email'] = @email
+      hash[FORMAT_STRING % 'FirstName'] = @first_name
+      hash[FORMAT_STRING % 'LastName'] = @last_name
     end
   end
+
+  def self.parse(data)
+    email = data[FORMAT_STRING % 'email']
+    first_name = CGI.unescape(data[FORMAT_STRING % 'FirstName'])
+    last_name = CGI.unescape(data[FORMAT_STRING % 'LastName'])
+    self.new(email, first_name, last_name)
+  end
 end
 end

data/lib/payson_api/shipping_address.rb

@@ -0,0 +1,36 @@
+require 'cgi'
+
+module PaysonAPI
+class ShippingAddress
+  FORMAT_STRING = "shippingAddress.%s"
+  attr_accessor :name, :street_address, :postal_code, :city, :country
+
+  def initialize(name, street_address, postal_code, city, country)
+    @name = name
+    @street_address = street_address
+    @postal_code = postal_code
+    @city = city
+    @country = country
+  end
+
+  def to_hash
+    {}.tap do |hash|
+      hash[FORMAT_STRING % 'name'] = @name
+      hash[FORMAT_STRING % 'streetAddress'] = @street_address
+      hash[FORMAT_STRING % 'postalCode'] = @postal_code
+      hash[FORMAT_STRING % 'city'] = @city
+      hash[FORMAT_STRING % 'country'] = @country
+    end
+  end
+
+  def self.parse(data)
+    return unless data[FORMAT_STRING % 'name']
+    name = CGI.unescape(data[FORMAT_STRING % 'name'])
+    street_address = CGI.unescape(data[FORMAT_STRING % 'streetAddress'])
+    postal_code = CGI.unescape(data[FORMAT_STRING % 'postalCode'])
+    city = CGI.unescape(data[FORMAT_STRING % 'city'])
+    country = CGI.unescape(data[FORMAT_STRING % 'country'])
+    self.new(name, street_address, postal_code, city, country)
+  end
+end
+end

data/lib/payson_api/version.rb

@@ -1,3 +1,3 @@
 module PaysonAPI
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/lib/payson_api.rb

@@ -1,10 +1,26 @@
-require 'payson_api/config'
-require 'payson_api/client'
-require 'payson_api/errors/payson_api_error'
-require 'payson_api/errors/remote_error'
-require 'payson_api/order_item'
-require 'payson_api/pay_data'
-require 'payson_api/receiver'
-require 'payson_api/response'
-require 'payson_api/sender'
-require 'payson_api/version'
+required_files = [
+  'config',
+  'error_codes',
+  'client',
+  'envelope',
+  'funding',
+  'order_item',
+  'receiver',
+  'remote_error',
+  'request/ipn',
+  'request/payment_details',
+  'request/payment_update',
+  'request/payment',
+  'response/ipn',
+  'response/payment_details',
+  'response/payment_update',
+  'response/payment',
+  'response/validate',
+  'sender',
+  'shipping_address',
+  'version'
+]
+
+required_files.each do |file|
+  require "payson_api/#{file}"
+end

data/test/fixtures/config.yml

@@ -1,2 +1,5 @@
-:api_user_id: XXXX
-:api_password: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+#:api_user_id: XXXX
+#:api_password: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+
+:api_user_id: 13671
+:api_password: 305390e8-f866-41e5-a543-dc8747f545f8

data/test/integration/payment_details_test.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'test/unit'
+require 'test_helper'
+require 'payson_api'
+
+class PaymentDetailsTest < Test::Unit::TestCase
+  include TestHelper
+
+  def test_generated_hash_from_payment_details
+    #token = acquire_token
+    #token = 'b28c31bb-1499-4988-9fc6-fa915c287e90'
+    token = '4d7328b0-9883-44e3-a19d-b25cef65a3b8'
+
+    if !token
+      puts "Token was not received, please look into your test config"
+      return
+    end
+
+    payment_details = PaysonAPI::Request::PaymentDetails.new(token)
+    response = PaysonAPI::Client.get_payment_details(payment_details)
+
+
+
+p response
+  end
+end

data/test/integration/payment_test.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'test/unit'
+require 'test_helper'
+require 'payson_api'
+
+class PaymentTest < Test::Unit::TestCase
+  include TestHelper
+
+  def test_generated_hash_from_payment_data
+    setup_payment_hash(include_order_items = true)
+
+    assert_equal PAYMENT_DATA[:return_url], @payment_hash['returnUrl']
+    assert_equal PAYMENT_DATA[:cancel_url], @payment_hash['cancelUrl']
+    assert_equal PAYMENT_DATA[:ipn_url], @payment_hash['ipnNotificationUrl']
+    assert_equal PAYMENT_DATA[:memo], @payment_hash['memo']
+
+    # Ensure expected format of receiver list
+    receiver_format = PaysonAPI::Receiver::FORMAT_STRING
+    @receivers.each_with_index do |receiver, index|
+      email = @payment_hash[receiver_format % [index, 'email']]
+      amount = @payment_hash[receiver_format % [index, 'amount']]
+
+      assert_equal receiver.email, email
+      assert_equal receiver.amount, amount
+    end
+
+    # Do same test for order items
+    order_item_format = PaysonAPI::OrderItem::FORMAT_STRING
+    @order_items.each_with_index do |order_item, index|
+      description = @payment_hash[order_item_format % [index, 'description']]
+      unit_price = @payment_hash[order_item_format % [index, 'unitPrice']]
+      quantity = @payment_hash[order_item_format % [index, 'quantity']]
+      tax = @payment_hash[order_item_format % [index, 'taxPercentage']]
+      sku = @payment_hash[order_item_format % [index, 'sku']]
+
+      assert_equal order_item.description, description
+      assert_equal order_item.unit_price, unit_price
+      assert_equal order_item.quantity, quantity
+      assert_equal order_item.tax, tax
+      assert_equal order_item.sku, sku
+    end
+  end
+
+  def test_payment_initiation_request
+    token = acquire_token
+
+    if !token
+      puts "Token was not received, please look into your test config"
+      return
+    end
+  end
+end

data/test/test_helper.rb

@@ -2,6 +2,7 @@ require 'yaml'
 
 module TestHelper
   CONFIG = YAML.load_file('test/fixtures/config.yml')
+  PAYMENT_DATA = YAML.load_file('test/fixtures/payment_data.yml')
 
   def setup
     PaysonAPI.configure do |config|
@@ -10,6 +11,56 @@ module TestHelper
     end
   end
 
+  def setup_payment_hash(include_order_items = false)
+    @sender = PaysonAPI::Sender.new(
+      PAYMENT_DATA[:sender][:email],
+      PAYMENT_DATA[:sender][:first_name],
+      PAYMENT_DATA[:sender][:last_name]
+    )
+
+    @receivers = []
+    PAYMENT_DATA[:receivers].each do |receiver|
+      @receivers << PaysonAPI::Receiver.new(
+        receiver[:email],
+        receiver[:amount]
+      )
+    end
+
+    @payment = PaysonAPI::Request::Payment.new(
+      PAYMENT_DATA[:return_url],
+      PAYMENT_DATA[:cancel_url],
+      PAYMENT_DATA[:ipn_url],
+      PAYMENT_DATA[:memo],
+      @sender,
+      @receivers
+    )
+
+    @order_items = []
+    PAYMENT_DATA[:order_items].each do |order_item|
+      @order_items << PaysonAPI::OrderItem.new(
+        order_item[:description],
+        order_item[:unit_price],
+        order_item[:quantity],
+        order_item[:tax],
+        order_item[:sku]
+      )
+    end
+
+    @payment.order_items = @order_items if include_order_items
+    @payment_hash = @payment.to_hash
+  end
+
+  # Note that for this method to succeed you must configure the tests
+  # with your personal details:
+  #   * The api_user_id/api_password must be valid (in config.yml)
+  #   * The receiver email must be valid for the supplied credentials
+  #       (in payment_data.yml)
+  def acquire_token
+    setup_payment_hash
+    response = PaysonAPI::Client.initiate_payment(@payment_hash)
+    response.token
+  end
+
   def teardown
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 6
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors: 
 - Christopher Svensson
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-25 00:00:00 +02:00
+date: 2012-07-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -61,20 +61,29 @@ files:
 - lib/payson_api.rb
 - lib/payson_api/client.rb
 - lib/payson_api/config.rb
-- lib/payson_api/errors/payson_api_error.rb
-- lib/payson_api/errors/remote_error.rb
+- lib/payson_api/envelope.rb
+- lib/payson_api/funding.rb
 - lib/payson_api/order_item.rb
-- lib/payson_api/pay_data.rb
 - lib/payson_api/receiver.rb
-- lib/payson_api/response.rb
+- lib/payson_api/remote_error.rb
+- lib/payson_api/request/ipn.rb
+- lib/payson_api/request/payment.rb
+- lib/payson_api/request/payment_details.rb
+- lib/payson_api/request/payment_update.rb
+- lib/payson_api/response/ipn.rb
+- lib/payson_api/response/payment.rb
+- lib/payson_api/response/payment_details.rb
+- lib/payson_api/response/payment_update.rb
+- lib/payson_api/response/validate.rb
 - lib/payson_api/sender.rb
+- lib/payson_api/shipping_address.rb
 - lib/payson_api/version.rb
 - payson_api.gemspec
 - test/fixtures/config.yml
-- test/fixtures/order.yml
+- test/fixtures/payment_data.yml
 - test/integration/config_test.rb
-- test/integration/pay_data_test.rb
-- test/integration/request_test.rb
+- test/integration/payment_details_test.rb
+- test/integration/payment_test.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: https://github.com/stoffus/payson_api
@@ -108,8 +117,8 @@ specification_version: 3
 summary: Client for Payson API
 test_files: 
 - test/fixtures/config.yml
-- test/fixtures/order.yml
+- test/fixtures/payment_data.yml
 - test/integration/config_test.rb
-- test/integration/pay_data_test.rb
-- test/integration/request_test.rb
+- test/integration/payment_details_test.rb
+- test/integration/payment_test.rb
 - test/test_helper.rb

data/lib/payson_api/errors/payson_api_error.rb

@@ -1,7 +0,0 @@
-module PaysonAPI
-  module Errors
-    class PaysonAPIError < StandardError
-      # Base error.
-    end
-  end
-end

data/lib/payson_api/errors/remote_error.rb

@@ -1,55 +0,0 @@
-module PaysonAPI
-  module Errors
-    class RemoteError < PaysonAPIError
-      ERROR_CODES = {
-        '500000' => "System error.",
-        '520002' => "Internal error.",
-        '520003' => "Authentication failed; Credentials were not valid.",
-        '520004' => "The merchant account is restricted.",
-        '520005' => "The merchant account is locked.",
-        '520006' => "The requested API endpoint is unknown.",
-        '529038' => "Error while executing payment.",
-        '539041' => "An email account is not receive enabled.",
-        '539043' => "An email account is not send enabled.",
-        '559044' => "A receiver's preferences denied the payment.",
-        '560027' => "Unrecognized fees payer type.",
-        '579007' => "Payment request number of receivers exceeds the maximum.",
-        '579008' => "Number of primary receivers exceeds 1.",
-        '579017' => "Primary receiver amount for chained payment must not be less than sum of other receiver amounts.",
-        '579033' => "Sender and each receiver must all have different accounts.",
-        '579040' => "Two receivers belong to the same Payson user account.",
-        '579042' => "The tracking ID already exists and cannot be duplicated.",
-        '579045' => "This request would exceed the receiving limit for an account.",
-        '579047' => "This request would exceed the purse limit for an account.",
-        '579048' => "This request would exceed the sending limit for an account.",
-        '579049' => "The payment request you are looking for was not found in our system.",
-        '580001' => "Invalid request - the request did not pass our basic validation.",
-        '580021' => "Invalid parameter - too long.",
-        '580022' => "Your request was invalid. Check the parameter of the error to see which is invalid.",
-        '580023' => "A receiver was given more than once in the request.",
-        '580027' => "Unsupported currency code.",
-        '580028' => "A URL supplied with the request is malformed.",
-        '580029' => "A required parameter was not provided. Check the error parameter list.",
-        '589018' => "Invalid pay key.",
-        '589052' => "The transaction ID was not found in our system.",
-        '589053' => "All payment methods have been disabled for this combination of funding constraint, merchant and receiver.",
-        '590001' => "The total amount specified for receivers does not match the total amount specified by the order items.",
-        '590005' => "Not all related order item parameters where specified. All or none of unitPrice, quantity, taxPercentage and sku must be set.",
-        '590006' => "Invoice requires one reciever.",
-        '590007' => "Invoice requires fee on reciever.",
-        '590008' => "Invoice requires that order items are specified.",
-        '590009' => "Invoice payments are not available to this merchant.",
-        '590010' => "The requested action is not possible in the current state of the payment.",
-        '590011' => "The amount on the invoice is below the minimum limit.",
-        '590012' => "Invoice does not support the selected currency.",
-        '590013' => "The invoice fee out of the valid range (0-30 SEK).",
-        '590014' => "The invoice fee can only be specified for invoices.",
-        '590015' => "The receiver is not allowed to receive invoices.",
-        '590016' => "The sender and reciever is the same user.",
-        '590017' => "Invoice is frozen and cannot be updated.",
-        '590018' => "The requested action is not possible for the current type of payment.",
-        '590021' => "The funding constraint INVOICE cannot be combined with other funding constraints."
-      }
-    end
-  end
-end

data/lib/payson_api/response.rb

@@ -1,35 +0,0 @@
-module PaysonAPI
-class Response
-  attr_accessor :envelope, :token, :errors
-
-  def initialize(response)
-    @errors = {}
-    @envelope = {}
-    @token = nil
-    parse_response(response)
-  end
-
-  def parse_response(response)
-    response.split(/&/).each do |item|
-      if item =~ /TOKEN/
-        @token = item.split(/=/)[1]
-      elsif item =~ /errorId/
-        code = item.split(/=/)[1]
-        @errors[code] = Errors::RemoteError::ERROR_CODES[code]
-      elsif item =~ /responseEnvelope/
-        name, value = item.split(/=/)
-        name = name.split(/\./)[1]
-        @envelope[name] = value
-      end
-    end
-  end
-
-  def success?
-    @envelope['ack'] == 'SUCCESS'
-  end
-
-  def forward_url
-    url = PAYSON_WWW_HOST + PAYSON_WWW_PAY_FORWARD_URL % @token
-  end
-end
-end

data/test/integration/pay_data_test.rb

@@ -1,80 +0,0 @@
-# encoding: utf-8
-
-require 'test/unit'
-require 'test_helper'
-require 'payson_api'
-
-class PayDataTest < Test::Unit::TestCase
-  include TestHelper
-  ORDER = YAML.load_file('test/fixtures/order.yml')
-
-  def test_generated_hash_from_pay_data
-    sender = PaysonAPI::Sender.new(
-      ORDER[:sender][:email],
-      ORDER[:sender][:first_name],
-      ORDER[:sender][:last_name]
-    )
-
-    receivers = []
-    ORDER[:receivers].each do |receiver|
-      receivers << PaysonAPI::Receiver.new(
-        receiver[:email],
-        receiver[:amount]
-      )
-    end
-
-    pay_data = PaysonAPI::PayData.new(
-      ORDER[:return_url],
-      ORDER[:cancel_url],
-      ORDER[:ipn_url],
-      ORDER[:memo],
-      sender,
-      receivers
-    )
-
-    order_items = []
-    ORDER[:order_items].each do |order_item|
-      order_items << PaysonAPI::OrderItem.new(
-        order_item[:description],
-        order_item[:unit_price],
-        order_item[:quantity],
-        order_item[:tax],
-        order_item[:sku]
-      )
-    end
-
-    pay_data.order_items = order_items
-    pay_data_hash = pay_data.to_hash
-
-    assert_equal ORDER[:return_url], pay_data_hash['returnUrl']
-    assert_equal ORDER[:cancel_url], pay_data_hash['cancelUrl']
-    assert_equal ORDER[:ipn_url], pay_data_hash['ipnNotificationUrl']
-    assert_equal ORDER[:memo], pay_data_hash['memo']
-
-    # Ensure expected format of receiver list
-    receiver_format = PaysonAPI::Receiver::FORMAT_STRING
-    receivers.each_with_index do |receiver, index|
-      email = pay_data_hash[receiver_format % [index, 'email']]
-      amount = pay_data_hash[receiver_format % [index, 'amount']]
-
-      assert_equal receiver.email, email
-      assert_equal receiver.amount, amount
-    end
-
-    # Do same test for order items
-    order_item_format = PaysonAPI::OrderItem::FORMAT_STRING
-    order_items.each_with_index do |order_item, index|
-      description = pay_data_hash[order_item_format % [index, 'description']]
-      unit_price = pay_data_hash[order_item_format % [index, 'unitPrice']]
-      quantity = pay_data_hash[order_item_format % [index, 'quantity']]
-      tax = pay_data_hash[order_item_format % [index, 'taxPercentage']]
-      sku = pay_data_hash[order_item_format % [index, 'sku']]
-
-      assert_equal order_item.description, description
-      assert_equal order_item.unit_price, unit_price
-      assert_equal order_item.quantity, quantity
-      assert_equal order_item.tax, tax
-      assert_equal order_item.sku, sku
-    end
-  end
-end

data/test/integration/request_test.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'test/unit'
-require 'test_helper'
-require 'payson_api'
-
-class PayDataTest < Test::Unit::TestCase
-  include TestHelper
-  ORDER = YAML.load_file('test/fixtures/order.yml')
-
-  def test_request_and_fail_gracefully
-    sender = PaysonAPI::Sender.new(
-      ORDER[:sender][:email],
-      ORDER[:sender][:first_name],
-      ORDER[:sender][:last_name]
-    )
-
-    receivers = []
-    ORDER[:receivers].each do |receiver|
-      receivers << PaysonAPI::Receiver.new(
-        receiver[:email],
-        receiver[:amount]
-      )
-    end
-
-    pay_data = PaysonAPI::PayData.new(
-      ORDER[:return_url],
-      ORDER[:cancel_url],
-      ORDER[:ipn_url],
-      ORDER[:memo],
-      sender,
-      receivers
-    )
-
-    response = PaysonAPI::Client.pay(pay_data)
-
-    # This should fail due to bad credentials
-    assert_equal 'FAILURE', response.envelope['ack']
-  end
-end