public async Task Then_Redirects_To_The_Confirmation_Employer_View_With_ProviderId_When_Part_Of_Empty_Cohort(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            CreateReservationResult createReservationResult,
            [Frozen] Mock <IMediator> mockMediator,
            ReservationsController controller)
        {
            createReservationResult.IsEmptyCohortFromSelect = true;
            routeModel.UkPrn = null;
            var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, Guid.NewGuid().ToString());

            controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
            viewModel.Reserve           = true;
            mockMediator
            .Setup(mediator => mediator.Send(It.IsAny <CreateReservationCommand>(), CancellationToken.None))
            .ReturnsAsync(createReservationResult);

            var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;

            result.Should().NotBeNull($"result was not a {typeof(RedirectToRouteResult)}");
            result.RouteName.Should().Be(RouteNames.EmployerCompleted);
            result.RouteValues.Should().ContainKey("id").WhichValue.Should().NotBe(Guid.Empty);
            result.RouteValues.Should().ContainKey("cohortReference")
            .WhichValue.Should().Be(createReservationResult.CohortRef);
            result.RouteValues.Should().ContainKey("accountLegalEntityPublicHashedId")
            .WhichValue.Should().Be(createReservationResult.AccountLegalEntityPublicHashedId);
            result.RouteValues.Should().ContainKey("providerId")
            .WhichValue.Should().Be(createReservationResult.ProviderId);
        }
        public void Then_The_Model_Is_Constructed_With_Correct_Route_Names_Using_Other_Constructor(uint?ukPrn)
        {
            //Arrange
            var startDate = new TrainingDateModel {
                StartDate = DateTime.Now
            };

            var reservationsRouteModel = new ReservationsRouteModel
            {
                AccountLegalEntityPublicHashedId = AccountLegalEntityPublicHashedId,
                UkPrn             = ukPrn,
                Id                = new Guid(),
                EmployerAccountId = "123FDS",
                FromReview        = true
            };

            var postReviewViewModel = new PostReviewViewModel
            {
                AccountLegalEntityName           = AccountLegalEntityName,
                AccountLegalEntityPublicHashedId = AccountLegalEntityPublicHashedId,
                CourseDescription = CourseDescription,
                TrainingDate      = startDate,
                Reserve           = ExpectedReserve
            };

            //Act
            var actual = new ReviewViewModel(reservationsRouteModel, postReviewViewModel);

            //Assert
            AssertAllProperties(actual, ukPrn, startDate);
            Assert.AreEqual(ExpectedReserve, actual.Reserve);
        }
        public void Add_A_Stat_For_Sentences_Per_Paragraph()
        {
            Post.Content = "<p>This is a dog.  This is a basset hound.</p><p>This is something.</p>";

            Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));

            Target.Stats["Sentences Per Paragraph"].ShouldBe("1.5");
        }
        public void Add_A_Warning_For_Non_SSL_Links()
        {
            Post.Content = $@"<p>Only an external <a href=""http://wwww.theonion.com/blah"">link</a>.</p>";

            Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));

            Target.Warnings.ShouldContain(s => s.Contains("non-SSL links"));
        }
        public void Add_A_Warning_When_Post_Is_Less_Than_Ninety_Percent_Of_Length()
        {
            RenderedContents.Arrange(rc => rc.WordCount).Returns(1079);

            Target = new PostReviewViewModel(Post, RenderedContents);

            Target.Warnings.ShouldContain(s => s.Contains("too short"));
        }
        public void Add_A_Warning_When_No_Internal_Links_Exist()
        {
            Post.Content = $@"<p>Only an external <a href=""https://wwww.theonion.com/blah"">link</a>.</p>";

            Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));

            Target.Warnings.ShouldNotBeEmpty();
        }
        public async Task And_Invalid_ViewModel_And_Has_Ukprn_Then_Continues_As_Normal(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            ReservationsController controller)
        {
            controller.ModelState.AddModelError("key", "error message");

            var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;

            result.RouteName.Should().Be(RouteNames.ProviderCompleted);
        }
Esempio n. 8
0
        public ActionResult Review(int postId)
        {
            var post = _blogContext.BlogPosts.First(p => p.Id == postId);

            AuthorizeWordpress();
            post.Content = _wordpressService.GetBlogPostById(post.WordpressId).Content;

            var viewModel = new PostReviewViewModel(post, new RenderedPostContents(post.Content));

            _blogContext.SaveChanges();
            return(View(viewModel));
        }
        public async Task Then_Sends_Create_Command_With_Correct_Values_Set(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            [Frozen] Mock <IMediator> mockMediator,
            ReservationsController controller)
        {
            await controller.PostReview(routeModel, viewModel);

            mockMediator.Verify(mediator =>
                                mediator.Send(It.Is <CreateReservationCommand>(command =>
                                                                               command.Id == routeModel.Id), It.IsAny <CancellationToken>()));
        }
        public async Task And_Invalid_ViewModel_And_No_Ukprn_Then_Renders_Provider_Review_Again(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            ReservationsController controller)
        {
            routeModel.UkPrn = null;
            controller.ModelState.AddModelError("key", "error message");

            var result = await controller.PostReview(routeModel, viewModel) as ViewResult;

            result.ViewName.Should().Be(ViewNames.EmployerReview);
            result.Model.Should().BeEquivalentTo(new ReviewViewModel(routeModel, viewModel));
        }
        public async Task And_Reserve_False_And_No_Ukprn_Then_Redirect_To_Account_Home(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            string expectedUrl,
            [Frozen] Mock <IExternalUrlHelper> mockUrlHelper,
            ReservationsController controller)
        {
            viewModel.Reserve = false;
            routeModel.UkPrn  = null;
            mockUrlHelper
            .Setup(helper => helper.GenerateDashboardUrl(routeModel.EmployerAccountId))
            .Returns(expectedUrl);

            var result = await controller.PostReview(routeModel, viewModel) as RedirectResult;

            result.Url.Should().Be(expectedUrl);
        }
        private IActionResult PostReviewStep(bool reserve)
        {
            var controller = Services.GetService <ReservationsController>();
            var claim      = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, TestData.UserId.ToString());

            controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));

            var viewModel = new PostReviewViewModel
            {
                Reserve      = reserve,
                TrainingDate = TestData.TrainingDate
            };

            var result = controller.PostReview(TestData.ReservationRouteModel, viewModel)
                         .Result;

            return(result);
        }
        public async Task And_CachedReservationNotFoundException_And_Has_Ukprn_Then_Redirects_To_ProviderIndex(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            CachedReservationNotFoundException notFoundException,
            [Frozen] Mock <IMediator> mockMediator,
            ReservationsController controller)
        {
            mockMediator.Setup(x => x.Send(It.IsAny <CreateReservationCommand>(), It.IsAny <CancellationToken>()))
            .ThrowsAsync(notFoundException);

            var actual = await controller.PostReview(routeModel, viewModel);

            actual.Should().NotBeNull();
            var redirectToRouteResult = actual as RedirectToRouteResult;

            redirectToRouteResult.Should().NotBeNull();
            redirectToRouteResult?.RouteName.Should().Be(RouteNames.ProviderIndex);
        }
        public async Task Then_Sends_UserId_If_Employer_Command_With_Correct_Values_Set(
            Guid expectedUserId,
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            [Frozen] Mock <IMediator> mockMediator,
            ReservationsController controller)
        {
            routeModel.UkPrn  = null;
            viewModel.Reserve = true;
            var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, expectedUserId.ToString());

            controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));

            await controller.PostReview(routeModel, viewModel);

            mockMediator.Verify(mediator =>
                                mediator.Send(It.Is <CreateReservationCommand>(command =>
                                                                               command.Id == routeModel.Id && command.UserId.Equals(expectedUserId)), It.IsAny <CancellationToken>()));
        }
        public async Task Then_Redirects_To_The_Confirmation_Provider_View_When_Has_UkPrn(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            CreateReservationResult createReservationResult,
            [Frozen] Mock <IMediator> mockMediator,
            ReservationsController controller)
        {
            mockMediator
            .Setup(mediator => mediator.Send(It.IsAny <CreateReservationCommand>(), CancellationToken.None))
            .ReturnsAsync(createReservationResult);

            var result = await controller.PostReview(routeModel, viewModel) as RedirectToRouteResult;

            result.Should().NotBeNull($"result was not a {typeof(RedirectToRouteResult)}");
            result.RouteName.Should().Be(RouteNames.ProviderCompleted);
            result.RouteValues.Should().ContainKey("id").WhichValue.Should().NotBe(Guid.Empty);
            result.RouteValues.Should().ContainKey("accountLegalEntityPublicHashedId")
            .WhichValue.Should().Be(createReservationResult.AccountLegalEntityPublicHashedId);
            result.RouteValues.Should().ContainKey("cohortReference")
            .WhichValue.Should().Be(createReservationResult.CohortRef);
        }
        public async Task And_CachedReservationNotFoundException_And_No_Ukprn_Then_Redirects_To_EmployerIndex(
            ReservationsRouteModel routeModel,
            PostReviewViewModel viewModel,
            CachedReservationNotFoundException notFoundException,
            [Frozen] Mock <IMediator> mockMediator,
            ReservationsController controller)
        {
            routeModel.UkPrn = null;
            var claim = new Claim(EmployerClaims.IdamsUserIdClaimTypeIdentifier, Guid.NewGuid().ToString());

            controller.HttpContext.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { claim }));
            viewModel.Reserve           = true;
            mockMediator.Setup(x => x.Send(It.IsAny <CreateReservationCommand>(), It.IsAny <CancellationToken>()))
            .ThrowsAsync(notFoundException);

            var actual = await controller.PostReview(routeModel, viewModel);

            actual.Should().NotBeNull();
            var redirectToRouteResult = actual as RedirectToRouteResult;

            redirectToRouteResult.Should().NotBeNull();
            redirectToRouteResult?.RouteName.Should().Be(RouteNames.EmployerIndex);
        }
Esempio n. 17
0
        //[OutputCache(Duration = 120)]
        public ActionResult PostInfo(Guid postId)
        {
            var review = this.reviewService.GetPostReview(postId, this.HttpContext.User.Identity.GetUserId());

            Guard.WhenArgument(review, "review").IsNull().Throw();

            var reviewVm = new PostReviewViewModel()
            {
                PostId          = review.PostId,
                IsRated         = review.Ratings.Any(),
                RatedFromViewer = review.RatedFromViewer,
                Comments        = review.Comments.Select(c => new CommentReviewViewModel()
                {
                    Username  = c.AuthorId,
                    Content   = c.Content,
                    CreatedOn = c.CreatedOn
                }),
                Book = new BookReviewViewModel()
                {
                    Id       = review.Book.Id,
                    Author   = review.Book.Author,
                    Category = review.Book.Category,
                    Title    = review.Book.Title,
                    Wishers  = review.Book.Wishers
                },
                Description = review.Description,
                CreatedOn   = review.CreatedOn,
                IsOwned     = review.IsOwned,
                IsRead      = review.IsRead,
                IsTradable  = review.IsTradable,
                Price       = review.Price,
                Username    = this.userManager.FindById(review.PublisherId).UserName,
                Ratings     = review.Ratings
            };

            return(this.PartialView("_PostInfo", reviewVm));
        }
Esempio n. 18
0
        public async Task <IActionResult> PostReview(ReservationsRouteModel routeModel, PostReviewViewModel viewModel)
        {
            var isProvider     = routeModel.UkPrn.HasValue;
            var reviewViewName = isProvider ? ViewNames.ProviderReview : ViewNames.EmployerReview;

            try
            {
                if (!isProvider)
                {
                    if (!ModelState.IsValid)
                    {
                        var reviewViewModel = new ReviewViewModel(routeModel, viewModel);
                        return(View(reviewViewName, reviewViewModel));
                    }

                    if (!viewModel.Reserve.Value)
                    {
                        var homeUrl = _urlHelper.GenerateDashboardUrl(routeModel.EmployerAccountId);
                        return(Redirect(homeUrl));
                    }
                }

                Guid?userId = null;
                if (!isProvider)
                {
                    var userAccountIdClaim = HttpContext.User.Claims.First(c => c.Type.Equals(EmployerClaims.IdamsUserIdClaimTypeIdentifier));

                    userId = Guid.Parse(userAccountIdClaim.Value);
                }

                var command = new CreateReservationCommand
                {
                    Id     = routeModel.Id.GetValueOrDefault(),
                    UkPrn  = routeModel.UkPrn,
                    UserId = userId
                };

                var result = await _mediator.Send(command);

                routeModel.AccountLegalEntityPublicHashedId = result.AccountLegalEntityPublicHashedId;
                routeModel.CohortReference = result.CohortRef;
                if (result.IsEmptyCohortFromSelect)
                {
                    routeModel.ProviderId = result.ProviderId;
                }
            }
            catch (ValidationException ex)
            {
                _logger.LogWarning(ex, "Validation error when trying to create reservation from cached reservation.");
                return(RedirectToRoute(routeModel.UkPrn.HasValue ? RouteNames.ProviderIndex : RouteNames.EmployerIndex, routeModel));
            }
            catch (CachedReservationNotFoundException ex)
            {
                _logger.LogWarning(ex, "Expected a cached reservation but did not find one.");
                return(RedirectToRoute(routeModel.UkPrn.HasValue ? RouteNames.ProviderIndex : RouteNames.EmployerIndex, routeModel));
            }

            return(RedirectToRoute(routeModel.UkPrn.HasValue ? RouteNames.ProviderCompleted : RouteNames.EmployerCompleted, routeModel));
        }
 public void Have_No_Internal_Links_When_Post_Blog_Is_Null()
 {
     Post.Blog = null;
     Target    = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
     Target.InternalLinks.Count().ShouldBe(0);
 }
 public void BeforeEachTest()
 {
     Target = new PostReviewViewModel(Post, new RenderedPostContents(Post.Content));
 }