bigbluebutton_rails 1.4.0 → 2.0.0

data/app/models/bigbluebutton_recording.rb

@@ -21,12 +21,17 @@ class BigbluebuttonRecording < ActiveRecord::Base
            :foreign_key => 'recording_id',
            :dependent => :destroy
 
-  scope :published, where(:published => true)
+  scope :published, -> { where(:published => true) }
 
   def to_param
     self.recordid
   end
 
+  def default_playback_format
+    playback_formats.joins(:playback_type)
+      .where("bigbluebutton_playback_types.default = ?", true).first
+  end
+
   # Syncs the recordings in the db with the array of recordings in 'recordings',
   # as received from BigBlueButtonApi#get_recordings.
   # Will add new recordings that are not in the db yet and update the ones that
@@ -56,14 +61,14 @@ class BigbluebuttonRecording < ActiveRecord::Base
     # set as unavailable the recordings that are not in 'recordings'
     recordIDs = recordings.map{ |rec| rec[:recordID] }
     if recordIDs.length <= 0 # empty response
-      BigbluebuttonRecording
-        .where(:available => true)
-        .update_all(:available => false)
+      BigbluebuttonRecording.
+        where(available: true, server: server).
+        update_all(available: false)
     else
-      BigbluebuttonRecording
-        .where(:available => true)
-        .where("recordid NOT IN (?)", recordIDs)
-        .update_all(:available => false)
+      BigbluebuttonRecording.
+        where(available: true, server: server).
+        where.not(recordid: recordIDs).
+        update_all(available: false)
     end
   end
 
@@ -89,7 +94,7 @@ class BigbluebuttonRecording < ActiveRecord::Base
   def self.update_recording(server, recording, data)
     recording.server = server
     recording.room = BigbluebuttonRails.match_room_recording(data)
-    recording.attributes = data.slice(:meetingid, :name, :published, :start_time, :end_time)
+    recording.attributes = data.slice(:meetingid, :name, :published, :start_time, :end_time, :size)
     recording.available = true
     recording.save!
 
@@ -100,7 +105,7 @@ class BigbluebuttonRecording < ActiveRecord::Base
   # The format expected for 'data' follows the format returned by
   # BigBlueButtonApi#get_recordings but with the keys already converted to our format.
   def self.create_recording(server, data)
-    filtered = data.slice(:recordid, :meetingid, :name, :published, :start_time, :end_time)
+    filtered = data.slice(:recordid, :meetingid, :name, :published, :start_time, :end_time, :size)
     recording = BigbluebuttonRecording.create(filtered)
     recording.available = true
     recording.room = BigbluebuttonRails.match_room_recording(data)
@@ -163,16 +168,16 @@ class BigbluebuttonRecording < ActiveRecord::Base
     formats_copy = formats.clone
 
     # make it an array if it's a hash with a single format
-    formats_copy = [ formats_copy ] if formats_copy.is_a?(Hash)
+    formats_copy = [formats_copy] if formats_copy.is_a?(Hash)
 
-    BigbluebuttonPlaybackFormat.where(:recording_id => recording.id).each do |format_db|
-      format = formats_copy.select{ |d|
-        !d[:type].blank? and d[:type] == format_db.format_type
-      }.first
+    BigbluebuttonPlaybackFormat.where(recording_id: recording.id).each do |format_db|
+      format = formats_copy.select do |d|
+        !d[:type].blank? && d[:type] == format_db.format_type
+      end.first
 
       # the format exists in the hash, update it in the db
       if format
-        format_db.update_attributes({ :url => format[:url], :length => format[:length] })
+        format_db.update_attributes({ url: format[:url], length: format[:length] })
         formats_copy.delete(format)
 
       # the format is not in the hash, remove from the db
@@ -181,14 +186,28 @@ class BigbluebuttonRecording < ActiveRecord::Base
       end
     end
 
-    # for formats that are not in the db yet
+    # create the formats that are not in the db yet
     formats_copy.each do |format|
       unless format[:type].blank?
-        attrs = { :recording_id => recording.id, :format_type => format[:type],
-          :url => format[:url], :length => format[:length].to_i }
+        playback_type = BigbluebuttonPlaybackType.find_by_identifier(format[:type])
+        if playback_type.nil?
+          attrs = { identifier: format[:type], visible: true }
+          playback_type = BigbluebuttonPlaybackType.create!(attrs)
+        end
+
+        attrs = { recording_id: recording.id, url: format[:url],
+                  length: format[:length].to_i, playback_type_id: playback_type.id }
         BigbluebuttonPlaybackFormat.create!(attrs)
       end
     end
+
+    cleanup_playback_types
+  end
+
+  # Remove the unused playback types from the list.
+  def self.cleanup_playback_types
+    ids = BigbluebuttonPlaybackFormat.uniq.pluck(:playback_type_id)
+    BigbluebuttonPlaybackType.destroy_all(['id NOT IN (?)', ids])
   end
 
   # Finds the BigbluebuttonMeeting that generated this recording. The meeting is searched using

data/app/models/bigbluebutton_room.rb

@@ -1,8 +1,9 @@
 class BigbluebuttonRoom < ActiveRecord::Base
   include ActiveModel::ForbiddenAttributesProtection
 
-  belongs_to :server, :class_name => 'BigbluebuttonServer'
-  belongs_to :owner, :polymorphic => true
+  belongs_to :owner, polymorphic: true
+
+  belongs_to :server, class_name: 'BigbluebuttonServer'
 
   has_many :recordings,
            :class_name => 'BigbluebuttonRecording',
@@ -24,8 +25,8 @@ class BigbluebuttonRoom < ActiveRecord::Base
   delegate :default_layout, :default_layout=, :to => :room_options
   delegate :presenter_share_only, :presenter_share_only=, :to => :room_options
   delegate :auto_start_video, :auto_start_video=, :to => :room_options
-  delegate :auto_start_audio, :auto_start_audio=, :to => :room_options 
-  delegate :get_available_layouts, :to => :room_options
+  delegate :auto_start_audio, :auto_start_audio=, :to => :room_options
+  delegate :background, :background=, :to => :room_options
 
   accepts_nested_attributes_for :metadata,
     :allow_destroy => true,
@@ -33,12 +34,11 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   validates :meetingid, :presence => true, :uniqueness => true,
     :length => { :minimum => 1, :maximum => 100 }
-  validates :name, :presence => true, :uniqueness => true,
+  validates :name, :presence => true,
     :length => { :minimum => 1, :maximum => 150 }
   validates :welcome_msg, :length => { :maximum => 250 }
   validates :private, :inclusion => { :in => [true, false] }
-  validates :voice_bridge, :presence => true, :uniqueness => true
-  validates :record, :inclusion => { :in => [true, false] }
+  validates :record_meeting, :inclusion => { :in => [true, false] }
 
   validates :duration,
     :presence => true,
@@ -48,16 +48,16 @@ class BigbluebuttonRoom < ActiveRecord::Base
             :presence => true,
             :uniqueness => true,
             :length => { :minimum => 1 },
-            :format => { :with => /^([a-zA-Z\d_]|[a-zA-Z\d_]+[a-zA-Z\d_-]*[a-zA-Z\d_]+)$/,
+            :format => { :with => /\A([a-zA-Z\d_]|[a-zA-Z\d_]+[a-zA-Z\d_-]*[a-zA-Z\d_]+)\z/,
                          :message => I18n.t('bigbluebutton_rails.rooms.errors.param_format') }
 
   # Passwords are 16 character strings
   # See http://groups.google.com/group/bigbluebutton-dev/browse_thread/thread/9be5aae1648bcab?pli=1
-  validates :attendee_password, :length => { :maximum => 16 }
-  validates :moderator_password, :length => { :maximum => 16 }
+  validates :attendee_key, :length => { :maximum => 16 }
+  validates :moderator_key, :length => { :maximum => 16 }
 
-  validates :attendee_password, :presence => true, :if => :private?
-  validates :moderator_password, :presence => true, :if => :private?
+  validates :attendee_key, :presence => true, :if => :private?
+  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,
@@ -66,7 +66,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   after_initialize :init
   after_create :create_room_options
   before_validation :set_param
-  before_validation :set_passwords
+  before_validation :set_keys
 
   # the full logout_url used when logout_url is a relative path
   attr_accessor :full_logout_url
@@ -105,9 +105,9 @@ class BigbluebuttonRoom < ActiveRecord::Base
   #
   # Triggers API call: <tt>getMeetingInfo</tt>.
   def fetch_meeting_info
-    require_server
+    require_server :get_meeting_info
 
-    response = self.server.api.get_meeting_info(self.meetingid, self.moderator_password)
+    response = self.server.api.get_meeting_info(self.meetingid, self.moderator_api_password)
 
     @participant_count = response[:participantCount]
     @moderator_count = response[:moderatorCount]
@@ -132,7 +132,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   #
   # Triggers API call: <tt>isMeetingRunning</tt>.
   def fetch_is_running?
-    require_server
+    require_server :is_meeting_running
     @running = self.server.api.is_meeting_running?(self.meetingid)
   end
 
@@ -140,8 +140,8 @@ class BigbluebuttonRoom < ActiveRecord::Base
   #
   # Triggers API call: <tt>end</tt>.
   def send_end
-    require_server
-    response = self.server.api.end_meeting(self.meetingid, self.moderator_password)
+    require_server :end
+    response = self.server.api.end_meeting(self.meetingid, self.moderator_api_password)
 
     # enqueue an update in the meetings for later on
     Resque.enqueue(::BigbluebuttonMeetingUpdater, self.id, 15.seconds)
@@ -159,21 +159,25 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # will be created. If a server is selected, the model is saved.
   #
   # With the response, updates the following attributes:
-  # * <tt>attendee_password</tt>
-  # * <tt>moderator_password</tt>
+  # * <tt>attendee_api_password</tt>
+  # * <tt>moderator_api_password</tt>
   #
   # Triggers API call: <tt>create</tt>.
   def send_create(user=nil, user_opts={})
     # updates the server whenever a meeting will be created and guarantees it has a meetingid
-    self.server = select_server
-    self.meetingid = unique_meetingid() if self.meetingid.nil?
+    require_server :create
+
+    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?
-    require_server
 
     response = internal_create_meeting(user, user_opts)
     unless response.nil?
-      self.attendee_password = response[:attendeePW]
-      self.moderator_password = response[:moderatorPW]
+      self.attendee_api_password = response[:attendeePW]
+      self.moderator_api_password = response[:moderatorPW]
+      self.create_time = response[:createTime]
+      self.voice_bridge = response[:voiceBridge] if response.has_key?(:voiceBridge)
       self.save unless self.new_record?
     end
 
@@ -183,20 +187,20 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # Returns the URL to join this room.
   # username:: Name of the user
   # role:: Role of the user in this room. Can be <tt>[:moderator, :attendee]</tt>
-  # password:: Password to be use (in case role == nil)
+  # key:: Key to be use (in case role == nil)
   # options:: Additional options to use when generating the URL
   #
   # Uses the API but does not require a request to the server.
-  def join_url(username, role, password=nil, options={})
-    require_server
+  def join_url(username, role, key=nil, options={})
+    require_server :join_meeting_url
 
     case role
     when :moderator
-      r = self.server.api.join_meeting_url(self.meetingid, username, self.moderator_password, options)
+      r = self.server.api.join_meeting_url(self.meetingid, username, self.moderator_api_password, options)
     when :attendee
-      r = self.server.api.join_meeting_url(self.meetingid, username, self.attendee_password, options)
+      r = self.server.api.join_meeting_url(self.meetingid, username, self.attendee_api_password, options)
     else
-      r = self.server.api.join_meeting_url(self.meetingid, username, password, options)
+      r = self.server.api.join_meeting_url(self.meetingid, username, map_key_to_internal_password(key), options)
     end
 
     r.strip! unless r.nil?
@@ -204,16 +208,16 @@ class BigbluebuttonRoom < ActiveRecord::Base
   end
 
 
-  # Returns the role of the user based on the password given.
+  # Returns the role of the user based on the key given.
   # The return value can be <tt>:moderator</tt>, <tt>:attendee</tt>, or
-  # nil if the password given does not match any of the room passwords.
-  # params:: Hash with a key :password
+  # nil if the key given does not match any of the room keys.
+  # params:: Hash with a key :key
   def user_role(params)
     role = nil
-    if params && params.has_key?(:password)
-      if self.moderator_password == params[:password]
+    if params && params.has_key?(:key)
+      if self.moderator_key == params[:key]
         role = :moderator
-      elsif self.attendee_password == params[:password]
+      elsif self.attendee_key == params[:key]
         role = :attendee
       end
     end
@@ -250,6 +254,10 @@ class BigbluebuttonRoom < ActiveRecord::Base
   def create_meeting(user=nil, request=nil, user_opts={})
     fetch_is_running?
     unless is_running?
+
+      # in case the meeting is not running but it's still in memory
+      suppress(BigBlueButton::BigBlueButtonException) { send_end }
+
       add_domain_to_logout_url(request.protocol, request.host_with_port) unless request.nil?
       send_create(user, user_opts)
       true
@@ -296,7 +304,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
         :server => self.server,
         :meetingid => self.meetingid,
         :name => self.name,
-        :record => self.record,
+        :recorded => self.record_meeting,
         :running => self.running
       }
       unless metadata.nil?
@@ -326,9 +334,9 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   # Sets all meetings related to this room as not running
   def finish_meetings
-    BigbluebuttonMeeting.where(:running => true)
-      .find_by_room_id(room_id)
-      .update_attributes(:running => false)
+    BigbluebuttonMeeting.where(running: true)
+      .where(room_id: self.id)
+      .update_all(running: false)
   end
 
   # Gets a 'configToken' to use when joining the room.
@@ -354,7 +362,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
       # returns true if something was changed
       config_xml = self.room_options.set_on_config_xml(config_xml)
       if config_xml
-
+        self.server.update_config(config_xml)
         # get the new token for the room, and return it
         self.server.api.set_config_xml(self.meetingid, config_xml)
       else
@@ -365,6 +373,33 @@ class BigbluebuttonRoom < ActiveRecord::Base
     end
   end
 
+  def available_layouts
+    server.present? ? server.available_layouts : []
+  end
+
+  def available_layouts_names
+    server.present? ? server.available_layouts_names : []
+  end
+
+  def available_layouts_for_select
+    server.present? ? server.available_layouts_for_select : []
+  end
+
+  # Generates a new dial number following `pattern` and saves it in the room, returning
+  # the results of `update_attributes`.
+  # Will always generate a unique number. Tries several times if the number already
+  # exists and returns `nil` in case it wasn't possible to generate a unique value.
+  def generate_dial_number!(pattern=nil)
+    pattern ||= 'xxxx-xxxx'
+    20.times do
+      dn = BigbluebuttonRails::DialNumber.randomize(pattern)
+      if BigbluebuttonRoom.where(dial_number: dn).empty?
+        return self.update_attributes(dial_number: dn)
+      end
+    end
+    nil
+  end
+
   protected
 
   def create_room_options
@@ -377,25 +412,44 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # but not yet ended.
   # Any action that requires a server should call 'require_server' before
   # anything else.
-  def require_server
+  # This method will automatically select a server if the room has no server
+  # set on it yet.
+  def require_server(api_method=nil)
+    selected_server = select_server(api_method)
+    unless selected_server.nil?
+      self.server = selected_server
+      self.save if selected_server && !self.new_record?
+    end
     if self.server.nil?
-      msg = I18n.t('bigbluebutton_rails.rooms.errors.server.not_set')
+      msg = I18n.t('bigbluebutton_rails.rooms.errors.server.nil')
       raise BigbluebuttonRails::ServerRequired.new(msg)
     end
   end
 
+  # Selects the server with less rooms in it in case this room has no server
+  # set to it yet. Returns nil if there are no servers to select or if the
+  # room already has a server associated to it.
+  #
   # This method can be overridden to change the way the server is selected
-  # before a room is created
-  # This one selects the server with less rooms in it
-  def select_server
-    BigbluebuttonServer.
-      select("bigbluebutton_servers.*, count(bigbluebutton_rooms.id) as room_count").
-      joins(:rooms).group(:server_id).order("room_count ASC").first
+  # before a room is used. `api_method` contains the API method that is being
+  # called. Any server returned here will be used. If no server is returned, the
+  # room will continue with its current server (if any).
+  # One good example is to always select a new server when a meeting is being
+  # created (in case `api_method` is `:create`), making this a simple load
+  # balancing tool that can work well in simple cases.
+  def select_server(api_method=nil)
+    if self.server.nil?
+      BigbluebuttonServer.
+        select("bigbluebutton_servers.*, count(bigbluebutton_rooms.id) as room_count").
+        joins("LEFT JOIN bigbluebutton_rooms ON bigbluebutton_servers.id = bigbluebutton_rooms.server_id").
+        group(:server_id).order("room_count ASC").first
+    else
+      nil
+    end
   end
 
   def init
     self[:meetingid] ||= unique_meetingid
-    self[:voice_bridge] ||= random_voice_bridge
 
     @request_headers = {}
 
@@ -409,29 +463,27 @@ class BigbluebuttonRoom < ActiveRecord::Base
     @attendees = []
   end
 
-  def random_voice_bridge
-    value = (70000 + SecureRandom.random_number(9999)).to_s
-    count = 1
-    while not BigbluebuttonRoom.find_by_voice_bridge(value).nil? and count < 10
-      count += 1
-      value = (70000 + SecureRandom.random_number(9999)).to_s
-    end
-    value
-  end
-
   def internal_create_meeting(user=nil, user_opts={})
     opts = {
-      :record => self.record,
+      :record => self.record_meeting,
       :duration => self.duration,
-      :moderatorPW => self.moderator_password,
-      :attendeePW => self.attendee_password,
+      :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,
-      :voiceBridge => self.voice_bridge
+      :moderatorOnlyMessage => self.moderator_only_message,
+      :autoStartRecording => self.auto_start_recording,
+      :allowStartStopRecording => self.allow_start_stop_recording
     }.merge(user_opts)
 
+    # Set the voice bridge only if the gem is configured to do so and the voice bridge
+    # is not blank.
+    if BigbluebuttonRails.use_local_voice_bridges && !self.voice_bridge.blank?
+      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)
@@ -442,6 +494,12 @@ class BigbluebuttonRoom < ActiveRecord::Base
       opts.merge!({ "meta_#{BigbluebuttonRails.metadata_user_name}" => username })
     end
 
+    # Add the invitation URL, if any
+    invitation_url = self.try(BigbluebuttonRails.invitation_url_method)
+    unless invitation_url.nil?
+      opts.merge!({ "meta_#{BigbluebuttonRails.metadata_invitation_url}" => invitation_url })
+    end
+
     self.server.api.request_headers = @request_headers # we need the client's IP
     response = self.server.api.create_meeting(self.name, self.meetingid, opts)
 
@@ -455,8 +513,11 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # there's no message set in this room.
   # Can be used to easily set a default message format for all rooms.
   def default_welcome_message
-    I18n.t('bigbluebutton_rails.rooms.default_welcome_msg',
-           :name => self.name, :voice_number => self.voice_bridge)
+    if self.dial_number.present?
+      I18n.t('bigbluebutton_rails.rooms.default_welcome_msg_dial_number')
+    else
+      I18n.t('bigbluebutton_rails.rooms.default_welcome_msg')
+    end
   end
 
   # if :param wasn't set, sets it as :name downcase and parameterized
@@ -466,14 +527,14 @@ class BigbluebuttonRoom < ActiveRecord::Base
     end
   end
 
-  # When setting a room as private we generate passwords in case they don't exist.
-  def set_passwords
+  # When setting a room as private we generate keys in case they don't exist.
+  def set_keys
     if self.private_changed? and self.private
-      if self.moderator_password.blank?
-        self.moderator_password = SecureRandom.hex(4)
+      if self.moderator_key.blank?
+        self.moderator_key = SecureRandom.hex(4)
       end
-      if self.attendee_password.blank?
-        self.attendee_password = SecureRandom.hex(4)
+      if self.attendee_key.blank?
+        self.attendee_key = SecureRandom.hex(4)
       end
     end
   end
@@ -484,4 +545,20 @@ class BigbluebuttonRoom < ActiveRecord::Base
     }
   end
 
+  private
+
+  def internal_password
+    SecureRandom.uuid
+  end
+
+  def map_key_to_internal_password(key)
+    if key == self.attendee_key
+      self.attendee_api_password
+    elsif key == self.moderator_key
+      self.moderator_api_password
+    else
+      nil
+    end
+  end
+
 end