bigbluebutton_rails 0.0.2 → 0.0.3

data/CHANGELOG.rdoc

@@ -1,6 +1,14 @@
+== 0.0.3
+
+* Rooms can be public or private
+* New route RoomsController#invite used to request a password to join a room or to allow anonymous users to join.
+* Room's "meeting_id" attribute renamed to "meetingid".
+* A room can have it's meetingid randomly generated for each "send_create" call if randomize_meetingid is set.
+* New attributes for rooms: logout_url, dial_number, voice_bridge and max_participant.
+
 == 0.0.2
 
-* New "fetch" methods in BigbluebuttonRooms to fetch info about meetings from BBB and store in the model.
+* New "fetch" and "send" methods in BigbluebuttonRooms to fetch info about meetings from BBB and store in the model.
 * New class BigbluebuttonAttendee to store attendee information returned by BBB in get_meeting_info.
 * New class BigbluebuttonMeeting to store meeting information returned by BBB in get_meetings.
 

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    bigbluebutton_rails (0.0.2)
-      bigbluebutton-api-ruby (~> 0.0.9)
+    bigbluebutton_rails (0.0.3)
+      bigbluebutton-api-ruby (~> 0.0.10)
       rails (~> 3.0.3)
 
 GEM
@@ -36,7 +36,7 @@ GEM
       activesupport (= 3.0.6)
     activesupport (3.0.6)
     arel (2.0.9)
-    bigbluebutton-api-ruby (0.0.9)
+    bigbluebutton-api-ruby (0.0.10)
       nokogiri (~> 1.4.0)
     builder (2.1.2)
     diff-lcs (1.1.2)

data/README.rdoc

@@ -1,6 +1,6 @@
 = BigBlueButton on Rails
 
-BigBlueButton (http://bigbluebutton.org) integration for Ruby on Rails 3.
+{BigBlueButton}[http://bigbluebutton.org] integration for Ruby on Rails 3.
 
 Features:
 * Allows multiple servers and multiple conference rooms
@@ -9,11 +9,12 @@ Features:
 * Easy integration with authentication and authorization mechanisms, such as Devise and CanCan
 
 Future:
+* Private room and invitations to allow visitants to join conferences (using a password or not).
 * Friendly URLs (e.g. http://somewhere.com/my-server/my-room)
 * Random meeting IDs to avoid problems with end_meeting and timeouts
 * Server administration (modify config.xml, use bbb-conf, etc.)
 
-For more future features and issues check http://code.google.com/p/mconf/issues/list?can=2&q=label%3AComponent%20label%3ABigBlueButtonRails
+For more future features and issues check {our google code page}[http://code.google.com/p/mconf/issues/list?can=2&q=label%3AComponent%20label%3ABigBlueButtonRails].
 
 == Installation
 
@@ -47,7 +48,7 @@ For more information see the section Dependencies below.
 
 === Routes
 
-The routes to bigbluebutton_rails can be generated with the helper "bigbluebutton_routes". See the example below:
+The routes to bigbluebutton_rails can be generated with the helper <tt>bigbluebutton_routes</tt>. See the example below:
 
   bigbluebutton_routes :default
 
@@ -72,21 +73,23 @@ So you can allow access to webconference rooms using URLs such as:
   http://myserver.com/user-10/room-5/join
   http://myserver.com/zaphod/public-room/join
 
-PS: bigbluebutton_rails does not allows the room access using IDs such as "room-5" or "public-room" yet, but soon you it will.
+Obs: bigbluebutton_rails does not allows the room access using IDs such as "room-5" or "public-room" yet, but soon you it will.
 
 === User authorization, permissions and assumptions
 
 There are some basic assumptions made by bigbluebutton_rails:
 
-* You have a method called "current_user" that returns the current user;
-* The current_user has an attribute or method called "name" that returns his/her fullname.
+* You have a method called <tt>current_user</tt> that returns the current user;
+* The <tt>current_user</tt> has an attribute or method called "name" that returns his/her fullname.
 
 If you don't, you can change this behaviour easily, keep reading.
 
-bigbluebutton_rails uses the methods "bigbluebutton_user" and "bigbluebutton_role(room)" to get the current user and to get the permission that the current
-user has in the "room", respectively.
+bigbluebutton_rails uses the methods <tt>bigbluebutton_user</tt> and <tt>bigbluebutton_role(room)</tt> to get the current user and to get the permission that the current
+user has in the <tt>room</tt>, respectively. These methods are defined in <tt>lib/bigbluebutton_rails/controller_methods.rb</tt> and you can reimplement them in your
+application controller to change their behaviour.
 
-These methods are defined in "lib/bigbluebutton_rails/controller_methods.rb" and you can reimplement them in your application_controller to change their behaviour.
+Although this is the general rule, the permission checking is different for public or private rooms. Check the <tt>How it Works</tt>
+section below for more details.
 
 
 ==== Integration with Devise
@@ -105,32 +108,62 @@ Files:
 
 * Javascripts:
   * JQuery (jquery.min.js). See http://jquery.com
-  * JQuery Heartbeat plugin (heartbeat.js). See http://plugins.jquery.com/project/Heartbeat
 * Images:
   * loading.gif
 
-All these files are used by views/bigbluebutton/rooms/join_wait and can be generated with:
+JQuery is used in the views <tt>join_wait</tt> and <tt>invite</tt> and can be copied into your application with:
 
   rails generate bigbluebutton_rails:public
 
 == How it works
 
+=== Overview
+
 bigbluebutton_rails has two entities: servers and rooms. Servers can have multiple rooms, that belong to a server and can also belong to any other model.
 You can make a room belong to a user, for example.
 
-Every server has an associated API object (using the gem bigbluebutton-api-ruby) used to access BigBlueButton.
-The server now has basically the RESTful actions defined in Rails.
+Every server has an associated API object (using the gem bigbluebutton-api-ruby) used to access the BigBlueButton server.
+The server controller has only the standard CRUD actions defined by Rails.
+
+The rooms controller also have the CRUD actions, plus some specific actions to join, end, and check if a meeting is currently running in the room.
+These extra actions will be explained bellow.
+
+A room model has methods to fetch and send information to the BBB server. They are simple API calls, but the "fetch" methods check the response and store
+data from it, while the "send" methods just make the API call. You can, for example, use <tt>fetch_meeting_info</tt> to get information about the meeting
+(will trigger the API call <tt>getMeetingInfo</tt>). The data parsed from the response wil be stored in the model and can be accessed using it's attributes. 
+
+All methods in the models that trigger any API call are documented with "Triggers API call" and the API functions that are called. Be aware that they
+can throw a BigBlueButtonException.
+
+=== RoomsController
+
+==== <tt>running</tt> and <tt>end</tt>
 
-The rooms also have the RESTful actions, plus specific actions to "join", "end", and check if a meeting is being held currently in the room ("running").
-All actions are pretty simple. "running" returns a json indicating if the conference is running or not and "end" ends the meeting.
-The most elaborated action is "join", that does the following:
+These are pretty simple actions. <tt>running</tt> returns a json indicating if the conference is running or not, while <tt>end</tt> ends the meeting.
+
+==== <tt>join</tt>, <tt>invite</tt> and <tt>auth</tt>
+
+The actions used to redirect a user to join a room are <tt>join</tt> and <tt>invite</tt>, while <tt>auth</tt> is used by <tt>invite</tt> to authenticate
+the user. Basic differences:
+
+* <tt>invite</tt> renders a view to ask for a user name and a password. It is used to enable <b>anonymous users</b> to join a room or
+  to define the user role using the <b>room password</b> instead of the <tt>bigbluebutton_role</tt> method.
+  * It first checks <tt>bigbluebutton_role</tt> to see if the current user already has a role in the target room. In case it has, redirects to <tt>join</tt>.
+  * If there is a user logged, uses <tt>bigbluebutton_user().name</tt> as the user name. Otherwise, ask the user to type a name.
+* <tt>join</tt> requires a <b>logged user</b> and uses <tt>bigbluebutton_role</tt> to get the role of this user.
+  * It redirects the user straight to the meeting if the join is successful.
+  * In case there's no role associated with the current user, falls back to <tt>invite</tt> to ask for a password.
+
+Internally, they use the same algorithm:
 
 * If the user is a moderator:
-  * If the rooms is not created yet, creates it.
-  * Redirects to the url to join as a moderator.
+  * If the room is not created yet, creates it.
+  * Redirects the user to the meeting as a moderator.
 * If the user is a normal attendee:
-  * If the rooms is running, redirects to the url to join as an attendee.
-  * Otherwise, redirects to join_wait, to wait for a moderator before joining the conference.
+  * If the meeting is running, redirects the user to the meeting as an attendee.
+  * Otherwise:
+    * <tt>join</tt> redirects to <tt>join_wait</tt>, to wait for a moderator before joining the conference.
+    * <tt>invite</tt> renders the invite view again and shows a warning that the metting is not running.
 
 == Development
 
@@ -144,4 +177,6 @@ Prepare the rails_app used for tests:
 
 Run the tests:
 
-  rake spec
+  rake spec
+
+Develop. :)

data/Rakefile

@@ -16,6 +16,7 @@ Rake::RDocTask.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('README.rdoc')
   rdoc.rdoc_files.include('CHANGELOG.rdoc')
   rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
 end
 
 eval("$specification = begin; #{ IO.read('bigbluebutton_rails.gemspec')}; end")

data/app/controllers/bigbluebutton/rooms_controller.rb

@@ -26,21 +26,29 @@ class Bigbluebutton::RoomsController < ApplicationController
   def create
     @room = BigbluebuttonRoom.new(params[:bigbluebutton_room])
     @room.server = @server
-
-    # TODO Generate a random meeting_id everytime a room is created
-    if !params[:bigbluebutton_room].has_key?(:meeting_id) or
-        params[:bigbluebutton_room][:meeting_id].blank?
-      @room.meeting_id = @room.name
+    
+    # TODO Generate a random meetingid everytime a room is created
+    if !params[:bigbluebutton_room].has_key?(:meetingid) or
+        params[:bigbluebutton_room][:meetingid].blank?
+      @room.meetingid = @room.name
     end
 
     respond_with @room do |format|
       if @room.save
         format.html {
           message = t('bigbluebutton_rails.rooms.notice.create.success')
-          redirect_to(bigbluebutton_server_room_path(@server, @room), :notice => message)
+          params[:redir_url] ||= bigbluebutton_server_room_path(@server, @room)
+          redirect_to params[:redir_url], :notice => message
         }
       else
-        format.html { render :action => "new" }
+        format.html {
+          unless params[:redir_url].blank?
+            message = t('bigbluebutton_rails.rooms.notice.create.failure')
+            redirect_to params[:redir_url], :error => message
+          else
+            render :action => "new"
+          end
+        }
       end
     end
   end
@@ -48,19 +56,27 @@ class Bigbluebutton::RoomsController < ApplicationController
   def update
     @room = BigbluebuttonRoom.find(params[:id])
 
-    if !params[:bigbluebutton_room].has_key?(:meeting_id) or
-        params[:bigbluebutton_room][:meeting_id].blank?
-      params[:bigbluebutton_room][:meeting_id] = params[:bigbluebutton_room][:name]
+    if !params[:bigbluebutton_room].has_key?(:meetingid) or
+        params[:bigbluebutton_room][:meetingid].blank?
+      params[:bigbluebutton_room][:meetingid] = params[:bigbluebutton_room][:name]
     end
 
     respond_with @room do |format|
       if @room.update_attributes(params[:bigbluebutton_room])
         format.html {
           message = t('bigbluebutton_rails.rooms.notice.update.success')
-          redirect_to(bigbluebutton_server_room_path(@server, @room), :notice => message)
+          params[:redir_url] ||= bigbluebutton_server_room_path(@server, @room)
+          redirect_to params[:redir_url], :notice => message
         }
       else
-        format.html { render :action => "edit" }
+        format.html {
+          unless params[:redir_url].blank?
+            message = t('bigbluebutton_rails.rooms.notice.update.failure')
+            redirect_to params[:redir_url], :error => message
+          else
+            render :action => "edit"
+          end
+        }
       end
     end
   end
@@ -79,42 +95,54 @@ class Bigbluebutton::RoomsController < ApplicationController
     end
 
     @room.destroy
-    redirect_to(bigbluebutton_server_rooms_url)
+    params[:redir_url] ||= bigbluebutton_server_rooms_url
+    redirect_to params[:redir_url]
   end
 
+  # Used to join public rooms with a logged user.
   def join
     @room = BigbluebuttonRoom.find(params[:id])
+
+    # anonymous users or users without a role join through #invite
     role = bigbluebutton_role(@room)
+    if bigbluebutton_user.nil? or role.nil?
+      redirect_to :action => :invite
+    else
+      join_internal(bigbluebutton_user.name, role, :join)
+    end
 
-    begin
-      @room.fetch_is_running?
+  end
 
-      # if the current user is a moderator, create the room (if needed)
-      # and join it
-      if role == :moderator
-        @room.send_create unless @room.is_running?
-        join_url = @room.join_url(bigbluebutton_user.name, role)
-        redirect_to(join_url)
+  # Used to join private rooms or to invited anonymous users (not logged)
+  def invite
+    @room = BigbluebuttonRoom.find(params[:id])
 
-      # normal user only joins if the conference is running
-      # if it's not, wait for a moderator to create the conference
+    respond_with @room do |format|
+
+      # if there's already a logged user with a role in the room, join through #join
+      unless bigbluebutton_user.nil? or bigbluebutton_role(@room).nil?
+        format.html { redirect_to :action => :join }
       else
-        if @room.is_running?
-          join_url = @room.join_url(bigbluebutton_user.name, role)
-          redirect_to(join_url)
-        else
-          render :action => :join_wait
-        end
+        format.html
       end
 
-    rescue BigBlueButton::BigBlueButtonException => e
-      flash[:error] = e.to_s
-      redirect_to request.referer
     end
-
   end
 
-  def join_wait
+  # Authenticates an user using name and password passed in the params from #invite
+  def auth
+    @room = BigbluebuttonRoom.find(params[:id])
+
+    # if there's a user logged, use his name instead of the name in the params
+    name = bigbluebutton_user.nil? ? params[:user][:name] : bigbluebutton_user.name
+    role = @room.user_role(params[:user])
+
+    unless role.nil? or name.nil?
+      join_internal(name, role, :invite)
+    else
+      flash[:error] = t('bigbluebutton_rails.rooms.error.auth.failure')
+      render :action => "invite", :status => :unauthorized
+    end
   end
 
   def running
@@ -125,7 +153,6 @@ class Bigbluebutton::RoomsController < ApplicationController
     rescue BigBlueButton::BigBlueButtonException => e
       flash[:error] = e.to_s
       render :json => { running: "false", error: "#{e.to_s}" }
-      #redirect_to request.referer
     else
       render :json => { running: "#{@room.is_running?}" }
     end
@@ -162,4 +189,34 @@ class Bigbluebutton::RoomsController < ApplicationController
     end
   end
 
+  def join_internal(username, role, wait_action)
+
+    begin
+      @room.fetch_is_running?
+
+      # if the current user is a moderator, create the room (if needed)
+      # and join it
+      if role == :moderator
+        @room.send_create unless @room.is_running?
+        join_url = @room.join_url(username, role)
+        redirect_to(join_url)
+
+      # normal user only joins if the conference is running
+      # if it's not, wait for a moderator to create the conference
+      else
+        if @room.is_running?
+          join_url = @room.join_url(username, role)
+          redirect_to(join_url)
+        else
+          flash[:error] = t('bigbluebutton_rails.rooms.error.not_running')
+          render :action => wait_action
+        end
+      end
+
+    rescue BigBlueButton::BigBlueButtonException => e
+      flash[:error] = e.to_s
+      redirect_to request.referer
+    end
+  end
+
 end

data/app/models/bigbluebutton_room.rb

@@ -1,38 +1,63 @@
+require 'active_support/secure_random'
+
 class BigbluebuttonRoom < ActiveRecord::Base
   belongs_to :server, :class_name => 'BigbluebuttonServer'
   belongs_to :owner, :polymorphic => true
 
   validates :server_id, :presence => true
-  validates :meeting_id, :presence => true, :uniqueness => true,
+  validates :meetingid, :presence => true, :uniqueness => true,
     :length => { :minimum => 1, :maximum => 100 }
   validates :name, :presence => true, :uniqueness => true,
     :length => { :minimum => 1, :maximum => 150 }
-  validates :attendee_password, :length => { :maximum => 50 }
-  validates :moderator_password, :length => { :maximum => 50 }
   validates :welcome_msg, :length => { :maximum => 250 }
+  validates :private, :inclusion => { :in => [true, false] }
+  validates :randomize_meetingid, :inclusion => { :in => [true, false] }
+
+  # 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 }
 
-  attr_accessible :name, :server_id, :meeting_id, :attendee_password,
-                  :moderator_password, :welcome_msg, :owner, :server
+  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
 
-  # Note: these params need to be fetched before being accessed
-  attr_reader :running, :participant_count, :moderator_count, :attendees,
-              :has_been_forcibly_ended, :start_time, :end_time
+  # 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
+
+  # Convenience method to access the attribute <tt>running</tt>
   def is_running?
     @running
   end
 
+  # Fetches info from BBB about this room.
+  # The response is parsed and stored in the model. You can access it using attributes such as:
+  #
+  #   room.participant_count
+  #   room.attendees[0].full_name
+  #
+  # The attributes changed are:
+  # * <tt>participant_count</tt>
+  # * <tt>moderator_count</tt>
+  # * <tt>running</tt>
+  # * <tt>has_been_forcibly_ended</tt>
+  # * <tt>start_time</tt>
+  # * <tt>end_time</tt>
+  # * <tt>attendees</tt> (array of <tt>BigbluebuttonAttendee</tt>)
+  #
+  # Triggers API call: <tt>get_meeting_info</tt>.
   def fetch_meeting_info
-    response = self.server.api.get_meeting_info(self.meeting_id, self.moderator_password)
+    response = self.server.api.get_meeting_info(self.meetingid, self.moderator_password)
 
     @participant_count = response[:participantCount]
     @moderator_count = response[:moderatorCount]
-    @running = response[:running].downcase == "true"
-    @has_been_forcibly_ended = response[:hasBeenForciblyEnded].downcase == "true"
-    @start_time = response[:startTime] == "null" ?
-                  nil : DateTime.parse(response[:startTime])
-    @end_time = response[:endTime] == "null" ?
-                nil : DateTime.parse(response[:endTime])
+    @running = response[:running]
+    @has_been_forcibly_ended = response[:hasBeenForciblyEnded]
+    @start_time = response[:startTime]
+    @end_time = response[:endTime]
     @attendees = []
     response[:attendees].each do |att|
       attendee = BigbluebuttonAttendee.new
@@ -43,37 +68,121 @@ class BigbluebuttonRoom < ActiveRecord::Base
     response
   end
 
+  # Fetches the BBB server to see if the meeting is running. Sets <tt>running</tt>
+  #
+  # Triggers API call: <tt>is_meeting_running</tt>.
   def fetch_is_running?
-    @running = self.server.api.is_meeting_running?(self.meeting_id)
+    @running = self.server.api.is_meeting_running?(self.meetingid)
   end
 
+  # Sends a call to the BBB server to end the meeting.
+  #
+  # Triggers API call: <tt>end_meeting</tt>.
   def send_end
-    self.server.api.end_meeting(self.meeting_id, self.moderator_password)
+    self.server.api.end_meeting(self.meetingid, self.moderator_password)
   end
 
+  # Sends a call to the BBB server to create the meeting.
+  #
+  # With the response, updates the following attributes:
+  # * <tt>attendee_password</tt>
+  # * <tt>moderator_password</tt>
+  #
+  # Triggers API call: <tt>create_meeting</tt>.
   def send_create
-    response = self.server.api.create_meeting(self.name, self.meeting_id, self.moderator_password,
-                                              self.attendee_password, self.welcome_msg)
 
-    # updates model information with data returned by BBB
+    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
+
     unless response.nil?
-      self.attendee_password = response[:attendeePW].to_s
-      self.moderator_password = response[:moderatorPW].to_s
+      self.attendee_password = response[:attendeePW]
+      self.moderator_password = response[:moderatorPW]
       self.save
     end
 
     response
   end
 
-  # uses the API but does not require a request to the server
+  # 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>
+  #
+  # Uses the API but does not require a request to the server.
   def join_url(username, role)
     if role == :moderator
-      self.server.api.join_meeting_url(self.meeting_id, username,
-                                       self.moderator_password)
+      self.server.api.join_meeting_url(self.meetingid, username, self.moderator_password)
     else
-      self.server.api.join_meeting_url(self.meeting_id, username,
-                                       self.attendee_password)
+      self.server.api.join_meeting_url(self.meetingid, username, self.attendee_password)
     end
   end
 
+
+  # Returns the role of the user based on the password 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
+  def user_role(params)
+    role = nil
+    if params.has_key?(:password)
+      if self.moderator_password == params[:password]
+        role = :moderator
+      elsif self.attendee_password == params[:password]
+        role = :attendee
+      end
+    end
+    role
+  end
+
+  protected
+
+  def init
+    self[:meetingid] ||= random_meetingid
+
+    # fetched attributes
+    @participant_count = 0
+    @moderator_count = 0
+    @running = false
+    @has_been_forcibly_ended = false
+    @start_time = nil
+    @end_time = nil
+    @attendees = []
+  end
+
+  def random_meetingid
+    #ActiveSupport::SecureRandom.hex(16)
+    # TODO temporarily using the name to get a friendlier meetingid
+    if self[:name].blank?
+      ActiveSupport::SecureRandom.hex(8)
+    else
+      self[:name] + '-' + ActiveSupport::SecureRandom.random_number(9999).to_s
+    end
+  end
+
+  def do_create_meeting
+    self.server.api.create_meeting(self.name, self.meetingid, self.moderator_password,
+                                   self.attendee_password, self.welcome_msg, self.dial_number,
+                                   self.logout_url, self.max_participants, self.voice_bridge)
+  end
+
 end

data/app/models/bigbluebutton_server.rb

@@ -14,6 +14,8 @@ class BigbluebuttonServer < ActiveRecord::Base
 
   validates :version, :presence => true, :inclusion => { :in => ['0.64', '0.7'] }
 
+  # Returns the API object (<tt>BigBlueButton::BigBlueButtonAPI</tt> defined in
+  # <tt>bigbluebutton-api-ruby</tt>) associated with this server.
   def api
     if @api.nil?
       @api = BigBlueButton::BigBlueButtonApi.new(self.url, self.salt,
@@ -22,20 +24,34 @@ class BigbluebuttonServer < ActiveRecord::Base
     @api
   end
 
+  # Array of <tt>BigbluebuttonMeeting</tt>
   attr_reader :meetings
 
+  # Fetches the meetings currently created in the server (running or not).
+  #
+  # Using the response, updates <tt>meetings</tt> with a list of <tt>BigbluebuttonMeeting</tt>
+  # objects.
+  #
+  # Triggers API call: <tt>get_meetings</tt>.
   def fetch_meetings
     response = self.api.get_meetings
 
     # updates the information in the rooms that are currently in BBB
     @meetings = []
     response[:meetings].each do |attr|
-      room = BigbluebuttonRoom.find_by_server_id_and_meeting_id(self.id, attr[:meetingID])
-
-      meeting = BigbluebuttonMeeting.new
-      meeting.from_hash(attr)
-      meeting.room = room
-      @meetings << meeting
+      room = BigbluebuttonRoom.find_by_server_id_and_meetingid(self.id, attr[:meetingID])
+      if room.nil?
+        room = BigbluebuttonRoom.new(:server => self, :meetingid => attr[:meetingID],
+                                     :attendee_password => attr[:attendeePW],
+                                     :moderator_password => attr[:moderatorPW])
+        room.running = attr[:running]
+      else
+        room.update_attributes(:attendee_password => attr[:attendeePW],
+                               :moderator_password => attr[:moderatorPW])
+        room.running = attr[:running]
+      end
+
+      @meetings << room
     end
   end