arrow_payments 0.1.1

data/lib/arrow_payments/client/customers.rb

@@ -0,0 +1,45 @@
+module ArrowPayments
+  module Customers
+    # Get all existing customers
+    # @return [Array<Customer>]
+    def customers
+      get('/customers').map { |c| Customer.new(c) }
+    end
+
+    # Get an existing customer
+    # @param [Integer] customer ID
+    # @return [Customer]
+    def customer(id)
+      Customer.new(get("/customer/#{id}"))
+    rescue NotFound
+      nil
+    end
+
+    # Create a new customer
+    # @param [Hash] customer attributes
+    # @return [Customer]
+    def create_customer(options={})
+      customer = options.kind_of?(Hash) ? Customer.new(options) : options
+      Customer.new(post("/customer/add", customer.to_source_hash))
+    end
+
+    # Update an existing customer attributes
+    # @param [Customer] customer instance
+    # @return [Boolean] update result
+    def update_customer(customer)
+      params = customer.to_source_hash
+      params['CustomerID'] = customer.id
+
+      resp = post('/customer/update', params)
+      resp['Success'] == true
+    end
+
+    # Delete an existing customer
+    # @param [Integer] customer ID
+    # @return [Boolean]
+    def delete_customer(id)
+      resp = post('/customer/delete', 'CustomerID' => id)
+      resp['Success'] == true
+    end
+  end
+end

data/lib/arrow_payments/client/payment_methods.rb

@@ -0,0 +1,90 @@
+module ArrowPayments
+  module PaymentMethods
+    # Get a single payment method
+    # @param [Integer] customer ID
+    # @param [Integer] payment method ID
+    # @return [PaymentMethod] payment method instance
+    def payment_method(customer_id, id)
+      customer(customer_id).payment_methods.select { |cc| cc.id == id }.first
+    end
+
+    # Start a new payment method
+    # @param [Integer] customer ID
+    # @param [Address] billing address instance
+    # @param [String] return url
+    # @return [String] payment method form url
+    def start_payment_method(customer_id, billing_address, return_url=nil)
+      if billing_address.kind_of?(Hash)
+        billing_address = ArrowPayments::Address.new(billing_address)
+      end
+
+      params = {
+        'CustomerId'     => customer_id,
+        'BillingAddress' => billing_address.to_source_hash
+      }
+
+      # If return url is blank means that its not browser-less payment method
+      # creation. Reponse should include token ID for the Step 3.
+      if return_url
+        params['ReturnUrl'] = return_url
+      end
+
+      post("/paymentmethod/start", params)['FormPostUrl']
+    end
+
+    # Setup a new payment method
+    # @param [String] payment method form url
+    # @param [PaymentMethod] payment method instance or hash
+    # @return [String] confirmation token
+    def setup_payment_method(form_url, payment_method)
+      cc = payment_method
+
+      if payment_method.kind_of?(Hash)
+        cc = ArrowPayments::PaymentMethod.new(payment_method)
+      end
+
+      resp = post_to_url(form_url, payment_method_form(cc))
+      resp.headers['location'].scan(/token-id=(.*)/).flatten.first
+    end
+
+    # Complete payment method creation
+    # @param [String] token ID
+    # @return [PaymentMethod]
+    def complete_payment_method(token_id)
+      resp = post('/paymentmethod/complete', 'TokenID' => token_id)
+      ArrowPayments::PaymentMethod.new(resp)
+    end
+
+    # Create a new payment method. This is a wrapper on top of 3 step process
+    # @param [Integer] customer ID
+    # @param [Address] credit card address
+    # @param [PaymentMethod] credit card
+    # @return [PaymentMethod]
+    def create_payment_method(customer_id, address, card)
+      url   = start_payment_method(customer_id, address)
+      token = setup_payment_method(url, card)
+      
+      complete_payment_method(token)
+    end
+
+    # Delete an existing payment method
+    # @param [Integer] payment method ID
+    # @return [Boolean]
+    def delete_payment_method(id)
+      resp = post('/paymentmethod/delete', 'PaymentMethodId' => id)
+      resp['Success'] == true
+    end
+
+    private
+
+    def payment_method_form(cc)
+      {
+        'billing-cc-number'  => cc.number,
+        'billing-cc-exp'     => [cc.expiration_month, cc.expiration_year].join,
+        'billing-cvv'        => cc.security_code,
+        'billing-first-name' => cc.first_name,
+        'billing-last-name'  => cc.last_name
+      }
+    end
+  end
+end

data/lib/arrow_payments/client/transactions.rb

@@ -0,0 +1,64 @@
+module ArrowPayments
+  module Transactions
+    # Get transaction details
+    # @param [String] transaction ID
+    # @return [Transaction] transactions instance
+    def transaction(id)
+      Transaction.new(get("/transaction/#{id}"))
+    rescue NotFound
+      nil
+    end
+
+    # Get customer transactions by status
+    # @param [String] customer ID
+    # @param [String] transaction status
+    # @return [Array<Transaction>]
+    def transactions(customer_id, status='NotSettled')
+      unless Transaction::STATUSES.include?(status)
+        raise ArgumentError, "Invalid status: #{status}"
+      end
+
+      resp = get("/customer/#{customer_id}/Transactions/#{status}")
+      resp['Transactions'].map { |t| Transaction.new(t) }
+    end
+
+    # Create a new transaction
+    # @return [Transaction]
+    def create_transaction(transaction)
+      if transaction.kind_of?(Hash)
+        transaction = ArrowPayments::Transaction.new(transaction)
+      end
+
+      # Set default transaction attributes
+      transaction.transaction_source = 'API'
+
+      params = transaction.to_source_hash
+      params['Amount'] = params['TotalAmount']
+
+      resp = post('/transaction/add', params)
+
+      if resp['Success'] == true
+        ArrowPayments::Transaction.new(resp)
+      else
+        raise ArrowPayments::Error, resp['Message']
+      end
+    end
+
+    # Capture an unsettled transaction
+    # @param [String] transaction ID
+    # @param [Integer] amount, less than or equal to original amount
+    # @return [Boolean]
+    def capture_transaction(id, amount)
+      resp = post('/transaction/capture', 'TransactionId' => id, 'Amount' => amount)
+      resp['Success'] == true
+    end
+
+    # Void a previously submitted transaction that have not yet settled
+    # @param [String] transaction ID
+    # @return [Boolean]
+    def void_transaction(id)
+      resp = post('/transaction/void', 'TransactionId' => id)
+      resp['Success'] == true
+    end
+  end
+end

data/lib/arrow_payments/configuration.rb

@@ -0,0 +1,7 @@
+module ArrowPayments
+  class Configuration
+    class << self
+      attr_accessor :api_key, :mode, :merchant_id
+    end
+  end
+end

data/lib/arrow_payments/connection.rb

@@ -0,0 +1,78 @@
+require 'faraday'
+require 'json'
+
+module ArrowPayments
+  module Connection
+    API_PRODUCTION = 'https://gateway.arrowpayments.com'
+    API_SANDBOX = 'http://demo.arrowpayments.com'
+
+    def get(path, params={}, raw=false)
+      request(:get, path, params, raw)
+    end
+
+    def post(path, params={}, raw=false)
+      request(:post, path, params, raw)
+    end
+
+    def post_to_url(url, params)
+      Faraday.post(url, params)
+    end
+
+    protected
+
+    def request(method, path, params={}, raw=false)
+      if method == :post
+        path = "/api#{path}"
+        
+        params['ApiKey'] = api_key
+        params['MID'] = merchant_id
+      else
+        path = "/api/#{api_key}#{path}"
+      end
+
+      headers = {
+        'Accept'       => 'application/json',
+        'Content-Type' => 'application/json'
+      }
+
+      api_url = production? ? API_PRODUCTION : API_SANDBOX
+
+      response = connection(api_url).send(method, path, params) do |request|
+        request.headers = headers
+
+        case method
+        when :get, :delete
+          request.url(path, params)
+        when :post, :put
+          request.path = path
+          request.body = params.to_json
+        end
+      end
+
+      unless response.success?
+        handle_failed_response(response)        
+      end
+
+      raw ? response : JSON.parse(response.body)
+    end
+
+    def connection(url)
+      connection = Faraday.new(url) do |c|
+        c.use(Faraday::Request::UrlEncoded)
+        c.use(Faraday::Response::Logger) if debug?
+        c.adapter(Faraday.default_adapter)
+      end
+    end
+
+    def handle_failed_response(response)
+      case response.status
+      when 400
+        raise ArrowPayments::BadRequest, response.headers['error']
+      when 404
+        raise ArrowPayments::NotFound, response.headers['error']
+      when 500
+        raise ArrowPayments::Error, response.headers['error']
+      end
+    end
+  end
+end

data/lib/arrow_payments/customer.rb

@@ -0,0 +1,38 @@
+module ArrowPayments
+  class Customer < Entity
+    property :id,                 :from => 'ID'
+    property :name,               :from => 'Name'
+    property :code,               :from => 'Code'
+    property :contact,            :from => 'PrimaryContact'
+    property :phone,              :from => 'PrimaryContactPhone'
+    property :email,              :from => 'PrimaryContactEmailAddress'
+    property :recurring_billings, :from => 'RecurrentBilling'
+    property :payment_methods,    :from => 'PaymentMethods'
+
+    def PaymentMethods=(data)
+      if data.kind_of?(Array)
+        self.payment_methods = data.map { |d| PaymentMethod.new(d) }
+      else
+        self.payment_methods = []
+      end
+    end
+
+    def PaymentMethods
+      (payment_methods || []).map(&:to_source_hash)
+    end
+
+    def RecurrentBillings=(data)
+      if data.kind_of?(Array)
+        self.recurring_billings = data.map { |d| RecurringBilling.new(d) }
+      else
+        self.recurring_billings = []
+      end
+    end
+
+    def to_source_hash(options={})
+      hash = super(options)
+      hash.merge!('PaymentMethods' => (payment_methods || []).map(&:to_source_hash))
+      hash
+    end
+  end
+end

data/lib/arrow_payments/entity.rb

@@ -0,0 +1,39 @@
+require 'hashie'
+
+module ArrowPayments
+  class Entity < Hashie::Trash
+    include Hashie::Extensions::Coercion
+
+    class << self
+      attr_reader :properties_map
+    end
+
+    instance_variable_set('@properties_map', {})
+
+    def to_source_hash(options={})
+      hash = {}
+
+      self.class.properties_map.each_pair do |k, v|
+        val = send(k)
+        hash[v] = val unless val.nil?
+      end
+
+      hash
+    end
+
+    def self.property(property_name, options = {})
+      super(property_name, options)
+
+      if options[:from]
+        @properties_map ||= {}
+        @properties_map[property_name.to_sym] = options[:from]
+      end
+    end
+
+    private
+
+    def property_exists?(property)
+      self.class.property?(property.to_sym)
+    end
+  end
+end

data/lib/arrow_payments/errors.rb

@@ -0,0 +1,13 @@
+module ArrowPayments
+  # Generic API error
+  class Error < StandardError ; end
+
+  # Error when API entity is not found
+  class NotFound < Error ; end
+
+  # Error when API endpoint or method is not implemented
+  class NotImplemented < Error ; end
+
+  # Bad request error, does not contain a message
+  class BadRequest < Error ; end
+end

data/lib/arrow_payments/line_item.rb

@@ -0,0 +1,10 @@
+module ArrowPayments
+  class LineItem < Entity
+    property :id,              :from => 'ID'
+    property :commodity_code,  :from => 'CommodityCode'
+    property :description,     :from => 'Description'
+    property :price,           :from => 'Price'
+    property :product_code,    :from => 'ProductCode'
+    property :unit_of_measure, :from => 'UnitOfMeasure'
+  end
+end

data/lib/arrow_payments/payment_method.rb

@@ -0,0 +1,19 @@
+module ArrowPayments
+  class PaymentMethod < Entity
+    property :id,               :from => 'ID'
+    property :card_type,        :from => 'CardType'
+    property :last_digits,      :from => 'Last4'
+    property :first_name,       :from => 'CardholderFirstName'
+    property :last_name,        :from => 'CardholderLastName'
+    property :expiration_month, :from => 'ExpirationMonth'
+    property :expiration_year,  :from => 'ExpirationYear'
+    property :address,          :from => 'BillingStreet1'
+    property :address2,         :from => 'BillingStreet2'
+    property :city,             :from => 'BillingCity'
+    property :state,            :from => 'BillingState'
+    property :zip,              :from => 'BillingZip'
+
+    property :number
+    property :security_code
+  end
+end

data/lib/arrow_payments/recurring_billing.rb

@@ -0,0 +1,30 @@
+# From documentation:
+# * Frequency -> W, M, Q, Y (weekly, monthly, quarterly, yearly)
+# * TransactionDay -> Weekly: [1-7], Monthly: [1-28], Quarterly:[1,2,3], Yearly: [1-12]
+
+module ArrowPayments
+  class RecurringBilling < Entity
+    FREQUENCIES = %w(W M Q Y)
+    FREQUENCY_NAMES = {
+      'W' => 'Weekly',
+      'M' => 'Monthly', 
+      'Q' => 'Quarterly',
+      'Y' => 'Yearly'
+    }
+
+    property :id,                :from => 'ID'
+    property :payment_method_id, :from => 'PaymentMethodId'
+    property :frequency,         :from => 'Frequency'
+    property :total_amount,      :from => 'TotalAmount'
+    property :shipping_amount,   :from => 'ShippingAmount'
+    property :description,       :from => 'Description'
+    property :transaction_day,   :from => 'TransactionDay'
+    property :date_created,      :from => 'DateCreated'
+
+    # Get billing frequency name
+    # @return [String]
+    def frequency_name
+      FREQUENCY_NAMES[frequency]
+    end
+  end
+end