// GET /Api/v1/LogBooks
public HttpResponseMessage Get(string q = "",
int skip = AppConstants.DefaultSkip,
int take = AppConstants.DefaultTake,
string fields = "")
{
if (take > AppConstants.MaxTake)
return BadRequest(string.Concat("Maximum take value is ", take));
var stats = new RavenQueryStatistics();
//
// TODO: Create an index that includes the user friends so we can verify it's visible to the current user without all the ToArray() calls.
// Also, Skip and Take will return the wrong number of results at the moment
//
var logBooks = base.RavenSession.Query<LogBook>()
.Statistics(out stats)
.Skip(skip)
.Take(take)
.ToArray()
.Where(x => x.IsVisibleTo(base.User.Identity.Name, (ownerId) => base.RavenSession.Load<User>(ownerId).GetFriends()))
.ToArray();
var fieldsArray = fields.Split(new[] { ' ', '+' })
.Where(x => string.IsNullOrWhiteSpace(x) == false);
var logBookViews = from lb in logBooks
select lb.MapTo<LogBookView>();
if (fieldsArray.Count() == 0)
return Ok(logBookViews);
var squashedLogBooks = logBookViews.Select(x => x.SquashTo(fieldsArray));
return Ok(squashedLogBooks);
}
public IRavenQueryable <T> Query <T>(string indexName, bool isMapReduce = false)
{
var ravenQueryStatistics = new RavenQueryStatistics();
var highlightings = new RavenQueryHighlightings();
return(new RavenQueryInspector <T>(
new RavenQueryProvider <T>(this, indexName, ravenQueryStatistics, highlightings,
#if !SILVERLIGHT
null,
#endif
AsyncDatabaseCommands, isMapReduce),
ravenQueryStatistics,
highlightings,
indexName,
null,
this,
#if !SILVERLIGHT
null,
#endif
AsyncDatabaseCommands,
isMapReduce));
}
PaginatedResult <User> Search(FindUsers request)
{
PaginatedResult <User> result = new PaginatedResult <User>()
{
Data = new List <User>()
};
RavenQueryStatistics statsRef = new RavenQueryStatistics();
var results = DocumentSession.Query <Users_Smart_Search.Result, Users_Smart_Search>()
.Statistics(out statsRef)
.Search(x => x.Content, $"{request.Qry}*", escapeQueryOptions: EscapeQueryOptions.AllowPostfixWildcard)
.Skip(request.CurrentPage * request.PageSize)
.Take(request.PageSize)
.ProjectFromIndexFieldsInto <Users_Smart_Search.Projection>();
result.Data = ConvertResultsToUsersViewModel(results.ToList());
result.TotalItems = statsRef.TotalResults;
result.TotalPages = result.TotalItems / request.PageSize;
if ((result.TotalItems % request.PageSize) > 0)
{
result.TotalPages += 1;
}
result.PageSize = request.PageSize;
result.CurrentPage = request.CurrentPage;
if (CurrentPageIsOverflown(result))
{
return(Search(new FindUsers()
{
Qry = request.Qry, CurrentPage = 0, PageSize = request.PageSize
}));
}
return(result);
}
// GET: Commander
public ActionResult Index(int?page)
{
page = page ?? 0;
var view = new CommanderIndexView();
using (var session = DB.Instance.GetSession())
{
RavenQueryStatistics stats = null;
view.Commanders = session.Query <Commander>()
.Statistics(out stats)
.OrderBy(x => x.Name)
.Skip(page.Value * 20)
.Take(20)
.ToList();
view.Pager = new Pager
{
Count = stats.TotalResults,
Page = page.Value,
PageSize = 20
};
return(View(view));
}
}
public SearchResult <MessageSearchResult> Search(SearchModel searchModel)
{
using (var session = store.OpenSessionForDefaultTenant())
{
RavenQueryStatistics stats = null;
var results = session.Advanced.DocumentQuery <MessageSearchResult, MessageDocument_Search>()
.Where(searchModel.RavenSearchString)
.OrderBy(searchModel.RavenSort)
.SelectFields <MessageSearchResult>()
.UsingDefaultField("Any").Skip(searchModel.Page * searchModel.Take).Take(searchModel.Take).Statistics(out stats).ShowTimings()
.ToList();
if (logger.IsDebugEnabled)
{
var timings = string.Join("\n\t",
stats.TimingsInMilliseconds.Select(x => string.Format("{0}:{1}ms", x.Key, x.Value)));
logger.Debug(
"Query for {0} order by {1} matched {2} documents. Took {3} from page (0-based) {4}. Timings: \n\t{5}",
!string.IsNullOrWhiteSpace(searchModel.RavenSearchString) ? searchModel.RavenSearchString : "ALL DOCS", searchModel.RavenSort, stats.TotalResults, searchModel.Take, searchModel.Page, timings);
}
return(new SearchResult <MessageSearchResult>(searchModel, results, stats));
}
}
public ActionResult Index(int?page)
{
page = page ?? 0;
var view = new TradeIndexView();
using (var session = DB.Instance.GetSession())
{
RavenQueryStatistics stats = null;
view.Routes = session.Query <TradeRoute>()
.Statistics(out stats)
.OrderByDescending(x => x.Name)
.Skip(page.Value * 15)
.Take(15)
.ToList();
view.Pager = new Pager
{
Count = stats.TotalResults,
Page = page.Value,
PageSize = 15
};
}
return(View(view));
}
public override async Task <Response> Handle(Request request)
{
//Used to get total results
var stats = new RavenQueryStatistics();
var sources = await Session.Query <Domain.Entities.Sources.Source>()
.Statistics(out stats)
.OrderByDescending(x => x.DateCreated)
.Skip((request.Page - 1) * request.PageSize)
.Take(request.PageSize).ToListAsync();
var response = new Response
{
Sources = sources.Select(x => new Response.Source
{
Id = x.Id,
Url = x.Url,
Name = x.Name,
CategoryId = x.CategoryId,
IsActive = x.IsActive,
}).ToList(),
Page = request.Page,
PageSize = request.PageSize,
TotalItemCount = stats.TotalResults
};
foreach (var source in response.Sources)
{
var category = await Session.LoadAsync <Domain.Entities.Categories.Category>(source.CategoryId);
source.CategoryName = category.Name;
source.CategoryIsActive = category.IsActive;
}
return(response);
}
public override async Task <Response> Handle(Request request)
{
//Used to get total results
var stats = new RavenQueryStatistics();
var categories = await Session.Query <Domain.Entities.Categories.Category>()
.Statistics(out stats)
.OrderByDescending(x => x.DateCreated)
.Skip((request.Page - 1) * request.PageSize)
.Take(request.PageSize).ToListAsync();
return(new Response
{
Categories = categories.Select(x => new Response.Category
{
Id = x.Id,
Name = x.Name,
IsActive = x.IsActive
}).ToList(),
Page = request.Page,
PageSize = request.PageSize,
TotalItemCount = stats.TotalResults
});
}
/// <summary>
/// Initializes a new instance of the <see cref="RavenQueryInspector{T}"/> class.
/// </summary>
public void Init(
IRavenQueryProvider provider,
RavenQueryStatistics queryStats,
RavenQueryHighlightings highlightings,
string indexName,
Expression expression,
InMemoryDocumentSessionOperations session
,
bool isMapReduce
)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
this.provider = provider.For <T>();
this.queryStats = queryStats;
this.highlightings = highlightings;
this.indexName = indexName;
this.session = session;
this.isMapReduce = isMapReduce;
this.provider.AfterQueryExecuted(this.AfterQueryExecuted);
this.expression = expression ?? Expression.Constant(this);
}
private static void Populate(IDocumentStore store)
{
new Simple_Index().Execute(store);
using (var session = store.OpenSession())
{
RavenQueryStatistics stats = null;
session.Query <Simple, Simple_Index>().Statistics(out stats).Take(0).ToArray();
if (stats.TotalResults > 0)
{
return;
}
}
using (var session = store.OpenSession())
{
for (int i = 0; i < 1000; i++)
{
session.Store(new Simple());
}
session.SaveChanges();
}
WaitForIndexing(store);
}
public static Negotiator WithEtag(this Negotiator negotiator, RavenQueryStatistics stats)
{
var etag = stats.IndexEtag;
return(WithEtag(negotiator, etag));
}
public static Negotiator WithPagingLinksAndTotalCount(this Negotiator negotiator, RavenQueryStatistics stats,
Request request)
{
return(negotiator.WithPagingLinksAndTotalCount(stats.TotalResults, request));
}
private Task <QueryResult> GetQueryResults(int start, int pageSize)
{
IndexQuery templateQuery;
string indexName;
lock (_lockObject)
{
templateQuery = TemplateQuery;
indexName = _indexName;
}
if (templateQuery == null || string.IsNullOrEmpty(indexName))
{
return(TaskEx.FromResult(new QueryResult()));
}
var query = templateQuery.Clone();
query.Start = start;
query.PageSize = pageSize;
var queryStartTime = SystemTime.UtcNow.Ticks;
var queryEndtime = DateTime.MinValue.Ticks;
return(ApplicationModel.DatabaseCommands
.QueryAsync(indexName,
query,
new string[] { }, MetadataOnly)
.ContinueWith(task =>
{
queryEndtime = SystemTime.UtcNow.Ticks;
var queryTime = new TimeSpan(queryEndtime - queryStartTime);
RavenQueryStatistics statistics;
if (!task.IsFaulted)
{
statistics = new RavenQueryStatistics
{
IndexEtag = task.Result.IndexEtag,
IndexName = task.Result.IndexName,
IndexTimestamp =
task.Result.IndexTimestamp,
IsStale = task.Result.IsStale,
SkippedResults =
task.Result.SkippedResults,
Timestamp = SystemTime.UtcNow,
TotalResults = task.Result.TotalResults
};
}
else
{
statistics = new RavenQueryStatistics()
{
Timestamp = SystemTime.UtcNow
};
}
OnQueryStatisticsUpdated(new QueryStatisticsUpdatedEventArgs()
{
QueryTime = queryTime,
Statistics = statistics
});
if (task.IsFaulted)
{
OnQueryError(new QueryErrorEventArgs()
{
Exception = task.Exception
});
}
return task.Result;
}, TaskContinuationOptions.ExecuteSynchronously));
}
public static QueryStatsInfo ToQueryStatsInfo(this RavenQueryStatistics stats)
{
return(new QueryStatsInfo(stats.IndexEtag, stats.TotalResults));
}
public static Negotiator WithTotalCount(this Negotiator negotiator, RavenQueryStatistics stats)
{
return(negotiator.WithHeader("Total-Count", stats.TotalResults.ToString(CultureInfo.InvariantCulture)));
}
// GET: HitList
public PartialViewResult Index(string SortOrder, string SortDirection, int?page, string pageSize,
string search, string Class)
{
if (!string.IsNullOrEmpty(search))
{
ViewBag.Filtered = "Y";
}
else
{
ViewBag.Filtered = "N";
}
//List<Project> projects;
var ravenDb = HttpContext.GetOwinContext().Get <IDocumentSession>();
RavenQueryStatistics statsRef = new RavenQueryStatistics();
if (page == null)
{
page = 1;
}
if (Request.Cookies["pageSize"] == null)
{
pageSize = GenericHelpers.IsNull(pageSize, "10");
HttpCookie pageSizeCookie = new HttpCookie("pageSize");
pageSizeCookie.Value = pageSize;
Response.Cookies.Add(pageSizeCookie);
}
else
{
pageSize = GenericHelpers.IsNull(pageSize, Request.Cookies["pageSize"].Value);
Response.Cookies["pageSize"].Value = pageSize;
}
foreach (var pSize in GenericHelpers.PageSizeList)
{
pSize.Selected = false;
if (pSize.Text == pageSize.ToString())
{
pSize.Selected = true;
}
}
int pageNumber = (page ?? 1);
int skippedResult = Convert.ToInt32(pageSize) * (pageNumber - 1);
object results;
switch (Class)
{
case "Project":
results = GetHitList.GetPage <Project, Project>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
case "Contact":
results = GetHitList.GetPage <Contact, Contact>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
case "User":
results = GetHitList.GetPage <ApplicationUser, ApplicationUser>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
case "Distributor":
results = GetHitList.GetPage <Distributor, Distributor>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
case "Detail":
results = GetHitList.GetPage <ProjectDetail, ProjectDetail>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
case "Warning":
results = GetHitList.GetPage <Warning, Warning>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
default:
results = GetHitList.GetPage <Project, Project>(ravenDb, skippedResult, Convert.ToInt32(pageSize),
"Id", SortOrder, SortDirection, search, out statsRef);
break;
}
ViewBag.TotalPage = Math.Round((double)(statsRef.TotalResults / Convert.ToInt32(pageSize))) + 1;
ViewBag.ActualPage = pageNumber;
ViewBag.TotalResult = statsRef.TotalResults;
ViewBag.SortOrder = SortOrder;
ViewBag.SortDirection = SortDirection;
ViewBag.PageSizeList = GenericHelpers.PageSizeList;
ViewBag.Search = search;
ViewData["controller"] = Class;
return(PartialView("Index", results));
}
void Follow()
{
using (var session = RavenFactory.OpenSession())
{
var l = session.Advanced.Lazily.Load <Leadership>(Leadership.Identifier);
var m = session.Advanced.Lazily.Load <Followership>(Followership.FormatId(ProcessIdentity));
session.Advanced.Eagerly.ExecuteAllPendingLazyOperations();
var leadership = l.Value ?? new Leadership();
var me = m.Value;
if (me == null)
{
me = new Followership(ProcessIdentity);
session.Store(me);
}
if (leadership.Status == Leadership.ClusterStatus.Turmoil ||
leadership.DeniedAssignment(ProcessIdentity))
{
while (_workQueue.Count > 0)
{
RavenTransportMessage trash;
_workQueue.TryTake(out trash); //clear the queue
}
Thread.Sleep(10); //make sure workers have enough time to get their work in the InProgress collection
RecentMessages.Clear(); //we're clearing the decks, so forget what we've seen and rely on db
}
if (RecentMessages.Count == 0)
{
me.LastSequenceNumber = 0;
}
if (leadership.Status == Leadership.ClusterStatus.Harmony &&
leadership.HasAssignment(ProcessIdentity))
{
var assignment = leadership.GetAssignment(ProcessIdentity);
var take = MaxMessagesToRead - _workQueue.Count;
RavenQueryStatistics stats = null;
var messages =
session.Query <RavenTransportMessage, RavenTransportMessageIndex>()
.Statistics(out stats)
.Where(x => x.Destination == _address.Queue)
.Where(x => x.ClaimTicket >= assignment.LowerBound && x.ClaimTicket <= assignment.UpperBound)
.Where(x => x.SequenceNumber >= me.LastSequenceNumber)
.OrderBy(x => x.SequenceNumber)
.Take(take)
.ToList();
Console.WriteLine("Follower Query Stats: {0:N0}", stats.DurationMilliseconds);
messages = messages.Where(x => !RecentMessages.Contains(x.Id)).ToList();
messages.ForEach(_workQueue.Add);
messages.Select(x => x.Id).ToList().ForEach(RecentMessages.Enqueue);
if (messages.Any())
{
me.LastSequenceNumber = messages.Last().SequenceNumber;
}
}
var progress = InProgress.Select(x => x.Value).Where(x => !string.IsNullOrWhiteSpace(x)).ToList();
me.MakeReportForLeader(leadership, progress);
session.SaveChanges();
}
}
public IRavenQueryable <T> Statistics(out RavenQueryStatistics stats)
{
stats = QueryStatistics;
return(this);
}
private bool CheckEtag(RavenQueryStatistics stats, out string responseETagHeader)
{
string requestETagHeader = Request.Headers["If-None-Match"] ?? string.Empty;
responseETagHeader = stats.Timestamp.ToString("o") + EtagInitValue;
return requestETagHeader == responseETagHeader;
}
protected abstract RavenQueryInspector <T> CreateRavenQueryInspector <T>(string indexName, bool isMapReduce,
RavenQueryProvider <T> provider,
RavenQueryStatistics
ravenQueryStatistics,
RavenQueryHighlightings highlightings);
public void SaveDynamicEntityWithStronglyTypedProperties()
{
RavenQueryStatistics stats = null;
using (var store = NewDocumentStore())
{
new BookSearch().Execute(store);
Book book = new Book()
{
Title = "Greatest Ever",
Publisher = "DC",
Contributors = new List <Contributor>()
{
new Contributor()
{
Name = "Jack Sparrow"
},
new Contributor()
{
Name = "Will Smith"
},
new Contributor()
{
Name = "Wayne Rooney"
}
},
Prices = new List <Price>()
{
new Price()
{
price = "10$"
},
new Price()
{
price = "8£"
}
},
Subjects = new List <Subject>()
{
new Subject()
{
Code = "1TGS"
},
new Subject()
{
Code = "8TRD"
}
}
};
using (var session = store.OpenSession())
{
session.Store(book);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
string[] searchTerms = { "Will", "Wayne", "Jack" };
var ravenQueryable = session.Query <Book, BookSearch>()
.Customize(x => x.WaitForNonStaleResults())
.Where(x => x.Keywords.In(searchTerms));
var bookinfo = ravenQueryable
.Statistics(out stats)
.ToArray();
}
}
Assert.Equal(1, stats.TotalResults);
}
public static Negotiator WithPagingLinks(this Negotiator negotiator, RavenQueryStatistics stats, Request request)
{
decimal 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;
}
// No need to add a Link header if no paging
if (stats.TotalResults <= maxResultsPerPage)
{
return(negotiator);
}
var links = new List <string>();
var lastPage = (int)Math.Ceiling(stats.TotalResults / maxResultsPerPage);
// No need to add a Link header if page does not exist!
if (page > lastPage)
{
return(negotiator);
}
var queryParts = HttpUtility.ParseQueryString(request.Url.Query);
var url = request.Url.Clone();
var query = new StringBuilder();
query.Append("?");
foreach (var key in queryParts.AllKeys.Where(key => key != "page"))
{
query.AppendFormat("{0}={1}&", key, queryParts[key]);
}
var queryParams = query.ToString();
if (page != 1)
{
AddLink(links, 1, "first", queryParams, url);
}
if (page > 1)
{
AddLink(links, page - 1, "prev", queryParams, url);
}
if (page != lastPage)
{
AddLink(links, lastPage, "last", queryParams, url);
}
if (page < lastPage)
{
AddLink(links, page + 1, "next", queryParams, url);
}
return(negotiator.WithHeader("Link", String.Join(", ", links)));
}
public FakeRavenQueryProvider(IQueryable source, RavenQueryStatistics stats = null)
{
this._source = source;
this._stats = stats;
}
private T[] PerformQuery <T, TIndex>(
IDocumentSession session, Expression <Func <T, bool> >[] conditions, int skip, int take, out RavenQueryStatistics stats)
where TIndex : AbstractIndexCreationTask, new()
{
try
{
using (TransactionScope scope = OpenQueryScope())
{
IQueryable <T> query = session.Query <T, TIndex>().Customize(x =>
{
if (_consistentQueries)
{
x.WaitForNonStaleResults();
}
}).Statistics(out stats);
query = conditions.Aggregate(query, (current, condition) => current.Where(condition));
var results = query
.Skip(skip).Take(take)
.ToArray();
scope.Complete();
return(results);
}
}
catch (WebException e)
{
Logger.Warn(Messages.StorageUnavailable);
throw new StorageUnavailableException(e.Message, e);
}
catch (ObjectDisposedException)
{
Logger.Warn(Messages.StorageAlreadyDisposed);
throw;
}
catch (Exception e)
{
Logger.Error(Messages.StorageThrewException, e.GetType());
throw new StorageException(e.Message, e);
}
}
public static HttpResponseMessage WithEtag(this HttpResponseMessage response, RavenQueryStatistics stats)
{
var etag = stats.IndexEtag;
return(response.WithEtag(etag));
}
public ActionResult Index(int?page, SolarSystemIndexView.Form form)
{
page = page ?? 0;
var view = new SolarSystemIndexView();
using (var session = DB.Instance.GetSession())
{
//Query
RavenQueryStatistics stats = null;
var query = session.Query <SolarSystem_Query.Result, SolarSystem_Query>()
.Statistics(out stats)
.OrderBy(x => x.Name)
.Skip(page.Value * 35)
.Take(35);
if (!String.IsNullOrEmpty(form.Query))
{
query = query.Where(x => x.NamePartial == form.Query);
}
if (form.Economy != 0)
{
var enumEconomy = (StationEconomy)Enum.Parse(typeof(StationEconomy), form.Economy.ToString());
query = query.Where(x => x.Economies.Any(e => e == enumEconomy));
}
if (form.Supply != 0)
{
var enumSupply = (CommodityType)Enum.Parse(typeof(CommodityType), form.Supply.ToString());
query = query.Where(x => x.Supply.Any(s => s == enumSupply));
}
if (form.Demand != 0)
{
var enumDemand = (CommodityType)Enum.Parse(typeof(CommodityType), form.Demand.ToString());
query = query.Where(x => x.Demand.Any(s => s == enumDemand));
}
if (form.PowerPlayLeader != 0)
{
var enumLeader = (PowerPlayLeader)Enum.Parse(typeof(PowerPlayLeader), form.PowerPlayLeader.ToString());
query = query.Where(x => x.PowerPlayLeader == enumLeader);
}
if (form.PowerPlayState != 0)
{
var enumState = (PowerPlayState)Enum.Parse(typeof(PowerPlayState), form.PowerPlayState.ToString());
query = query.Where(x => x.PowerPlayState == enumState);
}
if (form.Outfitting != 0)
{
var enumOutfitting = (StationOutfitting)Enum.Parse(typeof(StationOutfitting), form.Outfitting.ToString());
query = query.Where(x => x.Outfitting.Any(s => s == enumOutfitting));
}
if (form.FactionId != 0)
{
query = query.Where(x => x.Factions.Any(f => f == form.FactionId));
}
if (form.Group != 0)
{
query = query.Where(x => x.Groups.Any(g => g == form.Group));
}
else if (CommanderSystemGroups.Count > 0)
{
query = query.Where(x => x.Groups.In(CommanderSystemGroups));
}
switch (form.Status)
{
case 1:
query = query.Where(x => x.Attitude == FactionAttitude.Ally);
break;
case 2:
query = query.Where(x => x.Attitude == FactionAttitude.Hostile);
break;
case 3:
query = query.Where(x => x.Attitude != FactionAttitude.Hostile);
break;
case 4:
query = query.Where(x => x.Attitude == FactionAttitude.Hostile && x.HasAlly);
break;
}
//Set up view
view.SolarSystems = query.OfType <SolarSystem>().ToList();
view.Query = form;
view.Pager = new Pager
{
Count = stats.TotalResults,
Page = page.Value,
PageSize = 35
};
//Select list item
view.Statuses = new List <SelectListItem>
{
new SelectListItem {
Text = "All statuses", Value = "0", Selected = form.Status == 0
},
new SelectListItem {
Text = "Allied", Value = "1", Selected = form.Status == 1
},
new SelectListItem {
Text = "Hostile", Value = "2", Selected = form.Status == 2
},
new SelectListItem {
Text = "Not hostile", Value = "3", Selected = form.Status == 3
},
new SelectListItem {
Text = "Allied faction not in control", Value = "4", Selected = form.Status == 4
}
};
//Groups
var groups = session.Query <SolarSystemGroup>().OrderBy(x => x.Name).ToList();
if (CommanderSystemGroups.Count > 0)
{
groups.RemoveAll(x => !CommanderSystemGroups.Contains(x.Id));
}
groups.Insert(0, new SolarSystemGroup {
Id = 0, Name = "All"
});
view.Groups = new SelectList(groups, "Id", "Name", form.Group);
return(View(view));
}
}
public FakeRavenQueryable(IQueryable <T> source, RavenQueryStatistics stats = null)
{
this.source = source;
QueryStatistics = stats;
}
private IQueryable <T> QueryableRepository(out RavenQueryStatistics stats, bool withTracking = false)
{
using (var session = DocumentStore.OpenSession()) {
return(withTracking ? Queryable.Where(session.Query <T>().Statistics(out stats), p => p.Deleted == false).AsQueryable() : Queryable.Where(session.Query <T>().Statistics(out stats), p => p.Deleted == false).AsQueryable().AsNoTracking());
}
}
private bool CheckEtag(RavenQueryStatistics stats, out string responseETagHeader)
{
responseETagHeader = stats.Timestamp.ToString("o") + EtagInitValue;
var requestETagHeader = Request.Headers["If-None-Match"];
if (requestETagHeader == null) return false;
return (requestETagHeader.FirstOrDefault() ?? string.Empty) == responseETagHeader;
}
public void ShouldProperlyPageResults()
{
using (var store = NewDocumentStore())
{
new UsersAndFiendsIndex().Execute(store);
using (var bulk = store.BulkInsert())
{
for (int i = 0; i < 50; i++)
{
var user = new User()
{
Id = "users/" + i,
Name = "user/" + i,
Friends = new List <User>(1000)
};
var friendsCount = new Random().Next(700, 1000);
for (int j = 0; j < friendsCount; j++)
{
user.Friends.Add(new User()
{
Name = "friend/" + i + "/" + j
});
}
bulk.Store(user);
}
}
WaitForIndexing(store);
int skippedResults = 0;
var pagedResults = new List <User>();
var page = 0;
const int pageSize = 10;
using (var session = store.OpenSession())
{
for (int i = 0; i < 5; i++)
{
var stats = new RavenQueryStatistics();
var results = session
.Query <User, UsersAndFiendsIndex>()
.Statistics(out stats)
.Skip((page * pageSize) + skippedResults)
.Take(pageSize)
.Distinct()
.ToList();
skippedResults += stats.SkippedResults;
page++;
pagedResults.AddRange(results);
}
}
Assert.Equal(50, pagedResults.Select(x => x.Id).Distinct().Count());
}
}
/// <summary>
/// Provide statistics about the query, such as total count of matching records
/// </summary>
public IDocumentQuery <T> Statistics(out RavenQueryStatistics stats)
{
throw new NotImplementedException();
}
/// <summary>
/// Provide statistics about the query, such as total count of matching records
/// </summary>
IAsyncDocumentQuery <T> IDocumentQueryBase <T, IAsyncDocumentQuery <T> > .Statistics(out RavenQueryStatistics stats)
{
Statistics(out stats);
return(this);
}
public static Negotiator WithTotalCount(this Negotiator negotiator, RavenQueryStatistics stats)
{
return(negotiator.WithTotalCount(stats.TotalResults));
}
