paytrace 0.1.19 → 0.1.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 320dcdc4504f93ee689d060590f765241e9b2e2b
-  data.tar.gz: 8babaffbd61ff385240e26268c4ac9b16002195f
+  metadata.gz: 2c5e82942b71219987900a9ece01e48f70b44833
+  data.tar.gz: 8bb191238ff8bbf79bcc5afcf2011d1e0578d353
 SHA512:
-  metadata.gz: dade330968ea5744206631a953abde4f18aab0a2757f0d0678409931497646dfd522cdd68e51f1e7c01406f3fe6cf9d4ee692b69e17f8890456b37a732a95371
-  data.tar.gz: d2ff117c82ecb19ceda25508cd96a460926c31bdbe0c25ff5e94ae297b4d718cea61722badefdbb3c187ab912219a0046c79a7617938e666ad81d753f51c7e60
+  metadata.gz: f374f6d857de369ec8554404108057191b71e4a9d04f4b9c23f247eafdd25124fdfa9f5e659acf91f11b18463352df8e7b6340db2fbc35ee718e4662fa593a18
+  data.tar.gz: 2b9ec845d6a698605509144cf7aae2fa3b25ba62a802ad95d6036943de2b5009412af076e3efe21bf8b5f636edb097f96507efa36c9569adbbff622f40aab073

data/lib/paytrace/address.rb

@@ -1,7 +1,20 @@
 module PayTrace
+  # Abstracts an address -- two types are possible, shipping and billing.
+  # _Note:_ the "region" parameter can only be defined for shipping addresses, and the
+  # default address type (if unspecified) is billing.
   class Address
     attr_accessor :name, :street,:street2,:city,:state, :country,:region,:postal_code,:address_type
 
+    # Initialize a new address instance. Parameters are symbolic keys in a hash. They are:
+    # * *:name* -- the name on this address
+    # * *:street* -- the street address
+    # * *:street2* -- an optional second line of street address (apartment, suite, etc.)
+    # * *:city* -- the city
+    # * *:state* -- the state 
+    # * *:country* -- the country
+    # * *:postal_code* -- the postal/zip code
+    # * *:address_type* -- either :billing or :shipping
+    # * *:region* -- the region (often county); note, only used for shipping addresses, ignored for billing addresses
     def initialize(options={})
       @name = options[:name]
       @street = options[:street]
@@ -14,6 +27,9 @@ module PayTrace
       @region = options[:region] if @address_type == :shipping # special case for shipping addresses
     end
 
+    # Applies the address parameters to a request object for proper formatting to the API
+    # Parameters:
+    # * *request* -- the request object to apply this address to
     def set_request(request)
       atype_str = address_type.to_s
 

data/lib/paytrace/api/fields.rb

@@ -1,5 +1,6 @@
 module PayTrace
   module API
+    # Friendly names for API methods and parameters
     def self.fields
       {
         amount: "AMOUNT",
@@ -52,6 +53,7 @@ module PayTrace
         check_id:"CHECKID",
         start_date:"SDATE",
         end_date:"EDATE",
+        store_forward_date:"STRFWDDATE",
         #credit card
         card_number: "CC",
         expiration_year: "EXPYR",
@@ -100,6 +102,7 @@ module PayTrace
         recur_count: "TOTALCOUNT",
         recur_receipt: "CUSTRECEIPT",
         recur_type: "RECURTYPE",
+        recur_next: "NEXT",
         # attach signatures
         image_data: "IMAGEDATA",
         image_type: "IMAGETYPE",

data/lib/paytrace/api/gateway.rb

@@ -4,7 +4,9 @@ require 'paytrace/exceptions'
 
 module PayTrace
   module API
+    # Helper for sending requests
     class Gateway
+      # :nodoc:
       attr_accessor :connection
       @@debug = false
       @@last_request = nil
@@ -13,14 +15,17 @@ module PayTrace
       @@next_response = nil
       @@raise_exceptions = true
 
+      # Creates a new gateway object, optionally using a supplied connection object
       def initialize(connection = nil)
         @connection = connection || PayTrace.configuration.connection
       end
 
+      # Sets or clears a debug flag to enable testing
       def self.debug=(enable)
         @@debug = enable
       end 
 
+      # Clears debug data
       def self.reset_trace
         @@last_request = nil
         @@last_response = nil
@@ -28,26 +33,34 @@ module PayTrace
         @@next_response = nil
       end
 
+      # Returns the last request sent (as raw text)
       def self.last_request
         @@last_request
       end
 
+      # Returns the last response received (as raw text)
       def self.last_response
         @@last_response
       end
 
+      # Returns the last response object received
       def self.last_response_object
         @@last_response_object
       end
 
+      # Use this to set the raw text of the next response; only used when debug is true
       def self.next_response=(next_response)
         @@next_response = next_response
       end
 
+      # Sets or clears a flag to raise exceptions on receiving server errors
       def self.raise_exceptions=(raise_exceptions)
         @@raise_exceptions = raise_exceptions
       end
 
+      # Sends a request object
+      # Params:
+      # * *:multi_value_response_fields* -- response fields that may have multiple entries for the same key
       def send_request(request, multi_value_response_fields = [])
         @@last_request = request.to_parms_string if @@debug
         unless (@@debug && @@next_response)

data/lib/paytrace/api/request.rb

@@ -1,8 +1,12 @@
 module PayTrace
   module API
+    # An object representing an API request to be sent using a PayTrace::API::Gateway object
     class Request
+      # :nodoc:
       attr_reader :params, :field_delim, :value_delim, :discretionary_data
+      # :doc:
 
+      # Initializes a new Request object
       def initialize
         @field_delim = "|"
         @multi_field_delim = "+"
@@ -18,6 +22,7 @@ module PayTrace
         @discretionary_data = {}
       end
 
+      # Returns the formatted URL that this request will send
       def to_parms_string()
         raw_request = @params.map do |k,items|
           items.map do |item|
@@ -34,28 +39,39 @@ module PayTrace
         raw_request
       end
 
-      def set_discretionary(k, v = nil)
-        if k.is_a?(Hash)
-          @discretionary_data = k
+      # Sets discretionary data keys and values
+      # * *:key* -- the name of the setting
+      # * *:value* -- the value of the setting
+      def set_discretionary(key, value = nil)
+        if key.is_a?(Hash)
+          @discretionary_data = key
         else
-          @discretionary_data[k] = v unless v.nil?
+          @discretionary_data[key] = value unless value.nil?
         end
       end
 
+      # :nodoc:
       def validate_param(k, v)
         raise PayTrace::Exceptions::ValidationError.new("Unknown field '#{k}'") unless PayTrace::API.fields.has_key?(k)
       end
+      # :doc:
 
-      def set_param(k, v)
-        validate_param(k, v)
+      # Sets a single request parameters
+      # * *:key* -- the name of the setting
+      # * *:value* -- the value of the setting
+      def set_param(key, value = nil)
+        validate_param(key, value)
 
-        unless v.nil?
-          @params[k] ||= []
+        unless value.nil?
+          @params[key] ||= []
 
-          @params[k] << v
+          @params[key] << value
         end
       end
 
+      # Sets multiple parameters with the same name using the custom delimiter
+      # * *:param_name* -- the name of the "top level" setting
+      # * *:items* -- a hash of "second level" settings
       def set_multivalue(param_name, items = {})
         result = (items.map do |k,v|
           validate_param(k, v)
@@ -67,6 +83,9 @@ module PayTrace
         result
       end
 
+      # Sets multiple parameters at once
+      # * *:keys* -- an array of key names to extract from the params hash
+      # * *:params* -- the parameters hash to be extracted from
       def set_params(keys, params)
         keys.each do |key|
           set_param(key, params[key])

data/lib/paytrace/api/response.rb

@@ -1,5 +1,6 @@
 module PayTrace
   module API
+    # An object representing an API response from sending a PayTrace::API::Request with a PayTrace::API::Gateway object
     class Response
       attr_reader :values, :errors
 

data/lib/paytrace/check_transaction.rb

@@ -1,8 +1,28 @@
 module PayTrace
+  # Provides a number of helper methods to process check transactions
   class CheckTransaction
     PROCESS_SALE_METHOD = "ProcessCheck"
     MANAGE_CHECK_METHOD = "ManageCheck"
 
+    # Process a transaction as a sale. Parameters are passed by symbol name in a hash. 
+    # _Note:_ either supply a customer ID *or* an account/routing number. Although passing in
+    # both sets of data will not raise an error, the backend API will ignore the account/routing
+    # number if the customer ID is supplied
+    # 
+    # The parameters are:
+    # * *:check_type* -- the check transaction type; typically "Sale"
+    # * *:amount* -- the amount of the check
+    # * *:customer_id* -- the customer ID for the check
+    # * *:account_anumber* -- the checking account number
+    # * *:routing_number* -- the checking account routing number
+    # * *:email* -- the customer's email
+    # * *:invoice* -- an invoice number to apply to the sale
+    # * *:description* -- a free text description of the sale
+    # * *:tax_amount* -- the tax amount for the sale
+    # * *:customer_reference_id* -- an optional customer reference number
+    # * *:discretionary_data* -- any discretionary data to be applied
+    # * *:shipping_address* -- a shipping address object; see PayTrace::Address
+    # * *:billing_address* -- a billing address object; see PayTrace::Address
     def self.process_sale(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, PROCESS_SALE_METHOD)
@@ -15,6 +35,9 @@ module PayTrace
       end
     end
 
+    # Process a transaction as a hold. Parameters are passed by symbol name in a hash. 
+    # _Note:_ the parameters for this method are identical to process_sale; this is simply
+    # a convenience method. The :check_type is automatically set to "Hold"
     def self.process_hold(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, PROCESS_SALE_METHOD)
@@ -29,6 +52,9 @@ module PayTrace
       end
     end
 
+    # Process a transaction as a refund. Parameters are passed by symbol name in a hash. 
+    # _Note:_ the parameters for this method are identical to process_sale; this is simply
+    # a convenience method. The :check_type is automatically set to "Hold"
     def self.process_refund(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, PROCESS_SALE_METHOD)
@@ -44,6 +70,10 @@ module PayTrace
       end
     end
 
+    # Manage an existing check, setting a new check type if necessary. Params are passed by symbol
+    # name in a hash. They are:
+    # * *:check_type* -- the (new) type of this check (e.g. "Sale", "Hold", "Refund", etc.)
+    # * *:check_id* -- the id of the check to manage
     def self.manage_check(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, MANAGE_CHECK_METHOD)
@@ -56,6 +86,7 @@ module PayTrace
       end
     end
 
+    # Helper method called by the framework. Do not call directly.
     def self.add_common_parameters(params = {}, request)
       request.set_params([
         :check_type, 

data/lib/paytrace/configuration.rb

@@ -1,15 +1,28 @@
 module PayTrace
+  # Contains necessary configuration to access the API server; notably the user name, password, and URL information
   class Configuration
     attr_accessor :user_name, :password, :connection, :domain, :path
 
     RESET_PASSWORD_METHOD = "UpdatePassword"
 
+    # Default initializer. Do not call directly; instead use the PayTrace.configure method
+    # Example:
+    #       PayTrace.configure do |config|
+    #         config.user_name = "demo123"
+    #         config.password = "password"
+    #         config.domain = "stage.paytrace.com"
+    #         config.path = "api/default.pay"
+    #       end
+    #
+    # _Note:_ sane defaults are provided for the domain and path; typically you only need to supply the user name and password.
     def initialize
       @domain = "paytrace.com"
       @connection = Faraday.new
       @path = "api/default.pay"
     end
 
+    # Updates the API password. Parameters are passed in a hash. They are:
+    # * *:new_password* -- the new password to use
     def update_password(params)
       request = PayTrace::API::Request.new
       request.set_param(:method, RESET_PASSWORD_METHOD)
@@ -27,15 +40,19 @@ module PayTrace
       response
     end
 
+    # Returns the API URL, based off the domain and path configured.
     def url
       "https://#{@domain}/#{@path}"
     end
   end
 
+  # Returns the singleton Configuration object
   def self.configuration
     @configuration ||= Configuration.new
   end
 
+  # Allows setting configuration properties via a yield block.
+  # :yields: a Configuration object.
   def self.configure 
     yield(configuration) if block_given?
   end

data/lib/paytrace/credit_card.rb

@@ -1,14 +1,32 @@
 module PayTrace
+  # Contains credit card information, including possible swipe data.
   class CreditCard
     attr_accessor :card_number, :expiration_month, :expiration_year, :swipe, :csc
 
+    # Initialize instance; possible options are: 
+    # * *:card_number* -- the credit card number
+    # * *:expiration_month* -- the expiration month of the card
+    # * *:expiration_year* -- the expiration year of the card
+    # * *:csc* -- the CSC code
+    # * *:swipe* -- swipe data, if present
+    # All parameters are passed in a hash, with symbols for key names.
     def initialize(options={})
-
       @card_number = options[:card_number]
       @expiration_month = options[:expiration_month]
       @expiration_year = options[:expiration_year]
       @swipe = options[:swipe]
       @csc = options[:csc]
     end
+
+    # :nodoc:
+    # Internal helper method; not meant to be called directly.
+    def set_request_data(request = nil)
+      request ||= PayTrace::API::Request.new
+      request.set_param(:card_number, card_number) if card_number
+      request.set_param(:expiration_month, expiration_month) if expiration_month
+      request.set_param(:expiration_year, expiration_year) if expiration_year
+      request.set_param(:swipe, swipe) if swipe
+      request.set_param(:csc, csc) if csc
+    end
   end
 end

data/lib/paytrace/customer.rb

@@ -1,7 +1,9 @@
 module PayTrace
+  # Abstracts the idea of a merchant's customer. Also provides numerous helper methods to aid in managing customers.
   class Customer
     attr :id, :customer_id
 
+    # :nodoc:
     CREATE_CUSTOMER = "CreateCustomer"
     UPDATE_CUSTOMER = "UpdateCustomer"
     DELETE_CUSTOMER = "DeleteCustomer"
@@ -9,14 +11,23 @@ module PayTrace
     EXPORT_INACTIVE_CUSTOMERS = "ExportInactiveCustomers"
     EXPORT_CUSTOMERS_RESPONSE = "CUSTOMERRECORD"
 
+    # :doc:
+    # Initializer. Only param is:
+    # *customer_id* -- the merchant-generated customer ID, if present
     def initialize(customer_id = nil)
       @customer_id = customer_id
     end
 
+    # See http://help.paytrace.com/api-update-customer-profile
+    # Updates the customer's information from parameters hash. See the self.from_cc_info and self.from_transaction_id for
+    # information on the permitted parameters. Immediately updates the profile.
     def update(params = {})
-      set_request_data(UPDATE_CUSTOMER, params)
+      send_request(UPDATE_CUSTOMER, params)
     end
 
+    # See http://help.paytrace.com/api-delete-customer-profile
+    # Sends a request to the server to delete a given customer. No parameters; the customer ID is assumed to be set on
+    # this object.
     def delete
       request = PayTrace::API::Request.new
       request.set_param(:method, DELETE_CUSTOMER)
@@ -25,6 +36,12 @@ module PayTrace
       gateway.send_request(request)
     end
 
+    # See http://help.paytrace.com/api-exporting-customer-profiles for more information.
+    # Exports a customer's (or multiple customers') profile information. Params:
+    # * *:customer_id* -- the customer ID to export
+    # * *:email* -- the email of the customer to export
+    # * *:transaction_user* -- the user name of the PayTrace user who created or processed the customer or transaction you are trying to export
+    # * *:return_bin* -- if set to "Y", card numbers from ExportTranx and ExportCustomers requests will include the first 6 and last 4 digits of the card number
     def self.export(params = {})
       # CUSTID, EMAIL, USER, RETURNBIN
       request = PayTrace::API::Request.new
@@ -41,6 +58,9 @@ module PayTrace
       end
     end
 
+    # See http://help.paytrace.com/api-exporting-inactive-customers
+    # Exports the profiles of customers who have been inactive for a certain length of time. Params:
+    # *:days_inactive* -- the number of days of inactivity to search for
     def self.export_inactive(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, EXPORT_INACTIVE_CUSTOMERS)
@@ -53,38 +73,73 @@ module PayTrace
       end
     end
 
+    # See http://help.paytrace.com/api-delete-customer-profile
+    # Performs the same functionality as Customer.delete, but saves a step by not requiring the user to instantiate a new Customer object first. Params:
+    # *customer_id* -- the merchant-assigned customer ID of the profile to delete
     def self.delete(customer_id)
       Customer.new(customer_id).delete
     end
 
+    # See http://help.paytrace.com/api-create-customer-profile
+    # Creates a new customer profile from credit card information. Params:
+    # *:customer_id* -- customer ID to use
+    # *:billing_address* -- a PayTrace::Address object; at minimum the billing name must be filled out
+    # *:credit_card* -- a PayTrace::CreditCard object
+    # *:shipping_address* -- a PayTrace::Address object representing the shipping address
+    # *:email* -- the customer's email address
+    # *:customer_phone* -- the customer's phone number
+    # *:customer_fax* -- the customer's fax number
+    # *:customer_password* -- password that customer uses to log into customer profile in shopping cart. Only required if you are using the PayTrace shopping cart. 
+    # *:account_number* -- a checking account number to use for the customer
+    # *:routing_number* -- a bank routing number to use
+    # *:discretionary_data* -- discretionay data (if any) for the customer, expressed as a hash
     def self.from_cc_info(params = {})
       customer = Customer.new(params[:customer_id])
-      customer.set_request_data(CREATE_CUSTOMER, params)
+      customer.send_request(CREATE_CUSTOMER, params)
     end
 
+    # See http://help.paytrace.com/api-create-customer-profile
+    # Creates a new customer profile from credit card information. Params are the same as from_cc_info, with the exception that *:transaction_id* is used to reference a previous sale transaction instead of a credit card.
     def self.from_transaction_id(params = {})
       customer = Customer.new(params[:customer_id])
-      customer.set_request_data(CREATE_CUSTOMER, params)
+      customer.send_request(CREATE_CUSTOMER, params)
     end
 
-    def set_request_data(method, params)
-      request = PayTrace::API::Request.new
+    # :nodoc:
+    # Internal helper method; not meant to be called directly.
+    def send_request(method, params)
+      request ||= PayTrace::API::Request.new
       request.set_param(:method, method)
+      if params[:billing_address]
+        params[:billing_address].name = nil if (method == CREATE_CUSTOMER && params[:transaction_id])
+      end
+      set_request_data(params, request)
+
+      gateway = PayTrace::API::Gateway.new
+      response = gateway.send_request(request)
+      unless response.has_errors?
+        values = response.values
+        @id = values["CUSTID"]
+        @customer_id = values["CUSTOMERID"]
+        self
+      else
+        nil
+      end
+    end
+
+    # :nodoc:
+    # Internal helper method; not meant to be called directly.
+    def set_request_data(params, request = nil)
+      request ||= PayTrace::API::Request.new
       request.set_param(:customer_id, params[:customer_id])
       request.set_param(:new_customer_id, params[:new_customer_id])
       request.set_param(:transaction_id, params[:transaction_id])
 
-      if params[:billing_address]
-        params[:billing_address].name = nil if (method == CREATE_CUSTOMER && params[:transaction_id])
-        params[:billing_address].set_request(request)
-      end
+      params[:billing_address].set_request(request) if params[:billing_address]
       params[:shipping_address].set_request(request) if params[:shipping_address]
-        
 
       if params[:credit_card]
-        request.set_param(:card_number, params[:credit_card].card_number)
-        request.set_param(:expiration_month, params[:credit_card].expiration_month)
-        request.set_param(:expiration_year, params[:credit_card].expiration_year)
+        params[:credit_card].set_request_data(request)
       end
 
       request.set_param(:email, params[:email])
@@ -98,17 +153,6 @@ module PayTrace
           request.set_discretionary(k, params[:discretionary_data][k])
         end
       end
-
-      gateway = PayTrace::API::Gateway.new
-      response = gateway.send_request(request)
-      unless response.has_errors?
-        values = response.values
-        @id = values["CUSTID"]
-        @customer_id = values["CUSTOMERID"]
-        self
-      else
-        nil
-      end
     end
   end
 end

data/lib/paytrace/debug.rb

@@ -1,6 +1,7 @@
 require 'paytrace'
 
 module PayTrace
+  # Useful helper methods for debugging.
   module Debug
     #
     # Helper that loops through the response values and dumps them out
@@ -19,10 +20,17 @@ module PayTrace
       end
     end
 
+    # Formatted output for a text message.
     def self.log(msg)
       puts ">>>>>>           #{msg}"
     end
 
+    # Helper method to dump a request response pair. Usage:
+    # Usage: 
+    #  PayTrace::Debug.trace do
+    #  # code the intiates a request/response pair
+    #  end
+    # _Note:_ also includes exception handling to ensure responses are dumped even if an exception occurs
     def self.trace(&block)
       PayTrace::API::Gateway.debug = true
 
@@ -37,6 +45,8 @@ module PayTrace
       end
     end
 
+    # Helper method to configure a default test environment. Accepts *username*, *password*, and *domain* parameters.
+    # domain defaults to "stage.paytrace.com" and the username/password default to the credentials for the sandbox account
     def self.configure_test(un = "demo123", pw = "demo123", domain = "stage.paytrace.com")
       PayTrace.configure do |config|
         config.user_name = un

data/lib/paytrace/email_receipt_request.rb

@@ -1,8 +1,16 @@
 module PayTrace
+  # Methods to request an email receipt for a transaction
   class EmailReceiptRequest
+    # :nodoc:
     TRANSACTION_METHOD = "EmailReceipt"
     attr_accessor :email, :transaction_id, :check_id
+    # :doc:
 
+    # Initializer. Params:
+    # *:email* -- the email address to send the receipt to
+    # *:transaction_id* -- the transaction ID of the transaction to email
+    # *:check_id* -- the check ID of the transaction to email
+    # _Note:_ only use *:transaction_id* _or_ *:check_id* -- not both.
     def initialize(params = {})
       email, id, id_is_check_id = false
       @email = params[:email]
@@ -10,6 +18,7 @@ module PayTrace
       @check_id = params[:check_id]
     end
 
+    # :nodoc:
     def set_request(request = nil)
       request ||= PayTrace::API::Request.new
       request.set_param(:method, TRANSACTION_METHOD)
@@ -19,7 +28,9 @@ module PayTrace
 
       request
     end
+    # :doc:
 
+    # Sends the request for the transaction. Accepts an existing request object, or creates one if needed.
     def send_request(request = nil)
       request ||= set_request
 

data/lib/paytrace/exceptions.rb

@@ -1,11 +1,15 @@
 module PayTrace
+  # Container module for custom PayTrace exceptions
   module Exceptions
+    # Base PayTrace exception object
     class Base < RuntimeError
     end
 
+    # Raised when an unknown field is sent, or an incorrect value is used
     class ValidationError < Base
     end
 
+    # Raised by default when an error response is returned from the server
     class ErrorResponse < Base
     end
   end

data/lib/paytrace/recurring_transaction.rb

@@ -1,7 +1,9 @@
 require 'paytrace'
 
 module PayTrace
+  # Manages recurring transactions
   class RecurringTransaction
+    # :nodoc:
     attr :id, :amount, :customer_id, :next, :total_count, :current_count, :repeat, :description
 
     CREATE_METHOD = "CreateRecur"
@@ -26,18 +28,44 @@ module PayTrace
       "<RecurringTransaction:#{@id},customer id:#{@customer_id},amount: #{@amount},next: #{@next}>"
     end
 
+    # :doc:
+
+    # See http://help.paytrace.com/api-exporting-recurring-transactions
+    # Exports recurring transactions by recurrence ID or customer ID. Params:
+    # * *:recur_id* -- a recurrence ID to export
+    # * *:customer_id* -- a customer ID to export
+    # _Note:_ only supply a recurrence ID _or_ a customer ID, not both.
     def self.export_scheduled(params = {})
       parse_response(set_request_data(EXPORT_SCHEDULED_METHOD, params))
     end
 
+    # See http://help.paytrace.com/api-exporting-a-recurring-transaction
+    # Exports the single most recent recurring transaction for a given customer ID, Params: 
+    # * *:customer_id* -- the customer ID to be exported for
     def self.export_approved(params = {})
       set_request_data(EXPORT_APPROVED_METHOD, params)
     end
 
+    # See http://help.paytrace.com/api-create-recurring-transaction
+    # Creates a recurring transaction. Params:
+    # * *:customer_id* -- the customer ID for which the recurrence should be created
+    # * *:recur_frequency* -- the frequency of the recurrence; this must be 1 for annually, 8 for semi-annually, A for trimesterly, 2 for quarterly, 9 for bi-monthly, , 3 for monthly, 4 for bi-weekly, 7 for 1st and 15th, 5 for weekly, or 6 for daily
+    # * *:recur_start* -- date of the first recurrence
+    # * *:recur_count* -- the total number of times the recurring transaction should be processed. Use 999 if the recurring transaction should be processed indefinitely
+    # * *:amount* -- the amount of the recurrence
+    # * *:transaction_type* -- the transaction type of the recurrence; typically "Sale"
+    # * *:description* -- an optional description of the recurrence
+    # * *:recur_receipt* -- "Y" to send a receipt to the customer at each recurrence; default is "N"
+    # * *:recur_type* -- default value is "C" which represents credit card number. Alternative is "A" which represents an ACH/check transaction
     def self.create(params = {})
       parse_response(set_request_data(CREATE_METHOD, params))
     end
 
+    # See http://help.paytrace.com/api-deleting-a-recurring-transaction
+    # Deletes recurring transactions by recurrence ID or customer ID. Params:
+    # * *:recur_id* -- a recurrence ID to export
+    # * *:customer_id* -- a customer ID to export
+    # _Note:_ only supply a recurrence ID _or_ a customer ID, not both.
     def self.delete(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, DELETE_METHOD)
@@ -51,10 +79,23 @@ module PayTrace
       parse_response(gateway.send_request(request))
     end
 
+    # See http://help.paytrace.com/api-update-recurring-transaction
+    # Updates parameters of an existing recurrence. Params:
+    # * *:recur_id* -- a recurrence ID to update
+    # * *:customer_id* -- the customer ID for which the recurrence should be created
+    # * *:recur_frequency* -- the frequency of the recurrence; this must be 1 for annually, 8 for semi-annually, A for trimesterly, 2 for quarterly, 9 for bi-monthly, 3 for monthly, 4 for bi-weekly, 7 for 1st and 15th, 5 for weekly, or 6 for daily
+    # * *:recur_next* -- the date of the next recurrence
+    # * *:recur_count* -- the total number of times the recurring transaction should be processed. Use 999 if the recurring transaction should be processed indefinitely
+    # * *:amount* -- the amount of the recurrence
+    # * *:transaction_type* -- the transaction type of the recurrence; typically "Sale"
+    # * *:description* -- an optional description of the recurrence
+    # * *:recur_receipt* -- "Y" to send a receipt to the customer at each recurrence; default is "N"
+    # * *:recur_type* -- default value is "C" which represents credit card number. Alternative is "A" which represents an ACH/check transaction; _note:_ only use for check/ACH recurrences
     def self.update(params = {})
       parse_response(set_request_data(UPDATE_METHOD, params))
     end
 
+    # :nodoc:
     def self.parse_response(response)
       unless response.has_errors?
         values = response.values
@@ -75,6 +116,7 @@ module PayTrace
       request.set_param(:customer_id, params[:customer_id])
       request.set_param(:recur_frequency, params[:recur_frequency])
       request.set_param(:recur_start, params[:recur_start])
+      request.set_param(:recur_next, params[:recur_next])
       request.set_param(:recur_count, params[:recur_count])
       request.set_param(:amount, params[:amount])
       request.set_param(:transaction_type, params[:transaction_type])
@@ -85,5 +127,6 @@ module PayTrace
       gateway = PayTrace::API::Gateway.new
       gateway.send_request(request)
     end
+    # :doc:
   end
 end

data/lib/paytrace/transaction.rb

@@ -4,101 +4,175 @@ require 'paytrace/address'
 require 'base64'
 
 module PayTrace
-  module TransactionOperations
-    def sale(args)
+  # Manages transaction-related functionality
+  class Transaction
+    # :nodoc:
+    attr_reader :amount, :credit_card, :type, :customer, :billing_address, :shipping_address,:optional_fields
+    attr_accessor :response, :discretionary_data
+
+    TRANSACTION_METHOD = "PROCESSTRANX"
+    EXPORT_TRANSACTIONS_METHOD = "ExportTranx"
+    EXPORT_TRANSACTIONS_RESPONSE = "TRANSACTIONRECORD"
+    ATTACH_SIGNATURE_METHOD = "AttachSignature"
+    CALCULATE_SHIPPING_COST = "CalculateShipping"
+    CALCULATE_SHIPPING_COST_RESPONSE = "SHIPPINGRECORD"
+    LEVEL_3_VISA_METHOD = "Level3Visa"
+    LEVEL_3_MC_METHOD = "Level3MCRD"
+    SETTLE_TRANSACTION_METHOD = "SettleTranx"
+    ADJUST_AMOUNT_METHOD = "AdjustAmount"
+
+    # :doc:
+
+    # See http://help.paytrace.com/api-sale
+    # Creates a sale transaction. Params (in hash format):
+    # * *:amount* -- the amount of the transaction
+    # Depending upon the type of sale, the following additional parameters may be present:
+    # * *:credit_card* -- a PayTrace::CreditCard object (key entered sale)
+    # * *:customer* -- a PayTrace::Customer object (for additional customer data; customer ID token or referenced transaction sale). _Note:_ for discretionary data, the best way to include it is by adding it to the PayTrace::Customer object.
+    # * *:optional* -- optional fields hash, kept inside the parameters
+    # _Note:_ the following parameters are kept in the optional fields hash
+    # * *:swipe* -- credit card swipe data (card swiped sales)
+    # * *:customer_id* -- a PayTrace customer ID (customer ID token sale)
+    # * *:transaction_id* -- a transaction ID (referenced transaction sale)
+    # * *:csc* -- credit card security code (customer ID token or referenced transaction sale)
+    # * *:invoice* -- an internal invoice number (customer ID token or referenced transaction sale)
+    # * *:description* -- a description of the sale (customer ID token or referenced transaction sale)
+    # * *:tax_amount* -- the amount of tax on the sale (customer ID token or referenced transaction sale)
+    # * *:customer_reference_id* -- a customer reference ID (customer ID token or referenced transaction sale)
+    # * *:return_clr* -- if set to "Y", card level results will be returned w/ the response. Card level results include whether or not the card is a consumer, purchasing, check, rewards, etc. account. Card level results are only returned with requests to process sales or authorizations through accounts on the TSYS/Vital, Heartland, Global, Paymentech, and Trident networks.(customer ID token sale)
+    # * *:custom_dba* -- optional value that is sent to the cardholder’s issuer and overrides the business name stored in PayTrace. Custom DBA values are only used with requests to process sales or authorizations through accounts on the TSYS/Vital, Heartland, and Trident networks (customer ID token sale)
+    # * *:enable_partial_authentication* -- flag that must be set to ‘Y’ in order to support partial authorization and balance amounts in transaction responses (customer ID token sale)
+    def self.sale(args)
       create_transaction(args,TransactionTypes::SALE)
     end
 
-    def authorization(args)
+    # See http://help.paytrace.com/api-authorizations
+    # Performs an authorization transaction. Params (in hash format):
+    # * *:amount* -- the amount of the transaction
+    # Depending upon the type of authorization, the following additional parameters may be present:
+    # * *:credit_card* -- a PayTrace::CreditCard object (standard authorization)
+    # * *:customer* -- a PayTrace::Customer object (for additional customer data; customer ID token or referenced transaction sale). _Note:_ for discretionary data, the best way to include it is by adding it to the PayTrace::Customer object.
+    # * *:optional* -- optional fields hash, kept inside the parameters
+    # _Note:_ the following parameters are kept in the optional fields hash
+    # * *:customer_id* -- a PayTrace customer ID (customer ID token auth)
+    # * *:transaction_id* -- a transaction ID (referenced transaction sale)
+    # * *:csc* -- credit card security code (customer ID token or referenced transaction auth)
+    # * *:invoice* -- an internal invoice number (customer ID token or referenced transaction auth)
+    # * *:description* -- a description of the auth (customer ID token or referenced transaction auth)
+    # * *:tax_amount* -- the amount of tax on the auth (customer ID token or referenced transaction auth)
+    # * *:customer_reference_id* -- a customer reference ID (customer ID token or referenced transaction auth)
+    # * *:return_clr* -- if set to "Y", card level results will be returned w/ the response. Card level results include whether or not the card is a consumer, purchasing, check, rewards, etc. account. Card level results are only returned with requests to process auths or authorizations through accounts on the TSYS/Vital, Heartland, Global, Paymentech, and Trident networks.(customer ID token auth)
+    # * *:custom_dba* -- optional value that is sent to the cardholder’s issuer and overrides the business name stored in PayTrace. Custom DBA values are only used with requests to process auths or authorizations through accounts on the TSYS/Vital, Heartland, and Trident networks (customer ID token auth)
+    # * *:enable_partial_authentication* -- flag that must be set to ‘Y’ in order to support partial authorization and balance amounts in transaction responses (customer ID token auth)
+    def self.authorization(args)
       create_transaction(args,TransactionTypes::Authorization)
     end
 
-    def refund(args)
+    # See http://help.paytrace.com/api-refunds
+    # Note that the parameters and transaction types are the same as for self.sale
+    def self.refund(args)
       create_transaction(args,TransactionTypes::Refund)
     end
 
-    def void(transaction_id)
+    # See http://help.paytrace.com/api-void
+    # Performs a void request. Parameters are:
+    # * *transaction_id* -- (_Note:_ this is _not_ in a hash!) the transaction ID to void
+    def self.void(transaction_id)
       params = {transaction_id: transaction_id}
       t = Transaction.new({type: TransactionTypes::Void,
                           optional:params})
-      t.response = send_request(t)
+      t.response = t.send_request
       t
     end
 
-    def forced_sale(approval_code,args)
+    # See http://help.paytrace.com/api-forced-sale
+    # Performs a forced approval sale. Params are:
+    # *approval_code* -- (_Note:_ this is _not_ in a hash!) the approval code obtained external to the PayTrace system
+    # *args* -- the argument hash, see the arguments for self.sale
+    def self.forced_sale(approval_code,args)
       args[:approval_code] = approval_code
       create_transaction(args,TransactionTypes::ForcedSale)
     end
 
-    def capture(transaction_id)
+    # See http://help.paytrace.com/api-capture
+    # Capturing a transaction updates an approved authorization to a pending settlement status that will initiate a transfer of funds. Processing a capture through the PayTrace API may only be accomplished by providing the transaction ID of the unsettled transaction that should be settled. Params are:
+    # * *transaction_id* -- the transaction ID to be captured
+    def self.capture(transaction_id)
       t = Transaction.new({transaction_id: transaction_id, type: TransactionTypes::Capture,
                           optional:params})
-      t.response = send_request(t)
+      t.response = t.send_request
       t
     end
 
-    def cash_advance(args)
+    # See http://help.paytrace.com/api-cash-advance
+    # Processing a Cash Advance transaction is similar to processing a Sale, however Cash Advances are special transactions that result in cash disbursements to the card holder. Consequently, additional information is required to process Cash Advances. Cash Advances should always be swiped unless your card reader is not able to reader the card’s magnetic stripe. Additionally, your PayTrace account must be specially configured to process this type of transaction. Params are:
+    # * *:amount* -- the amount of the cash advance
+    # Depending upon the type of cash advance, the following additional parameters may be present:
+    # * *:credit_card* -- a PayTrace::CreditCard object (key entered cash advances)
+    # * *:optional* -- optional fields hash, kept inside the parameters
+    # _Note:_ the following parameters are kept in the optional fields hash
+    # * *:swipe* -- swipe data provided with the cash advance (swiped cash advances)
+    # * *:cash_advance* -- (swiped cash advances) When set to "Y", this attribute causes a Sale transaction to be processed as a cash advance where cash is given to the customer as opposed to a product or service. Please note that Cash Advances may only be processed on accounts that are set up on the TSYS/Vital network and are configured to process Cash Advances. Also, only swiped/card present Sales may include the CashAdvance parameter
+    # * *:id_number* -- the card holder’s drivers license number or other form of photo ID
+    # * *:id_expiration* -- the expiration date of the card holder’s photo ID. MM/DD/YYYY
+    # * *:cc_last_4* -- the last 4 digits of the card number as it appears on the face of the card
+    # * *:billing_address* -- a billing address provided with the cash advance
+    # * *:shipping_address* -- a shipping address provided with the cash advance (key entered cash advances)
+    # * *:csc* -- credit card security code (key entered cash advances)
+    # * *:invoice* -- an internal invoice number (key entered cash advances)
+    # * *:description* -- a description of the auth (key entered cash advances)
+    # * *:tax_amount* -- the amount of tax on the auth (key entered cash advances)
+    # * *:customer_reference_id* -- a customer reference ID (key entered cash advances)
+    def self.cash_advance(args)
       args[:cash_advance] = "Y"
 
       create_transaction(args,TransactionTypes::SALE)
     end
 
-    def store_forward(amount,credit_card,optional={})
-      optional[:amount] = amount
-      optional[:credit_card] = credit_card
-      create_transaction(optional,TransactionTypes::StoreForward)
+    # See http://help.paytrace.com/api-store-and-forward
+    # Processing a store & forward through the PayTrace API will request that the transaction is stored for future authorization for specified amount. Please note that the authorization of the store & forward may be scheduled by provided a StrFwdDate value or manually via the Virtual Terminal. *Note that swiped account numbers and CSC values are not stored. Only the card number and expiration dates are stored from the swipe.*
+    # All versions of store and forward may include the following parameters:
+    # * *:amount* -- the amount of the store and forward
+    # * *:optional* -- optional fields hash, kept inside the parameters
+    # The swiped card version takes the following parameters:
+    # * *:swipe* -- swipe data provided with the store and forward (in optional parameters hash)
+    # The key entered version takes the following parameters:
+    # * *:credit_card* -- additional credit card data
+    # The customer ID (token) version takes the following parameters:
+    # * *:customer_id* -- the customer ID (in optional parameters hash)
+    # * *:customer* -- a PayTrace::Customer object for additional customer details
+    # * *:csc* -- credit card security code (in optional parameters hash)
+    # * *:invoice* -- an internal invoice number (in optional parameters hash)
+    # * *:description* -- a description of the auth (in optional parameters hash)
+    # * *:tax_amount* -- the amount of tax on the auth (in optional parameters hash)
+    # * *:customer_reference_id* -- a customer reference ID (in optional parameters hash)
+    # * *:return_clr* -- if set to "Y", card level results will be returned w/ the response. Card level results include whether or not the card is a consumer, purchasing, check, rewards, etc. account. Card level results are only returned with requests to process auths or authorizations through accounts on the TSYS/Vital, Heartland, Global, Paymentech, and Trident networks.(in optional parameters hash)
+    # * *:custom_dba* -- optional value that is sent to the cardholder’s issuer and overrides the business name stored in PayTrace. Custom DBA values are only used with requests to process auths or authorizations through accounts on the TSYS/Vital, Heartland, and Trident networks (in optional parameters hash)
+    # * *:enable_partial_authentication* -- flag that must be set to ‘Y’ in order to support partial authorization and balance amounts in transaction responses (in optional parameters hash)
+    # * *:store_forward_date* -- optional future date when the transaction should be authorized and settled. Only applicable if the TranxType is STR/FWD (in optional parameters hash)
+    def self.store_forward(amount,credit_card,args={})
+      args[:amount] = amount
+      args[:credit_card] = credit_card
+      create_transaction(args,TransactionTypes::StoreForward)
     end
 
-    private
-    def create_transaction(args,type)
+    # :nodoc:
+    def self.create_transaction(args,type)
       amount = args.delete(:amount)  if args[:amount]
       cc = CreditCard.new(args.delete(:credit_card)) if args[:credit_card]
       customer = args.delete(:customer) if args[:customer]
 
-      t = Transaction.new({amount: amount,
-                          credit_card: cc,
-                          customer: customer,
-                          type: type,
-                          optional:args})
+      t = Transaction.new({ 
+        amount: amount,
+        credit_card: cc,
+        customer: customer,
+        type: type,
+        optional:args})      
+      t.send_request
 
-      t.response = send_request(t)
       t
     end
 
-    private
-    def send_request(t)
-      request = PayTrace::API::Request.new
-      t.set_request(request)
-
-      gateway = PayTrace::API::Gateway.new
-      gateway.send_request(request)
-    end
-
-  end
-
-  class Transaction
-    class << self
-      include TransactionOperations
-    end
-
-    attr_reader :amount, :credit_card, :type, :customer, :billing_address, :shipping_address,:optional_fields
-    attr_accessor :response, :discretionary_data
-
-    TRANSACTION_METHOD = "PROCESSTRANX"
-    EXPORT_TRANSACTIONS_METHOD = "ExportTranx"
-    EXPORT_TRANSACTIONS_RESPONSE = "TRANSACTIONRECORD"
-    ATTACH_SIGNATURE_METHOD = "AttachSignature"
-    CALCULATE_SHIPPING_COST = "CalculateShipping"
-    CALCULATE_SHIPPING_COST_RESPONSE = "SHIPPINGRECORD"
-    LEVEL_3_VISA_METHOD = "Level3Visa"
-    LEVEL_3_MC_METHOD = "Level3MCRD"
-    SETTLE_TRANSACTION_METHOD = "SettleTranx"
-    ADJUST_AMOUNT_METHOD = "AdjustAmount"
-
-    def set_shipping_same_as_billing()
-        @shipping_address = @billing_address
-    end
-
     def initialize(params = {})
       @amount = params[:amount]
       @credit_card = params[:credit_card]
@@ -111,7 +185,7 @@ module PayTrace
     def set_request(request)
       add_credit_card(request, credit_card) if credit_card
       if customer.is_a?(PayTrace::Customer)
-        request.set_param(:customer_id, customer.id)
+        customer.set_request_data(request)
       elsif customer.is_a?(Fixnum)
         request.set_param(:customer_id, customer)
       end
@@ -122,18 +196,21 @@ module PayTrace
         request.set_discretionary(@discretionary_data)
       end
     end
+    # :doc:
+
 
     def self.export(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, EXPORT_TRANSACTIONS_METHOD)
-      request.set_param(:transaction_id, params[:transaction_id])
-      request.set_param(:start_date, params[:start_date])
-      request.set_param(:end_date, params[:end_date])
-      request.set_param(:transaction_type, params[:transaction_type])
-      request.set_param(:customer_id, params[:customer_id])
-      request.set_param(:transaction_user, params[:transaction_user])
-      request.set_param(:return_bin, params[:return_bin])
-      request.set_param(:search_text, params[:search_test])
+      request.set_params([
+        :transaction_id,
+        :start_date, 
+        :end_date, 
+        :transaction_type, 
+        :customer_id, 
+        :transaction_user, 
+        :return_bin,
+        :search_text], params)
 
       gateway = PayTrace::API::Gateway.new
       response = gateway.send_request(request, [EXPORT_TRANSACTIONS_RESPONSE])
@@ -146,9 +223,9 @@ module PayTrace
     def self.attach_signature(params = {})
       request = PayTrace::API::Request.new
       request.set_param(:method, ATTACH_SIGNATURE_METHOD)
-      request.set_param(:transaction_id, params[:transaction_id])
-      request.set_param(:image_data, params[:image_data])
-      request.set_param(:image_type, params[:image_type])
+      request.set_params([:transaction_id, 
+        :image_data, 
+        :image_type], params)
       if params.has_key?(:image_file)
         File.open(params[:image_file], 'rb') do |file|
           request.set_param(:image_data, Base64.encode64(file.read))
@@ -250,7 +327,6 @@ module PayTrace
       gateway.send_request(request)      
     end
 
-    private
     def add_transaction_info(request)
       request.set_param(:transaction_type, type)
       request.set_param(:method, TRANSACTION_METHOD)
@@ -258,11 +334,7 @@ module PayTrace
     end
 
     def add_credit_card(request, cc)
-      request.set_param(:card_number, cc.card_number) if cc.card_number
-      request.set_param(:expiration_month, cc.expiration_month) if cc.expiration_month
-      request.set_param(:expiration_year, cc.expiration_year) if cc.expiration_year
-      request.set_param(:swipe, cc.swipe) if cc.swipe
-      request.set_param(:csc, cc.csc) if cc.csc
+      cc.set_request_data(request)
     end
 
     def add_optional_fields(request)
@@ -288,13 +360,21 @@ module PayTrace
       s =  args.delete(:shipping_address) if args[:shipping_address]
       @shipping_address = PayTrace::Address.new({address_type: :shipping}.merge(s)) if s
       if args[:address_shipping_same_as_billing]
-        self.set_shipping_same_as_billing
+        @shipping_address = @billing_address
       end
 
-      @optional_fields = args
+      if args.any?
+        @optional_fields = args
+      end
     end
 
+    def send_request
+      request = PayTrace::API::Request.new
+      self.set_request(request)
 
+      gateway = PayTrace::API::Gateway.new
+      gateway.send_request(request)
+    end
   end
 
   module TransactionTypes

data/lib/paytrace/version.rb

@@ -1,3 +1,4 @@
 module PayTrace
-  VERSION = "0.1.19"
+  # Version number
+  VERSION = "0.1.20"
 end

data/test/paytrace/transaction_spec.rb

@@ -8,6 +8,7 @@ describe PayTrace::Transaction do
   before do
     PayTrace::API::Gateway.debug = true
     PayTrace::API::Gateway.reset_trace()
+    PayTrace::API::Gateway.next_response = "RESPONSE~ok|"
   end
 
   it "exports transaction(s)" do
@@ -78,10 +79,6 @@ describe PayTrace::Transaction do
   end
 
   describe "create sales transactions" do
-    before do
-      @response = mock()
-      PayTrace::API::Gateway.any_instance.expects(:send_request).returns(@response)
-    end
     it "can create a Payment Authorization" do
       t = PayTrace::Transaction.authorization(
           { amount:"1242.32",
@@ -122,7 +119,6 @@ describe PayTrace::Transaction do
       t.credit_card.card_number.must_equal "1234123412341234"
       t.credit_card.expiration_month.must_equal 10
       t.credit_card.expiration_year.must_equal 24
-      t.response.must_equal @response
     end
 
     it "can run a transaction for a customer" do
@@ -135,8 +131,6 @@ describe PayTrace::Transaction do
       t.type.must_equal PayTrace::TransactionTypes::SALE
       t.customer.must_equal 123456
       t.credit_card.must_be_nil
-      t.response.must_equal @response
-
     end
 
     it "can run a cash advance" do
@@ -220,25 +214,6 @@ describe PayTrace::Transaction do
         b.country.must_equal "USA"
         b.postal_code.must_equal "98107"
     end
-
-    it "will return the same address if set to billing shipping same address" do
-      address = {
-        street: "1234 happy lane",
-        street2: "suit 234",
-        city:"Seattle",
-        state:"WA",
-        country:"USA",
-        postal_code:"98107"
-      }
-
-      t = PayTrace::Transaction.new({
-          optional: { billing_address: address
-          } })
-      t.set_shipping_same_as_billing
-
-      t.shipping_address.must_equal t.billing_address
-    end
-
   end
 
   it "can be set to void a transaction" do
@@ -255,16 +230,10 @@ describe PayTrace::Transaction do
   end
 
   it "can create a forced sale" do
-    @response = mock()
-    PayTrace::API::Gateway.any_instance.expects(:send_request).returns(@response)
     t = PayTrace::Transaction.forced_sale("111",{})
 
     t.optional_fields[:approval_code].must_equal "111"
     t.type.must_equal PayTrace::TransactionTypes::ForcedSale
-
-
-
-
   end
 
 

data/test/scripts/run_check_transactions.rb

@@ -3,11 +3,15 @@ $:<< "./lib" # uncomment this to run against a Git clone instead of an installed
 require "paytrace"
 require "paytrace/debug"
 
+# see: http://help.paytrace.com/api-processing-a-check-sale
+
 # change this as needed to reflect the username, password, and test host you're testing against
 PayTrace::Debug.configure_test("demo123", "demo123", "stage.paytrace.com")
 
-# http://help.paytrace.com/api-processing-a-check-sale
+# setting this to false keeps the framework from throwing an exception and halting the integration test at the first error
+PayTrace::API::Gateway.raise_exceptions = false
 
+# process sale transaction -- replace with valid customer ID to see it succeed.
 PayTrace::Debug.trace do
   params = {
   check_type: "Sale",
@@ -18,4 +22,58 @@ PayTrace::Debug.trace do
 }
 
   PayTrace::CheckTransaction::process_sale(params)
+end
+
+# process manage check -- this is invalid data, you can replace with a valid check number 
+# for the login to see it succeed.
+PayTrace::Debug.trace do
+  params = {
+    check_type: "Hold",
+    check_id: 1234
+  }
+
+  PayTrace::CheckTransaction::manage_check(params)
+end
+
+# process a check refund -- replace this with a valid customer ID and amount to see it succeed
+PayTrace::Debug.trace do
+  ba = PayTrace::Address.new({
+    name: "John Doe",
+    street: "1234 Main Street",
+    street2: "Apartment 1B",
+    city: "Shoreline",
+    state: "WA",
+    country: "US",
+    postal_code: "98133",
+    address_type: :billing
+  })
+
+  sa = PayTrace::Address.new({
+    name: "Jane Doe",
+    street: "1235 Moon Street",
+    street2: "Apartment 2C",
+    city: "Shortline",
+    state: "WA",
+    country: "US",
+    postal_code: "98134",
+    address_type: :shipping
+  })
+
+  params = {
+    check_type: "Refund",
+    amount: 15.99,
+    customer_id: "MMouse",
+    billing_address: ba,
+    shipping_address: sa,
+    email: "tom@paytrace.com",
+    invoice: "abc1234",
+    description: "accidental billing",
+    tax: 2.99,
+    customer_reference_id: '1234AB',
+    discretionary_data: {
+      hair_color: :red
+    }
+  }
+
+  PayTrace::CheckTransaction::process_refund(params)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: paytrace
 version: !ruby/object:Gem::Version
-  version: 0.1.19
+  version: 0.1.20
 platform: ruby
 authors:
 - Trevor Redfern
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-04 00:00:00.000000000 Z
+date: 2014-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -176,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Integration providing access to the transaction processing API for PayTrace