Merge pull request #949 from amatsuda/proposal_state_enum

Define Proposal state transitioning methods as Enum events

Author: amatsuda

app/controllers/proposals_controller.rb

@@ -50,19 +50,19 @@ def confirm
   end
 
   def withdraw
-    @proposal.withdraw unless @proposal.confirmed?
+    @proposal.withdraw! unless @proposal.confirmed?
     flash[:info] = "As requested, your talk has been removed for consideration."
     redirect_to [@proposal.event, @proposal], status: :see_other
   end
 
   def decline
-    @proposal.decline
+    @proposal.decline!
     flash[:info] = "As requested, your talk has been removed for consideration."
     redirect_to [@proposal.event, @proposal], status: :see_other
   end
 
   def destroy
-    @proposal.destroy
+    @proposal.destroy!
     flash[:info] = "Your proposal has been deleted."
     redirect_to event_proposals_url(@event), status: :see_other
   end
@@ -102,7 +102,7 @@ def edit
 
   def update
     if params[:confirm]
-      @proposal.update(confirmed_at: Time.current)
+      @proposal.update!(confirmed_at: Time.current)
       redirect_to [@event, @proposal], flash: {success: 'Thank you for confirming your participation'}
     elsif @proposal.speaker_update_and_notify(proposal_params)
       redirect_to [@event, @proposal]

app/controllers/staff/proposals_controller.rb

@@ -37,7 +37,16 @@ def update_state
       authorize @proposal, :update_state?
     end
 
-    @proposal.update_state(params[:new_state])
+    case params[:new_state]
+    when 'soft_accepted'
+      @proposal.soft_accept
+    when 'soft_waitlisted'
+      @proposal.soft_waitlist
+    when 'soft_rejected'
+      @proposal.soft_reject
+    when 'submitted'
+      @proposal.finalized? ? @proposal.hard_reset : @proposal.reset
+    end
 
     respond_to do |format|
       format.html { redirect_to event_staff_program_proposals_path(@proposal.event), status: :see_other }

app/models/proposal.rb

@@ -11,19 +11,67 @@ class Proposal < ApplicationRecord
     rejected: 'rejected',
     withdrawn: 'withdrawn',
     not_accepted: 'not accepted'
-  }, default: :submitted
+  }, default: :submitted do
+    event :soft_accept do
+      transition :submitted => :soft_accepted
+    end
 
-  SOFT_STATES = [:soft_accepted, :soft_waitlisted, :soft_rejected, :submitted].freeze
-  FINAL_STATES = [:accepted, :waitlisted, :rejected, :withdrawn, :not_accepted].freeze
+    event :soft_waitlist do
+      transition :submitted => :soft_waitlisted
+    end
+
+    event :soft_reject do
+      transition :submitted => :soft_rejected
+    end
 
-  SOFT_TO_FINAL = {
-    soft_accepted: :accepted,
-    soft_rejected: :rejected,
-    soft_waitlisted: :waitlisted,
-    submitted: :rejected
-  }.with_indifferent_access.freeze
+    event :withdraw do
+      transition all - [:withdrawn] => :withdrawn
+
+      after do
+        reviewers.each do |reviewer|
+          Notification.create_for(reviewer, proposal: self, message: "Proposal, #{title}, withdrawn")
+        end
+      end
+    end
+
+    event :promote do
+      transition :waitlisted => :accepted
+    end
 
-  BECOMES_PROGRAM_SESSION = [:accepted, :waitlisted].freeze
+    event :decline do
+      transition [:accepted, :waitlisted] => :withdrawn
+
+      before do
+        self.confirmed_at = Time.current
+      end
+
+      after do
+        program_session.update(state: :declined)
+      end
+    end
+
+    event :finalize do
+      transition :soft_accepted => :accepted
+      transition :soft_rejected => :rejected
+      transition :soft_waitlisted => :waitlisted
+      transition :submitted => :rejected
+
+      after do
+        ProgramSession.create_from_proposal(self) if becomes_program_session?
+      end
+    end
+
+    event :reset do
+      transition [:soft_accepted, :soft_waitlisted, :soft_rejected] => :submitted
+    end
+
+    event :hard_reset do
+      transition [:accepted, :waitlisted, :rejected] => :submitted
+    end
+  end
+
+  SOFT_STATES = [:soft_accepted, :soft_waitlisted, :soft_rejected, :submitted].freeze
+  FINAL_STATES = [:accepted, :waitlisted, :rejected, :withdrawn, :not_accepted].freeze
 
   has_many :public_comments, dependent: :destroy
   has_many :internal_comments, dependent: :destroy
@@ -124,46 +172,11 @@ def custom_fields
     proposal_data[:custom_fields] || {}
   end
 
-  def update_state(new_state)
-    update(state: new_state)
-  end
-
-  def finalize
-    transaction do
-      update_state(SOFT_TO_FINAL[state]) if SOFT_TO_FINAL.key?(state)
-      if becomes_program_session?
-        ps = ProgramSession.create_from_proposal(self)
-        ps.persisted?
-      else
-        true
-      end
-    end
-  rescue ActiveRecord::RecordInvalid
-    false
-  end
-
-  def withdraw
-    withdrawn!
-    reviewers.each do |reviewer|
-      Notification.create_for(reviewer, proposal: self,
-                                        message: "Proposal, #{title}, withdrawn")
-    end
-  end
-
   def confirm
     update(confirmed_at: Time.current)
     program_session.confirm if program_session.present?
   end
 
-  def promote
-    accepted! if waitlisted?
-  end
-
-  def decline
-    update(state: :withdrawn, confirmed_at: Time.current)
-    program_session.update(state: :declined)
-  end
-
   # draft? is an alias for submitted?
   def draft?
     submitted?
@@ -174,7 +187,7 @@ def finalized?
   end
 
   def becomes_program_session?
-    BECOMES_PROGRAM_SESSION.include?(state.to_sym)
+    accepted? || waitlisted?
   end
 
   def confirmed?
@@ -272,7 +285,7 @@ def changeset_fields
   private
 
   def state_must_be_final_for_confirmation
-    errors.add(:state, "'#{state}' not a confirmable state.") unless FINAL_STATES.include?(state.to_sym)
+    errors.add(:state, "'#{state}' not a confirmable state.") unless finalized?
   end
 
   def abstract_length

spec/models/proposal_spec.rb

@@ -169,10 +169,10 @@
 
     describe "#finalize" do
       it "changes a soft state to a finalized state" do
-        Proposal::SOFT_TO_FINAL.each do |key, val|
-          proposal = create(:proposal_with_track, state: key)
+        {soft_accepted: :accepted, soft_rejected: :rejected, soft_waitlisted: :waitlisted, submitted: :rejected}.each do |from, to|
+          proposal = create(:proposal_with_track, state: from)
           proposal.finalize
-          expect(proposal.state.to_sym).to eq(val)
+          expect(proposal.state.to_sym).to eq(to)
         end
       end
 
@@ -199,18 +199,6 @@
       end
     end
 
-    describe "#update_state" do
-      it "updates the state" do
-        proposal = create(:proposal_with_track, state: :accepted)
-        proposal.update_state(:waitlisted)
-        expect(proposal).to be_waitlisted
-      end
-
-      it "rejects invalid states" do
-        proposal = create(:proposal_with_track, state: :accepted)
-        expect { proposal.update_state('almonds!') }.to raise_error(ArgumentError)
-      end
-    end
   end
 
   context "saving tags" do