7697858967

Committed 29 Jan 2024 02:45PM UTC coverage: 58.562%. Remained the same

Build # 7697858967

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #473 from loresoft/dependabot/github_actions/actions/deploy-pages-4

Bump actions/deploy-pages from 2 to 4

Run Details

230 of 438 branches covered (0.0%)

Branch coverage included in aggregate %.

560 of 911 relevant lines covered (61.47%)

19.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/MediatR.CommandQuery.Cosmos/Handlers/EntityPagedQueryHandler.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading;
using System.Threading.Tasks;

using AutoMapper;

using Cosmos.Abstracts;
using Cosmos.Abstracts.Extensions;

using MediatR.CommandQuery.Extensions;
using MediatR.CommandQuery.Queries;

using Microsoft.Azure.Cosmos.Linq;
using Microsoft.Extensions.Logging;

namespace MediatR.CommandQuery.Cosmos.Handlers;

public class EntityPagedQueryHandler<TRepository, TEntity, TReadModel>
    : RepositoryHandlerBase<TRepository, TEntity, EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>
    where TRepository : ICosmosRepository<TEntity>
    where TEntity : class
{
    public EntityPagedQueryHandler(ILoggerFactory loggerFactory, TRepository repository, IMapper mapper)
        : base(loggerFactory, repository, mapper)
    {
    }

    protected override async Task<EntityPagedResult<TReadModel>> Process(EntityPagedQuery<TReadModel> request, CancellationToken cancellationToken)
    {
        if (request is null)
            throw new ArgumentNullException(nameof(request));

        var cosmosQuery = await Repository
            .GetQueryableAsync()
            .ConfigureAwait(false);

        // build query from filter
        var query = BuildQuery(request, cosmosQuery);

        // get total for query
        int total = await QueryTotal(request, query, cancellationToken)
            .ConfigureAwait(false);

        // short circuit if total is zero
        if (total == 0)
            return new EntityPagedResult<TReadModel> { Data = new List<TReadModel>() };

        // page the query and convert to read model
        var result = await QueryPaged(request, query, cancellationToken)
            .ConfigureAwait(false);

        return new EntityPagedResult<TReadModel>
        {
            Total = total,
            Data = result
        };
    }


    protected virtual IQueryable<TEntity> BuildQuery(EntityPagedQuery<TReadModel> request, IQueryable<TEntity> query)
    {
        var entityQuery = request.Query;

        // build query from filter
        if (entityQuery?.Filter != null)
            query = query.Filter(entityQuery.Filter);

        // add raw query
        if (!string.IsNullOrEmpty(entityQuery?.Query))
            query = query.Where(entityQuery.Query);


        return query;
    }

    protected virtual async Task<int> QueryTotal(EntityPagedQuery<TReadModel> request, IQueryable<TEntity> query, CancellationToken cancellationToken)
    {
        return await query
            .CountAsync(cancellationToken)
            .ConfigureAwait(false);
    }

    protected virtual async Task<IReadOnlyCollection<TReadModel>> QueryPaged(EntityPagedQuery<TReadModel> request, IQueryable<TEntity> query, CancellationToken cancellationToken)
    {
        var entityQuery = request.Query;

        var queryable = query
            .Sort(entityQuery.Sort);

        if (entityQuery.Page > 0 && entityQuery.PageSize > 0)
            queryable = queryable.Page(entityQuery.Page, entityQuery.PageSize);

        var results = await queryable
            .ToListAsync(cancellationToken)
            .ConfigureAwait(false);

        return Mapper.Map<IList<TEntity>, IReadOnlyCollection<TReadModel>>(results);
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Linq.Dynamic.Core;
5	using System.Threading;
6	using System.Threading.Tasks;
7
8	using AutoMapper;
9
10	using Cosmos.Abstracts;
11	using Cosmos.Abstracts.Extensions;
12
13	using MediatR.CommandQuery.Extensions;
14	using MediatR.CommandQuery.Queries;
15
16	using Microsoft.Azure.Cosmos.Linq;
17	using Microsoft.Extensions.Logging;
18
19	namespace MediatR.CommandQuery.Cosmos.Handlers;
20
21	public class EntityPagedQueryHandler<TRepository, TEntity, TReadModel>
22	: RepositoryHandlerBase<TRepository, TEntity, EntityPagedQuery<TReadModel>, EntityPagedResult<TReadModel>>
23	where TRepository : ICosmosRepository<TEntity>
24	where TEntity : class
25	{
26	public EntityPagedQueryHandler(ILoggerFactory loggerFactory, TRepository repository, IMapper mapper)
27	: base(loggerFactory, repository, mapper)	×
28	{
29	}	×
30
31	protected override async Task<EntityPagedResult<TReadModel>> Process(EntityPagedQuery<TReadModel> request, CancellationToken cancellationToken)
32	{
33	if (request is null)
34	throw new ArgumentNullException(nameof(request));
35
36	var cosmosQuery = await Repository
37	.GetQueryableAsync()
38	.ConfigureAwait(false);
39
40	// build query from filter
41	var query = BuildQuery(request, cosmosQuery);
42
43	// get total for query
44	int total = await QueryTotal(request, query, cancellationToken)
45	.ConfigureAwait(false);
46
47	// short circuit if total is zero
48	if (total == 0)
49	return new EntityPagedResult<TReadModel> { Data = new List<TReadModel>() };
50
51	// page the query and convert to read model
52	var result = await QueryPaged(request, query, cancellationToken)
53	.ConfigureAwait(false);
54
55	return new EntityPagedResult<TReadModel>
56	{
57	Total = total,
58	Data = result
59	};
60	}
61
62
63	protected virtual IQueryable<TEntity> BuildQuery(EntityPagedQuery<TReadModel> request, IQueryable<TEntity> query)
64	{
65	var entityQuery = request.Query;	×
66
67	// build query from filter
68	if (entityQuery?.Filter != null)	×
69	query = query.Filter(entityQuery.Filter);	×
70
71	// add raw query
72	if (!string.IsNullOrEmpty(entityQuery?.Query))	×
73	query = query.Where(entityQuery.Query);	×
74
75
76	return query;	×
77	}
78
79	protected virtual async Task<int> QueryTotal(EntityPagedQuery<TReadModel> request, IQueryable<TEntity> query, CancellationToken cancellationToken)
80	{
81	return await query
82	.CountAsync(cancellationToken)
83	.ConfigureAwait(false);
84	}
85
86	protected virtual async Task<IReadOnlyCollection<TReadModel>> QueryPaged(EntityPagedQuery<TReadModel> request, IQueryable<TEntity> query, CancellationToken cancellationToken)
87	{
88	var entityQuery = request.Query;
89
90	var queryable = query
91	.Sort(entityQuery.Sort);
92
93	if (entityQuery.Page > 0 && entityQuery.PageSize > 0)
94	queryable = queryable.Page(entityQuery.Page, entityQuery.PageSize);
95
96	var results = await queryable
97	.ToListAsync(cancellationToken)
98	.ConfigureAwait(false);
99
100	return Mapper.Map<IList<TEntity>, IReadOnlyCollection<TReadModel>>(results);
101	}
102	}

loresoft / MediatR.CommandQuery / 7697858967

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous