public IActionResult LearnerInformation(LearnerInformationViewModel model)
        {
            var data = TempData.Peek <DelegateRegistrationByCentreData>() !;

            var centreId = data.Centre !.Value;

            promptsService.ValidateCentreRegistrationPrompts(
                centreId,
                model.Answer1,
                model.Answer2,
                model.Answer3,
                model.Answer4,
                model.Answer5,
                model.Answer6,
                ModelState
                );

            ProfessionalRegistrationNumberHelper.ValidateProfessionalRegistrationNumber(
                ModelState,
                model.HasProfessionalRegistrationNumber,
                model.ProfessionalRegistrationNumber
                );

            if (!ModelState.IsValid)
            {
                PopulateLearnerInformationExtraFields(model, data);
                return(View(model));
            }

            data.SetLearnerInformation(model);
            TempData.Set(data);

            return(RedirectToAction("WelcomeEmail"));
        }
        public void ValidateCentreRegistrationPrompts_adds_error_for_missing_mandatory_answer()
        {
            // Given
            var registrationPrompt1       = PromptsTestHelper.GetDefaultCentreRegistrationPrompt(1, mandatory: true);
            var registrationPrompt2       = PromptsTestHelper.GetDefaultCentreRegistrationPrompt(2, mandatory: true);
            var centreRegistrationPrompts = PromptsTestHelper.GetDefaultCentreRegistrationPrompts(
                new List <CentreRegistrationPrompt> {
                registrationPrompt1, registrationPrompt2
            },
                1
                );
            var modelState = new ModelStateDictionary();

            A.CallTo(() => centreRegistrationPromptsService.GetCentreRegistrationPromptsByCentreId(1))
            .Returns(centreRegistrationPrompts);

            // When
            promptsService.ValidateCentreRegistrationPrompts(1, null, Answer2, null, null, null, null, modelState);

            // Then
            modelState["Answer1"].Errors.Count.Should().Be(1);
            modelState["Answer2"].Should().BeNull();
        }
        public IActionResult Index(EditDelegateFormData formData, int delegateId)
        {
            var centreId = User.GetCentreId();

            promptsService.ValidateCentreRegistrationPrompts(formData, centreId, ModelState);

            if (!userService.NewAliasIsValid(formData.AliasId, delegateId, centreId))
            {
                ModelState.AddModelError(
                    nameof(EditDelegateFormData.AliasId),
                    "A user with this alias is already registered at this centre"
                    );
            }

            ProfessionalRegistrationNumberHelper.ValidateProfessionalRegistrationNumber(
                ModelState,
                formData.HasProfessionalRegistrationNumber,
                formData.ProfessionalRegistrationNumber
                );

            if (!ModelState.IsValid)
            {
                return(ReturnToEditDetailsViewWithErrors(formData, delegateId, centreId));
            }

            if (!userService.NewEmailAddressIsValid(formData.Email !, null, delegateId, centreId))
            {
                ModelState.AddModelError(
                    nameof(EditDetailsFormData.Email),
                    "A user with this email is already registered at this centre"
                    );
                return(ReturnToEditDetailsViewWithErrors(formData, delegateId, centreId));
            }

            var(accountDetailsData, centreAnswersData) = AccountDetailsDataHelper.MapToUpdateAccountData(
                formData,
                delegateId,
                User.GetCentreId()
                );
            userService.UpdateUserAccountDetailsViaDelegateAccount(accountDetailsData, centreAnswersData);

            return(RedirectToAction("Index", "ViewDelegate", new { delegateId }));
        }