public void EndInitTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
target.EndInit();
}
public void Then_the_items_queryable_implements_async_enumerable()
{
var sorting = new SortingHeader("Value", SortOrder.Ascending);
var paginationInfo = new PaginationInfo(0, 0, false);
var pagedQueryable = new PagedQueryable <QueryItem>(new QueryAbleWithoutAsync <QueryItem>(), paginationInfo, sorting);
pagedQueryable.Items.Should().BeAssignableTo <IAsyncEnumerable <QueryItem> >();
}
public void RefreshTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
target.Reset();
Assert.AreEqual(1, target.CurrentPage);
}
public void MoveLastTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
target.MoveLast();
Assert.AreEqual(target.PageCount, target.CurrentPage);
}
public void ZeroCountQueryTest()
{
IOrderedQueryable <GenericParameterHelper> query = new List <GenericParameterHelper>().AsQueryable().OrderBy(i => i.Data);
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
target.Reset();
Assert.AreEqual(0, target.Items.Count);
}
public void PagedQueryableConstructorTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
Expression <Func <GenericParameterHelper, bool> > condition = GetFilter();
int pageSize = 12;
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, condition, pageSize, autoLoad);
Assert.AreEqual(12, target.PageSize);
Assert.AreEqual(1, target.CurrentPage);
Assert.AreEqual(12, target.Items.Count);
}
public void SortColumnTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
target.BeginInit();
target.SortColumn = "Data";
target.EndInit();
Assert.AreEqual(1, target.CurrentPage);
}
public void MoveNextTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
int second = Math.Min(2, target.PageCount);
target.MoveNext();
Assert.AreEqual(second, target.CurrentPage);
}
public void PagedQueryableConstructorTest2()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
var target = new PagedQueryable <GenericParameterHelper>(query, autoLoad);
int expectedItemsCount = Math.Min(20, GetQuery().Count());
Assert.AreEqual(20, target.PageSize);
Assert.AreEqual(1, target.CurrentPage);
Assert.AreEqual(expectedItemsCount, target.Items.Count);
}
protected override void OnActivated()
{
_salesListSource = new List <DataDto>();
#region fill query source (could be from database...)
int i;
for (i = 0; i < _rnd.Next(1, 10000); i++)
{
_salesListSource.Add(new DataDto
{
CreatedAt = DateTime.Now,
Category = "North",
SalesOrderRowAmount = _rnd.Next(1, 100)
});
}
for (i = 0; i < _rnd.Next(1, 10000); i++)
{
_salesListSource.Add(new DataDto
{
CreatedAt = DateTime.Now,
Category = "East",
SalesOrderRowAmount = _rnd.Next(1, 100)
});
}
for (i = 0; i < _rnd.Next(1, 10000); i++)
{
_salesListSource.Add(new DataDto
{
CreatedAt = DateTime.Now,
Category = "West",
SalesOrderRowAmount = _rnd.Next(1, 100)
});
}
for (i = 0; i < _rnd.Next(1, 10000); i++)
{
_salesListSource.Add(new DataDto
{
CreatedAt = DateTime.Now,
Category = "South",
SalesOrderRowAmount = _rnd.Next(1, 100)
});
}
#endregion
IOrderedQueryable <DataDto> query = _salesListSource.AsQueryable().OrderBy(o => o.CreatedAt);
_salesList = new PagedQueryable <DataDto>(query, 10);
_salesList.Reloaded += SalesListReloaded;
base.OnActivated();
}
protected override void OnOpened()
{
IOrderedQueryable <CultureInfoDto> cultureQuery =
from c in CultureInfo.GetCultures(CultureTypes.NeutralCultures).AsQueryable()
select new CultureInfoDto(c)
into m
orderby m.NativeName
select m;
_cultures = new PagedQueryable <CultureInfoDto>(cultureQuery);
}
protected override void OnOpened()
{
base.OnOpened();
//check if modes are supported
IsNewSupported = ExportedModels.Any(m => m is EntityNewModel <T>);
IsDeleteSupported = ExportedModels.Any(m => m is EntityDeleteModel <T>);
IsDetailsSupported = ExportedModels.Any(m => m is EntityDetailsModel <T>);
IsNewEnabled = IsDetailsSupported;
_riport = new PagedQueryable <T>(ProvideQuery(Context));
}
protected override void OnOpened()
{
var items = new List <RiportDto>();
for (int i = 1; i < 100; i++)
{
items.Add(new RiportDto {
Id = i, Name = "Name" + i, Description = "Description" + i
});
}
//create new riport query with page size of 10
_riport = new PagedQueryable <RiportDto>(items.AsQueryable().OrderBy(d => d.Id), 10);
}
public void ItemsTest()
{
IOrderedQueryable <GenericParameterHelper> query = GetQuery();
bool autoLoad = true;
int pageSize = 19;
var target = new PagedQueryable <GenericParameterHelper>(query, pageSize, autoLoad);
TweakedObservableCollection <GenericParameterHelper> actual;
actual = target.Items;
int expected = Math.Min(19, query.Count());
Assert.AreEqual(expected, actual.Count);
}
public When_fetching_query_results_with_limit_zero_pagination()
{
const int limitZero = 0;
_numberOfItems = 15;
var queryData = new Fixture()
.CreateMany <string>(_numberOfItems)
.Select((s, i) => new TestQuery.Item {
Index = i, Value = s
})
.ToImmutableList();
_fetchResult = new TestQuery(queryData)
.Fetch(
new FilteringHeader <TestQuery.FilterItem>(default),
private static async Task <string> BuildAtomFeed(
DateTimeOffset lastUpdate,
PagedQueryable <MunicipalitySyndicationQueryResult> pagedMunicipalities,
IOptions <ResponseOptions> responseOptions,
IConfiguration configuration)
{
var sw = new StringWriterWithEncoding(Encoding.UTF8);
using (var xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings {
Async = true, Indent = true, Encoding = sw.Encoding
}))
{
var formatter = new AtomFormatter(null, xmlWriter.Settings)
{
UseCDATA = true
};
var writer = new AtomFeedWriter(xmlWriter, null, formatter);
var syndicationConfiguration = configuration.GetSection("Syndication");
var atomConfiguration = AtomFeedConfigurationBuilder.CreateFrom(syndicationConfiguration, lastUpdate);
await writer.WriteDefaultMetadata(atomConfiguration);
var municipalities = await pagedMunicipalities.Items.ToListAsync();
var highestPosition = municipalities.Any()
? municipalities.Max(x => x.Position)
: (long?)null;
var nextUri = BuildNextSyncUri(
pagedMunicipalities.PaginationInfo.Limit,
highestPosition + 1,
syndicationConfiguration["NextUri"]);
if (nextUri != null)
{
await writer.Write(new SyndicationLink(nextUri, GrArAtomLinkTypes.Next));
}
foreach (var municipality in municipalities)
{
await writer.WriteMunicipality(responseOptions, formatter, syndicationConfiguration["Category"], municipality);
}
xmlWriter.Flush();
}
return(sw.ToString());
}
protected override void OnOpened()
{
IOrderedQueryable <ModelDto> query = from m in ExportedModels.AsQueryable()
select
new ModelDto
{
ModelTitle = m.ModelTitle, ModelTypeName = m.GetType().Name
}
into dto
orderby dto.ModelTypeName
select dto;
_modelList = new PagedQueryable <ModelDto>(query);
base.OnOpened();
}
private static async Task <string> BuildAtomFeed(
DateTimeOffset lastFeedUpdate,
PagedQueryable <AddressSyndicationQueryResult> pagedAddresses,
IOptions <ResponseOptions> responseOptions,
IConfiguration configuration)
{
var sw = new StringWriterWithEncoding(Encoding.UTF8);
using (var xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings {
Async = true, Indent = true, Encoding = sw.Encoding
}))
{
var formatter = new AtomFormatter(null, xmlWriter.Settings)
{
UseCDATA = true
};
var writer = new AtomFeedWriter(xmlWriter, null, formatter);
var syndicationConfiguration = configuration.GetSection("Syndication");
var atomFeedConfig = AtomFeedConfigurationBuilder.CreateFrom(syndicationConfiguration, lastFeedUpdate);
await writer.WriteDefaultMetadata(atomFeedConfig);
var addresses = pagedAddresses.Items.ToList();
var nextFrom = addresses.Any()
? addresses.Max(x => x.Position) + 1
: (long?)null;
var nextUri = BuildNextSyncUri(pagedAddresses.PaginationInfo.Limit, nextFrom, syndicationConfiguration["NextUri"]);
if (nextUri != null)
{
await writer.Write(new SyndicationLink(nextUri, "next"));
}
foreach (var address in addresses)
{
await writer.WriteAddress(responseOptions, formatter, syndicationConfiguration["Category"], address);
}
xmlWriter.Flush();
}
return(sw.ToString());
}
private static async Task <string> BuildAtomFeed(
PagedQueryable <PostalInformationSyndicationQueryResult> pagedPostalInfoItems,
IOptions <ResponseOptions> responseOptions,
IConfiguration configuration)
{
var sw = new StringWriterWithEncoding(Encoding.UTF8);
using (var xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings {
Async = true, Indent = true, Encoding = sw.Encoding
}))
{
var formatter = new AtomFormatter(null, xmlWriter.Settings)
{
UseCDATA = true
};
var writer = new AtomFeedWriter(xmlWriter, null, formatter);
var syndicationConfiguration = configuration.GetSection("Syndication");
await writer.WriteDefaultMetadata(
syndicationConfiguration["Id"],
syndicationConfiguration["Title"],
Assembly.GetEntryAssembly().GetName().Version.ToString(),
new Uri(syndicationConfiguration["Self"]),
syndicationConfiguration.GetSection("Related").GetChildren().Select(c => c.Value).ToArray());
var nextUri = BuildVolgendeUri(pagedPostalInfoItems.PaginationInfo, syndicationConfiguration["NextUri"]);
if (nextUri != null)
{
await writer.Write(new SyndicationLink(nextUri, GrArAtomLinkTypes.Next));
}
foreach (var postalInfo in pagedPostalInfoItems.Items)
{
await writer.WritePostalInfo(responseOptions, formatter, syndicationConfiguration["Category"], postalInfo);
}
xmlWriter.Flush();
}
return(sw.ToString());
}
/// <summary>Adds the 'X-Pagination' and 'X-Sorting' response headers</summary>
public static void AddPagedQueryResultHeaders <T>(this HttpResponse response, PagedQueryable <T> queryResult)
{
response.AddPaginationResponse(queryResult.PaginationInfo);
response.AddSortingResponse(queryResult.Sorting);
}
