public async Task <IActionResult> Browse()
{
var query = new BrowseRemarks();
var remarks = await _remarkService.BrowseAsync(query);
var categories = await _categorySevice.GetAsync();
var result = remarks
.Select(x => new RemarkDto
{
Id = x.Id,
Name = x.Name,
Description = x.Description,
Latitude = x.Latitude,
Longitude = x.Longitude,
Author = x.AuthorId,
CategoryId = x.CategoryId,
CategoryName = categories.FirstOrDefault(y => y.Id == x.CategoryId)?.Name,
Status = x.Status.ToString()
})
.ToList();
return(Ok(result));
}
private static IFindFluent <Remark, Remark> SortRemarks(BrowseRemarks query,
IFindFluent <Remark, Remark> findResult)
{
if (query.OrderBy.Empty() && !query.Latest)
{
return(findResult);
}
if (query.SortOrder.Empty())
{
query.SortOrder = "ascending";
}
if (query.Latest)
{
query.OrderBy = "createdat";
query.SortOrder = "descending";
}
query.OrderBy = query.OrderBy.ToLowerInvariant();
query.SortOrder = query.SortOrder.ToLowerInvariant();
switch (query.OrderBy)
{
case "userid": return(SortRemarks(query, findResult, x => x.Author.UserId));
case "createdat": return(SortRemarks(query, findResult, x => x.CreatedAt));
}
return(findResult);
}
public async Task <IActionResult> Get()
{
var query = new BrowseRemarks();
var result = await _remarkRepository.BrowseAsync(query);
return(Ok(result));
}
private async Task <IEnumerable <Remark> > GetRemarksWithoutLocationAsync(BrowseRemarks query)
{
var keys = Enumerable.Empty <string>();
if (query.AuthorId.NotEmpty())
{
keys = await _cache.GetSetAsync($"users:{query.AuthorId}:remarks");
}
else if (query.ResolverId.NotEmpty())
{
keys = await _cache.GetSetAsync($"users:{query.ResolverId}:remarks");
}
else
{
keys = await _cache.GetSortedSetAsync("remarks-latest");
}
if (keys == null || !keys.Any())
{
return(Enumerable.Empty <Remark>());
}
var remarks = await _cache.GetManyAsync <Remark>(keys
.Select(x => $"remarks:{x}")
.ToArray());
remarks = remarks?.Where(x => x != null) ?? Enumerable.Empty <Remark>();
return(remarks);
}
private static IFindFluent <Remark, Remark> SortRemarks(BrowseRemarks query,
IFindFluent <Remark, Remark> findResult, Expression <Func <Remark, object> > sortBy)
{
switch (query.SortOrder)
{
case "ascending": return(findResult.SortBy(sortBy));
case "descending": return(findResult.SortByDescending(sortBy));
}
return(findResult);
}
public async Task <IActionResult> Browse()
{
var query = new BrowseRemarks
{
Latitude = 19,
Longitude = 19,
Radius = 10000
};
var result = await _storageService
.BrowseRemarksAsync(query)
.OrFailAsync();
return(Ok(result));
}
public async Task <Maybe <PagedResult <Remark> > > BrowseAsync(BrowseRemarks query)
{
var results = await _database.Remarks()
.QueryAsync(query);
if (!query.IsLocationProvided())
{
return(results);
}
var center = new Coordinates(query.Latitude, query.Longitude);
foreach (var remark in results.Items)
{
var coordinates = new Coordinates(remark.Location.Latitude, remark.Location.Longitude);
remark.Distance = center.DistanceTo(coordinates, UnitOfLength.Meters);
}
return(results);
}
public async Task <Maybe <PagedResult <Remark> > > BrowseAsync(BrowseRemarks query)
{
if (!_useCache)
{
return(await _storageClient.GetFilteredCollectionAsync <Remark, BrowseRemarks>(query, "remarks"));
}
var keys = await _cache.GetSortedSetAsync("remarks-latest");
if (keys == null || !keys.Any())
{
return(await _storageClient.GetFilteredCollectionAsync <Remark, BrowseRemarks>(query, "remarks"));
}
if (!query.IsLocationProvided() || query.SkipLocation)
{
return(_browseRemarksFilter.Filter(await GetRemarksWithoutLocationAsync(query), query));
}
return(_browseRemarksFilter.Filter(await GetRemarksByLocationAsync(query), query));
}
public static async Task <PagedResult <Remark> > QueryAsync(this IMongoCollection <Remark> remarks,
BrowseRemarks query)
{
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.Results <= 0)
{
query.Results = 10;
}
var filter = FilterDefinition <Remark> .Empty;
var totalCount = await remarks.CountAsync(filter);
var totalPages = (int)totalCount / query.Results + 1;
var result = await remarks.Find(filter)
.Skip(query.Results * (query.Page - 1))
.Limit(query.Results)
.ToListAsync();
return(PagedResult <Remark> .Create(result, query.Page, query.Results, totalPages, totalCount));
}
public static async Task <IEnumerable <RemarkDto> > QueryAsync(this IMongoCollection <RemarkDto> remarks,
BrowseRemarks query)
{
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.Results <= 0)
{
query.Results = 100;
}
var filterBuilder = new FilterDefinitionBuilder <RemarkDto>();
var filter = FilterDefinition <RemarkDto> .Empty;
var filteredRemarks = remarks.Find(filter);
var findResults = filteredRemarks
.Skip(query.Results * (query.Page - 1))
.Limit(query.Results);
var result = await findResults.ToListAsync();
return(result);
}
public async Task <Maybe <PagedResult <Remark> > > BrowseAsync(BrowseRemarks query) => await _remarkRepository.BrowseAsync(query);
public async Task <Response <IEnumerable <RemarkDto> > > BrowseRemarksAsync(BrowseRemarks query)
=> await GetAsync <IEnumerable <RemarkDto> >("api/remarks");
public static async Task <PagedResult <Remark> > QueryAsync(this IMongoCollection <Remark> remarks,
BrowseRemarks query)
{
if (!query.IsLocationProvided() && query.AuthorId.Empty() && query.ResolverId.Empty())
{
query.Latest = true;
}
if (query.Page <= 0)
{
query.Page = 1;
}
if (query.Results <= 0)
{
query.Results = 10;
}
if (query.Results > 1000)
{
query.Results = 1000;
}
var filterBuilder = new FilterDefinitionBuilder <Remark>();
var filter = FilterDefinition <Remark> .Empty;
if (query.IsLocationProvided() && !query.SkipLocation)
{
var maxDistance = query.Radius > 0 ? (double?)query.Radius / 1000 / 6378.1 : null;
filter = filterBuilder.NearSphere(x => x.Location,
query.Longitude, query.Latitude, maxDistance);
}
if (query.AuthorId.NotEmpty())
{
filter = filter & filterBuilder.Where(x => x.Author.UserId == query.AuthorId);
if (query.OnlyLiked)
{
filter = filter & filterBuilder.Where(x => x.Votes.Any(v => v.UserId == query.AuthorId && v.Positive));
}
else if (query.OnlyDisliked)
{
filter = filter & filterBuilder.Where(x => x.Votes.Any(v => v.UserId == query.AuthorId && !v.Positive));
}
}
if (query.ResolverId.NotEmpty())
{
filter = filter & filterBuilder.Where(x => x.State.State == "resolved" &&
x.State.User.UserId == query.ResolverId);
}
if (!query.Description.Empty())
{
filter = filter & filterBuilder.Where(x => x.Description.Contains(query.Description));
}
if (query.Categories?.Any() == true)
{
filter = filter & filterBuilder.Where(x => query.Categories.Contains(x.Category.Name));
}
if (query.Tags?.Any() == true)
{
filter = filter & filterBuilder.Where(x => x.Tags.Any(y => query.Tags.Contains(y)));
}
if (query.States?.Any() == true)
{
filter = filter & filterBuilder.Where(x => query.States.Contains(x.State.State));
}
if (!query.Disliked)
{
filter = filter & filterBuilder.Where(x => x.Rating > NegativeVotesThreshold);
}
if (query.GroupId.HasValue && query.GroupId != Guid.Empty)
{
filter = filter & filterBuilder.Where(x => x.Group.Id == query.GroupId);
}
if (query.UserFavorites.NotEmpty())
{
filter = filterBuilder.Where(x => x.UserFavorites.Contains(query.UserFavorites));
}
var totalCount = await remarks.CountAsync(_ => true);
var filteredRemarks = remarks.Find(filter);
var totalPages = (int)totalCount / query.Results + 1;
var findResult = filteredRemarks
.Skip(query.Results * (query.Page - 1))
.Limit(query.Results);
findResult = SortRemarks(query, findResult);
var result = await findResult.ToListAsync();
return(PagedResult <Remark> .Create(result, query.Page, query.Results, totalPages, totalCount));
}
public static bool IsLocationProvided(this BrowseRemarks query)
=> (Math.Abs(query.Latitude) <= 0.0000000001 ||
Math.Abs(query.Longitude) <= 0.0000000001) == false;
public async Task <IEnumerable <Remark> > BrowseAsync(BrowseRemarks query)
{
return(await _context.Remarks.ToListAsync());
}
public async Task <IEnumerable <RemarkDto> > BrowseAsync(BrowseRemarks query)
{
return(await _database.Remarks().QueryAsync(query));
}
public async Task <Maybe <PagedResult <Remark> > > BrowseAsync(BrowseRemarks query) => await _provider.GetCollectionAsync(async() => await _remarkRepository.BrowseAsync(query));
public async Task <Maybe <PagedResult <Remark> > > BrowseAsync(BrowseRemarks query) => await _database.Remarks().QueryAsync(query);
