public async Task <IActionResult> GetAddresses(
string stateId = "None",
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 6)
{
var query = (IQueryable <Address>)_context.Addresses;
if (stateId != "None")
{
query = query.Where(a => a.Region == stateId);
}
var addressesCount = await query.LongCountAsync();
var addresses = await query
.OrderBy(c => c.Region)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
var model = new PaginatedItemsViewModel <Address>
{
PageIndex = pageIndex,
PageSize = addresses.Count,
Count = addressesCount,
Data = addresses
};
return(Ok(model));
}
public async Task <IActionResult> AuthorsAsync([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0, string ids = null)
{
if (!string.IsNullOrEmpty(ids))
{
var item = await GetAuthorsByIdsAsync(ids);
if (!item.Any())
{
return(BadRequest("Ids values are invalid. It must be comma separated"));
}
return(Ok(item));
}
if (pageIndex <= 0 || pageSize <= 0)
{
return(BadRequest("Invalid page index or page size"));
}
var totalItems = await _catalogContext.Authors.LongCountAsync();
var itemOnPage = await _catalogContext.Authors
.OrderBy(c => c.Name).Skip(pageSize * pageIndex).Take(pageSize).ToListAsync();
var data = new PaginatedItemsViewModel <Author>(pageIndex, pageSize, totalItems, itemOnPage);
return(Ok(data));
}
public async Task <IActionResult> Items(string name,
[FromQuery] int pageSize = 6,
[FromQuery] int pageIndex = 0)
{
var totalItems = await _context.EventItems
.Where(c => c.Name.StartsWith(name))
.LongCountAsync();
var itemsOnPage = await _context.EventItems
.Where(c => c.Name.StartsWith(name))
.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
itemsOnPage = ChangePictureUrl(itemsOnPage);
var model = new PaginatedItemsViewModel <EventItem>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> ItemsAsync
(
[FromQuery] int pageSize = 10,
[FromQuery] int pageIndex = 0,
string ids = null
)
{
if (!string.IsNullOrEmpty(ids))
{
var items = await GetItemsByIdsAsync(ids);
if (!items.Any())
{
return(BadRequest("ids value invalid. Must be comma-separated list of numbers"));
}
return(Ok(items));
}
var totalItems = await _catalogContext.CatalogItems
.LongCountAsync();
var itemsOnPage = await _catalogContext.CatalogItems
.OrderBy(item => item.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
var model = new PaginatedItemsViewModel <CatalogItem>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
private string ChangePrice(BasketItem itemToModify, decimal newPrice, PaginatedItemsViewModel <CatalogItem> catalogProducts)
{
var catalogProduct = catalogProducts.Data.Single(pr => pr.Id == int.Parse(itemToModify.ProductId));
catalogProduct.Price = newPrice;
return(JsonConvert.SerializeObject(catalogProduct));
}
public async Task <ActionResult <PaginatedItemsViewModel <PurchaseRequestDetailDTO> > > GetListAsync(
[FromQuery] int pageSize = 10,
[FromQuery] int pageIndex = 0,
[FromQuery] Dictionary <string, Dictionary <string, List <string> > > filter = default,
[FromQuery] Dictionary <string, int> sorting = default,
[FromQuery] Dictionary <string, int> exact = default,
CancellationToken cancellation = default)
{
InitUserInfo();
if (!AllowRead)
{
return(ValidationProblem());
}
CleanFilter(filter);
var filterSpec = GenerateFilter(filter, exact);
var totalItems = await _purchaseRequestDetailService.CountAsync(filterSpec, cancellation);
var sortingSpec = GenerateSortingSpec(sorting);
var pagedFilterSpec = GenerateFilter(filter, exact, pageSize, pageIndex, sortingSpec);
var items = await _purchaseRequestDetailService.ListAsync(pagedFilterSpec, sortingSpec, false, cancellation);
var model = new PaginatedItemsViewModel <PurchaseRequestDetailDTO>(pageIndex, pageSize, totalItems, items.Select(_mapper.Map <PurchaseRequestDetailDTO>));
return(Ok(model));
}
public async Task <IActionResult> ItemsAsyncReceitas([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0, string ids = null)
{
if (!string.IsNullOrEmpty(ids))
{
List <Model.Receita> items = await GetItemsByIdsAsyncReceitas(ids);
if (!items.Any())
{
return(BadRequest("Valor de ids incorretos. Deve ser uma lista de números separados por vírgula."));
}
return(Ok(items));
}
long totalItems = await _receitaContext.Receitas
.LongCountAsync();
var itemsOnPage = await _receitaContext.Receitas
.Include(categoria => categoria.Categoria)
.OrderBy(c => c.Titulo)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
PaginatedItemsViewModel <Model.Receita> model = new PaginatedItemsViewModel <Model.Receita>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> EventCategories(int?eventCategoryId,
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 4)
{
var query = (IQueryable <EventItem>)_context.EventItems;
if (eventCategoryId.HasValue)
{
query = query.Where(c => c.CategoryId == eventCategoryId);
}
var eventsCount = query.LongCountAsync();
var events = await query
.OrderBy(c => c.EventCategory)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
events = ChangeImageUrl(events);
var model = new PaginatedItemsViewModel <EventItem>
{
PageIndex = pageIndex,
PageSize = events.Count,
Count = eventsCount.Result,
Data = events
};
return(Ok(model));
}
public async Task <IActionResult> Items(
int?categoryId,
int?typeId,
[FromQuery] int pageIndex = 0,
[FromQuery] int pagesize = 6)
{
var query = (IQueryable <EventItem>)_context.EventItems;
if (categoryId.HasValue)
{
query = query.Where(i => i.CategoryId == categoryId);
}
if (typeId.HasValue)
{
query = query.Where(i => i.TypeId == typeId);
}
var itemCount = query.LongCountAsync();
var result = await query
.OrderBy(s => s.EventName)
.Skip(pageIndex * pagesize)
.Take(pagesize)
.ToListAsync();
result = ChangeImageUrl(result);
var model = new PaginatedItemsViewModel <EventItem>
{
PageIndex = pageIndex,
PageSize = result.Count,
Count = (int)itemCount.Result,
Data = result
};
return(Ok(model));
}
public async Task <IActionResult> Items(int?catalogTypeId, [FromQuery] int pageSize = 6, [FromQuery] int pageIndex = 0)
{
var root = _catalogContext.CatalogItems.AsQueryable();
if (catalogTypeId.HasValue)
{
root = root.Where(c => c.CatalogTypeId == catalogTypeId);
}
var totalItems = await root
.LongCountAsync();
var itemsOnPage = await root
.Select(x => new CatalogItemResponseVM
{
Description = x.Description,
Id = x.Id,
Name = x.Name,
Price = x.Price,
PictureUrl = x.PictureFileName
})
.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
ChangeItemPictureUrls(itemsOnPage);
var model = new PaginatedItemsViewModel <CatalogItemResponseVM>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public PaginatedItemsViewModel <SupplierViewModel> GetAllSuppliers(int pageSize, int currentPage)
{
var query = _db.Suppliers.OrderBy(t => t.Name);
int totalRecordCount = 0;
double totalPages = 0;
int totalPageCount = 0;
var data = new List <SupplierViewModel>();
totalRecordCount = query.Count();
totalPages = (double)totalRecordCount / pageSize;
totalPageCount = (int)Math.Ceiling(totalPages);
var pageData = query.Skip((currentPage - 1) * pageSize).Take(pageSize).OrderBy(t => t.Name).ToList();
pageData.ForEach(p =>
{
data.Add(p.ToVm());
});
var response = new PaginatedItemsViewModel <SupplierViewModel>(currentPage, pageSize, totalPageCount, totalRecordCount, data);
return(response);
}
public async Task <IActionResult> SearchRestaurants([FromQuery] int pageIndex = 0, [FromQuery] int pageSize = 0) //int? catalogTypeId, int? catalogBrandId, [FromQuery]int pageSize = 6, [FromQuery]int pageIndex = 0
{
#region DP version
try
{
IQueryable <Restaurant> result = null;
result = RestaurantList.GetAll(); // ="Mango Tree"
if (result.Any())
{
var totalItems = await result.LongCountAsync();
var itemsOnPage = await result
.Skip(pageSize *pageIndex)
.OrderBy(c => c.Name)
.Take(pageSize)
.ToListAsync();
var model = new PaginatedItemsViewModel <Restaurant>(
pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(result));
}
return(NotFound());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
#endregion
}
public async Task <IActionResult> Items(bool?isFraud, string nameDest, DateTime?transactionDate, [FromQuery] int pageSize = 6, [FromQuery] int pageIndex = 0)
{
var query = (IQueryable <TransactionItem>)_transactionContext.TransactionItems;
if (isFraud.HasValue)
{
query = query.Where(ti => ti.IsFraud == isFraud);
}
if (!string.IsNullOrEmpty(nameDest))
{
query = query.Where(ti => ti.NameDest.StartsWith(nameDest));
}
if (transactionDate.HasValue)
{
query = query.Where(ti => ti.TransactionDate == transactionDate);
}
var totalItems = await query.LongCountAsync();
var itemsOnPage = await query
.Skip(pageSize *pageIndex)
.OrderBy(c => c.NameOrig)
.Take(pageSize)
.ToListAsync();
var model = new PaginatedItemsViewModel <TransactionItem>(
pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> Items(
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 6)
{
var itemsCount = await _context.EventItems.LongCountAsync();
var items = await _context.EventItems
.OrderBy(c => c.Name)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
items = ChangeImageUrl(items);
// items = ChangeImageUrl
var model = new PaginatedItemsViewModel <EventItem>
{
PageIndex = pageIndex,
PageSize = items.Count,
Data = items,
Count = itemsCount
//KAL CODE itemsCount.Result
};
return(Ok(model));
}
public async Task <IActionResult> Items(int?catalogTypeId, int?catalogBrandId, [FromQuery] int pageSize = 6, [FromQuery] int pageIndex = 0)
{
var root = (IQueryable <CatalogItem>)_catalogContext.CatalogItems; // not sent the call to db
if (catalogTypeId.HasValue)
{
root = root.Where(x => x.CatalogTypeId == catalogTypeId);
}
if (catalogBrandId.HasValue)
{
root = root.Where(x => x.CatalogBrandId == catalogBrandId);
}
var totalItems = await root.LongCountAsync();
//list of item we are going to send to the page
var itemsOnPage = await root
.OrderBy(x => x.Name)
.Skip(pageSize * pageIndex).Take(pageSize).ToListAsync();
//replace current external url to local
itemsOnPage = ChangeUrlPlaceholder(itemsOnPage);
var model = new PaginatedItemsViewModel <CatalogItem>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> FilterByDate(int?day, int?month, int?year,
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 5)
{
var query = (IQueryable <EventItem>)_context.EventItems;
if (day.HasValue && month.HasValue && year.HasValue)
{
query = query.Where(e => e.EventStartTime.Day == day)
.Where(e => e.EventStartTime.Month == month)
.Where(e => e.EventStartTime.Year == year);
}
var eventsCount = query.LongCountAsync();
var events = await query
.OrderBy(t => t.EventName)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
events = ChangeImageUrl(events);
var model = new PaginatedItemsViewModel <EventItem>
{
PageIndex = pageIndex,
PageSize = events.Count,
Count = eventsCount.Result,
Data = events
};
return(Ok(model));
}
public async Task <IActionResult> Items(int?departmentTypeId, string departmentGroupId, [FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0)
{
var root = (IQueryable <Department>)_deptoContext.Departments;
if (departmentTypeId.HasValue)
{
root = root.Where(ci => ci.DepartmentType == (DepartmentType)departmentTypeId);
}
if (departmentGroupId != null)
{
root = root.Where(ci => ci.DepartmentGroup.Id == departmentGroupId);
}
var totalItems = await root
.LongCountAsync();
var itemsOnPage = await root
.Skip(pageSize *pageIndex)
.Take(pageSize)
.ToListAsync();
// itemsOnPage = ComposePicUri(itemsOnPage);
var model = new PaginatedItemsViewModel <Department>(
pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
//IACtionResult is wrapped in task vs PicController because PicController will be called by this controller whereas
//Catalogcontroller is called by the UI (picController is not)
//pageIndex is which page the data User wants to see the data for
//pageSize is how many items are in per page
//[FromQuery] attribute indicates that the parameter will come from the query
//use of Query route means you must remove the URI route
public async Task <IActionResult> Items(
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 6)
{
//LINQ query to get the total # of records in the Items Database, similar to Select Count(*) from CatalogItems
var itemsCount = await _context.CatalogItems.LongCountAsync();
//context is the entity core parameter; CatalogItems is the table; then we need a LINQ query
//Need to grab data from catalogitems just for this page index and page size
//this call happens in 2ndary thread, but we wait for the secondary thread to finish and give back the data
//asynchronous will happen in the secondary thread
var items = await _context.CatalogItems
.Skip(pageIndex *pageSize)
.Take(pageSize)
.ToListAsync();
//After getting items, we're going to replace the pictureURL via the below method and pass along the items
items = ChangePictureUrl(items);
var model = new PaginatedItemsViewModel <CatalogItem>
{
PageIndex = pageIndex,
PageSize = pageSize,
Count = itemsCount,
Data = items
};
//when making an API call, you must send back a status (200 = good, 400 = bad, 500 = internal server errors)
return(Ok(model));
}
public IActionResult Get([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0)
{
var items = new List <string>
{
"i01", "i02", "i03", "i04", "i05", "i06", "i07", "i08", "i09", "i10",
"i11", "i12", "i13", "i14", "i15", "i16",
};
var total = items.Count;
List <string> itemsOnPage;
if (pageSize * pageIndex + pageSize > total)
{
itemsOnPage = items.GetRange(pageSize * pageIndex, total - pageSize * pageIndex);
}
else
{
itemsOnPage = items.GetRange(pageSize * pageIndex, pageSize);
}
var model = new PaginatedItemsViewModel <string>(
pageIndex, pageSize, total, itemsOnPage
);
return(Ok(model));
}
public async Task <PaginatedItemsViewModel <DocumentViewModel> > GetDocumentsPaginatedAsync(
DocumentsFilter parameters,
int pageSize,
int pageIndex)
{
var documentsQuery = _context.Documents.Filter(parameters);
var totalCount = await documentsQuery.LongCountAsync();
var documentsOnPage = await documentsQuery
.OrderByDescending(d => d.CreationDate)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.Select(d => new DocumentViewModel
{
ID = d.ID,
CreationDate = d.CreationDate,
Name = d.Name,
Extension = d.Originals.Where(o => o.ForSign).Select(o => o.Extension).FirstOrDefault(),
DocumentType = d.DocumentType.Name
})
.ToListAsync();
var model = new PaginatedItemsViewModel <DocumentViewModel>(
pageIndex, pageSize, totalCount, documentsOnPage);
return(model);
}
public async Task <IActionResult> EventItems(
int?zipcodeId,
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 6
)
{
var query = (IQueryable <EventItem>)_context.EventItems;
query = query.Where(c => c.Location.ZipCodeId == zipcodeId);
var eventItemsCount = await query.LongCountAsync();
var eventItems = await query
.OrderBy(c => c.Title)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
eventItems = ChangePictureUrl(eventItems);
var model = new PaginatedItemsViewModel <EventItem>
{
PageIndex = pageIndex,
PageSize = eventItems.Count,
Count = eventItemsCount,
Data = eventItems
};
return(Ok(model));
}
public async Task <IActionResult> Items(int?catalogTypeId = 0, int?catalogBrandId = null, [FromQuery] int pageSize = 6, [FromQuery] int pageIndex = 0)
{
// IQueryable used to indicate that the query is not ready yet and we will not make db call
var root = (IQueryable <CatalogItem>)_catalogContext.CatalogItems;
if (catalogTypeId != 0)
{
root = root.Where(c => c.CatalogTypeId == catalogTypeId);
}
if (catalogBrandId.HasValue)
{
root = root.Where(c => c.CatalogBrandId == catalogBrandId);
}
var totalItems = await root.LongCountAsync();
var itemsOnPage = await root
.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
itemsOnPage = ChangeUrlPlaceHolder(itemsOnPage);
var model = new PaginatedItemsViewModel <CatalogItem>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> ItemsAsync([FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0, string ids = null)
{
if (!string.IsNullOrEmpty(ids))
{
var items = await GetItemsByIdsAsync(ids);
if (!items.Any())
{
return(BadRequest("ids value invalid. Must be comma-separated list of numbers"));
}
return(Ok(items));
}
var totalItems = await _productRepository.GetAsyncProductCount();
var itemsOnPage = await _productRepository.GetAsyncProductsItemsForPage(pageSize, pageIndex);
/* The "awesome" fix for testing Devspaces */
/*
* foreach (var pr in itemsOnPage) {
* pr.Name = "Awesome " + pr.Name;
* }
*
*/
var model = new PaginatedItemsViewModel <Product>(pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
protected void Page_Load(object sender, EventArgs e)
{
if (PaginationParamsAreSet())
{
var size = Convert.ToInt32(Page.RouteData.Values["size"]);
var index = Convert.ToInt32(Page.RouteData.Values["index"]);
Model = CatalogService.GetCatalogItemsPaginated(size, index);
}
else
{
Model = CatalogService.GetCatalogItemsPaginated(DefaultPageSize, DefaultPageIndex);
}
PeopleGrid.DataSource = new List <People>()
{
new People("Andy", "Wayne", "PG"),
new People("Bill", "Johnson", "SD"),
new People("Caroline", "Barry", "Manager")
};
PeopleGrid.DataBind();
ProductList.DataSource = Model.Data;
ProductList.DataBind();
ConfigurePagination();
}
public async Task <IActionResult> Items(int?catalogTypeId, int?catalogBrandId, [FromQuery] int pageSize = 10, [FromQuery] int pageIndex = 0)
{
var root = (IQueryable <CatalogItem>)_context.CatalogItems;
if (catalogTypeId.HasValue)
{
root = root.Where(ci => ci.CatalogTypeId == catalogTypeId);
}
if (catalogBrandId.HasValue)
{
root = root.Where(ci => ci.CatalogBrandId == catalogBrandId);
}
var totalItems = await root
.LongCountAsync();
var itemsOnPage = await root
.Skip(pageSize *pageIndex)
.Take(pageSize)
.ToListAsync();
itemsOnPage = ComposePicUri(itemsOnPage);
var model = new PaginatedItemsViewModel <CatalogItem>(
pageIndex, pageSize, totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> Events(
[FromQuery] int pageSize = 6,
[FromQuery] int pageIndex = 0)
{
var eventsCount =
await _context.Events.LongCountAsync();
var events = await _context.Events
.OrderBy(c => c.Title)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
events = ChangePictureUrl(events);
var model = new PaginatedItemsViewModel <Event>
{
PageIndex = pageIndex,
PageSize = pageSize,
Count = eventsCount,
Data = events
};
return(Ok(model));
}
public async Task <IActionResult> Items(
[FromQuery] int pageSize = 6,
[FromQuery] int pageIndex = 0)
{
var itemsCount = await _context.EventItems.LongCountAsync();
var items = await _context.EventItems
.OrderBy(e => e.Name)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
items = ChangePictureUrl(items);
//var model=new PaginatedItemsViewModel<EventItem>()
//{
// PageIndex = pageIndex,
// PageSize = pageSize,
// Count = itemsCount,
// Data = items
//};
var model = new PaginatedItemsViewModel <EventItem>(pageIndex, pageSize, itemsCount, items);
return(Ok(model));
}
public async Task <IActionResult> Items(
[FromQuery] int pageSize = 6,
[FromQuery] int pageIndex = 0)
{
var itemsCount = await _context.EventItems.LongCountAsync();
var items = await _context.EventItems
.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
items = ChangePictureUrl(items);
var model = new PaginatedItemsViewModel <EventItem>
{
PageSize = pageSize,
PageIndex = pageIndex,
Count = itemsCount,
Data = items
};
return(Ok(model));
}
public async Task <IActionResult> Items(int?catalogTypeId, int?catalogBrandId, [FromQuery] int pageSize = 6, [FromQuery] int pageIndex = 0)
{
var root = (IQueryable <CatalogItem>)_catalogContext.CatalogItems;
if (catalogTypeId.HasValue)
{
root = root.Where(c => c.CatalogTypeId == catalogTypeId);
}
if (catalogBrandId.HasValue)
{
root = root.Where(c => c.CatalogBrandId == catalogBrandId);
}
var totalItems = await root.LongCountAsync();
var itemsOnPage = await root.OrderBy(c => c.Name)
.Skip(pageSize * pageIndex)
.Take(pageSize)
.ToListAsync();
itemsOnPage = ChangeUrlPlaceHolder(itemsOnPage);
var model = new PaginatedItemsViewModel <CatalogItem>(pageIndex, pageSize, (int)totalItems, itemsOnPage);
return(Ok(model));
}
public async Task <IActionResult> GetItemsbyDate(
DateTime dateval,
[FromQuery] int pageIndex = 0,
[FromQuery] int pageSize = 3)
{
var query = (IQueryable <EventItem>)_context.EventItems;
query = (IQueryable <EventItem>)query.Where(e => e.Event_Start_Time.Date == dateval.Date);
var itemsCount = query.LongCountAsync();
var items = await query
.OrderBy(c => c.Event_Name)
.Skip(pageIndex * pageSize)
.Take(pageSize)
.ToListAsync();
items = ChangePictureUrl(items);
var model = new PaginatedItemsViewModel <EventItem>
{
PageIndex = pageIndex,
PageSize = items.Count,
Count = itemsCount.Result,
Data = items
};
return(Ok(model));
}
