an 0.0.1.rc1 → 0.0.1.rc2

data/an.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name              = "an"
-  s.version           = "0.0.1.rc1"
+  s.version           = "0.0.1.rc2"
   s.summary           = "A thin Authorize.NET client."
   s.description       = "AN is a simplified client for integration with Authorize.NET."
   s.authors           = ["Cyril David"]

data/lib/an.rb

@@ -1,93 +1,128 @@
+require "mote"
 require "net/http"
 require "net/https"
 require "uri"
-require "scrivener"
+require "xmlsimple"
 
 class AN
-  class << self
-    attr_accessor :login_id
-    attr_accessor :transaction_key
+  # In production systems, you can simply set
+  #
+  # AUTHORIZE_NET_URL=https://login:key@api.authorize.net/xml/v1/request.api
+  #
+  # in the appropriate location (e.g. /etc/profile.d, ~/.bashrc, or 
+  # whatever you're most comfortable with.
+  #
+  # The TEST URL is https://apikey.authorize.net/xml/v1/request.api
+  def self.connect(url = ENV["AUTHORIZE_NET_URL"])
+    new(URI(url))
+  end
+  
+  TEMPLATES = File.expand_path("../templates", File.dirname(__FILE__))
+
+  include Mote::Helpers
+
+  attr :url
+  attr :auth
+  attr :client
+ 
+  def initialize(uri)
+    @auth   = { login: uri.user, transaction_key: uri.password }
+    @client = Client.new(uri)
   end
 
-  class ValueObject < Scrivener
-    # This is an Authorize.net specific implementation detail,
-    # basically all their field names are prefixed with an `x_`.
-    def to_hash
-      {}.tap do |ret|
-        attributes.each do |att, val|
-          ret["x_#{att}"] = val
-        end
-      end
-    end
+  def transact(params)
+    call("createTransactionRequest", params)
+  end
+
+  def create_profile(params)
+    call("createCustomerProfileRequest", params)
   end
 
-  class CreditCard < ValueObject
-    attr_accessor :card_num
-    attr_accessor :card_code
-    attr_accessor :exp_month
-    attr_accessor :exp_year
+  def create_payment_profile(params)
+    call("createCustomerPaymentProfileRequest", params)
+  end
+  
+  def create_profile_transaction(params)
+    call("createCustomerProfileTransactionRequest", params)
+  end
 
-    def validate
-      assert_present(:card_num) &&
-        assert(Luhn.check(card_num), [:card_num, :not_valid])
+private 
+  def call(api_call, params)
+    Response.new(post(payload(api_call, params)))
+  end
+  
+  def post(xml)
+    client.post(xml, "Content-Type" => "text/xml")
+  end
 
-      assert_present(:card_code)
+  def payload(api_call, params)
+    mote(File.join(TEMPLATES, "%s.mote" % api_call), params.merge(auth))
+  end
+  
+  class Response
+    attr :data
+  
+    OK = "Ok"
 
-      assert_format(:exp_month, /\A\d{1,2}\z/) &&
-        assert_format(:exp_year, /\A\d{4}\z/) &&
-          assert(exp_in_future, [:exp_date, :not_valid])
+    def initialize(xml)
+      @data = XmlSimple.xml_in(xml, forcearray: false)      
     end
 
-    # Convert to the expiry date expected by the API which is in MMYY.
-    def exp_date
-      y = "%.4i" % exp_year
-      m = "%.2i" % exp_month
+    def success?
+      data["messages"]["resultCode"] == OK
+    end
 
-      "#{m}#{y[-2..-1]}"
+    def transaction_id
+      data["transactionResponse"]["transId"]      
     end
 
-    def to_hash
-      { "x_card_num" => card_num, "x_card_code" => card_code,
-        "x_exp_date" => exp_date }
+    def reference_id
+      data["refId"]
     end
 
-  private
-    def exp_in_future
-      Time.new(exp_year, exp_month) > Time.now
+    def profile_id
+      data["customerProfileId"]      
     end
-  end
 
-  class Customer < ValueObject
-    attr_accessor :first_name
-    attr_accessor :last_name
-    attr_accessor :address
-    attr_accessor :state
-    attr_accessor :zip
-    attr_accessor :email
+    def payment_profile_id
+      data["customerPaymentProfileId"]
+    end
 
-    def validate
-      assert_present :first_name
-      assert_present :last_name
+    def validation_response
+      if resp = data["validationDirectResponse"] || data["directResponse"]
+        ValidationResponse.new(resp)
+      end
     end
   end
 
-  class Invoice < ValueObject
-    attr_accessor :invoice_num
-    attr_accessor :amount
-    attr_accessor :description
+  class ValidationResponse
+    RESPONSE_FIELDS = %w[code subcode reason_code reason_text
+                         authorization_code avs_response trans_id
+                         invoice_number description amount method
+                         transaction_type customer_id first_name
+                         last_name company address city state zip
+                         country phone fax email
+                         shipping_first_name shipping_last_name
+                         shipping_company shipping_address shipping_city
+                         shipping_state shipping_zip shipping_country
+                         tax duty freight tax_exempt purchase_order_number
+                         md5_hash card_code_response cavv_response
+                         _41 _42 _43 _44 _45 _46 _47 _48 _49 _50
+                         account_number card_type split_tender_id
+                         requested_amount balance_on_card].freeze
+
+    attr :fields
 
-    def amount=(amount)
-      if amount.nil? || amount.empty?
-        @amount = nil
-      else
-        @amount = "%.2f" % amount
-      end
+    def initialize(data, delimiter = ",")
+      @fields = Hash[RESPONSE_FIELDS.zip(data.split(delimiter))]
     end
 
-    def validate
-      assert_present(:invoice_num) && assert_length(:invoice_num, 1..20)
-      assert_present(:amount)
-      assert_present(:description)
+    def success?
+      fields["code"] == "1" && fields["reason_code"] == "1"
+    end
+
+    def transaction_id
+      fields["trans_id"]
     end
   end
 
@@ -102,8 +137,8 @@ class AN
       @http.use_ssl = true if uri.scheme == "https"
     end
 
-    def post(params)
-      reply(http.post(path, params))
+    def post(params, *args)
+      reply(http.post(path, params, *args))
     end
 
     def reply(res)
@@ -117,20 +152,22 @@ class AN
     end
   end
 
-  class AIM
-    DELIMITER = "<|>"
+end
+
+__END__
 
-    DEFAULT_PARAMS = {
-      "x_version"        => "3.1",
-      "x_delim_data"     => "TRUE",
-      "x_delim_char"     => DELIMITER,
-      "x_relay_response" => "FALSE",
-      "x_method"         => "CC"
-    }.freeze
+module AN
+  require_relative "an/client"
+  require_relative "an/model"
+  require_relative "an/aim"
+  require_relative "an/cim"
 
-    TEST = "https://test.authorize.net/gateway/transact.dll"
-    LIVE = "https://secure.authorize.net/gateway/transact.dll"
+  class << self
+    attr_accessor :login_id
+    attr_accessor :transaction_key
+  end
 
+  class PaymentResponse
     RESPONSE_FIELDS = %w[code subcode reason_code reason_text
                          authorization_code avs_response trans_id
                          invoice_number description amount method
@@ -145,94 +182,26 @@ class AN
                          account_number card_type split_tender_id
                          requested_amount balance_on_card]
 
-    def self.test
-      new(TEST)
-    end
-
-    def self.live
-      new(LIVE)
-    end
-
-    def initialize(url)
-      @client = Client.connect(url)
-      @params = DEFAULT_PARAMS.merge(
-        "x_login" => AN.login_id,
-        "x_tran_key" => AN.transaction_key
-      )
-    end
-
-    def sale(customer, invoice, card)
-      transact("AUTH_CAPTURE", customer, invoice, card)
-    end
+    attr :fields
 
-    def authorize(customer, invoice, card)
-      transact("AUTH_ONLY", customer, invoice, card)
+    def initialize(data, delimiter = ",")
+      @fields = Hash[RESPONSE_FIELDS.zip(data.split(delimiter))]
     end
 
-    def capture(trans_id)
-      transact("PRIOR_AUTH_CAPTURE", {
-        "x_trans_id" => trans_id
-      })
+    def success?
+      fields["code"] == "1" && fields["reason_code"] == "1"
     end
 
-    def refund(trans_id, card_num, amount)
-      transact("CREDIT", {
-        "x_trans_id" => trans_id,
-        "x_card_num" => card_num,
-        "x_amount" => amount
-      })
+    def code
+      fields["code"]
     end
 
-    def void(trans_id, split_tender_id = nil)
-      transact("VOID", {
-        "x_trans_id" => trans_id,
-        "x_split_tender_id" => split_tender_id
-      })
+    def message
+      fields["reason_text"]
     end
 
-  private
-    def transact(type, *models)
-      params = @params.merge("x_type" => type, "x_email_customer" => "TRUE")
-      models.each { |model| params.merge!(model.to_hash) }
-
-      response = Hash[RESPONSE_FIELDS.zip(post(params))]
-
-      if response["code"] == "1"
-        response
-      else
-        raise TransactionFailed.new(response), response["reason_text"]
-      end
-    end
-
-    def post(params)
-      @client.post(URI.encode_www_form(params)).split(DELIMITER)
-    end
-  end
-
-  class TransactionFailed < StandardError
-    attr :response
-
-    def initialize(response)
-      @response = response
-    end
-  end
-
-  # @see http://en.wikipedia.org/wiki/Luhn_algorithm
-  # @credit https://gist.github.com/1182499
-  module Luhn
-    RELATIVE_NUM = { '0' => 0, '1' => 2, '2' => 4, '3' => 6, '4' => 8,
-                     '5' => 1, '6' => 3, '7' => 5, '8' => 7, '9' => 9 }
-
-    def self.check(number)
-      number = number.to_s.gsub(/\D/, "").reverse
-
-      sum = 0
-
-      number.split("").each_with_index do |n, i|
-        sum += (i % 2 == 0) ? n.to_i : RELATIVE_NUM[n]
-      end
-
-      sum % 10 == 0
+    def trans_id
+      fields["trans_id"]
     end
   end
 end

data/test/an.rb

@@ -1,63 +1,98 @@
-require_relative "../lib/an"
-require "securerandom"
-require "benchmark"
-
-AN.login_id = ENV["LOGIN_ID"]
-AN.transaction_key = ENV["TRANS_KEY"]
+require_relative "helper"
 
 setup do
-  customer = AN::Customer.new(first_name: "John",
-                                        last_name: "Doe",
-                                        zip: "98004",
-                                        email: "me@cyrildavid.com")
-
-  invoice = AN::Invoice.new(invoice_num: SecureRandom.hex(20),
-                                      amount: "19.99",
-                                      description: "Sample Transaction")
-
-  card = AN::CreditCard.new(card_num: "4111111111111111",
-                                      card_code: "123",
-                                      exp_month: "1", exp_year: "2015")
-
-  [customer, invoice, card]
+  AN.connect
 end
 
-test "straight up sale" do |customer, invoice, card|
-  gateway = AN::AIM.test
-  response = gateway.sale(customer, invoice, card)
+test "AIM basic transaction" do |gateway|
+  resp = gateway.transact({
+    :card_number => "4111111111111111",
+    :card_code => "123",
+    :expiration_date => "2015-01",
+    :amount => "10.00",
+    :invoice_number => SecureRandom.hex(10),
+    :description => "Aeutsahoesuhtaeu",
+    :first_name => "John",
+    :last_name => "Doe",
+    :address => "12345 foobar street",
+    :zip => "90210"
+  })
 
-  assert_equal "1", response["code"]
+  assert resp.success?
+  assert resp.transaction_id
 end
 
-test "wrong credit card number" do |customer, invoice, card|
-  gateway = AN::AIM.test
-  card.card_num = "4111222233334444"
-
-  ex = nil
+# CIM (Customer Information Manager)
+scope do
+  test do |gateway|
+    reference_id = SecureRandom.hex(10)
+    customer_id  = SecureRandom.hex(10)
 
-  begin
-    gateway.sale(customer, invoice, card)
-  rescue Exception => e
-    ex = e
-  end
+    # So this step ideally should be done in a background process
+    # after the user on your site signs up.
+    resp = gateway.create_profile(reference_id: reference_id,
+                                  customer_id: customer_id,
+                                  email: "foo@bar.com")
+    
+    assert resp.success?
+    assert_equal reference_id, resp.reference_id
+    assert resp.profile_id
 
-  assert ex.kind_of?(AN::TransactionFailed)
-  assert_equal "6", ex.response["reason_code"]
-  assert_equal "The credit card number is invalid.", ex.response["reason_text"]
-end
+    # After a successful response in the background process, you
+    # should store the profile id in your User hash / table / relation.
+    profile_id = resp.profile_id
 
-test "authorize and capture" do |customer, invoice, card|
-  gateway = AN::AIM.test
-  auth = gateway.authorize(customer, invoice, card)
-  capt = gateway.capture(auth["trans_id"])
+    # Now this happens when the customer provides his credit card details
+    # the first time he tries to go into a page or resource that requires
+    # a form of payment. For example in heroku, you need to add a credit
+    # card as soon as you try to use any kind of add-on.
+    resp = gateway.create_payment_profile(profile_id: profile_id,
+                                          first_name: "Quentin",
+                                          last_name: "Tarantino",
+                                          card_number: "4111111111111111",
+                                          card_code: "123",
+                                          address: "#12345 Foobar street",
+                                          zip: "90210",
+                                          expiration_date: "2015-01")
 
-  assert_equal "1", capt["code"]
-end
+    # If you're to allow the entry of this payment profile, then you
+    # should verify 2 things:
+    #
+    # 1. the actual response is successful
+    # 2. the payment response is successful.
+    #
+    # By default the validation method used is liveMode which returns an
+    # AIM-like payment response string related to the credit card details
+    # passed as part of creating the payment profile.
+    assert resp.success?  
+    assert resp.payment_profile_id
+    assert resp.validation_response.success?
+    
+    assert_equal "XXXX1111", resp.validation_response.fields["account_number"]
+    assert_equal "Visa", resp.validation_response.fields["card_type"]
+  
+    # The payment profile id should then be saved together with the user.
+    # You may also do a one-to-many setup similar to amazon where they can
+    # add multiple credit cards. If that's the case, simply use the
+    # account_number / card type in order to let the customer identify
+    # which credit card is which.
+    payment_profile_id = resp.payment_profile_id
 
-test "authorize and void" do |customer, invoice, card|
-  gateway = AN::AIM.test
-  auth = gateway.authorize(customer, invoice, card)
-  void = gateway.void(auth["trans_id"])
-
-  assert_equal "1", void["code"]
+    # Now this should be executed when the customer does a one-click
+    # payment option similar to amazon, or when the end of month utility
+    # bill is due (i.e. AWS / Heroku).
+    resp = gateway.create_profile_transaction({
+      profile_id: profile_id,
+      payment_profile_id: payment_profile_id,
+      amount: "11.95",
+      invoice_number: SecureRandom.hex(10),
+      description: "Jan - Feb",
+      purchase_order_number: "001"
+    })
+    
+    assert resp.success?
+    assert resp.validation_response.success?
+    assert_equal "XXXX1111", resp.validation_response.fields["account_number"]
+    assert_equal "Visa", resp.validation_response.fields["card_type"]
+  end
 end

data/test/helper.rb

@@ -0,0 +1,3 @@
+require "cutest"
+require "securerandom"
+require_relative "../lib/an"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: an
 version: !ruby/object:Gem::Version
-  version: 0.0.1.rc1
+  version: 0.0.1.rc2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-10 00:00:00.000000000 Z
+date: 2012-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: scrivener
-  requirement: &2151820040 !ruby/object:Gem::Requirement
+  requirement: &2156032980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2151820040
+  version_requirements: *2156032980
 - !ruby/object:Gem::Dependency
   name: cutest
-  requirement: &2151819460 !ruby/object:Gem::Requirement
+  requirement: &2155894040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151819460
+  version_requirements: *2155894040
 description: AN is a simplified client for integration with Authorize.NET.
 email:
 - me@cyrildavid.com
@@ -45,6 +45,7 @@ files:
 - lib/an.rb
 - an.gemspec
 - test/an.rb
+- test/helper.rb
 homepage: http://github.com/cyx/an
 licenses: []
 post_install_message: