public async Task <IActionResult> GetProducts(ResourceParameters resourceParameters, ProductFilterParameters filterParameters) { if (!_propertyMappingService.ValidMappingExistsFor <ProductEntity, Data.Sqlite.Models.ProductModel>(resourceParameters.OrderBy)) { return(BadRequest(ExceptionMessageModelFactory.BadRequstOrderByParameters())); } if (!_typeHelper.TypeHasProperties <ProductForGetModel>(resourceParameters.Fields)) { return(BadRequest(ExceptionMessageModelFactory.BadRequstFieldsParameters())); } var products = await _productRepository.GetProducts(resourceParameters, filterParameters); AddHeaders(); var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products); return(Ok(modelResults.ShapeData(resourceParameters.Fields))); // Local method to get create headers. Is this overkill? Probably. void AddHeaders() => Response.Headers.Add("X-Pagination", _pagedListHelper.AddPaginationMetadataToResponseHeader(products, resourceParameters, filterParameters, "GetProducts")); }
private string CreatePaymentHistoryResourceUri( ResourceParameters resourceParameters, ResourceUriType type) { switch (type) { case ResourceUriType.PreviousPage: return(Url.Link("PaymentHistory", new { pageNumber = resourceParameters.PageNumber - 1, pageSize = resourceParameters.PageSize, searchQuery = resourceParameters.SearchQuery })); case ResourceUriType.NextPage: return(Url.Link("PaymentHistory", new { pageNumber = resourceParameters.PageNumber + 1, pageSize = resourceParameters.PageSize, searchQuery = resourceParameters.SearchQuery })); default: return(Url.Link("PaymentHistory", new { pageNumber = resourceParameters.PageNumber, pageSize = resourceParameters.PageSize, searchQuery = resourceParameters.SearchQuery })); } }
public async Task <IActionResult> GetDepartments([FromQuery] ResourceParameters parameters) { var departments = await _siteReportRepository.GetDepartments(parameters); var prevLink = departments.HasPrevious ? CreateResourceUri(parameters, ResourceUriType.PreviousPage) : null; var nextLink = departments.HasNext ? CreateResourceUri(parameters, ResourceUriType.NextPage) : null; var currentLink = CreateResourceUri(parameters, ResourceUriType.CurrentPage); var pagination = new Pagination { currentPage = currentLink, nextPage = nextLink, previousPage = prevLink, totalPages = departments.TotalPages, perPage = departments.PageSize, totalEntries = departments.TotalCount }; return(Ok(new PagedResponse <IEnumerable <TblDepartments> > { success = true, message = "Departments retrieved successfully", data = departments, meta = new Meta { pagination = pagination } })); }
private string CreateResourceUri(ResourceParameters parameters, ResourceUriType type) { switch (type) { case ResourceUriType.PreviousPage: return(Url.Link("GetDepartments", new { PageNumber = parameters.PageNumber - 1, parameters.PageSize, })); case ResourceUriType.NextPage: return(Url.Link("GetDepartments", new { PageNumber = parameters.PageNumber + 1, parameters.PageSize, })); default: return(Url.Link("GetDepartments", new { parameters.PageNumber, parameters.PageSize, })); } }
public override PagedList <Tak> FindAll(ResourceParameters resourceParameters) { var result = GetAllWithAllIncluded().AsNoTracking(); var sortString = resourceParameters.SortBy + " " + resourceParameters.SortOrder; if (resourceParameters is TakResourceParameters takResourceParameters && takResourceParameters.TabIsAllowed) { result = result.Where(x => x.TabIsAllowed); } if (!string.IsNullOrWhiteSpace(resourceParameters.Query)) { result = result.Where(x => x.Naam.Contains(resourceParameters.Query)); } if (!string.IsNullOrWhiteSpace(sortString)) { result = result.OrderBy(sortString); } var pagedList = PagedList <Tak> .QueryAndCreate(result, resourceParameters.PageNumber, resourceParameters.PageSize); return(pagedList); }
/// <summary> /// Generates the resource. /// </summary> /// <param name="connectionString">Optional connection string for the resource.</param> /// <param name="parameters">The resource parameters.</param> /// <returns>Returns the resource.</returns> public override ResourceToken CreateResourceToken(string connectionString, ResourceParameters parameters) { if (string.IsNullOrWhiteSpace(connectionString)) { throw new ArgumentException("connectionString is invalid"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } BlobParameters blobParameters = parameters as BlobParameters; if (blobParameters == null) { throw new ArgumentException("Expected a BlobParameters collection", "parameters"); } if (string.IsNullOrWhiteSpace(blobParameters.Container)) { throw new ArgumentException("The container name must not be null or empty", "parameters.Container"); } if (string.IsNullOrWhiteSpace(blobParameters.Name)) { throw new ArgumentException("The blob name must not be null or empty", "parameters.Name"); } StorageProvider storageProvider = new StorageProvider(connectionString); return(storageProvider.CreateBlobAccessToken(blobParameters.Container, blobParameters.Name, blobParameters.Permissions, blobParameters.Expiration)); }
public IEnumerable <LinkDto> CreateLinksForEntities(ResourceParameters resourceParameters, bool hasNext, bool hasPrevious) { var links = new List <LinkDto> { new LinkDto(CreateResourceUri( resourceParameters, ResourceUriType.Current), "current", "GET") }; if (hasNext) { links.Add( new LinkDto(CreateResourceUri( resourceParameters, ResourceUriType.NextPage), "nextPage", "GET")); } if (hasPrevious) { links.Add( new LinkDto(CreateResourceUri( resourceParameters, ResourceUriType.PreviousPage), "previousPage", "GET")); } return(links); }
public async Task <RepositoryActionResult <IEnumerable <Event> > > GetEvents(ResourceParameters eventsResourceParameters) { try { IEnumerable <Event> eventsFromDb = await _ctx.Events .OrderBy(e => e.Start) .Skip(eventsResourceParameters.PageSize * (eventsResourceParameters.PageNumber - 1)) .Take(eventsResourceParameters.PageSize) .ToListAsync(); if (eventsFromDb == null) { return(new RepositoryActionResult <IEnumerable <Event> >(eventsFromDb, RepositoryActionStatus.NotFound)); } else { return(new RepositoryActionResult <IEnumerable <Event> >(eventsFromDb, RepositoryActionStatus.Ok)); } } catch (Exception) { return(new RepositoryActionResult <IEnumerable <Event> >(null, RepositoryActionStatus.Error)); } }
private string CreateContactResourceUri(ResourceParameters contactResourceParameters, ResourceUriType type) { switch (type) { case ResourceUriType.PreviousPage: return(_urlHelper.Link("SearchAllContact", new { searchQuery = contactResourceParameters.SearchQuery, pageNumber = contactResourceParameters.PageNumber - 1, pageSize = contactResourceParameters.PageSize })); case ResourceUriType.NextPage: return(_urlHelper.Link("SearchAllContact", new { searchQuery = contactResourceParameters.SearchQuery, pageNumber = contactResourceParameters.PageNumber + 1, pageSize = contactResourceParameters.PageSize })); default: return(_urlHelper.Link("SearchAllContact", new { searchQuery = contactResourceParameters.SearchQuery, pageNumber = contactResourceParameters.PageNumber, pageSize = contactResourceParameters.PageSize })); } }
public string CreatePaginationResourceUri(string actionName, ResourceParameters ResourceParameters, ResourceUriType type) { //var UrlHelper = new UrlHelper() switch (type) { case ResourceUriType.PreviousPage: return(_urlHelper.Link(actionName, new { PageNumber = ResourceParameters.PageNumber - 1, pageSize = ResourceParameters.PageSize })); case ResourceUriType.NextPage: return(_urlHelper.Link(actionName, new { PageNumber = ResourceParameters.PageNumber + 1, pageSize = ResourceParameters.PageSize, })); case ResourceUriType.Current: default: return(_urlHelper.Link(actionName, new { PageNumber = ResourceParameters.PageNumber, pageSize = ResourceParameters.PageSize, })); } }
private List <LinkDto> CreateLinksForContact(ResourceParameters contactResourceParameters, bool hasNext, bool hasPrevious) { var links = new List <LinkDto> { new LinkDto(CreateContactResourceUri(contactResourceParameters, ResourceUriType.Current) , "self", "GET") }; // self if (hasNext) { links.Add( new LinkDto(CreateContactResourceUri(contactResourceParameters, ResourceUriType.NextPage), "nextPage", "GET")); } if (hasPrevious) { links.Add( new LinkDto(CreateContactResourceUri(contactResourceParameters, ResourceUriType.PreviousPage), "previousPage", "GET")); } return(links); }
private IEnumerable <LinkDto> CreateLinksForMovie(ResourceParameters movieResourceParameters, bool hasNext, bool hasPrevious, string routeName) { var links = new List <LinkDto>(); // self links.Add( new LinkDto(CreateMovieResourceUri( movieResourceParameters, ResourceUriType.Current, routeName) , "self", "GET")); if (hasNext) { links.Add( new LinkDto(CreateMovieResourceUri( movieResourceParameters, ResourceUriType.NextPage, routeName), "nextPage", "GET")); } if (hasPrevious) { links.Add( new LinkDto(CreateMovieResourceUri( movieResourceParameters, ResourceUriType.PreviousPage, routeName), "previousPage", "GET")); } return(links); }
protected string CreateResourceUri(string routeName, ResourceParameters resourceParameters, ResourceUriType type) { switch (type) { case ResourceUriType.PreviousPage: return(_urlHelper.Link(routeName, new { pageNumber = resourceParameters.PageNumber - 1, pageSize = resourceParameters.PageSize, search = resourceParameters.Search, start = resourceParameters.Start, destination = resourceParameters.Destination })); case ResourceUriType.NextPage: return(_urlHelper.Link(routeName, new { pageNumber = resourceParameters.PageNumber + 1, pageSize = resourceParameters.PageSize, search = resourceParameters.Search, start = resourceParameters.Start, destination = resourceParameters.Destination })); default: return(_urlHelper.Link(routeName, new { pageNumber = resourceParameters.PageNumber, pageSize = resourceParameters.PageSize, search = resourceParameters.Search, start = resourceParameters.Start, destination = resourceParameters.Destination })); } }
public async Task <IActionResult> GetOrderHistoryByPage(ResourceParameters eventsResourceParemeters) { var userId = User.FindFirst("sub").Value; // this should be redundant due to authorize attribute (todo: check to remove this) if (userId == null) { return(StatusCode(StatusCodes.Status400BadRequest, null)); } RepositoryActionResult <IEnumerable <Order> > orderHistoryResult = await _orderService.GetAllOrderHistory(userId, eventsResourceParemeters); if (orderHistoryResult.Status == RepositoryActionStatus.Error) { return(StatusCode(StatusCodes.Status500InternalServerError)); } if (orderHistoryResult.Status == RepositoryActionStatus.NotFound) { return(StatusCode(StatusCodes.Status404NotFound)); } DTO.Orders.PagedOrder results = new DTO.Orders.PagedOrder(); results.Orders = Mapper.Map <IEnumerable <DTO.Orders.Order> >(orderHistoryResult.Entity); results.Total_count = await _orderService.GetOrderHistoryTotalCount(userId); return(StatusCode(StatusCodes.Status200OK, results)); }
public string CreateResourceUri( ResourceParameters resourceParameters, ResourceUriType type) { var performancesResourceParameters = (PerformancesResourceParameters)resourceParameters; string fields = performancesResourceParameters.Fields, orderBy = performancesResourceParameters.OrderBy, title = performancesResourceParameters.Filter == null ? "" : performancesResourceParameters.Filter.Title, director = performancesResourceParameters.Filter == null ? "" : performancesResourceParameters.Filter.Director; int pageNumber = performancesResourceParameters.PageNumber, pageSize = performancesResourceParameters.PageSize; int?year = performancesResourceParameters.Filter == null ? null : performancesResourceParameters.Filter.PremiereYear; switch (type) { case ResourceUriType.PreviousPage: return(_urlHelper.Link("GetPerformances", new { fields, orderBy, pageNumber = pageNumber - 1, pageSize, title, year, director })); case ResourceUriType.NextPage: return(_urlHelper.Link("GetPerformances", new { fields, orderBy, pageNumber = pageNumber + 1, pageSize, title, year, director })); case ResourceUriType.Current: default: return(_urlHelper.Link("GetPerformances", new { fields, orderBy, pageNumber, pageSize, title, year, director })); } }
/* ------------------------------ Menu Categories ----------------------------- */ public async Task <PagedList <MenuCategory> > GetMenuCategoriesAsync(int menuId, ResourceParameters resourceParameters) => await PagedList <MenuCategory> .CreateAsync(_catRepo.EntityDbSet .Where(c => c.MenuId == menuId) .Include(c => c.MenuItems), resourceParameters.PageNumber, resourceParameters.PageSize);
/// <summary> /// Extracts the parameters for a request. /// </summary> /// <param name="parameters">The parameters to extract.</param> /// <param name="defaultParameters">Optional parameters instance to use.</param> /// <returns>Returns the extracted parameters.</returns> public override ResourceParameters ExtractParameters(JToken parameters, ResourceParameters defaultParameters = null) { BlobParameters blobParameters = null; if (defaultParameters == null) { blobParameters = new BlobParameters(); } else { blobParameters = defaultParameters as BlobParameters; if (blobParameters == null) { throw new ArgumentException("Must be a BlobParameters instance", "defaultParameters"); } } base.ExtractParameters(parameters, blobParameters); try { // Container. blobParameters.Container = parameters.Value <string>("container"); if (string.IsNullOrWhiteSpace(blobParameters.Container)) { throw new HttpResponseException(HttpStatusCode.BadRequest); } } catch (Exception) { throw new HttpResponseException(HttpStatusCode.BadRequest); } return(blobParameters); }
public string AddPaginationMetadataToResponseHeader <T>(PagedList <T> items, ResourceParameters resourceParameters, object filterParameters, string routeName) { var filters = filterParameters.AsDictionary(); var previousPageLink = items.HasPrevious ? CreateProductsResourceUri(resourceParameters, filters, ResourceUriType.PreviousPage, routeName) : null; var nextPageLink = items.HasNext ? CreateProductsResourceUri(resourceParameters, filters, ResourceUriType.NextPage, routeName) : null; var paginationMetadata = new { previousPageLink, nextPageLink, totalCount = items.TotalCount, pageSize = items.PageSize, currentPage = items.CurrentPage, totalPages = items.TotalPages }; return(Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata)); }
public async Task <HttpResponseMessage> GetProducts([FromUri] ResourceParameters resourceParameters, [FromUri] ProductFilterParameters filterParameters) { filterParameters = filterParameters ?? new ProductFilterParameters(); resourceParameters = resourceParameters ?? new ResourceParameters(); if ( !_propertyMappingService.ValidMappingExistsFor <ProductEntity, Data.Sqlite.Models.ProductModel>( resourceParameters.OrderBy)) { return(Request.CreateResponse(HttpStatusCode.BadRequest, ExceptionMessageModelFactory.BadRequstOrderByParameters())); } if (!_typeHelper.TypeHasProperties <ProductForGetModel>(resourceParameters.Fields)) { return(Request.CreateResponse(HttpStatusCode.BadRequest, ExceptionMessageModelFactory.BadRequstFieldsParameters())); } var products = await _productRepository.GetProducts(resourceParameters, filterParameters); // UrlHelper requires the Request to get var pagedListHelper = new PagedListHelper(new UrlHelper(Request)); var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products); var response = Request.CreateResponse(HttpStatusCode.OK, modelResults.ShapeData(resourceParameters.Fields)); response.Headers.Add("X-Pagination", pagedListHelper.AddPaginationMetadataToResponseHeader(products, resourceParameters, filterParameters, "GetProducts")); return(response); }
public async Task <IEnumerable <Car> > GetAll(ResourceParameters parameters) { return(await _ctx.Cars .Skip(parameters.PageSize *(parameters.PageNumber - 1)) .Take(parameters.PageSize) .ToListAsync()); }
private string CreateResourceUri(ResourceParameters resourceParameters, ResourceUriType type) { switch (type) { case ResourceUriType.PreviousPage: return(_urlHelper.Link("GetFoods", new { pageNumber = resourceParameters.PageNumber - 1, pageSize = resourceParameters.PageSize })); case ResourceUriType.NextPage: return(_urlHelper.Link("GetFoods", new { pageNumber = resourceParameters.PageNumber + 1, pageSize = resourceParameters.PageSize })); default: return(_urlHelper.Link("GetFoods", new { pageNumber = resourceParameters.PageNumber, pageSize = resourceParameters.PageSize })); } }
public ActionResult <IEnumerable <Product> > GetProducts([FromQuery] ResourceParameters resourceParameters) { var products = _repository.GetProductsPage(resourceParameters); var cResourceUri = new CreateResourceUri(_urlHelper); var previousPageLink = products.HasPrevious ? cResourceUri.CreateProductResourceUri(resourceParameters, ResourceUriType.PreviousPage, "GetProducts") : null; var nextPageLink = products.HasNext ? cResourceUri.CreateProductResourceUri(resourceParameters, ResourceUriType.NextPage, "GetProducts") : null; var paginationMetadata = new { totalCount = products.TotalCount, pageSize = products.PageSize, currentPage = products.CurrentPage, totalPages = products.TotalPage, previousPageLink, nextPageLink }; Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata)); return(Ok(_mapper.Map <IList <Product>, IList <ProductViewModel> >(products))); }
public async Task <ActionResult> List([FromQuery] ResourceParameters resourceParameters) { var list = await Work.Role.GetList(resourceParameters); var previousPageLink = list.HasPrevious ? Help.CreateResourceUri(resourceParameters, ResourceUriType.PreviousPage, nameof(List)) : null; var nextPageLink = list.HasNext ? Help.CreateResourceUri(resourceParameters, ResourceUriType.NextPage, nameof(List)) : null; var paginationMetadata = new { totalCount = list.TotalCount, pageSize = list.PageSize, currentPage = list.CurrentPage, totalPages = list.TotalPages, previousPageLink, nextPageLink }; Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert .SerializeObject(paginationMetadata)); var personViews = _mapper.Map <IEnumerable <RoleDtoForReadUpdate> >(list); return(new JsonResult(personViews)); }
public async Task <ActionResult <IEnumerable <FoodDto> > > GetFoods([FromQuery] ResourceParameters resourceParameters) { var foodFromRepo = await _food.GetAllAsync(resourceParameters); var prevPageLink = foodFromRepo.HasPrevious ? CreateResourceUri(resourceParameters, ResourceUriType.PreviousPage) : null; var nextPageLink = foodFromRepo.HasNext ? CreateResourceUri(resourceParameters, ResourceUriType.NextPage) : null; var paginationMetaData = new { totalCount = foodFromRepo.TotalCount, pageSize = foodFromRepo.PageSize, currentPage = foodFromRepo.CurrentPage, totalPages = foodFromRepo.TotalPages, prevPageLink, nextPageLink }; Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetaData)); var foodDTO = _mapper.Map <IEnumerable <FoodDto> >(foodFromRepo); return(Ok(foodDTO)); }
/// <inheritdoc /> public override PagedList <Order> FindAll(ResourceParameters resourceParameters) { var sortString = resourceParameters.GetFullSortString(); var result = GetAllWithAllIncluded(); var orderParameters = (OrderResourceParameters)resourceParameters; if (orderParameters.Start.Year != 1) { result = result.Where(x => x.CreatedOn.Date >= orderParameters.Start); } if (orderParameters.End.Year != 1) { result = result.Where(x => x.CreatedOn.Date <= orderParameters.End); } if (!string.IsNullOrWhiteSpace(sortString)) { result = result.OrderBy(sortString); } var pagedList = PagedList <Order> .QueryAndCreate(result, resourceParameters.PageNumber, resourceParameters.PageSize); return(pagedList); }
public object GetAllUsers(long idUser, ResourceParameters usersResourceParameters = null) { //provera da li postoji user za svaki slucaj: var user = _uow.Users.FirstOrDefault(a => a.Id == idUser, ""); ValidationHelper.ValidateNotNull(user); if (usersResourceParameters != null) { // provera da li postoje polja za sort if (!_propertyMappingService.ValidMappingExistsFor <UserModel, User> (usersResourceParameters.OrderBy)) { throw new ValidationException($"{usersResourceParameters.OrderBy} fields for ordering do not exist!"); } //provera da li postoji properti za data shaping if (!_servicePropertyChecker.TypeHasProperties <UserModel> (usersResourceParameters.Fields)) { throw new ValidationException($"{usersResourceParameters.Fields} fields for shaping do not exist!"); } } var allUsers = _uow.Users.Find(x => x.Id != idUser, ""); //as IQueryable<User> // necemo da nam vraca nas (crr usera) if (usersResourceParameters != null) { return(generateResult(allUsers, usersResourceParameters)); } else { return(allUsers.ToList()); } }
private IEnumerable <LinkDto> CreateLinksForFriends(ResourceParameters usersResourceParameters, bool hasNext, bool hasPrevious) { var links = new List <LinkDto>(); // self links.Add( new LinkDto(CreateFriendsResourceUri( usersResourceParameters, ResourceUriType.Current) , "self", "GET")); if (hasNext) { links.Add( new LinkDto(CreateFriendsResourceUri( usersResourceParameters, ResourceUriType.NextPage), "nextPage", "GET")); } if (hasPrevious) { links.Add( new LinkDto(CreateFriendsResourceUri( usersResourceParameters, ResourceUriType.PreviousPage), "previousPage", "GET")); } return(links); }
public async Task <IActionResult> GetAllCars(ResourceParameters parameters) { var cars = await _repo.GetAll(parameters); var carsDto = _mapper.Map <IList <CarDto> >(cars); return(Ok(carsDto)); }
public async Task <ActionResult <IEnumerable <ArchiveEntry> > > List([FromQuery] ResourceParameters resourceParameters) { var entities = await _unitOfWork.ArchiveEntries.List(resourceParameters); Response.Headers.Add("X-Total-Count", entities.TotalCount.ToString()); return(Ok(entities)); }
public virtual async Task <IEnumerable <TEntity> > GetAll(ResourceParameters parameters) { var query = this.GetQueryable(); return(await query .Apply(parameters) .ToListAsync()); }