public async Task <IEnumerable <ImageViewModel> > Handle(GetImagesQuery message, CancellationToken cancellationToken)
{
var images = await _dbContext.Images.ToListAsync();
var viewModel = _context.Map(images);
return(viewModel);
}
public async Task <IEnumerable <ResumeEventViewModel> > Handle(GetResumeEventsQuery message, CancellationToken cancellationToken)
{
var author = await _dbContext.Authors.FirstOrDefaultAsync(a => a.Id == message.AuthorId);
var resumeEvents = await _dbContext.ResumeEvents.Where(r => r.AuthorId == author.Id)
.OrderByDescending(r => r.DateRange.StartDate)
.ToListAsync();
return(_context.Map(resumeEvents));
}
public async Task <BlogPostUpdateViewModel> Handle(UpdateBlogPostQuery query, CancellationToken cancellationToken)
{
var blogPost = await _dbContext.BlogPosts.Include(b => b.Tags)
.Include(b => b.Image)
.Include(b => b.ExternalLinks)
.Include(b => b.MetaTags)
.FirstOrDefaultAsync(b => b.Id == query.Id);
return(_context.Map(blogPost));
}
public async Task <Result <IEnumerable <CategoryViewModel> > > Handle(GetAllCategoriesQuery request, CancellationToken cancellationToken)
{
var categories = await _dbContext.Categories.OrderBy(c => c.SortOrder).ToListAsync(cancellationToken: cancellationToken);
if (!categories.Any())
{
return(Result <IEnumerable <CategoryViewModel> > .NotFoundResult());
}
return(_context.Map(categories).ToSuccessResult());
}
private async Task <BlogPostViewModel> CreateViewModelAsync(int blogPostId)
{
var blogPost = await GetBlogPost(blogPostId);
if (blogPost == null)
{
return(null);
}
return(_context.Map(blogPost));
}
public async Task <Result <CategoryViewModel> > Handle(GetCategoryQuery request, CancellationToken cancellationToken)
{
var foundCategory = await _dbContext.Categories.FirstOrDefaultAsync(c => c.Id == request.Id, cancellationToken : cancellationToken);
if (foundCategory == null)
{
return(Result <CategoryViewModel> .NotFoundResult());
}
var viewModel = _context.Map(foundCategory);
return(viewModel.ToSuccessResult());
}
public void HandlerContext_Maps_Correctly()
{
var mapper = TestContext.CreateMapper(new[] { new TestViewModelProfile() });
var cacheService = TestContext.CreateStubCacheService();
var context = new HandlerContext <TestViewModel>(mapper, RequestDbContext, cacheService);
var testModel = new TestModel()
{
FirstName = "Test", LastName = "Test"
};
var testViewModel = context.Map(testModel);
Assert.Equal("Test Test", testViewModel.FullName);
}
private async Task <IEnumerable <BlogPostSummaryViewModel> > ViewModelAsync(string tag)
{
IEnumerable <BlogPost> blogPosts;
if (tag == null)
{
blogPosts = await QueryBlogPosts();
}
else
{
blogPosts = await QueryBlogPostsWithTag(tag);
}
return(_context.Map(blogPosts));
}
private AuthorViewModel CreateViewModel(Author author) => _context.Map(author);
private ResumeEventViewModel ViewModel(ResumeEvent resumeEvent) => _context.Map(resumeEvent);
public async Task <ResumeViewModel> CreateViewModelAsync(GetResumeQuery message)
{
var resume = await CreateResumeAsync(message.AuthorId);
return(_context.Map(resume));
}
private BlogPostSummaryViewModel ViewModel(BlogPost blogPost) => _context.Map(blogPost);
public async Task <IEnumerable <BlogPostSummaryViewModel> > Handle(GetBlogPostsByCategoryQuery request, CancellationToken cancellationToken)
{
var blogs = await _cacheService.GetOrAddAsync(() => BlogPostsFactoryAsync(request.CategoryId), request.CategoryId);
return(_context.Map(blogs));
}
private ResumeEventViewModel ViewModel(ResumeEvent resumeEvent)
{
return(_context.Map(resumeEvent));
}
public async Task <ResumeEventViewModel> Handle(GetResumeEventQuery message, CancellationToken cancellationToken)
{
var resumeEvent = await _dbContext.ResumeEvents.FindAsync(message.Id);
return(_context.Map(resumeEvent));
}
