microsoft_graph 0.1.0

data/integration_spec/integration_spec_helper.rb

@@ -0,0 +1,18 @@
+require "common_spec_helper"
+require "dotenv"
+Dotenv.load
+# ADAL::Logging.log_level = ADAL::Logger::VERBOSE
+
+TENANT        = ENV['MS_GRAPH_TENANT']
+USERNAME      = ENV['MS_GRAPH_USERNAME']
+PASSWORD      = ENV['MS_GRAPH_PASSWORD']
+CLIENT_ID     = ENV['MS_GRAPH_CLIENT_ID']
+CLIENT_SECRET = ENV['MS_GRAPH_CLIENT_SECRET']
+RESOURCE      = 'https://graph.microsoft.com'
+
+USER_CRED   = ADAL::UserCredential.new(USERNAME, PASSWORD)
+CLIENT_CRED = ADAL::ClientCredential.new(CLIENT_ID, CLIENT_SECRET)
+CONTEXT     = ADAL::AuthenticationContext.new(ADAL::Authority::WORLD_WIDE_AUTHORITY, TENANT)
+TOKENS      = CONTEXT.acquire_token_for_user(RESOURCE, CLIENT_CRED, USER_CRED)
+
+create_classes(TOKENS)

data/integration_spec/live_spec.rb

@@ -0,0 +1,180 @@
+require_relative "integration_spec_helper"
+
+describe MicrosoftGraph::User do
+  Given(:auth_callback) {
+    Proc.new { |r| r.headers["Authorization"] = "Bearer #{TOKENS.access_token}" }
+  }
+  Given(:test_run_id) { rand(2**128) }
+  Given(:graph) { MicrosoftGraph.new(&auth_callback) }
+  Given(:user) { graph.users.take(3).last }
+  Given(:email_destination) { user.user_principal_name }
+  Given(:message_template) {
+    {
+      subject: "test message #{test_run_id}",
+      body: {
+        content: "Hello.\n\nThis message is generated by an automated test suite.",
+      },
+      to_recipients: [
+        { email_address: { address: email_destination } },
+      ],
+    }
+  }
+
+  describe 'current user' do
+    Given(:subject) { graph.me }
+
+    describe 'direct reports' do
+      When(:result) { subject.direct_reports.take(5) }
+      Then { result.length == 0 }
+    end
+
+    describe 'membership' do
+      Given(:groups) { subject.member_of.take(5) }
+      Given(:group) { groups.last }
+
+      When(:result) { subject.check_member_groups(group_ids: [group.id]) }
+
+      Then { result.to_a == [group.id] }
+      And  { groups.length == 5 }
+      And  { group.display_name.length > 0 }
+    end
+
+    describe MicrosoftGraph::Drive do
+      Given(:drive) { subject.drive }
+
+      describe MicrosoftGraph::DriveItem do
+        Given(:root) { drive.root }
+        Given(:root_contents) { root.children }
+
+        Then { root_contents.size == 0 }
+      end
+    end
+
+    describe 'contacts' do
+      Given(:contacts) { subject.contacts.take(5) }
+      Given(:contact) { contacts.last }
+
+      Then { contacts.to_a.size == 5 }
+      And  { contact.display_name.length > 0 }
+    end
+
+    describe 'email' do
+      describe 'send a new email' do
+        When(:result) { subject.send_mail(message: message_template) }
+        Then { result != Failure() }
+      end
+    end
+
+    describe 'messages' do
+      Given(:messages) { subject.mail_folders.find('Inbox').messages }
+      Given(:first_five_messages) { messages.take(5) }
+      Given(:message) { first_five_messages.last }
+
+      describe 'list' do
+        When(:result) { first_five_messages.size }
+        Then { result == 5 }
+      end
+
+      describe 'post a reply' do
+        When(:result) { message.create_reply('test reply') }
+        Then { result != Failure() }
+      end
+
+      describe 'post a reply-all' do
+        When(:result) { message.create_reply_all('test reply-all') }
+        Then { result != Failure() }
+      end
+
+      describe 'drafts' do
+        Given(:draft_messages) { subject.mail_folders.find('Drafts').messages }
+        # Note: Graph API seems to not allow you to find a mail_folder with a space in its name like we do above
+        Given(:sent_messages) { subject.mail_folders.detect { |f| f.display_name == 'Sent Items' }.messages }
+
+        describe 'post and send a draft message' do
+          When(:draft_message) { draft_messages.create!(message_template) }
+          When(:draft_id) { draft_message.id }
+          When(:draft_title) { draft_message.subject }
+          When(:send_result) { draft_message.send }
+          When { sleep 0.5 }
+          When(:try_finding_in_drafts) { draft_messages.find(draft_id) }
+          # below could find the wrong message if someone else is sending at the same time:
+          When(:sent_message) { sent_messages.order_by('sentDateTime desc').first }
+          When(:sent_title) { sent_message.subject }
+
+          Then { send_result != Failure() }
+          And  { try_finding_in_drafts == Failure(OData::ClientError, /404/) }
+          And  { sent_title == draft_title }
+        end
+      end
+    end
+
+    describe 'calendar' do
+      Given(:calendar) { subject.calendar }
+      Given(:event_template) {
+        {
+          subject: 'test event',
+          body: {
+            content: 'this event generated by an automated test suite'
+          },
+        }
+      }
+
+      describe 'events' do
+        Given(:events) { calendar.events }
+
+        describe 'new' do
+
+          describe 'create!' do
+            When(:event) { events.create!(event_template) }
+            When(:id) { event.id }
+            When(:title) { event.subject }
+            When { event.delete! }
+            When(:get_deleted_event) { events.find(id) }
+
+            Then { title == event_template[:subject] }
+            And  { get_deleted_event == Failure(OData::ClientError, /404/) }
+          end
+
+          describe 'create recurring' do
+            Given(:start_date) { Date.today }
+            Given(:recurring_event_template) {
+              event_template.merge(
+                recurrence: {
+                  pattern: {
+                    days_of_week: [start_date.strftime('%A').downcase],
+                    interval: 1,
+                    type: 'weekly',
+                  },
+                  range: {
+                    start_date: start_date,
+                    type: 'noEnd',
+                  },
+                }
+              )
+            }
+            When(:event) { events.create!(recurring_event_template) }
+            When(:id) { event.id }
+            When(:title) { event.subject }
+            When { event.delete! }
+            When(:get_deleted_event) { events.find(id) }
+
+            Then { id.length > 0 }
+            And  { title == event_template[:subject] }
+            And  { get_deleted_event == Failure(OData::ClientError, /404/) }
+          end
+
+          describe 'add attachment'
+        end
+
+        describe 'existing' do
+          describe 'first invitation' do
+            describe 'tentatively accept'
+            describe 'accept'
+            describe 'decline'
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/microsoft_graph.rb

@@ -0,0 +1,35 @@
+require "odata"
+
+Dir[
+  File.join(
+    File.dirname(__FILE__),
+    'microsoft_graph',
+    '*'
+  )
+].each { |f| require f }
+
+class MicrosoftGraph
+  attr_reader :service
+  BASE_URL = "https://graph.microsoft.com/v1.0/"
+
+  def initialize(options = {}, &auth_callback)
+    @service = OData::Service.new(
+      base_url: BASE_URL,
+      metadata_file: options[:cached_metadata_file],
+      auth_callback: auth_callback
+    )
+    @association_collections = {}
+    unless MicrosoftGraph::ClassBuilder.loaded?
+      MicrosoftGraph::ClassBuilder.load!(service)
+    end
+
+  end
+
+  def containing_navigation_property(type_name)
+    navigation_properties.values.find do |navigation_property|
+      navigation_property.collection? && navigation_property.type.name == "Collection(#{type_name})"
+    end
+  end
+
+  def path; end
+end

data/lib/microsoft_graph/base.rb

@@ -0,0 +1,110 @@
+class MicrosoftGraph
+  class Base
+
+    def initialize(options = {})
+      @cached_navigation_property_values = {}
+      @cached_property_values            = {}
+      if options[:attributes]
+        initialize_serialized_properties(options[:attributes], options[:persisted])
+      end
+      @dirty = ! options[:persisted]
+      @dirty_properties = if @dirty
+        @cached_property_values.keys.inject({}) do |result, key|
+          result[key] = true
+          result
+        end
+      else
+        {}
+      end
+    end
+
+    def properties
+      {}
+    end
+
+    def odata_type
+      self.class.const_get("ODATA_TYPE").name
+    end
+
+    def as_json(options = {})
+      (if options[:only]
+        @cached_property_values.select { |key,v| options[:only].include? key }
+      elsif options[:except]
+        @cached_property_values.reject { |key,v| options[:except].include? key }
+      else
+        @cached_property_values
+      end).inject({}) do |result, (k,v)|
+        k = OData.convert_to_camel_case(k) if options[:convert_to_camel_case]
+        result[k.to_s] = v.respond_to?(:as_json) ? v.as_json(options) : v
+        result
+      end
+    end
+
+    def to_json(options = {})
+      as_json(options).to_json
+    end
+
+    def dirty?
+      @dirty || @cached_property_values.any? { |key, value|
+        value.respond_to?(:dirty?) && value.dirty?
+      }
+    end
+
+    def mark_clean
+      @dirty = false
+      @dirty_properties = {}
+      @cached_property_values.each { |key, value|
+        value.respond_to?(:mark_clean) && value.mark_clean
+      }
+    end
+
+    private
+
+    def get(property_name)
+      if properties[property_name].collection?
+        @cached_property_values[property_name] ||= Collection.new(properties[property_name].type)
+      else
+        @cached_property_values[property_name]
+      end
+    end
+
+    def set(property_name, value)
+      property = properties[property_name]
+
+      raise NonNullableError unless property.nullable_match?(value)
+      if property.collection?
+        raise TypeError unless value.all? { |v| property.collection_type_match?(v) }
+        @cached_property_values[property_name] = Collection.new(property.type, value)
+      else
+        raise TypeError unless property.type_match?(value)
+        @cached_property_values[property_name] = property.coerce_to_type(value)
+      end
+      @dirty = true
+      @dirty_properties[property_name] = true
+    end
+
+    def initialize_serialized_properties(raw_attributes, from_server = false)
+      unless raw_attributes.respond_to? :keys
+        raise TypeError.new("Cannot initialize #{self.class} with attributes: #{raw_attributes.inspect}")
+      end
+      attributes = OData.convert_keys_to_snake_case(raw_attributes)
+      properties.each do |property_key, property|
+        if attributes.keys.include?(property_key.to_s)
+          value = attributes[property_key.to_s]
+          @cached_property_values[property_key] =
+            if property.collection?
+              Collection.new(property.type, value)
+            elsif klass = MicrosoftGraph::ClassBuilder.get_namespaced_class(property.type.name)
+              klass.new(attributes: value)
+            else
+              if from_server && ! property.type_match?(value) && OData::EnumType === property.type
+                value.to_s
+              else
+                property.coerce_to_type(value)
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/microsoft_graph/base_entity.rb

@@ -0,0 +1,152 @@
+class MicrosoftGraph
+  class BaseEntity < Base
+
+    attr_accessor :graph
+    attr_accessor :parent
+
+    def initialize(options = {})
+      @resource_name            = options[:resource_name]
+      @parent                   = options[:parent] || options[:graph]
+      @graph                    = options[:graph] || parent && parent.graph
+      @navigation_property_name = options[:navigation_property_name]
+      @persisted                = options[:persisted] || false
+      super
+    end
+
+    def parental_chain
+      if parent && parent.respond_to?(:parental_chain)
+        parent.parental_chain.concat([parent])
+      else
+        [parent]
+      end
+    end
+
+    def containing_navigation_property(type_name)
+      candidate_navigation_properties = navigation_properties.values.select do |navigation_property|
+        navigation_property.collection? && navigation_property.type.name == "Collection(#{type_name})"
+      end
+      candidate_navigation_properties.sort { |a, b|
+        a_index = type_name.downcase.index(a.name[0..-2].downcase) || 0
+        b_index = type_name.downcase.index(b.name[0..-2].downcase) || 0
+        a_index <=> b_index
+      }.last
+    end
+
+    def path
+      containing_navigation_property_name = nil
+      owning_ancestor = parental_chain.find do |ancestor|
+        unless MicrosoftGraph::CollectionAssociation === ancestor
+          containing_navigation_property = ancestor.containing_navigation_property(odata_type)
+          containing_navigation_property && containing_navigation_property_name = containing_navigation_property.name
+        end
+      end
+
+      if owning_ancestor && @cached_property_values[:id]
+        [owning_ancestor.path, containing_navigation_property_name, @cached_property_values[:id]].compact.join("/")
+      else
+        @resource_name
+      end
+    end
+
+    def fetch
+      @persisted = true
+      initialize_serialized_properties(graph.service.get(path)[:attributes])
+    end
+
+    def persisted?
+      @persisted
+    end
+
+    def delete!
+      if persisted?
+        @persisted = false
+        graph.service.delete(path)
+      end
+    end
+
+    def reload!
+      @dirty_properties.keys.each do |dirty_property|
+        @cached_property_values[dirty_property] = nil
+      end
+      mark_clean
+      fetch if persisted?
+    end
+
+    def save!
+      raise NoAssociationError unless parent
+      raise_no_graph_error! unless graph
+      if persisted?
+        graph.service.patch(path, to_json(only: @dirty_properties.keys, convert_to_camel_case: true))
+      else
+        initialize_serialized_properties(
+          graph.service.post(parent.path, to_json(convert_to_camel_case: true))
+        )
+        @persisted = true
+      end
+      mark_clean
+      true
+    end
+
+    def save
+      save!
+    rescue OData::HTTPError
+      false
+    end
+
+    private
+
+    def raise_no_graph_error!
+      raise NoGraphError.new("#{self.class}#graph must be a MicrosoftGraph instance to make network requests.")
+    end
+
+    def get(property_name)
+      if uncached_property?(property_name) && graph
+        initialize_serialized_properties(graph.service.get(path, property_name.to_s)[:attributes], true)
+        super
+      else
+        super
+      end
+    end
+
+    def get_navigation_property(navigation_property_name)
+      raise_no_graph_error! unless graph
+      navigation_property = navigation_properties[navigation_property_name]
+      if navigation_property.collection?
+        @cached_navigation_property_values[navigation_property_name] ||=
+          CollectionAssociation.new(
+            graph: graph,
+            type: navigation_properties[navigation_property_name].type,
+            resource_name: OData.convert_to_camel_case(navigation_property_name.to_s),
+            parent: self
+          )
+      else
+        @cached_navigation_property_values[navigation_property_name] ||=
+          if response = graph.service.get("#{path}/#{OData.convert_to_camel_case(navigation_property_name.to_s)}")
+            type = graph.service.get_type_for_odata_response(response[:attributes]) || navigation_property.type
+            klass = ClassBuilder.get_namespaced_class(type.name)
+            klass.new(
+              graph: graph,
+              parent: self,
+              attributes: response[:attributes],
+              persisted: true,
+              navigation_property_name: navigation_property_name.to_s
+            )
+          else
+            nil
+          end
+      end
+    end
+
+    def set_navigation_property(navigation_property_name, value)
+      navigation_property = navigation_properties[navigation_property_name]
+      raise TypeError unless navigation_property.type_match?(value)
+      value.parent = self
+      @cached_navigation_property_values[navigation_property_name] = value
+    end
+
+    def uncached_property?(property)
+      properties.keys.include?(property) && ! @cached_property_values.keys.include?(property)
+    end
+
+  end
+end