public async Task Handle_ShouldBeReturnPosts() { var query = new GetPostsQuery { NumberPage = 1, PageSize = 1, Sort = GetPostsPostSort.LoadedAsc, UserId = DefaultUserId }; var handler = GetNewHandler(); var result = await handler.Handle(query, CancellationToken.None); Assert.AreEqual(query.NumberPage, result.CurrentPage); Assert.AreEqual(1, result.CountAllPages); Assert.That(result.Posts.Count == 1); var post = result.Posts.First(); Assert.That(post.Id > 0); Assert.That(post.Files.Count == DefaultFileIds.Count); Assert.That(DateTimeService.NowUtc > post.LastModifiedUtc || post.LastModifiedUtc == null); Assert.That(DateTimeService.NowUtc > post.LoadedUtc); Assert.That(post.Text, IsNotNullOrEmpty); post.Files.ForEach(f => { Assert.That(f.Id > 0); Assert.That(f.Name, IsNotNullOrEmpty); Assert.That(DateTimeService.NowUtc > f.LoadedUtc); }); }
public async Task <IActionResult> AllPosts() { // Get all posts. var postsQuery = new GetPostsQuery(); var postsDTO = await _mediator.Send(postsQuery); var posts = postsDTO.OrderByDescending(post => post.Date); var models = _mapper.Map <IEnumerable <PostDTO>, IEnumerable <PostViewModel> >(posts); foreach (var model in models) { var authorQuery = new GetAuthorQuery { Id = model.AuthorId }; var author = await _mediator.Send(authorQuery); var topicQuery = new GetTopicQuery { Id = model.TopicId }; var topic = await _mediator.Send(topicQuery); model.Author = author.FirstName + " " + author.LastName; model.Topic = topic.Text; } return(View(models)); }
public async Task <IActionResult> GetAllAsync() { var query = new GetPostsQuery(); var response = await _mediator.Send(query); return(Ok(response)); }
public Task <List <PostDto> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { var posts = _context.Posts .ProjectTo <PostDto>(_mapper.ConfigurationProvider) .ToList(); return(Task.FromResult(posts)); }
public async Task <List <PostsDto> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { var posts = await _postRepository.GetAllStuff(); var postsFromDb = await _repository.ListAllAsync(); var postsMapped = _mapper.Map <List <PostsDto> >(postsFromDb); return(postsMapped); }
public async Task OnGetAsync([FromRoute] int pageNum = 1) { PageNum = pageNum; var query = new GetPostsQuery(_db); Posts = await query.ExecuteAsync(pageNum, PageSize); Paginator = new Paginator(pageNum, await GetPageCountAsync()); }
/// <summary> /// Get posts info. /// </summary> /// <param name="request">Info request.</param> /// <param name="cancellationToken">Cancellation token.</param> /// <returns>Number of posts DTO.</returns> public async Task <ICollection <PostDTO> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { var entities = await _context.Posts .OrderByDescending(p => p.Date) .ToArrayAsync(cancellationToken); var posts = _mapper.Map <ICollection <PostDTO> >(entities); return(posts); }
public Task <IReadOnlyCollection <PublishedPost> > ExecuteAsync(GetPostsQuery command, IReadOnlyCollection <PublishedPost> previousResult) { int pageNumber = command.Page ?? 0; IReadOnlyCollection <PublishedPost> result = _repository .OrderByDescending(x => x.PostedAtUtc) .Skip(pageNumber * PageSize) .Take(PageSize).ToArray(); return(Task.FromResult(result)); }
public IActionResult GetAllPosts() { var query = new GetPostsQuery(); var result = queryProcessor.Process(query); if (result == null) { return(BadRequest()); } return(Ok(result)); }
public async Task Handler_ReturnsPostDTOCollection() { // Arrange var query = new GetPostsQuery(); // Act var handler = new GetPostsQuery.GetPostsQueryHandler(Context, Mapper); var result = await handler.Handle(query, CancellationToken.None); // Assert result.ShouldBeOfType <List <PostDTO> >(); result.ShouldNotBeNull(); }
public async Task <FilteredDataViewModel <PostViewModel> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { IEnumerable <PostViewModel> posts = await _postService.GetPostsAsync(request.SearchParams); int postsCount = await _postService.GetPostsCountAsync(request.SearchParams); return(new FilteredDataViewModel <PostViewModel> { Data = posts, Count = postsCount, }); }
public async Task <IActionResult> Index() { var query = new GetPostsQuery(this.documentDbOptions); var posts = await query.ExecuteAsync(); var viewModel = new PostSummaryListViewModel(); foreach (var post in posts) { viewModel.AddPost(post); } return(View(viewModel)); }
public async Task ShouldGetPostsForFeed() { var userId = await RunAsDefaultUserAsync(); var feed = FeedSeed.UserFeeds.FirstOrDefault(_ => _.Key == userId).Value; var query = new GetPostsQuery { FeedId = feed.Id }; var result = await SendAsync(query); result.Posts.Should().HaveCount(1); result.Posts.First().Text.Should().Be(feed.Posts.First().Text); }
public async Task OnGetAsync([FromQuery] int pageNum = 1) { PageNum = pageNum; var query = new GetPostsQuery(_db); Posts = await query.ExecuteAsync(PageNum, PageSize, publishedOnly : false); Posts = Posts .OrderBy(p => p.Published.HasValue) .ThenByDescending(p => p.Published) .ThenByDescending(p => p.Updated); Paginator = new Paginator(pageNum, await GetPageCountAsync()); }
public List <Post> Handle(GetPostsQuery query) { var posts = ctx.Posts .Include(p => p.Author) .Include(p => p.Comments) .ToList(); //TODO: Come back to this as a DB hit for each comment is horrific foreach (var post in posts) { post.Comments = LoadComments(post); } return(posts); }
public void Handle_GivenInvalidUserId_ThrowsException() { var query = new GetPostsQuery { NumberPage = 1, PageSize = 1, Sort = GetPostsPostSort.LoadedAsc, UserId = 2020 }; var handler = GetNewHandler(); Assert.ThrowsAsync <ValidationException>(async() => await handler.Handle(query, CancellationToken.None)); }
public async Task <IActionResult> Index(int id = default) { IRequest <ICollection <PostDTO> > postsQuery; if (id == default) { postsQuery = new GetPostsQuery(); } else { postsQuery = new GetPostsByAuthorIdQuery { AuthorId = id } }; // Get all posts. var postsDTO = await _mediator.Send(postsQuery); var posts = postsDTO.OrderByDescending(post => post.Date); var models = _mapper.Map <IEnumerable <PostDTO>, IEnumerable <PostViewModel> >(posts); foreach (var model in models) { var authorQuery = new GetAuthorQuery { Id = model.AuthorId }; var author = await _mediator.Send(authorQuery); var topicQuery = new GetTopicQuery { Id = model.TopicId }; var topic = await _mediator.Send(topicQuery); model.AuthorId = author.Id; model.Author = author.FirstName + " " + author.LastName; model.Topic = topic.Text; } return(View(models)); }
public async Task <IActionResult> List([FromServices] GetPostsQuery getPostQuery, string categoryCode = null, int page = 1) { if (page < 1) { page = 1; } IQueryable <Post> query = getPostQuery.ForCategory(categoryCode).Build(); double pagesCount = Math.Ceiling((double)query.Count() / postsPerPage); List <Data.Post> posts = await query.Paginate((page - 1) *postsPerPage, postsPerPage).ToListAsync(); var model = new PostsListModel { Posts = posts, CurrentPageIndex = page, TotalPageNumber = pagesCount }; return(Json(model)); }
public async Task<ActionResult> List(string categoryCode = null, int page = 1) { if (page < 1) { page = 1; } var query = new GetPostsQuery(this.context).ForCategory(categoryCode).Build(); var pagesCount = Math.Ceiling((double) query.Count()/postsPerPage); var posts = await query.Paginate((page - 1)*postsPerPage, postsPerPage).ToListAsync(); var model = new PostsListModel { Posts = posts, CurrentPageIndex = page, TotalPageNumber = pagesCount }; return View(model); }
public async Task <List <PostDto> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { var posts = await context.Posts .Include(x => x.Comments).ThenInclude(a => a.User) .Include(x => x.User).ThenInclude(x => x.Photo) .Include(x => x.PostEmotions) .OrderByDescending(x => x.CreateDate) .ToListAsync(); var postsDto = mapper.Map <List <PostDto> >(posts); foreach (var postdto in postsDto) { postdto.LikeCount = postdto.PostEmotions.Count(x => x.EmotionTypeId == 1); postdto.AngeryCount = postdto.PostEmotions.Count(x => x.EmotionTypeId == 2); } return(postsDto); throw new NotImplementedException(); }
public async Task ShouldReturnAsociatedPostsPaging() { // Arrange await RunAsDefaultUserAsync(); var addedPost = await AddAsync(new Post { DisplayName = "Test1", UserName = "******", PhotoUrl = "someUrl", Title = "Test1 Title", Content = "Test1 Content for GetPostQueryTest" }); var query = new GetPostsQuery() { CurrentPage = 0, PageSize = 4 }; // Act var postPagingResult = await SendAsync(query); // Assert foreach (var postItem in postPagingResult) { postItem.DisplayName.Should().Be(addedPost.DisplayName); postItem.UserName.Should().Be(addedPost.UserName); postItem.PhotoUrl.Should().Be(addedPost.PhotoUrl); postItem.Title.Should().Be(addedPost.Title); postItem.Content.Should().Be(addedPost.Content); } postPagingResult.Should().NotBeNull(); postPagingResult.TotalCount.Should().Be(1); postPagingResult.CurrentPage.Should().Be(1); postPagingResult.PageSize.Should().Be(3); postPagingResult.TotalPages.Should().Be(1); }
public async Task <PagedList <Post> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { var queryable = _context.Set <Post>().AsQueryable(); return(await PagedList <Post> .CreateAsync(queryable, request.CurrentPage, request.PageSize)); }
public async Task <ActionResult <GetPostsResponseDto> > GetPosts( [FromQuery] GetPostsQuery query) { return(await Mediator.Send(query)); }
public async Task <IActionResult> SitemapXml([FromServices] SitemapBuilder sitemapBuilder, [FromServices] GetPostsQuery getPostsQuery) { DateTime now = DateTime.Now; sitemapBuilder.AddUrl(new SitemapNode { Url = $"{this.Request.Scheme}://{this.Request.Host}", ChangeFrequency = ChangeFrequency.Always, Modified = now, Priority = 1 }); var posts = await getPostsQuery.Build().Select(p => new { PostUrl = p.Url, CategoryCode = p.Category.Code, p.PublicationDate }).ToListAsync(); foreach (var post in posts) { sitemapBuilder.AddUrl(new SitemapNode { Url = $"{this.Request.Scheme}://{this.Request.Host}/posts/{post.CategoryCode}/{post.PostUrl}", Priority = 0.5, Modified = post.PublicationDate, ChangeFrequency = ChangeFrequency.Always }); } return(Content(sitemapBuilder.ToString(), "application/xml", Encoding.UTF8)); }
public async Task <IActionResult> AllPosts([FromServices] GetPostsQuery query, string categoryCode = null) { System.Collections.Generic.List <Post> posts = await query.ForCategory(categoryCode).WithUnpublish().Build().ToListAsync(); return(Json(posts)); }
public Task <PagableListResult <GetPostsResult> > GetPosts( [FromQuery] GetPostsQuery query) => Mediator.Send(query);
public async Task <List <PostDto> > Get(GetPostsQuery command) { return(await _mediator.Send(command)); }
public async Task <IEnumerable <PostDto> > Handle(GetPostsQuery request) { IEnumerable <Post> posts = await persistence.GetAllPosts(); return(posts.Select(x => PostDto.From(x))); }
public Task <IReadOnlyCollection <Post> > ExecuteAsync(GetPostsQuery command, IReadOnlyCollection <Post> previousResult) { return(Task.FromResult((IReadOnlyCollection <Post>)Posts.Items.Values)); }
public async Task <ICollection <PostDTO> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { GetPosts(); return(GetDtoResponse()); }
public async Task <List <PostResponse> > Handle(GetPostsQuery request, CancellationToken cancellationToken) { var posts = await _postService.GetPostsAsync(); return(_mapper.Map <List <PostResponse> >(posts)); }