public HttpResponseMessage CreateSearch(CreateSearchDto dto)
{
if (dto.PageNumber == 0)
{
dto.PageNumber = 1;
}
if (dto.PageSize == 0)
{
dto.PageSize = 10;
}
RavenQueryStatistics stats;
IRavenQueryable <Task> tasks = this.RavenSession.Query <Task>().Statistics(out stats);
if (!string.IsNullOrWhiteSpace(dto.Category))
{
tasks = tasks.Where(t => t.Categories.Contains(dto.Category));
}
if (dto.Finished != null)
{
tasks = tasks.Where(t => t.IsFinished == dto.Finished);
}
tasks = tasks.Skip((dto.PageNumber - 1) * dto.PageSize).Take(dto.PageSize) as IRavenQueryable <Task>;
tasks = tasks.OrderBy(t => t.Description);
int count = stats.TotalResults; // TODO: do something with it
return(Request.CreateResponse <IEnumerable <Task> >(HttpStatusCode.OK, tasks.ToList()));
}
public Task <IList <Event> > GetAll(bool descending)
{
IRavenQueryable <Event> query = DbSession.Query <Event>();
if (descending)
{
query = query.OrderByDescending(e => e.Number);
}
else
{
query = query.OrderBy(e => e.Number);
}
return(query.ToListAsync());
}
static IQueryable <TUserAuth> SortAndPage(IRavenQueryable <TUserAuth> q, string orderBy, int?skip, int?take)
{
var qEnum = q.AsQueryable();
if (!string.IsNullOrEmpty(orderBy))
{
orderBy = AuthRepositoryUtils.ParseOrderBy(orderBy, out var desc);
qEnum = desc
? q.OrderByDescending(orderBy)
: q.OrderBy(orderBy);
}
if (skip != null)
{
qEnum = qEnum.Skip(skip.Value);
}
if (take != null)
{
qEnum = qEnum.Take(take.Value);
}
return(qEnum);
}
private static IRavenQueryable <T> OrderBy <T>(
this IRavenQueryable <T> query,
string sortBy,
string sortDirection = "asc")
{
if (string.IsNullOrWhiteSpace(sortBy))
{
return(query);
}
var param = Expression.Parameter(typeof(T), "item");
var sortExpression = Expression.Lambda <Func <T, object> >
(Expression.Convert(Expression.Property(param, sortBy), typeof(object)), param);
switch (sortDirection.ToLower())
{
case "asc":
return(query.OrderBy <T, object>(sortExpression));
default:
return(query.OrderByDescending <T, object>(sortExpression));
}
}
public static IRavenQueryable <TSource> Sort <TSource>(this IRavenQueryable <TSource> source, Request request,
Expression <Func <TSource, object> > defaultKeySelector = null, string defaultSortDirection = "desc")
where TSource : MessagesViewIndex.SortAndFilterOptions
{
var direction = defaultSortDirection;
if (request.Query.direction.HasValue)
{
direction = (string)request.Query.direction;
}
if (direction != "asc" && direction != "desc")
{
direction = defaultSortDirection;
}
var sortOptions = new[]
{
"processed_at", "id", "message_type",
"time_sent", "critical_time", "delivery_time", "processing_time",
"status", "message_id"
};
var sort = "time_sent";
Expression <Func <TSource, object> > keySelector;
if (request.Query.sort.HasValue)
{
sort = (string)request.Query.sort;
}
if (!sortOptions.Contains(sort))
{
sort = "time_sent";
}
switch (sort)
{
case "id":
case "message_id":
keySelector = m => m.MessageId;
break;
case "message_type":
keySelector = m => m.MessageType;
break;
case "critical_time":
keySelector = m => m.CriticalTime;
break;
case "delivery_time":
keySelector = m => m.DeliveryTime;
break;
case "processing_time":
keySelector = m => m.ProcessingTime;
break;
case "processed_at":
keySelector = m => m.ProcessedAt;
break;
case "status":
keySelector = m => m.Status;
break;
default:
if (defaultKeySelector == null)
{
keySelector = m => m.TimeSent;
}
else
{
keySelector = defaultKeySelector;
}
break;
}
if (direction == "asc")
{
return(source.OrderBy(keySelector));
}
return(source.OrderByDescending(keySelector));
}
private IRavenQueryable <CustomFieldIndexedForList> ApplySorting(IRavenQueryable <CustomFieldIndexedForList> query, CustomFieldListGetRequest dto)
{
if (dto.OrderBy == CustomFieldOrderColumns.Default)
{
dto.OrderBy = CustomFieldOrderColumns.Name;
dto.OrderDirection = OrderDirections.Asc;
}
return(dto.OrderBy switch
{
CustomFieldOrderColumns.Name
or CustomFieldOrderColumns.Default => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.Name) : query.OrderByDescending(t => t.Name),
CustomFieldOrderColumns.Type => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.FieldType) : query.OrderByDescending(t => t.FieldType),
_ => throw new ArgumentOutOfRangeException($"Unsupported 'order by' - {dto.OrderBy}")
});
private IRavenQueryable <UserIndexedForList> ApplySorting(IRavenQueryable <UserIndexedForList> query, UserListGetRequest dto)
{
if (dto.OrderBy == UsersOrderColumns.Default)
{
if (IsSearchResult)
{
return(query); // Use default order by relevance. Otherwise descending sort by number
}
dto.OrderBy = UsersOrderColumns.Name;
dto.OrderDirection = OrderDirections.Asc;
}
return(dto.OrderBy switch
{
UsersOrderColumns.Name => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.FullName) : query.OrderByDescending(t => t.FullName),
UsersOrderColumns.Email => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.Email) : query.OrderByDescending(t => t.Email),
UsersOrderColumns.RegistrationDate => dto.OrderDirection == OrderDirections.Asc ? query.OrderBy(t => t.RegistrationDate) : query.OrderByDescending(t => t.RegistrationDate),
_ => throw new NotImplementedException()
});
