payson_api 0.3.3 → 1.0.2

data/lib/payson_api/receiver.rb

@@ -1,52 +0,0 @@
-require 'cgi'
-
-module PaysonAPI
-class Receiver
-  FORMAT_STRING = "receiverList.receiver(%d).%s"
-  attr_accessor :email, :amount, :first_name, :last_name, :primary
-
-  def initialize(email, amount, first_name = nil, last_name = nil, primary = true)
-    @email = email
-    @amount = amount
-    @first_name = first_name
-    @last_name = last_name
-    @primary = primary
-  end
-
-  def self.to_hash(receivers)
-    {}.tap do |hash|
-      receivers.each_with_index do |receiver, index|
-        raise "Invalid receiver" unless receiver.instance_of?(self)
-        hash.merge!({
-          FORMAT_STRING % [index, 'email'] => receiver.email,
-          FORMAT_STRING % [index, 'amount'] => receiver.amount,
-          FORMAT_STRING % [index, 'firstName'] => receiver.first_name,
-          FORMAT_STRING % [index, 'lastName'] => receiver.last_name,
-          FORMAT_STRING % [index, 'primary'] => receiver.primary
-        })
-        if receiver.first_name
-          hash[FORMAT_STRING % [index, 'firstName']] = receiver.first_name
-        end
-        if receiver.last_name
-          hash[FORMAT_STRING % [index, 'lastName']] = receiver.last_name
-        end
-      end
-    end
-  end
-
-  def self.parse(data)
-    [].tap do |receivers|
-      i = 0
-      while data[FORMAT_STRING % [i, 'email']]
-        email = CGI.unescape(data[FORMAT_STRING % [i, 'email']].to_s)
-        amount = data[FORMAT_STRING % [i, 'amount']]
-        first_name = CGI.unescape(data[FORMAT_STRING % [i, 'firstName']].to_s)
-        last_name = CGI.unescape(data[FORMAT_STRING % [i, 'lastName']].to_s)
-        primary = data[FORMAT_STRING % [i, 'primary']]
-        receivers << self.new(email, amount, first_name, last_name, primary)
-        i += 1
-      end
-    end
-  end
-end
-end

data/lib/payson_api/remote_error.rb

@@ -1,31 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/request/payment.rb

@@ -1,66 +0,0 @@
-module PaysonAPI
-module Request
-class Payment
-  attr_accessor :return_url, :cancel_url, :ipn_url, :memo, :sender, :receivers,
-    :locale, :currency, :tracking_id, :invoice_fee, :order_items, :fundings,
-    :fees_payer, :guarantee_offered
-
-  def initialize(return_url, cancel_url, ipn_url, memo, sender, receivers)
-    @return_url = return_url
-    @cancel_url = cancel_url
-    @ipn_url = ipn_url
-    @memo = memo
-    @sender = sender
-    @receivers = receivers
-  end
-
-  def to_hash
-    {}.tap do |hash|
-      # Append mandatory params
-      hash['returnUrl'] = @return_url
-      hash['cancelUrl'] = @cancel_url
-      hash['memo'] = @memo
-      hash.merge!(@sender.to_hash)
-      hash.merge!(Receiver.to_hash(@receivers))
-
-      # Append optional params
-      append_locale(hash, @locale) if @locale
-      append_currency(hash, @currency) if @currency
-      append_fees_payer(hash, @fees_payer) if @fees_payer
-      append_guarantee(hash, @guarantee_offered) if @guarantee_offered
-      hash.merge!(OrderItem.to_hash(@order_items)) if @order_items
-      hash.merge!(Funding.to_hash(@fundings)) if @fundings
-      hash['ipnNotificationUrl'] = @ipn_url if @ipn_url
-      hash['invoiceFee'] = @invoice_fee if @invoice_fee
-      hash['trackingId'] = @tracking_id if @tracking_id
-    end
-  end
-
-private
-
-  def append_locale(hash, locale)
-    raise "Unknown locale: #{locale}" if !LOCALES.include?(locale)
-    hash['localeCode'] = locale
-  end
-
-  def append_currency(hash, currency)
-    raise "Unknown currency: #{currency}" if !CURRENCIES.include?(currency)
-    hash['currencyCode'] = currency
-  end
-
-  def append_guarantee(hash, guarantee_offered)
-    if !GUARANTEE_OFFERINGS.include?(guarantee_offered)
-      raise "Unknown guarantee offering: #{guarantee_offered}"
-    end
-    hash['guaranteeOffered'] = guarantee_offered
-  end
-
-  def append_fees_payer(hash, fees_payer)
-    if !FEES_PAYERS.include?(fees_payer)
-      raise "Unknown fees payer: #{fees_payer}"
-    end
-    hash['feesPayer'] = fees_payer
-  end
-end
-end
-end

data/lib/payson_api/request/payment_details.rb

@@ -1,15 +0,0 @@
-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

@@ -1,22 +0,0 @@
-module PaysonAPI
-module Request
-class PaymentUpdate
-  attr_accessor :token, :action
-
-  def initialize(token, action)
-    @token = token
-    if !PAYMENT_ACTIONS.include?(action)
-      raise "Unknown payment update action: #{action}"
-    end
-    @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

@@ -1,36 +0,0 @@
-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.parse(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

@@ -1,22 +0,0 @@
-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 % (PaysonAPI.test? ? 'test-www' : 'www') +
-      PAYSON_WWW_PAY_FORWARD_URL % @token
-  end
-end
-end
-end

data/lib/payson_api/response/payment_details.rb

@@ -1,43 +0,0 @@
-require 'cgi'
-
-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.parse(CGI.unescape(data['guaranteeDeadlineTimestamp']))
-    when 'INVOICE'
-      @invoice_status = data['invoiceStatus']
-      if %w[ORDERCREATED SHIPPED DONE CREDITED].include?(@invoice_status)
-        @shipping_address = ShippingAddress.parse(data)
-      end
-    end
-  end
-
-  def success?
-    @envelope.ack == 'SUCCESS'
-  end
-end
-end
-end

data/lib/payson_api/response/payment_update.rb

@@ -1,16 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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,29 +0,0 @@
-require 'cgi'
-
-module PaysonAPI
-class Sender
-  FORMAT_STRING = "sender%s"
-  attr_accessor :email, :first_name, :last_name
-
-  def initialize(email, first_name, last_name)
-    @email = email
-    @first_name = first_name
-    @last_name = last_name
-  end
-
-  def to_hash
-    {}.tap do |hash|
-      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'].to_s)
-    last_name = CGI.unescape(data[FORMAT_STRING % 'LastName'].to_s)
-    self.new(email, first_name, last_name)
-  end
-end
-end

data/lib/payson_api/shipping_address.rb

@@ -1,36 +0,0 @@
-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'].to_s)
-    street_address = CGI.unescape(data[FORMAT_STRING % 'streetAddress'].to_s)
-    postal_code = CGI.unescape(data[FORMAT_STRING % 'postalCode'].to_s)
-    city = CGI.unescape(data[FORMAT_STRING % 'city'].to_s)
-    country = CGI.unescape(data[FORMAT_STRING % 'country'].to_s)
-    self.new(name, street_address, postal_code, city, country)
-  end
-end
-end

data/payson_api.gemspec

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-$:.push File.expand_path("../lib", __FILE__)
-require "payson_api/version"
-
-Gem::Specification.new do |s|
-  s.name        = "payson_api"
-  s.version     = PaysonAPI::VERSION
-  s.authors     = ["Christopher Svensson"]
-  s.email       = ["stoffus@stoffus.com"]
-  s.homepage    = "https://github.com/stoffus/payson_api"
-  s.summary     = %q{Client for Payson API}
-  s.description = %q{Client that enables access to the Payson payment gateway API.}
-  s.license     = 'MIT'
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'guard-test'
-end