dynamics_crm 0.1.0

data/lib/dynamics_crm/response/create_result.rb

@@ -0,0 +1,15 @@
+module DynamicsCRM
+  module Response
+
+    class CreateResult < Result
+
+      protected
+
+      # Invoked by Result constructor
+      def parse_result_response(result)
+        {"Id" => result.text, "id" => result.text}
+      end
+    end
+
+  end
+end

data/lib/dynamics_crm/response/execute_result.rb

@@ -0,0 +1,26 @@
+module DynamicsCRM
+  module Response
+    # Base response class for all Execute requests.
+    # Pulls out the ResponseName and parses the Results element of key/value pairs.
+    class ExecuteResult < Result
+
+      protected
+
+      # Returns base element of the response document to parse.
+      def response_element
+        class_name = 'ExecuteResult' if self.is_a?(ExecuteResult)
+      end
+
+      # Invoked by Result constructor
+      def parse_result_response(result)
+        h = {}
+        h["ResponseName"] = result.elements["b:ResponseName"].text
+
+        attributes = XML::MessageParser.parse_key_value_pairs(result.elements["b:Results"])
+        h.merge(attributes)
+      end
+
+    end
+
+  end
+end

data/lib/dynamics_crm/response/result.rb

@@ -0,0 +1,78 @@
+module DynamicsCRM
+  module Response
+
+    class Result < Hash
+
+      attr_reader :document
+      attr_reader :result_response
+
+      def initialize(xml)
+
+        @document = REXML::Document.new(xml)
+
+        fault_xml = @document.get_elements("//[local-name() = 'Fault']")
+        raise XML::Fault.new(fault_xml) if fault_xml.any?
+
+        @result_response = @document.get_elements("//#{response_element}").first
+
+        # Child classes should override this method.
+        h = parse_result_response(@result_response)
+
+        # Calling super causes undesired behavior so just merge.
+        self.merge!(h)
+      end
+
+      # Returns base element of the response document to parse.
+      def response_element
+        class_name = self.class.to_s.split("::").last
+      end
+
+      # Invoked by constructor, should be implemented in sub-classes.
+      def parse_result_response(result)
+        # do nothing here
+        {}
+      end
+
+      # Allows method-like access to the hash using camelcase field names.
+      def method_missing(method, *args, &block)
+
+        # First return local hash entry for symbol or string.
+        return self[method] if self.has_key?(method)
+
+        string_method = method.to_s
+        return self[string_method] if self.has_key?(string_method)
+
+        value = nil
+        # Then check if string converted to underscore finds a match.
+        if string_method =~ /[A-Z+]/
+          string_method = ::DynamicsCRM::StringUtil.underscore(string_method)
+          value = self[string_method] || self[string_method.to_sym]
+        end
+
+        # Finally return nil.
+        return value
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        self.has_key?(method_name.to_s) || self.has_key?(method_name) || super
+      end
+
+    end
+
+    # There's nothing to parse in the UpdateResult
+    class UpdateResponse < Result
+    end
+
+    # There's nothing to parse in the DeleteResult
+    class DeleteResponse < Result
+    end
+
+    # There's nothing to parse in the Associate/DisassociateResponse
+    class AssociateResponse < Result
+    end
+
+    class DisassociateResponse < Result
+    end
+
+  end
+end

data/lib/dynamics_crm/response/retrieve_multiple_result.rb

@@ -0,0 +1,38 @@
+module DynamicsCRM
+  module Response
+    # Retrieve Multiple returns a list of Entities.
+    class RetrieveMultipleResult < Result
+
+      protected
+
+      # Invoked by Result constructor
+      def parse_result_response(result)
+
+        h = {}
+        result.elements.each do |el|
+          next if el.name == "Entities"
+
+          # Convert text to actual data types.
+          value = el.text
+          if value == "true" || value == "false"
+            value = (value == "true")
+          elsif value =~ /^[-?]\d+$/
+            value = value.to_i
+          elsif value =~ /^[-?]\d+\.\d+$/
+            value = value.to_f
+          end
+          h[el.name] = value
+        end
+
+        h[:entities] = []
+        result.elements["b:Entities"].elements.each do |entity_xml|
+          h[:entities] << XML::Entity.from_xml(entity_xml)
+        end
+
+        h
+      end
+
+    end
+    # RetrieveMultipleResult
+  end
+end

data/lib/dynamics_crm/response/retrieve_result.rb

@@ -0,0 +1,20 @@
+module DynamicsCRM
+  module Response
+    class RetrieveResult < Result
+
+      protected
+
+      # Invoked by Result constructor
+      def parse_result_response(result)
+        h = {}
+        h["LogicalName"] = h["type"] = result.elements["b:LogicalName"].text
+        h["Id"] = h["id"] = result.elements["b:Id"].text
+
+        attributes = XML::MessageParser.parse_key_value_pairs(result.elements["b:Attributes"])
+        h.merge(attributes)
+      end
+
+    end
+    # RetrieveResult
+  end
+end

data/lib/dynamics_crm/version.rb

@@ -0,0 +1,3 @@
+module DynamicsCRM
+  VERSION = "0.1.0"
+end

data/lib/dynamics_crm/xml/attributes.rb

@@ -0,0 +1,163 @@
+module DynamicsCRM
+  module XML
+
+    class Attributes < Hash
+
+      def initialize(attrs)
+        super
+        self.merge!(attrs)
+      end
+
+      def get_type(key, value)
+        type = "string"
+        case value
+          when ::Fixnum
+            type = "int"
+          when ::BigDecimal, ::Float
+            type = "decimal"
+          when ::TrueClass, ::FalseClass
+            type = "boolean"
+          when ::Time, ::DateTime
+            type = "dateTime"
+          when ::Hash, EntityReference
+            type = "EntityReference"
+          when Query
+            type = "QueryExpression"
+          when FetchExpression
+            type = "FetchExpression"
+          else
+            if key.to_s == "EntityFilters"
+              type = "EntityFilters"
+            elsif key.to_s == "RollupType"
+              type = "RollupType"
+            end
+        end
+
+        if type == "string" && value =~ /\w+{8}-\w+{4}-\w+{4}-\w+{4}-\w+{12}/
+          type = "guid"
+        end
+
+        type
+      end
+
+      # Removes Attributes class wrapper.
+      def to_hash
+        raw_hash = {}
+        self.each do |key, value|
+          raw_hash[key] = value
+        end
+        raw_hash
+      end
+
+      def to_xml
+        xml = %Q{<a:#{self.class_name} xmlns:c="http://schemas.datacontract.org/2004/07/System.Collections.Generic">}
+
+        self.each do |key,value|
+
+          # Temporary hack to handle types I cannot infer (OptionSetValue or Money).
+          if value.is_a?(Hash) && !value[:type].nil?
+            type = value[:type]
+            value = value[:value]
+          else
+            type = get_type(key, value)
+          end
+
+          xml << build_xml(key, value, type)
+        end
+
+        xml << %Q{\n</a:#{self.class_name}>}
+      end
+
+      def to_s
+        self.to_xml
+      end
+
+      def build_xml(key, value, type)
+
+        xml = %Q{
+          <a:KeyValuePairOfstringanyType>
+            <c:key>#{key}</c:key>
+          }
+
+        # If we have an object that can convert itself, use it.
+        if (value.respond_to?(:to_xml) && value.class.to_s.include?("DynamicsCRM"))
+          xml <<  "<c:value i:type=\"a:#{type}\">\n" << value.to_xml({exclude_root: true, namespace: 'a'}) << "</c:value>"
+        else
+          xml << render_value_xml(type, value)
+        end
+
+        xml << "\n</a:KeyValuePairOfstringanyType>"
+
+        xml
+      end
+
+      def render_value_xml(type, value)
+        xml = ""
+        case type
+        when "EntityReference"
+          xml << %Q{
+            <c:value i:type="a:EntityReference">
+                <a:Id>#{value[:id]}</a:Id>
+                <a:LogicalName>#{value[:logical_name]}</a:LogicalName>
+                <a:Name #{value[:name] ? '' : 'i:nil="true"'}>#{value[:name]}</a:Name>
+            </c:value>
+          }
+        when "OptionSetValue", "Money"
+          xml << %Q{
+              <c:value i:type="a:#{type}">
+                <a:Value>#{value}</a:Value>
+              </c:value>
+          }
+        else
+          s_namespace = "http://www.w3.org/2001/XMLSchema"
+          if ["EntityFilters"].include?(type)
+            s_namespace = "http://schemas.microsoft.com/xrm/2011/Metadata"
+          end
+
+          if type == "guid"
+            xml << %Q{
+              <c:value xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/" i:type="d:guid">#{value}</c:value>
+            }
+          elsif type == "RollupType"
+            xml << %Q{
+              <c:value i:type="a:RollupType">#{value}</c:value>
+            }
+          elsif type == "dateTime"
+            xml << %Q{
+              <c:value i:type="s:#{type}" xmlns:s="http://www.w3.org/2001/XMLSchema">#{value.utc.strftime('%Y-%m-%dT%H:%M:%SZ')}</c:value>
+            }
+          else
+            xml << %Q{
+              <c:value i:type="s:#{type}" xmlns:s="#{s_namespace}">#{value}</c:value>
+            }
+          end
+        end
+
+        xml
+      end
+
+      def class_name
+        self.class.to_s.split("::").last
+      end
+
+      def self.from_xml(xml_document)
+        hash = MessageParser.parse_key_value_pairs(xml_document)
+        return Attributes.new(hash)
+      end
+
+      # Allows method-like access to the hash (OpenStruct)
+      def method_missing(method_name, *args, &block)
+        # Return local hash entry if any.
+        return self[method_name.to_s]
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        self.has_key?(method_name.to_s) || super
+      end
+
+    end
+
+    class Parameters < Attributes; end
+  end
+
+end

data/lib/dynamics_crm/xml/column_set.rb

@@ -0,0 +1,34 @@
+module DynamicsCRM
+  module XML
+
+    class ColumnSet < Array
+
+      def initialize(column_names=[])
+        super(column_names || [])
+      end
+
+      def to_xml(options={})
+        namespace = options[:namespace] ? options[:namespace] + ":" : ""
+
+        column_set = ''
+        if self.any?
+          column_set = "<b:Columns xmlns:d=\"http://schemas.microsoft.com/2003/10/Serialization/Arrays\">"
+          self.each do |name|
+            column_set << "\n<d:string>#{name}</d:string>"
+          end
+          column_set << "\n</b:Columns>"
+        end
+
+        # Really annoying that Retrieve uses columnSet
+        # while QueryExpression uses ColumnSet.
+        tag_name = options[:camel_case] ? "ColumnSet" : "columnSet"
+        %Q{<#{namespace}#{tag_name} xmlns:b="http://schemas.microsoft.com/xrm/2011/Contracts" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
+            <b:AllColumns>#{self.empty?}</b:AllColumns>
+            #{column_set}
+          </#{namespace}#{tag_name}>}
+      end
+    end
+    # ColumnSet
+  end
+
+end

data/lib/dynamics_crm/xml/criteria.rb

@@ -0,0 +1,54 @@
+module DynamicsCRM
+  module XML
+
+    class Criteria < Array
+
+      attr_accessor :filter_operator
+      def initialize(tuples=[])
+        super
+        @filter_operator = 'And'
+      end
+
+      # ConditionExpression can be repeated multiple times
+      # Operator: can be lots of values such as: eq (Equals), neq (Not Equals), gt (Greater Than) 
+      #           get the values from a fetch xml query
+      # Values -> Value can be repeated multiple times
+      # FilterOperator: and OR or depending on the filter requirements
+      def to_xml(options={})
+        ns = options[:namespace] ? options[:namespace] : "a"
+
+        expressions = ""
+        self.each do |tuple|
+          attr_name = tuple[0]
+          operator = tuple[1]
+          values = tuple[2].is_a?(Array) ? tuple[2] : [tuple[2]]
+          # TODO: Improve type detection
+          type = (tuple[3] || values.first.class).to_s.downcase
+          type = "int" if type == "fixnum"
+          type = "boolean" if ["trueclass", "falseclass"].include?(type)
+
+          expressions << %Q{<#{ns}:ConditionExpression>
+              <#{ns}:AttributeName>#{attr_name}</#{ns}:AttributeName>
+              <#{ns}:Operator>#{operator}</#{ns}:Operator>
+              <#{ns}:Values xmlns:d="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
+            }
+              values.each do |v|
+                  expressions << %Q{<d:anyType i:type="s:#{type}" xmlns:s="http://www.w3.org/2001/XMLSchema">#{v}</d:anyType>}
+              end
+              
+          expressions << %Q{
+               </#{ns}:Values>
+          </#{ns}:ConditionExpression>}
+        end
+
+        %Q{<#{ns}:Criteria>
+            <#{ns}:Conditions>
+              #{expressions}
+            </#{ns}:Conditions>
+            <#{ns}:FilterOperator>#{@filter_operator}</#{ns}:FilterOperator>
+        </#{ns}:Criteria>}
+      end
+    end
+    # Criteria
+  end
+end

data/lib/dynamics_crm/xml/entity.rb

@@ -0,0 +1,61 @@
+module DynamicsCRM
+  module XML
+
+    class Entity
+
+      attr_accessor :attributes, :entity_state, :formatted_values, :id, :logical_name, :related_entities
+
+      def initialize(logical_name)
+        @logical_name = logical_name
+        @id = "00000000-0000-0000-0000-000000000000"
+      end
+
+      # Using Entity vs entity causes the error: Value cannot be null.
+      def to_xml(options={})
+        %Q{
+        <entity xmlns:a="http://schemas.microsoft.com/xrm/2011/Contracts">
+          #{@attributes}
+          <a:EntityState i:nil="true" />
+          <a:FormattedValues xmlns:b="http://schemas.datacontract.org/2004/07/System.Collections.Generic" />
+          <a:Id>#{@id}</a:Id>
+          <a:LogicalName>#{@logical_name}</a:LogicalName>
+          <a:RelatedEntities xmlns:b="http://schemas.datacontract.org/2004/07/System.Collections.Generic" />
+        </entity>
+        }
+      end
+
+      def to_hash
+        {
+          :attributes => attributes.to_hash,
+          :entity_state => entity_state,
+          :formatted_values => formatted_values,
+          :id => @id,
+          :logical_name => @logical_name,
+          :related_entities => related_entities
+        }
+      end
+
+      def self.from_xml(xml_document)
+        entity = Entity.new('')
+
+        if xml_document
+          xml_document.elements.each do |node|
+
+            attr_name = DynamicsCRM::StringUtil.underscore(node.name).to_sym
+            if entity.respond_to?(attr_name)
+              if node.name == "Attributes"
+                entity.attributes = XML::Attributes.from_xml(node)
+              else
+                entity.send("#{attr_name}=", node.text ? node.text.strip : nil)
+              end
+            end
+          end
+        end
+
+        return entity
+      end
+
+    end
+    # Entity
+  end
+end

data/lib/dynamics_crm/xml/entity_reference.rb

@@ -0,0 +1,56 @@
+module DynamicsCRM
+  module XML
+
+    class EntityReference
+
+      attr_accessor :id, :logical_name, :name, :namespace
+
+      def initialize(logical_name, id)
+        @logical_name = logical_name
+        @id = id || "00000000-0000-0000-0000-000000000000"
+      end
+
+      def to_xml(options={})
+        namespace = options[:namespace] ? "#{options[:namespace]}:" : ''
+
+        xml = %Q{
+          <#{namespace}LogicalName>#{@logical_name}</#{namespace}LogicalName>
+          <#{namespace}Id>#{@id}</#{namespace}Id>
+          <#{namespace}Name #{@name ? '' : 'nil="true"'}>#{@name}</#{namespace}Name>
+        }
+
+        if options[:exclude_root].nil?
+        xml = %Q{
+        <#{namespace}entityReference>#{xml}</#{namespace}entityReference>
+        }
+        end
+        return xml
+      end
+
+      def to_hash
+        {
+          :logical_name => @logical_name,
+          :id => @id,
+          :name => @name,
+        }
+      end
+
+      def self.from_xml(xml_document)
+        entity_ref = EntityReference.new('unknown', nil)
+
+        if xml_document
+          xml_document.each_element do |node|
+            attr_name = ::DynamicsCRM::StringUtil.underscore(node.name).to_sym
+            if entity_ref.respond_to?(attr_name)
+              entity_ref.send("#{attr_name}=", node.text ? node.text.strip : nil)
+            end
+          end
+        end
+
+        return entity_ref
+      end
+
+    end
+    # EntityReference
+  end
+end

data/lib/dynamics_crm/xml/fault.rb

@@ -0,0 +1,42 @@
+module DynamicsCRM
+  module XML
+
+    # Represents a SOAP Fault
+    # Resposible for parsing each element
+    class Fault < RuntimeError
+
+      attr_reader :code, :subcode, :reason, :detail
+
+      def initialize(fault_xml)
+        if fault_xml.is_a?(Array)
+          fault_xml = fault_xml.first
+        end
+        # REXL::Element
+        @code = fault_xml.get_text("//[local-name() = 'Code']/[local-name() = 'Value']")
+        @subcode = fault_xml.get_text("//[local-name() = 'Code']/[local-name() = 'Subcode']/[local-name() = 'Value']")
+        @reason = fault_xml.get_text("//[local-name() = 'Reason']/[local-name() = 'Text']")
+
+        @detail = {}
+        detail_fragment = fault_xml.get_elements("//[local-name() = 'Detail']").first
+        if detail_fragment
+          fault_type = detail_fragment.elements.first
+          @detail[:type] = fault_type.name
+          detail_fragment.elements.first.each_element do |node|
+
+            @detail[node.name.to_sym] = node.text
+          end
+        end
+      end
+
+      def message
+        if @detail.empty?
+          "%s[%s] %s" % [@code, @subcode, @reason]
+        else
+          "%s[%s] %s (Detail => %s)" % [@code, @subcode, @reason, @detail]
+        end
+      end
+
+    end
+    # Fault
+  end
+end

data/lib/dynamics_crm/xml/fetch_expression.rb

@@ -0,0 +1,27 @@
+module DynamicsCRM
+  module XML    
+    class FetchExpression
+
+      def initialize(fetch_xml)
+        @fetch = fetch_xml
+      end
+
+      # Using Entity vs entity causes the error: Value cannot be null.
+      # <Order> can be repeated multiple times
+      # orderType: 0 (Ascending) or 1 (Descending)
+      def to_xml(options={})
+        %Q{
+		    <a:Query>
+		        #{CGI.escapeHTML(@fetch)}
+		    </a:Query>
+        }
+      end
+
+      def to_hash
+        {:fetch_xml => @fetch}
+      end
+
+    end
+
+  end
+end