arrow_payments 0.1.1

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+*.swp
+*.tmproj
+*~
+.DS_Store
+.\#*
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+\#*
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+tmtags
+lib/test.rb

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=nested

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/README.md

@@ -0,0 +1,272 @@
+# ArrowPayments
+
+Ruby wrapper for Arrow Payments gateway
+
+**Under Development**
+
+## Installation
+
+In your Gemfile add a line:
+
+```
+gem 'arrow_payments', :github => 'sosedoff/arrow_payments'
+```
+
+## Configuration
+
+To configure gateway globally, add an initializer with the following:
+
+```ruby
+ArrowPayments::Configuration.api_key = 'foo'
+ArrowPayments::Configuration.mode = 'production'
+ArrowPayments::Configuration.merchant_id = '1231231'
+```
+
+Another way is to configure on the instance level:
+
+```ruby
+client = ArrowPayments::Client.new(
+  :api_key     => 'foo', 
+  :mode        => 'production',
+  :merchant_id => '123451',
+  :debug       => true
+)
+```
+
+A set of helper methods:
+
+```ruby
+client.production? # => true
+client.sandbox?    # => false
+client.debug?      # => true
+```
+
+## Usage
+
+Check the **API reference** section for objects details. 
+
+Initialize a new client:
+
+```ruby
+client = ArrowPayments::Client.new(
+  :api_key     => 'foo',
+  :mode        => 'sandbox',
+  :merchant_id => '12345'
+)
+```
+
+### Customers
+
+```ruby
+# Get all customers. 
+# Does not include recurring billings and payment methods.
+client.customers # => [Customer, ...]
+
+# Get customer details. 
+# Returns nil if not found
+client.customer('12345')
+
+# Create a new customer. 
+# Raises ArrowPayments::Error if unable to create.
+customer = client.create_customer(
+  :name => 'John Doe',
+  :contact => 'John Doe',
+  :code => 'JOHN',
+  :email => 'john@doe.com',
+  :phone => '(123) 123-12-12'
+)
+
+# Update an existing customer
+customer = client.customer('12345')
+customer.name = 'Foo Bar'
+client.update_customer(customer) # => true
+
+# Delete an existing customer
+client.delete_customer('12345') # => true
+```
+
+### Payment Methods
+
+Example: Add a new payment method to an existing customer
+
+```ruby
+client_id = '12345'
+
+# Initialize a new billing address instance
+address = ArrowPayments::Address.new(
+  :address  => 'Some Street',
+  :address2 => 'Apt 1',
+  :city     => 'Chicago',
+  :state    => 'IL',
+  :zip      => '60657',
+  :phone    => '123123123'
+)
+
+# Initialize a new payment method instance
+cc = ArrowPayments::PaymentMethod.new(
+  :first_name       => 'John',
+  :last_name        => 'Doe',
+  :number           => '4111111111111111',
+  :security_code    => '123',
+  :expiration_month => 12,
+  :expiration_year  => 14
+)
+
+# Step 1: Provide payment method customer and billing address
+url = client.start_payment_method(customer_id, address)
+
+# Step 2: Add credit card information
+token = client.setup_payment_method(url, cc)
+
+# Step 3: Finalize payment method creation
+cc = client.complete_payment_methodtoken)
+
+# Delete an existing payment method
+client.delete_payment_method('123456') # => true
+```
+
+You can also create a payment method using a wrapper method:
+
+```ruby
+address = ArrowPayments::Address.new( ... data ... )
+cc      = ArrowPayments::PaymentMethod.new( ... data ... )
+
+# Returns a new PaymentMethod instance or raises errors
+client.create_payment_method(customer_id, address, cc)
+```
+
+### Transactions
+
+```ruby
+# Get list of transactions by customer. 
+# Only unsettled transactions will be returns as ArrowPayments does not support
+# any other filters for now
+client.transactions('12345')
+
+# Get a single transaction details.
+# Raises ArrowPayments::NotFound if not found
+client.transaction('45678')
+
+# Capture a transaction for a specified amount. 
+# Returns success result or raises ArrowPayments::Error exception
+client.capture_transaction('45678', 123.00)
+
+# Void an existing unsettled transaction
+# Returns a success result or raises ArrowPayments::NotFound if not found
+client.void_transaction('45678')
+
+# Create a new transaction for an existing custromer and payment method.
+# Returns a new Transaction instance if request was successfull, otherwise
+# raises ArrowPayments::Error exception with error message.
+transaction = client.create_transaction(
+  :customer_id        => 'Customer ID', 
+  :payment_method_id  => 'Payment Method ID',
+  :transaction_type   => 'sale',
+  :total_amount       => 250,
+  :tax_amount         => 0,
+  :shipping_amount    => 0
+)
+```
+
+## Reference
+
+List of all gateway errors:
+
+- `ArrowPayments::Error` - Raised on invalid data. Generic error.
+- `ArrowPayments::NotFound` - Raised on invalid API token or non-existing object
+- `ArrowPayments::NotImplemented` - Raised when API endpoint is not implemented
+
+List of all gateway objects:
+
+- `Customer`      - Gateway customer object
+- `PaymentMethod` - Gateway payment method (credit card) object
+- `Transaction`   - Contains all information about transaction 
+- `Address`       - User for shipping and billing addresses
+- `LineItem`      - Contains information about transaction item
+
+### Address
+
+- `address`
+- `address2`
+- `city`
+- `state`
+- `zip`
+- `phone`
+- `tag`
+
+### Customer
+
+- `id`
+- `name`
+- `code`
+- `contact`
+- `phone`
+- `email`
+- `recurring_billings` - Array of `RecurringBilling` instances if any
+- `payment_methods` - Array of PaymentMethod instances if any
+
+### PaymentMethod
+
+- `id`
+- `card_type`
+- `last_digits`
+- `first_name`
+- `last_name`
+- `expiration_month`
+- `expiration_year`
+- `address`
+- `address2`
+- `city`
+- `state`
+- `zip`
+
+### LineItem
+
+- `id`
+- `commodity_code`
+- `description`
+- `price`
+- `product_code`
+- `unit_of_measure`
+
+### Transaction
+
+- `id`
+- `account`
+- `transaction_type`
+- `created_at` - A `DateTime` object of creation
+- `level`
+- `total_amount`
+- `description`
+- `transaction_source`
+- `status` - One of `NotSettled`, `Settled`, `Voided`, `Failed`
+- `capture_amount`
+- `authorization_code`
+- `payment_method_id`
+- `cardholder_first_name`
+- `cardholder_last_name`
+- `card_type`
+- `card_last_digits`
+- `customer_po_number`
+- `tax_amount`
+- `shipping_amount`
+- `shipping_address_id`
+- `shipping_address`
+- `customer_id`
+- `customer_name`
+- `line_items`
+- `billing_address`
+
+## Testing
+
+To run a test suite:
+
+```
+rake test
+```
+
+## TODO
+
+There are multiple features that are pending implementation:
+
+- Filter transactions by status

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test) do |t|
+  t.pattern = 'spec/*_spec.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/arrow_payments.gemspec

@@ -0,0 +1,25 @@
+require File.expand_path('../lib/arrow_payments/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "arrow_payments"
+  s.version     = ArrowPayments::VERSION.dup
+  s.summary     = "Ruby wrapper for ArrowPayments gateway"
+  s.description = "Ruby wrapper for ArrowPayments gateway"
+  s.homepage    = "http://github.com/sosedoff/arrow_payments"
+  s.authors     = ["Dan Sosedoff"]
+  s.email       = ["dan.sosedoff@gmail.com"]
+  
+  s.add_development_dependency 'webmock',   '~> 1.6'
+  s.add_development_dependency 'rake',      '~> 0.9'
+  s.add_development_dependency 'rspec',     '~> 2.12'
+  
+  s.add_runtime_dependency 'faraday',            '~> 0.8'
+  s.add_runtime_dependency 'faraday_middleware', '~> 0.8'
+  s.add_runtime_dependency 'hashie',             '~> 2.0'
+  s.add_runtime_dependency 'json',               '~> 1.7'
+
+  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"]
+end

data/lib/arrow_payments.rb

@@ -0,0 +1,25 @@
+require 'arrow_payments/version'
+require 'arrow_payments/errors'
+
+module ArrowPayments
+  autoload :Configuration,    'arrow_payments/configuration'
+  autoload :Entity,           'arrow_payments/entity'
+  autoload :Customer,         'arrow_payments/customer'
+  autoload :PaymentMethod,    'arrow_payments/payment_method'
+  autoload :RecurringBilling, 'arrow_payments/recurring_billing'
+  autoload :Transaction,      'arrow_payments/transaction'
+  autoload :Address,          'arrow_payments/address'
+  autoload :LineItem,         'arrow_payments/line_item'
+  autoload :Connection,       'arrow_payments/connection'
+  autoload :Client,           'arrow_payments/client'
+
+  autoload :Customers,        'arrow_payments/client/customers'
+  autoload :PaymentMethods,   'arrow_payments/client/payment_methods'
+  autoload :Transactions,     'arrow_payments/client/transactions'
+
+  class << self
+    def client(options={})
+      ArrowPayments::Client.new(options)
+    end
+  end
+end

data/lib/arrow_payments/address.rb

@@ -0,0 +1,11 @@
+module ArrowPayments
+  class Address < Entity
+    property :address,  :from => 'Address1'
+    property :address2, :from => 'Address2'
+    property :city,     :from => 'City'
+    property :state,    :from => 'State'
+    property :zip,      :from => 'Postal'
+    property :phone,    :from => 'Phone'
+    property :tag,      :from => 'Tag'
+  end
+end

data/lib/arrow_payments/client.rb

@@ -0,0 +1,57 @@
+module ArrowPayments
+  class Client
+    include ArrowPayments::Connection
+    include ArrowPayments::Customers
+    include ArrowPayments::PaymentMethods
+    include ArrowPayments::Transactions
+
+    attr_reader :api_key, :mode, :merchant_id, :debug
+
+    # Initialize a new client instance
+    # @param [Hash] client connection options
+    # 
+    # Available options:
+    #
+    #   :api_key - Your API key (required)
+    #   :mode - API mode (sandox / production)
+    #   :merchant_id - Your merchant ID 
+    #   :debug - True for request logging
+    #
+    def initialize(options={})
+      @api_key     = options[:api_key] || ArrowPayments::Configuration.api_key
+      @mode        = (options[:mode] || ArrowPayments::Configuration.mode || 'production').to_s
+      @merchant_id = options[:merchant_id] || ArrowPayments::Configuration.merchant_id
+      @debug       = options[:debug] == true
+
+      if api_key.to_s.empty?
+        raise ArgumentError, "API key required"
+      end
+
+      if merchant_id.to_s.empty?
+        raise ArgumentError, "Merchant ID required"
+      end
+
+      unless %(sandbox production).include?(mode)
+        raise ArgumentError, "Invalid mode: #{mode}"
+      end
+    end
+
+    # Check if client is in sandbox mode
+    # @return [Boolean]
+    def sandbox?
+      mode == 'sandbox'
+    end
+
+    # Check if client is in production mode
+    # @return [Boolean]
+    def production?
+      mode == 'production'
+    end
+
+    # Check if debug mode is enabled
+    # @return [Boolean]
+    def debug?
+      debug == true
+    end
+  end
+end