authorizenet 1.9.7 → 2.0.0

data/lib/authorize_net/reporting/transaction_details.rb

@@ -1,22 +0,0 @@
-module AuthorizeNet::Reporting
-  # Models the details of a transaction.
-  class TransactionDetails
-    include AuthorizeNet::Model
-
-    attr_accessor :id, :submitted_at, :status, :order, :customer, :account_type,
-                  :account_number, :settle_amount, :reference_id, :split_tender_id,
-                  :type, :response_code, :response_reason_code, :response_reason_description,
-                  :auth_code, :avs_response, :card_code_response, :cavv_response,
-                  :fds_filter_action, :fds_filters, :batch, :prepaid_balance_remaining,
-                  :payment_method, :recurring_billing, :bill_to, :ship_to, :auth_amount,
-                  :subscription_id, :subscription_paynum, :solution_id, :solution_name, :returns
-
-    def submitted_at=(time)
-      if time.is_a?(DateTime)
-        @submitted_at = time
-      else
-        @submitted_at = DateTime.parse(time.to_s)
-      end
-    end
-  end
-end

data/lib/authorize_net/sim/hosted_payment_form.rb

@@ -1,34 +0,0 @@
-module AuthorizeNet::SIM
-  # Models a hosted payment form.
-  class HostedPaymentForm
-    include AuthorizeNet::Model
-
-    attr_accessor :header_html, :footer_html, :color_background, :color_link, :color_text, :logo_url, :background_url, :rename
-
-    # Convenience method for adding field rename requests to the transaction. This renames a field shown on
-    # the hosted payment form.
-    def add_rename(field, name)
-      rename = "#{field},#{name}"
-      if @rename.nil?
-        @rename = [rename]
-      else
-        @rename = @rename.to_a << rename
-      end
-    end
-
-    def to_hash
-      hash = {
-        header_html_payment_form: @header_html,
-        footer_html_payment_form: @footer_html,
-        color_background: @color_background,
-        color_link: @color_link,
-        color_text: @color_text,
-        logo_url: @logo_url,
-        background_url: @background_url,
-        rename: @rename
-      }
-      hash.delete_if { |_k, v| v.nil? }
-      hash
-    end
-  end
-end

data/lib/authorize_net/sim/hosted_receipt_page.rb

@@ -1,32 +0,0 @@
-module AuthorizeNet::SIM
-  # Models a hosted receipt page.
-  class HostedReceiptPage
-    # Defines constants for each of the link methods used by the hosted receipt page.
-    module LinkMethod
-      LINK = 'LINK'.freeze
-      POST = 'POST'.freeze
-      GET = 'GET'.freeze
-    end
-
-    include AuthorizeNet::Model
-
-    attr_accessor :header_html, :footer_html, :color_background, :color_link, :color_text, :logo_url, :background_url, :link_method, :link_text, :link_url
-
-    def to_hash
-      hash = {
-        header_html_receipt: @header_html,
-        footer_html_receipt: @footer_html,
-        color_background: @color_background,
-        color_link: @color_link,
-        color_text: @color_text,
-        logo_url: @logo_url,
-        background_url: @background_url,
-        receipt_link_method: @link_method,
-        receipt_link_text: @link_text,
-        receipt_link_url: @link_url
-      }
-      hash.delete_if { |_k, v| v.nil? }
-      hash
-    end
-  end
-end

data/lib/authorize_net/sim/response.rb

@@ -1,133 +0,0 @@
-module AuthorizeNet::SIM
-  # The SIM response class. Handles parsing the response from the gateway. Also
-  # provides a few relay response helpers used to implement Direct Post Method.
-  class Response < AuthorizeNet::KeyValueResponse
-    # Our MD5 digest generator.
-    @@digest = OpenSSL::Digest.new('md5')
-
-    include AuthorizeNet::SIM::Fields
-
-    # Constructs a new response object from a +raw_response+. Provides utility methods
-    # for validating the response as authentic, and for handling the Direct Post Method
-    # relay response.
-    #
-    # +raw_response+:: The raw response, either a string in POST body or GET query string format, or a hash of key/value pairs.
-    #
-    # Typical usage:
-    #   response = AuthorizeNet::SIM::Response("x_first_name=John&x_last_name=Doe")
-    def initialize(raw_response)
-      @raw_response = raw_response
-      @custom_fields = {}
-      @fields = {}
-      parse_response(@raw_response)
-    end
-
-    # Returns True if the MD5 hash found in the response payload validates using
-    # the supplied api_login and secret merchant_value (THIS IS NOT YOUR API KEY).
-    def valid_md5?(api_login, merchant_value)
-      return false if @fields[:MD5_Hash].nil?
-      @@digest.hexdigest("#{merchant_value}#{api_login}#{@fields[:trans_id]}#{@fields[:amount]}").casecmp(@fields[:MD5_Hash]).zero?
-    end
-
-    # Returns an HTML string that can be returned to the gateway during the Relay Response,
-    # and will send the user on to URL you specify. Takes a hash of options, currently the
-    # only option is :include, which can be True to include all fields returned in the response
-    # as query string parameters, or it can be an array of fields to include.
-    def direct_post_reply(url, options = {})
-      url = direct_post_url(url, options[:include]) if options.key?(:include)
-      js_url = url.tr("'", '\'')
-      html_url = url.gsub('&', '&amp;').tr('"', "\"")
-      html = <<-HTML
-<html><head><script type="text/javascript" charset="utf-8">window.location='#{js_url}';</script><noscript><meta http-equiv="refresh" content="1;url=#{html_url}"></noscript></head><body></body></html>
-HTML
-    end
-
-    # Returns an URL with the fields found in the response and specified in include_fields attached as
-    # part of the URL's query string. If you pass true instead of an array of fields, all fields will be
-    # attached.
-    def direct_post_url(base_url, include_fields = true)
-      url = base_url
-      if include_fields
-        fields = []
-        case include_fields
-        when TrueClass
-          fields = FIELDS.collect do |k|
-            k_str = k.to_s
-            k_str[2..k_str.length].to_sym
-          end
-        when Array
-          fields = include_fields
-        else
-          fields = include_fields.to_a
-        end
-        parsed_url = URI.parse(url)
-        if parsed_url.query.nil?
-          parsed_url.query = ''
-        elsif !parsed_url.query.empty?
-          parsed_url.query = parsed_url.query.chomp('&') + '&'
-        end
-        parsed_url.query += ((fields.select { |k| @fields.key?(k) }).collect { |k| to_param(k, @fields[k]) }).join('&')
-        parsed_url.query.chomp('&')
-        url = parsed_url.to_s
-      end
-      url
-    end
-
-    # Check to see if the response indicated success. Success is defined as a valid MD5 hash
-    # and an response code of AuthorizeNet::Response::ResponseCode::APPROVED.
-    def success?(api_login, merchant_value)
-      valid_md5?(api_login, merchant_value) && approved?
-    end
-
-    # Returns the transaction's authorization code. This should be shown to the
-    # end user.
-    def authorization_code
-      @fields[:auth_code]
-    end
-
-    # Returns the transaction's authorization id. You will need this for future void, refund
-    # and prior authorization capture requests.
-    def transaction_id
-      @fields[:trans_id]
-    end
-
-    # Returns the customer id from the response.
-    def customer_id
-      @fields[:cust_id]
-    end
-
-    # Returns a response code (from AVSResponseCode) indicating the result of any Address Verification
-    # Service checks.
-    def avs_response
-      @fields[:avs_code]
-    end
-
-    #:enddoc:
-    protected
-
-    # Internal helper to parse the raw response object. It handles both raw POST bodies and
-    # hashes.
-    def parse_response(raw_response)
-      case raw_response
-      when Hash
-        raw_response.each do |k, v|
-          k = k.to_sym
-          if FIELDS.include?(k)
-            @fields[to_internal_field(k)] = v # remove x_ from sym and stick in @fields
-          else
-            @custom_fields[k] = v
-          end
-        end
-      when String
-        # convert to hash and re-parse
-        hash = CGI.parse(raw_response)
-        hash.each do |k, v|
-          hash[k] = v[0] if v.is_a?(Array) && v.length == 1
-        end
-        parse_response(hash)
-      else
-        parse_response(@raw_response.to_s)
-      end
-    end
-  end
-end

data/lib/authorize_net/sim/transaction.rb

@@ -1,128 +0,0 @@
-module AuthorizeNet::SIM
-  # The SIM transaction class. Handles building the transaction payload and
-  # generating a set of hidden form fields to be POSTed to the gateway.
-  class Transaction < AuthorizeNet::KeyValueTransaction
-    RANDOM_SEQUENCE_MAX = (1 << 32) - 1
-
-    # Our MD5 digest generator.
-    @@digest = OpenSSL::Digest.new('md5')
-
-    # The default options for the constructor.
-    @@option_defaults = {
-      sequence: nil,
-      timestamp: nil,
-      test: false,
-      hosted_payment_form: false,
-      relay_response: true,
-      relay_url: nil,
-      transaction_type: Type::AUTHORIZE_AND_CAPTURE
-    }
-
-    # Constructs a SIM transaction. You can use the new SIM transaction object
-    # to build the hidden field payload needed to process a SIM transaction with
-    # the gateway. In particular, this class handles generating the MD5 fingerprint
-    # used to authenticate transactions at the gateway. Since the fingerprint includes
-    # the amount to charge, you should not construct this object until you know EXACTLY
-    # how much you want to charge (or authorize).
-    #
-    # +api_login_id+:: Your API login ID, as a string.
-    # +api_transaction_key+:: Your API transaction key, as a string.
-    # +amount+:: The amount of the transaction, as a string, Float or BigDecimal.
-    # +options+:: A hash of options. See below for values.
-    #
-    # Options
-    # +sequence+:: The sequence number of the transaction as a string or Integer. This is usually something like an invoice number. If none is provided, the SDK generates one at random.
-    # +timestamp+:: The time the transaction was initiated as a string or Integer. This needs to be within 15 minutes of when the gateway receives the transaction. If no value is provided, the SDK defaults it to Time.now().
-    # +test+:: A boolean indicating if the transaction should be run in test mode or not (defaults to false).
-    # +hosted_payment_form+:: A boolean indicating if the transaction should use a hosted payment form (defaults to false).
-    # +relay_response+:: A boolean indicating if the transaction should use the relay response feature to return a receipt to the customer (defaults to true). Direct Post Method requires using a relay response.
-    # +relay_url+:: A string of the URL that the gateway should hit to get the relay response (defaults to nil).
-    # +transaction_type+:: The type of transaction to perform. Defaults to AuthorizeNet::Type::AUTHORIZE_AND_CAPTURE. This value is only used if run is called directly.
-    #
-    def initialize(api_login_id, api_transaction_key, amount, options = {})
-      ActiveSupport::Deprecation.warn "use AuthorizeNet::API::Transaction"
-      super()
-      @api_transaction_key = api_transaction_key
-      @api_login_id = api_login_id
-      @amount = decimal_to_value(amount)
-      options = @@option_defaults.merge(options)
-      @sequence = options[:sequence]
-      @timestamp = options[:timestamp]
-      @test_mode = options[:test]
-      @hosted_payment_form = options[:hosted_payment_form]
-      @relay_url = options[:relay_url]
-      @type = options[:transaction_type]
-      if @relay_url.nil?
-        @relay_response = !!options[:relay_response]
-      else
-        @relay_response = true
-      end
-      @delim_data = !@relay_response
-    end
-
-    # Calculates and returns the HMAC-MD5 fingerprint needed to authenticate the transaction
-    # with the SIM gateway.
-    def fingerprint
-      @timestamp = Time.now.to_i if @timestamp.nil?
-
-      @sequence = rand(RANDOM_SEQUENCE_MAX) if @sequence.nil?
-      OpenSSL::HMAC.hexdigest(@@digest, @api_transaction_key, "#{@api_login_id.to_s.rstrip}^#{@sequence.to_s.rstrip}^#{@timestamp.to_s.rstrip}^#{@amount.to_s.rstrip}^")
-    end
-
-    # Returns all the fields needed for the fingerprint. These must all be passed to the SIM
-    # exactly as returned. And these values are time sensitive.
-    def fingerprint_fields
-      {
-        login: @api_login_id,
-        fp_hash: fingerprint,
-        fp_sequence: @sequence,
-        fp_timestamp: @timestamp,
-        amount: @amount
-      }
-    end
-
-    # Returns all the fields (including custom) exactly as they should be named
-    # in the SIM form. Fields with multiple values are returned with an array
-    # for the key's value.
-    def form_fields
-      form_fields = {}
-      form_fields[:x_test_request] = boolean_to_value(@test_mode)
-      form_fields[:x_show_form] = 'PAYMENT_FORM' if @hosted_payment_form
-      if @relay_response && !@relay_url.nil?
-        form_fields[:x_relay_url] = @relay_url
-      end
-      fields.merge(type: @type, version: @version, delim_data: boolean_to_value(@delim_data), relay_response: boolean_to_value(@relay_response)).each do |k, v|
-        form_fields[to_external_field(k)] = v
-      end
-      fingerprint_fields.each do |k, v|
-        form_fields[to_external_field(k)] = v
-      end
-      form_fields.merge(custom_fields)
-    end
-
-    # Takes an instance of AuthorizeNet::SIM::HostedPaymentForm and adds it to the transaction. Note that
-    # many of the fields in AuthorizeNet::SIM::HostedPaymentForm are shared with those in
-    # AuthorizeNet::SIM::HostedReceiptPage. For the duplicate fields, which ever value
-    # is added to the transaction last will be the one used.
-    def set_hosted_payment_form(form)
-      @fields.merge!(form.to_hash)
-      @hosted_payment_form = true
-    end
-
-    # Takes an instance of AuthorizeNet::SIM::HostedReceiptPage and adds it to the transaction. Note that
-    # many of the fields in AuthorizeNet::SIM::HostedReceiptPage are shared with those in
-    # AuthorizeNet::SIM::HostedPaymentForm. For the duplicate fields, which ever value
-    # is added to the transaction last will be the one used. If you set a hosted payment receipt,
-    # the relay response will be disabled.
-    def set_hosted_payment_receipt(form)
-      @fields.merge!(form.to_hash)
-      @relay_response = false
-      @delim_data = true
-    end
-
-    # An alias for form_fields.
-    def run
-      form_fields
-    end
-  end
-end

data/lib/generators/authorize_net/direct_post/direct_post_generator.rb

@@ -1,52 +0,0 @@
-require 'rails/generators'
-require 'rails/generators/named_base'
-
-module AuthorizeNet
-  module Generators
-    class DirectPostGenerator < Rails::Generators::NamedBase
-      source_root File.expand_path('templates', __dir__)
-      p '__FILE__:' + __FILE__
-      p 'source_root:' + source_root
-      argument :api_login_id, type: :string, desc: 'Your Authorize.Net API login ID.', optional: true
-      argument :api_transaction_key, type: :string, desc: 'Your Authorize.Net API transaction key.', optional: true
-      argument :merchant_hash_value, type: :string, desc: 'Your Authorize.Net merchant hash value.', optional: true
-      desc <<-DESC
-Description
-    Generates a simple implementation of Authorize.Net's Direct Post Method integration method.
-
-Example:
-    rails generate authorize_net:direct_post payments API_LOGIN_ID API_TRANSACTION_KEY MERCHANT_HASH_VALUE
-
-    This will create:
-      create  README-AuthorizeNet
-      create  app/views/payments
-      create  app/views/payments/payment.erb
-      create  app/views/payments/receipt.erb
-      create  app/views/payments/relay_response.erb
-      create  app/views/layouts/authorize_net.erb
-      create  config/authorize_net.yml
-      create  config/initializers/authorize_net.rb
-      create  app/controllers/payments_controller.rb
-       route  match '/payments/receipt', :to => 'payments#receipt', :as => 'payments_receipt', :via => [:get]
-       route  match '/payments/relay_response', :to => 'payments#relay_response', :as => 'payments_relay_response', :via => [:post]
-       route  match '/payments/payment', :to => 'payments#payment', :as => 'paymentspayment', :via => [:get]
-
-DESC
-
-      def manifest
-        copy_file "README-AuthorizeNet", "README-AuthorizeNet"
-        empty_directory "app/views/#{file_name}"
-        copy_file "payment.rails3.erb", "app/views/#{file_name}/payment.erb"
-        copy_file "receipt.erb", "app/views/#{file_name}/receipt.erb"
-        copy_file "relay_response.erb", "app/views/#{file_name}/relay_response.erb"
-        copy_file "layout.erb", "app/views/layouts/authorize_net.erb"
-        template "config.yml.rails3.erb", "config/authorize_net.yml"
-        copy_file "initializer.rb", "config/initializers/authorize_net.rb"
-        template "controller.rb.erb", "app/controllers/#{file_name}_controller.rb"
-        route "match '/#{plural_name}/receipt', :to => '#{file_name}#receipt', :as => '#{singular_name}_receipt', :via => [:get]"
-        route "match '/#{plural_name}/relay_response', :to => '#{file_name}#relay_response', :as => '#{singular_name}_relay_response', :via => [:post]"
-        route "match '/#{plural_name}/payment', :to => '#{file_name}#payment', :as => '#{singular_name}payment', :via => [:get]"
-      end
-    end
-  end
-end

data/lib/generators/authorize_net/direct_post/templates/README-AuthorizeNet

@@ -1,49 +0,0 @@
-= Authorize.Net Ruby SDK
-
-The Authorize.Net Ruby SDK is meant to offer an alternate object-oriented
-model of development with the Authorize.net APIs (Version 3.1). The SDK is
-based entirely off the name-value pair API, but performs the core payment
-activities (such as error handling/parsing, network communication, and data
-encoding) behind the scenes. Providing the end developer with this allows the
-developer to start integrating immediately without having to write out a mass
-of boiler plate code.
-
-== Prerequisites
-
-* Ruby 1.8.7 or higher
-* RubyGem 1.3.7 or higher (to build the gem)
-* RDoc 1.0 or higher (to build documentation)
-* Rake 0.8.7 or higher (to use the rake tasks)
-
-== Installation
-
-Goto the Authorize.Net SDK download page and download the Ruby gem. Then
-
-  > gem install authorize-net-1.0.0.gem
-
-== Usage
-
-A generator is provided to aid in setting up a Direct Post Method application. In the example below 'payments' is the name of the controller to generate.
-
-  > sudo gem install rails -v '~> 2.1'
-  > rails my_direct_post_app
-  > cd my_direct_post_app
-  > script/generate authorize_net_direct_post payments YOUR_API_LOGIN_ID YOUR_TRANSACTION_KEY MERCH_HASH_KEY
-  > script/server
-  
-After running the generator you will probably want to customize the payment form found in 'app/views/payments/payment.erb' and the receipt found in 'app/views/payments/receipt.erb'.
-
-There is also a default layout generated, 'app/views/layouts/authorize_net.erb'. If you already have your own layout, you can delete that file and the reference to it in the controller ('app/controllers/payments_controller.rb').
-
-
-== Credit Card Test Numbers
-
-For your reference, you can use the following test credit card numbers.
-The expiration date must be set to the present date or later. Use 123 for
-the CCV code.
-
-American Express::  370000000000002
-Discover::  6011000000000012
-Visa::  4007000000027
-JCB:: 3088000000000017
-Diners Club/ Carte Blanche::  38000000000006