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));
}
