public IActionResult Index(SortFilterPageOptions options)
{
var listService = new ListCustomersService(_context);
var customerList = listService.SortFilterPage(options).ToList();
return(View(new CustomerListCombinedDto(options, customerList)));
}
public async Task SetupRestOfDto(BooksFilterBy filterBy, string filterValue, int pageSize,
int expectedPageNum, int expectedNumPages)
{
//SETUP
var numBooks = 12;
var options = SqliteInMemory.CreateOptions <BookDbContext>();
using (var context = new BookDbContext(options))
{
context.Database.EnsureCreated();
context.SeedDatabaseDummyBooks(numBooks);
var sfpDto = new SortFilterPageOptions
{
FilterBy = BooksFilterBy.ByVotes,
FilterValue = "Dummy",
PageSize = 10,
PageNum = 2
};
//need to do this to to setup PrevCheckState
await sfpDto.SetupRestOfDtoAsync(context.Books);
//ATTEMPT
sfpDto.PageNum = 2;
sfpDto.FilterBy = filterBy;
sfpDto.FilterValue = filterValue;
sfpDto.PageSize = pageSize;
await sfpDto.SetupRestOfDtoAsync(context.Books);
//VERIFY
sfpDto.PageNum.ShouldEqual(expectedPageNum);
sfpDto.NumPages.ShouldEqual(expectedNumPages);
}
}
public IActionResult Index(SortFilterPageOptions options, [FromServices] IListBooksService service)
{
var output = service.SortFilterPage(options).ToList();
SetupTraceInfo();
return(View(new BookListCombinedDto(options, output)));
}
// GET: Home
public ViewResult Index(SortFilterPageOptions options)
{
var listServices = new ListCustomersService(_context);
var customerList = listServices.SortFilterPage(options).ToList();
return(View(new CustomersListDto(options, customerList)));
}
public TestBetterLinq(ITestOutputHelper output)
{
_output = output;
showLogs = false;
int count = 1;
_options = this.CreateUniqueClassOptionsWithLogging <BookDbContext>(log =>
{
if (showLogs)
{
_output.WriteLine($"\nLOG {count++:D2}");
_output.WriteLine(log.ToString());
}
});
_sfpOptions = new SortFilterPageOptions
{
PageSize = 10,
PageNum = 0
};
using var context = new BookDbContext(_options);
{
context.Database.EnsureCreated();
if (!context.Books.Any())
{
context.SeedDatabaseDummyBooks(100);
}
}
}
public async Task <IActionResult> Index(SortFilterPageOptions options, [FromServices] IListNoSqlBooksService service)
{
var output = await(await service.SortFilterPageAsync(options)).ToListAsync();
SetupTraceInfo();
return(View(new BookListNoSqlCombinedDto(options, output)));
}
public void SetupRestOfDto(BooksFilterBy filterBy, string filterValue, int pageSize,
int expectedPageNum, int expectedNumPages)
{
//SETUP
var inMemDb = new SqliteInMemory();
const int numBooks = 12;
using (var db = inMemDb.GetContextWithSetup())
{
db.Books.AddRange(EfTestData.CreateDummyBooks(numBooks, false));
db.SaveChanges();
var sfpDto = new SortFilterPageOptions
{
FilterBy = BooksFilterBy.ByVotes,
FilterValue = "Dummy",
PageNum = 2
};
//need to do this to to setup PrevCheckState
sfpDto.SetupRestOfDto(db.Books);
//ATTEMPT
sfpDto.PageNum = 2;
sfpDto.FilterBy = filterBy;
sfpDto.FilterValue = filterValue;
sfpDto.PageSize = pageSize;
sfpDto.SetupRestOfDto(db.Books);
//VERIFY
sfpDto.PageNum.ShouldEqual(expectedPageNum);
sfpDto.NumPages.ShouldEqual(expectedNumPages);
}
}
public void OnGet()
{
SortFilterPage = new SortFilterPageOptions {
FilterBy = ProdukterFilterBy.ByNavn, FilterValue = SearchTerm, OrderByOptions = OrderBy, PageNum = CurrentPage, PageSize = PageSize
};
Produkts = _produktService.SortFilterPage(SortFilterPage);
OrderByList = _htmlHelper.GetEnumSelectList <OrderByOptions>();
TotalPages = SortFilterPage.NumPages;
}
public JsonResult GetFilterSearchContent
(SortFilterPageOptions options)
{
var service = new
BookFilterDropdownService(new EfCoreContext());
return(Json(service.GetFilterDropDownValues(
options.FilterBy), JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Index(SortFilterPageOptions options, [FromServices] BookDbContext context)
{
options.SetupRestOfDto(await context.DapperBookListCountAsync(options));
var bookList = (await context.DapperBookListQueryAsync(options)).ToList();
SetupTraceInfo();
return(View(new BookListCombinedDto(options, bookList)));
}
public JsonResult GetFilterSearchContent(SortFilterPageOptions options, [FromServices] IBookFilterDropdownService service)
{
var traceIdent = HttpContext.TraceIdentifier;
return(Json(
new TraceIndentGeneric <IEnumerable <DropdownTuple> >(
traceIdent,
service.GetFilterDropDownValues(
options.FilterBy))));
}
public async Task <JsonResult> GetFilterSearchContent(SortFilterPageOptions options,
[FromServices] CosmosDbContext context,
[FromServices] BookAppSettings settings)
{
var traceIdent = HttpContext.TraceIdentifier;
var dropdowns = await context.GetFilterDropDownValuesAsync(options.FilterBy, settings.CosmosDatabaseName);
return(Json(
new TraceIndentGeneric <IEnumerable <DropdownTuple> >(
traceIdent, dropdowns)));
}
public IQueryable <ProduktListDto> SortFilterPage(SortFilterPageOptions options)
{
var produkterQuery = _context.Produkter
.AsNoTracking()
.MapProduktToDto()
.OrderProduktBy(options.OrderByOptions)
.FilterProduktBy(options.FilterBy, options.FilterValue);
options.SetupRestOfDto(produkterQuery); // Added
return(produkterQuery.Page(options.PageNum - 1, options.PageSize)); // Added
}
public async Task <IActionResult> Index(SortFilterPageOptions options,
[FromServices] CosmosDbContext context,
[FromServices] BookAppSettings settings)
{
options.SetupRestOfDto(await context.CosmosDirectCountAsync(options, settings.CosmosDatabaseName));
var bookList = (await context.CosmosDirectQueryAsync(options, settings.CosmosDatabaseName)).ToList();
SetupTraceInfo();
return(View(new CosmosDirectBookListCombinedDto(options, bookList)));
}
public JsonResult GetFilterSearchContent(SortFilterPageOptions options)
{
var service = new BookFilterDropdownService(_context);
var traceIdent = HttpContext.TraceIdentifier; //This makes the logging display work
return(Json(
new TraceIndentGeneric <IEnumerable <DropdownTuple> >(
traceIdent,
service.GetFilterDropDownValues(
options.FilterBy))));
}
public async Task OnGetAsync(SortFilterPageOptions options)
{
var booksQuery = _service.ReadManyNoTracked <BookListDto>()
.OrderBooksBy(options.OrderByOptions)
.FilterBooksBy(options.FilterBy,
options.FilterValue);
await options.SetupRestOfDto(booksQuery);
BooksList = await booksQuery.Page(options.PageNum - 1, options.PageSize).ToArrayAsync();
SortFilterPageData = options;
}
public static async Task <int> CosmosDirectCountAsync(this CosmosDbContext context,
SortFilterPageOptions options, string databaseName)
{
var container = context.GetCosmosContainerFromDbContext(databaseName);
var command = BuildQueryString(options, true);
using (new LogCosmosCommand(command, context))
{
var resultSet = container.GetItemQueryIterator <int>(new QueryDefinition(command));
return((await resultSet.ReadNextAsync()).First());
}
}
CosmosDirectQueryAsync(this CosmosDbContext context,
SortFilterPageOptions options, string databaseName)
{
var container = context.GetCosmosContainerFromDbContext(databaseName);
var command = BuildQueryString(options, false);
using (new LogCosmosCommand(command, context))
{
var resultSet = container.GetItemQueryIterator <CosmosBook>(new QueryDefinition(command));
return(await resultSet.ReadNextAsync());
}
}
public async Task <IQueryable <BookListNoSql> > SortFilterPageAsync(SortFilterPageOptions options)
{
var booksQuery = _context.Books
.AsNoTracking()
.OrderBooksBy(options.OrderByOptions)
.FilterBooksBy(options.FilterBy,
options.FilterValue);
await options.SetupRestOfDtoAsync(booksQuery);
return(booksQuery.Page(options.PageNum - 1,
options.PageSize));
}
public IActionResult Index(SortFilterPageOptions options)
{
var listService =
new ListBooksService(_context);
var bookList = listService
.SortFilterPage(options)
.ToList();
SetupTraceInfo(); //Thsi makes the logging display work
return(View(new BookListCombinedDto(options, bookList)));
}
public IQueryable <BookListDTO> SortFilterPage(SortFilterPageOptions options)
{
var BooksQuery = Context.Books.
AsNoTracking().
MapBookToDto().
FilterBooksBy(options.FilterBy, options.FilterValue).
OrderBooksBy(options.OrderByOptions);
options.SetupRestOfDto(BooksQuery);
return(BooksQuery
.Page <BookListDTO>(options.PageNum - 1, options.PageSize));
}
public JsonResult GetFilterSearchContent
(SortFilterPageOptions options)
{
var service = new
ProductFilterDropDownService(_context);
var traceIdent = HttpContext.TraceIdentifier;
return(Json(
service.GetFilterDropDownValues(
options.FilterBy)));
}
public async Task <IActionResult> Index //#A
(SortFilterPageOptions options)
{
var listService =
new ListBooksService(_context);
var bookList = await listService //#B
.SortFilterPage(options)
.ToListAsync(); //#C
SetupTraceInfo(); //REMOVE THIS FOR BOOK as it could be confusing
return(View(new BookListCombinedDto(options, bookList)));
}
public IQueryable <BookListDto> SortFilterPage(SortFilterPageOptions options)
{
var booksQuery = _context.Books //#A
.AsNoTracking() //#B
.MapBookToDto() //#C
.OrderBooksBy(options.OrderByOptions) //#D
.FilterBooksBy(options.FilterBy, //#E
options.FilterValue); //#E
options.SetupRestOfDto(booksQuery); //#F
return(booksQuery.Page(options.PageNum - 1, //#G
options.PageSize)); //#G
}
public async Task TestListBooksServiceOrderNormalOk()
{
//SETUP
using var context = new BookDbContext(_options);
var service = new ListBooksService(context);
var sfpOptions = new SortFilterPageOptions();
//ATTEMPT
var query = (await service.SortFilterPageAsync(sfpOptions));
//VERIFY
_output.WriteLine(query.ToQueryString());
}
public JsonResult GetFilterSearchContent //#A
(SortFilterPageOptions options) //#B
{
var service = new //#C
BookFilterDropdownService(_context); //#C
var traceIdent = HttpContext.TraceIdentifier; //REMOVE THIS FOR BOOK as it could be confusing
return(Json( //#D
new TraceIndentGeneric <IEnumerable <DropdownTuple> >(
traceIdent,
service.GetFilterDropDownValues( //#E
options.FilterBy)))); //#E
}
} //#A
public IActionResult Index //#B
(SortFilterPageOptions options) //#C
{
var listService = //#D
new ListBooksService(_context); //#D
var bookList = listService //#E
.SortFilterPage(options) //#E
.ToList(); //#F
var traceIdent = HttpContext.TraceIdentifier; //REMOVE THIS FOR BOOK as it could be confusing
return(View(new BookListCombinedDto //#G
(traceIdent, options, bookList))); //#G
}
private static string FormSelectPart(SortFilterPageOptions options, bool justCount)
{
if (justCount)
{
return("SELECT value COUNT(c) FROM c");
}
return
(@"SELECT c.BookId, c.Title, c.PublishedOn, c.EstimatedDate, c.YearPublished,
c.OrgPrice, c.ActualPrice, c.PromotionalText, c.ManningBookUrl,
c.AuthorsOrdered, c.ReviewsCount, c.ReviewsAverageVotes, c.Tags, c.TagsString
FROM c
");
}
public IActionResult Index
(SortFilterPageOptions options)
{
var listService =
new ListProductsService(_context);
var productList = listService
.SortFilterPage(options)
.ToList();
var traceIdent = HttpContext.TraceIdentifier;
return(View(new ProductListCombinedDto
(traceIdent, options, productList)));
}
public ActionResult Index(SortFilterPageOptions options)
{
var context = new EfCoreContext();
context.Database.Log = message => Trace.Write(message);
var listService =
new ListBooksService(context);
var bookList = listService
.SortFilterPage(options)
.ToList();
return(View(new BookListCombinedDto
(options, bookList)));
}
