public async Task <PagingResponse <CompanyDto> > GetCompaniesAsync(CompanyParametersDto companyParameters)
{
var queryStringParam = new Dictionary <string, string>
{
["pageNumber"] = companyParameters.PageNumber.ToString(),
["pageSize"] = companyParameters.PageSize.ToString(),
["sortOrder"] = companyParameters.SortOrder.ToString(),
["filters"] = String.IsNullOrEmpty(companyParameters.Filters) ? "" : $"Name @=* {companyParameters.Filters}"
};
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync(QueryHelpers.AddQueryString(uri.ToString(), queryStringParam)))
{
if (response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
var pagingResponse = new PagingResponse <CompanyDto>
{
Items = JsonConvert.DeserializeObject <PageListCompany>(content).Companies,
Metadata = JsonConvert.DeserializeObject <MetaData>(response.Headers.GetValues("x-pagination").First())
};
pagingResponse.Filters = companyParameters.Filters;
pagingResponse.SortOrder = companyParameters.SortOrder;
return(pagingResponse);
}
return(null);
}
}
}
public async Task <IActionResult> GetCompanies([FromQuery] CompanyParametersDto companyParametersDto)
{
var companiesFromRepo = await _companyRepo.GetCompaniesAsync(companyParametersDto);
var paginationMetadata = new
{
totalCount = companiesFromRepo.MetaData.TotalCount,
pageSize = companiesFromRepo.MetaData.PageSize,
currentPageSize = companiesFromRepo.MetaData.CurrentPageSize,
currentStartIndex = companiesFromRepo.MetaData.CurrentStartIndex,
currentEndIndex = companiesFromRepo.MetaData.CurrentEndIndex,
pageNumber = companiesFromRepo.MetaData.PageNumber,
totalPages = companiesFromRepo.MetaData.TotalPages,
hasPrevious = companiesFromRepo.MetaData.HasPrevious,
hasNext = companiesFromRepo.MetaData.HasNext
};
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetadata));
var companiesDto = _mapper.Map <IEnumerable <CompanyDto> >(companiesFromRepo);
var response = new Response <IEnumerable <CompanyDto> >(companiesDto);
return(Ok(response));
}
public async Task <PageList <Company> > GetCompaniesAsync(CompanyParametersDto parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(CompanyRepository));
}
var data = _db.Company as IQueryable <Company>;
if (!string.IsNullOrWhiteSpace(parameters.CompanyName))
{
data = data.Where(m => m.Name.Equals(parameters.CompanyName));
}
if (!string.IsNullOrWhiteSpace(parameters.Search))
{
data = data.Where(m => m.Introduction.Contains(parameters.Search) ||
m.Country.Contains(parameters.Search) ||
m.Name.Contains(parameters.Search));
}
var mappingDictionary = _service.GetPropertyMapping <CompanyDto, Company>();
data = data.ApplySort(parameters.OrderBy, mappingDictionary);
return(await PageList <Company> .Create(data, parameters.PageNum, parameters.PageSize));
}
[HttpHead]//不返回body即不返回数据内容
//使用ActionResult<T>语义更准确
public async Task <IActionResult> GetCompanies([FromQuery] CompanyParametersDto parameters)
{
if (!_propertyCheckServices.HasProperty <CompanyDto>(parameters.Fields))
{
return(BadRequest());
}
//throw new Exception("error");
if (!_mappingService.ValidMappingExists <CompanyDto, Company>(parameters.OrderBy))
{
return(BadRequest());
}
var data = await _service.GetCompaniesAsync(parameters);
var companyDto = CompanyProfile.InitializeAutoMapper().Map <IEnumerable <CompanyDto> >(data);
var pageNationMetaData = new
{
data.PageSize,
currentPage = data.CurrentPage,
totalCount = data.Count,
totalPages = data.TotalPages
};
Response.Headers.Add("x-pageNation", JsonSerializer.Serialize(pageNationMetaData, new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var shapeData = companyDto.ShapeData(parameters.Fields);
var links = CreateLinksForCompany(parameters, data.HasPrevious, data.HasNext);
var shapeDataLinks = shapeData.Select(c =>
{
var companyDic = c as IDictionary <string, object>;
var link = CreateLinksForCompany((Guid)companyDic["Id"], null);
companyDic.Add("Links", link);
return(companyDic);
});
var resource = new
{
value = shapeDataLinks,
links
};
return(Ok(resource));
}
public async Task <IActionResult> Index(int page = 1, int pageSize = 10, String filters = "", String sortOrder = "")
{
ViewBag.pageSize = pageSize;
ViewBag.filter = filters;
ViewData["IdSortParm"] = sortOrder == "Id" ? "-Id" : "Id";
ViewData["NameSortParm"] = sortOrder == "Name" ? "-Name" : "Name";
CompanyParametersDto companyParameters = new CompanyParametersDto()
{
PageNumber = page,
PageSize = pageSize,
SortOrder = sortOrder,
Filters = filters
};
var pagingResponse = await _companyRepo.GetCompaniesAsync(companyParameters);
return(View(pagingResponse));
}
private IEnumerable <LinkDto> CreateLinksForCompany(CompanyParametersDto parameters, bool hasPrevious,
bool hasNext)
{
var links = new List <LinkDto>();
links.Add(new LinkDto(CreateCompaniesResourceUri(parameters, ResourceUriType.CurrentPage), "self", "Get"));
if (hasPrevious)
{
links.Add(new LinkDto(CreateCompaniesResourceUri(parameters, ResourceUriType.PreviousPage),
"previousPage", "Get"));
}
if (hasNext)
{
links.Add(new LinkDto(CreateCompaniesResourceUri(parameters, ResourceUriType.NextPage), "nextPage",
"Get"));
}
return(links);
}
private string CreateCompaniesResourceUri(CompanyParametersDto parameters, ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(Url.Link(nameof(GetCompanies), new
{
parameters.Fields,
parameters.OrderBy,
parameters.PageSize,
PageNum = parameters.PageNum - 1,
parameters.Search,
parameters.CompanyName
}));
case ResourceUriType.NextPage:
return(Url.Link(nameof(GetCompanies), new
{
parameters.Fields,
parameters.OrderBy,
parameters.PageSize,
PageNum = parameters.PageNum + 1,
parameters.Search,
parameters.CompanyName
}));
default:
return(Url.Link(nameof(GetCompanies), new
{
parameters.Fields,
parameters.OrderBy,
parameters.PageSize,
parameters.PageNum,
parameters.Search,
parameters.CompanyName
}));
}
}
public async Task <PagedList <Company> > GetCompaniesAsync(CompanyParametersDto companyParameters)
{
if (companyParameters == null)
{
throw new ArgumentNullException(nameof(companyParameters));
}
// TODO: AsNoTracking() should increase performance, but will break the sort tests. need to investigate
var collection = _context.Companies
as IQueryable <Company>;
var sieveModel = new SieveModel
{
Sorts = companyParameters.SortOrder ?? "Id",
Filters = companyParameters.Filters
};
collection = _sieveProcessor.Apply(sieveModel, collection);
return(await PagedList <Company> .CreateAsync(collection,
companyParameters.PageNumber,
companyParameters.PageSize));
}
