Ejemplo n.º 1
0
        public async Task <IActionResult> Appeal(AppealPostRequest request)
        {
            var userId   = HttpContext.User.UserId();
            var userName = HttpContext.User.UserDisplayName();

            if (request.SelectedOption == AppealPostRequest.SubmitOption.Upload)
            {
                await _appealOrchestrator.UploadAppealFile(request.ApplicationId, request.FileUpload, userId, userName);

                TempData.AddValue("Message", request.Message);
                return(RedirectToAction("Appeal", new AppealRequest {
                    ApplicationId = request.ApplicationId
                }));
            }

            if (request.SelectedOption == AppealPostRequest.SubmitOption.RemoveFile)
            {
                await _appealOrchestrator.RemoveAppealFile(request.ApplicationId, request.FileId, userId, userName);

                TempData.AddValue("Message", request.Message);
                return(RedirectToAction("Appeal", new AppealRequest {
                    ApplicationId = request.ApplicationId
                }));
            }

            await _appealOrchestrator.CreateAppeal(request.ApplicationId, request.OversightReviewId, request.Message, userId, userName);

            return(RedirectToAction("Outcome", new OutcomeRequest {
                ApplicationId = request.ApplicationId
            }));
        }
        public async Task Post_Appeal_New_Appeal_Recorded()
        {
            var applicationId     = Guid.NewGuid();
            var oversightReviewId = Guid.NewGuid();

            _appealOrchestrator.Setup(x =>
                                      x.CreateAppeal(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));

            var request = new AppealPostRequest
            {
                OversightReviewId = oversightReviewId,
                ApplicationId     = applicationId,
                FileUpload        = null,
                SelectedOption    = AppealPostRequest.SubmitOption.SaveAndContinue,
                Message           = _autoFixture.Create <string>()
            };

            await _controller.Appeal(request);

            _appealOrchestrator.Verify(x => x.CreateAppeal(It.Is <Guid>(id => id == applicationId),
                                                           It.Is <Guid>(reviewId => reviewId == oversightReviewId),
                                                           It.Is <string>(m => m == request.Message),
                                                           It.IsAny <string>(),
                                                           It.IsAny <string>()),
                                       Times.Once);
        }
Ejemplo n.º 3
0
        public async Task <Guid> SaveAppealPostRequestToCache(AppealPostRequest request)
        {
            var key = Guid.NewGuid();
            await _cacheStorageService.SaveToCache(key.ToString(), request, 1);

            return(key);
        }
Ejemplo n.º 4
0
        public async Task <IActionResult> Appeal([CustomizeValidator(Interceptor = typeof(AppealValidatorInterceptor))] AppealPostRequest request)
        {
            var userId   = HttpContext.User.UserId();
            var userName = HttpContext.User.UserDisplayName();

            var cacheKey = await _oversightOrchestrator.SaveAppealPostRequestToCache(request);

            return(RedirectToAction("ConfirmAppealOutcome", new { applicationId = request.ApplicationId, OutcomeKey = cacheKey }));
        }
Ejemplo n.º 5
0
        public void SetUp()
        {
            _pdfValidatorService = new Mock <IPdfValidatorService>();
            _pdfValidatorService.Setup(x => x.IsPdf(It.IsAny <IFormFile>())).ReturnsAsync(true);

            _validator = new AppealPostRequestValidator(_pdfValidatorService.Object);

            _request = new AppealPostRequest
            {
                ApplicationId  = Guid.NewGuid(),
                Message        = "This is a test message",
                SelectedOption = AppealPostRequest.SubmitOption.SaveAndContinue
            };
        }
        public async Task Post_Appeal_User_Is_Redirected_To_Outcome_Page()
        {
            var applicationId = Guid.NewGuid();

            var request = new AppealPostRequest
            {
                ApplicationId  = applicationId,
                Message        = "This is an appeal",
                SelectedOption = AppealPostRequest.SubmitOption.SaveAndContinue
            };

            var result = await _controller.Appeal(request);

            Assert.IsInstanceOf <RedirectToActionResult>(result);
            var redirectResult = (RedirectToActionResult)result;

            Assert.AreEqual("Outcome", redirectResult.ActionName);
            Assert.IsTrue(redirectResult.RouteValues.ContainsKey("ApplicationId"));
        }
        public async Task Post_Appeal_RemoveFile_Removal_Is_Recorded()
        {
            var applicationId = Guid.NewGuid();
            var fileId        = Guid.NewGuid();

            _appealOrchestrator.Setup(x =>
                                      x.RemoveAppealFile(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>()));

            var request = new AppealPostRequest
            {
                ApplicationId  = applicationId,
                SelectedOption = AppealPostRequest.SubmitOption.RemoveFile,
                FileId         = fileId
            };

            await _controller.Appeal(request);

            _appealOrchestrator.Verify(x => x.RemoveAppealFile(applicationId, fileId, It.IsAny <string>(), It.IsAny <string>()));
        }
        public async Task Post_Appeal_Preserves_Any_Message_In_TempData_On_Post_Of_Non_CTA(AppealPostRequest.SubmitOption submitOption)
        {
            var applicationId = Guid.NewGuid();
            var fileId        = Guid.NewGuid();

            _appealOrchestrator.Setup(x =>
                                      x.RemoveAppealFile(It.IsAny <Guid>(), It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>()));

            var request = new AppealPostRequest
            {
                ApplicationId  = applicationId,
                Message        = _autoFixture.Create <string>(),
                FileUpload     = submitOption == AppealPostRequest.SubmitOption.Upload ? GenerateFile() : null,
                FileId         = submitOption == AppealPostRequest.SubmitOption.RemoveFile ? fileId : Guid.Empty,
                SelectedOption = submitOption
            };

            await _controller.Appeal(request);

            Assert.AreEqual(request.Message, _tempDataDictionary["Message"]);
        }
Ejemplo n.º 9
0
        public async Task Post_Appeal_redirects_to_confirmation()
        {
            var viewModel = new AppealViewModel()
            {
                ApplicationSummary = new ApplicationSummaryViewModel {
                    ApplicationId = _applicationDetailsApplicationId
                }
            };

            _oversightOrchestrator.Setup(x => x.GetAppealDetailsViewModel(_applicationDetailsApplicationId, null)).ReturnsAsync(viewModel);

            var command = new AppealPostRequest()
            {
                ApplicationId    = _applicationDetailsApplicationId,
                AppealStatus     = AppealStatus.Unsuccessful,
                UnsuccessfulText = "test"
            };

            var result = await _controller.Appeal(command) as RedirectToActionResult;

            Assert.AreEqual("ConfirmAppealOutcome", result.ActionName);
        }
        public async Task Post_Appeal_File_Upload_Is_Recorded()
        {
            var applicationId = Guid.NewGuid();

            _appealOrchestrator.Setup(x =>
                                      x.UploadAppealFile(It.IsAny <Guid>(), It.IsAny <IFormFile>(), It.IsAny <string>(), It.IsAny <string>()));

            var file = GenerateFile();

            var request = new AppealPostRequest
            {
                ApplicationId  = applicationId,
                FileUpload     = file,
                SelectedOption = AppealPostRequest.SubmitOption.Upload
            };

            await _controller.Appeal(request);

            _appealOrchestrator.Verify(x => x.UploadAppealFile(It.Is <Guid>(id => id == applicationId),
                                                               It.Is <IFormFile>(f => f.FileName == file.FileName && f.ContentType == file.ContentType),
                                                               It.IsAny <string>(),
                                                               It.IsAny <string>()),
                                       Times.Once);
        }