microsoft_graph 0.1.0

data/lib/microsoft_graph/cached_metadata_directory.rb

@@ -0,0 +1,3 @@
+class MicrosoftGraph
+  CACHED_METADATA_DIRECTORY = File.realpath(File.join(__FILE__, "../../../data/"))
+end

data/lib/microsoft_graph/class_builder.rb

@@ -0,0 +1,217 @@
+class MicrosoftGraph
+  class ClassBuilder
+    @@loaded = false
+
+    def self.load!(service)
+      if !@@loaded
+        @service_namespace = service.namespace
+        service.entity_types.each do |entity_type|
+          create_class! entity_type
+        end
+
+        service.complex_types.each do |complex_type|
+          create_class! complex_type
+        end
+
+        service.entity_sets.each do |entity_set|
+          add_graph_association! entity_set
+        end
+
+        service.actions.each do |action|
+          add_action_method! action
+        end
+
+        service.functions.each do |function|
+          add_function_method! function
+        end
+
+        service.singletons.each do |singleton|
+          class_name = classify(singleton.type_name)
+          MicrosoftGraph.instance_eval do
+            resource_name = singleton.name
+            define_method(OData.convert_to_snake_case(resource_name)) do
+              MicrosoftGraph
+                .const_get(class_name)
+                .new(
+                  graph:         self,
+                  resource_name: resource_name,
+                  parent:        self
+                ).tap(&:fetch)
+            end
+          end
+        end
+
+        MicrosoftGraph.instance_eval do
+          define_method(:navigation_properties) do
+            service.entity_sets
+              .concat(service.singletons)
+              .map { |navigation_property|
+                [navigation_property.name.to_sym, navigation_property]
+              }.to_h
+          end
+        end
+
+        @@loaded = true
+      end
+    end
+
+    def self.loaded?
+      @@loaded
+    end
+
+    private
+
+    def remove_service_namespace(name)
+      name.gsub("#{@service_namespace}.", "")
+    end
+
+    def self.create_class!(type)
+      superklass = get_superklass(type)
+      klass = MicrosoftGraph.const_set(classify(type.name), Class.new(superklass))
+      klass.const_set("ODATA_TYPE", type)
+      klass.instance_eval do
+        def self.odata_type
+          const_get("ODATA_TYPE")
+        end
+      end
+      create_properties(klass, type)
+      create_navigation_properties(klass, type) if type.respond_to? :navigation_properties
+    end
+
+    def self.add_graph_association!(entity_set)
+      klass = get_namespaced_class(entity_set.member_type)
+      resource_name = entity_set.name.gsub("#{@service_namespace}.", "")
+      odata_collection =
+        OData::CollectionType.new(member_type: klass.odata_type, name: entity_set.name)
+      MicrosoftGraph.send(:define_method, resource_name) do
+        @association_collections[entity_set.name] ||=
+          MicrosoftGraph::CollectionAssociation
+            .new(
+              type:          odata_collection,
+              resource_name: resource_name,
+              parent:        self
+            )
+            .tap do |collection|
+              collection.graph = self
+            end
+      end
+    end
+
+    def self.create_properties(klass, type)
+      property_map = type.properties.map { |property|
+        define_getter_and_setter(klass, property)
+        [
+          OData.convert_to_snake_case(property.name).to_sym,
+          property
+        ]
+      }.to_h
+
+      klass.class_eval do
+        define_method(:properties) do
+          super().merge(property_map)
+        end
+      end
+    end
+
+    def self.define_getter_and_setter(klass, property)
+      klass.class_eval do
+        property_name = OData.convert_to_snake_case(property.name)
+        define_method(property_name.to_sym) do
+          get(property_name.to_sym)
+        end
+        define_method("#{property_name}=".to_sym) do |value|
+          set(property_name.to_sym, value)
+        end
+      end
+    end
+
+    def self.create_navigation_properties(klass, type)
+      klass.class_eval do
+        type.navigation_properties.each do |navigation_property|
+          navigation_property_name = OData.convert_to_snake_case(navigation_property.name).to_sym
+          define_method(navigation_property_name.to_sym) do
+            get_navigation_property(navigation_property_name.to_sym)
+          end
+          unless navigation_property.collection?
+            define_method("#{navigation_property_name}=".to_sym) do |value|
+              set_navigation_property(navigation_property_name.to_sym, value)
+            end
+          end
+        end
+
+        define_method(:navigation_properties) do
+          type.navigation_properties.map { |navigation_property|
+            [
+              OData.convert_to_snake_case(navigation_property.name).to_sym,
+              navigation_property
+            ]
+          }.to_h
+        end
+      end
+    end
+
+    def self.add_function_method!(function)
+      klass = get_namespaced_class(function.binding_type.name)
+      klass.class_eval do
+        define_method(OData.convert_to_snake_case(function.name).to_sym) do |params={}|
+          raise NoAssociationError unless parent
+          raise_no_graph_error! unless graph
+          function_params = params.map do |param_key, param_value|
+            "#{OData.convert_to_camel_case(param_key)}='#{param_value}'"
+          end
+          response = graph.service.get("#{path}/microsoft.graph.#{function.name}(#{function_params.join(',')})")
+          if function.return_type
+            if function.return_type.collection?
+              Collection.new(function.return_type, response[:attributes]['value'])
+            else
+              ClassBuilder.get_namespaced_class(function.return_type.name).new(attributes: response[:attributes]['value'])
+            end
+          end
+        end
+      end
+    end
+
+    def self.add_action_method!(action)
+      klass = get_namespaced_class(action.binding_type.name)
+      klass.class_eval do
+        define_method(OData.convert_to_snake_case(action.name).to_sym) do |args={}|
+          raise NoAssociationError unless parent
+          raise_no_graph_error! unless graph
+          response = graph.service.post("#{path}/#{action.name}", OData.convert_keys_to_camel_case(args).to_json)
+          if action.return_type
+            if action.return_type.collection?
+              Collection.new(action.return_type, response['value'])
+            else
+              ClassBuilder.get_namespaced_class(action.return_type.name).new(attributes: response['value'])
+            end
+          end
+        end
+      end
+    end
+
+    def self.classify(name)
+      raw_name = name.gsub("#{@service_namespace}.", "")
+      raw_name.to_s.slice(0, 1).capitalize + raw_name.to_s.slice(1..-1)
+    end
+
+    def self.get_namespaced_class(property_name)
+      klass_name = classify(property_name)
+      klass      = begin
+        MicrosoftGraph.const_get(klass_name) if MicrosoftGraph.const_defined?(klass_name)
+      rescue NameError
+        return false
+      end
+      klass && MicrosoftGraph::BaseEntity != klass.superclass && klass
+    end
+
+    def self.get_superklass(type)
+      if type.base_type.nil?
+        (type.class == OData::ComplexType) ?
+          MicrosoftGraph::Base :
+          MicrosoftGraph::BaseEntity
+      else
+        Object.const_get("MicrosoftGraph::" + classify(type.base_type))
+      end
+    end
+  end
+end

data/lib/microsoft_graph/collection.rb

@@ -0,0 +1,95 @@
+require 'forwardable'
+
+class MicrosoftGraph
+  class Collection
+    include Enumerable
+    extend Forwardable
+
+    attr_accessor :graph
+
+    def_delegators :values, :size, :length, :include?, :empty?, :[]
+
+    def initialize(type, initial_values = [])
+      @type = type
+      @dirty = false
+      @internal_values =
+        if klass = MicrosoftGraph::ClassBuilder.get_namespaced_class(type.member_type.name)
+          initial_values.map { |v| klass.new(attributes: v) }
+        else
+          initial_values
+        end
+    end
+
+    def each
+      values.each do |value|
+        yield value
+      end
+    end
+
+    def <<(value)
+      unless @type.valid_value?(value)
+        raise MicrosoftGraph::TypeError.new(
+          "Value \"#{value}\" does not match type #{@type.member_type.name}"
+        )
+      end
+      @dirty = true
+      @internal_values << value
+      self
+    end
+
+    def []=(index, value)
+      raise MicrosoftGraph::TypeError unless @type.valid_value?(value)
+      @dirty = true
+      values[index] = value
+    end
+
+    def dirty?
+      @dirty || @internal_values.any? { |value|
+        value.respond_to?(:dirty?) && value.dirty?
+      }
+    end
+
+    def mark_clean
+      @dirty = false
+      @internal_values.each { |value|
+        value.respond_to?(:mark_clean) && value.mark_clean
+      }
+    end
+
+    def as_json(options = {})
+      values.map do |value|
+        if value.respond_to? :as_json
+          value.as_json(options)
+        else
+          value
+        end
+      end
+    end
+
+    def new(attributes = {})
+      klass = MicrosoftGraph::ClassBuilder.get_namespaced_class(@type.member_type.name)
+      if klass
+        new_instance = klass.new(graph: graph, attributes: attributes)
+        self << new_instance
+        new_instance
+      else
+        raise NoMethodError.new("undefined method `new' for #{as_json}:#{self.class}")
+      end
+    end
+
+    def parental_chain
+      if parent && parent.respond_to?(:parental_chain)
+        parent.parental_chain.concat([parent])
+      else
+        [parent]
+      end
+    end
+
+    private
+
+    def values
+      @internal_values
+    end
+
+  end
+end

data/lib/microsoft_graph/collection_association.rb

@@ -0,0 +1,230 @@
+class MicrosoftGraph
+  class CollectionAssociation < Collection
+    attr_reader :type
+    attr_reader :parent
+
+    def initialize(options = {})
+      @type            = options[:type]
+      @graph           = options[:graph]
+      @resource_name   = options[:resource_name]
+      @parent          = options[:parent]
+      @order_by        = options[:order_by]
+      @filter          = options[:filter]
+      @dirty           = false
+      @loaded          = false
+      @internal_values = []
+
+      raise MicrosoftGraph::TypeError.new("A collection cannot be both ordered and filtered.") if @order_by && @filter
+      @order_by && @order_by.each do |field|
+        field_name, direction = field.to_s.split(' ')
+        field_names = field_name.split("/")
+        unless valid_nested_property(field_names, @type)
+          raise MicrosoftGraph::TypeError.new("Tried to order by invalid field: #{field_name}")
+        end
+        if direction && ! %w(asc desc).include?(direction)
+          raise MicrosoftGraph::TypeError.new("Tried to order field #{field_name} by invalid direction: #{direction}")
+        end
+      end
+      @filter && @filter.respond_to?(:keys) && @filter.keys.each do |field_name|
+        unless @type.properties.map(&:name).include? OData.convert_to_camel_case(field_name)
+          raise MicrosoftGraph::TypeError.new("Tried to filter by invalid field: #{field_name}")
+        end
+      end
+
+    end
+
+    def find(id)
+      if response = graph.service.get("#{path}/#{URI.escape(id.to_s)}")
+        klass = if member_type = specified_member_type(response)
+          ClassBuilder.get_namespaced_class(response)
+        else
+          default_member_class
+        end
+        klass.new(
+            graph: graph,
+            parent: self,
+            attributes: response[:attributes],
+            persisted: true
+          )
+      else
+        nil
+      end
+    end
+
+    def path
+      if parent && parent.path
+        "#{parent.path}/#{@resource_name}"
+      else
+        @resource_name
+      end
+    end
+
+    def query_path
+      if @order_by
+        order_by_names = @order_by.map do |field|
+          URI.escape OData.convert_to_camel_case(field)
+        end
+        "#{path}?$orderby=#{order_by_names.join(',')}"
+      elsif @filter
+        escaped_filters = URI.escape(stringify_filters(@filter))
+        "#{path}?$filter=#{escaped_filters}"
+      else
+        path
+      end
+    end
+
+    def order_by(*fields)
+      self.class.new(
+        type: @type,
+        graph: @graph,
+        resource_name: @resource_name,
+        parent: @parent,
+        order_by: fields,
+        filter: @filter
+      )
+    end
+
+    def valid_nested_property(field_names, parent_type)
+      field_name = field_names.shift
+      if field_name
+        property = parent_type.properties.find do |prop|
+          OData.convert_to_camel_case(prop.name) == OData.convert_to_camel_case(field_name)
+        end
+        property && valid_nested_property(field_names, property.type)
+      else
+        true
+      end
+    end
+
+    def filter(new_filters)
+      self.class.new(
+        type: @type,
+        graph: @graph,
+        resource_name: @resource_name,
+        parent: @parent,
+        order_by: @order_by,
+        filter: merge_with_existing_filter(new_filters)
+      )
+    end
+
+    def merge_with_existing_filter(new_filters)
+      existing_filter = @filter || {}
+      if new_filters.respond_to?(:keys) && existing_filter.respond_to?(:keys)
+        existing_filter.merge(new_filters)
+      else
+        [stringify_filters(new_filters), stringify_filters(@filter)].compact.join(" and ")
+      end
+    end
+
+    def stringify_filters(filters)
+      if filters.respond_to?(:keys)
+        filter_strings = filters.map do |k,v|
+          v = v.is_a?(String) ? "'#{v}'" : v
+          "#{OData.convert_to_camel_case(k)} eq #{v}"
+        end
+        filter_strings.sort.join(' and ')
+      else
+        filters
+      end
+    end
+
+    def create(attributes = {})
+      build(attributes).tap { |n| n.save }
+    end
+
+    def create!(attributes = {})
+      build(attributes).tap { |n| n.save! }
+    end
+
+    def build(attributes = {})
+      ClassBuilder
+        .get_namespaced_class(type.member_type.name)
+        .new(
+          graph:         graph,
+          resource_name: @resource_name,
+          parent:        self,
+          attributes:    attributes,
+        ).tap { |new_member|
+          @internal_values << new_member
+        }
+    end
+
+    def <<(new_member)
+      super
+      new_member.graph = graph
+      new_member.parent = self
+      new_member.save
+      self
+    end
+
+    def each(start = 0)
+      return to_enum(:each, start) unless block_given?
+      @next_link = query_path
+      Array(@internal_values[start..-1]).each do |element|
+        yield(element)
+      end
+
+      unless last?
+        start = [@internal_values.size, start].max
+
+        fetch_next_page
+
+        each(start, &Proc.new)
+      end
+    end
+
+    def collection?
+      true
+    end
+
+    def reload!
+      @next_link = query_path
+      @internal_values = []
+      fetch_next_page
+    end
+
+    private
+
+    def last?
+      @loaded || @internal_values.size >= 1000
+    end
+
+    def fetch_next_page
+      @next_link ||= query_path
+      result = begin
+        @graph.service.get(@next_link)
+      rescue OData::ClientError => e
+        if matches = /Unsupported sort property '([^']*)'/.match(e.message)
+          raise MicrosoftGraph::TypeError.new("Cannot sort by #{matches[1]}")
+        elsif /OrderBy not supported/.match(e.message)
+          if @order_by.length == 1
+            raise MicrosoftGraph::TypeError.new("Cannot sort by #{@order_by.first}")
+          else
+            raise MicrosoftGraph::TypeError.new("Cannot sort by at least one field requested")
+          end
+        else
+          raise e
+        end
+      end
+      @next_link = result[:attributes]['@odata.next_link']
+      result[:attributes]['value'].each do |entity_hash|
+        klass =
+          if member_type = specified_member_type(entity_hash)
+            ClassBuilder.get_namespaced_class(member_type.name)
+          else
+            default_member_class
+          end
+        @internal_values.push klass.new(attributes: entity_hash, parent: self, persisted: true)
+      end
+      @loaded = result[:attributes]['@odata.next_link'].nil?
+    end
+
+    def default_member_class
+      ClassBuilder.get_namespaced_class(type.member_type.name)
+    end
+
+    def specified_member_type(entity_hash)
+      @graph.service.get_type_for_odata_response(entity_hash)
+    end
+  end
+end