Finishes implementation of set minimum optional competencies validation and posting

kevwhitt-hee · kevwhitt-hee · commit dba4e03f1b56 · 2025-12-10T16:09:47.000Z
diff --git a/DigitalLearningSolutions.Data/DataServices/CompetencyAssessmentDataService.cs b/DigitalLearningSolutions.Data/DataServices/CompetencyAssessmentDataService.cs
@@ -915,7 +915,7 @@ public void UpdateMinimumOptionalCompetencies(int selfAssessmentId, int minimumO
                 @"UPDATE SelfAssessments
                     SET 
                     [MinimumOptionalCompetencies] = @minimumOptionalCompetecies
-                    WHERE id = @selfAssessmentId AND MinimumOptionalCompetencies <> minimumOptionalCompetecies;"
+                    WHERE id = @selfAssessmentId AND MinimumOptionalCompetencies <> @minimumOptionalCompetecies;"
             ,
                 new { selfAssessmentId, minimumOptionalCompetecies }
             );
@@ -926,7 +926,7 @@ public void UpdateManageOptionalCompetenciesPrompt(int selfAssessmentId, string
                 @"UPDATE SelfAssessments
                     SET 
                     [ManageOptionalCompetenciesPrompt] = @manageOptionalCompetenciesPrompt
-                    WHERE id = @selfAssessmentId AND MinimumOptionalCompetencies <> minimumOptionalCompetecies;"
+                    WHERE id = @selfAssessmentId AND ManageOptionalCompetenciesPrompt <> @manageOptionalCompetenciesPrompt;"
             ,
                 new { selfAssessmentId, manageOptionalCompetenciesPrompt }
             );
diff --git a/DigitalLearningSolutions.Web/Controllers/CompetencyAssessmentsController/CompetencyAssessments.cs b/DigitalLearningSolutions.Web/Controllers/CompetencyAssessmentsController/CompetencyAssessments.cs
@@ -747,20 +747,19 @@ public IActionResult SetMinimumOptionalCompetencies(int competencyAssessmentId)
             var adminId = GetAdminID();
             var competencyAssessmentBase = competencyAssessmentService.GetCompetencyAssessmentBaseById(competencyAssessmentId, adminId);
             var competencies = competencyAssessmentService.GetCompetenciesForCompetencyAssessment(competencyAssessmentId);
-            var competencyAssessmentTaskStatus = competencyAssessmentService.GetCompetencyAssessmentTaskStatus(competencyAssessmentId, null);
-            var viewModel = new SelectOptionalCompetenciesViewModel(competencyAssessmentBase, competencies, competencyAssessmentTaskStatus.OptionalCompetenciesTaskStatus);
+            var viewModel = new SetMinimumOptionalCompetenciesViewModel(competencyAssessmentBase, competencies);
             return View("SetMinimumOptionalCompetencies", viewModel);
         }
         [HttpPost]
         [Route("/CompetencyAssessments/{competencyAssessmentId}/Competencies/Optional/SetMinimum")]
-        public IActionResult SetMinimumOptionalCompetencies(SelectOptionalCompetenciesViewModel model)
+        public IActionResult SetMinimumOptionalCompetencies(SetMinimumOptionalCompetenciesFormData model)
         {
             if (!ModelState.IsValid)
             {
                 var adminId = GetAdminID();
                 var competencyAssessmentBase = competencyAssessmentService.GetCompetencyAssessmentBaseById(model.ID, adminId);
                 var competencies = competencyAssessmentService.GetCompetenciesForCompetencyAssessment(model.ID);
-                var viewModel = new SelectOptionalCompetenciesViewModel(competencyAssessmentBase, competencies, model.TaskStatus);
+                var viewModel = new SetMinimumOptionalCompetenciesViewModel(competencyAssessmentBase, competencies);
                 return View("SetMinimumOptionalCompetencies", viewModel);
             }
             competencyAssessmentService.UpdateMinimumOptionalCompetencies(model.ID, model.MinimumOptionalCompetencies ?? 0);
diff --git a/DigitalLearningSolutions.Web/Helpers/MaxOptionalCompetenciesAttribute.cs b/DigitalLearningSolutions.Web/Helpers/MaxOptionalCompetenciesAttribute.cs
@@ -2,41 +2,35 @@
 using System;
 using System.ComponentModel.DataAnnotations;
 
-public class MaxOptionalCompetenciesAttribute : ValidationAttribute
+public class MaxOptionalCountAttribute : ValidationAttribute
 {
-    private readonly string _selectedIdsProperty;
+    private readonly string _maxProperty;
 
-    public MaxOptionalCompetenciesAttribute(string selectedIdsProperty)
+    public MaxOptionalCountAttribute(string maxProperty)
     {
-        _selectedIdsProperty = selectedIdsProperty;
+        _maxProperty = maxProperty;
     }
 
     protected override ValidationResult? IsValid(object? value, ValidationContext validationContext)
     {
-        // Get the integer value (MinimumOptionalCompetencies)
         var number = value as int?;
         if (number == null)
         {
             return ValidationResult.Success;
         }
 
-        // Get the other property (SelectedCompetencyIds)
-        var selectedIdsProperty = validationContext.ObjectType.GetProperty(_selectedIdsProperty);
-        if (selectedIdsProperty == null)
+        // Get the max property value (OptionalCompetenciesCount)
+        var maxProp = validationContext.ObjectType.GetProperty(_maxProperty);
+        if (maxProp == null)
         {
-            return new ValidationResult($"Unknown property {_selectedIdsProperty}");
+            return new ValidationResult($"Unknown property {_maxProperty}");
         }
 
-        var selectedIds = (int[])selectedIdsProperty.GetValue(validationContext.ObjectInstance, null)
-                           ?? Array.Empty<int>();
+        var maxValue = (int)maxProp.GetValue(validationContext.ObjectInstance)!;
 
-        var maxAllowed = selectedIds.Length;
-
-        if (number < 0 || number > maxAllowed)
+        if (number < 0 || number > maxValue)
         {
-            return new ValidationResult(
-                $"Value must be between 0 and {maxAllowed}."
-            );
+            return new ValidationResult($"Must be between 0 and {maxValue}.");
         }
 
         return ValidationResult.Success;
diff --git a/DigitalLearningSolutions.Web/ViewModels/CompetencyAssessments/SelectOptionalCompetenciesFormData.cs b/DigitalLearningSolutions.Web/ViewModels/CompetencyAssessments/SelectOptionalCompetenciesFormData.cs
@@ -6,7 +6,6 @@ public class SelectOptionalCompetenciesFormData
     {
         public int ID { get; set; }
         public bool? TaskStatus { get; set; }
-        [MaxOptionalCompetencies(nameof(SelectedCompetencyIds))]
         public int? MinimumOptionalCompetencies { get; set; }
         public string? ManageOptionalCompetenciesPrompt { get; set; }
         public int[] SelectedCompetencyIds { get; set; } = [];
diff --git a/DigitalLearningSolutions.Web/ViewModels/CompetencyAssessments/SetMinimumOptionalCompetenciesFormData.cs b/DigitalLearningSolutions.Web/ViewModels/CompetencyAssessments/SetMinimumOptionalCompetenciesFormData.cs
@@ -0,0 +1,12 @@
+﻿using DigitalLearningSolutions.Web.Helpers;
+
+namespace DigitalLearningSolutions.Web.ViewModels.CompetencyAssessments
+{
+    public class SetMinimumOptionalCompetenciesFormData
+    {
+        [MaxOptionalCount(nameof(OptionalCompetenciesCount))]
+        public int? MinimumOptionalCompetencies { get; set; }
+        public int OptionalCompetenciesCount { get; set; }
+        public int ID { get; set; }
+    }
+}
diff --git a/DigitalLearningSolutions.Web/ViewModels/CompetencyAssessments/SetMinimumOptionalCompetenciesViewModel.cs b/DigitalLearningSolutions.Web/ViewModels/CompetencyAssessments/SetMinimumOptionalCompetenciesViewModel.cs
@@ -0,0 +1,25 @@
+﻿namespace DigitalLearningSolutions.Web.ViewModels.CompetencyAssessments
+{
+    using DigitalLearningSolutions.Data.Models.CompetencyAssessments;
+    using DigitalLearningSolutions.Web.Helpers;
+    using System.Collections.Generic;
+    using System.Linq;
+
+    public class SetMinimumOptionalCompetenciesViewModel : SetMinimumOptionalCompetenciesFormData
+    {
+        public SetMinimumOptionalCompetenciesViewModel(CompetencyAssessmentBase competencyAssessmentBase, IEnumerable<Competency> competencies)
+        {
+            ID = competencyAssessmentBase.ID;
+            CompetencyAssessmentName = competencyAssessmentBase.CompetencyAssessmentName;
+            MinimumOptionalCompetencies = competencyAssessmentBase.MinimumOptionalCompetencies;
+            UserRole = competencyAssessmentBase.UserRole;
+            VocabularySingular = FrameworkVocabularyHelper.VocabularySingular(competencyAssessmentBase.Vocabulary);
+            VocabularyPlural = FrameworkVocabularyHelper.VocabularyPlural(competencyAssessmentBase.Vocabulary);
+            OptionalCompetenciesCount = competencies.Count(c => c.Optional == true);
+        }
+        public string CompetencyAssessmentName { get; set; }
+        public int UserRole { get; set; }
+        public string VocabularySingular { get; set; }
+        public string VocabularyPlural { get; set; }
+    }
+}
diff --git a/DigitalLearningSolutions.Web/Views/CompetencyAssessments/ManageOptionalCompetencies.cshtml b/DigitalLearningSolutions.Web/Views/CompetencyAssessments/ManageOptionalCompetencies.cshtml
@@ -21,31 +21,31 @@
         </div>
     </nav>
 }
-<h1>Manage optional competencies</h1>
+<h1>Manage optional @Model.VocabularyPlural.ToLower()</h1>
 <p class="nhsuk-lede-text">
-    Manage optional competencies for the assessment @Model.CompetencyAssessmentName.
-    Optional competencies can be selected for inclusion in a self assessment by a learner if required.
+    Manage optional @Model.VocabularyPlural.ToLower() for the assessment @Model.CompetencyAssessmentName.
+    Optional @Model.VocabularyPlural.ToLower() can be selected for inclusion in a self assessment by a learner if required.
 </p>
 <dl class="nhsuk-summary-list">
     <div class="nhsuk-summary-list__row">
         <dt class="nhsuk-summary-list__key">
-            Optional competencies
+            Optional @Model.VocabularyPlural.ToLower()
         </dt>
         <dd class="nhsuk-summary-list__value">
             @if (!Model.SelectedCompetencyIds.Any())
             {
-                <text>No competencies have been made optional for this self assessment.</text>
+                <text>No @Model.VocabularyPlural.ToLower() have been made optional for this self assessment.</text>
             }
             else
             {
                 <text>
                     @(Model.CompetencyGroups.Count(g =>
                                     g.Any(c => c.GroupOptionalCompetencies)
-                                    )) optional competency groups
+                                    )) optional @Model.VocabularySingular.ToLower() groups
                     <br />
                     @(Model.CompetencyGroups
                                     .Where(g => g.All(c => !c.GroupOptionalCompetencies))
-                                    .Sum(g => g.Count())) individual optional competencies from
+                                    .Sum(g => g.Count())) individual optional @Model.VocabularyPlural.ToLower() from
                     @(Model.CompetencyGroups.Count(g =>
                                     g.All(c => !c.GroupOptionalCompetencies)
                                     )) groups
@@ -54,25 +54,25 @@
             }
         </dd>
         <dd class="nhsuk-summary-list__actions">
-            <a class="nhsuk-link" asp-route-competencyAssessmentId="@Model.ID" asp-action="SelectOptionalCompetencies">Change<span class="nhsuk-u-visually-hidden"> optional competencies</span></a>
+            <a class="nhsuk-link" asp-route-competencyAssessmentId="@Model.ID" asp-action="SelectOptionalCompetencies">Change<span class="nhsuk-u-visually-hidden"> optional @Model.VocabularyPlural.ToLower()</span></a>
         </dd>
     </div>
     @if (Model.SelectedCompetencyIds.Any())
     {
         <div class="nhsuk-summary-list__row">
             <dt class="nhsuk-summary-list__key">
-                Minimum optional competencies
+                Minimum optional @Model.VocabularyPlural.ToLower()
             </dt>
             <dd class="nhsuk-summary-list__value">
                 @(Model.MinimumOptionalCompetencies == null | Model.MinimumOptionalCompetencies == 0 ? "No minimum set" : Model.MinimumOptionalCompetencies.ToString())
             </dd>
             <dd class="nhsuk-summary-list__actions">
-                <a class="nhsuk-link" asp-route-competencyAssessmentId="@Model.ID" asp-action="SetMinimumOptionalCompetencies">Change<span class="nhsuk-u-visually-hidden"> minimum optional competencies</span></a>
+                <a class="nhsuk-link" asp-route-competencyAssessmentId="@Model.ID" asp-action="SetMinimumOptionalCompetencies">Change<span class="nhsuk-u-visually-hidden"> minimum optional @Model.VocabularyPlural.ToLower()</span></a>
             </dd>
         </div>
         <div class="nhsuk-summary-list__row">
             <dt class="nhsuk-summary-list__key">
-                Optional competency learner guidance
+                Optional @Model.VocabularySingular.ToLower() learner guidance
             </dt>
             <dd class="nhsuk-summary-list__value">
                 @Html.Raw(Model.ManageOptionalCompetenciesPrompt == null ? "No guidance text specified" : Model.ManageOptionalCompetenciesPrompt.ToString())
@@ -89,6 +89,7 @@
         <input type="hidden" asp-for="MinimumOptionalCompetencies" />
         <input type="hidden" asp-for="ManageOptionalCompetenciesPrompt" />
         <input type="hidden" asp-for="SelectedCompetencyIds" />
+        <input type="hidden" asp-for="GroupIds" />
         <vc:single-checkbox asp-for="@nameof(Model.TaskStatus)" label="Mark this task as complete" hint-text="You will still be able to make changes after marking this task as complete."></vc:single-checkbox>
     </nhs-form-group>
     <button class="nhsuk-button" type="submit">
diff --git a/DigitalLearningSolutions.Web/Views/CompetencyAssessments/SetMinimumOptionalCompetencies.cshtml b/DigitalLearningSolutions.Web/Views/CompetencyAssessments/SetMinimumOptionalCompetencies.cshtml
@@ -1,5 +1,5 @@
 ﻿@using DigitalLearningSolutions.Web.ViewModels.CompetencyAssessments
-@model SelectOptionalCompetenciesViewModel;
+@model SetMinimumOptionalCompetenciesViewModel;
 @{
     ViewData["Title"] = "Select Optional Competencies";
     ViewData["Application"] = "Framework Service";
@@ -21,25 +21,24 @@
         </div>
     </nav>
 }
-<h1>Set a minimum number of optional competencies</h1>
+<h1>Set a minimum number of optional @Model.VocabularyPlural.ToLower()</h1>
 
 <p class="nhsuk-lede-text">
-    If appropriate, you can specify a minimum number of optional competencies that a learner must select when completing their self assessment.
+    If required, you can specify a minimum number of optional @Model.VocabularyPlural.ToLower() that a learner must select when completing their @Model.CompetencyAssessmentName self assessment.
 </p>
-<form method="post">
-    <div class="nhsuk-form-group">
+<form method="post" asp-action="SetMinimumOptionalCompetencies">
+    <nhs-form-group nhs-validation-for="MinimumOptionalCompetencies">
         <label class="nhsuk-label" for="minimum-comps-input">
-            Minimum optional competencies
+            Minimum optional @Model.VocabularyPlural.ToLower()
         </label>
         <div id="minimum-comps-input-hint" class="nhsuk-hint">
-            Specify a number between 0 and @Model.SelectedCompetencyIds.Count().
+            Specify a number between 0 and @Model.OptionalCompetenciesCount.
         </div>
         <input class="nhsuk-input nhsuk-input--width-3" id="minimum-comps-input" asp-for="MinimumOptionalCompetencies" aria-describedby="minimum-comps-input-hint" type="number">
-    </div>
+        <span nhs-validation-for="MinimumOptionalCompetencies"></span>
+    </nhs-form-group>
     <input type="hidden" asp-for="ID" />
-    <input type="hidden" asp-for="GroupIds" />
-    <input type="hidden" asp-for="SelectedCompetencyIds" />
-    <input type="hidden" asp-for="ManageOptionalCompetenciesPrompt" />
+    <input type="hidden" asp-for="OptionalCompetenciesCount" />
     <button class="nhsuk-button" type="submit">
         Save
     </button>

Original file line number	Diff line number	Diff line change
`@@ -747,20 +747,19 @@ public IActionResult SetMinimumOptionalCompetencies(int competencyAssessmentId)`
`747`	`747`	`var adminId = GetAdminID();`
`748`	`748`	`var competencyAssessmentBase = competencyAssessmentService.GetCompetencyAssessmentBaseById(competencyAssessmentId, adminId);`
`749`	`749`	`var competencies = competencyAssessmentService.GetCompetenciesForCompetencyAssessment(competencyAssessmentId);`
`750`		`- var competencyAssessmentTaskStatus = competencyAssessmentService.GetCompetencyAssessmentTaskStatus(competencyAssessmentId, null);`
`751`		`- var viewModel = new SelectOptionalCompetenciesViewModel(competencyAssessmentBase, competencies, competencyAssessmentTaskStatus.OptionalCompetenciesTaskStatus);`
	`750`	`+ var viewModel = new SetMinimumOptionalCompetenciesViewModel(competencyAssessmentBase, competencies);`
`752`	`751`	`return View("SetMinimumOptionalCompetencies", viewModel);`
`753`	`752`	`}`
`754`	`753`	`[HttpPost]`
`755`	`754`	`[Route("/CompetencyAssessments/{competencyAssessmentId}/Competencies/Optional/SetMinimum")]`
`756`		`- public IActionResult SetMinimumOptionalCompetencies(SelectOptionalCompetenciesViewModel model)`
	`755`	`+ public IActionResult SetMinimumOptionalCompetencies(SetMinimumOptionalCompetenciesFormData model)`
`757`	`756`	`{`
`758`	`757`	`if (!ModelState.IsValid)`
`759`	`758`	`{`
`760`	`759`	`var adminId = GetAdminID();`
`761`	`760`	`var competencyAssessmentBase = competencyAssessmentService.GetCompetencyAssessmentBaseById(model.ID, adminId);`
`762`	`761`	`var competencies = competencyAssessmentService.GetCompetenciesForCompetencyAssessment(model.ID);`
`763`		`- var viewModel = new SelectOptionalCompetenciesViewModel(competencyAssessmentBase, competencies, model.TaskStatus);`
	`762`	`+ var viewModel = new SetMinimumOptionalCompetenciesViewModel(competencyAssessmentBase, competencies);`
`764`	`763`	`return View("SetMinimumOptionalCompetencies", viewModel);`
`765`	`764`	`}`
`766`	`765`	`competencyAssessmentService.UpdateMinimumOptionalCompetencies(model.ID, model.MinimumOptionalCompetencies ?? 0);`
Original file line number	Diff line number	Diff line change
`@@ -2,41 +2,35 @@`
`2`	`2`	`using System;`
`3`	`3`	`using System.ComponentModel.DataAnnotations;`
`4`	`4`
`5`		`-public class MaxOptionalCompetenciesAttribute : ValidationAttribute`
	`5`	`+public class MaxOptionalCountAttribute : ValidationAttribute`
`6`	`6`	`{`
`7`		`- private readonly string _selectedIdsProperty;`
	`7`	`+ private readonly string _maxProperty;`
`8`	`8`
`9`		`- public MaxOptionalCompetenciesAttribute(string selectedIdsProperty)`
	`9`	`+ public MaxOptionalCountAttribute(string maxProperty)`
`10`	`10`	`{`
`11`		`- _selectedIdsProperty = selectedIdsProperty;`
	`11`	`+ _maxProperty = maxProperty;`
`12`	`12`	`}`
`13`	`13`
`14`	`14`	`protected override ValidationResult? IsValid(object? value, ValidationContext validationContext)`
`15`	`15`	`{`
`16`		`- // Get the integer value (MinimumOptionalCompetencies)`
`17`	`16`	`var number = value as int?;`
`18`	`17`	`if (number == null)`
`19`	`18`	`{`
`20`	`19`	`return ValidationResult.Success;`
`21`	`20`	`}`
`22`	`21`
`23`		`- // Get the other property (SelectedCompetencyIds)`
`24`		`- var selectedIdsProperty = validationContext.ObjectType.GetProperty(_selectedIdsProperty);`
`25`		`- if (selectedIdsProperty == null)`
	`22`	`+ // Get the max property value (OptionalCompetenciesCount)`
	`23`	`+ var maxProp = validationContext.ObjectType.GetProperty(_maxProperty);`
	`24`	`+ if (maxProp == null)`
`26`	`25`	`{`
`27`		`- return new ValidationResult($"Unknown property {_selectedIdsProperty}");`
	`26`	`+ return new ValidationResult($"Unknown property {_maxProperty}");`
`28`	`27`	`}`
`29`	`28`
`30`		`- var selectedIds = (int[])selectedIdsProperty.GetValue(validationContext.ObjectInstance, null)`
`31`		`- ?? Array.Empty<int>();`
	`29`	`+ var maxValue = (int)maxProp.GetValue(validationContext.ObjectInstance)!;`
`32`	`30`
`33`		`- var maxAllowed = selectedIds.Length;`
`34`		`-`
`35`		`- if (number < 0 \|\| number > maxAllowed)`
	`31`	`+ if (number < 0 \|\| number > maxValue)`
`36`	`32`	`{`
`37`		`- return new ValidationResult(`
`38`		`- $"Value must be between 0 and {maxAllowed}."`
`39`		`- );`
	`33`	`+ return new ValidationResult($"Must be between 0 and {maxValue}.");`
`40`	`34`	`}`
`41`	`35`
`42`	`36`	`return ValidationResult.Success;`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ public class SelectOptionalCompetenciesFormData`
`6`	`6`	`{`
`7`	`7`	`public int ID { get; set; }`
`8`	`8`	`public bool? TaskStatus { get; set; }`
`9`		`- [MaxOptionalCompetencies(nameof(SelectedCompetencyIds))]`
`10`	`9`	`public int? MinimumOptionalCompetencies { get; set; }`
`11`	`10`	`public string? ManageOptionalCompetenciesPrompt { get; set; }`
`12`	`11`	`public int[] SelectedCompetencyIds { get; set; } = [];`