conference_manager-ruby 0.0.1

data/.gitignore

@@ -0,0 +1,14 @@
+.bundle/
+log/*.log
+pkg/
+spec/dummy/db/*.sqlite3
+spec/dummy/log/*.log
+spec/dummy/tmp/
+spec/dummy/.project
+**.tmp_*
+Gemfile.lock
+.idea
+.project
+.document
+.settings/
+rdoc/

data/.yardopts

@@ -0,0 +1,2 @@
+lib/**/*.rb
+app/**/*.rb

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+     
+gemspec

data/README.rdoc

@@ -0,0 +1,26 @@
+= ConferenceManager Ruby Wrapping
+
+A ruby gem to wrap the ConferenceManager functionality
+
+
+= Installation
+
+Add to your Gemfile:
+
+  gem 'conference_manager-ruby'
+  
+Then run:
+
+  bundle update
+  
+= Usage
+
+In your model:
+
+  class Event < ActiveRecord::Base      
+    acts_as_conference_manager_event
+  end
+  
+  class Session < ActiveRecord::Base      
+    acts_as_conference_manager_session
+  end

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+begin
+  require 'bundler/setup'
+  require 'bundler'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+
+=begin
+require 'rdoc/task'
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ConferenceManager Ruby Wrapping"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb', 'app/**/*.rb')
+end
+=end
+
+Bundler::GemHelper.install_tasks

data/conference_magener-ruby.gemspec

@@ -0,0 +1,30 @@
+Gem::Specification.new do |s|
+	s.name = "conference_manager-ruby"
+	s.version = "0.0.1"
+	s.authors = ["GING-UPM"]
+	s.summary = "Ruby wrapping for Conference Manager."
+	s.description = "Ruby wrapping for Conference Manager."
+	s.email = "vcc@dit.upm.es"
+	s.homepage = "http://github.com/ging/conference_manager-ruby"
+	s.files = `git ls-files`.split("\n")
+
+	# Gem dependencies
+  #
+  #s.add_runtime_dependency('rails', '3.1.0.rc4')
+  s.add_runtime_dependency('activeresource')
+  
+	# Debugging
+	if RUBY_VERSION < '1.9'
+		s.add_development_dependency('ruby-debug', '~> 0.10.3')
+	end
+	
+	# Specs
+	#s.add_development_dependency('rspec-rails', '~> 2.6.1')
+	# Fixtures
+	#s.add_development_dependency('factory_girl', '~> 1.3.2')
+	# Population
+	#s.add_development_dependency('forgery', '~> 0.3.6')
+	# Integration testing
+	#s.add_development_dependency('capybara', '~> 0.3.9')
+end
+

data/lib/conference_manager/editor.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class Editor < Resource
+    singleton
+
+    self.element_name = "editor" 
+    self.site = domain
+    self.prefix = "/events/:event_id/" 
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager/editor_session.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class EditorSession < Resource
+    singleton
+   
+    self.element_name = "editor" 
+    self.site = domain
+    self.prefix = "/events/:event_id/sessions/:session_id/" 
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager/event.rb

@@ -0,0 +1,24 @@
+module ConferenceManager
+  class Event < Resource
+    
+    self.element_name = "event"
+    self.site = domain
+    
+    def enable_sip?
+      enable_sip == "true"
+    end
+    
+    def enable_isabel?
+      enable_isabel == "true"
+    end
+    
+    def enable_web?
+      enable_web =="true"
+    end
+    
+    def enable_httplivestreaming?
+      enable-httplivestreaming == "true"  
+    end
+    
+  end
+end

data/lib/conference_manager/event_status.rb

@@ -0,0 +1,10 @@
+module ConferenceManager
+  class EventStatus < Resource
+    singleton
+   
+    self.element_name = "event-status" 
+    self.site = domain
+    self.prefix = "/events/:event_id/"
+
+  end
+end

data/lib/conference_manager/models/conference_manager_event.rb

@@ -0,0 +1,248 @@
+module ConferenceManager
+  module Models
+    module ConferenceManagerEvent
+      CM_ATTRIBUTES = ["name", "cm_mode", "start_date", "end_date", "web_bw", "isabel_bw", "sip_interface", "httplivestreaming_bw", "permalink"]
+      #in these arrays the number in kb is lower than in the comments because we pass the conference manager interface
+      #only the video bandwidth, and the total is about 50kb lower
+      WEB_BANDWIDTH = [100000, 200000, 400000] #equivalents: low (150K), medium (250K), high (450K)
+      WEB_CODEC = ["H264","H264","H263"] #equivalents: low (h.264), medium (h.264), high (sorenson)
+      RECORDING_BANDWIDTH = [0, 200000, 500000] #equivalents low (0) we don't use it, medium (250K), high (550K)
+      RECORDING_CODEC = ["H264","H264","H264"] #equivalents: low (H.264), medium (h.264), high (h.264)
+
+      WEB_BW_HASH_FOR_DROP_DOWN = {"100000"=> ["Low (150K H.264)", "0"], "200000" => ["Medium (250K H.264)", "1"], "400000"=>["High (450K Sorenson)", "2"]}
+      RECORDING_HASH_FOR_DROP_DOWN = {"0"=>["Medium (250K H.264)", "1"],"200000"=>["Medium (250K H.264)", "1"],"500000"=>["High (550K H.264)", "2"]}
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+      module ClassMethods
+        def acts_as_conference_manager_event
+          include ConferenceManager::Models::ConferenceManagerEvent::InstanceMethods
+        end
+
+        def included(base)
+          base.class_eval do
+
+            validate_on_create do |event|
+              if event.uses_conference_manager?
+                if event.recording_type == ::Event::RECORDING_TYPE.index(:manual)
+                end_date_after_adjust = event.end_date + ::Event::EXTRA_TIME_FOR_EVENTS_WITH_MANUAL_REC
+                else
+                end_date_after_adjust = event.end_date
+                end
+                cm_e =
+                ConferenceManager::Event.new(:name => event.name,
+                :mode => event.cm_mode,
+                :initDate => event.start_date,
+                :endDate => end_date_after_adjust,
+                :enable_web => "1",
+                :enable_isabel => "1",
+                :enable_sip => event.sip_interface?,
+                :enable_httplivestreaming => "0",
+                :isabel_bw => event.isabel_bw,
+                :web_bw => WEB_BANDWIDTH[event.web_bw],
+                :recording_bw => RECORDING_BANDWIDTH[event.recording_bw],
+                :httplivestreaming_bw => WEB_BANDWIDTH[event.web_bw],
+                :web_codec => WEB_CODEC[event.web_bw],
+                :recording_codec => RECORDING_CODEC[event.recording_bw],
+                :path => "attachments/conferences/#{event.permalink}")
+                begin
+                  cm_e.save
+                  event.cm_event_id = cm_e.id
+                rescue StandardError => e
+                event.errors.add_to_base(e.to_s)
+                end
+              end
+            end
+
+            validate_on_update do |event|
+              if !event.past? && event.uses_conference_manager? && (event.changed & CM_ATTRIBUTES).any?
+                if event.recording_type == ::Event::RECORDING_TYPE.index(:manual)
+                end_date_after_adjust = event.end_date + ::Event::EXTRA_TIME_FOR_EVENTS_WITH_MANUAL_REC
+                else
+                end_date_after_adjust = event.end_date
+                end
+                new_params = { :name => event.name,
+                  :mode => event.cm_mode,
+                  :initDate => event.start_date,
+                  :endDate => end_date_after_adjust,
+                  :enable_web => "1",
+                  :enable_isabel => "1",
+                  :enable_sip => event.sip_interface?,
+                  :enable_httplivestreaming => "0",
+                  :isabel_bw => event.isabel_bw,
+                  :web_bw => WEB_BANDWIDTH[event.web_bw],
+                  :recording_bw => RECORDING_BANDWIDTH[event.recording_bw],
+                  :httplivestreaming_bw => WEB_BANDWIDTH[event.web_bw],
+                  :web_codec => WEB_CODEC[event.web_bw],
+                  :recording_codec => RECORDING_CODEC[event.recording_bw],
+                  :path => "attachments/conferences/#{event.permalink}" }
+                cm_event = event.cm_event
+                cm_event.load(new_params)
+
+                begin
+                  cm_event.save
+                rescue  StandardError =>e
+                event.errors.add_to_base(e.to_s)
+                end
+              end
+            end
+
+            before_destroy do |event|
+              if event.uses_conference_manager?
+                # Delete event in conference Manager
+                begin
+                  cm_event = ConferenceManager::Event.find(event.cm_event_id)
+                  cm_event.destroy
+                rescue ActiveResource::ResourceNotFound => e
+                  true
+                else
+                true
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+      module InstanceMethods
+        # The conference manager mode
+        def cm_mode
+          case vc_mode_sym
+          when :telemeeting
+            'meeting'
+          when :teleconference
+            'conference'
+          when :teleclass
+            'class'
+          else
+          raise "Unknown Conference Manager mode: #{ vc_mode_sym }"
+          end
+        end
+
+        def uses_conference_manager?
+          case vc_mode_sym
+          when :telemeeting, :teleconference, :teleclass
+            true
+          else
+          false
+          end
+        end
+
+        def cm_event
+          unless self.cm_event_id
+            return nil
+          end
+          begin
+            @cm_event ||= ConferenceManager::Event.find(self.cm_event_id)
+          rescue
+            nil
+          end
+        end
+
+        def cm_event?
+          cm_event.present?
+        end
+
+        def web_url
+          cm_event.try(:web_url)
+        end
+
+        def sip_url
+          cm_event.try(:sip_url)
+        end
+
+        def isabel_url
+          cm_event.try(:isabel_url)
+        end
+
+        def httplivestreaming_url
+          cm_event.try(:httplivestreaming_url)
+        end
+
+        # Returns a String that contains a html with the video of the Isabel Web Gateway
+        %w( player editor streaming ).each do |obj|
+          eval <<-EOM
+      def #{ obj }(width = '640', height = '480', type = 'flash')
+        begin
+          cm_#{ obj } ||=
+            ConferenceManager::#{ obj.classify }.find(:#{ obj },
+                                                      :params => { :width => width,
+                                                                   :height => height,
+                                                                   :type => type,
+                                                                   :event_id => cm_event_id })
+          cm_#{ obj }.html
+        rescue
+          nil
+        end
+      end
+        EOM
+        end
+
+        def web(username, width = '640', height = '480')
+          begin
+            cm_web ||=
+            ConferenceManager::Web.find(:web,
+            :params => { :username => username,
+              :width => width,
+              :height => height,
+              :event_id => cm_event_id })
+            cm_web.html
+          rescue
+            nil
+          end
+        end
+
+        def webstats
+          begin
+            cm_webstats ||=
+            ConferenceManager::Webstats.find(:webstat,
+            :params => { :event_id => cm_event_id })
+            cm_webstats.html
+          rescue
+            nil
+          end
+        end
+
+        def webmap
+          begin
+            cm_webmap ||=
+            ConferenceManager::Webmap.find(:webmap,
+            :params => { :event_id => cm_event_id })
+            cm_webmap.html
+          rescue
+            nil
+          end
+        end
+
+        def start!
+          begin
+            ConferenceManager::Start.create(:event_id => cm_event_id)
+          rescue  StandardError => e
+            errors.add_to_base(e.to_s)
+          end
+        end
+
+        #method to ask the conference manager the id of the entry being recorded
+        #returns nil if nothing is being recorded
+        def get_entry_being_recorded
+          begin
+            @event_status ||= ConferenceManager::EventStatus.find("event-status", :params => { :event_id => cm_event_id})
+            unless @event_status.nil?
+              if @event_status.attributes["recording_session"]
+                ae = ::AgendaEntry.find_by_cm_session_id(@event_status.attributes["recording_session"])
+                if ae.event == self
+                return ae.id
+                end
+              end
+            end
+            return nil
+          rescue
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conference_manager/models/conference_manager_session.rb

@@ -0,0 +1,248 @@
+module ConferenceManager
+  module Models
+    module ConferenceManagerSession
+      CM_ATTRIBUTES = ["title", "cm_streaming", "cm_recording", "start_time", "end_time"]
+      PAST_UNCHANGEABLE_ATTRIBUTES = ["cm_streaming", "cm_recording", "start_time", "end_time"]
+      CURRENT_UNCHANGEABLE_ATTRIBUTES = ["cm_streaming", "cm_recording", "start_time"]
+      WAKE_UP_TIME = 2.minutes
+      SESSION_STATUS = {:init=>"Init",:recording=>"Recording",:recorded=>"Recorded",:published=>"Published"}
+
+      def self.included(mod)
+        mod.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def acts_as_conference_manager_session
+          include ConferenceManager::Models::ConferenceManagerSession::InstanceMethods
+        end
+
+        def included(base)
+          base.class_eval do
+
+            validate_on_create do |entry|
+
+            # Validation: Session must be future
+              if entry.errors.empty? && entry.event.uses_conference_manager? && entry.start_time < (Time.zone.now + WAKE_UP_TIME)
+                entry.errors.add_to_base(I18n.t('agenda.entry.error.past_times',
+                :min_date => I18n.l(Time.zone.now + WAKE_UP_TIME), :format => '%d %b %Y %H:%M'))
+              end
+
+              #Session creation on Conference Manager
+              if entry.errors.empty? && entry.event.uses_conference_manager?
+
+                cm_s =
+                ConferenceManager::Session.new(:name => "none",
+                :recording => entry.cm_recording?,
+                :streaming => entry.cm_streaming?,
+                :initDate=> ((entry.start_time - entry.event.start_date)*1000).to_i,
+                :endDate=> ((entry.end_time - entry.event.start_date)*1000).to_i,
+                :event_id => entry.event.cm_event_id)
+                begin
+                  cm_s.save
+                  entry.cm_session = cm_s
+                rescue => e
+                entry.errors.add_to_base(e.to_s)
+                end
+              end
+            end
+
+            validate_on_update do |entry|
+
+              if entry.errors.empty? && entry.event.uses_conference_manager?
+
+                # Validation: In past sessions cannot be edited PAST_UNCHANGEABLE_ATTRIBUTES
+                if entry.end_time_was.present? && entry.end_time_was.past?
+                  entry.errors.add_to_base(I18n.t('agenda.entry.error.attribute_unchangeable')) if (entry.changed & PAST_UNCHANGEABLE_ATTRIBUTES).any?
+
+                # Validation: In current sessions cannot be edited CURRENT_UNCHANGEABLE_ATTRIBUTES
+                elsif entry.end_time_was.present? && !(entry.end_time_was.past?) && entry.start_time_was.present? && Time.now.in_time_zone > (entry.start_time_was - WAKE_UP_TIME)
+                  entry.errors.add_to_base(I18n.t('agenda.entry.error.attribute_unchangeable')) if (entry.changed & CURRENT_UNCHANGEABLE_ATTRIBUTES).any?
+                end
+              end
+
+              #Session update on Conference Manager
+              if !entry.past? && entry.errors.empty? && entry.event.uses_conference_manager? && (((entry.changed & CM_ATTRIBUTES).any?)||(entry.date_update_action.eql?"move_event")||(entry.date_update_action.eql?"start_date"))
+                if (!entry.date_update_action.eql?"move_event")
+                  cm_s = entry.cm_session
+                  new_params = { :name => entry.title,
+                    :recording => entry.cm_recording?,
+                    :streaming => entry.cm_streaming?,
+                    :initDate=> ((entry.start_time - entry.event.start_date)*1000).to_i,
+                    :endDate=> ((entry.end_time - entry.event.start_date)*1000).to_i,
+                    :event_id => entry.event.cm_event_id }
+
+                  if entry.cm_session?
+                  cm_s.load(new_params)
+                  else
+                    entry.errors.add_to_base(I18n.t('event.error.cm_connection'))
+                  end
+
+                  begin
+                    cm_s.save
+                  rescue => e
+                    if cm_s.present?
+                    entry.errors.add_to_base(e.to_s)
+                    end
+                  end
+                end
+              end
+            end
+
+            before_destroy do |entry|
+            #Delete session in Conference Manager if event is not in-person
+              if entry.event.uses_conference_manager?
+                begin
+                  cm_s = entry.cm_session
+                  cm_s.destroy
+                rescue => e
+                  entry.errors.add_to_base(I18n.t('agenda.entry.error.delete'))
+                false
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+      module InstanceMethods
+        def cm_session
+          begin
+            @cm_session ||=
+            ConferenceManager::Session.find(cm_session_id,
+            :params => { :event_id => event.cm_event_id })
+          rescue
+            nil
+          end
+        end
+
+        def cm_session=(cms_s)
+          self.cm_session_id = cms_s.id
+          @cm_session = cms_s
+        end
+
+        def cm_session?
+          cm_session.present?
+        end
+
+        def status
+          begin
+            @session_status ||=
+            ConferenceManager::SessionStatus.find(:status,
+            :params => { :event_id => event.cm_event_id,
+              :session_id => cm_session_id})
+          rescue
+            nil
+          end
+        end
+
+        def can_edit_hours?
+          !(event.uses_conference_manager? && past?)
+        end
+
+        #Return  a String that contains a html with the video player for this session
+        #with the default width and height, 640x480
+        def player
+          player("640","480")
+        end
+
+        #Return  a String that contains a html with the video player for this session
+        def player(width, height)
+          begin
+            @cm_player_session ||=
+            ConferenceManager::PlayerSession.find(:player,
+            :params => { :event_id => event.cm_event_id,
+              :session_id => cm_session.id,
+              :width => width,
+              :height => height})
+            @cm_player_session.html
+          rescue
+            nil
+          end
+        end
+
+        #Return  a String that contains a html with the video editor for this session
+        def editor(width, height)
+          begin
+            @cm_player_session ||=
+            ConferenceManager::EditorSession.find(:player,
+            :params => { :event_id => event.cm_event_id,
+              :session_id => cm_session.id,
+              :width => width,
+              :height => height})
+            @cm_player_session.html
+          rescue
+            nil
+          end
+        end
+
+        #method that changes the recording status of this session
+        #remember that the rest of the sessions of this event will stop the recording if you init one
+        def change_status(new_status)
+          cm_status = status
+          new_params = {:event_id => event.cm_event_id,
+            :session_id => cm_session_id,
+            :status => new_status}
+          cm_status.load(new_params)
+          begin
+            cm_status.save
+          rescue => e
+            if cm_status.present?
+              errors.add_to_base(e.to_s)
+            end
+          end
+        end
+
+        #method to check if the video has been published
+        #either by the user or because the event has finished
+        def check_published_recording
+          cm_status = status
+          debugger
+          puts "hola"
+        end
+
+        #method to get the session status
+        #it can be any in SESSION_STATUS
+        def session_status
+          cm_status = status
+          if cm_status
+            cm_status.attributes["status"]
+          end
+        end
+
+        #method to start the recording
+        #remember that the rest of the sessions of this event will stop the recording
+        def start_recording
+          cm_status = status
+          new_params = {:event_id => event.cm_event_id,
+            :session_id => cm_session_id,
+            :status => SESSION_STATUS[:recording]}
+          cm_status.load(new_params)
+          begin
+            cm_status.save
+          rescue => e
+            if cm_status.present?
+              errors.add_to_base(e.to_s)
+            end
+          end
+        end
+
+        #method to stop the recording
+        def stop_recording
+          cm_status = status
+          new_params = {:event_id => event.cm_event_id,
+            :session_id => cm_session_id,
+            :status => SESSION_STATUS[:recorded]}
+          cm_status.load(new_params)
+          begin
+            cm_status.save
+          rescue => e
+            if cm_status.present?
+              errors.add_to_base(e.to_s)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conference_manager/player.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class Player < Resource
+    singleton
+    
+    self.element_name = "player" 
+    self.site = domain 
+    self.prefix = "/events/:event_id/"
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager/player_session.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class PlayerSession < Resource
+    singleton
+   
+    self.element_name = "player" 
+    self.site = domain
+    self.prefix = "/events/:event_id/sessions/:session_id/" 
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager/resource.rb

@@ -0,0 +1,45 @@
+module ConferenceManager
+  class Resource < ActiveResource::Base
+    class << self
+      def domain
+        Site.current.cm_domain.present? ? Site.current.cm_domain : "http://vcc-test.dit.upm.es:8080"
+      end
+      
+      def subclasses
+        @subclasses ||= []
+      end
+      
+      def inherited(subclass)
+        @subclasses = subclasses | Array(subclass)
+        super
+      end
+      
+      def reload
+        subclasses.each{ |subclass|
+          subclass.site = subclass.domain
+        }
+      end
+
+      # This is a single resource, like web or recording, but not events.
+      def singleton
+        @singleton = true
+      end
+
+      # redefine this two methods to remove .format extension
+      def collection_path(prefix_options = {}, query_options = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        @singleton ?
+        "#{prefix(prefix_options)}#{collection_name.singularize}#{query_string(query_options)}" :
+        "#{prefix(prefix_options)}#{collection_name}#{query_string(query_options)}"
+      end
+      
+      
+      def element_path(id, prefix_options = {}, query_options = nil)
+        prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+        @singleton ?
+        "#{prefix(prefix_options)}#{collection_name.singularize}#{query_string(query_options)}" :
+        "#{prefix(prefix_options)}#{collection_name}/#{id}#{query_string(query_options)}"
+      end
+    end
+  end
+end

data/lib/conference_manager/session.rb

@@ -0,0 +1,15 @@
+module ConferenceManager
+  class Session < Resource
+    self.element_name = "session" 
+    self.site = domain
+    self.prefix = "/events/:event_id/"
+    
+    def recording?
+      recording == "true"
+    end  
+    
+    def streaming?
+      streaming == "true"
+    end
+  end
+end

data/lib/conference_manager/session_status.rb

@@ -0,0 +1,14 @@
+module ConferenceManager
+  class SessionStatus < Resource
+    singleton
+   
+    self.element_name = "session-status" 
+    self.site = domain
+    self.prefix = "/events/:event_id/sessions/:session_id/" 
+
+    def new?
+      false      
+    end
+    
+  end
+end

data/lib/conference_manager/start.rb

@@ -0,0 +1,9 @@
+module ConferenceManager
+  class Start < Resource
+    singleton
+
+    self.element_name = "restart" 
+    self.site = domain
+    self.prefix = "/events/:event_id/"
+  end   
+end

data/lib/conference_manager/streaming.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class Streaming < Resource
+    singleton
+    
+    self.element_name = "streaming" 
+    self.site = domain
+    self.prefix = "/events/:event_id/"
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager/web.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class Web < Resource
+    singleton
+
+    self.element_name = "web" 
+    self.site = domain
+    self.prefix = "/events/:event_id/" 
+    self.format = ActiveResource::Formats::HtmlFormat
+    
+  end
+end

data/lib/conference_manager/webmap.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class Webmap < Resource
+    singleton
+    
+    self.element_name = "webmap" 
+    self.site = domain 
+    self.prefix = "/events/:event_id/"
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager/webstats.rb

@@ -0,0 +1,11 @@
+module ConferenceManager
+  class Webstats < Resource
+    singleton
+    
+    self.element_name = "webstat" 
+    self.site = domain 
+    self.prefix = "/events/:event_id/"
+    self.format = ActiveResource::Formats::HtmlFormat
+
+  end
+end

data/lib/conference_manager-ruby.rb

@@ -0,0 +1,14 @@
+module ConferenceManager 
+  module Models
+    autoload :ConferenceManagerEvent, 'conference_manager/models/conference_manager_event.rb'
+    autoload :ConferenceManagerSession, 'conference_manager/models/conference_manager_session.rb'
+  end  
+  class Engine < Rails::Engine    
+    initializer "conference_manager-ruby.models" do
+      ActiveSupport.on_load(:active_record) do
+        include ConferenceManager::Models::ConferenceManagerEvent
+        include ConferenceManager::Models::ConferenceManagerSession
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: conference_manager-ruby
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- GING-UPM
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-01 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  name: activeresource
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 10
+        - 3
+        version: 0.10.3
+  type: :development
+  name: ruby-debug
+  version_requirements: *id002
+description: Ruby wrapping for Conference Manager.
+email: vcc@dit.upm.es
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .yardopts
+- Gemfile
+- README.rdoc
+- Rakefile
+- conference_magener-ruby.gemspec
+- lib/conference_manager-ruby.rb
+- lib/conference_manager/editor.rb
+- lib/conference_manager/editor_session.rb
+- lib/conference_manager/event.rb
+- lib/conference_manager/event_status.rb
+- lib/conference_manager/models/conference_manager_event.rb
+- lib/conference_manager/models/conference_manager_session.rb
+- lib/conference_manager/player.rb
+- lib/conference_manager/player_session.rb
+- lib/conference_manager/resource.rb
+- lib/conference_manager/session.rb
+- lib/conference_manager/session_status.rb
+- lib/conference_manager/start.rb
+- lib/conference_manager/streaming.rb
+- lib/conference_manager/web.rb
+- lib/conference_manager/webmap.rb
+- lib/conference_manager/webstats.rb
+has_rdoc: true
+homepage: http://github.com/ging/conference_manager-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Ruby wrapping for Conference Manager.
+test_files: []
+