bigbluebutton_rails 2.2.0 → 2.3.0

data/app/models/bigbluebutton_room.rb

@@ -14,6 +14,11 @@ class BigbluebuttonRoom < ActiveRecord::Base
            dependent: :destroy,
            inverse_of: :owner
 
+  has_many :meetings,
+           class_name: 'BigbluebuttonMeeting',
+           foreign_key: 'room_id',
+           dependent: :destroy
+
   has_one :room_options,
           class_name: 'BigbluebuttonRoomOptions',
           foreign_key: 'room_id',
@@ -33,7 +38,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   validates :meetingid, :presence => true, :uniqueness => true,
     :length => { :minimum => 1, :maximum => 100 }
   validates :name, :presence => true,
-    :length => { :minimum => 1, :maximum => 150 }
+    :length => { :minimum => 1, :maximum => 250 }
   validates :welcome_msg, :length => { :maximum => 250 }
   validates :private, :inclusion => { :in => [true, false] }
   validates :record_meeting, :inclusion => { :in => [true, false] }
@@ -58,8 +63,8 @@ class BigbluebuttonRoom < ActiveRecord::Base
   validates :moderator_key, :presence => true, :if => :private?
 
   # Note: these params need to be fetched from the server before being accessed
-  attr_accessor :running, :participant_count, :moderator_count, :attendees,
-                :has_been_forcibly_ended, :start_time, :end_time
+  attr_accessor :running, :participant_count, :moderator_count, :current_attendees,
+                :has_been_forcibly_ended, :end_time
 
   after_initialize :init
   after_create :create_room_options
@@ -74,6 +79,33 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # Currently used to send the client's IP to the load balancer.
   attr_accessor :request_headers
 
+  scope :order_by_activity, -> (direction='ASC') {
+    BigbluebuttonRoom.joins(:meetings)
+      .group('bigbluebutton_rooms.id')
+      .order("MAX(bigbluebutton_meetings.create_time) #{direction}")
+  }
+
+  scope :search_by_terms, -> (words) {
+    if words.present?
+      words ||= []
+      words = [words] unless words.is_a?(Array)
+      query_strs = []
+      query_params = []
+      query_orders = []
+
+      words.reject(&:blank?).each do |word|
+        str  = "name LIKE ? OR param LIKE ?"
+        query_strs << str
+        query_params += ["%#{word}%", "%#{word}%"]
+        query_orders += [
+          "CASE WHEN name LIKE '%#{word}%' THEN 1 ELSE 0 END + \
+           CASE WHEN param LIKE '%#{word}%' THEN 1 ELSE 0 END"
+        ]
+      end
+      where(query_strs.join(' OR '), *query_params.flatten).order(query_orders.join(' + ') + " DESC")
+    end
+  }
+
   # In case there's no room_options created yet, build one
   # (happens usually when an old database is migrated).
   def room_options_with_initialize
@@ -90,16 +122,16 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # The response is parsed and stored in the model. You can access it using attributes such as:
   #
   #   room.participant_count
-  #   room.attendees[0].full_name
+  #   room.current_attendees[0].user_name
   #
   # The attributes changed are:
   # * <tt>participant_count</tt>
   # * <tt>moderator_count</tt>
   # * <tt>running</tt>
   # * <tt>has_been_forcibly_ended</tt>
-  # * <tt>start_time</tt>
+  # * <tt>create_time</tt>
   # * <tt>end_time</tt>
-  # * <tt>attendees</tt> (array of <tt>BigbluebuttonAttendee</tt>)
+  # * <tt>current_attendees</tt> (array of <tt>BigbluebuttonAttendee</tt>)
   #
   # Triggers API call: <tt>getMeetingInfo</tt>.
   def fetch_meeting_info
@@ -111,14 +143,13 @@ class BigbluebuttonRoom < ActiveRecord::Base
       @moderator_count = response[:moderatorCount]
       @running = response[:running]
       @has_been_forcibly_ended = response[:hasBeenForciblyEnded]
-      @start_time = response[:startTime]
       @end_time = response[:endTime]
-      @attendees = []
+      @current_attendees = []
       if response[:attendees].present?
         response[:attendees].each do |att|
           attendee = BigbluebuttonAttendee.new
           attendee.from_hash(att)
-          @attendees << attendee
+          @current_attendees << attendee
         end
       end
 
@@ -156,7 +187,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
     response = server.api.end_meeting(self.meetingid, self.moderator_api_password)
 
     # enqueue an update in the meeting to end it faster
-    Resque.enqueue(::BigbluebuttonMeetingUpdater, self.id)
+    Resque.enqueue(::BigbluebuttonMeetingUpdaterWorker, self.id)
 
     response
   end
@@ -172,13 +203,17 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # * <tt>moderator_api_password</tt>
   #
   # Triggers API call: <tt>create</tt>.
-  def send_create(user=nil, user_opts={})
+  def send_create(user=nil)
     self.meetingid = unique_meetingid() if self.meetingid.blank?
     self.moderator_api_password = internal_password() if self.moderator_api_password.blank?
     self.attendee_api_password = internal_password() if self.attendee_api_password.blank?
     self.save unless self.new_record?
 
-    response = internal_create_meeting(user, user_opts)
+    # Get the user options to use when creating the meeting
+    user_opts = BigbluebuttonRails.configuration.get_create_options.call(self, user)
+    user_opts = {} if user_opts.blank?
+
+    server, response = internal_create_meeting(user, user_opts)
     unless response.nil?
       self.attendee_api_password = response[:attendeePW]
       self.moderator_api_password = response[:moderatorPW]
@@ -189,11 +224,11 @@ class BigbluebuttonRoom < ActiveRecord::Base
         self.save
 
         # creates the meeting object since the create was successful
-        create_meeting_record(response[:metadata])
+        create_meeting_record(response, server, user, user_opts)
 
         # enqueue an update in the meeting with a small delay we assume to be
         # enough for the user to fully join the meeting
-        Resque.enqueue(::BigbluebuttonMeetingUpdater, self.id, 10.seconds)
+        Resque.enqueue(::BigbluebuttonMeetingUpdaterWorker, self.id, 10.seconds)
       end
     end
 
@@ -229,6 +264,26 @@ class BigbluebuttonRoom < ActiveRecord::Base
     r
   end
 
+  def parameterized_join_url(username, role, id, options={}, user=nil)
+    opts = options.clone
+
+    # gets the token with the configurations for this user/room
+    if opts[:configToken].blank?
+      token = self.fetch_new_token
+      opts.merge!({ configToken: token }) unless token.blank?
+    end
+
+    # set the create time and the user id, if they exist
+    opts.merge!({ createTime: self.create_time }) unless self.create_time.blank? || options[:createTime].present?
+    opts.merge!({ userID: id }) unless id.blank? || options[:userID].present?
+
+    # Get options passed by the application, if any
+    user_opts = BigbluebuttonRails.configuration.get_join_options.call(self, user)
+    user_opts = {} if user_opts.blank?
+    opts.merge!(user_opts)
+
+    self.join_url(username, role, nil, opts)
+  end
 
   # Returns the role of the user based on the key given.
   # The return value can be <tt>:moderator</tt>, <tt>:attendee</tt>, or
@@ -236,10 +291,12 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # params:: Hash with a key :key
   def user_role(params)
     role = nil
-    if params && params.has_key?(:key)
-      if self.moderator_key == params[:key]
+    key = params.is_a?(String) ? params : (params && params.has_key?(:key) ? params[:key] : nil)
+
+    unless key.blank?
+      if self.moderator_key == key
         role = :moderator
-      elsif self.attendee_key == params[:key]
+      elsif self.attendee_key == key
         role = :attendee
       end
     end
@@ -251,8 +308,8 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # if they are have all equal values.
   # From: http://alicebobandmallory.com/articles/2009/11/02/comparing-instance-variables-in-ruby
   def instance_variables_compare(o)
-    vars = [ :@running, :@participant_count, :@moderator_count, :@attendees,
-             :@has_been_forcibly_ended, :@start_time, :@end_time ]
+    vars = [ :@running, :@participant_count, :@moderator_count, :@current_attendees,
+             :@has_been_forcibly_ended, :@end_time ]
     Hash[*vars.map { |v|
            self.instance_variable_get(v)!=o.instance_variable_get(v) ?
            [v,o.instance_variable_get(v)] : []}.flatten]
@@ -273,7 +330,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # The create logic.
   # Will create the meeting in this room unless it is already running.
   # Returns true if the meeting was created.
-  def create_meeting(user=nil, request=nil, user_opts={})
+  def create_meeting(user=nil, request=nil)
     fetch_is_running?
     unless is_running?
 
@@ -281,7 +338,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
       suppress(BigBlueButton::BigBlueButtonException) { send_end }
 
       add_domain_to_logout_url(request.protocol, request.host_with_port) unless request.nil?
-      send_create(user, user_opts)
+      send_create(user)
       true
     else
       false
@@ -324,7 +381,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
     unless self.create_time.nil?
       attrs = {
         :running => self.running,
-        :start_time => self.start_time.try(:utc)
+        :create_time => self.create_time
       }
       # note: it's important to update the 'ended' attr so the meeting is
       # reopened in case it was mistakenly considered as ended
@@ -345,7 +402,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
     end
   end
 
-  def create_meeting_record(metadata=nil)
+  def create_meeting_record(response, server, user, user_opts)
     unless get_current_meeting.present?
       if self.create_time.present?
 
@@ -353,7 +410,6 @@ class BigbluebuttonRoom < ActiveRecord::Base
         # has not yet been set as ended
         self.finish_meetings
 
-        server = BigbluebuttonRails.configuration.select_server.call(self)
         attrs = {
           room: self,
           server_url: server.url,
@@ -363,9 +419,10 @@ class BigbluebuttonRoom < ActiveRecord::Base
           recorded: self.record_meeting,
           create_time: self.create_time,
           running: self.running,
-          ended: false,
-          start_time: self.start_time.try(:utc)
+          ended: false
         }
+
+        metadata = response[:metadata]
         unless metadata.nil?
           begin
             attrs[:creator_id] = metadata[BigbluebuttonRails.configuration.metadata_user_id].to_i
@@ -375,6 +432,20 @@ class BigbluebuttonRoom < ActiveRecord::Base
             attrs[:creator_name] = nil
           end
         end
+
+        # the parameters the user might have overwritten in the create call
+        # need to be mapped to the name of the attrs in BigbluebuttMeeting
+        # note: recorded is not in the API response, so we can't just get these
+        # attributes from there
+        attrs_user = {
+          meetingid: user_opts[:meetingID],
+          name: user_opts[:name],
+          recorded: user_opts[:record],
+          creator_id: user_opts[:creator_id],
+          creator_name: user_opts[:creator_name]
+        }.delete_if { |k, v| v.nil? }
+        attrs.merge!(attrs_user)
+
         BigbluebuttonMeeting.create(attrs)
 
         Rails.logger.error "Did not create a current meeting because there was no create_time on room #{self.meetingid}"
@@ -386,15 +457,27 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   # Sets all meetings related to this room as not running
   def finish_meetings
+    to_be_finished = BigbluebuttonMeeting.where(ended: false, room_id: self.id).to_a
+    now = DateTime.now.strftime('%Q').to_i
+
     BigbluebuttonMeeting.where(ended: false)
       .where(room_id: self.id)
-      .update_all(running: false, ended: true)
+      .update_all(running: false, ended: true, finish_time: now)
 
     # in case there are inconsistent meetings marked as running
     # but that already ended
     BigbluebuttonMeeting.where(running: true, ended: true)
       .where(room_id: self.id)
-      .update_all(running: false, ended: true)
+      .update_all(running: false, ended: true, finish_time: now)
+
+    if to_be_finished.count > 0
+      # start trying to get the recording for this room
+      # since we don't have a way to know exactly when a recording is done, we
+      # have to keep polling the server for them
+      # 3 times so it tries at: 4, 9, 14 and 19
+      # no point trying more since there is a global synchronization process
+      Resque.enqueue_in(4.minutes, ::BigbluebuttonRecordingsForRoomWorker, self.id, 3)
+    end
   end
 
   # Gets a 'configToken' to use when joining the room.
@@ -411,15 +494,20 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # Triggers API call: <tt>getDefaultConfigXML</tt>.
   # Triggers API call: <tt>setConfigXML</tt>.
   def fetch_new_token
-    if self.room_options.is_modified?
+    if self.room_options.is_modified? || block_given?
       server = BigbluebuttonRails.configuration.select_server.call(self, :set_config_xml)
 
       # get the default XML we will use to create a new one
       config_xml = server.api.get_default_config_xml
 
-      # set the options on the XML
-      # returns true if something was changed
-      config_xml = self.room_options.set_on_config_xml(config_xml)
+      if block_given?
+        config_xml = yield(config_xml)
+      else
+        # set the options on the XML
+        # returns true if something was changed
+        config_xml = self.room_options.set_on_config_xml(config_xml)
+      end
+
       if config_xml
         server.update_config(config_xml)
         # get the new token for the room, and return it
@@ -481,6 +569,12 @@ class BigbluebuttonRoom < ActiveRecord::Base
     server
   end
 
+  # Short URL for this room. Can be overwritten by applications that want to use a
+  # different route.
+  def short_path
+    Rails.application.routes.url_helpers.join_bigbluebutton_room_path(self)
+  end
+
   protected
 
   def create_room_options
@@ -497,25 +591,24 @@ class BigbluebuttonRoom < ActiveRecord::Base
     @moderator_count = 0
     @running = false
     @has_been_forcibly_ended = false
-    @start_time = nil
     @end_time = nil
-    @attendees = []
+    @current_attendees = []
   end
 
   def internal_create_meeting(user=nil, user_opts={})
     opts = {
-      :record => self.record_meeting,
-      :duration => self.duration,
-      :moderatorPW => self.moderator_api_password,
-      :attendeePW => self.attendee_api_password,
-      :welcome => self.welcome_msg.blank? ? default_welcome_message : self.welcome_msg,
-      :dialNumber => self.dial_number,
-      :logoutURL => self.full_logout_url || self.logout_url,
-      :maxParticipants => self.max_participants,
-      :moderatorOnlyMessage => self.moderator_only_message,
-      :autoStartRecording => self.auto_start_recording,
-      :allowStartStopRecording => self.allow_start_stop_recording
-    }.merge(user_opts)
+      record: record_meeting,
+      duration: self.duration,
+      moderatorPW: self.moderator_api_password,
+      attendeePW: self.attendee_api_password,
+      welcome: self.welcome_msg.blank? ? default_welcome_message : self.welcome_msg,
+      dialNumber: self.dial_number,
+      logoutURL: self.full_logout_url || self.logout_url,
+      maxParticipants: self.max_participants,
+      moderatorOnlyMessage: self.moderator_only_message,
+      autoStartRecording: self.auto_start_recording,
+      allowStartStopRecording: self.allow_start_stop_recording
+    }
 
     # Set the voice bridge only if the gem is configured to do so and the voice bridge
     # is not blank.
@@ -523,8 +616,6 @@ class BigbluebuttonRoom < ActiveRecord::Base
       opts.merge!({ :voiceBridge => self.voice_bridge })
     end
 
-    opts.merge!(self.get_metadata_for_create)
-
     # Add information about the user that is creating the meeting (if any)
     unless user.nil?
       userid = user.send(BigbluebuttonRails.configuration.user_attr_id)
@@ -539,11 +630,18 @@ class BigbluebuttonRoom < ActiveRecord::Base
       opts.merge!({ "meta_#{BigbluebuttonRails.configuration.metadata_invitation_url}" => url })
     end
 
+    # Merge the metadata configured in the db
+    meta = get_metadata_for_create
+    opts.merge!(meta)
+
+    # Merge the user options, if any
+    opts.merge!(user_opts)
+
     server = BigbluebuttonRails.configuration.select_server.call(self, :create)
     server.api.request_headers = @request_headers # we need the client's IP
     response = server.api.create_meeting(self.name, self.meetingid, opts)
 
-    response
+    return server, response
   end
 
   # Returns the default welcome message to be shown in a conference in case
@@ -576,18 +674,9 @@ class BigbluebuttonRoom < ActiveRecord::Base
   end
 
   def get_metadata_for_create
-    metadata = self.metadata.inject({}) { |result, meta|
+    self.metadata.inject({}) { |result, meta|
       result["meta_#{meta.name}"] = meta.content; result
     }
-
-    dynamic_metadata = BigbluebuttonRails.configuration.get_dynamic_metadata.call(self)
-    unless dynamic_metadata.blank?
-      metadata = dynamic_metadata.inject(metadata) { |result, meta|
-        result["meta_#{meta[0]}"] = meta[1]; result
-      }
-    end
-
-    metadata
   end
 
   private

data/app/models/bigbluebutton_server.rb

@@ -57,7 +57,7 @@ class BigbluebuttonServer < ActiveRecord::Base
 
   # Schedules a recording update right after a recording server is added.
   after_create do
-    Resque.enqueue(::BigbluebuttonUpdateRecordings, self.id)
+    Resque.enqueue(::BigbluebuttonUpdateRecordingsWorker, self.id)
   end
 
   # In case there's no config created yet, build one.

data/app/views/bigbluebutton/api/error.rabl

@@ -0,0 +1,10 @@
+object false
+
+node(:errors) do
+  @errors.map do |error|
+    { :status => error.code.to_s,
+      :title => error.title,
+      :detail => error.to_s
+    }
+  end
+end

data/app/views/bigbluebutton/api/rooms/index.rabl

@@ -0,0 +1,45 @@
+object false
+
+node :links do
+  @pagination_links
+end
+
+child @rooms, :root => :data, :object_root => false, :if => lambda { |r| @rooms.size > 0 } do
+  node(:type) { |obj| api_type_of(obj) }
+  node(:id) { |obj| obj.to_param }
+
+  node :attributes do |room|
+    attrs = { }
+    [ :name, :private ].each { |attr|
+      attrs.merge!({ :"#{attr}" => room.send(attr) })
+    }
+    attrs
+  end
+
+  node :relationships, :unless => lambda { |r| r.owner.nil? } do |room|
+    owner = room.owner
+    url = polymorphic_path(owner)
+    { :owner =>
+      {
+        :data => {
+          :type => api_type_of(owner),
+          :id => owner.to_param,
+          :attributes => {
+            :name => owner.try(:name)
+          }
+        },
+        :links => {
+          :self => url
+        }
+      }
+    }
+  end
+
+  node :links do |room|
+    { self: room.short_path }
+  end
+end
+
+node :data, :if => lambda { |r| @rooms.size == 0 } do
+  []
+end