1
|
|
|
# frozen_string_literal: true |
2
|
|
|
|
3
|
|
|
# BigBlueButton open source conferencing system - http://www.bigbluebutton.org/. |
4
|
|
|
# |
5
|
|
|
# Copyright (c) 2018 BigBlueButton Inc. and by respective authors (see below). |
6
|
|
|
# |
7
|
|
|
# This program is free software; you can redistribute it and/or modify it under the |
8
|
|
|
# terms of the GNU Lesser General Public License as published by the Free Software |
9
|
|
|
# Foundation; either version 3.0 of the License, or (at your option) any later |
10
|
|
|
# version. |
11
|
|
|
# |
12
|
|
|
# BigBlueButton is distributed in the hope that it will be useful, but WITHOUT ANY |
13
|
|
|
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A |
14
|
|
|
# PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. |
15
|
|
|
# |
16
|
|
|
# You should have received a copy of the GNU Lesser General Public License along |
17
|
|
|
# with BigBlueButton; if not, see <http://www.gnu.org/licenses/>. |
18
|
|
|
|
19
|
|
|
class RoomsController < ApplicationController |
20
|
|
|
include RecordingsHelper |
21
|
|
|
include Pagy::Backend |
22
|
|
|
include Recorder |
23
|
|
|
|
24
|
|
|
before_action :validate_accepted_terms, unless: -> { !Rails.configuration.terms } |
25
|
|
|
before_action :validate_verified_email, except: [:show, :join], |
26
|
|
|
unless: -> { !Rails.configuration.enable_email_verification } |
27
|
|
|
before_action :find_room, except: [:create, :join_specific_room] |
28
|
|
|
before_action :verify_room_ownership, except: [:create, :show, :join, :logout, :login, :join_specific_room] |
29
|
|
|
before_action :verify_room_owner_verified, only: [:show, :join], |
30
|
|
|
unless: -> { !Rails.configuration.enable_email_verification } |
31
|
|
|
before_action :verify_user_not_admin, only: [:show] |
32
|
|
|
|
33
|
|
|
# POST / |
34
|
|
|
def create |
35
|
|
|
redirect_to(root_path) && return unless current_user |
36
|
|
|
|
37
|
|
|
return redirect_to current_user.main_room, flash: { alert: I18n.t("room.room_limit") } if room_limit_exceeded |
38
|
|
|
|
39
|
|
|
@room = Room.new(name: room_params[:name], access_code: room_params[:access_code]) |
40
|
|
|
@room.owner = current_user |
41
|
|
|
@room.room_settings = create_room_settings_string(room_params[:mute_on_join], |
42
|
|
|
room_params[:require_moderator_approval], room_params[:anyone_can_start], room_params[:all_join_moderator]) |
43
|
|
|
|
44
|
|
|
if @room.save |
45
|
|
|
logger.info("Support: #{current_user.email} has created a new room #{@room.uid}.") |
46
|
|
|
|
47
|
|
|
if room_params[:auto_join] == "1" |
48
|
|
|
start |
49
|
|
|
else |
50
|
|
|
flash[:success] = I18n.t("room.create_room_success") |
51
|
|
|
redirect_to @room |
52
|
|
|
end |
53
|
|
|
else |
54
|
|
|
flash[:alert] = I18n.t("room.create_room_error") |
55
|
|
|
redirect_to current_user.main_room |
56
|
|
|
end |
57
|
|
|
end |
58
|
|
|
|
59
|
|
|
# GET /:room_uid |
60
|
|
|
def show |
61
|
|
|
@is_running = @room.running? |
62
|
|
|
@anyone_can_start = JSON.parse(@room[:room_settings])["anyoneCanStart"] |
63
|
|
|
|
64
|
|
|
if current_user && @room.owned_by?(current_user) |
65
|
|
|
if current_user.highest_priority_role.can_create_rooms |
66
|
|
|
@search, @order_column, @order_direction, recs = |
67
|
|
|
recordings(@room.bbb_id, @user_domain, params.permit(:search, :column, :direction), true) |
68
|
|
|
|
69
|
|
|
@pagy, @recordings = pagy_array(recs) |
70
|
|
|
else |
71
|
|
|
@recent_rooms = Room.where(id: cookies.encrypted["#{current_user.uid}_recently_joined_rooms"]) |
72
|
|
|
render :cant_create_rooms |
73
|
|
|
end |
74
|
|
|
else |
75
|
|
|
return redirect_to root_path, flash: { alert: I18n.t("room.invalid_provider") } if incorrect_user_domain |
76
|
|
|
|
77
|
|
|
# Get users name |
78
|
|
|
@name = if current_user |
79
|
|
|
current_user.name |
80
|
|
|
elsif cookies.encrypted[:greenlight_name] |
81
|
|
|
cookies.encrypted[:greenlight_name] |
82
|
|
|
else |
83
|
|
|
"" |
84
|
|
|
end |
85
|
|
|
|
86
|
|
|
@search, @order_column, @order_direction, pub_recs = |
87
|
|
|
public_recordings(@room.bbb_id, @user_domain, params.permit(:search, :column, :direction), true) |
88
|
|
|
|
89
|
|
|
@pagy, @public_recordings = pagy_array(pub_recs) |
90
|
|
|
|
91
|
|
|
render :join |
92
|
|
|
end |
93
|
|
|
end |
94
|
|
|
|
95
|
|
|
# PATCH /:room_uid |
96
|
|
|
def update |
97
|
|
|
if params[:setting] == "rename_block" |
98
|
|
|
@room = Room.find_by!(uid: params[:room_block_uid]) |
99
|
|
|
update_room_attributes("name") |
100
|
|
|
elsif params[:setting] == "rename_header" |
101
|
|
|
update_room_attributes("name") |
102
|
|
|
elsif params[:setting] == "rename_recording" |
103
|
|
|
@room.update_recording(params[:record_id], "meta_name" => params[:record_name]) |
104
|
|
|
end |
105
|
|
|
|
106
|
|
|
if request.referrer |
107
|
|
|
redirect_to request.referrer |
108
|
|
|
else |
109
|
|
|
redirect_to room_path |
110
|
|
|
end |
111
|
|
|
end |
112
|
|
|
|
113
|
|
|
# POST /:room_uid |
114
|
|
|
def join |
115
|
|
|
return redirect_to root_path, |
116
|
|
|
flash: { alert: I18n.t("administrator.site_settings.authentication.user-info") } if auth_required |
117
|
|
|
|
118
|
|
|
opts = default_meeting_options |
119
|
|
|
unless @room.owned_by?(current_user) |
120
|
|
|
# Don't allow users to join unless they have a valid access code or the room doesn't |
121
|
|
|
# have an access code |
122
|
|
|
if @room.access_code && [email protected]_code.empty? && @room.access_code != session[:access_code] |
123
|
|
|
return redirect_to room_path(room_uid: params[:room_uid]), flash: { alert: I18n.t("room.access_code_required") } |
124
|
|
|
end |
125
|
|
|
|
126
|
|
|
# Assign join name if passed. |
127
|
|
|
if params[@room.invite_path] |
128
|
|
|
@join_name = params[@room.invite_path][:join_name] |
129
|
|
|
elsif !params[:join_name] |
130
|
|
|
# Join name not passed. |
131
|
|
|
return |
132
|
|
|
end |
133
|
|
|
end |
134
|
|
|
|
135
|
|
|
# create or update cookie with join name |
136
|
|
|
cookies.encrypted[:greenlight_name] = @join_name unless cookies.encrypted[:greenlight_name] == @join_name |
137
|
|
|
|
138
|
|
|
if current_user |
139
|
|
|
# create or update cookie to track the three most recent rooms a user joined |
140
|
|
|
recently_joined_rooms = cookies.encrypted["#{current_user.uid}_recently_joined_rooms"].to_a |
141
|
|
|
cookies.encrypted["#{current_user.uid}_recently_joined_rooms"] = recently_joined_rooms.prepend(@room.id) |
142
|
|
|
.uniq[0..2] |
143
|
|
|
end |
144
|
|
|
|
145
|
|
|
logger.info("Support: #{current_user.present? ? current_user.email : @join_name} is joining room #{@room.uid}") |
146
|
|
|
|
147
|
|
|
join_room(opts) |
148
|
|
|
end |
149
|
|
|
|
150
|
|
|
# DELETE /:room_uid |
151
|
|
|
def destroy |
152
|
|
|
# Don't delete the users home room. |
153
|
|
|
@room.destroy if @room.owned_by?(current_user) && @room != current_user.main_room |
154
|
|
|
|
155
|
|
|
redirect_to current_user.main_room |
156
|
|
|
end |
157
|
|
|
|
158
|
|
|
# POST room/join |
159
|
|
|
def join_specific_room |
160
|
|
|
room_uid = params[:join_room][:url].split('/').last |
161
|
|
|
|
162
|
|
|
begin |
163
|
|
|
@room = Room.find_by(uid: room_uid) |
164
|
|
|
rescue ActiveRecord::RecordNotFound |
165
|
|
|
return redirect_to current_user.main_room, alert: I18n.t("room.no_room.invalid_room_uid") |
166
|
|
|
end |
167
|
|
|
|
168
|
|
|
return redirect_to current_user.main_room, alert: I18n.t("room.no_room.invalid_room_uid") if @room.nil? |
169
|
|
|
|
170
|
|
|
redirect_to room_path(@room) |
171
|
|
|
end |
172
|
|
|
|
173
|
|
|
# POST /:room_uid/start |
174
|
|
|
def start |
175
|
|
|
logger.info("Support: #{current_user.email} is starting room #{@room.uid}") |
176
|
|
|
|
177
|
|
|
# Join the user in and start the meeting. |
178
|
|
|
opts = default_meeting_options |
179
|
|
|
opts[:user_is_moderator] = true |
180
|
|
|
|
181
|
|
|
# Include the user's choices for the room settings |
182
|
|
|
room_settings = JSON.parse(@room[:room_settings]) |
183
|
|
|
opts[:mute_on_start] = room_settings["muteOnStart"] if room_settings["muteOnStart"] |
184
|
|
|
opts[:require_moderator_approval] = room_settings["requireModeratorApproval"] |
185
|
|
|
|
186
|
|
|
begin |
187
|
|
|
redirect_to @room.join_path(current_user.name, opts, current_user.uid) |
188
|
|
|
rescue BigBlueButton::BigBlueButtonException => e |
189
|
|
|
logger.error("Support: #{@room.uid} start failed: #{e}") |
190
|
|
|
|
191
|
|
|
redirect_to room_path, alert: I18n.t(e.key.to_s.underscore, default: I18n.t("bigbluebutton_exception")) |
192
|
|
|
end |
193
|
|
|
|
194
|
|
|
# Notify users that the room has started. |
195
|
|
|
# Delay 5 seconds to allow for server start, although the request will retry until it succeeds. |
196
|
|
|
NotifyUserWaitingJob.set(wait: 5.seconds).perform_later(@room) |
197
|
|
|
end |
198
|
|
|
|
199
|
|
|
# POST /:room_uid/update_settings |
200
|
|
|
def update_settings |
201
|
|
|
begin |
202
|
|
|
raise "Room name can't be blank" if room_params[:name].empty? |
203
|
|
|
|
204
|
|
|
@room = Room.find_by!(uid: params[:room_uid]) |
205
|
|
|
# Update the rooms settings |
206
|
|
|
update_room_attributes("settings") |
207
|
|
|
# Update the rooms name if it has been changed |
208
|
|
|
update_room_attributes("name") if @room.name != room_params[:name] |
209
|
|
|
# Update the room's access code if it has changed |
210
|
|
|
update_room_attributes("access_code") if @room.access_code != room_params[:access_code] |
211
|
|
|
rescue StandardError |
212
|
|
|
flash[:alert] = I18n.t("room.update_settings_error") |
213
|
|
|
else |
214
|
|
|
flash[:success] = I18n.t("room.update_settings_success") |
215
|
|
|
end |
216
|
|
|
redirect_to room_path |
217
|
|
|
end |
218
|
|
|
|
219
|
|
|
# GET /:room_uid/logout |
220
|
|
|
def logout |
221
|
|
|
logger.info("Support: #{current_user.present? ? current_user.email : 'Guest'} has left room #{@room.uid}") |
222
|
|
|
|
223
|
|
|
# Redirect the correct page. |
224
|
|
|
redirect_to @room |
225
|
|
|
end |
226
|
|
|
|
227
|
|
|
# POST /:room_uid/login |
228
|
|
|
def login |
229
|
|
|
session[:access_code] = room_params[:access_code] |
230
|
|
|
|
231
|
|
|
flash[:alert] = I18n.t("room.access_code_required") if session[:access_code] != @room.access_code |
232
|
|
|
|
233
|
|
|
redirect_to room_path(@room.uid) |
234
|
|
|
end |
235
|
|
|
|
236
|
|
|
private |
237
|
|
|
|
238
|
|
|
def update_room_attributes(update_type) |
239
|
|
|
if @room.owned_by?(current_user) && @room != current_user.main_room |
240
|
|
|
if update_type.eql? "name" |
241
|
|
|
@room.update_attributes(name: params[:room_name] || room_params[:name]) |
242
|
|
|
elsif update_type.eql? "settings" |
243
|
|
|
room_settings_string = create_room_settings_string(room_params[:mute_on_join], |
244
|
|
|
room_params[:require_moderator_approval], room_params[:anyone_can_start], room_params[:all_join_moderator]) |
245
|
|
|
@room.update_attributes(room_settings: room_settings_string) |
246
|
|
|
elsif update_type.eql? "access_code" |
247
|
|
|
@room.update_attributes(access_code: room_params[:access_code]) |
248
|
|
|
end |
249
|
|
|
end |
250
|
|
|
end |
251
|
|
|
|
252
|
|
|
def create_room_settings_string(mute_res, require_approval_res, start_res, join_mod) |
253
|
|
|
room_settings = {} |
254
|
|
|
room_settings["muteOnStart"] = mute_res == "1" |
255
|
|
|
|
256
|
|
|
room_settings["requireModeratorApproval"] = require_approval_res == "1" |
257
|
|
|
|
258
|
|
|
room_settings["anyoneCanStart"] = start_res == "1" |
259
|
|
|
|
260
|
|
|
room_settings["joinModerator"] = join_mod == "1" |
261
|
|
|
|
262
|
|
|
room_settings.to_json |
263
|
|
|
end |
264
|
|
|
|
265
|
|
|
def room_params |
266
|
|
|
params.require(:room).permit(:name, :auto_join, :mute_on_join, :access_code, |
267
|
|
|
:require_moderator_approval, :anyone_can_start, :all_join_moderator) |
268
|
|
|
end |
269
|
|
|
|
270
|
|
|
# Find the room from the uid. |
271
|
|
|
def find_room |
272
|
|
|
@room = Room.find_by!(uid: params[:room_uid]) |
273
|
|
|
end |
274
|
|
|
|
275
|
|
|
# Ensure the user is logged into the room they are accessing. |
276
|
|
|
def verify_room_ownership |
277
|
|
|
bring_to_room unless @room.owned_by?(current_user) |
278
|
|
|
end |
279
|
|
|
|
280
|
|
|
# Redirects a user to their room. |
281
|
|
|
def bring_to_room |
282
|
|
|
if current_user |
283
|
|
|
# Redirect authenticated users to their room. |
284
|
|
|
redirect_to room_path(current_user.main_room) |
285
|
|
|
else |
286
|
|
|
# Redirect unauthenticated users to root. |
287
|
|
|
redirect_to root_path |
288
|
|
|
end |
289
|
|
|
end |
290
|
|
|
|
291
|
|
|
def validate_accepted_terms |
292
|
|
|
if current_user |
293
|
|
|
redirect_to terms_path unless current_user.accepted_terms |
294
|
|
|
end |
295
|
|
|
end |
296
|
|
|
|
297
|
|
|
def validate_verified_email |
298
|
|
|
if current_user |
299
|
|
|
redirect_to account_activation_path(current_user) unless current_user.activated? |
300
|
|
|
end |
301
|
|
|
end |
302
|
|
|
|
303
|
|
|
def verify_room_owner_verified |
304
|
|
|
unless @room.owner.activated? |
305
|
|
|
flash[:alert] = t("room.unavailable") |
306
|
|
|
|
307
|
|
|
if current_user && [email protected]_by?(current_user) |
308
|
|
|
redirect_to current_user.main_room |
309
|
|
|
else |
310
|
|
|
redirect_to root_path |
311
|
|
|
end |
312
|
|
|
end |
313
|
|
|
end |
314
|
|
|
|
315
|
|
|
def verify_user_not_admin |
316
|
|
|
redirect_to admins_path if current_user && current_user&.has_role?(:super_admin) |
317
|
|
|
end |
318
|
|
|
|
319
|
|
View Code Duplication |
def auth_required |
|
|
|
|
320
|
|
|
Setting.find_or_create_by!(provider: user_settings_provider).get_value("Room Authentication") == "true" && |
321
|
|
|
current_user.nil? |
322
|
|
|
end |
323
|
|
|
|
324
|
|
View Code Duplication |
def room_limit_exceeded |
|
|
|
|
325
|
|
|
limit = Setting.find_or_create_by!(provider: user_settings_provider).get_value("Room Limit").to_i |
326
|
|
|
|
327
|
|
|
# Does not apply to admin |
328
|
|
|
# 15+ option is used as unlimited |
329
|
|
|
return false if current_user&.has_role?(:admin) || limit == 15 |
330
|
|
|
|
331
|
|
|
current_user.rooms.count >= limit |
332
|
|
|
end |
333
|
|
|
|
334
|
|
|
def join_room(opts) |
335
|
|
|
room_settings = JSON.parse(@room[:room_settings]) |
336
|
|
|
|
337
|
|
|
if @room.running? || @room.owned_by?(current_user) || room_settings["anyoneCanStart"] |
338
|
|
|
|
339
|
|
|
# Determine if the user needs to join as a moderator. |
340
|
|
|
opts[:user_is_moderator] = @room.owned_by?(current_user) || room_settings["joinModerator"] |
341
|
|
|
|
342
|
|
|
opts[:require_moderator_approval] = room_settings["requireModeratorApproval"] |
343
|
|
|
|
344
|
|
|
if current_user |
345
|
|
|
redirect_to @room.join_path(current_user.name, opts, current_user.uid) |
346
|
|
|
else |
347
|
|
|
join_name = params[:join_name] || params[@room.invite_path][:join_name] |
348
|
|
|
redirect_to @room.join_path(join_name, opts) |
349
|
|
|
end |
350
|
|
|
else |
351
|
|
|
search_params = params[@room.invite_path] || params |
352
|
|
|
@search, @order_column, @order_direction, pub_recs = |
353
|
|
|
public_recordings(@room.bbb_id, @user_domain, search_params.permit(:search, :column, :direction), true) |
354
|
|
|
|
355
|
|
|
@pagy, @public_recordings = pagy_array(pub_recs) |
356
|
|
|
|
357
|
|
|
# They need to wait until the meeting begins. |
358
|
|
|
render :wait |
359
|
|
|
end |
360
|
|
|
end |
361
|
|
|
|
362
|
|
|
def incorrect_user_domain |
363
|
|
|
Rails.configuration.loadbalanced_configuration && @room.owner.provider != @user_domain |
364
|
|
|
end |
365
|
|
|
end |
366
|
|
|
|