public async Task <ListResponse <Project> > Handle
(DbGetProjectFilterRequest request,
CancellationToken cancellationToken)
{
try
{
Logger.LogInformation(LogEvent.DatabaseRequest,
"Request={Request}.", request.ToDictionary());
var validation = new DbGetProjectFilterRequestValidator()
.Validate(request);
if (!validation.IsValid)
{
Logger.LogWarning
(LogEvent.DatabaseRequestArgumentError,
"Database request validation" +
" error. Error={Error}.", validation.Errors);
return(ErrorResult("Database request validation error"));
}
var db = DbContext.Db;
var query = BuildQuery(request);
var totalCount = await query.CountAsync()
.ConfigureAwait(false);
if (totalCount == 0)
{
return(new ListResponse <Project>(new List <Project>(),
totalCount));
}
query = ApplyPagination(query, request);
var dbEntityList = await query
.ToListAsync()
.ConfigureAwait(false);
if (dbEntityList is null)
{
Logger.LogWarning
(LogEvent.DatabaseEmptyResponse,
"Database Project null response.");
return(ErrorResult("Database Project null response."));
}
var result = new ListResponse <Project>
{
Success = true,
TotalCount = totalCount
};
result.Entities.AddRange(dbEntityList);
return(result);
}
catch (Exception e)
{
Logger.LogWarning(LogEvent.DatabaseExceptionError, e,
"Database exception error. Error={Error}.", e.Message);
return(ErrorResult("Database exception error"));
}
}
private IMongoQueryable <Project> ApplyPagination(
IMongoQueryable <Project> query, DbGetProjectFilterRequest request)
{
if (request.Offset > 0)
{
query = query.Skip(request.Offset);
}
if (request.Limit > 0)
{
query = query.Take(request.Limit);
}
return(query);
}
public static Dictionary <string, object> ToDictionary
(this DbGetProjectFilterRequest from)
{
if (from is null)
{
return(null);
}
return(new Dictionary <string, object>
{
{ nameof(from.Archived), from.Archived },
{ nameof(from.Contains), from.Contains },
{ nameof(from.Limit), from.Limit },
{ nameof(from.Offset), from.Offset },
});
}
private IMongoQueryable <Project> BuildQuery
(
DbGetProjectFilterRequest request
)
{
var query = DbContext.Db.GetCollection <Project>
(Defaults.ProjectCollectionName)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request.Contains))
{
query = query.WhereText(request.Contains);
}
if (request.Archived.HasValue)
{
query = query.Where(x => x.IsArchived == request.Archived);
}
return(query);
}
public async Task <ListResponse <_TEntity> > Handle(_TListQuery request,
CancellationToken cancellationToken)
{
Logger.LogInformation(AppLogEvent.HandleRequest,
"Handle Get Project List {Request}", request.ToDictionary());
if (request is null)
{
Logger.LogWarning(AppLogEvent.HandleArgumentError,
"Handle Get Project List request with empty request");
return(ErrorResponse("Request empty argument"));
}
try
{
// Validate request
var validator = new ListQueryValidator <_TListQuery>();
var validationResult = await validator.ValidateAsync(request)
.ConfigureAwait(false);
if (!validationResult.IsValid)
{
Logger.LogError("Query validation error. " +
"Request={Request}. Error={Error}.",
request.ToDictionary(),
validationResult.Errors.Select(x => x.ErrorMessage));
return(ErrorResponse
(validationResult.Errors.Select(x => x.ErrorMessage)));
}
// Build filter
var defaultLimit = Configuration.GetValue
(Defaults.ConfigurationApiDefaultLimitParameterName,
Defaults.ConfigurationApiDefaultLimitDefaultValue);
var maxLimit = Configuration.GetValue
(Defaults.ConfigurationApiMaxLimitParameterName,
Defaults.ConfigurationApiMaxLimitDefaultValue);
var dbRequest = new DbGetProjectFilterRequest
{
Offset = request.Offset,
Limit = request.Limit == 0
? defaultLimit
: Math.Min(request.Limit, maxLimit),
Archived = request.Archived,
Contains = request.СontainsKeyWords
};
// Get Actor for current user by user name
var currentActorResponse = await Mediator
.Send(new DbGetActorByNameRequest
(request.CurrentPrincipal?.Identity?.Name))
.ConfigureAwait(false);
Actor currentActor = null;
if (currentActorResponse.Success)
{
currentActor = currentActorResponse.Entity;
}
else
{
Logger.LogWarning(AppLogEvent.HandleArgumentError,
"Not found current actor");
return(ErrorResponse("Not found current actor"));
}
// Apply security filter
var securizator = new DbGetProjectFilterRequestSecurityBuilder
(dbRequest, currentActor);
DbGetProjectFilterRequest securedFilter = securizator.Build();
return(await Mediator
.Send(securedFilter)
.ConfigureAwait(false));
}
catch (Exception e)
{
Logger.LogError(AppLogEvent.HandleErrorResponse, e,
"Call repository exception");
return(ErrorResponse("Not found"));
}
}
