private IEnumerable <LinkDto> CreateLinksForCountries(
CountriesResourceParameters countriesResourceParameters,
bool hasNext, bool hasPrevious)
{
var links = new List <LinkDto>();
// self
links.Add(
new LinkDto(CreateCountriesResourceUri(countriesResourceParameters,
ResourceUriType.Current)
, "self", "GET"));
if (hasNext)
{
links.Add(
new LinkDto(CreateCountriesResourceUri(countriesResourceParameters,
ResourceUriType.NextPage),
"nextPage", "GET"));
}
if (hasPrevious)
{
links.Add(
new LinkDto(CreateCountriesResourceUri(countriesResourceParameters,
ResourceUriType.PreviousPage),
"previousPage", "GET"));
}
return(links);
}
public CountriesControllerTests()
{
_mockCountryService = new Mock <ICountryService>();
_mockCountryService.Setup(c => c.Save()).ReturnsAsync(true);
_controller = new CountriesController(_mockCountryService.Object, _mapper);
SetupTestController(_controller);
_builder = new CountryTestBuilder();
resourceParameters = new CountriesResourceParameters();
resourceParameters.Fields = "Id, Name";
}
public async Task <PagedList <Country> > FindCountries(CountriesResourceParameters resourceParameters)
{
var countries = await _unitOfWork.Countries.GetAll();
if (!string.IsNullOrEmpty(resourceParameters.Name))
{
countries = await _unitOfWork.Countries.GetAll(new CountryByName(resourceParameters.Name));
}
if (!string.IsNullOrEmpty(resourceParameters.Search))
{
countries = await _unitOfWork.Countries
.GetAll(new CountryByName(resourceParameters.Name) || new CountryBySearch(resourceParameters.Search));
}
countries = countries.OrderBy(resourceParameters.OrderBy,
PropertyMappingService.CountryPropertyMapping);
return(PagedList <Country> .Create(countries.ToList(), resourceParameters.Page, resourceParameters.PageSize));
}
private string CreateCountriesResourceUri(
CountriesResourceParameters countriesResourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(_urlHelper.Link("GetCountries",
new
{
fields = countriesResourceParameters.Fields,
orderBy = countriesResourceParameters.OrderBy,
searchQuery = countriesResourceParameters.SearchQuery,
pageNumber = countriesResourceParameters.PageNumber - 1,
pageSize = countriesResourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(_urlHelper.Link("GetCountries",
new
{
fields = countriesResourceParameters.Fields,
orderBy = countriesResourceParameters.OrderBy,
searchQuery = countriesResourceParameters.SearchQuery,
pageNumber = countriesResourceParameters.PageNumber + 1,
pageSize = countriesResourceParameters.PageSize
}));
default:
return(_urlHelper.Link("GetCountries",
new
{
fields = countriesResourceParameters.Fields,
orderBy = countriesResourceParameters.OrderBy,
searchQuery = countriesResourceParameters.SearchQuery,
pageNumber = countriesResourceParameters.PageNumber,
pageSize = countriesResourceParameters.PageSize
}));
}
}
private string CreateCountriesResourceUri(CountriesResourceParameters resourceParameters,
ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(Url.Link("GetCountries", new
{
name = resourceParameters.Name,
search = resourceParameters.Search,
orderBy = resourceParameters.OrderBy,
fields = resourceParameters.Fields,
page = resourceParameters.Page - 1,
pageSize = resourceParameters.PageSize
}));
case ResourceUriType.NextPage:
return(Url.Link("GetCountries", new
{
name = resourceParameters.Name,
search = resourceParameters.Search,
orderBy = resourceParameters.OrderBy,
fields = resourceParameters.Fields,
page = resourceParameters.Page + 1,
pageSize = resourceParameters.PageSize
}));
default:
return(Url.Link("GetCountries", new
{
name = resourceParameters.Name,
search = resourceParameters.Search,
orderBy = resourceParameters.OrderBy,
fields = resourceParameters.Fields,
page = resourceParameters.Page,
pageSize = resourceParameters.PageSize
}));
}
}
public PagedList <Country> GetCountries(CountriesResourceParameters countriesResourceParameters)
{
//var collectionBeforePaging =
// _context.Countries
// .OrderBy(c => c.Name)
// .AsQueryable();
var collectionBeforePaging =
_context.Countries
.ApplySort(countriesResourceParameters.OrderBy,
_propertyMappingService.GetPropertyMapping <CountryDto, Country>());
if (!string.IsNullOrEmpty(countriesResourceParameters.Continent))
{
// trim & ignore casing
var continentForWhereClause = countriesResourceParameters.Continent
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(c => c.Continent.ToLowerInvariant() == continentForWhereClause);
}
if (!string.IsNullOrEmpty(countriesResourceParameters.SearchQuery))
{
// trim & ignore casing
var searchQueryForWhereClause = countriesResourceParameters.SearchQuery
.Trim().ToLowerInvariant();
collectionBeforePaging = collectionBeforePaging
.Where(c => c.Name.ToLowerInvariant().Contains(searchQueryForWhereClause));
}
return(PagedList <Country> .Create(collectionBeforePaging,
countriesResourceParameters.PageNumber,
countriesResourceParameters.PageSize));
}
public IActionResult GetCountries(CountriesResourceParameters countriesResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <CountryDto, Country>
(countriesResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <CountryDto>
(countriesResourceParameters.Fields))
{
return(BadRequest());
}
var countriesFromRepo = _repository.GetCountries(countriesResourceParameters);
var countries = Mapper.Map <IEnumerable <CountryDto> >(countriesFromRepo);
var previousPageLink = countriesFromRepo.HasPrevious ?
CreateCountriesResourceUri(countriesResourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = countriesFromRepo.HasNext ?
CreateCountriesResourceUri(countriesResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = countriesFromRepo.TotalCount,
pageSize = countriesFromRepo.PageSize,
currentPage = countriesFromRepo.CurrentPage,
totalPages = countriesFromRepo.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination",
Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
var links = CreateLinksForCountries(countriesResourceParameters,
countriesFromRepo.HasNext, countriesFromRepo.HasPrevious);
var shapedCountries = countries.ShapeData(countriesResourceParameters.Fields);
var shapedCountriesWithLinks = shapedCountries.Select(author =>
{
var countryAsDictionary = author as IDictionary <string, object>;
var countryLinks = CreateLinksForCountry(
(int)countryAsDictionary["Id"], countriesResourceParameters.Fields);
countryAsDictionary.Add("links", countryLinks);
return(countryAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedCountriesWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
public async Task <IActionResult> GetCountries(CountriesResourceParameters resourceParameters,
[FromHeader(Name = "Accept")] string mediaType)
{
if (!PropertyMappingService.ValidMappingExistsFor <Country>(resourceParameters.OrderBy))
{
return(BadRequest());
}
if (!TypeHelper.TypeHasProperties <CountryDto>(resourceParameters.Fields))
{
return(BadRequest());
}
var retrievedCountries = await _countryService.FindCountries(resourceParameters);
var countries = _mapper.Map <IEnumerable <CountryDto> >(retrievedCountries);
var shapedCountries = countries.ShapeData(resourceParameters.Fields);
if (mediaType == "application/json+hateoas")
{
if (!string.IsNullOrEmpty(resourceParameters.Fields) &&
!resourceParameters.Fields.ToLowerInvariant().Contains("id"))
{
return(BadRequest("Field parameter 'id' is required"));
}
var paginationMetadata = new
{
totalCount = retrievedCountries.TotalCount,
pageSize = retrievedCountries.PageSize,
currentPage = retrievedCountries.CurrentPage,
totalPages = retrievedCountries.TotalPages
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
var links = CreateCountriesLinks(resourceParameters,
retrievedCountries.HasNext, retrievedCountries.HasPrevious);
var linkedCountries = shapedCountries.Select(country =>
{
var countryAsDictionary = country as IDictionary <string, object>;
var countryLinks = CreateCountryLinks((Guid)countryAsDictionary["Id"],
resourceParameters.Fields);
countryAsDictionary.Add("links", countryLinks);
return(countryAsDictionary);
});
var linkedCollectionResource = new LinkedCollectionResource
{
Value = linkedCountries,
Links = links
};
return(Ok(linkedCollectionResource));
}
else
{
var previousPageLink = retrievedCountries.HasPrevious ?
CreateCountriesResourceUri(resourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = retrievedCountries.HasNext ?
CreateCountriesResourceUri(resourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = retrievedCountries.TotalCount,
pageSize = retrievedCountries.PageSize,
currentPage = retrievedCountries.CurrentPage,
totalPages = retrievedCountries.TotalPages,
previousPageLink,
nextPageLink,
};
Response.Headers.Add("X-Pagination",
JsonConvert.SerializeObject(paginationMetadata));
return(Ok(shapedCountries));
}
}
public CountryServiceTests()
{
_countryService = new CountryService(_unitOfWork);
resourceParameters = new CountriesResourceParameters();
}
