21874874321

Committed 10 Feb 2026 05:11PM UTC coverage: 95.344% (-0.4%) from 95.698%

Build # 21874874321

Build Type

push

github

Committed by

web-flow

Commit Message

v3.2.15 (#1973)

Coverage Stats

8336 of 9184 branches covered (90.77%)

Branch coverage included in aggregate %.

51 of 120 new or added lines in 5 files covered. (42.5%)

4 existing lines in 2 files now uncovered.

14908 of 15195 relevant lines covered (98.11%)

217.48 hits per line

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

61.36

/CourageScores/Services/Query/QueryService.cs

﻿using CourageScores.Common;
using CourageScores.Models.Dtos;
using CourageScores.Models.Dtos.Query;
using CourageScores.Services.Data;
using CourageScores.Services.Identity;
using Microsoft.Azure.Cosmos;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace CourageScores.Services.Query;

public class QueryService : IQueryService
{
    private readonly Database _database;
    private readonly IUserService _userService;
    private readonly ICosmosTableService _cosmosTableService;

    public QueryService(
        Database database,
        IUserService userService,
        ICosmosTableService cosmosTableService)
    {
        _database = database;
        _userService = userService;
        _cosmosTableService = cosmosTableService;
    }

    public async Task<ActionResultDto<QueryResponseDto>> ExecuteQuery(QueryRequestDto request, CancellationToken token)
    {
        var user = await _userService.GetUser(token);
        if (user == null)
        {
            return Warning("Not logged in");
        }

        if (user.Access?.RunDataQueries != true)
        {
            return Warning("Not permitted");
        }

        var tables = await _cosmosTableService.GetTables(token).WhereAsync(t => t.Name.Equals(request.Container, StringComparison.OrdinalIgnoreCase)).ToList();
        var table = tables.Count == 1 ? tables[0] : null;
        if (table == null)
        {
            return Warning("Table not found");
        }

        var options = new QueryRequestOptions();
        try
        {
            var rows = await _database
                .GetContainer(request.Container)
                .GetItemQueryIterator<JObject>(request.Query, requestOptions: options)
                .EnumerateResults(token)
                .ExcludeCosmosProperties()
                .ToList();
            request.Max ??= 10;

            return new ActionResultDto<QueryResponseDto>
            {
                Result = new QueryResponseDto
                {
                    Request = request,
                    Rows = rows.Take(request.Max.Value).ToList(),
                    RowCount = rows.Count,
                },
                Success = true,
            };
        }
        catch (CosmosException exc)
        {
            var errorResponse = GetErrorResponse(exc);
            if (errorResponse != null)
            {
                return new ActionResultDto<QueryResponseDto>
                {
                    Warnings = errorResponse.Errors.Select(e => e.Message).ToList(),
                };
            }

            return new ActionResultDto<QueryResponseDto>
            {
                Errors =
                {
                    exc.Message,
                }
            };
        }
    }

    private static ActionResultDto<QueryResponseDto> Warning(string message)
    {
        return new ActionResultDto<QueryResponseDto>
        {
            Warnings =
            {
                message
            },
        };
    }

    private static ErrorResponse? GetErrorResponse(CosmosException exc)
    {
        try
        {
            if (exc.InnerException != null)
            {
                var jsonInnerMessage = exc.InnerException.Message;
                return JsonConvert.DeserializeObject<ErrorResponse>(jsonInnerMessage);
            }

            var error = exc.GetError();
            var outerMessage = JObject.Parse(error["message"]!.Value<string>()!);
            var innerMessage = outerMessage["message"]!.Value<string>()!;
            return JsonConvert.DeserializeObject<ErrorResponse>(innerMessage.Substring(0, innerMessage.LastIndexOf("}") + 1));
        }
        catch (Exception)
        {
            return null;
        }
    }

    private class ErrorResponse
    {
        [JsonProperty("errors")]
        public required ErrorDetail[] Errors { get; set; }
    }

    private class ErrorDetail
    {
        [JsonProperty("severity")]
        public required string Severity { get; set; }
        [JsonProperty("location")]
        public required object Location { get; set; }
        [JsonProperty("code")]
        public required string Code { get; set; }
        [JsonProperty("message")]
        public required string Message { get; set; }
    }
}

1	using CourageScores.Common;
2	using CourageScores.Models.Dtos;
3	using CourageScores.Models.Dtos.Query;
4	using CourageScores.Services.Data;
5	using CourageScores.Services.Identity;
6	using Microsoft.Azure.Cosmos;
7	using Newtonsoft.Json;
8	using Newtonsoft.Json.Linq;
9
10	namespace CourageScores.Services.Query;
11
12	public class QueryService : IQueryService
13	{
14	private readonly Database _database;
15	private readonly IUserService _userService;
16	private readonly ICosmosTableService _cosmosTableService;
17
18	public QueryService(	6✔
19	Database database,	6✔
20	IUserService userService,	6✔
21	ICosmosTableService cosmosTableService)	6✔
22	{
23	_database = database;	6✔
24	_userService = userService;	6✔
25	_cosmosTableService = cosmosTableService;	6✔
26	}	6✔
27
28	public async Task<ActionResultDto<QueryResponseDto>> ExecuteQuery(QueryRequestDto request, CancellationToken token)
29	{
30	var user = await _userService.GetUser(token);	5✔
31	if (user == null)	5✔
32	{
33	return Warning("Not logged in");	1✔
34	}
35
36	if (user.Access?.RunDataQueries != true)	4!
37	{
38	return Warning("Not permitted");	1✔
39	}
40
41	var tables = await _cosmosTableService.GetTables(token).WhereAsync(t => t.Name.Equals(request.Container, StringComparison.OrdinalIgnoreCase)).ToList();	5✔
42	var table = tables.Count == 1 ? tables[0] : null;	3✔
43	if (table == null)	3✔
44	{
45	return Warning("Table not found");	1✔
46	}
47
48	var options = new QueryRequestOptions();	2✔
49	try
50	{
51	var rows = await _database	2✔
52	.GetContainer(request.Container)	2✔
53	.GetItemQueryIterator<JObject>(request.Query, requestOptions: options)	2✔
54	.EnumerateResults(token)	2✔
55	.ExcludeCosmosProperties()	2✔
56	.ToList();	2✔
57	request.Max ??= 10;	2✔
58
59	return new ActionResultDto<QueryResponseDto>	2✔
60	{	2✔
61	Result = new QueryResponseDto	2✔
62	{	2✔
63	Request = request,	2✔
64	Rows = rows.Take(request.Max.Value).ToList(),	2✔
65	RowCount = rows.Count,	2✔
66	},	2✔
67	Success = true,	2✔
68	};	2✔
69	}
NEW 70	catch (CosmosException exc)	×
71	{
NEW 72	var errorResponse = GetErrorResponse(exc);	×
NEW 73	if (errorResponse != null)	×
74	{
NEW 75	return new ActionResultDto<QueryResponseDto>	×
NEW 76	{	×
NEW 77	Warnings = errorResponse.Errors.Select(e => e.Message).ToList(),	×
NEW 78	};	×
79	}
80
NEW 81	return new ActionResultDto<QueryResponseDto>	×
UNCOV 82	{	×
NEW 83	Errors =	×
UNCOV 84	{	×
NEW 85	exc.Message,	×
UNCOV 86	}	×
NEW 87	};	×
88	}
89	}	5✔
90
91	private static ActionResultDto<QueryResponseDto> Warning(string message)
92	{
93	return new ActionResultDto<QueryResponseDto>	3✔
94	{	3✔
95	Warnings =	3✔
96	{	3✔
97	message	3✔
98	},	3✔
99	};	3✔
100	}
101
102	private static ErrorResponse? GetErrorResponse(CosmosException exc)
103	{
104	try
105	{
NEW 106	if (exc.InnerException != null)	×
107	{
NEW 108	var jsonInnerMessage = exc.InnerException.Message;	×
NEW 109	return JsonConvert.DeserializeObject<ErrorResponse>(jsonInnerMessage);	×
110	}
111
NEW 112	var error = exc.GetError();	×
NEW 113	var outerMessage = JObject.Parse(error["message"]!.Value<string>()!);	×
NEW 114	var innerMessage = outerMessage["message"]!.Value<string>()!;	×
NEW 115	return JsonConvert.DeserializeObject<ErrorResponse>(innerMessage.Substring(0, innerMessage.LastIndexOf("}") + 1));	×
116	}
NEW 117	catch (Exception)	×
118	{
NEW 119	return null;	×
120	}
NEW 121	}	×
122
123	private class ErrorResponse
124	{
125	[JsonProperty("errors")]
NEW 126	public required ErrorDetail[] Errors { get; set; }	×
127	}
128
129	private class ErrorDetail
130	{
131	[JsonProperty("severity")]
NEW 132	public required string Severity { get; set; }	×
133	[JsonProperty("location")]
NEW 134	public required object Location { get; set; }	×
135	[JsonProperty("code")]
NEW 136	public required string Code { get; set; }	×
137	[JsonProperty("message")]
NEW 138	public required string Message { get; set; }	×
139	}
140	}

laingsimon / courage_scores / 21874874321

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