authorize_net 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af027737f355d0be9ecdf632b089872b67c055ba
+  data.tar.gz: af7373a60654eb83262507dd8b5b3475bf0018f1
+SHA512:
+  metadata.gz: 67c4b05bbea66632978c76b3d7e35ce210746fba8cdd7bd1cf1479a5499d863d3df2da4cc55396d049524a92d52076ac5a091a231424fa085bc67a0eef1d5f50
+  data.tar.gz: 3045de76b817e9e898478829c768c7165be7db6ffb0b96f13065fe13be8e89f4a1800aaf2df6704d729d32b5d03fc35f212b3efc4f85c6c9cb252852ef24f067

data/lib/authorize_net/address.rb

@@ -0,0 +1,22 @@
+require 'authorize_net/data_object'
+
+class AuthorizeNet::Address < AuthorizeNet::DataObject
+
+  ATTRIBUTES = {
+    :first_name => {:key => "firstName"},
+    :last_name => {:key => "lastName"},
+    :company => nil,
+    :address => nil,
+    :city => nil,
+    :state => nil,
+    :zip => nil,
+    :country => nil,
+    :phone => nil,
+    :fax => nil,
+  }
+
+  self::ATTRIBUTES.keys.each do |attr|
+    attr_accessor attr
+  end
+
+end

data/lib/authorize_net/api.rb

@@ -0,0 +1,325 @@
+require 'nokogiri'
+
+# ===============================================================
+# This class uses the AuthroizeRequest object to interact with
+# the Authorize.Net API
+#
+# Add any new Authroize.Net API endpoints here
+# ===============================================================
+class AuthorizeNet::Api
+
+  def initialize(api_login_id, api_transaction_key, is_test_api)
+    @api_login_id = api_login_id
+    @api_transaction_key = api_transaction_key
+    @is_test_api = is_test_api
+    @logger = nil
+    @log_full_request = false
+  end
+
+  def setLogger(logger)
+    @logger = logger
+  end
+
+  def setLogFullRequest(log_full_request)
+    @log_full_request = log_full_request
+  end
+
+  # ===============================================================
+  # Charges the given credit card
+  # @param Number amount
+  # @param AuthorizeNet::CreditCard credit_card
+  # @param AuthorizeNet::Address billing_address
+  # @return {transaction_id}
+  # ===============================================================
+  def chargeCard(amount, credit_card, billing_address=nil)
+    xml_obj = getXmlAuth
+    xml_obj["transactionRequest"] = {
+      "transactionType" => "authCaptureTransaction",
+      "amount" => amount,
+      "payment" => {
+        "creditCard" => credit_card.to_h,
+      },
+    }
+    if !billing_address.nil?
+      xml_obj["transactionRequest"]["billTo"] = billing_address.to_h
+    end
+
+    response = sendRequest("createTransactionRequest", xml_obj)
+    if !response.nil?
+      return AuthorizeNet::Transaction.parse(response)
+    end
+  end
+
+  # ===============================================================
+  # Creates the CustomerProfile and charges the first listed
+  # PaymentProfile on AuthorizeNet
+  # @param Number amount
+  # @param AuthorizeNet::CustomerProfile customer_profile
+  # @return {customer_profile_id, payment_profile_id}
+  # ===============================================================
+  def chargeAndCreateProfile(amount, customer_profile)
+    if customer_profile.payment_profiles.empty?
+      raise "[AuthorizeNet] CustomerProfile in Api.chargeAndCreateProfile requires a PaymentProfile"
+    end
+
+    payment_profile = customer_profile.payment_profiles.first
+    xml_obj = getXmlAuth
+    xml_obj["transactionRequest"] = {
+      "transactionType" => "authCaptureTransaction",
+      "amount" => amount,
+      "payment" => {
+        "creditCard" => payment_profile.credit_card.to_h,
+      },
+      "profile" => {
+        "createProfile" => true,
+      },
+      "customer" => {
+        "id" => customer_profile.merchant_id,
+        "email" => customer_profile.email,
+        "description" => customer_profile.description,
+        "billTo" => payment_profile.billing_address.to_h,
+      },
+    }
+
+    response = sendRequest("createTransactionRequest", xml_obj)
+
+    if !response.nil?
+      return {
+        :transaction => AuthorizeNet::Transaction.parse(response),
+        :customer_profile_id => AuthorizeNet::Util.getXmlValue(
+          response, "customerProfileId"),
+        :payment_profile_id => AuthorizeNet::Util.getXmlValue(
+          response, "customerPaymentProfileIdList numericString"),
+      }
+    end
+  end
+
+  # ===============================================================
+  # Charges the given profile and payment profile on Authorize.net
+  # @param Number amount
+  # @param String/Number customer_profile_id
+  # @param String/Number payment_profile_id
+  # @return transaction_id
+  # ===============================================================
+  def chargeProfile(amount, profile_id, payment_profile_id)
+    xml_obj = getXmlAuth
+    xml_obj["transactionRequest"] = {
+      "transactionType" => "authCaptureTransaction",
+      "amount" => amount,
+      "profile" => {
+        "customerProfileId" => profile_id,
+        "paymentProfile" => {
+          "paymentProfileId" => payment_profile_id,
+        },
+      },
+    }
+
+    response = sendRequest("createTransactionRequest", xml_obj)
+    if !response.nil?
+      return AuthorizeNet::Transaction.parse(response)
+    end
+  end
+
+  # ===============================================================
+  # Creates the given customer profile on Authorize.net
+  # @param AuthorizeNet::CustomerProfile customer_profile
+  # @param Number amount
+  # @param AuthorizeNet::ValidationMode validation_mode (optional)
+  # @return transaction_id
+  # ===============================================================
+  def createCustomerProfile(customer_profile, validation_mode=nil)
+    xml_obj = getXmlAuth
+    xml_obj["profile"] = customer_profile.to_h
+
+    addValidationMode!(xml_obj, validation_mode)
+    response = sendRequest("createCustomerProfileRequest", xml_obj)
+
+    if !response.nil?
+      return {
+        :customer_profile_id => AuthorizeNet::Util.getXmlValue(
+          response, "customerProfileId"),
+        :payment_profile_id => AuthorizeNet::Util.getXmlValue(
+          response, "customerPaymentProfileIdList numericString"),
+      }
+    end
+  end
+
+  # ===============================================================
+  # Create Customer Payment Profile
+  # @param String/Number customer_profile_id
+  # @param AuthorizeNet::PaymentProfile payment_profile
+  # @param AuthorizeNet::ValidationMode validation_mode (optional)
+  # @return {customer_profile_id, payment_profile_id}
+  # ===============================================================
+  def createPaymentProfile(customer_profile_id, payment_profile, validation_mode=nil)
+    xml_obj = getXmlAuth
+    xml_obj["customerProfileId"] = customer_profile_id
+    xml_obj["paymentProfile"] = payment_profile.to_h
+
+    addValidationMode!(xml_obj, validation_mode)
+    response = sendRequest("createCustomerPaymentProfileRequest", xml_obj)
+
+    if !response.nil?
+      return {
+        :customer_profile_id => AuthorizeNet::Util.getXmlValue(
+          response, "customerProfileId"),
+        :payment_profile_id => AuthorizeNet::Util.getXmlValue(
+          response, "customerPaymentProfileId"),
+      }
+    end
+  end
+
+  # ===============================================================
+  # Delete Customer Payment Profile
+  # @param String/Number customer_profile_id
+  # @param String/Number payment_profile_id
+  # @return boolean is delete successful?
+  # ===============================================================
+  def deletePaymentProfile(customer_profile_id, payment_profile_id)
+    xml_obj = getXmlAuth
+    xml_obj["customerProfileId"] = customer_profile_id
+    xml_obj["customerPaymentProfileId"] = payment_profile_id
+
+    response = sendRequest("deleteCustomerPaymentProfileRequest", xml_obj)
+    return !response.nil?
+  end
+
+  # ===============================================================
+  # Validate Customer Payment Profile
+  # @param String/Number customer_profile_id
+  # @param String/Number payment_profile_id
+  # @param AuthorizeNet::ValidationMode::(String) validation_mode
+  # @return boolean is update successful?
+  # ===============================================================
+  def validatePaymentProfile(customer_profile_id, payment_profile_id, validation_mode)
+    xml_obj = getXmlAuth
+    xml_obj["customerProfileId"] = customer_profile_id
+    xml_obj["customerPaymentProfileId"] = payment_profile_id
+    xml_obj["validationMode"] = validation_mode
+
+    response = sendRequest("validateCustomerPaymentProfileRequest", xml_obj)
+    return !response.nil?
+  end
+
+  # ===============================================================
+  # Get customer profile information
+  # @param String/Number customer_profile_id
+  # @param String/Number customer_profile_id
+  # @return AuthorizeNet::CustomerProfile
+  # ===============================================================
+  def getCustomerProfile(customer_profile_id)
+    xml_obj = getXmlAuth
+    xml_obj["customerProfileId"] = customer_profile_id
+
+    response = sendRequest("getCustomerProfileRequest", xml_obj)
+    if response
+      return AuthorizeNet::CustomerProfile.parse(response)
+    end
+  end
+
+  # ===============================================================
+  # Gets transaction information
+  # @param String/Number customer_profile_id
+  # @param String/Number transaction_id
+  # @return AuthorizeNet::Transaction
+  # ===============================================================
+  def getTransactionInfo(transaction_id)
+    xml_obj = getXmlAuth
+    xml_obj["transId"] = transaction_id
+
+    response = sendRequest("getTransactionDetailsRequest", xml_obj)
+    if response
+      return AuthorizeNet::Transaction.parse(response)
+    end
+  end
+
+
+
+  private
+
+  def getXmlAuth
+    return {
+      "merchantAuthentication" => {
+        "name" => @api_login_id,
+        "transactionKey" => @api_transaction_key,
+      }
+    }
+  end
+
+  def addValidationMode!(xml_obj, validation_mode)
+    if validation_mode
+      xml_obj["validationMode"] = validation_mode
+    end
+  end
+
+  # =============================================
+  # Looks for potential errors in the response
+  # and raises an error if it finds any
+  # Passes through OK responses
+  # @throws AuthorizeNet::Exception
+  # =============================================
+  def handleResponse(raw_response)
+    logHttpResponse(raw_response)
+
+    response = AuthorizeNet::Response.parseXml(raw_response.read_body)
+    if response.result == AuthorizeNet::RESULT_OK && response.errors.nil?
+      return response.parsed_xml
+    else
+      logErrorResponse(response)
+      AuthorizeNet::ErrorHandler.handle(response)
+    end
+  end
+
+  # =============================================
+  # Send HTTP request to Authorize Net
+  # @param Net::HTTPResponse
+  # @return response
+  # =============================================
+  def sendRequest(type, xml_obj)
+    uri = @is_test_api ? AuthorizeNet::TEST_URI : AuthorizeNet::URI
+    request = AuthorizeNet::Request.new(type, xml_obj, uri)
+
+    if @logger.respond_to? :info
+      @logger.info(request.toLog(@log_full_request))
+    end
+
+    return handleResponse(request.postRequest)
+  end
+
+  # =============================================
+  # Log HTTP response from Authorize Net
+  # @param Net::HTTPResponse
+  # @return String log
+  # =============================================
+  def logHttpResponse(response)
+    if @logger.respond_to? :logHttpResponse
+      @logger.logHttpResponse(response)
+    elsif @logger.respond_to? :info
+      @logger.info("[AuthorizeNet] HTTP Response code=#{response.code} message=#{response.message}")
+    end
+  end
+
+  # =============================================
+  # Returns a log string with http response data
+  # @param Net::HTTPResponse
+  # @throws RuntimeError
+  # =============================================
+  def logErrorResponse(response)
+    if @logger.respond_to? :info
+      @logger.info("[AuthorizeNet] Responded with resultCode=\"#{response.result}\"")
+    end
+
+    if !response.messages.nil? and @logger.respond_to? :info
+      response.messages.each do |msg|
+        @logger.info("[AuthorizeNet] Message code=\"#{msg[:code]}\" text=\"#{msg[:text]}\"")
+      end
+    end
+
+    if !response.errors.nil? and @logger.respond_to? :error
+      response.errors.each do |error|
+        @logger.error("[AuthorizeNet] Error code=\"#{error[:code]}\" text=\"#{error[:text]}\"")
+      end
+    end
+  end
+
+end

data/lib/authorize_net/credit_card.rb

@@ -0,0 +1,16 @@
+require 'authorize_net/data_object'
+
+class AuthorizeNet::CreditCard < AuthorizeNet::DataObject
+
+  ATTRIBUTES = {
+    :card_num => {:key => "cardNumber"},
+    :expiration => {:key => "expirationDate"},
+    :security_code => {:key => "cardCode"},
+    :card_type => {:key => "cardType"},
+  }
+
+  self::ATTRIBUTES.keys.each do |attr|
+    attr_accessor attr
+  end
+
+end

data/lib/authorize_net/customer_profile.rb

@@ -0,0 +1,26 @@
+require 'authorize_net/data_object'
+require 'authorize_net/payment_profile'
+
+class AuthorizeNet::CustomerProfile < AuthorizeNet::DataObject
+
+  ATTRIBUTES = {
+    :id => {:key => "customerProfileId"},
+    :merchant_id => {:key => "merchantCustomerId"},
+    :email => nil,
+    :description => nil,
+    :payment_profiles => {
+      :key => "paymentProfiles",
+      :type => AuthorizeNet::DataObject::TYPE_OBJECT_ARRAY,
+      :class => AuthorizeNet::PaymentProfile,
+    },
+  }
+
+  self::ATTRIBUTES.keys.each do |attr|
+    attr_accessor attr
+  end
+
+  def initialize
+    @payment_profiles = []
+  end
+
+end

data/lib/authorize_net/data_object.rb

@@ -0,0 +1,123 @@
+# *** NOTE ***
+# Data objects must have a static ATTRIBUTES hash followed by these lines
+#
+#  self::ATTRIBUTES.keys.each do |attr|
+#    attr_accessor attr
+#  end
+#
+class AuthorizeNet::DataObject
+
+  TYPE_ARRAY = :type_array
+  TYPE_OBJECT = :type_object
+  TYPE_OBJECT_ARRAY = :type_object_array
+
+  # =======================================================
+  # Parses XML from the values in the ATTRIBUTES hash in
+  # to the attributes of this object.
+  # =======================================================
+  def parse(xml)
+    if xml.nil? || !xml.respond_to?(:at_css)
+      return
+    end
+
+    self.class::ATTRIBUTES.keys.each do |attr|
+      spec = self.class::ATTRIBUTES[attr].to_h
+      xml_key = spec[:key] || attr.to_s
+      type = spec[:type]
+      type_class = spec[:class]
+
+      if (type == TYPE_OBJECT or type == TYPE_OBJECT_ARRAY) and type_class.nil?
+        raise "DataObject=#{self.class} Attribute=#{attr} of type #{type} must specify a class"
+      end
+
+      if type == TYPE_OBJECT
+        obj_xml = xml.at_css(xml_key)
+        send("#{attr}=", type_class.parse(obj_xml))
+
+      elsif type == TYPE_OBJECT_ARRAY
+        array_xml = xml.css(xml_key)
+        send("#{attr}=", array_xml.map{ |x| type_class.parse(x) })
+
+      elsif type == TYPE_ARRAY
+        array_xml = xml.css(xml_key)
+        send("#{attr}=", array_xml.map{ |x| x.inner_text })
+
+      else
+        send("#{attr}=", AuthorizeNet::Util.getXmlValue(xml, xml_key))
+      end
+    end
+  end
+
+  # =======================================================
+  # Turns this object into a hash using the keys specified
+  # as the values in ATTRIBUTES
+  #
+  # If the value in ATTRIBUTES is nil, use the String
+  # version of the attribute itself
+  # =======================================================
+  def to_h(include_blanks=false)
+    hash = {}
+    self.class::ATTRIBUTES.keys.each do |attr|
+      spec = self.class::ATTRIBUTES[attr].to_h
+      key = spec[:key] || attr.to_s
+      type = spec[:type]
+      value = send(attr)
+
+      if value.nil?
+        if include_blanks
+          hash[key] = nil
+        end
+      elsif type == TYPE_OBJECT
+        hash[key] = value.to_h
+      elsif type == TYPE_OBJECT_ARRAY
+        hash[key] = value.map{ |e| e.to_h }
+      else
+        hash[key] = value
+      end
+    end
+
+    return hash
+  end
+
+  # =======================================================
+  # Turns this object into a hash using the keys specified
+  # as the keys in ATTRIBUTES
+  # =======================================================
+  def serialize
+    hash = {}
+    self.class::ATTRIBUTES.keys.each do |attr|
+      spec = self.class::ATTRIBUTES[attr].to_h
+      type = spec[:type]
+      value = send(attr)
+
+      if value.nil?
+        hash[attr] = nil
+      elsif type == TYPE_OBJECT
+        hash[attr] = value.serialize
+      elsif type == TYPE_OBJECT_ARRAY
+        hash[attr] = value.map{ |e| e.serialize }
+      else
+        hash[attr] = value
+      end
+    end
+
+    return hash
+  end
+
+
+  class << self
+    # =============================================
+    # Parses xml into a new instance of this class
+    # =============================================
+    def parse(xml)
+      if xml.nil? || !xml.respond_to?(:at_css)
+        return
+      end
+
+      object = new
+      object.parse(xml)
+      return object
+    end
+  end
+
+end

data/lib/authorize_net/error_handler.rb

@@ -0,0 +1,137 @@
+
+class AuthorizeNet::ErrorHandler
+  class << self
+    ERROR_FIELD_REGEXES = [
+      /'AnetApi\/xml\/v1\/schema\/AnetApiSchema\.xsd:([a-zA-Z]*)'/,
+      /The element '([a-zA-Z]*)' in namespace 'AnetApi\/xml\/v1\/schema\/AnetApiSchema.xsd'/
+    ]
+
+    MESSAGE_CODES = {
+      "E00003" => :invalid_field,
+      "E00015" => :invalid_field_length,
+      "E00027" => :missing_required_field,
+      "E00039" => :duplicate_record_exists,
+      "E00041" => :customer_profile_info_required,
+    }
+
+    ERROR_CODES = {
+      "210" => :transaction_declined,
+      "6" => :invalid_card_number,
+      "7" => :invalid_expiration_date,
+      "8" => :expired_credit_card,
+    }
+
+    ERROR_FIELDS = {
+      :invalid_card_number => :card_number,
+      :invalid_expiration_date => :card_expiration,
+      :expired_credit_card => :card_expiration,
+
+      "cardNumber" => :card_number,
+      "expirationDate" => :card_expiration,
+      "cardCode" => :card_security_code,
+    }
+
+    # =============================================
+    # Creates an exception, populates it as well
+    # as possible, and then raises it
+    # @param AuthorizeNet::Response
+    # @throws AuthorizeNet::Exception
+    # =============================================
+    def handle(response)
+      exception = AuthorizeNet::Exception.new
+
+      if !response.errors.nil?
+        first_error = response.errors.first
+        exception.message = first_error[:text]
+
+        # Add errors to exception
+        response.errors.each do |error|
+          exception.errors << buildError(error)
+        end
+
+        raise exception
+
+      # If there are no errors, then the "messages" are probably errors... *sigh*
+      elsif !response.messages.nil? and response.result == AuthorizeNet::RESULT_ERROR
+        first_msg = response.messages.first
+        exception.message = first_msg[:text]
+
+        # Add messages (that are sometimes actually errors) to exception
+        response.messages.each do |msg|
+          exception.errors << buildError(msg)
+        end
+
+        raise exception
+      end
+
+    end
+
+    # =============================================
+    # Attempts to determine the error type and field
+    # for an error hash
+    # @param Hash error
+    # @return Hash error
+    # =============================================
+    def buildError(error)
+      code = error[:code]
+      text = error[:text]
+      type = getTypeFromCode(code)
+      field = nil
+
+      if !type.nil? and ERROR_FIELDS.has_key? type
+        field = ERROR_FIELDS[type]
+      else
+        field = getFieldFromText(text)
+      end
+
+      return {
+        :code => code,
+        :text => text,
+        :type => type,
+        :field => field,
+      }
+    end
+
+    # =============================================
+    # Attempts to determine the error type given
+    # an error code
+    # @param String code
+    # @return Symbol|nil type
+    # =============================================
+    def getTypeFromCode(code)
+      if ERROR_CODES.has_key? code
+        return ERROR_CODES[code]
+      elsif MESSAGE_CODES.has_key? code
+        return MESSAGE_CODES[code]
+      end
+      return nil
+    end
+
+    # =============================================
+    # Attempts to determine the error field given
+    # an error message
+    # @param String text
+    # @return Symbol|nil field
+    # =============================================
+    def getFieldFromText(text)
+      if text.nil?
+        return nil
+      end
+
+      ERROR_FIELD_REGEXES.each do |regex|
+        field_match = text.match(regex)
+        if !field_match.nil?
+          field = field_match[1]
+
+          if ERROR_FIELDS.keys.include? field
+            return ERROR_FIELDS[field]
+          end
+          return field
+        end
+      end
+
+      return nil
+    end
+
+  end
+end

data/lib/authorize_net/exception.rb

@@ -0,0 +1,13 @@
+class AuthorizeNet::Exception < Exception
+
+  GENERIC_ERROR_MESSAGE = "[AuthorizeNet] The Authorize.Net API returned an error"
+
+  attr_accessor :message
+  attr_accessor :errors
+
+  def initialize
+    @message = GENERIC_ERROR_MESSAGE
+    @errors = []
+  end
+
+end

data/lib/authorize_net/payment_profile.rb

@@ -0,0 +1,39 @@
+require 'authorize_net/data_object'
+require 'authorize_net/credit_card'
+require 'authorize_net/address'
+
+class AuthorizeNet::PaymentProfile < AuthorizeNet::DataObject
+
+  ATTRIBUTES = {
+    :id => {:key => "customerPaymentProfileId"},
+    :credit_card => {
+      :key => "creditCard",
+      :type => AuthorizeNet::DataObject::TYPE_OBJECT,
+      :class => AuthorizeNet::CreditCard,
+    },
+    :billing_address => {
+      :key => "billTo",
+      :type => AuthorizeNet::DataObject::TYPE_OBJECT,
+      :class => AuthorizeNet::Address,
+    },
+  }
+
+  self::ATTRIBUTES.keys.each do |attr|
+    attr_accessor attr
+  end
+
+  # Override
+  def to_h
+    hash = super
+
+    hash.delete('creditCard')
+    if !@credit_card.nil?
+      hash['payment'] = {
+        'creditCard' => @credit_card.to_h
+      }
+    end
+
+    return hash
+  end
+
+end

data/lib/authorize_net/request.rb

@@ -0,0 +1,93 @@
+require 'net/http'
+require 'uri'
+
+# ===============================================================
+# This class represents a request to the Authorize.Net API
+#
+# Add any logic that applies to ALL requests here
+# ===============================================================
+class AuthorizeNet::Request
+
+  attr_accessor :response
+
+  def initialize(type, data, uri)
+    @xml_data = data
+    @request_type = type
+    @uri = URI(uri)
+    @response = nil
+  end
+
+  # =============================================
+  # Uses the given data to make a POST request
+  # =============================================
+  def postRequest
+    assertRequestData
+    assertRequestType
+    req = Net::HTTP::Post.new(@uri.request_uri)
+    req.add_field('Content-Type', 'text/xml')
+    req.body = buildXmlRequest
+    @response = sendRequest(req)
+    return @response
+  end
+
+  # =============================================
+  # Uses the given data to make a GET request
+  # =============================================
+  def getRequest
+    assertRequestType
+    req = Net::HTTP::Get.new(@uri.request_uri)
+    req.add_field('Content-Type', 'text/xml')
+    req.body = buildXmlRequest
+  end
+
+  # =============================================
+  # Make a log string for this request
+  # =============================================
+  def toLog(log_body)
+    log = "[AuthorizeNet] HTTP Request type=#{@request_type} uri=#{@uri}"
+
+    if log_body
+      log += " body=\"#{buildXmlRequest}\""
+    end
+
+    return log
+  end
+
+
+  private
+
+  def assertRequestData
+    if @xml_data.nil?
+      raise "AuthorizeRequest has no xml data"
+    end
+  end
+
+  def assertRequestType
+    if @request_type.nil?
+      raise "AuthorizeRequest has no request type"
+    end
+  end
+
+  # =============================================
+  # Builds the full XML request using request
+  # type and the xml data object
+  # =============================================
+  def buildXmlRequest
+    xml_string = AuthorizeNet::XML_HEADER
+    xml_string += "<#{@request_type} xmlns=\"#{AuthorizeNet::XML_SCHEMA}\">"
+    xml_string += AuthorizeNet::Util.buildXmlFromObject(@xml_data)
+    xml_string += "</#{@request_type}>"
+    return xml_string
+  end
+
+  # =============================================
+  # Sends the input request to Authorize.Net
+  # =============================================
+  def sendRequest(req)
+    http = Net::HTTP.start(@uri.host, @uri.port, :use_ssl => @uri.scheme == 'https')
+    @response = http.request(req)
+    return @response
+  end
+
+
+end

data/lib/authorize_net/response.rb

@@ -0,0 +1,50 @@
+require 'nokogiri'
+
+class AuthorizeNet::Response
+
+  attr_accessor :result
+  attr_accessor :errors
+  attr_accessor :messages
+  attr_accessor :raw_xml
+  attr_accessor :parsed_xml
+
+  class << self
+
+    # =============================================
+    # Returns a populated response object
+    # @param String xml
+    # @return AuthorizeNet::Response
+    # =============================================
+    def parseXml(xml)
+      response = new
+      response.raw_xml = xml
+      response.parsed_xml = Nokogiri::XML.parse(xml)
+      response.result = AuthorizeNet::Util.getXmlValue(response.parsed_xml, "resultCode")
+
+      errors = response.parsed_xml.at_css("errors")
+      if !errors.nil?
+        response.errors = []
+        errors.css("error").each do |xml_error|
+          response.errors << {
+            :code => AuthorizeNet::Util.getXmlValue(xml_error, "errorCode"),
+            :text => AuthorizeNet::Util.getXmlValue(xml_error, "errorText"),
+          }
+        end
+      end
+
+      messages = response.parsed_xml.at_css("messages")
+      if !messages.nil?
+        response.messages = []
+        messages.css("message").each do |xml_msg|
+          response.messages << {
+            :code => AuthorizeNet::Util.getXmlValue(xml_msg, "code"),
+            :text => AuthorizeNet::Util.getXmlValue(xml_msg, "text"),
+          }
+        end
+      end
+
+      return response
+    end
+  end
+
+end

data/lib/authorize_net/transaction.rb

@@ -0,0 +1,45 @@
+require 'authorize_net/data_object'
+require 'authorize_net/address'
+require 'authorize_net/customer_profile'
+require 'authorize_net/credit_card'
+require 'authorize_net/util'
+
+class AuthorizeNet::Transaction < AuthorizeNet::DataObject
+
+  ATTRIBUTES = {
+    :id => {:key => "transId"},
+    :timestamp_local => {:key => "submitTimeLocal"},
+    :timestamp_utc => {:key => "submitTimeUTC"},
+    :type => {:key => "transactionType"},
+    :status => {:key => "transactionStatus"},
+    :account_num => {:key => "accountNumber"},
+    :account_type => {:key => "accountType"},
+    :auth_code => {:key => "authCode"},
+    :credit_card => {
+      :key => "creditCard",
+      :type => AuthorizeNet::DataObject::TYPE_OBJECT,
+      :class => AuthorizeNet::CreditCard,
+    },
+    :customer_profile => {
+      :key => "customer",
+      :type => AuthorizeNet::DataObject::TYPE_OBJECT,
+      :class => AuthorizeNet::CustomerProfile,
+    },
+    :billing_address => {
+      :key => "billTo",
+      :type => AuthorizeNet::DataObject::TYPE_OBJECT,
+      :class => AuthorizeNet::Address,
+    },
+  }
+
+  self::ATTRIBUTES.keys.each do |attr|
+    attr_accessor attr
+  end
+
+  def parse(xml)
+    super
+
+    @customer_profile.merchant_id = AuthorizeNet::Util.getXmlValue(xml, 'customer id')
+  end
+
+end

data/lib/authorize_net/util.rb

@@ -0,0 +1,55 @@
+class AuthorizeNet::Util
+
+  class << self
+    # ==============================================
+    # A wrapper for safely getting the inner value
+    # of an XML attribute only if it exists
+    #
+    # If multiple instances exist, return the first one
+    # ==============================================
+    def getXmlValue(xml, attr_string)
+      if !xml.respond_to? :at_css || attr_string.nil?
+        return nil
+      end
+
+      attr = xml.at_css(attr_string)
+      if !attr.nil?
+        return attr.inner_text
+      end
+    end
+
+    # ==============================================
+    # Builds XML from Ruby Hashes/Arrays/Primitives
+    # ==============================================
+    def buildXmlFromObject(obj, parent_tag=nil)
+      xml = ""
+      has_parent = !parent_tag.nil?
+
+      # Arrays are formatted with the parent tag
+      # wrapping each of the array elements for some
+      # reason
+      if obj.is_a? Array
+        obj.each do |e|
+          xml += has_parent ? "<#{parent_tag}>" : ""
+          xml += buildXmlFromObject(e)
+          xml += has_parent ? "</#{parent_tag}>" : ""
+        end
+
+      elsif obj.is_a? Hash
+        xml += has_parent ? "<#{parent_tag}>" : ""
+        obj.keys.each do |key|
+          xml += buildXmlFromObject(obj[key], key.to_s)
+        end
+        xml += has_parent ? "</#{parent_tag}>" : ""
+
+      elsif !obj.nil?
+        xml += has_parent ? "<#{parent_tag}>" : ""
+        xml += obj.to_s
+        xml += has_parent ? "</#{parent_tag}>" : ""
+      end
+
+      return xml
+    end
+  end
+
+end

data/lib/authorize_net.rb

@@ -0,0 +1,30 @@
+module AuthorizeNet
+  URI = "https://api.authorize.net/xml/v1/request.api"
+  TEST_URI = "https://apitest.authorize.net/xml/v1/request.api"
+  XML_SCHEMA = "AnetApi/xml/v1/schema/AnetApiSchema.xsd"
+  XML_HEADER = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
+  RESULT_OK = "Ok"
+  RESULT_ERROR = "Error"
+
+  # ===============================================================
+  # Constants for types of authorize net credit card validation
+  #
+  # Live Mode - Executes a test charge on the credit card for $0.01
+  #   that is immediately voided
+  # Test Mode - Does basic mathematical checks on card validity
+  # None - No validation, could be useful for integration tests?
+  # ===============================================================
+  module ValidationMode
+    LIVE = "liveMode"
+    TEST = "testMode"
+    NONE = "None"
+  end
+end
+
+# require all authorize-net files
+Dir['lib/authorize_net/**/*.rb'].each do |filename|
+  match = filename.match(/lib\/(authorize_net\/.*).rb/)
+  if !match.nil?
+    require match[1]
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: authorize_net
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Avenir Interactive LLC
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.6.7.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.7.2
+description: A RubyGem that interfaces with the Authorize.net payment gateway
+email:
+- info@avenirhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/authorize_net.rb
+- lib/authorize_net/address.rb
+- lib/authorize_net/api.rb
+- lib/authorize_net/credit_card.rb
+- lib/authorize_net/customer_profile.rb
+- lib/authorize_net/data_object.rb
+- lib/authorize_net/error_handler.rb
+- lib/authorize_net/exception.rb
+- lib/authorize_net/payment_profile.rb
+- lib/authorize_net/request.rb
+- lib/authorize_net/response.rb
+- lib/authorize_net/transaction.rb
+- lib/authorize_net/util.rb
+homepage: https://github.com/AvenirHQ/authorize_net
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: API interface for Authorize.net payment gateway
+test_files: []
+has_rdoc: