public async Task ConfirmRemoveApplication_Yes_selected_And_fails_validation_returns_back_to_View()
        {
            var applicationId = Guid.NewGuid();

            var viewModel = new RoatpRemoveApplicationViewModel
            {
                ApplicationId            = applicationId,
                ConfirmApplicationAction = "Yes"
            };

            var validationErrors = new List <ValidationErrorDetail> {
                new ValidationErrorDetail()
            };

            ApplyApiClient.Setup(x => x.GetApplication(applicationId)).ReturnsAsync(new Apply {
                ApplicationId = applicationId
            });
            ApplyApiClient.Setup(x => x.GetOversightDetails(applicationId)).ReturnsAsync(() =>
                                                                                         new ApplicationOversightDetails {
                OversightStatus = OversightReviewStatus.None
            });
            _removeApplicationValidator.Setup(v => v.Validate(viewModel)).ReturnsAsync(new ValidationResponse {
                Errors = validationErrors
            });

            var result = await _controller.ConfirmRemoveApplication(applicationId, viewModel);

            var viewResult = result as ViewResult;

            Assert.IsTrue(viewResult.ViewName.EndsWith("ConfirmRemoveApplication.cshtml"));
        }
        public void ProcessRemoveApplicationViewModelOnError(RoatpRemoveApplicationViewModel viewModelOnError, ValidationResponse validationResponse)
        {
            if (validationResponse.Errors != null && validationResponse.Errors.Any())
            {
                viewModelOnError.ErrorMessages = validationResponse.Errors;

                foreach (var error in viewModelOnError.ErrorMessages)
                {
                    if (error.Field.Equals("ConfirmApplicationActionYes"))
                    {
                        viewModelOnError.CssFormGroupError = HtmlAndCssElements.CssFormGroupErrorClass;
                    }
                    else if (error.Field.Equals("OptionYesText"))
                    {
                        viewModelOnError.CssOnErrorOptionYesText = HtmlAndCssElements.CssTextareaErrorOverrideClass;
                        viewModelOnError.CssFormGroupError       = HtmlAndCssElements.CssFormGroupErrorClass;
                    }
                    else if (error.Field.Equals("OptionYesTextExternal"))
                    {
                        viewModelOnError.CssOnErrorOptionYesTextExternal = HtmlAndCssElements.CssTextareaErrorOverrideClass;
                        viewModelOnError.CssFormGroupError = HtmlAndCssElements.CssFormGroupErrorClass;
                    }
                }
            }
        }
        public async Task ConfirmRemoveApplication_When_oversight_performed_selected_returns_to_ViewApplication()
        {
            var applicationId = Guid.NewGuid();

            var viewModel = new RoatpRemoveApplicationViewModel
            {
                ApplicationId            = applicationId,
                ConfirmApplicationAction = HtmlAndCssElements.RadioButtonValueNo
            };

            ApplyApiClient.Setup(x => x.GetApplication(applicationId)).ReturnsAsync(new Apply {
                ApplicationId = applicationId
            });
            ApplyApiClient.Setup(x => x.GetOversightDetails(applicationId)).ReturnsAsync(() =>
                                                                                         new ApplicationOversightDetails {
                OversightStatus = OversightReviewStatus.Successful
            });
            _removeApplicationValidator.Setup(v => v.Validate(viewModel)).ReturnsAsync(new ValidationResponse {
                Errors = new List <ValidationErrorDetail>()
            });

            var result = await _controller.ConfirmRemoveApplication(applicationId, viewModel);

            var viewResult = result as RedirectToActionResult;

            Assert.AreEqual(nameof(RoatpGatewayController.ViewApplication), viewResult.ActionName);
            Assert.AreEqual("RoatpGateway", viewResult.ControllerName);
        }
        public async Task When_ConfirmApplicationAction_Is_No()
        {
            _viewModel = new RoatpRemoveApplicationViewModel
            {
                ConfirmApplicationAction = HtmlAndCssElements.RadioButtonValueNo
            };

            var result = await _validator.Validate(_viewModel);

            Assert.IsFalse(result.Errors.Any());
        }
        public async Task When_ConfirmApplicationAction_is_Empty()
        {
            _viewModel = new RoatpRemoveApplicationViewModel
            {
                ConfirmApplicationAction = string.Empty
            };

            var result = await _validator.Validate(_viewModel);

            Assert.IsTrue(result.Errors.Any());
            Assert.AreEqual("ConfirmApplicationActionYes", result.Errors.First().Field);
        }
        public async Task When_ConfirmApplicationAction_is_Yes_but_OptionYesTextExternal_is_Empty()
        {
            _viewModel = new RoatpRemoveApplicationViewModel
            {
                ConfirmApplicationAction = HtmlAndCssElements.RadioButtonValueYes,
                OptionYesText            = "text",
                OptionYesTextExternal    = string.Empty
            };

            var result = await _validator.Validate(_viewModel);

            Assert.IsTrue(result.Errors.Any());
            Assert.AreEqual("OptionYesTextExternal", result.Errors.First().Field);
        }
        public async Task RemoveApplication_model_is_returned()
        {
            var applicationId     = Guid.NewGuid();
            var expectedViewModel = new RoatpRemoveApplicationViewModel {
                ApplicationId = applicationId
            };

            _applicationActionsOrchestrator.Setup(x => x.GetRemoveApplicationViewModel(applicationId, UserId, Username)).ReturnsAsync(expectedViewModel);

            var result = await _controller.RemoveApplication(applicationId);

            var viewResult = result as ViewResult;

            Assert.AreSame(expectedViewModel, viewResult.Model);
        }
        public async Task When_OptionYesText_is_too_long(int wordCount, bool hasErrorMessage)
        {
            _viewModel = new RoatpRemoveApplicationViewModel
            {
                ConfirmApplicationAction = HtmlAndCssElements.RadioButtonValueYes,
                OptionYesText            = string.Join(" ", Enumerable.Range(1, wordCount)),
                OptionYesTextExternal    = "text"
            };

            var result = await _validator.Validate(_viewModel);

            Assert.AreEqual(hasErrorMessage, result.Errors.Any());

            if (hasErrorMessage)
            {
                Assert.AreEqual("OptionYesText", result.Errors.First().Field);
            }
        }
Пример #9
0
        public async Task <ValidationResponse> Validate(RoatpRemoveApplicationViewModel viewModel)
        {
            var validationResponse = new ValidationResponse
            {
                Errors = new List <ValidationErrorDetail>()
            };

            if (string.IsNullOrEmpty(viewModel.ConfirmApplicationAction))
            {
                validationResponse.Errors.Add(new ValidationErrorDetail("ConfirmApplicationActionYes", NoSelectionErrorMessage));
            }
            else if (viewModel.ConfirmApplicationAction.Equals(HtmlAndCssElements.RadioButtonValueYes, StringComparison.InvariantCultureIgnoreCase))
            {
                if (string.IsNullOrEmpty(viewModel.OptionYesText))
                {
                    validationResponse.Errors.Add(new ValidationErrorDetail("OptionYesText", ErrorEnterComments));
                }
                else
                {
                    var wordCount = viewModel.OptionYesText.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries).Length;
                    if (wordCount > 150)
                    {
                        validationResponse.Errors.Add(new ValidationErrorDetail("OptionYesText", TooManyWords));
                    }
                }

                if (string.IsNullOrEmpty(viewModel.OptionYesTextExternal))
                {
                    validationResponse.Errors.Add(new ValidationErrorDetail("OptionYesTextExternal", ErrorEnterExternalComments));
                }
                else
                {
                    var wordCount = viewModel.OptionYesTextExternal.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries).Length;
                    if (wordCount > 500)
                    {
                        validationResponse.Errors.Add(new ValidationErrorDetail("OptionYesTextExternal", TooManyWordsExternal));
                    }
                }
            }

            return(await Task.FromResult(validationResponse));
        }
        public async Task <RoatpRemoveApplicationViewModel> GetRemoveApplicationViewModel(Guid applicationId, string userId, string userName)
        {
            RoatpRemoveApplicationViewModel viewModel = null;

            var commonDetails = await _applyApiClient.GetPageCommonDetails(applicationId, _commonDetailsPageId, userId, userName);

            if (commonDetails != null)
            {
                viewModel = new RoatpRemoveApplicationViewModel
                {
                    ApplicationId          = commonDetails.ApplicationId,
                    ApplicationStatus      = commonDetails.ApplicationStatus,
                    Ukprn                  = commonDetails.Ukprn,
                    ApplyLegalName         = commonDetails.LegalName,
                    ApplicationRoute       = commonDetails.ProviderRouteName,
                    ApplicationSubmittedOn = commonDetails.ApplicationSubmittedOn
                };
            }

            return(viewModel);
        }
        private RoatpRemoveApplicationViewModel ProcessRemoveApplicationViewModelOnError(Guid applicationId, string field, string errorMessage)
        {
            var viewModelOnError = new RoatpRemoveApplicationViewModel
            {
                ApplicationId = applicationId,
            };

            var validationResponse = new ValidationResponse
            {
                Errors = new List <ValidationErrorDetail>
                {
                    new ValidationErrorDetail
                    {
                        Field        = field,
                        ErrorMessage = errorMessage
                    }
                }
            };

            _orchestrator.ProcessRemoveApplicationViewModelOnError(viewModelOnError, validationResponse);

            return(viewModelOnError);
        }
        public async Task ConfirmRemoveApplication_Yes_selected_And_passed_validation_performs_Application_Removal()
        {
            var applicationId = Guid.NewGuid();

            var application = new Apply
            {
                ApplicationId = applicationId,
                ApplyData     = new ApplyData {
                    ApplyDetails = new ApplyDetails()
                }
            };

            var viewModel = new RoatpRemoveApplicationViewModel
            {
                ApplicationId            = applicationId,
                ConfirmApplicationAction = HtmlAndCssElements.RadioButtonValueYes
            };

            var validationErrors = new List <ValidationErrorDetail>();

            ApplyApiClient.Setup(x => x.GetApplication(applicationId)).ReturnsAsync(application);
            ApplyApiClient.Setup(x => x.GetOversightDetails(applicationId)).ReturnsAsync(() =>
                                                                                         new ApplicationOversightDetails {
                OversightStatus = OversightReviewStatus.None
            });
            _removeApplicationValidator.Setup(v => v.Validate(viewModel)).ReturnsAsync(new ValidationResponse {
                Errors = validationErrors
            });

            var result = await _controller.ConfirmRemoveApplication(applicationId, viewModel);

            var viewResult = result as ViewResult;

            Assert.IsTrue(viewResult.ViewName.EndsWith("ApplicationRemoved.cshtml"));
            ApplyApiClient.Verify(x => x.RemoveApplication(viewModel.ApplicationId, viewModel.OptionYesText, viewModel.OptionYesTextExternal, It.IsAny <string>(), It.IsAny <string>()), Times.Once);
        }
Пример #13
0
        public async Task <IActionResult> ConfirmRemoveApplication(Guid applicationId, RoatpRemoveApplicationViewModel viewModel)
        {
            var application = await _applyApiClient.GetApplication(applicationId);

            if (application is null)
            {
                return(RedirectToAction(nameof(RoatpGatewayController.NewApplications), "RoatpGateway"));
            }
            else if (application.ApplicationStatus == ApplicationStatus.Removed)
            {
                return(RedirectToAction(nameof(RoatpGatewayController.ViewApplication), "RoatpGateway", new { applicationId }));
            }

            var validationResponse = await _removeApplicationValidator.Validate(viewModel);

            if (validationResponse.Errors != null && validationResponse.Errors.Any())
            {
                _applicationActionsOrchestrator.ProcessRemoveApplicationViewModelOnError(viewModel, validationResponse);
                return(View("~/Views/Gateway/ConfirmRemoveApplication.cshtml", viewModel));
            }
            else if (viewModel.ConfirmApplicationAction == HtmlAndCssElements.RadioButtonValueYes)
            {
                var username = HttpContext.User.UserDisplayName();
                var userId   = HttpContext.User.UserId();
                await _applyApiClient.RemoveApplication(viewModel.ApplicationId, viewModel.OptionYesText, viewModel.OptionYesTextExternal, userId, username);

                viewModel.ApplicationReferenceNumber = application.ApplyData.ApplyDetails.ReferenceNumber;
                return(View("~/Views/Gateway/ApplicationRemoved.cshtml", viewModel));
            }
            else
            {
                return(RedirectToAction(nameof(RoatpGatewayController.ViewApplication), "RoatpGateway", new { applicationId }));
            }
        }