rubyforgood
diff --git a/‎AGENTS.md‎
Lines changed: 1 addition & 3 deletions b/‎AGENTS.md‎
Lines changed: 1 addition & 3 deletions
diff --git a/‎app/controllers/event_registrations_controller.rb‎
Lines changed: 6 additions & 6 deletions b/‎app/controllers/event_registrations_controller.rb‎
Lines changed: 6 additions & 6 deletions
diff --git a/‎app/controllers/events/public_registrations_controller.rb‎
Lines changed: 159 additions & 40 deletions b/‎app/controllers/events/public_registrations_controller.rb‎
Lines changed: 159 additions & 40 deletions
diff --git a/‎app/controllers/events_controller.rb‎
Lines changed: 14 additions & 14 deletions b/‎app/controllers/events_controller.rb‎
Lines changed: 14 additions & 14 deletions
@@ -178,6 +178,7 @@ end
 - `TaggingSearchService` — Search and filter tagging data
 - `PersonFromUserService` — Create Person from User account
 - `BulkInviteService` — Bulk send welcome instructions and reset created_at for users
+- `FormBuilderService` — Builds configurable forms from composable sections with per-field visibility
 - `ModelDeduper` — Deduplication logic
 - `RichTextMigrator` — Rich text migration utility
 - `DisplayImagePresenter` — Image display logic
@@ -186,9 +187,6 @@ end
 
 - `EventRegistrationServices::ProcessConfirmation` — Registration confirmation flow
 - `EventRegistrationServices::PublicRegistration` — Public registration handling
-- `ExtendedEventRegistrationFormBuilder` — Extended registration form builder
-- `ShortEventRegistrationFormBuilder` — Short registration form builder
-- `ScholarshipApplicationFormBuilder` — Scholarship form builder
 
 ### Notifications
 
 
@@ -129,7 +129,7 @@ def process_confirm
   end
 
   def link_organization
-    @event_registration = EventRegistration.includes(:event, registrant: :person_forms).find(params[:id])
+    @event_registration = EventRegistration.includes(:event, registrant: :form_submissions).find(params[:id])
     authorize! @event_registration, to: :link_organization?
     @person = @event_registration.registrant
     @submitted_org_name = find_submitted_agency_name(@event_registration)
@@ -234,14 +234,14 @@ def find_submitted_agency_name(registration)
     form = registration.event.registration_form
     return nil unless form
 
-    field = form.form_fields.find_by(field_key: "agency_name")
+    field = form.form_fields.find_by(field_identifier: "agency_name")
     return nil unless field
 
-    PersonFormFormField
-      .joins(person_form: :person)
+    FormAnswer
+      .joins(form_submission: :person)
       .find_by(
-        person_forms: { person_id: registration.registrant_id, form_id: form.id },
+        form_submissions: { person_id: registration.registrant_id, form_id: form.id },
         form_field_id: field.id
-      )&.text
+      )&.submitted_answer
   end
 end
@@ -20,6 +20,7 @@ def new
 
       @form_fields = visible_form_fields
       @scholarship = scholarship_mode?
+      @scholarship_form = @event.scholarship_form if @scholarship
       @event = @event.decorate
     end
 
@@ -32,12 +33,15 @@ def create
       end
 
       @form = registration_form
-      form_params = params.dig(:public_registration, :form_fields)&.to_unsafe_h || {}
+      @scholarship = scholarship_mode?
+      @scholarship_form = @event.scholarship_form if @scholarship
+
+      all_params = params.dig(:public_registration, :form_fields)&.to_unsafe_h || {}
+      registration_params, scholarship_params = split_form_params(all_params)
 
-      @field_errors = validate_required_fields(form_params)
+      @field_errors = validate_required_fields(registration_params)
       if @field_errors.any?
         @form_fields = visible_form_fields
-        @scholarship = scholarship_mode?
         @event = @event.decorate
         render :new, status: :unprocessable_content
         return
@@ -48,15 +52,16 @@ def create
       result = EventRegistrationServices::PublicRegistration.call(
         event: @event,
         form: @form,
-        form_params: form_params,
-        scholarship_requested: scholarship_mode?
+        form_params: registration_params,
+        scholarship_requested: @scholarship,
+        person: current_user&.person
       )
 
       if result.success?
         registration = result.event_registration
 
-        if !registration.scholarship_requested? && @event.cost_cents.to_i > 0 && credit_card_payment?(form_params)
-          checkout_session = create_stripe_checkout_session(registration, form_params)
+        if !registration.scholarship_requested? && @event.cost_cents.to_i > 0 && credit_card_payment?(registration_params)
+          checkout_session = create_stripe_checkout_session(registration)
           redirect_to checkout_session.url, allow_other_host: true, status: :see_other
         else
           redirect_to registration_ticket_path(registration.slug),
@@ -90,47 +95,31 @@ def show
         return
       end
 
-      @person_form = @form.person_forms.find_by(person: person)
-      unless @person_form
+      @form_submission = @form.form_submissions.find_by(person: person)
+      unless @form_submission
         redirect_to event_path(@event), alert: "No registration form submission found."
         return
       end
 
-      @form_fields = if registration&.scholarship_requested?
-        @form.form_fields.where(status: :active).where.not(field_group: "payment").reorder(position: :asc)
-      else
-        @form.form_fields.where(status: :active).where.not(field_group: "scholarship").reorder(position: :asc)
-      end
-      @responses = @person_form.person_form_form_fields.index_by(&:form_field_id)
+      @form_fields = @form.form_fields.reorder(position: :asc)
+      @responses = @form_submission.form_answers.index_by(&:form_field_id)
       @event = @event.decorate
     end
 
     private
 
     def credit_card_payment?(form_params)
-      payment_method_field = @form.form_fields.find_by(field_key: "payment_method")
+      payment_method_field = @form.form_fields.find_by(field_identifier: "payment_method")
       return false unless payment_method_field
 
       form_params[payment_method_field.id.to_s] == "Credit Card"
     end
 
-    def number_of_attendees(form_params)
-      attendees_field = @form.form_fields.find_by(field_key: "number_of_attendees")
-      return 1 unless attendees_field
-
-      form_params[attendees_field.id.to_s].to_i
-    end
-
-    def create_stripe_checkout_session(registration, form_params)
+    def create_stripe_checkout_session(registration)
       person = registration.registrant
-      attendees = number_of_attendees(form_params)
-      amount = @event.cost_cents * attendees
+      amount = @event.cost_cents
 
       metadata = { event_registration_id: registration.id }
-      comments_field = @form.form_fields.find_by(field_key: "payment_comments")
-      if comments_field && form_params[comments_field.id.to_s].present?
-        metadata[:payment_comments] = form_params[comments_field.id.to_s]
-      end
 
       person.set_payment_processor :stripe
 
@@ -163,16 +152,146 @@ def scholarship_mode?
       params[:scholarship_requested] == "true"
     end
 
+    def split_form_params(all_params)
+      reg_field_ids = @form.form_fields.pluck(:id).map(&:to_s)
+      registration = all_params.slice(*reg_field_ids)
+
+      scholarship = {}
+      if @scholarship_form
+        scholarship_field_ids = @scholarship_form.form_fields.pluck(:id).map(&:to_s)
+        scholarship = all_params.slice(*scholarship_field_ids)
+      end
+
+      [ registration, scholarship ]
+    end
+
+    def create_or_update_scholarship_submission(person, scholarship_params)
+      scholarship_form = @event.scholarship_form
+      return unless scholarship_form
+
+      submission = FormSubmission.find_or_create_by!(
+        person: person, form: scholarship_form, role: "scholarship"
+      )
+
+      scholarship_params.each do |field_id, raw_value|
+        field = scholarship_form.form_fields.find_by(id: field_id)
+        next unless field
+        next if field.group_header?
+
+        text = raw_value.is_a?(Array) ? raw_value.reject(&:blank?).join(", ") : raw_value.to_s
+
+        record = submission.form_answers.find_or_initialize_by(form_field: field)
+        record.update!(submitted_answer: text, question_name_when_answered: field.name)
+      end
+    end
+
     def visible_form_fields
-      scope = @form.form_fields.where(status: :active)
-      if scholarship_mode?
-        scope = scope.where.not(field_group: "payment")
-      else
-        scope = scope.where.not(field_group: "scholarship")
+      scope = @form.form_fields
+
+      person = current_user&.person if params[:as_visitor] != "true"
+      if person
+        # Always hide logged_out_only fields for logged-in users with known data
+        known_identifiers = person_known_identifiers(person)
+        if known_identifiers.any?
+          known_ids = @form.form_fields
+                           .where(visibility: :logged_out_only, field_identifier: known_identifiers)
+                           .ids
+          scope = scope.where.not(id: known_ids) if known_ids.any?
+        end
+
+        # Hide logged_out_only headers when all their non-header fields are hidden
+        logged_out_sections = @form.form_fields.where(visibility: :logged_out_only)
+                                  .where.not(answer_type: :group_header)
+                                  .pluck(:section).uniq.compact
+        logged_out_sections.each do |sect|
+          section_field_ids = @form.form_fields.where(section: sect, visibility: :logged_out_only)
+                                  .where.not(answer_type: :group_header).ids
+          if section_field_ids.any? && known_identifiers.any? && (section_field_ids - scope.where(id: section_field_ids).ids).any?
+            remaining = scope.where(id: section_field_ids).ids
+            if remaining.empty?
+              scope = scope.where.not(section: sect, answer_type: :group_header, visibility: :logged_out_only)
+            end
+          end
+        end
+
+        if @form.hide_answered_form_questions?
+          answered_field_ids = []
+
+          # One-time fields: hide if answered on ANY form submission for this person
+          one_time_field_ids = @form.form_fields.where(visibility: :answers_on_file, one_time: true)
+                                   .where.not(answer_type: :group_header).ids
+          if one_time_field_ids.any?
+            answered_one_time = FormAnswer.joins(:form_submission)
+                                         .where(form_submissions: { person_id: person.id })
+                                         .where(form_field_id: one_time_field_ids)
+                                         .where.not(submitted_answer: [ nil, "" ])
+                                         .pluck(:form_field_id)
+            answered_field_ids.concat(answered_one_time)
+          end
+
+          # Regular fields: hide if answered on forms within this event
+          event_form_ids = @event.forms.ids
+          event_submissions = FormSubmission.where(person: person, form_id: event_form_ids)
+          if event_submissions.exists?
+            regular_field_ids = @form.form_fields.where(visibility: :answers_on_file, one_time: false)
+                                     .where.not(answer_type: :group_header).ids
+            if regular_field_ids.any?
+              answered_regular = FormAnswer.where(form_submission: event_submissions)
+                                          .where(form_field_id: regular_field_ids)
+                                          .where.not(submitted_answer: [ nil, "" ])
+                                          .pluck(:form_field_id)
+              answered_field_ids.concat(answered_regular)
+            end
+          end
+
+          answered_field_ids.uniq!
+          if answered_field_ids.any?
+            scope = scope.where.not(id: answered_field_ids)
+
+            # Hide section headers when all their non-header fields are answered
+            answered_sections = @form.form_fields.where(id: answered_field_ids)
+                                    .pluck(:section).uniq.compact
+            answered_sections.each do |sect|
+              section_field_ids = @form.form_fields.where(section: sect, visibility: :answers_on_file)
+                                      .where.not(answer_type: :group_header).ids
+              if section_field_ids.any? && (section_field_ids - answered_field_ids).empty?
+                scope = scope.where.not(section: sect, answer_type: :group_header, visibility: :answers_on_file)
+              end
+            end
+          end
+        end
       end
+
       scope.reorder(position: :asc)
     end
 
+    def person_known_identifiers(person)
+      keys = []
+      keys << "first_name" if person.first_name.present?
+      keys << "last_name" if person.last_name.present?
+      keys << "primary_email" << "confirm_email" if person.email.present?
+      keys << "primary_email_type" if person.email_type.present?
+      keys << "nickname" if person.legal_first_name.present? || person.first_name.present?
+      keys << "pronouns" if person.pronouns.present?
+      keys << "secondary_email" if person.email_2.present?
+      keys << "secondary_email_type" if person.email_2_type.present?
+
+      if person.addresses.exists?
+        address = person.addresses.find_by(primary: true) || person.addresses.first
+        keys << "mailing_street" if address.street_address.present?
+        keys << "mailing_address_type" if address.address_type.present?
+        keys << "mailing_city" if address.city.present?
+        keys << "mailing_state" if address.state.present?
+        keys << "mailing_zip" if address.zip_code.present?
+      end
+
+      if person.contact_methods.where(kind: :phone).exists?
+        keys << "phone" << "phone_type"
+      end
+
+      keys
+    end
+
     def ensure_registerable
       unless @event.registerable?
         redirect_to event_path(@event), alert: "Registration is closed for this event."
@@ -182,14 +301,14 @@ def ensure_registerable
     def validate_required_fields(form_params)
       errors = {}
       fields = visible_form_fields
-      fields_by_key = fields.select { |f| f.field_key.present? }.index_by(&:field_key)
+      fields_by_identifier = fields.select { |f| f.field_identifier.present? }.index_by(&:field_identifier)
 
       fields.find_each do |field|
         next if field.group_header?
 
         value = form_params[field.id.to_s]
 
-        if field.is_required && (value.blank? || (value.is_a?(Array) && value.reject(&:blank?).empty?))
+        if field.required && (value.blank? || (value.is_a?(Array) && value.reject(&:blank?).empty?))
           errors[field.id] = "can't be blank"
           next
         end
@@ -198,13 +317,13 @@ def validate_required_fields(form_params)
 
         if field.number_integer? && value.to_s !~ /\A\d+\z/
           errors[field.id] = "must be a whole number"
-        elsif field.field_key&.match?(/email(?!_type)/) && value.to_s !~ /\A[^@\s]+@[^@\s]+\z/
+        elsif field.field_identifier&.match?(/email(?!_type|_confirmation)/) && value.to_s !~ /\A[^@\s]+@[^@\s]+\z/
           errors[field.id] = "must be a valid email address"
         end
       end
 
-      confirm_field = fields_by_key["confirm_email"]
-      email_field = fields_by_key["primary_email"]
+      confirm_field = fields_by_identifier["confirm_email"]
+      email_field = fields_by_identifier["primary_email"]
       if confirm_field && email_field && errors[confirm_field.id].nil?
         confirm_value = form_params[confirm_field.id.to_s].to_s.strip
         email_value = form_params[email_field.id.to_s].to_s.strip
 
@@ -220,26 +220,26 @@ def event_registration_csv_row(registration, cost_required)
 
   def assign_event_forms(event)
     form_id = params.dig(:event, :registration_form_id)
-    return unless form_id
-
     if form_id.blank?
       event.event_forms.registration.destroy_all
     else
       form = Form.standalone.find_by(id: form_id)
-      return unless form
-
-      existing = event.event_forms.registration.first
-      if existing
-        existing.update!(form: form) unless existing.form_id == form.id.to_i
-      else
-        event.event_forms.create!(form: form, role: "registration")
+      if form
+        existing = event.event_forms.registration.first
+        if existing
+          existing.update!(form: form) unless existing.form_id == form.id.to_i
+        else
+          event.event_forms.create!(form: form, role: "registration")
+        end
       end
     end
 
-    scholarship_form = Form.standalone.find_by(name: ScholarshipApplicationFormBuilder::FORM_NAME)
-    if scholarship_form && event.cost_cents.to_i > 0
-      event.event_forms.find_or_create_by!(form: scholarship_form, role: "scholarship")
-    elsif event.cost_cents.to_i == 0
+    if params.dig(:event, :scholarship_enabled) == "1"
+      form = Form.standalone.find_by(role: "scholarship")
+      if form && !event.event_forms.scholarship.exists?
+        event.event_forms.create!(form: form, role: "scholarship")
+      end
+    else
       event.event_forms.scholarship.destroy_all
     end
   end
@@ -249,7 +249,7 @@ def set_form_variables
     @event.build_primary_asset if @event.primary_asset.blank?
     @event.gallery_assets.build
     @locations = Location.order(:city, :state)
-    @registration_forms = Form.standalone.where(scholarship_application: false).order(:name)
+    @registration_forms = Form.standalone.where(role: [ nil, "", "registration" ]).order(:name)
     @categories_grouped =
       Category
         .includes(:category_type)