aq1018-rforce 0.5.1

data/lib/rforce/binding.rb

@@ -0,0 +1,261 @@
+require 'net/https'
+require 'uri'
+require 'zlib'
+require 'stringio'
+require 'rexml/document'
+require 'builder'
+require 'oauth' # the 0.3.6 version must be checked out  
+
+
+module RForce
+  # Implements the connection to the SalesForce server.
+  class Binding
+    include RForce
+
+    DEFAULT_BATCH_SIZE = 2000
+    attr_accessor :batch_size, :url, :assignment_rule_id, 
+                  :use_default_rule, :update_mru, :client_id, 
+                  :trigger_user_email,
+                  :trigger_other_email, :trigger_auto_response_email
+
+    # Fill in the guts of this typical SOAP envelope
+    # with the session ID and the body of the SOAP request.
+    Envelope = <<-HERE
+<?xml version="1.0" encoding="utf-8" ?>
+<soap:Envelope xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:partner="urn:partner.soap.sforce.com">
+    xmlns:spartner="urn:sobject.partner.soap.sforce.com">
+  <soap:Header>
+    <partner:SessionHeader soap:mustUnderstand='1'>
+      <partner:sessionId>%s</partner:sessionId>
+    </partner:SessionHeader>
+    <partner:QueryOptions soap:mustUnderstand='1'>
+      <partner:batchSize>%d</partner:batchSize>
+    </partner:QueryOptions>
+    %s
+  </soap:Header>
+  <soap:Body>
+    %s
+  </soap:Body>
+</soap:Envelope>
+    HERE
+
+    AssignmentRuleHeaderUsingRuleId = '<partner:AssignmentRuleHeader soap:mustUnderstand="1"><partner:assignmentRuleId>%s</partner:assignmentRuleId></partner:AssignmentRuleHeader>'
+    AssignmentRuleHeaderUsingDefaultRule = '<partner:AssignmentRuleHeader soap:mustUnderstand="1"><partner:useDefaultRule>true</partner:useDefaultRule></partner:AssignmentRuleHeader>'
+    MruHeader = '<partner:MruHeader soap:mustUnderstand="1"><partner:updateMru>true</partner:updateMru></partner:MruHeader>'
+    ClientIdHeader = '<partner:CallOptions soap:mustUnderstand="1"><partner:client>%s</partner:client></partner:CallOptions>'
+
+    # Connect to the server securely.  If you pass an oauth hash, it
+    # must contain the keys :consumer_key, :consumer_secret,
+    # :access_token, :access_secret, and :login_url.
+    def initialize(url, sid = nil, oauth = nil)
+      @session_id = sid
+      @oauth = oauth
+      @batch_size = DEFAULT_BATCH_SIZE
+
+      init_server(url)
+    end
+
+
+    def show_debug
+      ENV['SHOWSOAP'] == 'true'
+    end
+
+
+    def init_server(url)
+      @url = URI.parse(url)
+      @server = Net::HTTP.new(@url.host, @url.port)
+      @server.use_ssl = @url.scheme == 'https'
+      @server.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      # run ruby with -d or env variable SHOWSOAP=true to see SOAP wiredumps.
+      @server.set_debug_output $stderr if show_debug
+    end
+
+
+    def consumer
+       OAuth::Consumer.new(@oauth[:consumer_key], 
+                           @oauth[:consumer_secret], {
+           :site               => "https://login.salesforce.com",
+           :signature_method   => 'HMAC-SHA1', # this is default, but just for clarity
+           :scheme             => :body,
+           :request_token_path => "/_nc_external/system/security/oauth/RequestTokenHandler",
+           :access_token_path  => "/_nc_external/system/security/oauth/AccessTokenHandler",
+           :authorize_path     => '/setup/secur/RemoteAccessAuthorizationPage.apexp',
+          })
+     end
+
+     
+     
+    # Log in to the server with OAuth, remembering
+    # the session ID returned to us by SalesForce.
+    def login_with_oauth
+      # post is method of Oauth::AccessToken, @server is instance of it
+      access_token  = OAuth::AccessToken.new consumer, @oauth[:access_token], @oauth[:access_secret]
+      result = access_token.post @oauth[:login_url]
+      
+      case result
+      when Net::HTTPSuccess
+        doc = REXML::Document.new result.body
+        @session_id = doc.elements['*/sessionId'].text
+        server_url  = doc.elements['*/serverUrl'].text
+        init_server(server_url)
+
+        return {:sessionId => @session_id, :serverUrl => server_url}
+      when Net::HTTPUnauthorized
+        raise "Invalid OAuth tokens=#{@oauth.inspect}"
+      else
+        raise "Unexpected error: #{result.inspect}"
+      end
+    end
+
+
+
+
+    # Log in to the server with a user name and password, remembering
+    # the session ID returned to us by SalesForce.
+    def login(user, password)
+      @user = user
+      @password = password
+
+      response = call_remote(:login, [:username, user, :password, password])
+
+      raise "Incorrect user name / password [#{response.fault}]" unless response.loginResponse
+
+      result = response[:loginResponse][:result]
+      @session_id = result[:sessionId]
+
+      init_server(result[:serverUrl])
+
+      response
+    end
+    
+    
+    
+    # Call a method on the remote server.  Arguments can be
+    # a hash or (if order is important) an array of alternating
+    # keys and values.
+    def call_remote(method, args)
+
+      urn, soap_url = block_given? ? yield : ["urn:partner.soap.sforce.com", @url.path]
+
+      # Create XML text from the arguments.
+      expanded = ''
+      @builder = Builder::XmlMarkup.new(:target => expanded)
+      expand(@builder, {method => args}, urn)
+
+      extra_headers = ""
+      extra_headers << (AssignmentRuleHeaderUsingRuleId % assignment_rule_id) if assignment_rule_id
+      extra_headers << AssignmentRuleHeaderUsingDefaultRule if use_default_rule
+      extra_headers << MruHeader if update_mru
+      extra_headers << (ClientIdHeader % client_id) if client_id
+
+      if trigger_user_email or trigger_other_email or trigger_auto_response_email
+        extra_headers << '<partner:EmailHeader soap:mustUnderstand="1">'
+
+        extra_headers << '<partner:triggerUserEmail>true</partner:triggerUserEmail>' if trigger_user_email
+        extra_headers << '<partner:triggerOtherEmail>true</partner:triggerOtherEmail>' if trigger_other_email
+        extra_headers << '<partner:triggerAutoResponseEmail>true</partner:triggerAutoResponseEmail>' if trigger_auto_response_email
+
+        extra_headers << '</partner:EmailHeader>'
+      end
+
+      # Fill in the blanks of the SOAP envelope with our
+      # session ID and the expanded XML of our request.
+      request = (Envelope % [@session_id, @batch_size, extra_headers, expanded])
+
+      # reset the batch size for the next request
+      @batch_size = DEFAULT_BATCH_SIZE
+
+      # gzip request
+      request = encode(request)
+
+      headers = {
+        'Connection' => 'Keep-Alive',
+        'Content-Type' => 'text/xml',
+        'SOAPAction' => '""',
+        'User-Agent' => 'activesalesforce rforce/0.4.1 LH'
+      }
+
+      unless show_debug
+        headers['Accept-Encoding'] = 'gzip'
+        headers['Content-Encoding'] = 'gzip'
+      end
+
+      # Send the request to the server and read the response.
+      response = @server.post2(soap_url, request.lstrip, headers)
+
+      # decode if we have encoding
+      content = decode(response)
+
+      # Check to see if INVALID_SESSION_ID was raised and try to relogin in
+      if method != :login && @session_id  && content =~ /sf:INVALID_SESSION_ID/
+        if @oauth
+          login_with_oauth
+        else  
+          login(@user, @password)
+        end  
+
+        # repackage and rencode request with the new session id
+        request = (Envelope % [@session_id, @batch_size, extra_headers, expanded])
+        request = encode(request)
+
+        # Send the request to the server and read the response.
+        response = @server.post2(soap_url, request.lstrip, headers)
+
+        content = decode(response)
+      end
+
+      SoapResponse.new(content).parse
+    end
+
+
+    # decode gzip
+    def decode(response)
+      encoding = response['Content-Encoding']
+
+      # return body if no encoding
+      if !encoding then return response.body end
+
+      # decode gzip
+      case encoding.strip
+      when 'gzip' then
+        begin
+          gzr = Zlib::GzipReader.new(StringIO.new(response.body))
+          decoded = gzr.read
+        ensure
+          gzr.close
+        end
+        decoded
+      else
+        response.body
+      end
+    end
+
+
+    # encode gzip
+    def encode(request)
+      return request if show_debug
+      begin
+        ostream = StringIO.new
+        gzw = Zlib::GzipWriter.new(ostream)
+        gzw.write(request)
+        ostream.string
+      ensure
+        gzw.close
+      end
+    end
+
+
+    # Turns method calls on this object into remote SOAP calls.
+    def method_missing(method, *args)
+      unless args.size == 1 && [Hash, Array].include?(args[0].class)
+        raise 'Expected 1 Hash or Array argument'
+      end
+
+      call_remote method, args[0]
+    end
+  end
+end

data/lib/rforce/method_keys.rb

@@ -0,0 +1,14 @@
+module RForce
+  # Allows indexing hashes like method calls: hash.key
+  # to supplement the traditional way of indexing: hash[key]
+  module MethodKeys
+    def method_missing(method, *args)
+      raise NoMethodError unless respond_to?('[]')
+      self[method]
+    end
+  end
+  
+  class MethodHash < Hash
+    include MethodKeys
+  end
+end

data/lib/rforce/soap_pullable.rb

@@ -0,0 +1,93 @@
+require 'rforce/method_keys'
+
+module RForce
+  module SoapPullable
+    SOAP_ENVELOPE = 'soapenv:Envelope'
+
+    # Split off the local name portion of an XML tag.
+    def local(tag)
+      first, second = tag.split ':'
+      return first if second.nil?
+      @namespaces.include?(first) ? second : tag
+    end
+
+    def tag_start(name, attrs)
+      # For shorter hash keys, we can strip any namespaces of the SOAP
+      # envelope tag from the tags inside it.
+      if name == SOAP_ENVELOPE
+        @namespaces = attrs.keys.grep(/xmlns:/).map {|k| k.split(':').last}
+        return
+      end
+
+      @stack.push MethodHash.new
+    end
+
+    def text(data)
+      adding = data.strip.empty? ? nil : data
+
+      if adding
+        @current_value = (@current_value || '') + adding
+      end
+    end
+
+    def tag_end(name)
+      return if @done || name == SOAP_ENVELOPE
+
+      tag_name = local name
+      working_hash = @stack.pop
+
+      # We are either done or working on a certain depth in the current
+      # stack.
+      if @stack.empty?
+        @parsed = working_hash
+        @done = true
+        return
+      end
+
+      index = @stack.size - 1
+
+      # working_hash and @current_value have a mutually exclusive relationship.
+      # If the current element doesn't have a value then it means that there
+      # is a nested data structure.  In this case then working_hash is populated
+      # and @current_value is nil.  Conversely, if @current_value has a value
+      # then we do not have a nested data structure and working_hash will
+      # be empty.
+      raise 'Parser is confused' unless working_hash.empty? || @current_value.nil?
+
+      use_value = working_hash.empty? ? @current_value : working_hash
+      tag_sym = tag_name.to_sym
+      element = @stack[index][tag_sym]
+
+      if @stack[index].keys.include? tag_sym
+        # This is here to handle the Id value being included twice and thus
+        # producing an array.  We skip the second instance so the array is
+        # not created.
+        #
+        # We also need to clear out the current value, so that the next
+        # tag doesn't erroneously pick up the value of the Id.
+        if tag_name == 'Id'
+          @current_value = nil
+          return
+        end
+
+        # We are here because the name of our current element is one that
+        # already exists in the hash.  If this is the first encounter with
+        # the duplicate tag_name then we convert the existing value to an
+        # array otherwise we push the value we are working with and add it
+        # to the existing array.
+        if element.is_a?( Array )
+          element << use_value
+        else
+          @stack[index][tag_sym] = [element, use_value]
+        end
+      else
+        # We are here because the name of our current element has not been
+        # assigned yet.
+        @stack[index][tag_sym] = use_value
+      end
+
+      # We are done with the current tag so reset the data for the next one
+      @current_value = nil
+    end
+  end
+end

data/lib/rforce/soap_response.rb

@@ -0,0 +1,7 @@
+require 'rforce/soap_response_nokogiri'
+
+
+module RForce
+  # always use Nokogiri because the other ones seem to be broken
+  SoapResponse = RForce::SoapResponseNokogiri
+end

data/lib/rforce/soap_response_expat.rb

@@ -0,0 +1,35 @@
+require 'xml/parser'
+require 'rforce/soap_pullable'
+
+module RForce
+  class SoapResponseExpat
+    include SoapPullable
+
+    def initialize(content)
+      @content = content
+    end
+
+    def parse
+      @current_value = nil
+      @stack = []
+      @parsed = MethodHash.new
+      @done = false
+      @namespaces = []
+
+      XML::Parser.new.parse(@content) do |type, name, data|
+        case type
+        when XML::Parser::START_ELEM then
+          tag_start name, data
+        when XML::Parser::CDATA then
+          text data
+        when XML::Parser::END_ELEM then
+          tag_end name
+        end
+
+        break if @done
+      end
+
+      @parsed
+    end
+  end
+end

data/lib/rforce/soap_response_hpricot.rb

@@ -0,0 +1,75 @@
+require 'hpricot'
+require 'cgi'
+
+
+module RForce
+  class SoapResponseHpricot
+    # Parses an XML string into structured data.
+    def initialize(content)
+      @content = content
+    end
+
+    # Digests an XML DOM node into nested Ruby types.
+    def parse
+      document = Hpricot.XML(@content)
+      node = document % 'soapenv:Body'
+      self.class.node_to_ruby node
+    end
+
+    private
+
+    def self.unescapeXML(string)
+      CGI.unescapeHTML(string).gsub("'", "'")
+    end
+
+    def self.node_to_ruby(node)
+      # Convert text nodes into simple strings.
+      children = (node.children || []).reject do |c|
+        c.is_a?(Hpricot::Text) && c.to_s.strip.empty?
+      end
+
+      if node.is_a?(Hpricot::Text)
+        return SoapResponseHpricot.unescapeXML(node.inspect[1..-2])
+      end
+
+      if children.first.is_a?(Hpricot::Text)
+        return SoapResponseHpricot.unescapeXML(children.first.inspect[1..-2])
+      end
+
+      # Convert nodes with children into MethodHashes.
+      elements = MethodHash.new
+
+      # Add all the element's children to the hash.
+      children.each do |e|
+        next if e.is_a?(Hpricot::Text) && e.to_s.strip.empty?
+        name = e.name
+
+        if name.include? ':'
+          name = name.split(':').last
+        end
+
+        name = name.to_sym
+
+        case elements[name]
+          # The most common case: unique child element tags.
+        when NilClass then elements[name] = node_to_ruby(e)
+
+          # Non-unique child elements become arrays:
+
+          # We've already created the array: just
+          # add the element.
+        when Array then elements[name] << node_to_ruby(e)
+
+          # We haven't created the array yet: do so,
+          # then put the existing element in, followed
+          # by the new one.
+        else
+          elements[name] = [elements[name]]
+          elements[name] << node_to_ruby(e)
+        end
+      end
+
+      return elements.empty? ? nil : elements
+    end
+  end
+end