Class: Openfire::Api

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

Instance Method Summary collapse

Constructor Details

#initialize(endpoint_url, access_token) ⇒ Api

Returns a new instance of Api.



3
4
5
6
 
# File 'lib/postfixman/api.rb', line 3

def initialize(endpoint_url, access_token)
  @endpoint_url = endpoint_url
  @access_token = access_token
end

Instance Method Details

#add_user_to_chatroom(room_name, username_or_jid, role) ⇒ Object 



198
199
200
 
# File 'lib/postfixman/api.rb', line 198

def add_user_to_chatroom(room_name, username_or_jid, role)
  raise 'not implemented'
end

#add_user_to_group(username, groupname) ⇒ Object 



130
131
132
133
134
 
# File 'lib/postfixman/api.rb', line 130

def add_user_to_group(username, groupname)
  request = web_request('POST', "/users/#{username}/groups/#{groupname}", { }, default_headers)

  (request[:status_code] == 201)
end

#add_user_to_groups(username, groupnames) ⇒ Object 



136
137
138
139
140
141
142
 
# File 'lib/postfixman/api.rb', line 136

def add_user_to_groups(username, groupnames)
  payload = { groupname: groupnames }.to_json

  request = web_request('POST', "/users/#{username}/groups", payload, default_headers)

  (request[:status_code] == 201)
end

#close_user_sessions(username) ⇒ Object 



293
294
295
296
 
# File 'lib/postfixman/api.rb', line 293

def close_user_sessions(username)
  request = web_request('DELETE', "/sessions/#{username}", { }, default_headers)
  (request[:status_code] == 200)
end

#create_alias(params) ⇒ Object 



38
39
40
41
 
# File 'lib/postfixman/api.rb', line 38

def create_alias(params)
  request = web_request('POST', '/aliases', params, default_headers)
  Openfire::User.new(request[:body])
end

#create_chatroom(room_data = {}) ⇒ Object 



186
187
188
 
# File 'lib/postfixman/api.rb', line 186

def create_chatroom(room_data={})
  raise 'not implemented'
end

#create_group(group_data) ⇒ Object 



256
257
258
259
 
# File 'lib/postfixman/api.rb', line 256

def create_group(group_data)
  request = web_request('POST', '/groups', group_data.to_json, default_headers)
  (request[:status_code] == 201)
end

#create_recipient_bccs(params) ⇒ Object 



58
59
60
61
 
# File 'lib/postfixman/api.rb', line 58

def create_recipient_bccs(params)
  request = web_request('POST', '/recipient_bccs', params, default_headers)
  Openfire::User.new(request[:body])
end

#create_sender_bccs(params) ⇒ Object 



78
79
80
81
 
# File 'lib/postfixman/api.rb', line 78

def create_sender_bccs(params)
  request = web_request('POST', '/sender_bccs', params, default_headers)
  Openfire::User.new(request[:body])
end

#create_system_property(property_name, value) ⇒ Object 



216
217
218
219
220
221
222
223
224
 
# File 'lib/postfixman/api.rb', line 216

def create_system_property(property_name, value)
  payload = {
    '@key' => property_name,
    '@value' => value
  }.to_json

  request = web_request('POST', '/system/properties', payload, default_headers)
  (request[:status_code] == 201)
end

#create_user(user_data = {}) ⇒ Object 



18
19
20
21
 
# File 'lib/postfixman/api.rb', line 18

def create_user(params)
  request = web_request('POST', '/users', params, default_headers)
  Openfire::User.new(request[:body])
end

#create_user_roster(username, roster_data = {}) ⇒ Object 



162
163
164
 
# File 'lib/postfixman/api.rb', line 162

def create_user_roster(username, roster_data={})
  raise 'not implemented'
end

#delete_alias(alias_id) ⇒ Object 



48
49
50
51
 
# File 'lib/postfixman/api.rb', line 48

def delete_alias(alias_id)
  request = web_request('DELETE', "/aliases/#{user_id}", params, default_headers)
  request[:body]['success'] == true
end

#delete_chatroom(room_name) ⇒ Object 



190
191
192
 
# File 'lib/postfixman/api.rb', line 190

def delete_chatroom(room_name)
  raise 'not implemented'
end

#delete_group(groupname) ⇒ Object 



266
267
268
269
 
# File 'lib/postfixman/api.rb', line 266

def delete_group(groupname)
  request = web_request('DELETE', "/groups/#{groupname}", { }, default_headers)
  (request[:status_code] == 200)
end

#delete_recipient_bccs(sender_bcc_id) ⇒ Object 



68
69
70
71
 
# File 'lib/postfixman/api.rb', line 68

def delete_recipient_bccs(sender_bcc_id)
  request = web_request('DELETE', "/recipient_bccs/#{user_id}", params, default_headers)
  request[:body]['success'] == true
end

#delete_sender_bccs(sender_bcc_id) ⇒ Object 



88
89
90
91
 
# File 'lib/postfixman/api.rb', line 88

def delete_sender_bccs(sender_bcc_id)
  request = web_request('DELETE', "/sender_bccs/#{user_id}", params, default_headers)
  request[:body]['success'] == true
end

#delete_system_property(property_name) ⇒ Object 



226
227
228
229
 
# File 'lib/postfixman/api.rb', line 226

def delete_system_property(property_name)
  request = web_request('DELETE', "/system/properties/#{property_name}", { }, default_headers)
  (request[:status_code] == 200)
end

#delete_user(username) ⇒ Object 



28
29
30
31
 
# File 'lib/postfixman/api.rb', line 28

def delete_user(user_id)
  request = web_request('DELETE', "/users/#{user_id}", params, default_headers)
  request[:body]['success'] == true
end

#delete_user_from_chatroom(room_name, username_or_jid, role) ⇒ Object 



202
203
204
 
# File 'lib/postfixman/api.rb', line 202

def delete_user_from_chatroom(room_name, username_or_jid, role)
  raise 'not implemented'
end

#delete_user_from_group(username, groupname) ⇒ Object 



144
145
146
147
148
 
# File 'lib/postfixman/api.rb', line 144

def delete_user_from_group(username, groupname)
  request = web_request('DELETE', "/users/#{username}/groups/#{groupname}", { }, default_headers)

  (request[:status_code] == 200)
end

#delete_user_from_groups(username, groupnames) ⇒ Object 



150
151
152
153
154
155
156
 
# File 'lib/postfixman/api.rb', line 150

def delete_user_from_groups(username, groupnames)
  payload = { groupname: groupnames }.to_json

  request = web_request('DELETE', "/users/#{username}/groups", payload, default_headers)

  (request[:status_code] == 200)
end

#delete_user_roster(username, jid) ⇒ Object 



166
167
168
 
# File 'lib/postfixman/api.rb', line 166

def delete_user_roster(username, jid)
  raise 'not implemented'
end

#get_aliases(domain_id) ⇒ Object 



33
34
35
36
 
# File 'lib/postfixman/api.rb', line 33

def get_aliases(domain_id)
  request = web_request('GET', "/domains/#{domain_id}/aliases", { }, default_headers)
  request[:body].map { |x| Openfire::Alias.new(x) }
end

#get_chatroom(room_name) ⇒ Object 



178
179
180
 
# File 'lib/postfixman/api.rb', line 178

def get_chatroom(room_name)
  raise 'not implemented'
end

#get_chatroom_participants(room_name) ⇒ Object 



182
183
184
 
# File 'lib/postfixman/api.rb', line 182

def get_chatroom_participants(room_name)
  raise 'not implemented'
end

#get_chatrooms ⇒ Object 



174
175
176
 
# File 'lib/postfixman/api.rb', line 174

def get_chatrooms
  raise 'not implemented'
end

#get_concurrent_sessions_count ⇒ Object 



241
242
243
244
 
# File 'lib/postfixman/api.rb', line 241

def get_concurrent_sessions_count
  request = web_request('GET', '/system/statistics/sessions', { }, default_headers)
  Openfire::SessionsCount.new(request[:body])
end

#get_domains ⇒ Object 



8
9
10
11
 
# File 'lib/postfixman/api.rb', line 8

def get_domains
  request = web_request('GET', '/domains', { }, default_headers)
  request[:body].map { |x| Openfire::Domain.new(x) }
end

#get_group(groupname) ⇒ Object 



251
252
253
254
 
# File 'lib/postfixman/api.rb', line 251

def get_group(groupname)
  request = web_request('GET', "/groups/#{groupname}", { }, default_headers)
  Openfire::Group.new(request[:body])
end

#get_groups ⇒ Object 



246
247
248
249
 
# File 'lib/postfixman/api.rb', line 246

def get_groups
  request = web_request('GET', '/groups', { }, default_headers)
  request[:body]['group'].map { |x| Openfire::Group.new(x) }
end

#get_recipient_bccs ⇒ Object 



53
54
55
56
 
# File 'lib/postfixman/api.rb', line 53

def get_recipient_bccs
  request = web_request('GET', "/domains/#{domain_id}/recipient_bccs", { }, default_headers)
  request[:body].map { |x| Openfire::RecipientBcc.new(x) }
end

#get_sender_bccs ⇒ Object 



73
74
75
76
 
# File 'lib/postfixman/api.rb', line 73

def get_sender_bccs
  request = web_request('GET', "/domains/#{domain_id}/sender_bccs", { }, default_headers)
  request[:body].map { |x| Openfire::SenderBcc.new(x) }
end

#get_sessions ⇒ Object 



271
272
273
274
275
276
277
278
279
280
 
# File 'lib/postfixman/api.rb', line 271

def get_sessions
  request = web_request('GET', '/sessions', { }, default_headers)
  data = request[:body]['session']

  if data.is_a?(Array)
    data.map { |x| Openfire::Session.new(x) }
  else
    [Openfire::Session.new(data)]
  end
end

#get_system_properties ⇒ Object 



206
207
208
209
 
# File 'lib/postfixman/api.rb', line 206

def get_system_properties
  request = web_request('GET', '/system/properties', { }, default_headers)
  request[:body]['property'].map { |x| Openfire::SystemProperty.new(x) }
end

#get_system_property(property_name) ⇒ Object 



211
212
213
214
 
# File 'lib/postfixman/api.rb', line 211

def get_system_property(property_name)
  request = web_request('GET', "/system/properties/#{property_name}", { }, default_headers)
  Openfire::SystemProperty.new(request[:body])
end

#get_user(username) ⇒ Object 



93
94
95
96
 
# File 'lib/postfixman/api.rb', line 93

def get_user(username)
  request = web_request('GET', "/users/#{username}", { }, default_headers)
  Openfire::User.new(request[:body])
end

#get_user_groups(username) ⇒ Object 



123
124
125
126
127
128
 
# File 'lib/postfixman/api.rb', line 123

def get_user_groups(username)
  request = web_request('GET', "/users/#{username}/groups", { }, default_headers)
  body = request[:body]['groupname']

  body.is_a?(Array) ? body : [body]
end

#get_user_roster(username) ⇒ Object 



158
159
160
 
# File 'lib/postfixman/api.rb', line 158

def get_user_roster(username)
  raise 'not implemented'
end

#get_user_sessions(username) ⇒ Object 



282
283
284
285
286
287
288
289
290
291
 
# File 'lib/postfixman/api.rb', line 282

def get_user_sessions(username)
  request = web_request('GET', "/sessions/#{username}", { }, default_headers)
  data = request[:body]['session']

  if data.is_a?(Array)
    data.map { |x| Openfire::Session.new(x) }
  else
    [Openfire::Session.new(data)]
  end
end

#get_users(domain_id) ⇒ Object 



13
14
15
16
 
# File 'lib/postfixman/api.rb', line 13

def get_users(domain_id)
  request = web_request('GET', "/domains/#{domain_id}/users", { }, default_headers)
  request[:body].map { |x| Openfire::User.new(x) }
end

#lock_user(username) ⇒ Object 



113
114
115
116
 
# File 'lib/postfixman/api.rb', line 113

def lock_user(username)
  request = web_request('POST', "/lockouts/#{username}", { }, default_headers)
  (request[:status_code] == 200)
end

#send_broadcast_message(message_text) ⇒ Object 



298
299
300
301
302
 
# File 'lib/postfixman/api.rb', line 298

def send_broadcast_message(message_text)
  payload = { body: message_text }.to_json

  request = web_request('POST', '/messages/users', payload, default_headers)
end

#unlock_user(username) ⇒ Object 



118
119
120
121
 
# File 'lib/postfixman/api.rb', line 118

def unlock_user(username)
  request = web_request('DELETE', "/lockouts/#{username}", { }, default_headers)
  (request[:status_code] == 200)
end

#update_alias(alias_id, params) ⇒ Object 



43
44
45
46
 
# File 'lib/postfixman/api.rb', line 43

def update_alias(alias_id, params)
  request = web_request('PUT', "/aliases/#{user_id}", params, default_headers)
  Openfire::User.new(request[:body])
end

#update_chatroom(room_name, room_data = {}) ⇒ Object 



194
195
196
 
# File 'lib/postfixman/api.rb', line 194

def update_chatroom(room_name, room_data={})
  raise 'not implemented'
end

#update_group(groupname, group_data = {}) ⇒ Object 



261
262
263
264
 
# File 'lib/postfixman/api.rb', line 261

def update_group(groupname, group_data={})
  request = web_request('PUT', "/groups/#{groupname}", group_data.to_json, default_headers)
  (request[:status_code] == 200)
end

#update_sender_bccs(sender_bcc_id) ⇒ Object 



63
64
65
66
 
# File 'lib/postfixman/api.rb', line 63

def update_sender_bccs(sender_bcc_id, params)
  request = web_request('PUT', "/recipient_bccs/#{user_id}", params, default_headers)
  Openfire::User.new(request[:body])
end

#update_system_property(property_name, value) ⇒ Object 



231
232
233
234
235
236
237
238
239
 
# File 'lib/postfixman/api.rb', line 231

def update_system_property(property_name, value)
  payload = {
    '@key' => property_name,
    '@value' => value
  }.to_json

  request = web_request('PUT', "/system/properties/#{property_name}", payload, default_headers)
  (request[:status_code] == 200)
end

#update_user(username, user_data = {}) ⇒ Object 



23
24
25
26
 
# File 'lib/postfixman/api.rb', line 23

def update_user(user_id, params)
  request = web_request('PUT', "/users/#{user_id}", params, default_headers)
  Openfire::User.new(request[:body])
end

#update_user_roster(username, jid, roster_data = {}) ⇒ Object 



170
171
172
 
# File 'lib/postfixman/api.rb', line 170

def update_user_roster(username, jid, roster_data={})
  raise 'not implemented'
end