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());
}
