private string CreateLink(CompaniesResourceParameters companiesResourceParameters,
ResourceUriLinkType resourceUriLinkType)
{
switch (resourceUriLinkType)
{
case ResourceUriLinkType.NextPage:
return(Url.Link("GetCompanies",
new CompaniesResourceParameters
{
PageSize = companiesResourceParameters.PageSize,
PageNumber = companiesResourceParameters.PageNumber + 1,
SearchQuery = companiesResourceParameters.SearchQuery
}));
case ResourceUriLinkType.PreviousPage:
return(Url.Link("GetCompanies", new CompaniesResourceParameters()
{
PageSize = companiesResourceParameters.PageSize,
PageNumber = companiesResourceParameters.PageNumber - 1,
SearchQuery = companiesResourceParameters.SearchQuery
}));
default:
return(Url.Link("GetCompanies", companiesResourceParameters));
}
}
private IEnumerable <LinkDto> CreateLinks(
CompaniesResourceParameters companiesResourceParameters,
bool hasNextPage,
bool hasPreviousPage)
{
var links = new List <LinkDto>();
links.Add(
new LinkDto(
href: CreateResourceUri(companiesResourceParameters, ResourceUriType.Current),
rel: "self",
method: "GET"));
if (hasNextPage)
{
links.Add(
new LinkDto(
href: CreateResourceUri(companiesResourceParameters, ResourceUriType.Current),
rel: "nextPage",
method: "GET"));
}
if (hasPreviousPage)
{
links.Add(
new LinkDto(
href: CreateResourceUri(companiesResourceParameters, ResourceUriType.Current),
rel: "previousPage",
method: "GET"));
}
return(links);
}
//public IEnumerable<Recruiter> GetCompanies(IEnumerable<Guid> companyIds)
//{
// if (companyIds == null)
// {
// throw new ArgumentNullException(nameof(companyIds));
// }
// return _context.Recruiters.Where(a => companyIds.Contains(a.Id));
//}
public async Task <IPagedList <Company> > GetCompaniesAsync(CompaniesResourceParameters companiesResourceParameters)
{
if (companiesResourceParameters == null)
{
throw new ArgumentNullException(nameof(companiesResourceParameters));
}
var collection = _context.Companies as IQueryable <Company>;
var name = companiesResourceParameters.Name;
if (name != null)
{
collection = collection.Where(a => a.Name == name);
}
var hqCity = companiesResourceParameters.HqCity;
if (hqCity != null)
{
collection = collection.Where(a => a.HqCity == hqCity);
}
var hqCountry = companiesResourceParameters.HqCountry;
if (hqCountry != null)
{
collection = collection.Where(a => a.HqCountry == hqCountry);
}
var category = companiesResourceParameters.Category;
if (category != null)
{
collection = collection.Where(a => a.Category.ToString() == category);
}
if (!string.IsNullOrWhiteSpace(companiesResourceParameters.SearchQuery))
{
var searchQuery = companiesResourceParameters.SearchQuery.Trim();
collection = collection.Where(a => a.Name.ToLower().Contains(searchQuery.ToLower()));
}
if (!string.IsNullOrWhiteSpace(companiesResourceParameters.OrderBy))
{
// get property mapping dictionary
var companyMappingDictionary = _propertyMappingService.GetPropertyMapping <CompanyDto, Company>();
collection = collection.ApplySort(companiesResourceParameters.OrderBy, companyMappingDictionary);
}
return(await Utils.PagedList <Company> .Create(collection, companiesResourceParameters.PageNumber, companiesResourceParameters.PageSize));
}
private string CreateResourceUri(CompaniesResourceParameters companiesResourceParameters, ResourceUriType resourceUriType)
{
switch (resourceUriType)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link(
routeName:
"GetCompanies",
values:
new
{
fields = companiesResourceParameters.Fields,
orderBy = companiesResourceParameters.OrderBy,
searchQuery = companiesResourceParameters.SearchQuery,
location = companiesResourceParameters.Location,
pageNumber = companiesResourceParameters.PageNumber - 1,
pageSize = companiesResourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(_urlHelper.Link(
routeName:
"GetCompanies",
values:
new
{
fields = companiesResourceParameters.Fields,
orderBy = companiesResourceParameters.OrderBy,
searchQuery = companiesResourceParameters.SearchQuery,
location = companiesResourceParameters.Location,
pageNumber = companiesResourceParameters.PageNumber + 1,
pageSize = companiesResourceParameters.PageSize
}));
case ResourceUriType.Current:
default:
return(_urlHelper.Link(
routeName:
"GetCompanies",
values:
new
{
fields = companiesResourceParameters.Fields,
orderBy = companiesResourceParameters.OrderBy,
searchQuery = companiesResourceParameters.SearchQuery,
location = companiesResourceParameters.Location,
pageNumber = companiesResourceParameters.PageNumber,
pageSize = companiesResourceParameters.PageSize
}));
}
}
public ActionResult <IEnumerable <CompanyDto> > GetCompanies
([FromQuery] CompaniesResourceParameters companiesResourceParameters)
{
var companiesFromRepo = jobRepository.GetCompanies(companiesResourceParameters);
var previousLink = companiesFromRepo.HasPrevious
? CreateLink(companiesResourceParameters, ResourceUriLinkType.PreviousPage) : null;
var nextLink = companiesFromRepo.HasNext ? CreateLink(companiesResourceParameters,
ResourceUriLinkType.NextPage) : null;
var metadataObj = new
{
pageSize = companiesFromRepo.PageSize,
pageNo = companiesFromRepo.CurrentPage,
previousLink,
nextLink,
totalCount = companiesFromRepo.Count,
totalPages = companiesFromRepo.TotalPages
};
Response.Headers.Add("x-pagination", JsonSerializer.Serialize(metadataObj));
return(Ok(mapper.Map <IEnumerable <CompanyDto> >(companiesFromRepo)));
}
public PagedList <Company> GetCompanies(CompaniesResourceParameters companiesResourceParameters)
{
var mappingDictionary = _propertyMappingService.GetPropertyMapping <CompanyDto, Company>();
// Apply sort to collection using a custom ApplySort extension on IQueryable.
var collection = _repositoryContext.Companies.ApplySort(
companiesResourceParameters.OrderBy,
mappingDictionary);
// Filtering
if (!string.IsNullOrEmpty(companiesResourceParameters.Name))
{
string nameFilter = companiesResourceParameters.Name.Trim().ToLowerInvariant();
collection = collection.Where(company => company.Name.ToLowerInvariant() == nameFilter);
}
// Filtering on location (v3)
if (!string.IsNullOrEmpty(companiesResourceParameters.Location))
{
string locationFilter = companiesResourceParameters.Location.Trim().ToLowerInvariant();
collection = collection.Where(company => company.Location.ToLowerInvariant() == locationFilter);
}
// Searching (simple hard-coded implementation). Could use Lucene?
if (!string.IsNullOrEmpty(companiesResourceParameters.SearchQuery))
{
string searchQuery = companiesResourceParameters.SearchQuery.Trim().ToLowerInvariant();
collection = collection.Where(a => a.Name.ToLowerInvariant().Contains(searchQuery));
}
// Paging
return(PagedList <Company> .Create(
source : collection,
pageNumber : companiesResourceParameters.PageNumber,
pageSize : companiesResourceParameters.PageSize));
}
public PagedList <Company> GetCompanies(CompaniesResourceParameters companiesResourceParameters)
{
if (companiesResourceParameters == null)
{
throw new ArgumentNullException(nameof(CompaniesResourceParameters));
}
var collection = context.Companies as IQueryable <Company>;
if (!string.IsNullOrEmpty(companiesResourceParameters.SearchQuery))
{
var searchQuery = companiesResourceParameters.SearchQuery.Trim();
collection = collection.Where(i => i.Name.Contains(searchQuery) ||
i.Activity.Contains(searchQuery));
}
//if (!string.IsNullOrEmpty(companiesResourceParameters.OrderBy))
//{
// collection.Sort<Company>(companiesResourceParameters.)
//}
return(PagedList <Company> .Create(collection, companiesResourceParameters.PageSize, companiesResourceParameters.PageNumber));
}
public async Task <IActionResult> GetCompanies([FromQuery] CompaniesResourceParameters companiesResourceParameters, [FromHeader(Name = "Accept")] string mediaType)
{
if (!MediaTypeHeaderValue.TryParse(mediaType, out MediaTypeHeaderValue parsedMediaType))
{
_logger.LogInformation($"Media type header value [{mediaType}] not parsable");
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <CompanyDto>(companiesResourceParameters.Fields))
{
_logger.LogInformation($"Property checker did not find on of the Company resource parameters fields");
return(BadRequest());
}
if (!_propertyMappingService.ValidMappingExistsFor <CompanyDto, Company>
(companiesResourceParameters.OrderBy))
{
return(BadRequest());
}
var companiesFromRepo = await _repository.GetCompaniesAsync(companiesResourceParameters);
return(Ok(companiesFromRepo));
}
[HttpHead] // Provide response headers without payload to allow consumer test calls
public IActionResult GetCompanies(
CompaniesResourceParameters companiesResourceParameters,
[FromHeader(Name = "Accept")] string mediaType) // Support custom media-type to support HATEOAS
{
if (!_propertyMappingService.ValidMappingExistsFor <CompanyDto, Company>(companiesResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <CompanyDto>(companiesResourceParameters.Fields))
{
return(BadRequest());
}
PagedList <Company> companies = _repository.GetCompanies(companiesResourceParameters);
var companyDtos = AutoMapper.Mapper.Map <IEnumerable <CompanyDto> >(companies);
if (mediaType == "application/vnd.marvin.hateoas+json")
{
var paginationMetadata = new
{
totalCount = companies.TotalCount,
pageSize = companies.PageSize,
currentPage = companies.CurrentPage,
totalPages = companies.TotalPages
};
Response.Headers.Add(
key: "X-Pagination",
value: JsonConvert.SerializeObject(paginationMetadata));
IEnumerable <LinkDto> linkDtos = CreateLinks(
companiesResourceParameters: companiesResourceParameters,
hasNextPage: companies.HasNextPage,
hasPreviousPage: companies.HasPreviousPage);
IEnumerable <ExpandoObject> dataShapedCompanyDtos = companyDtos.ShapeData(companiesResourceParameters.Fields);
var dataShapedCompanyDtosWithLinks = dataShapedCompanyDtos.Select(
companyDto =>
{
var companyDtoAsDictionary = companyDto as IDictionary <string, object>;
var companyLinks = CreateLinks(
id: (Guid)companyDtoAsDictionary["Id"],
fields: companiesResourceParameters.Fields);
companyDtoAsDictionary.Add("links", companyLinks);
return(companyDtoAsDictionary);
});
var linkedCollectionResource = new
{
value = dataShapedCompanyDtosWithLinks,
links = linkDtos
};
return(Ok(linkedCollectionResource));
}
else
{
var previousPageLink = companies.HasPreviousPage
? CreateResourceUri(companiesResourceParameters, ResourceUriType.PreviousPage)
: null;
var nextPageLink = companies.HasNextPage
? CreateResourceUri(companiesResourceParameters, ResourceUriType.NextPage)
: null;
var paginationMetadata = new
{
totalCount = companies.TotalCount,
pageSize = companies.PageSize,
currentPage = companies.CurrentPage,
totalPages = companies.TotalPages,
previousPageLink = previousPageLink,
nextPageLink = nextPageLink
};
Response.Headers.Add(
key: "X-Pagination",
value: JsonConvert.SerializeObject(paginationMetadata));
return(Ok(companyDtos.ShapeData(companiesResourceParameters.Fields)));
}
}
