Class: Openfire::Api

Inherits:
Object
  • Object
show all
Defined in:
lib/openfire/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/openfire/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 



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

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

#add_user_to_group(username, groupname) ⇒ Object 



50
51
52
53
54
 
# File 'lib/openfire/api.rb', line 50

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 



56
57
58
59
60
61
62
 
# File 'lib/openfire/api.rb', line 56

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 



213
214
215
216
 
# File 'lib/openfire/api.rb', line 213

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

#create_chatroom(room_data = {}) ⇒ Object 



106
107
108
 
# File 'lib/openfire/api.rb', line 106

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

#create_group(group_data) ⇒ Object 



176
177
178
179
 
# File 'lib/openfire/api.rb', line 176

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

#create_system_property(property_name, value) ⇒ Object 



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

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/openfire/api.rb', line 18

def create_user(user_data={})
  request = web_request('POST', '/users', user_data.to_json, default_headers)
  (request[:status_code] == 201)
end

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



82
83
84
 
# File 'lib/openfire/api.rb', line 82

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

#delete_chatroom(room_name) ⇒ Object 



110
111
112
 
# File 'lib/openfire/api.rb', line 110

def delete_chatroom(room_name)
  raise 'not implemented'
end

#delete_group(groupname) ⇒ Object 



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

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

#delete_system_property(property_name) ⇒ Object 



146
147
148
149
 
# File 'lib/openfire/api.rb', line 146

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/openfire/api.rb', line 28

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

#delete_user_from_chatroom(room_name, username_or_jid, role) ⇒ Object 



122
123
124
 
# File 'lib/openfire/api.rb', line 122

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

#delete_user_from_group(username, groupname) ⇒ Object 



64
65
66
67
68
 
# File 'lib/openfire/api.rb', line 64

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 



70
71
72
73
74
75
76
 
# File 'lib/openfire/api.rb', line 70

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 



86
87
88
 
# File 'lib/openfire/api.rb', line 86

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

#get_chatroom(room_name) ⇒ Object 



98
99
100
 
# File 'lib/openfire/api.rb', line 98

def get_chatroom(room_name)
  raise 'not implemented'
end

#get_chatroom_participants(room_name) ⇒ Object 



102
103
104
 
# File 'lib/openfire/api.rb', line 102

def get_chatroom_participants(room_name)
  raise 'not implemented'
end

#get_chatrooms ⇒ Object 



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

def get_chatrooms
  raise 'not implemented'
end

#get_concurrent_sessions_count ⇒ Object 



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

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

#get_group(groupname) ⇒ Object 



171
172
173
174
 
# File 'lib/openfire/api.rb', line 171

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

#get_groups ⇒ Object 



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

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

#get_sessions ⇒ Object 



191
192
193
194
195
196
197
198
199
200
 
# File 'lib/openfire/api.rb', line 191

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 



126
127
128
129
 
# File 'lib/openfire/api.rb', line 126

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 



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

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 



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

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

#get_user_groups(username) ⇒ Object 



43
44
45
46
47
48
 
# File 'lib/openfire/api.rb', line 43

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 



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

def get_user_roster(username)
  raise 'not implemented'
end

#get_user_sessions(username) ⇒ Object 



202
203
204
205
206
207
208
209
210
211
 
# File 'lib/openfire/api.rb', line 202

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(filters = {}) ⇒ Object 



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

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

#lock_user(username) ⇒ Object 



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

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

#send_broadcast_message(message_text) ⇒ Object 



218
219
220
221
222
 
# File 'lib/openfire/api.rb', line 218

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 



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

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

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



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

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

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



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

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

#update_system_property(property_name, value) ⇒ Object 



151
152
153
154
155
156
157
158
159
 
# File 'lib/openfire/api.rb', line 151

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/openfire/api.rb', line 23

def update_user(username, user_data={})
  request = web_request('PUT', "/users/#{username}", user_data.to_json, default_headers)
  (request[:status_code] == 200)
end

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



90
91
92
 
# File 'lib/openfire/api.rb', line 90

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