open_conference_ware 1.0.0.pre1

data/lib/tasks/mediawiki.rake

@@ -0,0 +1,96 @@
+namespace :open_conference_ware do
+  namespace :mediawiki do
+    def get_wiki_credentials
+      return @get_wiki_credentials ||= begin
+        require 'ostruct'
+
+        missing = nil
+
+        credentials          = OpenStruct.new
+        credentials.user     = ENV['USER']     or missing = "USER"
+        credentials.password = ENV['PASSWORD'] or missing = "PASSWORD"
+        credentials.url      = ENV['URL']      or missing = "URL"
+
+        if missing
+          puts <<-HERE
+MediaWiki credentials must include:
+  * USER: The admin user to login to the wiki as.
+  * PASSWORD: The admin user's password.
+  * URL: The URL for the server's "api.php".
+
+For example:
+    rake --trace open_conference_ware:mediawiki:populate USER=admin PASSWORD=secret URL=http://opensourcebridge.org/2011/w/api.php EVENT=2011
+          HERE
+
+          raise ArgumentError, "No #{missing} defined"
+        else
+          credentials
+        end
+      end
+    end
+
+    def sanitize_string(string)
+      return CGI.unescape(OpenConferenceWare::Proposal._session_notes_url_escape(string))
+    end
+
+    def event_wiki_title(event)
+      return "Category:#{sanitize_string(event.title)}"
+    end
+    
+    def tracks_wiki_title(event)
+      return "Category:#{sanitize_string(event.title)} tracks"
+    end
+
+    def track_wiki_title(track)
+      #IK# return "Category:#{track.title} :: #{track.event.title}"
+      return "Category:#{sanitize_string(track.title)}"
+    end
+
+    def session_wiki_title(session)
+      #IK# return "#{session.title} :: #{session.event.title}"
+      return "#{sanitize_string(session.event.slug)}/#{sanitize_string(session.title)}"
+    end
+
+    desc "Populates the attendee wiki with pages to hold session notes."
+    task :populate => :environment do
+      require 'lib/rwikibot_page_drone'
+
+      credentials = get_wiki_credentials
+      wiki = RWikiBot::Bot.new(credentials.user, credentials.password, credentials.url, '', true)
+      event = ENV['EVENT'] ? OpenConferenceWare::Event.find_by_slug(ENV['EVENT']) : OpenConferenceWare::Event.current
+
+      # Event page
+      drone = RwikibotPageDrone.new(wiki, event_wiki_title(event))
+      drone.replace_span "description", "For details, see [#{OpenConferenceWare.public_url} #{OpenConferenceWare.organization}]."
+      drone.save(true)
+
+      # Tracks page
+      drone = RwikibotPageDrone.new(wiki, tracks_wiki_title(event))
+      drone.replace_span "description", "Tracks for [#{OpenConferenceWare.public_url} #{OpenConferenceWare.organization}]."
+      drone.save(true)
+
+      # Tracks
+      event.tracks.includes(:event).each do |track|
+        drone = RwikibotPageDrone.new(wiki, track_wiki_title(track))
+        drone.append "[[#{event_wiki_title(track.event)}]]"
+        drone.append "[[#{tracks_wiki_title(track.event)}]]"
+        drone.replace_span "description", "#{textilize track.description}"
+        drone.save(true)
+      end
+      
+      # Sessions
+      event.proposals.confirmed.includes(:event, :track, :session_type).each do |proposal|
+        drone = RwikibotPageDrone.new(wiki, session_wiki_title(proposal))
+        content = "[[#{event_wiki_title(proposal.event)} notes]] [[#{track_wiki_title(proposal.track)} notes]]"
+        content << "#{textilize proposal.excerpt} " unless proposal.excerpt.blank?
+        content << "<p>Speaker#{proposal.users.size > 1 ? 's' : ''}: #{proposal.users.map{|user| sprintf('[%susers/%s %s]', OpenConferenceWare.app_root_url, user.id, user.fullname)}.join(', ')}</p>"
+        content << "<p>Return to [#{sprintf '%ssessions/%s', OpenConferenceWare.app_root_url, proposal.id} this session's details]</p>"
+        content << "\n= Contributed notes =\n"
+        drone.replace_span("generated", content)
+        drone.append "<!-- DO NOT CHANGE ANYTHING ABOVE THIS LINE -->"
+        drone.append "(Add your notes here!)"
+        drone.save(true)
+      end
+    end
+  end
+end

data/lib/tasks/open_conference_ware_tasks.rake

@@ -0,0 +1,16 @@
+namespace :open_conference_ware do
+  desc %{Setup application's database and seed data}
+  task :setup => ['db:migrate', 'db:seed'] do
+    puts <<-HERE
+
+TO FINISH SETUP
+1. See README.markdown for information about security and customization
+2. Start the server, e.g.: bin/rails server
+3. Sign in as an admin in development mode
+4. Use the web-based admin interface to create and configure an event
+    HERE
+  end
+end
+
+Rake::Task["open_conference_ware:install:migrations"].clear
+

data/lib/tasks/schedule.rake

@@ -0,0 +1,103 @@
+namespace :open_conference_ware do
+  namespace :schedule do
+    namespace :import do
+      desc "Import schedule from CSV file."
+      task :csv => :environment do
+        unless ENV['CSV'] and ENV['EVENT']
+          puts <<-HERE
+  schedule:import:csv
+
+  Usage:
+    rake schedule:import:csv RAILS_ENV=production EVENT=2010 CSV=schedule.csv
+
+  CSV format:
+    Your CSV file must have a header with these titles and data:
+    * date
+    * time
+    * proposal_id
+          HERE
+          exit 1
+        end
+
+        event_slug = ENV['EVENT']
+        csv_file = ENV['CSV']
+
+        event = Event.find_by_slug(event_slug)
+        puts "* Loaded event by slug: #{event.slug}"
+
+        has_seen_header = false
+        puts "* Reading CSV file: #{csv_file}"
+        CSV.foreach(csv_file) do |row|
+          date, time, proposal_id = row
+          if has_seen_header
+            proposal = Proposal.find(proposal_id)
+            datetime = Time.zone.parse "#{date} #{time}"
+            puts "- Setting #{datetime.inspect} for #{proposal.title}"
+            proposal.update_attribute(:start_time, datetime)
+          else
+            expected_header = %w[date time proposal_id]
+            unless expected_header == row
+              puts "ERROR: your CSV file header must be #{expected_header.inspect}"
+              exit 1
+            end
+            puts "* Validated CSV header"
+            has_seen_header = true
+          end
+        end
+      end
+
+      desc "Import schedule from Google Spread Sheet"
+      task :google_spreadsheet => :environment do
+        require 'google_spreadsheet'
+
+        if raw = SECRETS.schedule_google_spreadsheet
+          auth = OpenStruct.new(raw)
+        else
+          puts <<-HERE
+  ERROR: No credentials found for importing. Please add your credentials in the
+        following format to your "config/secrets.yml" file:
+
+      schedule_google_spreadsheet:
+        login: 'your@google.account'
+        password: 'your_password'
+        key: 'your_key'
+
+          HERE
+          raise ArgumentError, "No credentials"
+        end
+
+        gs = GoogleSpreadsheet.login(auth.login, auth.password).spreadsheet_by_key(auth.key)
+
+        print "- Loading ... "
+        STDOUT.flush
+        data = gs.worksheets.select{|sheet| sheet.title.include?("Exportable")}.map do |sheet|
+          sheet.rows[1..-1].map do |row|
+            {
+              :id => row[0],
+              :room_id => row[1],
+              :start_time => Time.zone.parse("#{row[2]} #{row[3]}")
+            }
+          end
+        end.flatten
+        puts "#{data.size} records"
+
+        print "- Saving ..."
+        STDOUT.flush
+        data.each do |scheduled|
+          if scheduled[:id].to_i > 0
+            begin
+              session = Proposal.find(scheduled[:id])
+              session.room_id = scheduled[:room_id]
+              session.start_time = scheduled[:start_time]
+              session.save
+            rescue ActiveRecord::RecordNotFound
+              puts "! Unknown record: #{scheduled.inspect}"
+            end
+          end
+        end
+        puts "done!"
+
+      end
+    end
+  end
+end

data/lib/tasks/snippets.rake

@@ -0,0 +1,23 @@
+namespace :open_conference_ware do
+  namespace :snippets do 
+    desc "Load initial snippets of text. Use FORCE environmental variable to avoid prompt if these are already present."
+    task :reload => ["environment"] do
+      replace = false
+      perform = true
+      if OpenConferenceWare::Snippet.count > 0 and not ENV["FORCE"]
+        replace = true
+        print "?? WARNING: Reset snippets back to defaults? (y/N) "
+        STDOUT.flush
+        response = STDIN.readline
+        unless response.strip.match(/y/i)
+          puts "** Not resetting snippets back to defaults"
+          perform = false
+        end
+      end
+
+      # TODO Merge snippets for Tickets and Proposals apps
+      #IK# Rake::Task["snippets:load"].invoke if perform
+      OpenConferenceWare::Snippet.reload_from_fixtures! if perform
+    end
+  end
+end

data/open_conference_ware.gemspec

@@ -0,0 +1,67 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "open_conference_ware/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "open_conference_ware"
+  s.version     = OpenConferenceWare::VERSION
+  s.authors     = ["Igal Koshevoy", "Reid Beels", "Kirsten Comandich", "Audrey Eschright", "et al."]
+  s.email       = ["reid@opensourcebridge.org"]
+  s.homepage    = "http://openconferenceware.org"
+  s.summary     = "An open source web application for events and conferences. "
+  s.description = "OpenConferenceWare is an open source web application for events and conferences. This customizable, general-purpose platform provides proposals, sessions, schedules, tracks and more."
+
+  s.require_paths = ["lib"]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+
+  cert = File.expand_path("~/.ssh/gem-private_key_ocw.pem")
+  if File.exist?(cert)
+    s.signing_key = cert
+    s.cert_chain = ["gem-public_cert.pem"]
+  end
+
+  s.add_dependency "rails", "~> 4.0.2"
+  s.add_dependency "rails-observers", "~> 0.1.2"
+
+  # Authentication
+  s.add_dependency "omniauth", "~> 1.1.4"
+
+  s.add_dependency "hashery"
+
+  s.add_dependency 'RedCloth'
+  s.add_dependency 'aasm'
+  s.add_dependency 'acts-as-taggable-on'
+  s.add_dependency 'color'
+  s.add_dependency 'comma',               '~> 3.0'
+  s.add_dependency 'gchartrb',            '~> 0.8.0' #, :require => 'google_chart'
+  s.add_dependency 'paperclip'
+  s.add_dependency 'vpim'
+  s.add_dependency 'nokogiri'
+  s.add_dependency 'prawn'
+  s.add_dependency 'dalli'
+  s.add_dependency "dynamic_form"
+  s.add_dependency 'rinku' #, :require => 'rails_rinku'
+
+  # Assets
+  s.add_dependency 'jquery-rails'
+  s.add_dependency 'sass-rails', " ~> 4.0.0"
+  s.add_dependency 'uglifier'
+
+  # Development
+  s.add_development_dependency "sqlite3"
+
+  # Testing
+  s.add_development_dependency 'omniauth-openid'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'factory_girl_rails'
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'cucumber-rails'
+  s.add_development_dependency 'guard-rspec'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'cadre'
+  s.add_development_dependency 'coveralls'
+end

data/spec/controllers/open_conference_ware/application_controller_spec.rb

@@ -0,0 +1,309 @@
+require 'spec_helper'
+
+describe OpenConferenceWare::ApplicationController do
+  fixtures :all
+  routes { OpenConferenceWare::Engine.routes }
+
+  def can_edit?(*args)
+    return @controller.send(:can_edit?, *args)
+  end
+
+  def accepting_proposals?(*args)
+    return @controller.send(:accepting_proposals?, *args)
+  end
+
+  describe "can_edit?" do
+    describe "users" do
+      it "should allow user to edit own" do
+        login_as :quentin
+        can_edit?(users(:quentin)).should be_true
+      end
+
+      it "should not allow user to edit other's" do
+        login_as :quentin
+        can_edit?(users(:clio)).should be_false
+      end
+
+      it "should allow admin to edit other's" do
+        login_as :aaron
+        can_edit?(users(:clio)).should be_true
+      end
+    end
+
+    describe "proposals" do
+      describe "accepting_proposals?" do
+        it "should be false without anything defined" do
+          accepting_proposals?.should_not be_true
+        end
+
+        it "should be true when given open event" do
+          accepting_proposals?(events(:open)).should be_true
+        end
+
+        it "should be false when given closed event" do
+          accepting_proposals?(events(:closed)).should_not be_true
+        end
+
+        it "should be true when given open proposal" do
+          accepting_proposals?(proposals(:quentin_widgets)).should be_true
+        end
+
+        it "should be false when given closed proposal" do
+          accepting_proposals?(proposals(:clio_chupacabras)).should_not be_true
+        end
+
+        it "should be true when assigned open event instance" do
+          @controller.instance_variable_set(:@event, events(:open))
+          accepting_proposals?.should be_true
+        end
+
+        it "should be false when assigned closed instance" do
+          @controller.instance_variable_set(:@event, events(:closed))
+          accepting_proposals?.should_not be_true
+        end
+      end
+
+      describe "when accepting" do
+        it "should allow user to edit own when accepting proposals" do
+          login_as :quentin
+          proposal = proposals(:quentin_widgets)
+          can_edit?(proposal).should be_true
+        end
+        
+        it "should allow user to edit own before a status has been set" do
+          login_as :quentin
+          proposal = proposals(:quentin_widgets)
+          proposal.status = 'proposed'
+          can_edit?(proposal).should be_true
+        end
+        
+        it "should not allow user to edit own once a status has been set" do
+          login_as :quentin
+          proposal = proposals(:quentin_widgets)
+          proposal.status = 'accepted'
+          pending # TODO decide when to stop editing
+          can_edit?(proposal).should be_false
+        end
+
+        it "should not allow user to edit other's when accepting proposals" do
+          login_as :quentin
+          can_edit?(proposals(:aaron_aardvarks)).should be_false
+        end
+      end
+
+      describe "when not accepting" do
+        it "should not allow user to edit own when not accepting proposals" do
+          login_as :clio
+          pending "FIXME do we really want people to be able to edit forever?"
+          can_edit?(proposals(:clio_chupacabras)).should be_false
+        end
+
+        it "should allow admin to edit other's when not accepting proposals" do
+          login_as :aaron
+          can_edit?(proposals(:clio_chupacabras)).should be_true
+        end
+      end
+    end
+
+    it "should not allow anonymous to edit anything" do
+      can_edit?(Proposal.first).should be_false
+    end
+
+    it "should fail on nil" do
+      login_as :quentin
+      lambda { can_edit? }.should raise_error(ArgumentError)
+    end
+
+    it "should fail on unknown record type" do
+      login_as :quentin
+      lambda { can_edit?(42) }.should raise_error(TypeError)
+    end
+  end
+
+  describe "assign_current_event_without_redirecting" do
+    it "should detected :assigned_already" do
+      @controller.instance_variable_set(:@event, events(:open))
+      @controller.send(:assign_current_event_without_redirecting)
+
+      @controller.instance_variable_get(:@event_assignment).should == :assigned_already
+    end
+  end
+
+  describe "assert_current_event_or_redirect" do
+    describe "when no events" do
+      it "should direct admin users to event manager" do
+        login_as :aaron
+        @controller.instance_variable_set(:@event_assignment, :empty)
+        @controller.should_receive(:manage_events_path)
+        @controller.should_receive(:redirect_to)
+        @controller.send(:assert_current_event_or_redirect)
+
+        flash[:failure].should_not be_blank
+      end
+
+      it "should display a failure for non-admins" do
+        logout
+        @controller.instance_variable_set(:@event_assignment, :empty)
+        @controller.should_receive(:render)
+        @controller.send(:assert_current_event_or_redirect)
+
+        flash[:failure].should_not be_blank
+      end
+    end
+  end
+
+  # These specs are evil. Surely there's a better way to describe the behavior of controller methods that rely on a request without testing them through an action?
+  describe "normalize_event_path_or_redirect" do
+    describe "with HTML" do
+      it "should not redirect canonical requests" do
+        @controller.should_receive(:request).at_least(:once).and_return(double(OpenStruct,
+          path: OpenConferenceWare.mounted_path('/events/123/proposals'),
+          format: 'html'))
+        @controller.send(:normalize_event_path_or_redirect).should be_false
+      end
+
+      it "should redirect incomplete requests and keep flash" do
+        event = events(:open)
+        @flash = double("Flash Container")
+        @controller.stub(:request).and_return(double("Request",
+          path: '/proposals',
+          format: 'html',
+          protocol: 'http',
+          host_with_port: 'foo:80',
+          flash: @flash
+        ))
+
+        @controller.instance_variable_set(:@event, event)
+        @controller.should_receive(:redirect_to).with(OpenConferenceWare.mounted_path("/events/#{event.to_param}/application/"))
+        @flash.should_receive(:keep)
+
+        @controller.send(:normalize_event_path_or_redirect)
+      end
+    end
+
+    describe "with JSON" do
+      it "should not redirect canonical requests" do
+        @controller.should_receive(:request).at_least(:once).and_return(double(OpenStruct,
+          path: '/events/123/proposals',
+          format: 'json'))
+        @controller.send(:normalize_event_path_or_redirect).should be_false
+      end
+
+      it "should redirect incomplete requests" do
+        @controller.should_receive(:request).at_least(:once).and_return(double(OpenStruct,
+          path: '/proposals',
+          format: 'json'))
+        @controller.send(:normalize_event_path_or_redirect).should be_false
+      end
+    end
+  end
+
+  describe "assert_schedule_published" do
+    before(:each) do
+      @event = stub_current_event!
+      @controller.instance_variable_set(:@event, @event)
+    end
+
+    describe "as admin" do
+      before(:each) do
+        login_as :aaron
+      end
+
+      it "should be able to view schedule when it's published" do
+        @controller.stub(:schedule_visible?).and_return(true)
+        @controller.should_not_receive(:redirect_to)
+
+        result = @controller.send(:assert_schedule_published)
+        flash[:failure].should be_blank
+      end
+
+      it "should be able to view schedule before it's published" do
+        @controller.stub(:schedule_visible?).and_return(false)
+        @controller.should_not_receive(:redirect_to)
+
+        result = @controller.send(:assert_schedule_published)
+        flash[:failure].should be_blank
+        flash[:notice].should_not be_blank
+      end
+    end
+
+    describe "as non-admin" do
+      before(:each) do
+        logout
+      end
+
+      it "should be able to view schedule when it's published" do
+        @controller.stub(:schedule_visible?).and_return(true)
+        @controller.should_not_receive(:redirect_to)
+
+        result = @controller.send(:assert_schedule_published)
+        flash[:failure].should be_blank
+      end
+
+      it "should not be able to view schedule before it's published" do
+        @controller.stub(:schedule_visible?).and_return(false)
+        @controller.should_receive(:redirect_to)
+
+        @controller.send(:assert_schedule_published)
+        flash[:failure].should_not be_blank
+      end
+    end
+
+  end
+
+  describe "current_user_cache_key" do
+    it "should return id of currently logged-in user" do
+      user = users(:quentin)
+      login_as user
+
+      @controller.send(:current_user_cache_key).should == user.id
+    end
+
+    it "should return -1 if not logged in" do
+      logout
+
+      @controller.send(:current_user_cache_key).should == -1
+    end
+  end
+
+  describe "current_event_cache_key" do
+    it "should return id of current event" do
+      event = events(:open)
+      @controller.instance_variable_set(:@event, event)
+
+      @controller.send(:current_event_cache_key).should == event.id
+    end
+
+    it "should return -1 if no current event" do
+      @controller.instance_variable_set(:@event, nil)
+
+      @controller.send(:current_event_cache_key).should == -1
+    end
+  end
+
+  describe "developer_mode?" do
+    it "should not be in development mode when testing" do
+      @controller.send(:development_mode?).should be_false
+    end
+  end
+
+  describe "#notify" do
+    it "should set a message if one isn't defined" do
+      @controller.send(:notify, :failure, "OMG")
+
+      flash[:failure].should == "OMG"
+    end
+
+    it "should append a message if one is defined" do
+      @controller.send(:notify, :failure, "OMG.")
+      @controller.send(:notify, :failure, "WTF.")
+      @controller.send(:notify, :failure, "BBQ.")
+
+      flash[:failure].should == "OMG. WTF. BBQ."
+    end
+
+    it "should fail if given an invalid level" do
+      lambda { @controller.send(:notify, :omg, "kittens") }.should raise_error(ArgumentError)
+    end
+  end
+end