- Update the Registration Entry registrant eligibility check so family members with unknown details (like age or grade) can show on the Registration Entry dropdown as potentially eligible instead of being blocked. The full requirements are still enforced at submission.

joshuahenninger · joshuahenninger · commit fc01f1177fd6 · 2026-04-30T09:45:21.000-07:00
diff --git a/Rock.Blocks/Event/RegistrationEntry.cs b/Rock.Blocks/Event/RegistrationEntry.cs
@@ -36,6 +36,7 @@
 using Rock.Financial;
 using Rock.Model;
 using Rock.Model.Event.RegistrationInstance.Options;
+using Rock.Model.Event.RegistrationTemplate.Options;
 using Rock.Pdf;
 using Rock.Security;
 using Rock.Tasks;
@@ -3975,6 +3976,15 @@ RegistrationGuid argument.
             var registrationTemplate = registrationTemplateService.Get( context.RegistrationSettings.RegistrationTemplateId );
             var registrantEligibilityEvaluator = registrationTemplateService.GetRegistrantEligibility( registrationTemplate );
 
+            // Use Lax mode here so that a family member who is missing data needed by an
+            // eligibility requirement (e.g. age, grade) is still surfaced in the dropdown
+            // as "potentially eligible" rather than being marked Ineligible. The strict
+            // check is still enforced at registration submission.
+            var familyMemberEligibilityOptions = new RegistrantEligibilityEvaluationOptions
+            {
+                Mode = RegistrantEligibilityEvaluationMode.Lax
+            };
+
             var currentPerson = GetCurrentPerson();
             var familyMembers = context.RegistrationSettings.AreCurrentFamilyMembersShown ?
                 currentPerson.GetFamilyMembers( true, rockContext )
@@ -3991,7 +4001,7 @@ RegistrationGuid argument.
                         FamilyGuid = gm.FamilyGuid,
                         FullName = gm.Person.FullName,
                         FieldValues = GetCurrentValueFieldValues( context, rockContext, gm.Person, null, formModels, false ),
-                        IsIneligible = !registrantEligibilityEvaluator.Evaluate( gm.Person )
+                        IsIneligible = !registrantEligibilityEvaluator.Evaluate( gm.Person, familyMemberEligibilityOptions )
                     } )
                     .ToList() :
                     new List<RegistrationEntryFamilyMemberBag>();
diff --git a/Rock/Model/Event/RegistrationTemplate/Options/RegistrantEligibilityEvaluationMode.cs b/Rock/Model/Event/RegistrationTemplate/Options/RegistrantEligibilityEvaluationMode.cs
@@ -0,0 +1,41 @@
+﻿// <copyright>
+// Copyright by the Spark Development Network
+//
+// Licensed under the Rock Community License (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.rockrms.com/license
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+namespace Rock.Model.Event.RegistrationTemplate.Options
+{
+    /// <summary>
+    /// Controls how a registrant eligibility evaluator treats a person who is missing data
+    /// required to fully evaluate an eligibility requirement (e.g. age, grade, gender, age classification).
+    /// </summary>
+    public enum RegistrantEligibilityEvaluationMode
+    {
+        /// <summary>
+        /// A person who is missing data required by a configured eligibility requirement is
+        /// considered ineligible. This is the default and is appropriate for the final
+        /// eligibility check at registration submission.
+        /// </summary>
+        Strict = 0,
+
+        /// <summary>
+        /// A person who is missing data required by a configured eligibility requirement is
+        /// considered eligible for that requirement. This is appropriate for surfacing
+        /// "potentially eligible" individuals in user interfaces (for example, the family
+        /// members dropdown on a registration entry block) where the person can supply the
+        /// missing data later.
+        /// </summary>
+        Lax = 1
+    }
+}
diff --git a/Rock/Model/Event/RegistrationTemplate/Options/RegistrantEligibilityEvaluationOptions.cs b/Rock/Model/Event/RegistrationTemplate/Options/RegistrantEligibilityEvaluationOptions.cs
@@ -0,0 +1,46 @@
+﻿// <copyright>
+// Copyright by the Spark Development Network
+//
+// Licensed under the Rock Community License (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.rockrms.com/license
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// </copyright>
+
+namespace Rock.Model.Event.RegistrationTemplate.Options
+{
+    /// <summary>
+    /// Options that control how a <see cref="RegistrantEligibilityEvaluator"/> evaluates a person
+    /// against the configured eligibility requirements of a registration template.
+    /// </summary>
+    public class RegistrantEligibilityEvaluationOptions
+    {
+        /// <summary>
+        /// Gets or sets the mode that controls how the evaluator treats a person who is missing
+        /// data required by a configured eligibility requirement.
+        /// </summary>
+        /// <remarks>
+        /// <para>
+        /// When <see cref="RegistrantEligibilityEvaluationMode.Strict"/> (the default) is used,
+        /// a missing field that is needed by a configured requirement (for example, an unspecified
+        /// age when a minimum age is configured) causes the person to be reported as ineligible.
+        /// </para>
+        /// <para>
+        /// When <see cref="RegistrantEligibilityEvaluationMode.Lax"/> is used, the person is
+        /// treated as eligible for that specific requirement; this is appropriate when surfacing
+        /// "potentially eligible" individuals in a UI where the missing data can be supplied later.
+        /// The eligibility Data View check, when configured, is always applied regardless of mode
+        /// because it's not currently possible to check whether a person is missing data that might
+        /// make them eligible against an arbitrary Data View.
+        /// </para>
+        /// </remarks>
+        public RegistrantEligibilityEvaluationMode Mode { get; set; } = RegistrantEligibilityEvaluationMode.Strict;
+    }
+}
diff --git a/Rock/Model/Event/RegistrationTemplate/RegistrantEligibilityEvaluator.cs b/Rock/Model/Event/RegistrationTemplate/RegistrantEligibilityEvaluator.cs
@@ -1,4 +1,4 @@
-﻿// <copyright>
+// <copyright>
 // Copyright by the Spark Development Network
 //
 // Licensed under the Rock Community License (the "License");
@@ -17,6 +17,8 @@
 using System;
 using System.Linq;
 
+using Rock.Model.Event.RegistrationTemplate.Options;
+
 namespace Rock.Model
 {
     /// <summary>
@@ -53,22 +55,57 @@ internal RegistrantEligibilityEvaluator( RegistrationTemplate registrationTempla
         }
 
         /// <summary>
-        /// Determines whether the specified registrant meets the eligibility criteria defined by the current settings.
+        /// Determines whether the specified registrant meets the eligibility criteria defined by
+        /// the current settings using <see cref="RegistrantEligibilityEvaluationMode.Strict"/> mode.
         /// </summary>
         /// <param name="registrantPerson">The person to evaluate for eligibility. Returns <see langword="false"/> if <see langword="null"/>.</param>
         /// <returns><see langword="true"/> if the registrant meets all eligibility requirements; otherwise, <see langword="false"/>.</returns>
         public bool Evaluate( Person registrantPerson )
         {
-            return Evaluate( registrantPerson, out var _ );
+            return Evaluate( registrantPerson, options: null, out var _ );
         }
 
         /// <summary>
-        /// Determines whether the specified registrant meets the eligibility criteria defined by the current settings.
+        /// Determines whether the specified registrant meets the eligibility criteria defined by
+        /// the current settings using <see cref="RegistrantEligibilityEvaluationMode.Strict"/> mode.
         /// </summary>
         /// <param name="registrantPerson">The person to evaluate for eligibility. Returns <see langword="false"/> if <see langword="null"/>.</param>
         /// <param name="error">The first friendly error explaining why the person is not eligible.</param>
         /// <returns><see langword="true"/> if the registrant meets all eligibility requirements; otherwise, <see langword="false"/>.</returns>
         public bool Evaluate( Person registrantPerson, out string error )
+        {
+            return Evaluate( registrantPerson, options: null, out error );
+        }
+
+        /// <summary>
+        /// Determines whether the specified registrant meets the eligibility criteria defined by
+        /// the current settings, using the supplied <paramref name="options"/> to control how
+        /// missing-data scenarios are handled.
+        /// </summary>
+        /// <param name="registrantPerson">The person to evaluate for eligibility. Returns <see langword="false"/> if <see langword="null"/>.</param>
+        /// <param name="options">
+        /// Options that control how the evaluator treats missing data on the person. If
+        /// <see langword="null"/>, defaults to <see cref="RegistrantEligibilityEvaluationMode.Strict"/>.
+        /// </param>
+        /// <returns><see langword="true"/> if the registrant meets all eligibility requirements; otherwise, <see langword="false"/>.</returns>
+        public bool Evaluate( Person registrantPerson, RegistrantEligibilityEvaluationOptions options )
+        {
+            return Evaluate( registrantPerson, options, out var _ );
+        }
+
+        /// <summary>
+        /// Determines whether the specified registrant meets the eligibility criteria defined by
+        /// the current settings, using the supplied <paramref name="options"/> to control how
+        /// missing-data scenarios are handled.
+        /// </summary>
+        /// <param name="registrantPerson">The person to evaluate for eligibility. Returns <see langword="false"/> if <see langword="null"/>.</param>
+        /// <param name="options">
+        /// Options that control how the evaluator treats missing data on the person. If
+        /// <see langword="null"/>, defaults to <see cref="RegistrantEligibilityEvaluationMode.Strict"/>.
+        /// </param>
+        /// <param name="error">The first friendly error explaining why the person is not eligible.</param>
+        /// <returns><see langword="true"/> if the registrant meets all eligibility requirements; otherwise, <see langword="false"/>.</returns>
+        public bool Evaluate( Person registrantPerson, RegistrantEligibilityEvaluationOptions options, out string error )
         {
             error = null;
 
@@ -86,18 +123,25 @@ public bool Evaluate( Person registrantPerson, out string error )
                 return true;
             }
 
+            // Resolve the evaluation mode. A null options instance falls back to the default
+            // (Strict), preserving the behavior of the parameterless Evaluate overloads.
+            var evaluationMode = ( options ?? new RegistrantEligibilityEvaluationOptions() ).Mode;
+
             // Minimum Age
             if ( _registrantEligibilitySettings.MinimumAge.HasValue )
             {
                 var minAgeError = $"{registrantPerson.FullName} does not meet the minimum age requirement for this {_registrationTemplate.RegistrationTerm} ({_registrantEligibilitySettings.MinimumAge.Value} years old or older).";
 
                 if ( !registrantPerson.Age.HasValue )
                 {
-                    error = minAgeError;
-                    return false;
+                    // Age is required to evaluate this rule. Strict mode rejects, Lax mode skips.
+                    if ( evaluationMode == RegistrantEligibilityEvaluationMode.Strict )
+                    {
+                        error = minAgeError;
+                        return false;
+                    }
                 }
-
-                if ( registrantPerson.Age.Value < _registrantEligibilitySettings.MinimumAge.Value )
+                else if ( registrantPerson.Age.Value < _registrantEligibilitySettings.MinimumAge.Value )
                 {
                     error = minAgeError;
                     return false;
@@ -107,16 +151,19 @@ public bool Evaluate( Person registrantPerson, out string error )
             // Maximum Age
             if ( _registrantEligibilitySettings.MaximumAge.HasValue )
             {
-                var isMaxAgeInteger = _registrantEligibilitySettings.MaximumAge.Value.IsInteger();
+                var isMaxAgeAnInteger = _registrantEligibilitySettings.MaximumAge.Value.IsInteger();
                 var maxAgeError = $"{registrantPerson.FullName} does not meet the maximum age requirement for this {_registrationTemplate.RegistrationTerm} ({_registrantEligibilitySettings.MaximumAge.Value} years old or younger).";
 
                 if ( !registrantPerson.Age.HasValue )
                 {
-                    error = maxAgeError;
-                    return false;
+                    // Age is required to evaluate this rule. Strict mode rejects, Lax mode skips.
+                    if ( evaluationMode == RegistrantEligibilityEvaluationMode.Strict )
+                    {
+                        error = maxAgeError;
+                        return false;
+                    }
                 }
-
-                if ( isMaxAgeInteger )
+                else if ( isMaxAgeAnInteger )
                 {
                     // If max age is an integer number of years old, then treat it as "up to and including that age".
                     // So if max age is 18, then a registrant who is 18 years and 11 months old would still be eligible,
@@ -139,13 +186,13 @@ public bool Evaluate( Person registrantPerson, out string error )
                     }
                 }
             }
-            
+
             // Age Classification
             if ( _registrantEligibilitySettings.AgeClassification.HasValue )
             {
                 // Typically age classification is set in the person save hook,
                 // but that won't run until a running transaction is committed.
-                // Resolve it here so we can determine registrant eligibility when a new person is created for a registration.
+                // Resolve it here using the same logic so we can determine registrant eligibility when a new person is created for a registration.
                 var resolvedAgeClassification = registrantPerson.AgeClassification;
                 if ( resolvedAgeClassification == AgeClassification.Unknown && registrantPerson.Age.HasValue )
                 {
@@ -159,9 +206,21 @@ public bool Evaluate( Person registrantPerson, out string error )
                     }
                 }
 
-                if ( resolvedAgeClassification != _registrantEligibilitySettings.AgeClassification.Value )
+                var ageClassificationError = $"{registrantPerson.FullName} does not meet the age requirement for this {_registrationTemplate.RegistrationTerm} ({_registrantEligibilitySettings.AgeClassification.GetDisplayName()}).";
+
+                if ( resolvedAgeClassification == AgeClassification.Unknown )
                 {
-                    error = $"{registrantPerson.FullName} does not meet the age requirement for this {_registrationTemplate.RegistrationTerm} ({_registrantEligibilitySettings.AgeClassification.GetDisplayName()}).";
+                    // Age classification could not be determined (no explicit value and no age to derive it).
+                    // Strict mode rejects, Lax mode skips this rule.
+                    if ( evaluationMode == RegistrantEligibilityEvaluationMode.Strict )
+                    {
+                        error = ageClassificationError;
+                        return false;
+                    }
+                }
+                else if ( resolvedAgeClassification != _registrantEligibilitySettings.AgeClassification.Value )
+                {
+                    error = ageClassificationError;
                     return false;
                 }
             }
@@ -170,14 +229,17 @@ public bool Evaluate( Person registrantPerson, out string error )
             if ( _registrantEligibilitySettings.MaximumGradeOffset.HasValue )
             {
                 var minGradeError = $"{registrantPerson.FullName} does not meet the minimum grade requirement for this {_registrationTemplate.RegistrationTerm}.";
-                
+
                 if ( !registrantPerson.GradeOffset.HasValue )
                 {
-                    error = minGradeError;
-                    return false;
+                    // Grade is required to evaluate this rule. Strict mode rejects, Lax mode skips.
+                    if ( evaluationMode == RegistrantEligibilityEvaluationMode.Strict )
+                    {
+                        error = minGradeError;
+                        return false;
+                    }
                 }
-
-                if ( registrantPerson.GradeOffset.Value > _registrantEligibilitySettings.MaximumGradeOffset.Value )
+                else if ( registrantPerson.GradeOffset.Value > _registrantEligibilitySettings.MaximumGradeOffset.Value )
                 {
                     error = minGradeError;
                     return false;
@@ -188,14 +250,17 @@ public bool Evaluate( Person registrantPerson, out string error )
             if ( _registrantEligibilitySettings.MinimumGradeOffset.HasValue )
             {
                 var maxGradeError = $"{registrantPerson.FullName} does not meet the maximum grade requirement for this {_registrationTemplate.RegistrationTerm}.";
-                
+
                 if ( !registrantPerson.GradeOffset.HasValue )
                 {
-                    error = maxGradeError;
-                    return false;
+                    // Grade is required to evaluate this rule. Strict mode rejects, Lax mode skips.
+                    if ( evaluationMode == RegistrantEligibilityEvaluationMode.Strict )
+                    {
+                        error = maxGradeError;
+                        return false;
+                    }
                 }
-
-                if ( registrantPerson.GradeOffset.Value < _registrantEligibilitySettings.MinimumGradeOffset.Value )
+                else if ( registrantPerson.GradeOffset.Value < _registrantEligibilitySettings.MinimumGradeOffset.Value )
                 {
                     error = maxGradeError;
                     return false;
@@ -205,14 +270,27 @@ public bool Evaluate( Person registrantPerson, out string error )
             // Gender
             if ( _registrantEligibilitySettings.Gender.HasValue )
             {
-                if ( registrantPerson.Gender != _registrantEligibilitySettings.Gender.Value )
+                var genderError = $"{registrantPerson.FullName} does not meet the gender requirement for this {_registrationTemplate.RegistrationTerm} ({_registrantEligibilitySettings.Gender.Value.GetDisplayName()}).";
+
+                if ( registrantPerson.Gender == Gender.Unknown )
+                {
+                    // Gender is required to evaluate this rule. Strict mode rejects, Lax mode skips.
+                    if ( evaluationMode == RegistrantEligibilityEvaluationMode.Strict )
+                    {
+                        error = genderError;
+                        return false;
+                    }
+                }
+                else if ( registrantPerson.Gender != _registrantEligibilitySettings.Gender.Value )
                 {
-                    error = $"{registrantPerson.FullName} does not meet the gender requirement for this {_registrationTemplate.RegistrationTerm} ({_registrantEligibilitySettings.Gender.Value.GetDisplayName()}).";
+                    error = genderError;
                     return false;
                 }
             }
 
             // Data View
+            // The Data View check is based on concrete membership in a configured query rather than
+            // missing-data semantics, so it is enforced regardless of the evaluation mode.
             if ( _eligibleDataViewPersonQuery != null )
             {
                 if ( !_eligibleDataViewPersonQuery.Any( p => p.Id == registrantPerson.Id ) )
