Class: RubyOutlook::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/ruby_outlook.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Client

Returns a new instance of Client.



15
16
17
18
19
 
# File 'lib/ruby_outlook.rb', line 15

def initialize
  @user_agent = "RubyOutlookGem/" << RubyOutlook::VERSION
  @api_host = "https://outlook.office365.com"
  @enable_fiddler = false
end

Instance Attribute Details

#api_host=(value) ⇒ Object (writeonly)

The server to make API calls to. Always “outlook.office365.com”



12
13
14
 
# File 'lib/ruby_outlook.rb', line 12

def api_host=(value)
  @api_host = value
end

#enable_fiddler=(value) ⇒ Object (writeonly)

Sets the attribute enable_fiddler

Parameters:

  • value —

    the value to set the attribute enable_fiddler to.



13
14
15
 
# File 'lib/ruby_outlook.rb', line 13

def enable_fiddler=(value)
  @enable_fiddler = value
end

#user_agent ⇒ Object (readonly)

User agent



9
10
11
 
# File 'lib/ruby_outlook.rb', line 9

def user_agent
  @user_agent
end

Instance Method Details

#create_contact(token, payload, folder_id = nil, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the contact entity folder_id (string): The Id of the contact folder to create the contact in.

If nil, contact is created in the default contacts folder.

user (string): The user to make the call for. If nil, use the ‘Me’ constant.



140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/ruby_outlook.rb', line 140

def create_contact(token, payload, folder_id = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))

  unless folder_id.nil?
    request_url << "/ContactFolders/" << folder_id
  end

  request_url << "/Contacts"

  create_contact_response = make_api_call "POST", request_url, token, nil, payload

  JSON.parse(create_contact_response)
end

#create_event(token, payload, folder_id = nil, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the event entity folder_id (string): The Id of the calendar folder to create the event in.

If nil, event is created in the default calendar folder.

user (string): The user to make the call for. If nil, use the ‘Me’ constant.



398
399
400
401
402
403
404
405
406
407
408
409
410
 
# File 'lib/ruby_outlook.rb', line 398

def create_event(token, payload, folder_id = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))

  unless folder_id.nil?
    request_url << "/Calendars/" << folder_id
  end

  request_url << "/Events"

  create_event_response = make_api_call "POST", request_url, token, nil, payload

  JSON.parse(create_event_response)
end

#create_message(token, payload, folder_id = nil, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the contact entity folder_id (string): The Id of the folder to create the message in.

If nil, message is created in the default drafts folder.

user (string): The user to make the call for. If nil, use the ‘Me’ constant.



258
259
260
261
262
263
264
265
266
267
268
269
270
 
# File 'lib/ruby_outlook.rb', line 258

def create_message(token, payload, folder_id = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))

  unless folder_id.nil?
    request_url << "/MailFolders/" << folder_id
  end

  request_url << "/Messages"

  create_message_response = make_api_call "POST", request_url, token, nil, payload

  JSON.parse(create_message_response)
end

#delete_contact(token, id, user = nil) ⇒ Object

token (string): access token id (string): The Id of the contact to delete. user (string): The user to make the call for. If nil, use the ‘Me’ constant.



169
170
171
172
173
174
175
176
177
 
# File 'lib/ruby_outlook.rb', line 169

def delete_contact(token, id, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id

  delete_response = make_api_call "DELETE", request_url, token

  return nil if delete_response.nil? || delete_response.empty?

   JSON.parse(delete_response)
end

#delete_event(token, id, user = nil) ⇒ Object

token (string): access token id (string): The Id of the event to delete. user (string): The user to make the call for. If nil, use the ‘Me’ constant.



427
428
429
430
431
432
433
434
435
 
# File 'lib/ruby_outlook.rb', line 427

def delete_event(token, id, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id

  delete_response = make_api_call "DELETE", request_url, token

  return nil if delete_response.nil? || delete_response.empty?

  JSON.parse(delete_response)
end

#delete_message(token, id, user = nil) ⇒ Object

token (string): access token id (string): The Id of the message to delete. user (string): The user to make the call for. If nil, use the ‘Me’ constant.



287
288
289
290
291
292
293
294
295
 
# File 'lib/ruby_outlook.rb', line 287

def delete_message(token, id, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id

  delete_response = make_api_call "DELETE", request_url, token

  return nil if delete_response.nil? || delete_response.empty?

  JSON.parse(delete_response)
end

#get_calendar_view(token, window_start, window_end, id = nil, fields = nil, user = nil) ⇒ Object

token (string): access token window_start (DateTime): The earliest time (UTC) to include in the view window_end (DateTime): The latest time (UTC) to include in the view id (string): The Id of the calendar to view

If nil, the default calendar is used

fields (array): An array of field names to include in results user (string): The user to make the call for. If nil, use the ‘Me’ constant.



370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'lib/ruby_outlook.rb', line 370

def get_calendar_view(token, window_start, window_end, id = nil, fields = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user))

  unless id.nil?
    request_url << "/Calendars/" << id
  end

  request_url << "/CalendarView"

  request_params = {
    'startDateTime' => window_start.strftime('%Y-%m-%dT00:00:00Z'),
    'endDateTime' => window_end.strftime('%Y-%m-%dT00:00:00Z')
  }

  unless fields.nil?
    request_params['$select'] = fields.join(',')
  end

  get_view_response =make_api_call "GET", request_url, token, request_params

  JSON.parse(get_view_response)
end

#get_contact_by_id(token, id, fields = nil, user = nil) ⇒ Object

token (string): access token id (string): The Id of the contact to retrieve fields (array): An array of field names to include in results user (string): The user to make the call for. If nil, use the ‘Me’ constant.



122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/ruby_outlook.rb', line 122

def get_contact_by_id(token, id, fields = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id
  request_params = nil

  unless fields.nil?
    request_params = { '$select' => fields.join(',') }
  end

  get_contact_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_contact_response)
end

#get_contacts(token, view_size, page, fields = nil, sort = nil, user = nil) ⇒ Object

token (string): access token view_size (int): maximum number of results page (int): What page to fetch (multiple of view size) fields (array): An array of field names to include in results sort (hash): { sort_on => field_to_sort_on, sort_order => ‘ASC’ | ‘DESC’ } user (string): The user to make the call for. If nil, use the ‘Me’ constant.



98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/ruby_outlook.rb', line 98

def get_contacts(token, view_size, page, fields = nil, sort = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts"
  request_params = {
    '$top' => view_size,
    '$skip' => (page - 1) * view_size
  }

  unless fields.nil?
    request_params['$select'] = fields.join(',')
  end

  unless sort.nil?
    request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
  end

  get_contacts_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_contacts_response)
end

#get_event_by_id(token, id, fields = nil, user = nil) ⇒ Object

token (string): access token id (string): The Id of the event to retrieve fields (array): An array of field names to include in results user (string): The user to make the call for. If nil, use the ‘Me’ constant.



350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'lib/ruby_outlook.rb', line 350

def get_event_by_id(token, id, fields = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id
  request_params = nil

  unless fields.nil?
    request_params = { '$select' => fields.join(',') }
  end

  get_event_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_event_response)
end

#get_events(token, view_size, page, fields = nil, sort = nil, user = nil) ⇒ Object

token (string): access token view_size (int): maximum number of results page (int): What page to fetch (multiple of view size) fields (array): An array of field names to include in results sort (hash): { sort_on => field_to_sort_on, sort_order => ‘ASC’ | ‘DESC’ } user (string): The user to make the call for. If nil, use the ‘Me’ constant.



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
 
# File 'lib/ruby_outlook.rb', line 326

def get_events(token, view_size, page, fields = nil, sort = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events"
  request_params = {
    '$top' => view_size,
    '$skip' => (page - 1) * view_size
  }

  unless fields.nil?
    request_params['$select'] = fields.join(',')
  end

  unless sort.nil?
    request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
  end

  get_events_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_events_response)
end

#get_message_by_id(token, id, fields = nil, user = nil) ⇒ Object

token (string): access token id (string): The Id of the message to retrieve fields (array): An array of field names to include in results user (string): The user to make the call for. If nil, use the ‘Me’ constant.



240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/ruby_outlook.rb', line 240

def get_message_by_id(token, id, fields = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id
  request_params = nil

  unless fields.nil?
    request_params = { '$select' => fields.join(',') }
  end

  get_message_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_message_response)
end

#get_messages(token, view_size, page, fields = nil, sort = nil, user = nil) ⇒ Object

token (string): access token view_size (int): maximum number of results page (int): What page to fetch (multiple of view size) fields (array): An array of field names to include in results sort (hash): { sort_field: field_to_sort_on, sort_order: ‘ASC’ | ‘DESC’ } user (string): The user to make the call for. If nil, use the ‘Me’ constant.



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/ruby_outlook.rb', line 189

def get_messages(token, view_size, page, fields = nil, sort = nil, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages"
  request_params = {
    '$top' => view_size,
    '$skip' => (page - 1) * view_size
  }

  unless fields.nil?
    request_params['$select'] = fields.join(',')
  end

  unless sort.nil?
    request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
  end

  get_messages_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_messages_response)
end

#get_messages_for_folder(token, view_size, page, fields = nil, sort = nil, user = nil, folder_id) ⇒ Object

token (string): access token view_size (int): maximum number of results page (int): What page to fetch (multiple of view size) fields (array): An array of field names to include in results sort (hash): { sort_on => field_to_sort_on, sort_order => ‘ASC’ | ‘DESC’ } user (string): The user to make the call for. If nil, use the ‘Me’ constant. folder_id (string): The folder to get mail for. (inbox, drafts, sentitems, deleteditems)



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
 
# File 'lib/ruby_outlook.rb', line 216

def get_messages_for_folder(token, view_size, page, fields = nil, sort = nil, user = nil, folder_id)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/MailFolders/#{folder_id}/messages"
  request_params = {
    '$top' => view_size,
    '$skip' => (page - 1) * view_size
  }

  unless fields.nil?
    request_params['$select'] = fields.join(',')
  end

  unless sort.nil?
    request_params['$orderby'] = sort[:sort_field] + " " + sort[:sort_order]
  end

  get_messages_response = make_api_call "GET", request_url, token, request_params

  JSON.parse(get_messages_response)
end

#make_api_call(method, url, token, params = nil, payload = nil) ⇒ Object

method (string): The HTTP method to use for the API call.

Must be 'GET', 'POST', 'PATCH', or 'DELETE'

url (string): The URL to use for the API call. Must not contain

the host. For example: '/api/v2.0/me/messages'

token (string): access token params (hash) a Ruby hash containing any query parameters needed for the API call payload (hash): a JSON hash representing the API call’s payload. Only used

for POST or PATCH.



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
 
# File 'lib/ruby_outlook.rb', line 29

def make_api_call(method, url, token, params = nil, payload = nil)

  conn_params = {
    :url => 'https://outlook.office365.com'
  }

  if @enable_fiddler
    conn_params[:proxy] = 'http://127.0.0.1:8888'
    conn_params[:ssl] = {:verify => false}
  end

  conn = Faraday.new(conn_params) do |faraday|
    # Uses the default Net::HTTP adapter
    faraday.adapter  Faraday.default_adapter

  end

  conn.headers = {
    'Authorization' => "Bearer #{token}",
    'Accept' => "application/json",

    # Client instrumentation
    # See https://msdn.microsoft.com/EN-US/library/office/dn720380(v=exchg.150).aspx
    'User-Agent' => @user_agent,
    'client-request-id' => UUIDTools::UUID.timestamp_create.to_str,
    'return-client-request-id' => "true"
  }

  case method.upcase
    when "GET"
      response = conn.get do |request|
        request.url url, params
      end
    when "POST"
      conn.headers['Content-Type'] = "application/json"
      response = conn.post do |request|
        request.url url, params
        request.body = JSON.dump(payload)
      end
    when "PATCH"
      conn.headers['Content-Type'] = "application/json"
      response = conn.patch do |request|
        request.url url, params
        request.body = JSON.dump(payload)
      end
    when "DELETE"
      response = conn.delete do |request|
        request.url url, params
      end
  end

  if response.status >= 300
    error_info = response.body.empty? ? '' : JSON.parse(response.body)
    return JSON.dump({ 
      'ruby_outlook_error' => response.status,
      'ruby_outlook_response' => error_info })
  end

  response.body
end

#send_message(token, payload, save_to_sentitems = true, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the message to send user (string): The user to make the call for. If nil, use the ‘Me’ constant.



300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
 
# File 'lib/ruby_outlook.rb', line 300

def send_message(token, payload, save_to_sentitems = true, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/SendMail"

  # Wrap message in the sendmail JSON structure
  send_mail_json = {
    'Message' => payload,
    'SaveToSentItems' => save_to_sentitems
  }

  send_response = make_api_call "POST", request_url, token, nil, send_mail_json

  return nil if send_response.nil? || send_response.empty?

  JSON.parse(send_response)
end

#update_contact(token, payload, id, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the updated contact fields id (string): The Id of the contact to update. user (string): The user to make the call for. If nil, use the ‘Me’ constant.



158
159
160
161
162
163
164
 
# File 'lib/ruby_outlook.rb', line 158

def update_contact(token, payload, id, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Contacts/" << id

  update_contact_response = make_api_call "PATCH", request_url, token, nil, payload

  JSON.parse(update_contact_response)
end

#update_event(token, payload, id, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the updated event fields id (string): The Id of the event to update. user (string): The user to make the call for. If nil, use the ‘Me’ constant.



416
417
418
419
420
421
422
 
# File 'lib/ruby_outlook.rb', line 416

def update_event(token, payload, id, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Events/" << id

  update_event_response = make_api_call "PATCH", request_url, token, nil, payload

  JSON.parse(update_event_response)
end

#update_message(token, payload, id, user = nil) ⇒ Object

token (string): access token payload (hash): a JSON hash representing the updated message fields id (string): The Id of the message to update. user (string): The user to make the call for. If nil, use the ‘Me’ constant.



276
277
278
279
280
281
282
 
# File 'lib/ruby_outlook.rb', line 276

def update_message(token, payload, id, user = nil)
  request_url = "/api/v2.0/" << (user.nil? ? "Me" : ("users/" << user)) << "/Messages/" << id

  update_message_response = make_api_call "PATCH", request_url, token, nil, payload

  JSON.parse(update_message_response)
end