authorizenet 1.8.2 → 1.8.3

data/lib/authorize_net/xml_response.rb~

@@ -1,173 +0,0 @@
-module AuthorizeNet
-
-  # The core, xml response class. You shouldn't instantiate this one.
-  # Instead you should use AuthorizeNet::ARB::Response.
-  class XmlResponse < AuthorizeNet::Response
-    
-    # DO NOT USE. Instantiate AuthorizeNet::ARB::Response or AuthorizeNet::CIM::Response instead.
-    def initialize(raw_response, transaction)
-      @raw_response = raw_response
-      @transaction = transaction
-      unless connection_failure?
-        begin
-          xml = Nokogiri::XML(@raw_response.body) do |config|
-            # confirm noent is the right flag
-            config.recover.noent.nonet
-          end
-          @root = xml.children[0]
-          @result_code = node_content_unless_nil(@root.at_css('messages resultCode'))
-          @message_code = node_content_unless_nil(@root.at_css('messages message code'))
-          @message_text = node_content_unless_nil(@root.at_css('messages message text'))
-          @reference_id = node_content_unless_nil(@root.at_css('refId'))
-        rescue
-          @raw_response = $!
-        end
-      end
-    end
-    
-    # Check to see if the response indicated success. Success is defined as a 200 OK response with a resultCode
-    # of 'Ok'.
-    def success?
-puts "there"
-      !connection_failure? && @result_code == 'Ok'
-    end
-    
-    # Returns true if we failed to open a connection to the gateway or got back a non-200 OK HTTP response.
-    def connection_failure?
-      !@raw_response.kind_of?(Net::HTTPOK)
-    end
-    
-    # Returns the underlying Net::HTTPResponse object. This has the original response body along with
-    # headers and such. Note that if an exception is generated while making the request (which happens
-    # if there is no internet connection for example), you will get the exception object here instead of
-    # a Net::HTTPResponse object.
-    def raw
-      @raw_response
-    end
-    
-    # Returns a deep-copy of the XML object received from the payment gateway. Or nil if there was no XML payload.
-    def xml
-      @root.dup unless @root.nil?
-    end
-    
-    # Returns the resultCode from the XML response. resultCode will be either 'Ok' or 'Error'.
-    def result_code
-      @result_code
-    end
-    
-    # Returns the messageCode from the XML response. This is a code indicating the details of an error
-    # or success.
-    def message_code
-      @message_code
-    end
-    
-    # Returns the messageText from the XML response. This is a text description of the message_code.
-    def message_text
-      @message_text
-    end
-    
-    # Alias for result_code.
-    def response_code
-      result_code
-    end
-    
-    # Alias for message_code.
-    def response_reason_code
-      message_code
-    end
-    
-    # Alias for message_text.
-    def response_reason_text
-      message_text
-    end
-    
-    # Returns the refId from the response if there is one. Otherwise returns nil.
-    def reference_id
-      @reference_id
-    end
-    
-    #:enddoc:
-    protected
-    
-    def node_content_unless_nil(node)
-      if node.nil?
-        nil
-      else
-        node.content
-      end
-    end
-    
-    def node_child_content_unless_nil(node)
-      if node.nil?
-        nil
-      else
-        if node.children.length > 0
-          node.children.collect(&:content)
-        else
-          nil
-        end
-      end
-    end
-    
-    # Transforms a block of XML into a model Object defined by entity_desc.
-    def build_entity(xml, entity_desc)
-      args = {}
-      entity_desc.node_structure.each do |node_desc|
-        node_name = (node_desc.keys.reject {|k| k.to_s[0..0] == '_' }).first
-        args.merge!(handle_node_type(xml, node_desc, node_name, args, ''))
-      end
-      
-      if args.length == 0
-        return nil
-      end
-      
-      if entity_desc.arg_mapping.nil?
-        return entity_desc.entity_class.new(args)
-      else
-        args_list = []
-        entity_desc.arg_mapping.each do |arg|
-          args_list <<= args[arg]
-          args.delete(arg)
-        end
-        args_list <<= args
-        return entity_desc.entity_class.new(*args_list)
-      end
-    end
-    
-    # Parses an XML fragment into an internal representation.
-    def handle_node_type(xml, node_desc, node_name, args, base_name)
-      case node_desc[node_name]
-      when Symbol
-        node = xml.at_css(base_name + node_name.to_s)
-        unless node.nil?
-          content = node.content
-          case node_desc[:_converter]
-          when Method, Proc
-            content = node_desc[:_converter].call(content)
-          when Symbol
-            content = self.send(node_desc[:_converter], content)
-          end
-          args[node_desc[node_name]] = content unless content.nil?
-        end
-      when AuthorizeNet::EntityDescription
-        unless node_desc[:_multivalue].nil?
-          xml.css(base_name + node_name.to_s).each do |node|
-            entity = build_entity(node, node_desc[node_name])
-            args[node_desc[:_multivalue]] = args[node_desc[:_multivalue]].to_a + entity.to_a unless entity.nil?
-          end
-        else
-          entity = build_entity(xml.css(base_name + node_name.to_s), node_desc[node_name])
-          args[node_desc[:_value]] = entity unless entity.nil?
-        end
-      when Array
-        node_desc[node_name].each do |inner_node|
-          inner_node_name = (inner_node.keys.reject {|k| k.to_s[0..0] == '_' }).first
-          args.merge!(handle_node_type(xml, inner_node, inner_node_name, args, node_name.to_s + ' '))
-        end
-      end
-      return args
-    end
-      
-  end
-  
-end

data/lib/authorize_net/xml_transaction.rb~

@@ -1,276 +0,0 @@
-module AuthorizeNet
-
-  # The ARB transaction class.
-  class XmlTransaction < AuthorizeNet::Transaction
-    
-    # The XML namespace used by the ARB API.
-    XML_NAMESPACE = 'AnetApi/xml/v1/schema/AnetApiSchema.xsd'
-    
-    # Constants for both the various Authorize.Net subscription gateways are defined here.
-    module Gateway
-      LIVE = 'https://api.authorize.net/xml/v1/request.api'
-      TEST = 'https://apitest.authorize.net/xml/v1/request.api'
-    end
-    
-    # Constants for both the various Authorize.Net transaction types are defined here.
-    module Type
-      ARB_CREATE = "ARBCreateSubscriptionRequest"
-      ARB_UPDATE = "ARBUpdateSubscriptionRequest"
-      ARB_GET_STATUS = "ARBGetSubscriptionStatusRequest"
-      ARB_CANCEL = "ARBCancelSubscriptionRequest"
-      ARB_GET_SUBSCRIPTION_LIST = "ARBGetSubscriptionListRequest"
-      CIM_CREATE_PROFILE = "createCustomerProfileRequest"
-      CIM_CREATE_PAYMENT = "createCustomerPaymentProfileRequest"
-      CIM_CREATE_ADDRESS = "createCustomerShippingAddressRequest"
-      CIM_CREATE_TRANSACTION = "createCustomerProfileTransactionRequest"
-      CIM_DELETE_PROFILE = "deleteCustomerProfileRequest"
-      CIM_DELETE_PAYMENT = "deleteCustomerPaymentProfileRequest"
-      CIM_DELETE_ADDRESS = "deleteCustomerShippingAddressRequest"
-      CIM_GET_PROFILE_IDS = "getCustomerProfileIdsRequest"
-      CIM_GET_PROFILE = "getCustomerProfileRequest"
-      CIM_GET_PAYMENT = "getCustomerPaymentProfileRequest"
-      CIM_GET_ADDRESS = "getCustomerShippingAddressRequest"
-      CIM_UPDATE_PROFILE = "updateCustomerProfileRequest"
-      CIM_UPDATE_PAYMENT = "updateCustomerPaymentProfileRequest"
-      CIM_UPDATE_ADDRESS = "updateCustomerShippingAddressRequest"
-      CIM_UPDATE_SPLIT = "updateSplitTenderGroupRequest"
-      CIM_VALIDATE_PAYMENT = "validateCustomerPaymentProfileRequest"
-      REPORT_GET_BATCH_LIST = "getSettledBatchListRequest"
-      REPORT_GET_TRANSACTION_LIST = "getTransactionListRequest"
-      REPORT_GET_TRANSACTION_DETAILS = "getTransactionDetailsRequest"
-    end
-    
-    # Fields to convert to/from booleans.
-    @@boolean_fields = []
-    
-    # Fields to convert to/from BigDecimal.
-    @@decimal_fields = []
-    
-    # Fields to convert to/from Date.
-    @@date_fields = []
-    
-    # Fields to convert to/from DateTime.
-    @@datetime_fields = []
-    
-    # The class to wrap our response in.
-    @response_class = AuthorizeNet::XmlResponse
-    
-    # The default options for the constructor.
-    @@option_defaults = {
-      :gateway => :production,
-      :verify_ssl => false,
-      :reference_id => nil
-    }
-    
-    # DO NOT USE. Instantiate AuthorizeNet::ARB::Transaction or AuthorizeNet::CIM::Transaction instead.
-    def initialize(api_login_id, api_transaction_key, options = {})
-      super()
-      @api_login_id = api_login_id
-      @api_transaction_key = api_transaction_key
-      
-      @response ||= nil
-      @type ||= nil
-      
-      options = @@option_defaults.merge(options)
-      @verify_ssl = options[:verify_ssl]
-      @reference_id = options[:reference_id]
-      case options[:gateway]
-      when :sandbox, :test
-        @gateway = Gateway::TEST
-      when :production, :live
-        @gateway = Gateway::LIVE
-      else
-        @gateway = options[:gateway]
-      end
-    end
-    
-    # Checks if the transaction has been configured for the sandbox or not. Return FALSE if the
-    # transaction is running against the production, TRUE otherwise.
-    def test?
-      @gateway != Gateway::LIVE
-    end
-        
-    # Checks to see if the transaction has a response (meaning it has been submitted to the gateway).
-    # Returns TRUE if a response is present, FALSE otherwise.
-    def has_response?
-      !@response.nil?
-    end
-    
-    # Retrieve the response object (or Nil if transaction hasn't been sent to the gateway).
-    def response
-      @response
-    end
-    
-    # Submits the transaction to the gateway for processing. Returns a response object. If the transaction
-    # has already been run, it will return nil.
-    def run
-      make_request
-    end
-    
-    # Returns a deep-copy of the XML object sent to the payment gateway. Or nil if there was no XML payload.
-    def xml
-      @xml
-    end
-    
-    #:enddoc:
-    protected
-    
-    # Takes a list of nodes (a Hash is a node, and Array is a list) and returns True if any nodes
-    # would be built by build_nodes. False if no new nodes would be generated.
-    def has_content(nodeList, data)
-      nodeList.each do |node|
-        nodeName = (node.keys.reject {|k| nodeName.to_s[0..0] == '_' }).first
-        multivalue = node[:_multivalue]
-        conditional = node[:_conditional]
-        value = node[nodeName]
-        unless conditional.nil?
-          value = self.send(conditional, nodeName)
-        end
-        case value
-        when Array
-          if multivalue.nil?
-            if has_content(value, data)
-              return true
-            end
-          else
-            data[multivalue].each do |v|
-              if has_content(value, v)
-                return true
-              end
-            end
-          end
-        when Symbol
-          converted = convert_field(value, data[value])
-          return true unless converted.nil?
-        else
-          return true
-        end
-      end
-      false
-    end
-    
-    # Takes a list of nodes (a Hash is a node, and Array is a list) and recursively builds the XML by pulling
-    # values as needed from data.
-    def build_nodes(builder, nodeList, data)
-      nodeList.each do |node|
-        # TODO - ADD COMMENTS HERE
-        nodeName = (node.keys.reject {|k| k.to_s[0..0] == '_' }).first
-        multivalue = node[:_multivalue]
-        conditional = node[:_conditional]
-        value = node[nodeName]
-
-        unless conditional.nil?
-          value = self.send(conditional, nodeName)
-        end
-        case value
-        when Array # node containing other nodes
-          if multivalue.nil?
-            proc = Proc.new { build_nodes(builder, value, data) }
-            builder.send(nodeName, &proc) if has_content(value, data)
-          else
-            data[multivalue].to_a.each do |v|
-              proc = Proc.new { build_nodes(builder, value, v) }
-              builder.send(nodeName, &proc) if has_content(value, v)
-            end
-          end
-        when Symbol # node containing actual data
-          if data[value].kind_of?(Array)
-            data[value].each do |v|
-              converted = convert_field(value, v)
-              builder.send(nodeName, converted) unless converted.nil?
-            end
-          else
-            converted = convert_field(value, data[value])
-            builder.send(nodeName, converted) unless converted.nil?
-          end
-        else
-          builder.send(nodeName, value)
-        end
-      end
-    end
-    
-    def convert_field(field, value)
-      if @@boolean_fields.include?(field) and !value.nil?
-        return boolean_to_value(value)
-      elsif @@decimal_fields.include?(field) and !value.nil?
-        return decimal_to_value(value)
-      elsif @@date_fields.include?(field) and !value.nil?
-        return date_to_value(value)
-      elsif @@datetime_fields.include?(field) and !value.nil?
-        return datetime_to_value(value)
-      elsif field == :extra_options
-        # handle converting extra options
-        options = []
-        unless value.nil?
-          value.each_pair{|k,v| options <<= self.to_param(k, v)}
-        end
-        unless @custom_fields.nil?
-          # special sort to maintain compatibility with AIM custom field ordering
-          # FIXME - This should be DRY'd up.
-          custom_field_keys = @custom_fields.keys.collect(&:to_s).sort.collect(&:to_sym)
-          for key in custom_field_keys
-            options <<= self.to_param(key, @custom_fields[key.to_sym], '')
-          end
-        end
-        
-        if options.length > 0
-          return options.join('&')
-        else
-          return nil
-        end
-      elsif field == :exp_date
-        # convert MMYY expiration dates into the XML equivalent
-        unless value.nil?
-          begin
-            return value.to_s.downcase == 'xxxx' ? 'XXXX' : Date.strptime(value.to_s, '%m%y').strftime('%Y-%m')
-          rescue
-            # If we didn't get the exp_date in MMYY format, try our best to convert it
-            return Date.parse(value.to_s).strftime('%Y-%m')
-          end
-        end
-      end
-      
-      value
-    end
-    
-    # An internal method that builds the POST body, submits it to the gateway, and constructs a Response object with the response.
-    def make_request
-      if has_response?
-        return nil
-      end
-      
-      fields = @fields
-  
-      builder = Nokogiri::XML::Builder.new(:encoding => 'utf-8') do |x|
-        x.send(@type.to_sym, :xmlns => XML_NAMESPACE) {
-          x.merchantAuthentication {
-            x.name @api_login_id
-            x.transactionKey @api_transaction_key
-          }
-          build_nodes(x, self.class.const_get(:FIELDS)[@type], fields)
-        }
-      end
-      @xml = builder.to_xml 
-      url = URI.parse(@gateway)
-      
-      request = Net::HTTP::Post.new(url.path)
-      request.content_type = 'text/xml'
-      request.body = @xml
-      connection = Net::HTTP.new(url.host, url.port)
-      connection.use_ssl = true
-      if @verify_ssl
-        connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      else
-        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      
-      # Use our Class's @response_class variable to find the Response class we are supposed to use.
-      begin
-        @response = self.class.instance_variable_get(:@response_class).new((connection.start {|http| http.request(request)}), self)
-      rescue
-        @response = self.class.instance_variable_get(:@response_class).new($!, self)
-      end
-    end
-    
-  end
-end