public async Task <IActionResult> ListPgms([FromQuery] TagsQuery request)
{
try
{
var result = await _service.GetTags(request);
return(Ok(result));
}
catch (BusinessLogicException ex)
{
return(BadRequest(new Response
{
Status = false,
Message = ex.Message
}));
}
catch (Exception e)
{
return(BadRequest(new Response
{
Status = false,
Message = ErrorMessages.UnkownError
}));
}
}
public Task <List <Tag> > GetAsync(TagsQuery query,
CancellationToken cancel = default)
{
var dataQuery = GetDataQuery(query);
dataQuery = GetOrderedQuery(query, dataQuery);
return(dataQuery.ToListAsync(cancel));
}
private static void GetTags()
{
TagsQuery p = new TagsQuery {
Site = NetworkSiteEnum.StackOverflow
};
IBridgeResponseCollection <Tag> tags = client.GetTags(p);
Console.WriteLine(tags.First().Name);
}
/// <summary>
/// Check <see cref="IAssetService"/> for more information
/// </summary>
/// <returns>Check <see cref="IAssetService"/> for more information</returns>
public Task <IList <Tag> > GetTagsAsync(TagsQuery query)
{
var request = new ApiRequest <IList <Tag> >
{
Path = "/api/v4/tags/",
HTTPMethod = HttpMethod.Get,
Query = query
};
return(_requestSender.SendRequestAsync(request));
}
private IQueryable <Tag> GetOrderedQuery(TagsQuery query,
IQueryable <Tag> dataQuery)
{
var orderParameters = query.OrderParameters;
if (orderParameters.IsEmpty())
{
return(dataQuery);
}
return(dataQuery.ApplyOrder(orderParameters.Select(x => (new TagOrderMapping(x.orderField).Base, x.isAsc)).ToList()));
}
private IQueryable <Tag> GetDataQuery(TagsQuery query)
{
IQueryable <Tag> dataQuery = Entities;
if (query.IsPublished.HasValue)
{
dataQuery = dataQuery.Where(x => x.IsPublished == query.IsPublished.Value);
}
if (query.WithScores.HasValue)
{
dataQuery = query.WithScores.Value
? dataQuery.Where(x => x.Score > 0)
: dataQuery.Where(x => x.Score <= 0);
}
return(dataQuery);
}
public async Task <Response <TagsDto> > GetTags(TagsQuery request)
{
var result = _context.Tags.AsQueryable();
if (!string.IsNullOrEmpty(request.Title))
{
result = result.Where(x => x.Title.Contains(request.Title));
}
///pagenating
int take = request.PageSize;
int skip = (request.PageId - 1) * take;
int totalPages = (int)Math.Ceiling(result.Count() / (double)take);
var finalResult = result.OrderBy(x => x.Title).Skip(skip).Take(take).AsQueryable();
//----------------
var resultData = new TagsDto
{
Dtos = await finalResult.Select(d => new TagDto()
{
Id = d.Id,
Title = d.Title
}).ToListAsync(),
PageId = request.PageId,
PageSize = request.PageSize,
Total = await result.CountAsync()
};
return(new Response <TagsDto>
{
Data = resultData,
Status = true,
Message = "success"
});
}
public async Task <Page <Tag> > GetPageAsync(TagsQuery query,
CancellationToken cancel = default)
{
var dataQuery = GetDataQuery(query);
var totalCount = await dataQuery.CountAsync(cancel);
dataQuery = GetOrderedQuery(query, dataQuery);
var tags = await dataQuery.Skip(query.Offset)
.Take(query.Limit)
.ToListAsync(cancel);
return(new Page <Tag>
{
TotalCount = totalCount,
PageSize = query.Limit,
Items = tags
});
}
public Task <Page <Tag> > GetAsync(TagsQuery query,
CancellationToken cancel = default)
{
return(_tagRepository.GetPageAsync(query, cancel));
}
public override async Task <IEnumerable <TagSmallDto> > HandleAsync(TagsQuery query, CancellationToken token)
{
return(await ProjectTo <TagSmallDto>(Entities.OrderBy(p => p.Label)).ToArrayAsync(token));
}
private void SetTag(TagDto tag)
{
var query = new TagsQuery(tag.Id);
_tagsQueryHandler.CreateOrUpdateValueById<TagDto>(query, tag);
}
public List<TagDto> GetTags()
{
var tagsIds = GetIdTags().Values;
var query = new TagsQuery(tagsIds);
return _tagsQueryHandler.GetValuesByIds(query);
}
public TagDto GetTag(Guid id)
{
var query = new TagsQuery(id);
return _tagsQueryHandler.GetValueById(query);
}
private static void GetTags()
{
TagsQuery p = new TagsQuery { Site = NetworkSiteEnum.StackOverflow };
IBridgeResponseCollection<Tag> tags = client.GetTags(p);
Console.WriteLine(tags.First().Name);
}
