payson_api 0.3.2 → 1.0.1

data/.gitignore

@@ -1,7 +0,0 @@
-.DS_Store
-*.gem
-.bundle
-Gemfile.lock
-pkg/*.gem
-.rvmrc
-doc

data/.travis.yml

@@ -1,6 +0,0 @@
-language: ruby
-rvm:
-  - 1.9.3
-  - 1.9.2
-  - 1.8.7
-  - 2.0.0

data/Gemfile

@@ -1,11 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec
-
-group :test, :development do
-  gem 'guard-test'
-  gem 'rake'
-  platforms :ruby do
-    gem 'rb-readline'
-  end
-end

data/Guardfile

@@ -1,9 +0,0 @@
-guard 'test' do
-  watch(%r{^lib/(.+)\.rb$})      { "test" }
-  watch(%r{^lib/payson_api/(.+)\.rb$})  { "test" }
-
-  watch(%r{^test/unit/.+_test\.rb$}) { "test" }
-  watch(%r{^test/fixtures/(.+)\.yml$}) { "test" }
-  watch(%r{^test/integration/.+_test\.rb$}) { "test" }
-  watch(%r{^test/.+_helper\.rb$})   { "test" }
-end

data/README.rdoc

@@ -1,155 +0,0 @@
-= Payson API
-
-A simple utility to handle requests against the Payson payment gateway API.
-
-
-== Supported versions
-
-* Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0
-
-
-== Install
-
-Put this line in your Gemfile:
-  gem 'payson_api'
-
-Then bundle:
-  $ bundle
-
-
-== Usage
-
-=== General configuration options
-
-You need to configure the gem with your own Payson credentials through the <tt>PaysonAPI.configure</tt> method:
-
-  PaysonAPI.configure do |config|
-    config.api_user_id = 'XXXX'
-    config.api_password = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
-  end
-
-Please note that if <tt>config.api_user_id</tt> is set to 1, the client will go into test mode.
-
-=== Initiating a payment
-
-  return_url = 'http://localhost/payson/success'
-  cancel_url = 'http://localhost/payson/cancel'
-  ipn_url = 'http://localhost/payson/ipn'
-  memo = 'Sample order description'
-
-  receivers = []
-  receivers << PaysonAPI::Receiver.new(
-    email = 'me@mydomain.com',
-    amount = 100,
-    first_name = 'Me',
-    last_name = 'Just me',
-    primary = true
-  )
-
-  sender = PaysonAPI::Sender.new(
-    email = 'mycustomer@mydomain.com',
-    first_name = 'My',
-    last_name = 'Customer'
-  )
-
-  order_items = []
-  order_items << PaysonAPI::OrderItem.new(
-    description = 'Order item description',
-    unit_price = 100,
-    quantity = 1,
-    tax = 0,
-    sku = 'MY-ITEM-1'
-  )
-
-  payment = PaysonAPI::Request::Payment.new(
-    return_url,
-    cancel_url,
-    ipn_url,
-    memo,
-    sender,
-    receivers
-  )
-  payment.order_items = order_items
-
-  response = PaysonAPI::Client.initiate_payment(payment)
-
-  if response.success?
-    # Redirect to response.forward_url
-  else
-    puts response.errors
-  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_response.token)
-      #   order.payson_status = ipn_response.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
-
-Nothing at the moment. Will focus on writing more thourough test cases and look over the code all in all.
-
-
-== Build Status {<img src="https://secure.travis-ci.org/stoffus/payson_api.png"/>}[http://travis-ci.org/stoffus/payson_api]
-
-
-== Questions, Feedback
-
-Feel free to message me on Github (stoffus).
-
-
-== Copyright
-
-Copyright (c) 2013 Christopher Svensson.

data/Rakefile

@@ -1,24 +0,0 @@
-require 'bundler/gem_tasks'
-
-task :default => ["test"]
-
-task :test do
-  Rake::Task['test:unit'].execute
-  Rake::Task['test:integration'].execute
-end
-
-namespace :test do
-  desc "Run unit tests"
-  task :unit do
-    Dir["test/unit/*_test.rb"].each do |path|
-      system "ruby -Ilib -Itest #{path}"
-    end
-  end
-
-  desc "Run integration tests"
-  task :integration do
-    Dir["test/integration/*_test.rb"].each do |path|
-      system "ruby -Ilib -Itest #{path}"
-    end
-  end
-end

data/lib/payson_api/client.rb

@@ -1,79 +0,0 @@
-require 'net/https'
-
-module PaysonAPI
-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
-
-  def self.hash_to_params(hash)
-    hash.map { |k, v| "#{k}=#{v}" }.join('&')
-  end
-
-  def self.params_to_hash(params)
-    {}.tap do |hash|
-      params.split('&').each do |param|
-        key, val = param.split('=')
-        hash[key] = val
-      end
-    end
-  end
-
-private
-
-  def self.payson_request(action, data)
-    action = '/%s/%s/' % [PAYSON_API_VERSION, action]
-    url = PAYSON_API_ENDPOINT % (PaysonAPI.test? ? 'test-api' : 'api') + 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

@@ -1,50 +0,0 @@
-module PaysonAPI
-  extend self
-
-  PAYSON_WWW_HOST = "https://%s.payson.se"
-  PAYSON_WWW_PAY_FORWARD_URL = "/paysecure/?token=%s"
-
-  PAYSON_API_ENDPOINT = "https://%s.payson.se"
-  PAYSON_API_VERSION = "1.0"
-  PAYSON_API_PAY_ACTION = "Pay"
-  PAYSON_API_PAYMENT_DETAILS_ACTION = "PaymentDetails"
-  PAYSON_API_PAYMENT_UPDATE_ACTION = "PaymentUpdate"
-  PAYSON_API_PAYMENT_VALIDATE_ACTION = "Validate"
-
-  LOCALES = %w[SV EN FI]
-  CURRENCIES = %w[SEK EUR]
-  FEES_PAYERS = %w[EACHRECEIVER SENDER PRIMARYRECEIVER SECONDARYONLY]
-  FUNDING_CONSTRAINTS = %w[CREDITCARD BANK INVOICE]
-  GUARANTEE_OFFERINGS = %w[OPTIONAL REQUIRED NO]
-  PAYMENT_STATUSES = %w[CREATED PENDING PROCESSING COMPLETED CREDITED
-    INCOMPLETE ERROR EXPIRED REVERSALERROR ABORTED]
-  PAYMENT_TYPES = %w[TRANSFER GUARANTEE INVOICE]
-  GUARANTEE_STATUSES = %w[WAITINGFORSEND WAITINGFORACCEPTANCE WAITINGFORRETURN
-    WAITINGFORRETURNACCEPTANCE RETURNNOTACCEPTED NOTRECEIVED RETURNNOTRECEIVED
-    MONEYRETURNEDTOSENDER RETURNACCEPTED
-  ]
-  INVOICE_STATUSES = %w[PENDING ORDERCREATED CANCELED SHIPPED DONE CREDITED]
-  PAYMENT_ACTIONS = %w[CANCELORDER SHIPORDER CREDITORDER REFUND]
-
-  def configure(&block)
-    yield @config ||= Configuration.new
-  end
-
-  def config
-    @config
-  end
-
-  class Configuration
-    attr_accessor :api_user_id, :api_password
-  end
-
-  configure do |config|
-    config.api_user_id = 'XXXX'
-    config.api_password = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
-  end
-
-  def test?
-    @config.api_user_id == '1'
-  end
-
-end

data/lib/payson_api/envelope.rb

@@ -1,21 +0,0 @@
-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'].to_s))
-    correlation_id = data[FORMAT_STRING % 'correlationId']
-    self.new(ack, timestamp, correlation_id)
-  end
-end
-end

data/lib/payson_api/funding.rb

@@ -1,34 +0,0 @@
-module PaysonAPI
-class Funding
-  FORMAT_STRING = "fundingList.fundingConstraint(%d).%s"
-  attr_accessor :constraint
-
-  def initialize(constraint)
-    if !FUNDING_CONSTRAINTS.include?(constraint)
-      raise "Unknown funding constraint: #{constraint}"
-    end
-    @constraint = constraint
-  end
-
-  def self.to_hash(fundings)
-    {}.tap do |hash|
-      fundings.each_with_index do |funding, index|
-        hash.merge!({
-          FORMAT_STRING % [index, 'constraint'] => 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,52 +0,0 @@
-require 'cgi'
-
-module PaysonAPI
-class OrderItem
-  attr_accessor :description, :quantity, :unit_price, :sku, :tax
-  FORMAT_STRING = "orderItemList.orderItem(%d).%s"
-
-  def initialize(description, unit_price, quantity, tax, sku)
-    @description = description
-    @unit_price = unit_price
-    @quantity = quantity
-    @tax = tax
-    @sku = sku
-  end
-
-  def self.to_hash(order_items)
-    {}.tap do |hash|
-      order_items.each_with_index do |item, index|
-        hash.merge!({
-          FORMAT_STRING % [index, 'description'] => item.description,
-          FORMAT_STRING % [index, 'unitPrice'] => item.unit_price,
-          FORMAT_STRING % [index, 'quantity'] => item.quantity,
-          FORMAT_STRING % [index, 'taxPercentage'] => item.tax,
-          FORMAT_STRING % [index, 'sku'] => item.sku
-        })
-      end
-    end
-  end
-
-  def self.parse(data)
-    [].tap do |order_items|
-      i = 0
-      while data[FORMAT_STRING % [i, 'description']]
-        description = CGI.unescape(data[FORMAT_STRING % [i, 'description']].to_s)
-        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
-        )
-        i += 1
-      end
-    end
-  end
-end
-end