bigbluebutton_rails 1.2.0 → 1.3.0.beta1

data/app/helpers/bigbluebutton_rails_helper.rb

@@ -1,17 +1,24 @@
 module BigbluebuttonRailsHelper
 
-  # Returns the URL for a QR-code image usign Google Charts API
+  # Returns the URL for a QR-code image using Google Charts API
   def qrcode_url(content, size=nil)
     size ||= "200x200"
     content = CGI::escape(content)
     "https://chart.googleapis.com/chart?cht=qr&chs=#{size}&chl=#{content}&choe=UTF-8"
   end
 
-  # TODO: improve it, showing all flashes
   def bbb_rails_error_explanation
-    if flash.has_key?(:error) and !flash[:error].blank?
-      content_tag(:div, flash[:error], { :id => "error_explanation" })
+    msgs = ""
+    flash.each do |key, msg|
+      msgs += content_tag(:div, msg, { :id => "error_explanation", :class => key })
     end
+    msgs.html_safe
+  end
+
+  # Setup a BigbluebuttonRoom to show in the forms
+  def setup_bigbluebutton_room(room)
+    (room.metadata.count..10).each { room.metadata.build }
+    room
   end
 
 end

data/app/models/bigbluebutton_metadata.rb

@@ -0,0 +1,43 @@
+class BigbluebuttonMetadata < ActiveRecord::Base
+  belongs_to :owner, :polymorphic => true, :inverse_of => :metadata
+
+  validates :owner_id, :presence => true
+  validates :owner_type, :presence => true
+
+  validates :name, :presence => true
+  validates :name, :format => {
+    :with => /^[a-zA-Z]+[a-zA-Z\d-]*$/,
+    :message => I18n.t('bigbluebutton_rails.metadata.errors.name_format')
+  }
+  validates :name,
+    :uniqueness => { :scope => [:owner_id, :owner_type] }
+  validate :exclusion_of_name_in_reserved_metadata_keys
+
+  attr_accessible :name, :content
+
+  # metadata keys are only invalid when the metadata belongs to a room,
+  # metadata that will be used in a 'create' call
+  # TODO: a better solution for rails >= 3.1
+  # validates :name, :exclusion => {
+  #   :in => lambda do |m|
+  #     if m.owner_type == "BigbluebuttonRoom"
+  #       BigbluebuttonRails.metadata_invalid_keys.map(&:to_s)
+  #     else
+  #       []
+  #     end
+  #   end
+  # }
+  def exclusion_of_name_in_reserved_metadata_keys
+    keys = if owner_type == "BigbluebuttonRoom"
+             BigbluebuttonRails.metadata_invalid_keys.map(&:to_s)
+           else
+             []
+           end
+    if keys.include?(name)
+      # use the same message rails would generate for :exclusion => :in
+      msg = self.errors.generate_message(:name, :exclusion, {})
+      errors.add(:name, msg)
+    end
+  end
+
+end

data/app/models/bigbluebutton_playback_format.rb

@@ -0,0 +1,9 @@
+class BigbluebuttonPlaybackFormat < ActiveRecord::Base
+  belongs_to :recording, :class_name => 'BigbluebuttonRecording'
+
+  validates :recording_id, :presence => true
+
+  validates :format_type, :presence => true
+
+  attr_accessible :recording_id, :format_type, :url, :length
+end

data/app/models/bigbluebutton_recording.rb

@@ -0,0 +1,191 @@
+class BigbluebuttonRecording < ActiveRecord::Base
+  belongs_to :server, :class_name => 'BigbluebuttonServer'
+  belongs_to :room, :class_name => 'BigbluebuttonRoom'
+
+  validates :server, :presence => true
+
+  validates :recordid,
+            :presence => true,
+            :uniqueness => true
+
+  attr_accessible :recordid, :meetingid, :name, :published, :start_time,
+                  :end_time, :available
+
+  has_many :metadata,
+           :class_name => 'BigbluebuttonMetadata',
+           :as => :owner,
+           :dependent => :destroy
+
+  has_many :playback_formats,
+           :class_name => 'BigbluebuttonPlaybackFormat',
+           :foreign_key => 'recording_id',
+           :dependent => :destroy
+
+  scope :published, where(:published => true)
+
+  def to_param
+    self.recordid
+  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
+  # already are (matching by 'recordid'). Will NOT delete recordings from the db
+  # if they are not in the array but instead mark them as unavailable.
+  # 'server' is the BigbluebuttonServer object from which the recordings
+  # were fetched.
+  #
+  # TODO: catch exceptions on creating/updating recordings
+  def self.sync(server, recordings)
+    recordings.each do |rec|
+      rec_obj = BigbluebuttonRecording.find_by_recordid(rec[:recordID])
+      rec_data = adapt_recording_hash(rec)
+      BigbluebuttonRecording.transaction do
+        if rec_obj
+          logger.info "Sync recordings: updating recording #{rec_obj.inspect}"
+          logger.debug "Sync recordings: recording data #{rec_data.inspect}"
+          self.update_recording(server, rec_obj, rec_data)
+        else
+          logger.info "Sync recordings: creating recording"
+          logger.debug "Sync recordings: recording data #{rec_data.inspect}"
+          self.create_recording(server, rec_data)
+        end
+      end
+    end
+
+    # 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)
+    else
+      BigbluebuttonRecording
+        .where(:available => true)
+        .where("recordid NOT IN (?)", recordIDs)
+        .update_all(:available => false)
+    end
+  end
+
+  protected
+
+  # Adapt keys in 'hash' from bigbluebutton-api-ruby's format to ours
+  def self.adapt_recording_hash(hash)
+    new_hash = hash.clone
+    mappings = {
+      :recordID => :recordid,
+      :meetingID => :meetingid,
+      :startTime => :start_time,
+      :endTime => :end_time
+    }
+    new_hash.keys.each { |k| new_hash[ mappings[k] ] = new_hash.delete(k) if mappings[k] }
+    new_hash
+  end
+
+  # Updates the BigbluebuttonRecording 'recording' with the data in the hash 'data'.
+  # The format expected for 'data' follows the format returned by
+  # BigBlueButtonApi#get_recordings but with the keys already converted to our format.
+  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.available = true
+    recording.save!
+
+    sync_additional_data(recording, data)
+  end
+
+  # Creates a new BigbluebuttonRecording with the data from 'data'.
+  # 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)
+    recording = BigbluebuttonRecording.create(filtered)
+    recording.available = true
+    recording.room = BigbluebuttonRails.match_room_recording(data)
+    recording.server = server
+    recording.save!
+
+    sync_additional_data(recording, data)
+  end
+
+  # Syncs data that's not directly stored in the recording itself but in
+  # associated models (e.g. metadata and playback formats).
+  # The format expected for 'data' follows the format returned by
+  # BigBlueButtonApi#get_recordings but with the keys already converted to our format.
+  def self.sync_additional_data(recording, data)
+    sync_metadata(recording, data[:metadata]) if data[:metadata]
+    if data[:playback] and data[:playback][:format]
+      sync_playback_formats(recording, data[:playback][:format])
+    end
+  end
+
+  # Syncs the metadata objects of 'recording' with the data in 'metadata'.
+  # The format expected for 'metadata' follows the format returned by
+  # BigBlueButtonApi#get_recordings but with the keys already converted to our format.
+  def self.sync_metadata(recording, metadata)
+    # keys are stored as strings in the db
+    received_metadata = metadata.clone.stringify_keys
+
+    query = { :owner_id => recording.id, :owner_type => recording.class.to_s }
+    BigbluebuttonMetadata.where(query).each do |meta_db|
+
+      # the metadata in the db is also in the received data, update it in the db
+      if received_metadata.has_key?(meta_db.name)
+        meta_db.update_attributes({ :content => received_metadata[meta_db.name] })
+        received_metadata.delete(meta_db.name)
+
+      # the metadata is not in the received data, remove from the db
+      else
+        meta_db.destroy
+      end
+    end
+
+    # for metadata that are not in the db yet
+    received_metadata.each do |name, content|
+      attrs = {
+        :name => name,
+        :content => content,
+      }
+      meta = BigbluebuttonMetadata.create(attrs)
+      meta.owner = recording
+      meta.save!
+    end
+  end
+
+  # Syncs the playback formats objects of 'recording' with the data in 'formats'.
+  # The format expected for 'formats' follows the format returned by
+  # BigBlueButtonApi#get_recordings but with the keys already converted to our format.
+  def self.sync_playback_formats(recording, formats)
+    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)
+
+    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
+
+      # the format exists in the hash, update it in the db
+      if format
+        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
+      else
+        format_db.destroy
+      end
+    end
+
+    # for 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 }
+        BigbluebuttonPlaybackFormat.create!(attrs)
+      end
+    end
+  end
+
+end

data/app/models/bigbluebutton_room.rb

@@ -2,20 +2,39 @@ class BigbluebuttonRoom < ActiveRecord::Base
   belongs_to :server, :class_name => 'BigbluebuttonServer'
   belongs_to :owner, :polymorphic => true
 
+  has_many :recordings,
+           :class_name => 'BigbluebuttonRecording',
+           :foreign_key => 'room_id',
+           :dependent => :nullify
+
+  has_many :metadata,
+           :class_name => 'BigbluebuttonMetadata',
+           :as => :owner,
+           :dependent => :destroy,
+           :inverse_of => :owner
+
+  accepts_nested_attributes_for :metadata,
+    :allow_destroy => true,
+    :reject_if => :all_blank
+
   validates :meetingid, :presence => true, :uniqueness => true,
     :length => { :minimum => 1, :maximum => 100 }
   validates :name, :presence => true, :uniqueness => true,
     :length => { :minimum => 1, :maximum => 150 }
   validates :welcome_msg, :length => { :maximum => 250 }
   validates :private, :inclusion => { :in => [true, false] }
-  validates :randomize_meetingid, :inclusion => { :in => [true, false] }
   validates :voice_bridge, :presence => true, :uniqueness => true
+  validates :record, :inclusion => { :in => [true, false] }
+
+  validates :duration,
+    :presence => true,
+    :numericality => { :only_integer => true, :greater_than_or_equal_to => 0 }
 
   validates :param,
             :presence => true,
             :uniqueness => true,
-            :length => { :minimum => 3 },
-            :format => { :with => /^[a-zA-Z\d_]+[a-zA-Z\d_-]*[a-zA-Z\d_]+$/,
+            :length => { :minimum => 1 },
+            :format => { :with => /^([a-zA-Z\d_]|[a-zA-Z\d_]+[a-zA-Z\d_-]*[a-zA-Z\d_]+)$/,
                          :message => I18n.t('bigbluebutton_rails.rooms.errors.param_format') }
 
   # Passwords are 16 character strings
@@ -28,8 +47,8 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   attr_accessible :name, :server_id, :meetingid, :attendee_password, :moderator_password,
                   :welcome_msg, :owner, :server, :private, :logout_url, :dial_number,
-                  :voice_bridge, :max_participants, :owner_id, :owner_type, :randomize_meetingid,
-                  :external, :param
+                  :voice_bridge, :max_participants, :owner_id, :owner_type,
+                  :external, :param, :record, :duration, :metadata_attributes
 
   # Note: these params need to be fetched from the server before being accessed
   attr_accessor :running, :participant_count, :moderator_count, :attendees,
@@ -37,10 +56,16 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   after_initialize :init
   before_validation :set_param
+  before_validation :set_passwords
 
   # the full logout_url used when logout_url is a relative path
   attr_accessor :full_logout_url
 
+  # HTTP headers that will be passed to the BigBlueButtonApi object to send
+  # in all GET/POST requests to a webconf server.
+  # Currently used to send the client's IP to the load balancer.
+  attr_accessor :request_headers
+
   # Convenience method to access the attribute <tt>running</tt>
   def is_running?
     @running
@@ -61,7 +86,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # * <tt>end_time</tt>
   # * <tt>attendees</tt> (array of <tt>BigbluebuttonAttendee</tt>)
   #
-  # Triggers API call: <tt>get_meeting_info</tt>.
+  # Triggers API call: <tt>getMeetingInfo</tt>.
   def fetch_meeting_info
     require_server
 
@@ -85,7 +110,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   # Fetches the BBB server to see if the meeting is running. Sets <tt>running</tt>
   #
-  # Triggers API call: <tt>is_meeting_running</tt>.
+  # Triggers API call: <tt>isMeetingRunning</tt>.
   def fetch_is_running?
     require_server
     @running = self.server.api.is_meeting_running?(self.meetingid)
@@ -93,13 +118,15 @@ class BigbluebuttonRoom < ActiveRecord::Base
 
   # Sends a call to the BBB server to end the meeting.
   #
-  # Triggers API call: <tt>end_meeting</tt>.
+  # Triggers API call: <tt>end</tt>.
   def send_end
     require_server
     self.server.api.end_meeting(self.meetingid, self.moderator_password)
   end
 
   # Sends a call to the BBB server to create the meeting.
+  # 'username' is the name of the user that is creating the meeting.
+  # 'userid' is the id of the user that is creating the meeting.
   #
   # Will trigger 'select_server' to select a server where the meeting
   # will be created. If a server is selected, the model is saved.
@@ -108,37 +135,15 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # * <tt>attendee_password</tt>
   # * <tt>moderator_password</tt>
   #
-  # Triggers API call: <tt>create_meeting</tt>.
-  def send_create
-    # updates the server whenever a meeting will be created
+  # Triggers API call: <tt>create</tt>.
+  def send_create(username=nil, userid=nil)
+    # 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?
     self.save unless self.new_record?
     require_server
 
-    unless self.randomize_meetingid
-      response = do_create_meeting
-
-    # create a new random meetingid everytime create fails with "duplicateWarning"
-    else
-      self.meetingid = random_meetingid
-
-      count = 0
-      try_again = true
-      while try_again and count < 10
-        response = do_create_meeting
-
-        count += 1
-        try_again = false
-        unless response.nil?
-          if response[:returncode] && response[:messageKey] == "duplicateWarning"
-            self.meetingid = random_meetingid
-            try_again = true
-          end
-        end
-
-      end
-    end
-
+    response = do_create_meeting(username, userid)
     unless response.nil?
       self.attendee_password = response[:attendeePW]
       self.moderator_password = response[:moderatorPW]
@@ -208,25 +213,18 @@ class BigbluebuttonRoom < ActiveRecord::Base
     self.param
   end
 
-  # The join logic
-  # A moderator can create the meeting and join
-  # An attendee can only join if the meeting is running
-  def perform_join(username, role, request=nil)
+  # 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(username, userid=nil, request=nil)
     fetch_is_running?
-
-    # if the user is a moderator, create the room (if needed) and join it
-    if role == :moderator
+    unless is_running?
       add_domain_to_logout_url(request.protocol, request.host_with_port) unless request.nil?
-      send_create unless is_running?
-      ret = join_url(username, role)
-
-    # normal user only joins if the conference is running
-    # if it's not, wait for a moderator to create the conference
+      send_create(username, userid)
+      true
     else
-      ret = join_url(username, role) if is_running?
+      false
     end
-
-    ret
   end
 
   # add a domain name and/or protocol to the logout_url if needed
@@ -244,6 +242,13 @@ class BigbluebuttonRoom < ActiveRecord::Base
     end
   end
 
+  def unique_meetingid
+    # GUID
+    # Has to be globally unique in case more that one bigbluebutton_rails application is using
+    # the same web conference server.
+    "#{SecureRandom.uuid}-#{Time.now.to_i}"
+  end
+
   protected
 
   # Every room needs a server to be used.
@@ -269,9 +274,11 @@ class BigbluebuttonRoom < ActiveRecord::Base
   end
 
   def init
-    self[:meetingid] ||= random_meetingid
+    self[:meetingid] ||= unique_meetingid
     self[:voice_bridge] ||= random_voice_bridge
 
+    @request_headers = {}
+
     # fetched attributes
     @participant_count = 0
     @moderator_count = 0
@@ -282,15 +289,6 @@ class BigbluebuttonRoom < ActiveRecord::Base
     @attendees = []
   end
 
-  def random_meetingid
-    # TODO temporarily using the name to get a friendlier meetingid
-    if self[:name].blank?
-      SecureRandom.hex(8)
-    else
-      self[:name] + '-' + SecureRandom.random_number(9999).to_s
-    end
-  end
-
   def random_voice_bridge
     value = (70000 + SecureRandom.random_number(9999)).to_s
     count = 1
@@ -301,14 +299,24 @@ class BigbluebuttonRoom < ActiveRecord::Base
     value
   end
 
-  def do_create_meeting
-    msg = (self.welcome_msg.nil? or self.welcome_msg.empty?) ? default_welcome_message : self.welcome_msg
+  def do_create_meeting(username=nil, userid=nil)
     opts = {
-      :moderatorPW => self.moderator_password, :attendeePW => self.attendee_password,
-      :welcome => msg, :dialNumber => self.dial_number,
+      :record => self.record,
+      :duration => self.duration,
+      :moderatorPW => self.moderator_password,
+      :attendeePW => self.attendee_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
-    }
+      :maxParticipants => self.max_participants,
+      :voiceBridge => self.voice_bridge
+    }.merge(self.get_metadata_for_create)
+
+    # Add information about the user that is creating the meeting (if any)
+    opts.merge!({ "meta_#{BigbluebuttonRails.metadata_user_id}" => userid }) unless userid.nil?
+    opts.merge!({ "meta_#{BigbluebuttonRails.metadata_user_name}" => username }) unless username.nil?
+
+    self.server.api.request_headers = @request_headers # we need the client's IP
     self.server.api.create_meeting(self.name, self.meetingid, opts)
   end
 
@@ -327,4 +335,22 @@ class BigbluebuttonRoom < ActiveRecord::Base
     end
   end
 
+  # When setting a room as private we generate passwords in case they don't exist.
+  def set_passwords
+    if self.private_changed? and self.private
+      if self.moderator_password.blank?
+        self.moderator_password = SecureRandom.hex(4)
+      end
+      if self.attendee_password.blank?
+        self.attendee_password = SecureRandom.hex(4)
+      end
+    end
+  end
+
+  def get_metadata_for_create
+    self.metadata.inject({}) { |result, meta|
+      result["meta_#{meta.name}"] = meta.content; result
+    }
+  end
+
 end