public Task <PagingCollection <ScoringOfferDetails> > GetAsync(OffersQuery query, DateTimeOffset now)
{
var queryable = from scoringOffer in _readContext.ScoringOffers
join scoring in _readContext.Scorings on scoringOffer.ScoringId equals scoring.Id
join project in _readContext.Projects on scoring.ProjectId equals project.Id
join user in _readContext.Users on scoringOffer.ExpertId equals user.Id
join country in _readContext.Countries on project.CountryId equals country.Id
where !query.ExpertId.HasValue || user.Id == query.ExpertId.Value
where !query.ScoringId.HasValue || scoring.Id == query.ScoringId.Value
where !query.ProjectId.HasValue || project.Id == query.ProjectId.Value
where query.Statuses.Count == 0 ||
query.Statuses.Contains(ScoringOfferStatus.Expired) && (scoring.AcceptingDeadline < now && scoringOffer.Status == ScoringOfferStatus.Pending ||
scoring.ScoringDeadline < now && scoringOffer.Status == ScoringOfferStatus.Accepted) ||
query.Statuses.Contains(scoringOffer.Status) &&
!(scoring.AcceptingDeadline < now && scoringOffer.Status == ScoringOfferStatus.Pending) &&
!(scoring.ScoringDeadline < now && scoringOffer.Status == ScoringOfferStatus.Accepted)
select new ScoringOfferDetails(scoringOffer.Status,
scoring.AcceptingDeadline,
scoring.ScoringDeadline,
scoring.ContractAddress,
scoring.Id,
user.Id,
project.Name,
country.Code,
project.Category,
project.Description,
scoringOffer.AreaId,
project.ExternalId,
project.Id,
project.IsPrivate,
scoring.Score);
if (query.OrderBy.HasValue)
{
switch (query.OrderBy.Value)
{
case ScoringOffersOrderBy.Name:
queryable = query.SortDirection == SortDirection.Ascending
? queryable.OrderBy(o => o.Name)
: queryable.OrderByDescending(o => o.Name);
break;
case ScoringOffersOrderBy.Status:
queryable = query.SortDirection == SortDirection.Ascending
? queryable.OrderBy(o => o.Status)
: queryable.OrderByDescending(o => o.Status);
break;
case ScoringOffersOrderBy.Deadline:
queryable = query.SortDirection == SortDirection.Ascending
? queryable.OrderBy(o => o.AcceptingDeadline)
: queryable.OrderByDescending(o => o.AcceptingDeadline);
break;
}
}
return(queryable.GetPageAsync(query.Offset, query.Count));
}
public async Task <IActionResult> QueryAsync([FromQuery] QueryScoringOffersRequest request)
{
var isAdmin = User.IsInRole(nameof(RoleType.Admin));
if (request.ExpertId.HasValue && request.ExpertId.Value != User.GetUserId() && !isAdmin || !request.ExpertId.HasValue && !isAdmin)
{
return(Unauthorized());
}
var query = new OffersQuery(request.Offset, request.Count, request.Statuses, request.ExpertId,
request.ScoringId, request.ProjectId, request.OrderBy, request.SortDirection);
var now = _clock.UtcNow;
var offers = await _scoringService.QueryOffersAsync(query, now);
return(Ok(offers.ToPartialCollectionResponse(o => ScoringOfferResponse.Create(o, now))));
}
public async Task <bool> IsAuthorizedToSeeProjectAsync(long projectId, long?userId)
{
var project = await GetByIdAsync(projectId);
if (!project.IsPrivate)
{
return(true);
}
if (!userId.HasValue)
{
return(false);
}
if (project.AuthorId == userId.Value)
{
return(true);
}
var user = await _userRepository.GetByIdAsync(userId.Value);
var isAdmin = await _userRepository.HasRoleAsync(user.Address, RoleType.Admin);
if (isAdmin)
{
return(true);
}
if (project.Scoring == null)
{
return(false);
}
var offersQuery = new OffersQuery(0, 1, expertId: userId, scoringId: project.Scoring.Id);
var offers = await _scoringOffersRepository.GetAsync(offersQuery, _clock.UtcNow);
return(offers.Any());
}
public Task <PagingCollection <ScoringOfferDetails> > QueryOffersAsync(OffersQuery query, DateTimeOffset now) => _scoringOffersRepository.GetAsync(query, now);
