eloqua 1.1.0

data/eloqua_initializer.tpl.rb

@@ -0,0 +1,3 @@
+Eloqua.configure do |config|
+  config.authenticate('Company\\User', 'Password')
+end

data/lib/eloqua.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/module'
+
+module Eloqua
+
+  autoload :Api, 'eloqua/api'
+  autoload :Entity, 'eloqua/entity'
+  autoload :Asset, 'eloqua/asset'
+  autoload :RemoteObject, 'eloqua/remote_object'
+  autoload :Query, 'eloqua/query'
+
+  mattr_accessor :user, :password
+
+  def self.configure(&block)
+    yield self
+  end
+
+  def self.authenticate(user, password)
+    self.user = user
+    self.password = password
+  end
+
+  def self.format_results_for_array(results, *keys)
+    max_depth = keys.length
+    depth = 0
+    keys.each do |key|
+      if(results.has_key?(key))
+        depth += 1
+        results = results[key]
+      end
+    end
+    if(depth == max_depth && !results.is_a?(Array))
+      results = [results]
+    end
+    results
+  end
+
+  def self.delegate_with_args(from_klass, to_klass, methods, methods_to_argument)
+    argument_string = methods_to_argument.join(', ')
+    methods.each do |__method_name|
+      from_klass.module_eval(<<-RUBY)
+        def self.#{__method_name}(*args, &block)
+          #{to_klass}.__send__(#{__method_name.inspect}, #{argument_string}, *args, &block)
+        end
+      RUBY
+    end
+
+  end
+
+
+end

data/lib/eloqua/api.rb

@@ -0,0 +1,119 @@
+require 'savon'
+
+require 'active_support/core_ext/class'
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
+require 'eloqua/builder/xml'
+require 'eloqua/exceptions'
+
+module Eloqua
+
+  class Api
+
+    autoload :Service, 'eloqua/api/service'
+    autoload :Action, 'eloqua/api/action'
+
+    # The namespace for Eloqua Array objects
+    XML_NS_ARRAY = 'http://schemas.microsoft.com/2003/10/Serialization/Arrays'
+
+    # WSDLs are from 3-30-2011
+    WSDL = {
+      :service => File.dirname(__FILE__) + '/wsdl/service.wsdl',
+      :data =>  File.dirname(__FILE__) + '/wsdl/data.wsdl',
+      :email =>  File.dirname(__FILE__) + '/wsdl/email.wsdl',
+      :action =>  File.dirname(__FILE__) + '/wsdl/action.wsdl'
+    }
+
+    class << self
+
+      delegate :define_builder_template, :to => Eloqua::Builder::Xml
+      delegate :builder_template, :to => Eloqua::Builder::Xml
+      delegate :builder_templates, :to => Eloqua::Builder::Xml
+
+      attr_accessor :last_request, :last_response, :soap_error, :http_error
+
+      @@clients = {}
+
+      def reset_clients
+        @@clients = {}
+      end
+
+      def clients
+        @@clients
+      end
+
+      # There are four currently supported wsdl types for eloqua
+      # 1. Service
+      # 2. Data
+      # 3. Email
+      # 4. External Action
+      def client(type)
+        if(!Eloqua.user || !Eloqua.password)
+          raise('Eloqua.user or Eloqua.password is not set see Eloqua.authenticate')
+        end
+        clients[type] ||= Savon::Client.new do
+          wsdl.document = WSDL[type]
+          wsse.credentials Eloqua.user, Eloqua.password
+        end
+      end
+
+      def builder(&block)
+        Eloqua::Builder::Xml.create(:namespace => :wsdl, &block)
+      end
+
+      def remote_type(name, type = 'Base', id = 0)
+        {
+          :name => name,
+          :type => type,
+          :id => id
+        }
+      end
+
+      def request(type, name, soap_body = nil, &block)
+        result = send_remote_request(type, name, soap_body, &block)
+
+        self.last_request = client(type).soap.to_xml if client(type).soap
+        self.last_response = result.to_xml if result.respond_to?(:to_xml)
+
+        if(result)
+          result = result.to_hash
+          response_key = "#{name}_response".to_sym
+          result_key = "#{name}_result".to_sym
+          if(result.has_key?(response_key))
+            result = result[response_key]
+          end
+          if(result.has_key?(result_key))
+            result = result[result_key]
+          end
+        end
+        result
+      end
+
+      # Sends remote request and returns a response object
+      def send_remote_request(type, name, soap_body = nil, &block)
+        @soap_error = nil
+        @http_error = nil
+
+        request = client(type).request(:wsdl, name) do
+          soap.namespaces["xmlns:arr"] = XML_NS_ARRAY
+          soap.element_form_default = :qualified
+          soap.body = soap_body if soap_body
+          instance_eval(&block) if block_given?
+        end
+        response_errors(request)
+        request
+      end
+
+      def response_errors(response)
+        @soap_error = Eloqua::SoapError.new(response.http)
+        @http_error = Eloqua::HTTPError.new(response.http)
+
+        raise @soap_error if @soap_error.present?
+        raise @http_error if @http_error.present?
+      end
+
+    end
+  end
+
+end

data/lib/eloqua/api/action.rb

@@ -0,0 +1,41 @@
+require 'eloqua/api'
+
+module Eloqua
+
+  class Api
+    class Action
+
+      cattr_reader :type_methods
+      @@type_methods = [:list_external_action_steps_by_type, :get_member_count_in_step_by_status, :list_members_in_step_by_status, :set_member_status]
+
+      class << self
+
+        delegate :builder, :remote_type, :to => Eloqua::Api
+
+        def get_member_count_in_step_by_status(stepId, status)
+          xml_query = builder do |xml|
+            xml.tag!(:stepId, stepId)
+            xml.tag!(:status, status)
+          end
+          results = request(:get_member_count_in_step_by_status, xml_query)
+          results = results.to_i
+        end
+
+        #still seems finicky, returns a funky hash table if there are no members in that step
+        def list_members_in_step_by_status(stepId, status, pageNumber, pageSize)
+          xml_query = builder do |xml|
+            xml.tag!(:stepId, stepId)
+            xml.tag!(:status, status)
+            xml.tag!(:pageNumber, pageNumber)
+            xml.tag!(:pageSize, pageSize)
+          end
+          results = request(:list_members_in_step_by_status, xml_query)
+        end
+
+        def request(*args)
+          Eloqua::Api.request(:action, *args)
+        end
+      end
+    end
+  end
+end

data/lib/eloqua/api/service.rb

@@ -0,0 +1,240 @@
+require 'eloqua/api'
+
+module Eloqua
+
+  class Api
+    class Service
+
+      cattr_reader :group_methods
+      cattr_reader :group_type_methods
+      cattr_reader :type_methods
+
+      @@group_methods = [:key_with_object, :object_method, :list_types, :describe_type]
+      @@type_methods = []
+      @@group_type_methods = [:create_object, :update_object, :delete_object, :find_object, :describe]
+
+      class << self
+
+        delegate :builder, :remote_type, :to => Eloqua::Api
+
+        def entity_association_xml(asset_type, asset_id, entity, entity_id)
+          xml_query = builder do |xml|
+            xml.template!(:object, :entity, entity, entity_id)
+            xml.template!(:object, :asset, asset_type, asset_id)
+          end
+        end
+
+        # Delegate Group
+        def key_with_object(group, name)
+          if (group == :entity)
+            name.to_sym
+          else
+            parts = name.to_s.split('_')
+            "#{parts[0]}_#{group}_#{parts[1]}".to_sym
+          end
+        end
+
+        # Delegate Group
+        def object_method(group, method)
+          if (group == :entity)
+            method.to_sym
+          else
+            "#{method}_#{group}".to_sym
+          end
+        end
+
+        def request(*args)
+          Eloqua::Api.request(:service, *args)
+        end
+
+        # Delegate, Group, Type
+        def create_object(group, type, attributes)
+          xml_query = builder do |xml|
+            xml.object_collection!(group) do
+              xml.dynamic_object!(group) do
+                xml.template!(:dynamic, group, type, nil, attributes)
+              end
+            end
+          end
+
+          result = request(object_method(group, :create), xml_query)
+          result = result[key_with_object(group, :create_result)]
+
+          if (result[:errors].nil? && result[:id])
+            {:id => result[:id].to_i}
+          else
+            handle_exception(result)
+          end
+        end
+
+        # Delegate Group, Type
+        def update_object(group, type, entity_id, attributes)
+          xml_query = builder do |xml|
+            xml.object_collection!(group) do
+              xml.dynamic_object!(group) do
+                xml.template!(:dynamic, group, type, entity_id, attributes)
+              end
+            end
+          end
+
+          result = request(object_method(group, :update), xml_query)
+          result = result[key_with_object(group, :update_result)]
+
+          if (result[:success] && result[:id].to_s == entity_id.to_s)
+            true
+          else
+            handle_exception(result)
+          end
+        end
+
+        # Delegate Group, Type
+        def delete_object(group, type, id)
+          xml_query = builder do |xml|
+            xml.object_type_lower!(group) do
+              xml.template!(:object_type, type)
+            end
+            xml.ids do
+              xml.template!(:int_array, [id])
+            end
+          end
+
+          result = request(object_method(group, :delete), xml_query)
+          result = result[key_with_object(group, :delete_result)]
+
+          if (result[:success] && result[:id].to_s == id.to_s)
+            [result[:id]]
+          else
+            handle_exception(result)
+          end
+        end
+
+        # Delegate Group, Type
+        def find_object(group, type, id)
+          xml_query = builder do |xml|
+            xml.object_type_lower!(group) do
+              xml.template!(:object_type, type)
+            end
+            xml.ids do
+              xml.template!(:int_array, [id])
+            end
+          end
+
+
+          result = request(object_method(group, :retrieve), xml_query)
+
+          field_key = "#{group}_fields".to_sym
+          dynamic_key = "dynamic_#{group}".to_sym
+
+          if (result[dynamic_key] && result[dynamic_key][:field_value_collection])
+            attribute_list = result[dynamic_key][:field_value_collection][field_key]
+            attributes = {:id => result[dynamic_key][:id].to_i}
+            attribute_list.each do |map|
+              attributes[map[:internal_name].to_sym] = map[:value]
+            end
+            attributes
+          else
+            false
+          end
+        end
+
+        # Delegate Type
+        def list_memberships(entity_type, entity_id)
+          xml_query = builder do |xml|
+            xml.template!(:object, :entity, entity_type, entity_id)
+          end
+          results = request(:list_group_membership, xml_query)
+          if(results.has_key?(:dynamic_asset))
+            results = Eloqua.format_results_for_array(results, :dynamic_asset)
+            results.inject([]) do |map, object|
+              map << object[:asset_type]
+              map
+            end
+          end
+        end
+
+        def entity_asset_operation(request_method, asset_type, asset_id, entity, entity_id)
+          xml_query = entity_association_xml(asset_type, asset_id, entity, entity_id)
+          result = request(request_method.to_sym, xml_query)
+          if (result[:success])
+            true
+          elsif (result[:errors])
+            handle_exception(result)
+          else
+            false
+          end
+        end
+
+        def add_group_member(asset_type, asset_id, entity_type, entity_id)
+          entity_asset_operation(:add_group_member, asset_type, asset_id, entity_type, entity_id)
+        end
+
+        def remove_group_member(asset_type, asset_id, entity_type, entity_id)
+          entity_asset_operation(:remove_group_member, asset_type, asset_id, entity_type, entity_id)
+        end
+
+        # Delegate Group
+        def list_types(group)
+          types = "#{group}_types".to_sym
+          result = request("list_#{types}".to_sym)
+          if (result && result[types])
+            result[types][:string]
+          end
+        end
+
+        # Delegate Group, Type
+        def describe(group, type)
+          xml_query = builder do |xml|
+            xml.object_type_lower!(group) do
+              xml.template!(:object_type, type)
+            end
+          end
+          remote_method = "describe_#{group}".to_sym
+          result = request(remote_method, xml_query)
+          if (result)
+            field_describe_key = "dynamic_#{group}_field_definition".to_sym
+            fields = result[:fields]
+            if (fields.is_a?(Hash) && fields.has_key?(field_describe_key))
+              result[:fields] = fields[field_describe_key]
+            end
+          end
+          result
+        end
+
+        # Delegate Group, Type
+        def describe_type(group, type_name)
+          key_type = "#{group}_type".to_sym
+          key_types = "#{key_type}s".to_sym
+
+          if(group == :entity)
+            type_name_key = :global_entity_type
+          else
+            type_name_key = key_type
+          end
+          result = request("describe_#{group}_type".to_sym, type_name_key => type_name)
+          Eloqua.format_results_for_array(result, key_types, key_type)
+        end
+
+        def handle_exception(response)
+          exception = response[:errors][:error]
+
+          error_code = exception[:error_code]
+          message = exception[:message]
+
+          error_message = sprintf("Eloqua Error: Code (%s) | Message: %s", error_code, message)
+
+          if (error_code =~ /Duplicate/)
+            raise(Eloqua::DuplicateRecordError, error_message)
+          else
+            raise(Eloqua::RemoteError, error_message)
+          end
+          false
+
+        end
+
+      end
+
+    end
+
+  end
+
+end