Add Question and Answer models for option questions

Phase 1: Data Model Implementation
- Created Question model with billable association, ordered scope
- Created Answer model with person/question associations
- Added validations for question types (radio/textarea)
- Implemented choice removal handling (nullifies affected answers)
- Prevented question type changes when answers exist
- Added nested attributes support to Billable and Person models
- Updated controllers to handle questions and answers
- Added applicable_questions method to Person model
- All existing tests pass

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: rubys

app/controllers/billables_controller.rb

@@ -217,7 +217,8 @@ def set_billable
 
     # Only allow a list of trusted parameters through.
     def billable_params
-      params.expect(billable: [:type, :name, :price, :order, :couples, :table_size, { options: {} }, { packages: {} }])
+      params.expect(billable: [:type, :name, :price, :order, :couples, :table_size, { options: {} }, { packages: {} },
+        { questions_attributes: [:id, :question_text, :question_type, :choices, :order, :_destroy] }])
     end
 
     def update_includes

app/controllers/people_controller.rb

@@ -646,10 +646,11 @@ def update
     respond_to do |format|
       if @person.update(update)
         update_options
+        update_answers
 
-        format.html { 
+        format.html {
           redirect_url = params[:return_to].presence || person_url(@person)
-          redirect_to redirect_url, notice: "#{@person.display_name} was successfully updated." 
+          redirect_to redirect_url, notice: "#{@person.display_name} was successfully updated."
         }
         format.json { render :show, status: :ok, location: @person }
       else
@@ -881,7 +882,8 @@ def set_person
 
     # Only allow a list of trusted parameters through.
     def person_params
-      params.expect(person: [:name, :studio_id, :type, :back, :level_id, :age_id, :category, :role, :exclude_id, :package_id, :independent, :invoice_to_id, :available, :table_id, { options: {} }])
+      params.expect(person: [:name, :studio_id, :type, :back, :level_id, :age_id, :category, :role, :exclude_id, :package_id, :independent, :invoice_to_id, :available, :table_id, { options: {} },
+        { answers_attributes: [:id, :question_id, :answer_value] }])
     end
 
     def filtered_params(person)
@@ -1113,7 +1115,7 @@ def update_options
       desired_options = person_params[:options] || {}
       option_tables = params[:person][:option_tables] || {}
       current_options = @person.options.group_by(&:option_id)
-      
+
       Billable.where(type: 'Option').each do |option|
         got = current_options[option.id]&.length || 0
         want = desired_options[option.id.to_s].to_i
@@ -1130,7 +1132,7 @@ def update_options
           current_options[option.id].pop.destroy
           got -= 1
         end
-        
+
         # Update table assignment for existing PersonOption records
         if got > 0 && current_options[option.id]
           current_options[option.id].each do |person_option|
@@ -1142,6 +1144,27 @@ def update_options
       end
     end
 
+    def update_answers
+      answers_data = person_params[:answers_attributes] || []
+
+      answers_data.each do |answer_attrs|
+        question_id = answer_attrs[:question_id]
+        answer_value = answer_attrs[:answer_value]
+
+        next unless question_id
+
+        answer = @person.answers.find_or_initialize_by(question_id: question_id)
+
+        if answer_value.present?
+          answer.answer_value = answer_value
+          answer.save
+        elsif answer.persisted?
+          # If value is empty and answer exists, update to nil
+          answer.update(answer_value: nil)
+        end
+      end
+    end
+
     def list_heats
       Heat.joins(:entry).where(entry: {follow_id: @person.id}).
         or(Heat.joins(:entry).where(entry: {lead_id: @person.id}))

app/models/answer.rb

@@ -0,0 +1,6 @@
+class Answer < ApplicationRecord
+  belongs_to :person
+  belongs_to :question
+
+  validates :person_id, uniqueness: { scope: :question_id }
+end

app/models/billable.rb

@@ -20,6 +20,9 @@ class Billable < ApplicationRecord
   has_many :people_option_link, class_name: 'PersonOption', dependent: :destroy, foreign_key: :option_id
   has_many :people_options, through: :people_option_link, source: :person
   has_many :tables, foreign_key: :option_id, dependent: :destroy
+  has_many :questions, dependent: :destroy
+
+  accepts_nested_attributes_for :questions, allow_destroy: true
 
   def people
     if type == 'Option'

app/models/person.rb

@@ -42,6 +42,9 @@ class Person < ApplicationRecord
   has_many :formations, dependent: :destroy
   has_many :options, class_name: 'PersonOption', foreign_key: :person_id,
     dependent: :destroy
+  has_many :answers, dependent: :destroy
+
+  accepts_nested_attributes_for :answers
 
   has_many :scores, dependent: :destroy, foreign_key: :judge_id
   has_many :payments, dependent: :destroy
@@ -177,6 +180,25 @@ def eligible_heats(start_times)
     end
   end
 
+  # Get all questions for this person based on their package and selected options
+  def applicable_questions
+    question_ids = Set.new
+
+    # Questions from package
+    if package
+      package.package_includes.each do |pi|
+        question_ids.merge(pi.option.questions.pluck(:id))
+      end
+    end
+
+    # Questions from directly selected options
+    options.each do |person_option|
+      question_ids.merge(person_option.option.questions.pluck(:id))
+    end
+
+    Question.where(id: question_ids.to_a).ordered
+  end
+
   def self.nobody
     person = Person.find_or_create_by(id: 0)
 

app/models/question.rb

@@ -0,0 +1,44 @@
+class Question < ApplicationRecord
+  belongs_to :billable
+  has_many :answers, dependent: :destroy
+
+  # Rails 8.0 compatible ordering scope
+  scope :ordered, -> { order(arel_table[:order]) }
+
+  validates :question_text, presence: true
+  validates :question_type, presence: true, inclusion: { in: %w[radio textarea] }
+  validate :choices_present_for_radio
+  validate :prevent_type_change_with_answers
+
+  # Serialize choices as JSON
+  serialize :choices, coder: JSON
+
+  before_save :handle_choice_removal
+
+  private
+
+  def choices_present_for_radio
+    if question_type == 'radio' && (choices.nil? || choices.empty?)
+      errors.add(:choices, "must be present for radio questions")
+    end
+  end
+
+  def prevent_type_change_with_answers
+    if question_type_changed? && persisted? && answers.exists?
+      errors.add(:question_type, "cannot be changed when answers exist")
+    end
+  end
+
+  def handle_choice_removal
+    return unless question_type == 'radio' && choices_changed? && persisted?
+
+    old_choices = choices_was || []
+    new_choices = choices || []
+    removed_choices = old_choices - new_choices
+
+    return if removed_choices.empty?
+
+    # Nullify answers that match removed choices
+    answers.where(answer_value: removed_choices).update_all(answer_value: nil)
+  end
+end

db/migrate/20251006000001_create_questions.rb

@@ -0,0 +1,15 @@
+class CreateQuestions < ActiveRecord::Migration[8.0]
+  def change
+    create_table :questions do |t|
+      t.references :billable, null: false, foreign_key: true
+      t.text :question_text, null: false
+      t.string :question_type, null: false
+      t.text :choices
+      t.integer :order
+
+      t.timestamps
+    end
+
+    add_index :questions, [:billable_id, :order]
+  end
+end

db/migrate/20251006000002_create_answers.rb

@@ -0,0 +1,13 @@
+class CreateAnswers < ActiveRecord::Migration[8.0]
+  def change
+    create_table :answers do |t|
+      t.references :person, null: false, foreign_key: true
+      t.references :question, null: false, foreign_key: true
+      t.text :answer_value
+
+      t.timestamps
+    end
+
+    add_index :answers, [:person_id, :question_id], unique: true
+  end
+end