frodata 0.9.1

data/lib/frodata/entity_container.rb

@@ -0,0 +1,75 @@
+module FrOData
+  #
+  class EntityContainer
+    # The EntityContainer's parent service
+    attr_reader :service
+    # The EntityContainer's metadata
+    attr_reader :metadata
+
+    # Creates a new EntityContainer
+    # @param service [FrOData::Service] The entity container's parent service
+    def initialize(service)
+      @metadata = service.metadata.xpath('//EntityContainer').first
+      @service  = service
+    end
+
+    # The EntityContainer's surrounding Schema
+    # @return [Nokogiri::XML]
+    def schema
+      @schema ||= metadata.ancestors('Schema').first
+    end
+
+    # Returns the EntityContainer's namespace.
+    # @return [String]
+    def namespace
+      @namespace ||= schema.attributes['Namespace'].value
+    end
+
+    # Returns the EntityContainer's name.
+    # @return [String]
+    def name
+      @name ||= metadata.attributes['Name'].value
+    end
+
+    # Returns a hash of EntitySet names and their respective EntityTypes.
+    # @return [Hash<String, String>]
+    def entity_sets
+      @entity_sets ||= metadata.xpath('//EntitySet').map do |entity|
+        [
+          entity.attributes['Name'].value,
+          entity.attributes['EntityType'].value
+        ]
+      end.to_h
+    end
+
+    # Retrieves the EntitySet associated with a specific EntityType by name
+    #
+    # @param entity_set_name [to_s] the name of the EntitySet desired
+    # @return [FrOData::EntitySet] an FrOData::EntitySet to query
+    def [](entity_set_name)
+      xpath_query = "//EntitySet[@Name='#{entity_set_name}']"
+      entity_set_node = metadata.xpath(xpath_query).first
+      raise ArgumentError, "Unknown Entity Set: #{entity_set_name}" if entity_set_node.nil?
+      entity_type = entity_set_node.attributes['EntityType'].value
+      FrOData::EntitySet.new(
+        name: entity_set_name,
+        namespace: namespace,
+        type: entity_type,
+        service_name: service.name,
+        container: name
+      )
+    end
+
+    def singletons
+      # TODO return singletons exposed by this EntityContainer
+    end
+
+    def actions
+      # TODO return action imports exposed by this EntityContainer
+    end
+
+    def functions
+      # TODO return function imports exposed by this EntityContainer
+    end
+  end
+end

data/lib/frodata/entity_set.rb

@@ -0,0 +1,161 @@
+module FrOData
+  # This class represents a set of entities within an FrOData service. It is
+  # instantiated whenever an FrOData::Service is asked for an EntitySet via the
+  # FrOData::Service#[] method call. It also provides Enumerable behavior so that
+  # you can interact with the entities within a set in a very comfortable way.
+  #
+  # This class also implements a query interface for finding certain entities
+  # based on query criteria or limiting the result set returned by the set. This
+  # functionality is implemented through transparent proxy objects.
+  class EntitySet
+    include Enumerable
+
+    # The name of the EntitySet
+    attr_reader :name
+    # The Entity type for the EntitySet
+    attr_reader :type
+    # The FrOData::Service's namespace
+    attr_reader :namespace
+    # The FrOData::Service's identifiable name
+    attr_reader :service_name
+    # The EntitySet's container name
+    attr_reader :container
+
+    # Sets up the EntitySet to permit querying for the resources in the set.
+    #
+    # @param options [Hash] the options to setup the EntitySet
+    # @return [FrOData::EntitySet] an instance of the EntitySet
+    def initialize(options = {})
+      @name         = options[:name]
+      @type         = options[:type]
+      @namespace    = options[:namespace]
+      @service_name = options[:service_name]
+      @container    = options[:container]
+    end
+
+    # Provided for Enumerable functionality
+    #
+    # @param block [block] a block to evaluate
+    # @return [FrOData::Entity] each entity in turn from this set
+    def each(&block)
+      query.execute.each(&block)
+    end
+
+    # Return the first `n` Entities for the set.
+    # If count is 1 it returns the single entity, otherwise its an array of entities
+    # @return [FrOData::EntitySet]
+    def first(count = 1)
+      result = query.limit(count).execute
+      count == 1 ? result.first : result.to_a
+    end
+
+    # Returns the number of entities within the set.
+    # Not supported in Microsoft CRM2011
+    # @return [Integer]
+    def count
+      query.count
+    end
+
+    # Create a new Entity for this set with the given properties.
+    # @param properties [Hash] property name as key and it's initial value
+    # @return [FrOData::Entity]
+    def new_entity(properties = {})
+      FrOData::Entity.with_properties(properties, entity_options)
+    end
+
+    # Returns a query targetted at the current EntitySet.
+    # @param options [Hash] query options
+    # @return [FrOData::Query]
+    def query(options = {})
+      FrOData::Query.new(self, options)
+    end
+
+    # Find the Entity with the supplied key value.
+    # @param key [to_s] primary key to lookup
+    # @return [FrOData::Entity,nil]
+    def [](key, options={})
+      properties_to_expand = if options[:expand] == :all
+        new_entity.navigation_property_names
+      else
+        [ options[:expand] ].compact.flatten
+      end
+
+      query.expand(*properties_to_expand).find(key)
+    end
+
+    # Write supplied entity back to the service.
+    # TODO Test this more with CRM2011
+    # @param entity [FrOData::Entity] entity to save or update in the service
+    # @return [FrOData::Entity]
+    def <<(entity)
+      url_chunk, options = setup_entity_post_request(entity)
+      result = execute_entity_post_request(options, url_chunk)
+      if entity.is_new?
+        doc = ::Nokogiri::XML(result.body).remove_namespaces!
+        primary_key_node = doc.xpath("//content/properties/#{entity.primary_key}").first
+        entity[entity.primary_key] = primary_key_node.content unless primary_key_node.nil?
+      end
+
+      unless result.code.to_s =~ /^2[0-9][0-9]$/
+        entity.errors << ['could not commit entity']
+      end
+
+      entity
+    end
+
+    # The FrOData::Service this EntitySet is associated with.
+    # @return [FrOData::Service]
+    # @api private
+    def service
+      @service ||= FrOData::ServiceRegistry[service_name]
+    end
+
+    # Options used for instantiating a new FrOData::Entity for this set.
+    # @return [Hash]
+    # @api private
+    def entity_options
+      {
+        service_name: service_name,
+        type:         type,
+        entity_set:   self
+      }
+    end
+
+    private
+
+    def execute_entity_post_request(options, url_chunk)
+      result = service.execute(url_chunk, options)
+      unless result.code.to_s =~ /^2[0-9][0-9]$/
+        service.logger.debug <<-EOS
+          [ODATA: #{service_name}]
+          An error was encountered committing your entity:
+
+            POSTed URL:
+            #{url_chunk}
+
+            POSTed Entity:
+            #{options[:body]}
+
+            Result Body:
+            #{result.body}
+        EOS
+        service.logger.info "[ODATA: #{service_name}] Unable to commit data to #{url_chunk}"
+      end
+      result
+    end
+
+    def setup_entity_post_request(entity)
+      primary_key = entity.get_property(entity.primary_key).url_value
+      chunk = entity.is_new? ? name : "#{name}(#{primary_key})"
+      options = {
+          method: :post,
+          body: entity.to_xml.gsub(/\n\s+/, ''),
+          headers: {
+              'Accept' => 'application/atom+xml',
+              'Content-Type' => 'application/atom+xml'
+          }
+      }
+      return chunk, options
+    end
+  end
+end

data/lib/frodata/errors.rb

@@ -0,0 +1,68 @@
+module FrOData
+  # Base class for FrOData errors
+  class Error < StandardError
+  end
+
+  # Base class for network errors
+  class RequestError < Error
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @message  = message
+      @response = response
+    end
+
+    def http_status
+      response.status
+    end
+
+    def message
+      [default_message, @message].compact.join(': ')
+    end
+
+    def default_message
+      nil
+    end
+  end
+
+  class ClientError < RequestError
+  end
+
+  class ServerError < RequestError
+  end
+
+  module Errors
+    ERROR_MAP = []
+
+    CLIENT_ERRORS = {
+      400 => "Bad Request",
+      401 => "Access Denied",
+      403 => "Forbidden",
+      404 => "Not Found",
+      405 => "Method Not Allowed",
+      406 => "Not Acceptable",
+      413 => "Request Entity Too Large"
+    }
+
+    CLIENT_ERRORS.each do |code, message|
+      klass = Class.new(ClientError) do
+        send(:define_method, :default_message) { "#{code} #{message}" }
+      end
+      const_set(message.delete(' \-\''), klass)
+      ERROR_MAP[code] = klass
+    end
+
+    SERVER_ERRORS = {
+      500 => "Internal Server Error",
+      503 => "Service Unavailable"
+    }
+
+    SERVER_ERRORS.each do |code, message|
+      klass = Class.new(ServerError) do
+        send(:define_method, :default_message) { "#{code} #{message}" }
+      end
+      const_set(message.delete(' \-\''), klass)
+      ERROR_MAP[code] = klass
+    end
+  end
+end

data/lib/frodata/navigation_property.rb

@@ -0,0 +1,29 @@
+require 'frodata/navigation_property/proxy'
+
+module FrOData
+  class NavigationProperty
+    attr_reader :name, :type, :nullable, :partner
+
+    def initialize(options)
+      @name     = options[:name] or raise ArgumentError, 'Name is required'
+      @type     = options[:type] or raise ArgumentError, 'Type is required'
+      @nullable = options[:nullable] || true
+      @partner  = options[:partner]
+    end
+
+    def nav_type
+      @nav_type ||= type =~ /^Collection/ ? :collection : :entity
+    end
+
+    def entity_type
+      @entity_type ||= type.split(/[()]/).last
+    end
+
+    def self.build(nav_property_xml)
+      options = nav_property_xml.attributes.map do |name, attr|
+        [name.downcase.to_sym, attr.value]
+      end.to_h
+      new(options)
+    end
+  end
+end

data/lib/frodata/navigation_property/proxy.rb

@@ -0,0 +1,80 @@
+module FrOData
+  class NavigationProperty
+    class Proxy
+      def initialize(entity, nav_name)
+        @entity = entity
+        @nav_name = nav_name
+      end
+
+      def value=(value)
+        @value = value
+      end
+
+      def value
+        if link.nil?
+          if nav_property.nav_type == :collection
+            []
+          else
+            nil
+          end
+        else
+          @value ||= fetch_result
+        end
+      end
+
+      private
+
+      attr_reader :entity, :nav_name
+
+      def service
+        @service ||= FrOData::ServiceRegistry[entity.service_name]
+      end
+
+      def namespace
+        @namespace ||= service.namespace
+      end
+
+      def schema
+        @schema ||= service.schemas[namespace]
+      end
+
+      def entity_type
+        @entity_type ||= entity.name
+      end
+
+      def link
+        entity.links[nav_name]
+      end
+
+      def nav_property
+        schema.navigation_properties[entity_type][nav_name]
+      end
+
+      def fetch_result
+        raise "Invalid navigation link for #{nav_name}" unless link[:href]
+
+        options = {
+          type:         nav_property.entity_type,
+          namespace:    namespace,
+          service_name: entity.service_name
+        }
+        entity_set = Struct.new(:service, :entity_options)
+                           .new(entity.service, options)
+
+        query = FrOData::Query.new(entity_set)
+        begin
+          result = query.execute(link[:href])
+        rescue => ex
+          raise ex unless ex.message =~ /Not Found/
+          result = []
+        end
+
+        if nav_property.nav_type == :collection
+          result
+        else
+          result.first
+        end
+      end
+    end
+  end
+end

data/lib/frodata/properties.rb

@@ -0,0 +1,32 @@
+# Modules
+require 'frodata/properties/number'
+
+# Implementations
+require 'frodata/properties/binary'
+require 'frodata/properties/boolean'
+require 'frodata/properties/collection'
+require 'frodata/properties/complex'
+require 'frodata/properties/date'
+require 'frodata/properties/date_time'
+require 'frodata/properties/date_time_offset'
+require 'frodata/properties/decimal'
+require 'frodata/properties/enum'
+require 'frodata/properties/float'
+require 'frodata/properties/geography'
+require 'frodata/properties/guid'
+require 'frodata/properties/integer'
+require 'frodata/properties/string'
+require 'frodata/properties/time'
+require 'frodata/properties/time_of_day'
+
+FrOData::Properties.constants.each do |property_name|
+  klass = FrOData::Properties.const_get(property_name)
+  if klass.is_a?(Class)
+    begin
+      property = klass.new('test', nil)
+      FrOData::PropertyRegistry.add(property.type, property.class)
+    rescue NotImplementedError
+      # Abstract type classes cannot be instantiated, ignore
+    end
+  end
+end