open_conference_ware 1.0.0.pre1

data/app/controllers/open_conference_ware/authentications_controller.rb

@@ -0,0 +1,42 @@
+module OpenConferenceWare
+  class AuthenticationsController < ApplicationController
+    before_filter :require_auth_hash, only: [:create]
+
+    def sign_in
+      page_title "Sign In"
+    end
+
+    def sign_out
+      cookies.delete :auth_token
+      reset_session
+      flash[:notice] = "You have been logged out."
+
+      redirect_back_or_default
+    end
+
+    def create
+      @authentication = Authentication.find_and_update_or_create_from_auth_hash(auth_hash)
+
+      if @authentication.user
+        self.current_user = @authentication.user
+      elsif logged_in?
+        @authentication.user = current_user
+        @authentication.save
+      else
+        self.current_user = User.create_from_authentication(@authentication)
+      end
+
+      redirect_back_or_default
+    end
+
+    protected
+
+    def auth_hash
+      request.env['omniauth.auth']
+    end
+
+    def require_auth_hash
+      redirect_to(sign_in_path) and return unless auth_hash
+    end
+  end
+end

data/app/controllers/open_conference_ware/comments_controller.rb

@@ -0,0 +1,86 @@
+module OpenConferenceWare
+  class CommentsController < ApplicationController
+
+    SECRET = OpenConferenceWare.comments_secret
+
+    MAX_FEED_ITEMS = 50
+
+    before_filter :require_admin, except: [:index, :create]
+
+    def index
+      @comments = Comment.listable
+      add_breadcrumb "Comments", comments_path()
+
+      if [:atom, :json, :xml].include?(request.format.to_sym)
+        unless params[:secret] == SECRET
+          render(text: "403 Forbidden: You can't see the comments feed unless you supply the secret key", status: 403) and return
+        end
+        @comments = @comments[0..MAX_FEED_ITEMS]
+      else
+        if admin?
+          respond_to do |format|
+            format.html  # index.html.erb
+            format.atom
+          end
+        else
+          require_admin
+        end
+      end
+    end
+
+    # This is a weird action. The form is part of the proposals#show page, so errors and successes both go back to that page.
+    def create
+      if params[:quagmire].present?
+        flash[:failure] = "Comment rejected because you're behaving like a robot, please leave the 'Leave blank' field blank."
+        redirect_to(:back) rescue redirect_to proposals_path()
+        return
+      end
+
+      @proposal = Proposal.find(params[:proposal_id])
+      @comment = @proposal.comments.new(comment_params)
+
+      # Use session to store email address and prefill it as needed
+      if @comment.email.blank?
+        @comment.email = current_email
+      else
+        session[:email] = @comment.email
+      end
+
+      respond_to do |format|
+        if @comment.save
+          flash[:success] = "Comment added."
+          format.html { redirect_to(proposal_path(@comment.proposal, commented: true)) }
+          format.xml  { render xml: @comment, status: :created }
+          format.json { render json: @comment, status: :created }
+        else
+          @display_comment_form = true
+          @focus_comment = true
+          flash[:failure] = "Invalid comment."
+
+          format.html { render template: "open_conference_ware/proposals/show" }
+          format.xml  { render xml: @comment.errors, status: :unprocessable_entity }
+          format.json { render json: @comment.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    def destroy
+      @comment = Comment.find(params[:id])
+      @comment.destroy
+      flash[:success] = "Destroyed comment: #{@comment.id}"
+
+      respond_to do |format|
+        format.html {
+          redirect_to(:back) rescue redirect_to(comments_path)
+        }
+      end
+    end
+
+  private
+
+    def comment_params
+      params.require(:comment).permit(:name, :email, :message)
+    end
+
+  end
+end

data/app/controllers/open_conference_ware/events_controller.rb

@@ -0,0 +1,36 @@
+module OpenConferenceWare
+  class EventsController < ApplicationController
+    include BreadcrumbsMixin
+    add_breadcrumb "Events", "/events"
+
+    before_filter :assert_current_event_or_redirect
+    before_filter :normalize_event_path_or_redirect
+    before_filter :assert_proposal_status_published, only: :speakers
+    before_filter :require_admin, only: [:selector_votes]
+
+    def index
+      @events = Event.order("deadline asc")
+
+      respond_to do |format|
+        format.html
+        format.json { render json: @events }
+      end
+    end
+
+    def show
+      respond_to do |format|
+        format.html { redirect_to event_proposals_path(@event) }
+        format.json { render json: @event }
+      end
+    end
+
+    def speakers
+      assign_prefetched_hashes
+
+      respond_to do |format|
+        format.html
+        format.csv { render csv: @speakers, style: admin? ? :full : :public }
+      end
+    end
+  end
+end

data/app/controllers/open_conference_ware/manage/events_controller.rb

@@ -0,0 +1,157 @@
+module OpenConferenceWare
+  module Manage
+    class EventsController < ApplicationController
+      before_filter :require_admin
+      before_filter :assert_current_event_or_redirect, only: [:show, :edit, :update, :destroy]
+
+      include BreadcrumbsMixin
+      add_breadcrumb "Manage", "/manage"
+      add_breadcrumb "Events", "/manage/events"
+
+      # GET /events
+      # GET /events.xml
+      def index
+        @events = Event.lookup
+
+        respond_to do |format|
+          format.html # index.html.erb
+          format.xml  { render xml: @events }
+        end
+      end
+
+      # GET /events/1
+      # GET /events/1.xml
+      def show
+        warn_about_incomplete_event
+
+        add_breadcrumb @event.title, manage_event_path(@event)
+
+        respond_to do |format|
+          format.html # show.html.erb
+          format.xml  { render xml: @event }
+        end
+      end
+
+      # GET /events/new
+      # GET /events/new.xml
+      def new
+        @event = Event.new
+        if params[:parent_id]
+          @event.parent_id = params[:parent_id]
+        end
+
+        respond_to do |format|
+          format.html # new.html.erb
+          format.xml  { render xml: @event }
+        end
+      end
+
+      # GET /events/1/edit
+      def edit
+        @return_to = params[:return_to] || request.env["HTTP_REFERER"]
+      end
+
+      # POST /events
+      # POST /events.xml
+      def create
+        @event = Event.new(event_params)
+
+        respond_to do |format|
+          if @event.save
+            flash[:notice] = 'Event was successfully created.'
+            format.html { redirect_to(manage_event_path(@event)) }
+            format.xml  { render xml: @event, status: :created, location: @event }
+          else
+            format.html { render action: "new" }
+            format.xml  { render xml: @event.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # PUT /events/1
+      # PUT /events/1.xml
+      def update
+        @return_to = params[:return_to]
+
+        respond_to do |format|
+          if @event.update_attributes(event_params)
+            flash[:notice] = 'Event was successfully updated.'
+            format.html { redirect_to(@return_to ? @return_to : [:manage, @event]) }
+            format.xml  { head :ok }
+          else
+            format.html { render action: "edit" }
+            format.xml  { render xml: @event.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /events/1
+      # DELETE /events/1.xml
+      def destroy
+        @event.destroy
+        flash[:success] = "Destroyed event: #{@event.title}"
+
+        respond_to do |format|
+          format.html { redirect_to(manage_events_path) }
+          format.xml  { head :ok }
+        end
+      end
+
+      def proposals
+        # NOTE: This is the bulk editor for the admin.
+        @proposals = @event.proposals.populated
+      end
+
+      # POST /events/1/notify_speakers
+      def notify_speakers
+        emailed = []
+        already_emailed = []
+        proposals = params[:proposal_ids].split(',')
+        proposals.each do |proposal_id|
+          proposal = Proposal.lookup(proposal_id)
+          next unless proposal
+          case params[:proposal_status]
+          when 'accepted'
+            e, a = proposal.notify_accepted_speakers
+          when 'rejected'
+            e, a = proposal.notify_rejected_speakers
+          else
+            raise ArgumentError, "No proposal_status specified"
+          end
+          emailed << e if e
+          already_emailed << a if a
+        end
+        flash[:success] = "Notified these speakers: "
+        flash[:success] << ( emailed.count == 0 ? "none" : emailed.join(' &amp; ') )
+        unless already_emailed.count == 0
+          flash[:success] << "<br/>These proposal speakers were not emailed because they have already been notified: #{already_emailed.join(' &amp; ')}."
+        end
+        redirect_to(manage_event_proposals_path(@event))
+      end
+
+      private
+
+        def event_params
+          params.require(:event).permit(
+            :slug,
+            :title,
+            :deadline,
+            :open_text,
+            :closed_text,
+            :session_text,
+            :tracks_text,
+            :start_date,
+            :end_date,
+            :proposal_status_published,
+            :accept_proposal_comments_after_deadline,
+            :schedule_published,
+            :proposal_titles_locked,
+            :accept_selector_votes,
+            :show_proposal_confirmation_controls,
+            :parent,
+            :parent_id
+          ) if admin?
+        end
+    end
+  end
+end

data/app/controllers/open_conference_ware/manage/snippets_controller.rb

@@ -0,0 +1,110 @@
+module OpenConferenceWare
+  module Manage
+    class SnippetsController < ApplicationController
+      before_filter :require_admin
+
+      include BreadcrumbsMixin
+      add_breadcrumb "Manage", "/manage"
+      add_breadcrumb "Snippets", "/manage/snippets/"
+
+      # GET /snippets
+      # GET /snippets.xml
+      def index
+        @snippets = Snippet.order(:slug).where(public: true)
+
+        respond_to do |format|
+          format.html # index.html.erb
+          format.xml  { render xml: @snippets }
+        end
+      end
+
+      # GET /snippets/1
+      # GET /snippets/1.xml
+      def show
+        @snippet = Snippet.find(params[:id])
+        add_breadcrumb @snippet.slug, manage_snippet_path(@snippet)
+
+        respond_to do |format|
+          format.html # show.html.erb
+          format.xml  { render xml: @snippet }
+        end
+      end
+
+      # GET /snippets/new
+      # GET /snippets/new.xml
+      def new
+        @snippet = Snippet.new
+
+        respond_to do |format|
+          format.html # new.html.erb
+          format.xml  { render xml: @snippet }
+        end
+      end
+
+      # GET /snippets/1/edit
+      def edit
+        @snippet = Snippet.find(params[:id])
+        add_breadcrumb @snippet.slug, manage_snippet_path(@snippet)
+
+        @return_to = params[:return_to] || request.env["HTTP_REFERER"]
+      end
+
+      # POST /snippets
+      # POST /snippets.xml
+      def create
+        @snippet = Snippet.new(snippet_params)
+
+        respond_to do |format|
+          if @snippet.save
+            flash[:notice] = 'Snippet was successfully created.'
+            format.html { redirect_to([:manage, @snippet]) }
+            format.xml  { render xml: @snippet, status: :created, location: @snippet }
+          else
+            format.html { render action: "new" }
+            format.xml  { render xml: @snippet.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # PUT /snippets/1
+      # PUT /snippets/1.xml
+      def update
+        @snippet = Snippet.find(params[:id])
+        add_breadcrumb @snippet.slug, manage_snippet_path(@snippet)
+
+        @return_to = params[:return_to]
+
+        respond_to do |format|
+          if @snippet.update_attributes(snippet_params)
+            flash[:notice] = 'Snippet was successfully updated.'
+            format.html { redirect_to(@return_to ? @return_to : [:manage, @snippet]) }
+            format.xml  { head :ok }
+          else
+            format.html { render action: "edit" }
+            format.xml  { render xml: @snippet.errors, status: :unprocessable_entity }
+          end
+        end
+      end
+
+      # DELETE /snippets/1
+      # DELETE /snippets/1.xml
+      def destroy
+        @snippet = Snippet.find(params[:id])
+        @snippet.destroy
+
+        respond_to do |format|
+          format.html { redirect_to manage_snippets_path, :flash => {:success => "Snippet was deleted."} }
+          format.xml  { head :ok }
+        end
+      end
+
+      private
+
+        def snippet_params
+          params.require(:snippet).permit(
+            :slug, :description, :content, :value, :public
+          ) if admin?
+        end
+    end
+  end
+end

data/app/controllers/open_conference_ware/proposals_controller.rb

@@ -0,0 +1,521 @@
+module OpenConferenceWare
+  class ProposalsController < ApplicationController
+
+    before_filter :authentication_required, only: [:edit, :update, :destroy, :speaker_confirm, :speaker_decline, :proposal_login_required]
+    before_filter :assert_current_event_or_redirect
+    before_filter :assert_proposal_status_published, only: [:sessions_index, :sessions_index_terse, :session_show]
+    before_filter :assert_schedule_published, only: [:schedule]
+    before_filter :normalize_event_path_or_redirect, only: [:index, :sessions_index, :schedule]
+    before_filter :assert_anonymous_proposals, only: [:new, :create]
+    before_filter :assert_accepting_proposals, only: [:new, :create]
+    before_filter :assign_proposal_and_event, only: [:show, :session_show, :edit, :update, :destroy, :speaker_confirm, :speaker_decline]
+    before_filter :assert_record_ownership, only: [:edit, :update, :destroy, :speaker_confirm, :speaker_decline]
+    before_filter :assert_user_complete_profile, only: [:new, :edit, :update]
+    before_filter :assign_proposals_breadcrumb
+
+    MAX_FEED_ITEMS = 50
+    SESSION_RELATED_ACTIONS = ['sessions_index', 'session_show', 'schedule']
+
+    def proposals_or_sessions
+      if @event && @event.proposal_status_published?
+        redirect_to event_sessions_path(@event)
+      else
+        redirect_to event_proposals_path(@event)
+      end
+    end
+
+    # GET /proposals
+    # GET /proposals.xml
+    def index
+      warn_about_incomplete_event
+
+      @kind = :proposals
+
+      assign_prefetched_hashes
+      @proposals = Defer { @proposals_hash.values }
+
+      unless params[:sort]
+        params[:sort] = "submitted_at"
+        params[:dir] = "desc"
+      end
+
+      respond_to do |format|
+        format.html {
+          add_breadcrumb @event.title, event_proposals_path(@event)
+        }
+        format.xml  {
+          render xml: @proposals
+        }
+        format.json {
+          render json: @proposals
+        }
+        format.atom {
+          # index.atom.builder
+          if @event_assignment == :assigned_to_param
+            @cache_key = "proposals_atom,event_#{@event.id}"
+            @proposals = Defer { @event.populated_proposals(:proposals).order("submitted_at desc").limit(MAX_FEED_ITEMS) }
+          else
+            @cache_key = "proposals_atom,all"
+            @proposals = Defer { Proposal.populated.order("submitted_at desc").limit(MAX_FEED_ITEMS) }
+          end
+        }
+        format.csv {
+          records = @event.populated_proposals(@kind).includes(:comments)
+          if admin?
+            render csv: records, style: :admin
+          else
+            if schedule_visible?
+              render csv: records, style: :schedule
+            else
+              render csv: records
+            end
+          end
+        }
+      end
+    end
+
+    def sessions_index
+      @kind = :sessions
+
+      assign_prefetched_hashes
+      @proposals = Defer { @sessions_hash.values }
+
+      params[:sort] ||= "track"
+
+      respond_to do |format|
+        format.html {
+          add_breadcrumb @event.title, event_proposals_path(@event)
+          render action: "index"
+        }
+        format.xml  {
+          render xml: @proposals
+        }
+        format.json {
+          render json: @proposals
+        }
+      end
+    end
+
+    def sessions_index_terse
+      assign_prefetched_hashes
+    end
+
+    def schedule
+      page_title 'Schedule'
+
+      @schedule = Defer { Schedule.new(@event, admin?) }
+      assign_prefetched_hashes
+
+      respond_to do |format|
+        format.html {
+          @view_cache_key = "schedule,event_#{@event.id},admin_#{admin?}"
+        }
+        format.json {
+          render json: @schedule
+        }
+        format.xml {
+          ### render xml: @schedule
+          render xml: {error: "XML output of schedule not yet supported"}, status: :unprocessable_entity
+        }
+        format.ics {
+          view_cache_key = "schedule,event_#{@event.id}.ics"
+          data = Rails.cache.fetch(view_cache_key) {
+            Proposal.to_icalendar(
+              @schedule.items,
+              title: "#{@event.title}",
+              url_helper: lambda {|item| session_url(item)})
+          }
+          render text: data
+        }
+      end
+    end
+
+    def session_show
+      # @proposal and @event set via #assign_proposal_and_event filter
+      @kind = :session
+      unless @proposal.confirmed?
+        @redirector = lambda {
+          flash[:failure] = "This proposal is not a session."
+          return redirect_to( proposal_path(@proposal) )
+        }
+      end
+      return base_show
+    end
+
+    # GET /proposals/1
+    # GET /proposals/1.xml
+    def show
+      # @proposal and @event set via #assign_proposal_and_event filter
+      @kind = :proposal
+      if @event.proposal_status_published? && @proposal.confirmed?
+        @redirector = lambda {
+          # flash[:notice] = "This proposal has been accepted as a session."
+          flash.keep
+          return redirect_to( session_path(@proposal) )
+        }
+      end
+      return base_show
+    end
+
+    # GET /proposals/new
+    # GET /proposals/new.xml
+    def new
+      add_breadcrumb @event.title, event_proposals_path(@event)
+      add_breadcrumb "Create a proposal", new_event_proposal_path(@event)
+
+      @proposal = Proposal.new(agreement: false)
+
+      # Set default track if only one was found.
+      if event_tracks? && @event.tracks.size == 1
+        @proposal.track = @event.tracks.first
+      end
+
+      # Set default session_type if only one was found.
+      if event_session_types? && @event.session_types.size == 1
+        @proposal.session_type = @event.session_types.first
+      end
+
+      if logged_in?
+        @proposal.presenter = current_user.fullname
+        @proposal.add_user(current_user)
+      end
+      @proposal.email = current_email
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.xml  { render xml: @proposal }
+        format.json { render json: @proposal }
+      end
+    end
+
+    # GET /proposals/1/edit
+    def edit
+      # @proposal set via #assign_proposal filter
+
+      @event = @proposal.event
+      add_breadcrumb @event.title, event_proposals_path(@event)
+      add_breadcrumb @proposal.title, proposal_path(@proposal)
+    end
+
+    # POST /proposals
+    # POST /proposals.xml
+    def create
+      @proposal = @event.proposals.new(proposal_params)
+      @proposal.add_user(current_user) if logged_in?
+      @proposal.transition = transition_from_params if admin?
+
+      manage_speakers_on_submit
+
+      respond_to do |format|
+        if params[:speaker_submit].blank? && params[:preview].nil? && @proposal.save
+          format.html {
+            # Display a page thanking users for submitting a proposal and telling them what to do next.
+            page_title "Thank You!"
+          }
+          format.xml  { render xml: @proposal, status: :created, location: @proposal }
+          format.json { render json: @proposal, status: :created, location: @proposal }
+        else
+          @proposal.valid? if params[:preview]
+          format.html { render action: "new" }
+          format.xml  { render xml: @proposal.errors, status: :unprocessable_entity }
+          format.json { render json: @proposal.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # PUT /proposals/1
+    # PUT /proposals/1.xml
+    def update
+      # @proposal and @event set via #assign_proposal_and_event filter
+      
+      # If proposal title editing is locked, prevent non-admin from modifying title.
+      if params[:proposal] && @event.proposal_titles_locked? && ! admin?
+        params[:proposal].delete(:title)
+      end
+
+      if params[:start_time] && admin?
+        if params[:start_time][:date].blank? || params[:start_time][:hour].blank? || params[:start_time][:minute].blank?
+          @proposal.start_time = nil
+        else
+          @proposal.start_time = "#{params[:start_time][:date]} #{params[:start_time][:hour]}:#{params[:start_time][:minute]}"
+        end
+      end
+
+      @proposal.assign_attributes(proposal_params)
+
+      add_breadcrumb @event.title, event_proposals_path(@event)
+      add_breadcrumb @proposal.title, proposal_path(@proposal)
+
+      manage_speakers_on_submit
+
+      respond_to do |format|
+        if params[:speaker_submit].blank? && params[:preview].nil? && @proposal.save
+          @proposal.transition = transition_from_params if admin?
+          format.html {
+            flash[:success] = 'Updated proposal.'
+            redirect_to(@proposal)
+          }
+          format.xml  { head :ok }
+          format.json { 
+            render(
+              json: {
+                proposal_status: @proposal.status,
+                _transition_control_html: render_to_string(partial: '/proposals/transition_control')
+              }, 
+              status: :ok
+            )
+          }
+        else
+          @proposal.valid? if params[:preview]
+
+          format.html { render action: "edit" }
+          format.xml  { render xml: @proposal.errors, status: :unprocessable_entity }
+          format.json { render json: @proposal.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+    # DELETE /proposals/1
+    # DELETE /proposals/1.xml
+    def destroy
+      # @proposal and @event set via #assign_proposal_and_event filter
+
+      @proposal.destroy
+      flash[:success] = "Destroyed proposal: #{@proposal.title}"
+
+      respond_to do |format|
+        format.html { redirect_to(event_proposals_path(@proposal.event)) }
+        format.xml  { head :ok }
+        format.json { head :ok }
+      end
+    end
+
+    def manage_speakers
+      @proposal = get_proposal_for_speaker_manager(params[:id], params[:speakers])
+
+      if params[:add]
+        user = User.find(params[:add])
+        @proposal.add_user(user)
+      elsif params[:remove]
+        user = User.find(params[:remove])
+        @proposal.remove_user(user)
+      end
+
+      respond_to do |format|
+        format.html { render partial: "manage_speakers", layout: false }
+      end
+    end
+
+    def search_speakers
+      @proposal = get_proposal_for_speaker_manager(params[:id], params[:speakers])
+      @matches = get_speaker_matches(params[:search])
+
+      respond_to do |format|
+        format.html { render partial: "search_speakers", layout: false }
+      end
+    end
+
+    def stats
+      # Uses @event
+    end
+
+    # GET /proposals/1/login
+    def proposal_login_required
+      return redirect_to(proposal_path(params[:proposal_id]))
+    end
+
+    def speaker_confirm
+      # @proposal and @event set via #assign_proposal_and_event filter
+      if current_user_is_proposal_speaker? and @proposal.confirm!
+        flash[:success] = 'Updated proposal. Thank you for confirming!'
+      end
+      redirect_to(@proposal)
+    end
+
+    def speaker_decline
+      # @proposal and @event set via #assign_proposal_and_event filter
+      if current_user_is_proposal_speaker? and @proposal.decline!
+        flash[:success] = 'Updated proposal.'
+      end
+      redirect_to(@proposal)
+    end
+
+  protected
+
+    def proposal_params
+      permitted = [
+        :presenter,
+        :affiliation,
+        :email,
+        :website,
+        :biography,
+        :title,
+        :description,
+        :excerpt,
+        :agreement,
+        :note_to_organizers,
+        :track_id,
+        :session_type_id,
+        :speaking_experience,
+        :audience_level]
+
+      permitted += [:status, :room_id, :start_time, :audio_url] if admin?
+
+      params.require(:proposal).permit(permitted)
+    end
+
+    # Is this event accepting proposals? If not, redirect with a warning.
+    def assert_accepting_proposals
+      unless accepting_proposals? || admin?
+        flash[:failure] = Snippet.content_for(:proposals_not_accepted_error)
+        redirect_to @event ? event_proposals_path(@event) : proposals_path
+      end
+    end
+
+    # Ensure that anonymous users are allowed to add proposals
+    def assert_anonymous_proposals
+      if logged_in?
+        return false # Logged in users can always create
+      else
+        if anonymous_proposals?
+          return false # Anonymous proposals are allowed
+        else
+          flash[:notice] = "Please sign in so you can create and manage proposals."
+          store_location
+          return redirect_to(sign_in_path)
+        end
+      end
+    end
+
+    # Return the proposal and its assignment status for this request. The status
+    # can be:
+    # * :assigned_via_param
+    # * :invalid_proposal
+    # * :invalid_event
+    def get_proposal_and_assignment_status
+      if proposal = Proposal.lookup(params[:id].to_i) rescue nil
+        if proposal.event
+          return [proposal, :assigned_via_param]
+        else
+          return [proposal, :invalid_event]
+        end
+      else
+        return [proposal, :invalid_proposal]
+      end
+    end
+
+    def get_proposal_for_speaker_manager(proposal_id, speaker_ids_string)
+      if proposal_id.blank? || proposal_id == "new_record"
+        proposal = Proposal.new
+        speaker_ids_string.split(',').each do |speaker|
+          proposal.add_user(speaker)
+        end
+      else
+        proposal = Proposal.find(proposal_id)
+      end
+      return proposal
+    end
+
+    # Assign @proposal and @event from parameters, or redirect with warnings.
+    def assign_proposal_and_event
+      @proposal, @proposal_assignment_status = get_proposal_and_assignment_status()
+      case @proposal_assignment_status
+      when :assigned_via_param
+        @event = @proposal.event
+        return false # Successfully found both @event and @proposal
+      when :invalid_proposal
+        flash[:failure] = "Sorry, that presentation proposal doesn't exist or has been deleted."
+        return redirect_to(action: :index)
+      when :invalid_event
+        flash[:failure] = "Sorry, no event was associated with proposal ##{@proposal.id}"
+        return redirect_to(action: :index)
+      end
+    end
+
+    def assert_user_complete_profile
+      if user_profiles? and logged_in? and not current_user.complete_profile?
+        current_user.complete_profile = true
+        if current_user.valid?
+          current_user.save
+        else
+          flash[:notice] = "Please complete your profile before creating a proposal."
+          store_location
+          return redirect_to(edit_user_path(current_user, require_complete_profile: true))
+        end
+      end
+    end
+
+    def assign_proposals_breadcrumb
+      add_breadcrumb "Proposals", proposals_path
+    end
+
+    def manage_speakers_on_submit
+      if params[:speaker_ids].present?
+        speakers = params[:speaker_ids].map(&:first)
+        unless speakers.blank?
+          speakers.each do |speaker|
+            @proposal.add_user(speaker)
+          end
+        end
+      end
+    end
+
+    # Return the name of a transition (e.g., "accept") from a Proposal's params.
+    def transition_from_params
+      return params[:proposal].present? ? params[:proposal][:transition] : nil
+    end
+
+    # Return a sanitized Regexp for matching a speaker by name from the +query+ string.
+    def get_speaker_matcher(query)
+      string = query.gsub(/[[:punct:]]/, ' ').gsub(/\s{2,}/, ' ').strip
+      return Regexp.new(Regexp.escape(string), Regexp::IGNORECASE)
+    end
+
+    # Return an array of speakers (User records) matching the +query+ string.
+    def get_speaker_matches(query)
+      if query.blank? || ! query.match(/\w+/)
+        return []
+      else
+        matcher = get_speaker_matcher(query)
+        return(User.complete_profiles.select{|u| u.fullname.try(:match, matcher)} - @proposal.users)
+      end
+    end
+
+    # Base method used for #show and #session_show
+    def base_show
+      if selector? && @event.accept_selector_votes?
+        @selector_vote = @proposal.selector_votes.find_or_initialize_by(user_id: current_user.id)
+      end
+
+      unless defined?(@redirector)
+        add_breadcrumb @event.title, event_proposals_path(@event)
+        add_breadcrumb @proposal.title, proposal_path(@proposal)
+
+        @profile = @proposal.profile
+        @comment = @proposal.comments.new(email: current_email)
+        @display_comment_form = \
+          # Admin can always leave comments
+          admin? || (
+            # Display comment form if the event is accepting proposals
+            accepting_proposals? ||
+            # or if the settings provide a toggle and the event is accepting comments
+            (event_proposal_comments_after_deadline? && @event.accept_proposal_comments_after_deadline?)
+          )
+        @focus_comment = false
+      end
+
+      respond_to do |format|
+        format.html { 
+          if defined?(@redirector)
+            @redirector.call
+          else
+            render template: "open_conference_ware/proposals/show"
+          end
+        }
+        format.xml  { render xml: @proposal }
+        format.json { render json: @proposal }
+      end
+    end
+
+  end
+end