bigbluebutton_rails 2.2.0 → 2.3.0

data/app/controllers/bigbluebutton/playback_types_controller.rb

@@ -2,7 +2,6 @@ class Bigbluebutton::PlaybackTypesController < ApplicationController
   include BigbluebuttonRails::InternalControllerMethods
 
   respond_to :html
-  respond_to :json
   before_filter :find_playback_type, only: [:update]
 
   def update
@@ -12,13 +11,11 @@ class Bigbluebutton::PlaybackTypesController < ApplicationController
           message = t('bigbluebutton_rails.playback_types.notice.update.success')
           redirect_to_using_params request.referer, :notice => message
         }
-        format.json { render :json => true, :status => :ok }
       else
         format.html {
           flash[:error] = @playback_type.errors.full_messages.join(", ")
           redirect_to_using_params request.referer
         }
-        format.json { render :json => @playback_type.errors.full_messages, :status => :unprocessable_entity }
       end
     end
   end

data/app/controllers/bigbluebutton/recordings_controller.rb

@@ -2,11 +2,21 @@ class Bigbluebutton::RecordingsController < ApplicationController
   include BigbluebuttonRails::InternalControllerMethods
 
   respond_to :html
-  respond_to :json, :only => [:index, :show, :update, :destroy, :publish, :unpublish]
   before_filter :find_recording, :except => [:index]
   before_filter :check_for_server, :only => [:publish, :unpublish]
   before_filter :find_playback, :only => [:play]
 
+  layout :determine_layout
+
+  def determine_layout
+    case params[:action].to_sym
+    when :play
+      false
+    else
+      'application'
+    end
+  end
+
   def index
     @recordings ||= BigbluebuttonRecording.all
     respond_with(@recordings)
@@ -27,10 +37,8 @@ class Bigbluebutton::RecordingsController < ApplicationController
           message = t('bigbluebutton_rails.recordings.notice.update.success')
           redirect_to_using_params @recording, :notice => message
         }
-        format.json { render :json => true, :status => :ok }
       else
         format.html { redirect_to_params_or_render :edit }
-        format.json { render :json => @recording.errors.full_messages, :status => :unprocessable_entity }
       end
     end
   end
@@ -60,26 +68,29 @@ class Bigbluebutton::RecordingsController < ApplicationController
           redirect_to_using_params bigbluebutton_recordings_url, :notice => message
         end
       }
-      format.json {
-        if error
-          render :json => { :message => message }, :status => :error
-        else
-          render :json => { :message => message }
-        end
-      }
     end
   end
 
   def play
-    respond_with do |format|
-      format.html {
-        if @playback
-          redirect_to @playback.url
+    if @recording.present?
+      if @playback
+        if BigbluebuttonRails.configuration.playback_url_authentication
+          uri = @recording.token_url(bigbluebutton_user, request.remote_ip, @playback)
+          @playback_url = uri
         else
-          flash[:error] = t('bigbluebutton_rails.recordings.errors.play.no_format')
-          redirect_to_using_params bigbluebutton_recording_url(@recording)
+          @playback_url = @playback.url
         end
-      }
+        if @playback.downloadable? || !BigbluebuttonRails.configuration.playback_iframe
+          redirect_to @playback_url
+        end
+        # else will render the default 'play' view
+      else
+        flash[:error] = t('bigbluebutton_rails.recordings.errors.play.no_format')
+        redirect_to_using_params bigbluebutton_recording_url(@recording)
+      end
+    else
+      flash[:error] = t('bigbluebutton_rails.recordings.errors.destroyed')
+      redirect_to my_home_path
     end
   end
 
@@ -105,7 +116,6 @@ class Bigbluebutton::RecordingsController < ApplicationController
           flash[:error] = message
           redirect_to bigbluebutton_recording_path(@recording)
         }
-        format.json { render :json => message, :status => :error }
       end
       false
     else
@@ -126,7 +136,6 @@ class Bigbluebutton::RecordingsController < ApplicationController
         format.html {
           redirect_to_using_params bigbluebutton_recording_path(@recording), :notice => message
         }
-        format.json { render :json => message }
       end
     rescue BigBlueButton::BigBlueButtonException => e
       respond_with do |format|
@@ -134,7 +143,6 @@ class Bigbluebutton::RecordingsController < ApplicationController
           flash[:error] = e.to_s[0..200]
           redirect_to_using_params bigbluebutton_recording_path(@recording)
         }
-        format.json { render :json => e.to_s[0..200], :status => :error }
       end
     end
   end
@@ -154,11 +162,17 @@ class Bigbluebutton::RecordingsController < ApplicationController
   protected
 
   def find_playback
-    if params[:type]
-      @playback = @recording.playback_formats.where(:playback_type_id => BigbluebuttonPlaybackType.find_by_identifier(params[:type])).first
+    if @recording.present?
+      if params[:type]
+        @playback = @recording.playback_formats.where(:playback_type_id => BigbluebuttonPlaybackType.find_by_identifier(params[:type])).first
+      else
+        @playback = @recording.default_playback_format || @recording.playback_formats.first
+      end
     else
-      @playback = @recording.default_playback_format || @recording.playback_formats.first
+      flash[:error] = t('bigbluebutton_rails.recordings.errors.destroyed')
+      redirect_to my_home_path
     end
+
   end
 
 end

data/app/controllers/bigbluebutton/rooms_controller.rb

@@ -14,8 +14,8 @@ class Bigbluebutton::RoomsController < ApplicationController
   before_filter :join_check_can_create, :only => :join
   before_filter :join_check_redirect_to_mobile, :only => :join
 
-  respond_to :html, :except => :running
-  respond_to :json, :only => [:running, :show, :new, :index, :create, :update]
+  respond_to :html, except: :running
+  respond_to :json, only: :running
 
   def index
     @rooms ||= BigbluebuttonRoom.all
@@ -50,15 +50,11 @@ class Bigbluebutton::RoomsController < ApplicationController
         format.html {
           redirect_to_using_params bigbluebutton_room_path(@room), :notice => message
         }
-        format.json {
-          render :json => { :message => message }, :status => :created
-        }
       else
         format.html {
           message = t('bigbluebutton_rails.rooms.notice.create.failure')
           redirect_to_params_or_render :new, :error => message
         }
-        format.json { render :json => @room.errors.full_messages, :status => :unprocessable_entity }
       end
     end
   end
@@ -70,13 +66,11 @@ class Bigbluebutton::RoomsController < ApplicationController
         format.html {
           redirect_to_using_params bigbluebutton_room_path(@room), :notice => message
         }
-        format.json { render :json => { :message => message } }
       else
         format.html {
           message = t('bigbluebutton_rails.rooms.notice.update.failure')
           redirect_to_params_or_render :edit, :error => message
         }
-        format.json { render :json => @room.errors.full_messages, :status => :unprocessable_entity }
       end
     end
   end
@@ -100,13 +94,6 @@ class Bigbluebutton::RoomsController < ApplicationController
         flash[:error] = message if error
         redirect_to_using_params bigbluebutton_rooms_url
       }
-      format.json {
-        if error
-          render :json => { :message => message }, :status => :error
-        else
-          render :json => { :message => message }
-        end
-      }
     end
   end
 
@@ -163,14 +150,12 @@ class Bigbluebutton::RoomsController < ApplicationController
           flash[:error] = message
           redirect_to_using_params :back
         }
-        format.json { render :json => message, :status => :error }
       end
     else
       respond_with do |format|
         format.html {
           redirect_to_using_params bigbluebutton_room_path(@room), :notice => message
         }
-        format.json { render :json => message }
       end
     end
 
@@ -224,7 +209,6 @@ class Bigbluebutton::RoomsController < ApplicationController
       message = t('bigbluebutton_rails.rooms.notice.generate_dial_number.success')
       respond_with do |format|
         format.html { redirect_to_using_params :back, notice: message }
-        format.json { render json: true, status: :ok }
       end
     else
       message = t('bigbluebutton_rails.rooms.errors.generate_dial_number.not_unique')
@@ -233,7 +217,6 @@ class Bigbluebutton::RoomsController < ApplicationController
           flash[:error] = message
           redirect_to_using_params :back
         }
-        format.json { render json: { message: message }, status: :error }
       end
     end
   end
@@ -241,7 +224,7 @@ class Bigbluebutton::RoomsController < ApplicationController
   protected
 
   def find_room
-    @room ||= BigbluebuttonRoom.find_by_param(params[:id])
+    @room ||= BigbluebuttonRoom.find_by(param: params[:id])
   end
 
   def set_request_headers
@@ -336,8 +319,7 @@ class Bigbluebutton::RoomsController < ApplicationController
       # first check if we have to create the room and if the user can do it
       unless @room.fetch_is_running?
         if bigbluebutton_can_create?(@room, role)
-          user_opts = bigbluebutton_create_options(@room)
-          if @room.create_meeting(bigbluebutton_user, request, user_opts)
+          if @room.create_meeting(bigbluebutton_user, request)
             logger.info "Meeting created: id: #{@room.meetingid}, name: #{@room.name}, created_by: #{username}, time: #{Time.now.iso8601}"
           end
         else
@@ -347,16 +329,9 @@ class Bigbluebutton::RoomsController < ApplicationController
         end
       end
 
-      # gets the token with the configurations for this user/room
-      token = @room.fetch_new_token
-      options = if token.nil? then {} else { :configToken => token } end
-
-      # set the create time and the user id, if they exist
-      options.merge!({ createTime: @room.create_time }) unless @room.create_time.blank?
-      options.merge!({ userID: id }) unless id.blank?
-
       # room created and running, try to join it
-      url = @room.join_url(username, role, nil, options)
+      url = @room.parameterized_join_url(username, role, id, {}, bigbluebutton_user)
+
       unless url.nil?
 
         # change the protocol to join with a mobile device

data/app/controllers/bigbluebutton/servers_controller.rb

@@ -2,7 +2,6 @@ class Bigbluebutton::ServersController < ApplicationController
   include BigbluebuttonRails::InternalControllerMethods
 
   respond_to :html
-  respond_to :json, :only => [:index, :show, :new, :create, :update, :destroy, :activity, :rooms]
   before_filter :find_server, :except => [:index, :new, :create]
 
   def index
@@ -47,14 +46,8 @@ class Bigbluebutton::ServersController < ApplicationController
       if error
         flash[:error] = message
         format.html { render :activity }
-        format.json {
-          array = @server.meetings
-          array.insert(0, { :message => message })
-          render :json => array, :status => :error
-        }
       else
         format.html
-        format.json
       end
     end
   end
@@ -68,10 +61,8 @@ class Bigbluebutton::ServersController < ApplicationController
           message = t('bigbluebutton_rails.servers.notice.create.success')
           redirect_to_using_params @server, :notice => message
         }
-        format.json { render :json => @server, :status => :created }
       else
         format.html { redirect_to_params_or_render :new }
-        format.json { render :json => @server.errors.full_messages, :status => :unprocessable_entity }
       end
     end
   end
@@ -83,10 +74,8 @@ class Bigbluebutton::ServersController < ApplicationController
           message = t('bigbluebutton_rails.servers.notice.update.success')
           redirect_to_using_params @server, :notice => message
         }
-        format.json { render :json => true, :status => :ok }
       else
         format.html { redirect_to_params_or_render :edit }
-        format.json { render :json => @server.errors.full_messages, :status => :unprocessable_entity }
       end
     end
   end
@@ -97,7 +86,6 @@ class Bigbluebutton::ServersController < ApplicationController
 
     respond_with do |format|
       format.html { redirect_to_using_params bigbluebutton_servers_url }
-      format.json { render :json => true, :status => :ok }
     end
   end
 
@@ -174,7 +162,6 @@ class Bigbluebutton::ServersController < ApplicationController
           end
           redirect_to_using_params recordings_bigbluebutton_server_path(@server), :notice => message
         }
-        format.json { render :json => message }
       end
     rescue BigBlueButton::BigBlueButtonException => e
       respond_with do |format|
@@ -182,7 +169,6 @@ class Bigbluebutton::ServersController < ApplicationController
           flash[:error] = e.to_s[0..200]
           redirect_to_using_params recordings_bigbluebutton_server_path(@server)
         }
-        format.json { render :json => e.to_s, :status => :error }
       end
     end
   end

data/app/helpers/bigbluebutton_rails_helper.rb

@@ -41,4 +41,8 @@ module BigbluebuttonRailsHelper
     "badges/apple_store_#{I18n.locale}.png"
   end
 
+  def api_type_of(obj)
+    type = obj.class.name.demodulize.underscore.dasherize
+    type.gsub(/bigbluebutton-/, '')
+  end
 end

data/app/models/bigbluebutton_attendee.rb

@@ -0,0 +1,21 @@
+class BigbluebuttonAttendee < ActiveRecord::Base
+  include ActiveModel::ForbiddenAttributesProtection
+
+  belongs_to :meeting, :class_name => 'BigbluebuttonMeeting',
+             :foreign_key => :bigbluebutton_meeting_id
+
+  validates :bigbluebutton_meeting_id, :presence => true
+
+  # TODO: no role on getStats yet, but it exists on getMeetings
+  attr_accessor :role
+
+  def duration
+    self.left_time - self.join_time
+  end
+
+  def from_hash(hash)
+    self.user_id = hash[:userID].to_s
+    self.user_name = hash[:fullName].to_s
+    self.role = hash[:role].to_s.downcase == "moderator" ? :moderator : :attendee
+  end
+end

data/app/models/bigbluebutton_meeting.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 class BigbluebuttonMeeting < ActiveRecord::Base
   include ActiveModel::ForbiddenAttributesProtection
 
@@ -8,6 +9,10 @@ class BigbluebuttonMeeting < ActiveRecord::Base
           :foreign_key => 'meeting_id',
           :dependent => :nullify
 
+  has_many :attendees,
+           :class_name => 'BigbluebuttonAttendee',
+           :dependent => :destroy
+
   validates :room, :presence => true
 
   validates :meetingid, :presence => true, :length => { :minimum => 1, :maximum => 100 }

data/app/models/bigbluebutton_playback_format.rb

@@ -4,8 +4,9 @@ class BigbluebuttonPlaybackFormat < ActiveRecord::Base
   belongs_to :recording, :class_name => 'BigbluebuttonRecording'
   belongs_to :playback_type, :class_name => 'BigbluebuttonPlaybackType'
 
-  delegate :name, :identifier, :visible, :visible?, :default, :default?, :description,
-    to: :playback_type, allow_nil: true
+  delegate :name, :identifier, :visible, :visible?, :default, :default?,
+           :description, :downloadable, :downloadable?,
+           to: :playback_type, allow_nil: true
   alias_attribute :format_type, :identifier
 
   validates :recording_id, :presence => true

data/app/models/bigbluebutton_recording.rb

@@ -1,6 +1,8 @@
 class BigbluebuttonRecording < ActiveRecord::Base
   include ActiveModel::ForbiddenAttributesProtection
 
+  # NOTE: when adding new attributes to recordings, add them to `recording_changed?`
+
   belongs_to :server, class_name: 'BigbluebuttonServer'
   belongs_to :room, class_name: 'BigbluebuttonRoom'
   belongs_to :meeting, class_name: 'BigbluebuttonMeeting'
@@ -23,15 +25,46 @@ class BigbluebuttonRecording < ActiveRecord::Base
 
   scope :published, -> { where(:published => true) }
 
+  serialize :recording_users, Array
+
   def to_param
     self.recordid
   end
 
+  def get_token(user, ip)
+    server = BigbluebuttonServer.default
+    user.present? ? authName = user.username : authName = "anonymous"
+    api_token = server.api.send_api_request(:getRecordingToken, { authUser: authName, authAddr: ip, meetingID: self.recordid })
+    str_token = api_token[:token]
+    str_token
+  end
+
+  # Passing it on the url
+  #
+  def token_url(user, ip, playback)
+    auth_token = get_token(user, ip)
+    if auth_token.present?
+      uri = playback.url
+      uri += URI.parse(uri).query.blank? ? "?" : "&"
+      uri += "token=#{auth_token}"
+      uri
+    end
+  end
+
   def default_playback_format
     playback_formats.joins(:playback_type)
       .where("bigbluebutton_playback_types.default = ?", true).first
   end
 
+  # Remove this recording from the server
+  def delete_from_server!
+    if self.server.present?
+      self.server.send_delete_recordings(self.recordid)
+    else
+      false
+    end
+  end
+
   # Returns the overall (i.e. for all recordings) average length of recordings in seconds
   # Uses the length of the default playback format
   def self.overall_average_length
@@ -47,6 +80,56 @@ class BigbluebuttonRecording < ActiveRecord::Base
     avg.nil? ? 0 : avg
   end
 
+  # Compares a recording from the db with data from a getRecordings call.
+  # If anything changed in the recording, returns true.
+  # We select only the attributes that are saved and turn it all into sorted arrays
+  # to compare. If new attributes are stored in recordings, they should be added here.
+  #
+  # This was created to speed up the full sync of recordings.
+  # In the worst case the comparison is wrong and we're updating them all (same as
+  # not using this method at all, which is ok).
+  def self.recording_changed?(recording, data)
+    begin
+      # the attributes that are considered in the comparison
+      keys = [:end_time, :meetingid,  :metadata, :playback, :published, :recordid, :size, :start_time] # rawSize is not stored at the moment
+      keys_formats = [:length, :type, :url] # :size, :processingTime are not stored at the moment
+
+      # the data from getRecordings
+      data_clone = data.deep_dup
+      data_clone[:size] = data_clone[:size].to_s if data_clone.key?(:size)
+      data_clone[:metadata] = data_clone[:metadata].sort if data_clone.key?(:metadata)
+      if data_clone.key?(:playback) && data_clone[:playback].key?(:format)
+        data_clone[:playback][:format] = [data_clone[:playback][:format]] unless data_clone[:playback][:format].is_a?(Array)
+        data_clone[:playback] = data_clone[:playback][:format].map{ |f|
+          f.slice(*keys_formats).sort
+        }.sort
+      else
+        data_clone[:playback] = []
+      end
+      data_clone[:end_time] = data_clone[:end_time].to_i if data_clone.key?(:end_time)
+      data_clone[:start_time] = data_clone[:start_time].to_i if data_clone.key?(:start_time)
+      data_clone = data_clone.slice(*keys)
+      data_sorted = data_clone.sort
+
+      # the data from the recording in the db
+      attrs = recording.attributes.symbolize_keys.slice(*keys)
+      attrs[:size] = attrs[:size].to_s if attrs.key?(:size)
+      attrs[:metadata] = recording.metadata.pluck(:name, :content).map{ |i| [i[0].to_sym, i[1]] }.sort
+      attrs[:playback] = recording.playback_formats.map{ |f|
+        r = f.attributes.symbolize_keys.slice(*keys_formats)
+        r[:type] = f.format_type
+        r.sort
+      }.sort
+      attrs = attrs.sort
+
+      # compare
+      data_sorted.to_s != attrs.to_s
+    rescue StandardError => e
+      logger.error "Error comparing recordings: #{e.inspect}"
+      true # always update recordings if on error
+    end
+  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
@@ -60,18 +143,24 @@ class BigbluebuttonRecording < ActiveRecord::Base
     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)
+      changed = !rec_obj.present? ||
+                self.recording_changed?(rec_obj, rec_data)
+
+      if changed
+        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
     end
+    cleanup_playback_types
 
     # set as unavailable the recordings that are not in 'recordings', but
     # only in a full synchronization process, which means that the recordings
@@ -107,6 +196,22 @@ class BigbluebuttonRecording < ActiveRecord::Base
     new_hash
   end
 
+  def self.adapt_recording_users(original)
+    if original.present? && original.size > 0
+      users = original[:user]
+      users = [users] unless users.is_a?(Array)
+      users = users.map{ |u|
+        id = u[:externalUserID]
+        begin
+          id = Integer(id)
+        rescue
+        end
+        id
+      }
+      return users
+    end
+  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.
@@ -115,6 +220,7 @@ class BigbluebuttonRecording < ActiveRecord::Base
     recording.room = BigbluebuttonRails.configuration.match_room_recording.call(data)
     recording.attributes = data.slice(:meetingid, :name, :published, :start_time, :end_time, :size)
     recording.available = true
+    recording.recording_users = adapt_recording_users(data[:recordingUsers])
     recording.save!
 
     sync_additional_data(recording, data)
@@ -129,8 +235,9 @@ class BigbluebuttonRecording < ActiveRecord::Base
     recording.available = true
     recording.room = BigbluebuttonRails.configuration.match_room_recording.call(data)
     recording.server = server
-    recording.description = I18n.t('bigbluebutton_rails.recordings.default.description', :time => recording.start_time.utc.to_formatted_s(:long))
+    recording.description = I18n.t('bigbluebutton_rails.recordings.default.description', :time => Time.at(recording.start_time).utc.to_formatted_s(:long))
     recording.meeting = BigbluebuttonRecording.find_matching_meeting(recording)
+    recording.recording_users = adapt_recording_users(data[:recordingUsers])
     recording.save!
 
     sync_additional_data(recording, data)
@@ -154,73 +261,60 @@ class BigbluebuttonRecording < ActiveRecord::Base
     # 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
+    # get all metadata for this recording
+    # note: it's a little slower than removing all metadata and adding again,
+    # but it's cleaner to just update it and the loss of performance is small
+    query = { owner_id: recording.id, owner_type: recording.class.to_s }
+    metas = BigbluebuttonMetadata.where(query).all
 
-    # for metadata that are not in the db yet
+    # batch insert all metadata
+    columns = [ :id, :name, :content, :owner_id, :owner_type ]
+    values = []
     received_metadata.each do |name, content|
-      attrs = {
-        :name => name,
-        :content => content,
-      }
-      meta = BigbluebuttonMetadata.create(attrs)
-      meta.owner = recording
-      meta.save!
+      id = metas.select{ |m| m.name == name }.first.try(:id)
+      values << [ id, name, content, recording.id, recording.class.to_s ]
     end
+    BigbluebuttonMetadata.import! columns, values, validate: true,
+                                  on_duplicate_key_update: [:name, :content]
+
+    # delete all that doesn't exist anymore
+    BigbluebuttonMetadata.where(query).where.not(name: received_metadata.keys).delete_all
   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
+    # clone and make it an array if it's a hash with a single format
+    formats_copy = formats.clone
     formats_copy = [formats_copy] if formats_copy.is_a?(Hash)
 
-    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] })
-        formats_copy.delete(format)
-
-      # the format is not in the hash, remove from the db
-      else
-        format_db.destroy
-      end
-    end
+    # remove all formats for this recording
+    # note: easier than updating the formats because they don't have a clear key
+    # to match by
+    BigbluebuttonPlaybackFormat.where(recording_id: recording.id).delete_all
 
-    # create the formats that are not in the db yet
+    # batch insert all playback formats
+    columns = [ :recording_id, :url, :length , :playback_type_id ]
+    values = []
     formats_copy.each do |format|
       unless format[:type].blank?
-        playback_type = BigbluebuttonPlaybackType.find_by_identifier(format[:type])
+        playback_type = BigbluebuttonPlaybackType.find_by(identifier: format[:type])
         if playback_type.nil?
-          attrs = { identifier: format[:type], visible: true }
+          downloadable = BigbluebuttonRails.configuration.downloadable_playback_types.include?(format[:type])
+          attrs = {
+            identifier: format[:type],
+            visible: true,
+            downloadable: downloadable
+          }
           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)
+        values << [ recording.id, format[:url], format[:length].to_i, playback_type.id ]
       end
     end
-
-    cleanup_playback_types
+    BigbluebuttonPlaybackFormat.import! columns, values, validate: true
   end
 
   # Remove the unused playback types from the list.
@@ -230,20 +324,22 @@ class BigbluebuttonRecording < ActiveRecord::Base
   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.
+  # the meetingid associated with this recording and the create time of the meeting, taken from
+  # the recording's ID. There are some flexible clauses that try to match very close or truncated
+  # timestamps from recordings start times to meeting create times.
   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
+    unless recording.nil? #or recording.room.nil?
+      unless recording.start_time.nil?
+        start_time = recording.start_time
+        meeting = BigbluebuttonMeeting.where("meetingid = ? AND create_time = ?", recording.meetingid, start_time).last
+          if meeting.nil?
+            meeting = BigbluebuttonMeeting.where("meetingid = ? AND create_time DIV 1000 = ?", recording.meetingid, start_time).last
+          end
+          if meeting.nil?
+            div_start_time = (start_time/10)
+            meeting = BigbluebuttonMeeting.where("meetingid = ? AND create_time DIV 10 = ?", recording.meetingid, div_start_time).last
+          end
         logger.info "Recording: meeting found for the recording #{recording.inspect}: #{meeting.inspect}"
       end
     end