odata4 0.7.0

data/lib/odata4/entity_set.rb

@@ -0,0 +1,162 @@
+module OData4
+  # This class represents a set of entities within an OData4 service. It is
+  # instantiated whenever an OData4::Service is asked for an EntitySet via the
+  # OData4::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 OData4::Service's namespace
+    attr_reader :namespace
+    # The OData4::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 [OData4::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 [OData4::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 [OData4::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 [OData4::Entity]
+    def new_entity(properties = {})
+      OData4::Entity.with_properties(properties, entity_options)
+    end
+
+    # Returns a query targetted at the current EntitySet.
+    # @param options [Hash] query options
+    # @return [OData4::Query]
+    def query(options = {})
+      OData4::Query.new(self, options)
+    end
+
+    # Find the Entity with the supplied key value.
+    # @param key [to_s] primary key to lookup
+    # @return [OData4::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 [OData4::Entity] entity to save or update in the service
+    # @return [OData4::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 OData4::Service this EntitySet is associated with.
+    # @return [OData4::Service]
+    # @api private
+    def service
+      @service ||= OData4::ServiceRegistry[service_name]
+    end
+
+    # Options used for instantiating a new OData4::Entity for this set.
+    # @return [Hash]
+    # @api private
+    def entity_options
+      {
+        namespace:    namespace,
+        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/odata4/enum_type.rb

@@ -0,0 +1,95 @@
+require 'odata4/enum_type/property'
+
+module OData4
+  # Enumeration types are nominal types that represent a series of related values.
+  # Enumeration types expose these related values as members of the enumeration.
+  class EnumType
+    # Creates a new EnumType based on the supplied options.
+    # @param type_xml [Nokogiri::XML::Element]
+    # @param service [OData4::Service]
+    # @return [self]
+    def initialize(type_definition, service)
+      @type_definition = type_definition
+      @service         = service
+    end
+
+    # The name of the EnumType
+    # @return [String]
+    def name
+      options['Name']
+    end
+
+    # Returns the namespaced type for the EnumType.
+    # @return [String]
+    def type
+      "#{namespace}.#{name}"
+    end
+
+    # Whether this EnumType supports setting multiple values.
+    # @return [Boolean]
+    def is_flags?
+      options['IsFlags'] == 'true'
+    end
+
+    # The underlying type of this EnumType.
+    # @return [String]
+    def underlying_type
+      options['UnderlyingType'] || 'Edm.Int32'
+    end
+
+    # Returns the namespace this EnumType belongs to.
+    # @return [String]
+    def namespace
+      @namespace ||= service.namespace
+    end
+
+    # Returns the members of this EnumType and their values.
+    # @return [Hash]
+    def members
+      @members ||= collect_members
+    end
+
+    # Returns the property class that implements this `EnumType`.
+    # @return [Class < OData4::EnumType::Property]
+    def property_class
+      @property_class ||= lambda { |type, members, is_flags|
+        klass = Class.new ::OData4::EnumType::Property
+        klass.send(:define_method, :type) { type }
+        klass.send(:define_method, :members) { members }
+        klass.send(:define_method, :is_flags?) { is_flags }
+        klass
+      }.call(type, members, is_flags?)
+    end
+
+    # Returns the value of the requested member.
+    # @param member_name [to_s]
+    # @return [*]
+    def [](member_name)
+      members.invert[member_name.to_s]
+    end
+
+    private
+
+    def service
+      @service
+    end
+
+    def type_definition
+      @type_definition
+    end
+
+    def options
+      @options = type_definition.attributes.map do |name, attr|
+        [name, attr.value]
+      end.to_h
+    end
+
+    def collect_members
+      Hash[type_definition.xpath('./Member').map.with_index do |member_xml, index|
+        member_name  = member_xml.attributes['Name'].value
+        member_value = member_xml.attributes['Value'].andand.value.andand.to_i
+        [member_value || index, member_name]
+      end]
+    end
+  end
+end

data/lib/odata4/enum_type/property.rb

@@ -0,0 +1,62 @@
+module OData4
+  class EnumType
+    # Abstract base class for OData4 EnumTypes
+    # @see [OData4::EnumType]
+    class Property < OData4::Property
+      # Returns the property value, properly typecast
+      # @return [String, nil]
+      def value
+        if @value.nil? && allows_nil?
+          nil
+        else
+          @value
+        end
+      end
+
+      # Sets the property value
+      # @params new_value [String]
+      def value=(new_value)
+        parsed_value = validate(new_value)
+        @value = is_flags? ? parsed_value : parsed_value.first
+      end
+
+      # Value to be used in URLs.
+      # @return [String]
+      def url_value
+        "#{type}'#{@value}'"
+      end
+
+      private
+
+      def members
+        raise NotImplementedError, 'Subclass must override'
+      end
+
+      def validate(value)
+        return [] if value.nil? && allows_nil?
+        values = parse_value(value)
+
+        if values.length > 1 && !is_flags?
+          raise ArgumentError, 'Multiple values are not allowed for this property'
+        end
+
+        values.map do |value|
+          if members.keys.include?(value)
+            members[value]
+          elsif members.values.include?(value)
+            value
+          else
+            raise ArgumentError, "Property '#{name}': Value must be one of #{members.to_a}, but was: '#{value}'" if strict?
+          end
+        end.compact
+      end
+
+      def parse_value(value)
+        return nil if value.nil?
+        value.to_s.split(',').map(&:strip).map do |val|
+          val =~ /^[0-9]+$/ ? val.to_i : val
+        end
+      end
+    end
+  end
+end

data/lib/odata4/navigation_property.rb

@@ -0,0 +1,29 @@
+require 'odata4/navigation_property/proxy'
+
+module OData4
+  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/odata4/navigation_property/proxy.rb

@@ -0,0 +1,76 @@
+module OData4
+  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 ||= OData4::ServiceRegistry[entity.service_name]
+      end
+
+      def namespace
+        @namespace ||= service.namespace
+      end
+
+      def entity_type
+        @entity_type ||= entity.name
+      end
+
+      def link
+        entity.links[nav_name]
+      end
+
+      def nav_property
+        service.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 = OData4::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/odata4/properties.rb

@@ -0,0 +1,25 @@
+# Modules
+require 'odata4/properties/number'
+
+# Implementations
+require 'odata4/properties/binary'
+require 'odata4/properties/boolean'
+require 'odata4/properties/date'
+require 'odata4/properties/date_time'
+require 'odata4/properties/date_time_offset'
+require 'odata4/properties/decimal'
+require 'odata4/properties/float'
+require 'odata4/properties/geography'
+require 'odata4/properties/guid'
+require 'odata4/properties/integer'
+require 'odata4/properties/string'
+require 'odata4/properties/time'
+require 'odata4/properties/time_of_day'
+
+OData4::Properties.constants.each do |property_name|
+  klass = OData4::Properties.const_get(property_name)
+  if klass.is_a?(Class)
+    property = klass.new('test', nil)
+    OData4::PropertyRegistry.add(property.type, property.class)
+  end
+end