public static IRavenQueryable <TSource> Paging <TSource>(this IRavenQueryable <TSource> source, Request request)
{
var maxResultsPerPage = 50;
if (request.Query.per_page.HasValue)
{
maxResultsPerPage = request.Query.per_page;
}
if (maxResultsPerPage < 1)
{
maxResultsPerPage = 50;
}
var page = 1;
if (request.Query.page.HasValue)
{
page = request.Query.page;
}
if (page < 1)
{
page = 1;
}
var skipResults = (page - 1) * maxResultsPerPage;
return((IRavenQueryable <TSource>)source.Skip(skipResults)
.Take(maxResultsPerPage));
}
public static IList <T> GetAllItemsAsList <T>(this IRavenQueryable <T> query, int pageSize)
{
RavenQueryStatistics stats;
var items = query.Statistics(out stats)
.Skip(0)
.Take(pageSize)
.As <T>()
.ToList();
if (stats.TotalResults > pageSize)
{
int pageNumber = stats.TotalResults / pageSize;
for (int i = 1; i < pageNumber; i++)
{
items.AddRange(query
.Skip(i * pageSize)
.Take(pageSize)
.As <T>());
}
}
return(items.ToList());
}
public static IEnumerable <T> GetPage <T>(this IRavenQueryable <T> queryable, int page)
{
return(queryable
.Skip((page - 1) * PAGE_SIZE)
.Take(PAGE_SIZE)
.ToArray());
}
private static Task <List <T> > PagedList <T>(
this IRavenQueryable <T> query, int page, int pageSize
) =>
query
.Skip(page * pageSize)
.Take(pageSize)
.ToListAsync();
public static async Task <PagedResult <T> > GetPagedWithODataOptions <T>(this IRavenQueryable <T> query
, ODataQueryOptions <T> options
, ODataValidationSettings validations = null
, int defaultPageSize = 100
, CancellationToken ctk = default)
where T : class
{
query.Statistics(out QueryStatistics stats);
var settings = new ODataQuerySettings
{
HandleNullPropagation = HandleNullPropagationOption.False
};
//Validations
options.Validate(validations ?? new RavenDefaultODataValidationSettings());
//Query
query = (options.Filter?.ApplyTo(query, settings) ?? query) as IRavenQueryable <T>;
query = (options.OrderBy?.ApplyTo(query, settings) ?? query) as IRavenQueryable <T>;
query = query.Skip(options.Skip?.Value ?? 0).Take(options.Top?.Value ?? defaultPageSize);
var data = await query.ToListAsync();
return(new PagedResult <T>
{
Count = stats.TotalResults,
Data = data,
IsCountPartial = false,
Limit = options.Top?.Value ?? defaultPageSize,
Skip = options.Skip?.Value ?? 0
});
}
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()));
}
private static List <ReleaseCandidate> GetPagedResult(int page, int pageSize, IRavenQueryable <ReleaseCandidate> query)
{
return(query
.Skip((page - 1) * pageSize)
.Take(pageSize)
.ToList());
}
private static void DoReplayEvents(IWindsorContainer container, IDocumentStore documentStore)
{
// wait for indexing to complete
WaitForIndexing(documentStore);
// delete all read models
documentStore.DatabaseCommands.DeleteByIndex("ReadModelIndex", new IndexQuery());
// load all event streams and dispatch events
var dispatcher = new EventDispatcher(container);
int current = 0;
while (true)
{
IDocumentSession session = null;
try
{
session = (IDocumentSession)container.Resolve(typeof(IDocumentSession));
IRavenQueryable <EventsIndex.Result> eventsQuery =
session.Query <EventsIndex.Result, EventsIndex>()
.Customize(
x => x.WaitForNonStaleResultsAsOf(DateTime.Now.AddSeconds(15)))
.OrderBy(x => x.ChangeSequence);
var results = eventsQuery.Skip(current).Take(128).ToList();
if (results.Count == 0)
{
break;
}
foreach (EventsIndex.Result result in results)
{
int changeSequence = result.ChangeSequence;
IEnumerable <string> ids = result.Id.Select(x => x.Id);
EventStream[] streams = session.Load <EventStream>(ids);
var events = from stream in streams
from @event in stream.History
where @event.ChangeSequence == changeSequence
orderby @event.TimeStamp
select new { stream.Id, Event = @event };
foreach (var item in events)
{
dispatcher.Dispatch(item.Event, item.Id);
}
}
session.SaveChanges();
current += results.Count;
}
finally
{
if (session != null)
{
container.Release(session);
}
}
}
}
public static IRavenQueryable <TSource> Paging <TSource>(this IRavenQueryable <TSource> source, HttpRequestMessage request)
{
var maxResultsPerPage = request.GetQueryStringValue("per_page", 50);
if (maxResultsPerPage < 1)
{
maxResultsPerPage = 50;
}
var page = request.GetQueryStringValue("page", 1);
if (page < 1)
{
page = 1;
}
var skipResults = (page - 1) * maxResultsPerPage;
return(source.Skip(skipResults)
.Take(maxResultsPerPage));
}
public ActionResult Index(string term = null, int page = 1, int size = 20)
{
RavenQueryStatistics stats;
IRavenQueryable <Contato_Search.ContatoSearch> query = null;
if (!string.IsNullOrEmpty(term))
{
query = DocumentSession.Query <Contato_Search.ContatoSearch, Contato_Search>()
.Statistics(out stats)
.Search(c => c.Query, string.Format("*{0}*", term), escapeQueryOptions: EscapeQueryOptions.AllowAllWildcards);
}
else
{
query = DocumentSession.Query <Contato_Search.ContatoSearch, Contato_Search>()
.Statistics(out stats);
}
var contatos = query
.Skip((page - 1) * size)
.Take(size)
.OrderBy(c => c.Nome)
.As <Contato>()
.ToList();
ViewBag.Term = term ?? string.Empty;
var result = new PagedResultViewModel <ContatoViewModel>
{
Page = page,
Size = size,
Result = Mapper.Map <IEnumerable <Contato>, IEnumerable <ContatoViewModel> >(contatos),
Count = stats.TotalResults
};
return(RespondTo(normal: () => View("Index", result),
ajax: () => PartialView("_Contatos", result)));
}
protected override List <T> PerformQuery(int queryStartPosition)
{
return(_input.Skip(queryStartPosition).ToList());
}
private static List<ReleaseCandidate> GetPagedResult(int page, int pageSize, IRavenQueryable<ReleaseCandidate> query)
{
return query
.Skip((page - 1)*pageSize)
.Take(pageSize)
.ToList();
}
public static IRavenQueryable <T> Paginate <T>(this IRavenQueryable <T> queryable, int page, int pageSize)
{
return(queryable
.Skip((page - 1) * pageSize)
.Take(pageSize));
}
/// <summary>
/// Migrates all store events. This will simply pass all events from all aggregates
/// into the specified migrators. There is a chance of events coming in the wrong
/// order, so don't rely on them coming in the order they were raised. They will,
/// however, come in the correct order for each individual aggregate.
/// </summary>
/// <param name="eventMigrators">Event migrators.</param>
/// <exception cref="ArgumentNullException"></exception>
public void MigrateEvents(IEnumerable <IEventMigrator> eventMigrators)
{
if (!initialized)
{
throw new InvalidOperationException("The event store must be initialized before first usage.");
}
if (eventMigrators == null)
{
throw new ArgumentNullException(nameof(eventMigrators));
}
// order by defined date
eventMigrators = eventMigrators.OrderBy(x => x.DefinedOn()).ToList();
int current = 0;
while (true)
{
var session = (IDocumentSession)container.Resolve(typeof(IDocumentSession));
try
{
// allow indexing to take its time
IRavenQueryable <EventStream> q =
session.Query <EventStream>()
.Customize(x => x.WaitForNonStaleResultsAsOf(DateTime.Now.AddSeconds(15)));
var eventStreams = q.Skip(current).Take(128).ToList();
if (eventStreams.Count == 0)
{
break;
}
foreach (EventStream eventStream in eventStreams)
{
var newHistory = new List <IDomainEvent>();
foreach (IDomainEvent domainEvent in eventStream.History)
{
var oldEvents = new List <IDomainEvent> {
domainEvent
};
foreach (IEventMigrator eventMigrator in eventMigrators)
{
var newEvents = new List <IDomainEvent>();
foreach (IDomainEvent migratedEvent in oldEvents)
{
newEvents.AddRange(eventMigrator.Migrate(migratedEvent, eventStream.Id));
}
oldEvents = newEvents;
}
newHistory.AddRange(oldEvents);
}
eventStream.History = newHistory;
}
session.SaveChanges();
current += eventStreams.Count;
}
finally
{
container.Release(session);
}
}
}
