bigbluebutton_rails 1.3.0 → 1.4.0.beta1

data/app/controllers/bigbluebutton/servers_controller.rb

@@ -1,4 +1,5 @@
 class Bigbluebutton::ServersController < ApplicationController
+  include BigbluebuttonRails::InternalControllerMethods
 
   respond_to :html
   respond_to :json, :only => [:index, :show, :new, :create, :update, :destroy, :activity, :rooms]
@@ -57,17 +58,17 @@ class Bigbluebutton::ServersController < ApplicationController
   end
 
   def create
-    @server = BigbluebuttonServer.new(params[:bigbluebutton_server])
+    @server = BigbluebuttonServer.new(server_params)
 
     respond_with @server do |format|
       if @server.save
         format.html {
           message = t('bigbluebutton_rails.servers.notice.create.success')
-          redirect_to(@server, :notice => message)
+          redirect_to_using_params @server, :notice => message
         }
         format.json { render :json => @server, :status => :created }
       else
-        format.html { render :new }
+        format.html { redirect_to_params_or_render :new }
         format.json { render :json => @server.errors.full_messages, :status => :unprocessable_entity }
       end
     end
@@ -75,14 +76,14 @@ class Bigbluebutton::ServersController < ApplicationController
 
   def update
     respond_with @server do |format|
-      if @server.update_attributes(params[:bigbluebutton_server])
+      if @server.update_attributes(server_params)
         format.html {
           message = t('bigbluebutton_rails.servers.notice.update.success')
-          redirect_to(@server, :notice => message)
+          redirect_to_using_params @server, :notice => message
         }
-        format.json { head :ok }
+        format.json { render :json => true, :status => :ok }
       else
-        format.html { render :edit }
+        format.html { redirect_to_params_or_render :edit }
         format.json { render :json => @server.errors.full_messages, :status => :unprocessable_entity }
       end
     end
@@ -93,8 +94,8 @@ class Bigbluebutton::ServersController < ApplicationController
     @server.destroy
 
     respond_with do |format|
-      format.html { redirect_to(bigbluebutton_servers_url) }
-      format.json { head :ok }
+      format.html { redirect_to_using_params bigbluebutton_servers_url }
+      format.json { render :json => true, :status => :ok }
     end
   end
 
@@ -146,7 +147,7 @@ class Bigbluebutton::ServersController < ApplicationController
         if error
           render :json => { :message => message }, :status => :error
         else
-          head :ok
+          render :json => true, :status => :ok
         end
       }
     end
@@ -168,7 +169,7 @@ class Bigbluebutton::ServersController < ApplicationController
           else
             message = t('bigbluebutton_rails.servers.notice.unpublish_recordings.success')
           end
-          redirect_to(recordings_bigbluebutton_server_path(@server), :notice => message)
+          redirect_to_using_params recordings_bigbluebutton_server_path(@server), :notice => message
         }
         format.json { render :json => message }
       end
@@ -176,11 +177,23 @@ class Bigbluebutton::ServersController < ApplicationController
       respond_with do |format|
         format.html {
           flash[:error] = e.to_s[0..200]
-          redirect_to recordings_bigbluebutton_server_path(@server)
+          redirect_to_using_params recordings_bigbluebutton_server_path(@server)
         }
         format.json { render :json => e.to_s, :status => :error }
       end
     end
   end
 
+  def server_params
+    unless params[:bigbluebutton_server].nil?
+      params[:bigbluebutton_server].permit(*server_allowed_params)
+    else
+      []
+    end
+  end
+
+  def server_allowed_params
+    [ :name, :url, :version, :salt, :param ]
+  end
+
 end

data/app/helpers/bigbluebutton_rails_helper.rb

@@ -21,4 +21,24 @@ module BigbluebuttonRailsHelper
     room
   end
 
+  # Link to download the Android application from Google Play.
+  def mobile_google_play_link
+    "https://play.google.com/store/apps/details?id=air.com.mconf.mconfmobile"
+  end
+
+  # Google Play image to show together with the link to download the Android client.
+  def mobile_google_play_image
+    "badges/google_play_#{I18n.locale}.png"
+  end
+
+  # Link to download the iOS application from Apple Store.
+  def mobile_apple_store_link
+    "https://itunes.apple.com/us/app/mconf-mobile/id864391260"
+  end
+
+  # Apple Store image to show together with the link to download the iOS client.
+  def mobile_apple_store_image
+    "badges/apple_store_#{I18n.locale}.png"
+  end
+
 end

data/app/models/bigbluebutton_meeting.rb

@@ -0,0 +1,28 @@
+class BigbluebuttonMeeting < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
+  belongs_to :server, :class_name => 'BigbluebuttonServer'
+  belongs_to :room, :class_name => 'BigbluebuttonRoom'
+
+  has_one :recording,
+          :class_name => 'BigbluebuttonRecording',
+          :foreign_key => 'meeting_id',
+          :dependent => :nullify
+
+  validates :room, :presence => true
+
+  validates :meetingid, :presence => true, :length => { :minimum => 1, :maximum => 100 }
+
+  validates :start_time, :presence => true
+  validates :start_time, :uniqueness => { :scope => :room_id }
+
+  # Whether the meeting was created by the `user` or not.
+  def created_by?(user)
+    unless user.nil?
+      userid = user.send(BigbluebuttonRails.user_attr_id)
+      self.creator_id == userid
+    else
+      false
+    end
+  end
+end

data/app/models/bigbluebutton_metadata.rb

@@ -1,4 +1,6 @@
 class BigbluebuttonMetadata < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
   belongs_to :owner, :polymorphic => true, :inverse_of => :metadata
 
   validates :owner_id, :presence => true
@@ -13,8 +15,6 @@ class BigbluebuttonMetadata < ActiveRecord::Base
     :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

data/app/models/bigbluebutton_playback_format.rb

@@ -1,9 +1,9 @@
 class BigbluebuttonPlaybackFormat < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
   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

@@ -1,6 +1,9 @@
 class BigbluebuttonRecording < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
   belongs_to :server, :class_name => 'BigbluebuttonServer'
   belongs_to :room, :class_name => 'BigbluebuttonRoom'
+  belongs_to :meeting, :class_name => 'BigbluebuttonMeeting'
 
   validates :server, :presence => true
 
@@ -8,9 +11,6 @@ class BigbluebuttonRecording < ActiveRecord::Base
             :presence => true,
             :uniqueness => true
 
-  attr_accessible :recordid, :meetingid, :name, :published, :start_time,
-                  :end_time, :available
-
   has_many :metadata,
            :class_name => 'BigbluebuttonMetadata',
            :as => :owner,
@@ -69,7 +69,8 @@ class BigbluebuttonRecording < ActiveRecord::Base
 
   protected
 
-  # Adapt keys in 'hash' from bigbluebutton-api-ruby's format to ours
+  # Adapt keys in 'hash' from bigbluebutton-api-ruby's (the way they are returned by
+  # BigBlueButton's API) format to ours (more rails-like).
   def self.adapt_recording_hash(hash)
     new_hash = hash.clone
     mappings = {
@@ -104,6 +105,8 @@ class BigbluebuttonRecording < ActiveRecord::Base
     recording.available = true
     recording.room = BigbluebuttonRails.match_room_recording(data)
     recording.server = server
+    recording.description = I18n.t('bigbluebutton_rails.recordings.default.description', :time => recording.start_time.utc.to_formatted_s(:long))
+    recording.meeting = BigbluebuttonRecording.find_matching_meeting(recording)
     recording.save!
 
     sync_additional_data(recording, data)
@@ -188,4 +191,26 @@ class BigbluebuttonRecording < ActiveRecord::Base
     end
   end
 
+  # Finds the BigbluebuttonMeeting that generated this recording. The meeting is searched using
+  # the room associated with this recording and the create time of the meeting, taken from
+  # the recording's ID.
+  def self.find_matching_meeting(recording)
+    meeting = nil
+
+    unless recording.nil? or recording.room.nil?
+
+      # recordid is something like: 'dd2816950ce2f1e0a928c1a5b8d5b526e9b3e32c-1381978014526'
+      # the create time of the meeting is the timestamp at the end
+      start_time = recording.recordid.match(/-(\d*)$/)
+      unless start_time.nil?
+        start_time = start_time[1]
+        start_time = Time.at(start_time.to_i).to_datetime.utc
+        meeting = BigbluebuttonMeeting.where(:room_id => recording.room.id, :start_time => start_time).last
+        logger.info "Recording: meeting found for the recording #{recording.inspect}: #{meeting.inspect}"
+      end
+    end
+
+    meeting
+  end
+
 end

data/app/models/bigbluebutton_room.rb

@@ -1,4 +1,6 @@
 class BigbluebuttonRoom < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
   belongs_to :server, :class_name => 'BigbluebuttonServer'
   belongs_to :owner, :polymorphic => true
 
@@ -13,6 +15,18 @@ class BigbluebuttonRoom < ActiveRecord::Base
            :dependent => :destroy,
            :inverse_of => :owner
 
+  has_one :room_options,
+          :class_name => 'BigbluebuttonRoomOptions',
+          :foreign_key => 'room_id',
+          :autosave => true,
+          :dependent => :destroy
+
+  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
+
   accepts_nested_attributes_for :metadata,
     :allow_destroy => true,
     :reject_if => :all_blank
@@ -45,16 +59,12 @@ class BigbluebuttonRoom < ActiveRecord::Base
   validates :attendee_password, :presence => true, :if => :private?
   validates :moderator_password, :presence => true, :if => :private?
 
-  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,
-                  :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,
                 :has_been_forcibly_ended, :start_time, :end_time
 
   after_initialize :init
+  after_create :create_room_options
   before_validation :set_param
   before_validation :set_passwords
 
@@ -66,6 +76,13 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # Currently used to send the client's IP to the load balancer.
   attr_accessor :request_headers
 
+  # In case there's no room_options created yet, build one
+  # (happens usually when an old database is migrated).
+  def room_options_with_initialize
+    room_options_without_initialize || build_room_options
+  end
+  alias_method_chain :room_options, :initialize
+
   # Convenience method to access the attribute <tt>running</tt>
   def is_running?
     @running
@@ -105,6 +122,9 @@ class BigbluebuttonRoom < ActiveRecord::Base
       @attendees << attendee
     end
 
+    # a 'shortcut' to update meetings since we have all information we need
+    update_current_meeting(response[:metadata])
+
     response
   end
 
@@ -121,12 +141,19 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # Triggers API call: <tt>end</tt>.
   def send_end
     require_server
-    self.server.api.end_meeting(self.meetingid, self.moderator_password)
+    response = self.server.api.end_meeting(self.meetingid, self.moderator_password)
+
+    # enqueue an update in the meetings for later on
+    Resque.enqueue(::BigbluebuttonMeetingUpdater, self.id, 15.seconds)
+
+    response
   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.
+  # 'user' is the object that represents the user that is creating the meeting.
+  # 'user_opts' is a hash of parameters to override the parameters sent in the create
+  #   request. Can be passed by the application to enforce some values over the values
+  #   that are taken from the database.
   #
   # Will trigger 'select_server' to select a server where the meeting
   # will be created. If a server is selected, the model is saved.
@@ -136,14 +163,14 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # * <tt>moderator_password</tt>
   #
   # Triggers API call: <tt>create</tt>.
-  def send_create(username=nil, userid=nil)
+  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?
     self.save unless self.new_record?
     require_server
 
-    response = do_create_meeting(username, userid)
+    response = internal_create_meeting(user, user_opts)
     unless response.nil?
       self.attendee_password = response[:attendeePW]
       self.moderator_password = response[:moderatorPW]
@@ -157,19 +184,23 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # 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)
+  # 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)
+  def join_url(username, role, password=nil, options={})
     require_server
 
     case role
     when :moderator
-      self.server.api.join_meeting_url(self.meetingid, username, self.moderator_password)
+      r = self.server.api.join_meeting_url(self.meetingid, username, self.moderator_password, options)
     when :attendee
-      self.server.api.join_meeting_url(self.meetingid, username, self.attendee_password)
+      r = self.server.api.join_meeting_url(self.meetingid, username, self.attendee_password, options)
     else
-      self.server.api.join_meeting_url(self.meetingid, username, password)
+      r = self.server.api.join_meeting_url(self.meetingid, username, password, options)
     end
+
+    r.strip! unless r.nil?
+    r
   end
 
 
@@ -179,7 +210,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
   # params:: Hash with a key :password
   def user_role(params)
     role = nil
-    if params.has_key?(:password)
+    if params && params.has_key?(:password)
       if self.moderator_password == params[:password]
         role = :moderator
       elsif self.attendee_password == params[:password]
@@ -216,11 +247,11 @@ 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(username, userid=nil, request=nil)
+  def create_meeting(user=nil, request=nil, user_opts={})
     fetch_is_running?
     unless is_running?
       add_domain_to_logout_url(request.protocol, request.host_with_port) unless request.nil?
-      send_create(username, userid)
+      send_create(user, user_opts)
       true
     else
       false
@@ -249,8 +280,97 @@ class BigbluebuttonRoom < ActiveRecord::Base
     "#{SecureRandom.uuid}-#{Time.now.to_i}"
   end
 
+  # Returns the current meeting running on this room, if any.
+  def get_current_meeting
+    unless self.start_time.nil?
+      BigbluebuttonMeeting.find_by_room_id_and_start_time(self.id, self.start_time.utc)
+    else
+      nil
+    end
+  end
+
+  # Updates the current meeting associated with this room
+  def update_current_meeting(metadata=nil)
+    unless self.start_time.nil?
+      attrs = {
+        :server => self.server,
+        :meetingid => self.meetingid,
+        :name => self.name,
+        :record => self.record,
+        :running => self.running
+      }
+      unless metadata.nil?
+        begin
+          attrs[:creator_id] = metadata[BigbluebuttonRails.metadata_user_id].to_i
+          attrs[:creator_name] = metadata[BigbluebuttonRails.metadata_user_name]
+        rescue
+          attrs[:creator_id] = nil
+          attrs[:creator_name] = nil
+        end
+      end
+
+      meeting = self.get_current_meeting
+      if !meeting.nil?
+        meeting.update_attributes(attrs)
+
+      # only create a new meeting if it is running
+      elsif self.running
+        attrs.merge!({ :room => self, :start_time => self.start_time.utc })
+        meeting = BigbluebuttonMeeting.create(attrs)
+
+      end
+    else
+      # TODO: not enough information to find the meeting, do what?
+    end
+  end
+
+  # 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)
+  end
+
+  # Gets a 'configToken' to use when joining the room.
+  # Returns a string with the token generated or nil if there's no need
+  # for a token (the options set in the room are the default options or there
+  # are no options set in the room) or if an error occurred.
+  #
+  # The entire process consists in these steps:
+  # * Go to the server get the default config.xml;
+  # * Modify the config.xml based on the room options set in the room;
+  # * Go to the server set the new config.xml;
+  # * Get the token identifier and return it.
+  #
+  # Triggers API call: <tt>getDefaultConfigXML</tt>.
+  # Triggers API call: <tt>setConfigXML</tt>.
+  def fetch_new_token
+    if self.room_options.is_modified?
+
+      # get the default XML we will use to create a new one
+      config_xml = self.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 config_xml
+
+        # get the new token for the room, and return it
+        self.server.api.set_config_xml(self.meetingid, config_xml)
+      else
+        nil
+      end
+    else
+      nil
+    end
+  end
+
   protected
 
+  def create_room_options
+    BigbluebuttonRoomOptions.create(:room => self)
+  end
+
   # Every room needs a server to be used.
   # The server of a room can change during the room's lifespan, but
   # it should not change if the room is running or if it was created
@@ -299,7 +419,7 @@ class BigbluebuttonRoom < ActiveRecord::Base
     value
   end
 
-  def do_create_meeting(username=nil, userid=nil)
+  def internal_create_meeting(user=nil, user_opts={})
     opts = {
       :record => self.record,
       :duration => self.duration,
@@ -310,14 +430,25 @@ class BigbluebuttonRoom < ActiveRecord::Base
       :logoutURL => self.full_logout_url || self.logout_url,
       :maxParticipants => self.max_participants,
       :voiceBridge => self.voice_bridge
-    }.merge(self.get_metadata_for_create)
+    }.merge(user_opts)
+
+    opts.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?
+    unless user.nil?
+      userid = user.send(BigbluebuttonRails.user_attr_id)
+      username = user.send(BigbluebuttonRails.user_attr_name)
+      opts.merge!({ "meta_#{BigbluebuttonRails.metadata_user_id}" => userid })
+      opts.merge!({ "meta_#{BigbluebuttonRails.metadata_user_name}" => username })
+    end
 
     self.server.api.request_headers = @request_headers # we need the client's IP
-    self.server.api.create_meeting(self.name, self.meetingid, opts)
+    response = self.server.api.create_meeting(self.name, self.meetingid, opts)
+
+    # enqueue an update in the meetings to start now
+    Resque.enqueue(::BigbluebuttonMeetingUpdater, self.id)
+
+    response
   end
 
   # Returns the default welcome message to be shown in a conference in case

data/app/models/bigbluebutton_room_options.rb

@@ -0,0 +1,46 @@
+require 'bigbluebutton_api'
+
+class BigbluebuttonRoomOptions < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
+  belongs_to :room, :class_name => 'BigbluebuttonRoom'
+  validates :room_id, :presence => true
+
+  def get_available_layouts
+    ["Default", "Video Chat", "Meeting", "Webinar", "Lecture assistant", "Lecture"]
+  end
+
+  # Sets the attributes from the model into the config.xml passed in the arguments.
+  # If anything was modified in the XML, returns the new XML generated as string.
+  # Otherwise returns false.
+  #
+  # xml (string):: The config.xml in which the attributes will be set
+  def set_on_config_xml(xml)
+    config_xml = BigBlueButton::BigBlueButtonConfigXml.new(xml)
+    unless self.default_layout.blank?
+      config_xml.set_attribute("layout", "defaultLayout", self.default_layout, false)
+    end
+    unless self.presenter_share_only.nil?
+      config_xml.set_attribute("VideoconfModule", "presenterShareOnly", self.presenter_share_only, true)
+      config_xml.set_attribute("PhoneModule", "presenterShareOnly", self.presenter_share_only, true)
+    end
+    unless self.auto_start_video.nil?
+      config_xml.set_attribute("VideoconfModule", "autoStart", self.auto_start_video, true)
+    end
+    unless self.auto_start_audio.nil?
+      config_xml.set_attribute("PhoneModule", "autoJoin", self.auto_start_audio, true)
+    end
+    if config_xml.is_modified?
+      config_xml.as_string
+    else
+      false
+    end
+  end
+
+  # Returns true if any of the attributes was set. Is used to check whether the options
+  # have to be sent to the server (setConfigXML) or not.
+  def is_modified?
+    !self.default_layout.nil? || !self.presenter_share_only.nil? || !self.auto_start_audio.nil? ||
+    !self.auto_start_video.nil?
+  end
+end

data/app/models/bigbluebutton_server.rb

@@ -1,6 +1,8 @@
 require 'bigbluebutton_api'
 
 class BigbluebuttonServer < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
   has_many :rooms,
            :class_name => 'BigbluebuttonRoom',
            :foreign_key => 'server_id',
@@ -38,8 +40,6 @@ class BigbluebuttonServer < ActiveRecord::Base
             :presence => true,
             :inclusion => { :in => ['0.7', '0.8'] }
 
-  attr_accessible :name, :url, :version, :salt, :param
-
   # Array of <tt>BigbluebuttonMeeting</tt>
   attr_reader :meetings
 
@@ -69,6 +69,7 @@ class BigbluebuttonServer < ActiveRecord::Base
     @meetings = []
     response[:meetings].each do |attr|
       room = BigbluebuttonRoom.find_by_server_id_and_meetingid(self.id, attr[:meetingID])
+      # TODO: there might be more attributes returned by the API, review them all
       if room.nil?
         room = BigbluebuttonRoom.new(:server => self, :meetingid => attr[:meetingID],
                                      :name => attr[:meetingID], :attendee_password => attr[:attendeePW],
@@ -78,6 +79,7 @@ class BigbluebuttonServer < ActiveRecord::Base
                                :moderator_password => attr[:moderatorPW])
       end
       room.running = attr[:running]
+      room.update_current_meeting
 
       @meetings << room
     end

data/app/views/bigbluebutton/recordings/_form.html.erb

@@ -46,6 +46,10 @@
     <%= f.label :end_time %><br />
     <%= f.text_field :end_time %>
   </div>
+  <div class="field">
+    <%= f.label :description %><br />
+    <%= f.text_field :description %>
+  </div>
 
   <p>
     <b><%= BigbluebuttonRecording.human_attribute_name(:metadata) %>:</b>

data/app/views/bigbluebutton/recordings/_recordings.html.erb

@@ -22,6 +22,7 @@
       <div class="field"><label><%= BigbluebuttonRecording.human_attribute_name(:available) %></label> <%= recording.available %></div>
       <div class="field"><label><%= BigbluebuttonRecording.human_attribute_name(:start_time) %></label> <%= recording.start_time %></div>
       <div class="field"><label><%= BigbluebuttonRecording.human_attribute_name(:end_time) %></label> <%= recording.end_time %></div>
+      <div class="field"><label><%= BigbluebuttonRecording.human_attribute_name(:description) %></label> <%= recording.description %></div>
       <div class="field">
         <label><%= BigbluebuttonRecording.human_attribute_name(:metadata) %></label>
         <div>

data/app/views/bigbluebutton/recordings/show.html.erb

@@ -52,6 +52,11 @@
   <%= @recording.end_time %>
 </p>
 
+<p>
+  <b><%= BigbluebuttonRecording.human_attribute_name(:description) %>:</b>
+  <%= @recording.description %>
+</p>
+
 <p>
   <b><%= BigbluebuttonRecording.human_attribute_name(:metadata) %>:</b>
   <% @recording.metadata.each do |metadata| %>