public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Entities.Author>(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _courseLibraryRepository.GetAuthors(authorsResourceParameters);
var previousPageLink = authorsFromRepo.HasPrevious ?
CreateAuthorsResourceUri(authorsResourceParameters, ResourceUriType.PreviousPage) : null;
var nextPageLink = authorsFromRepo.HasNext ?
CreateAuthorsResourceUri(authorsResourceParameters, ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));
return(Ok(_mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo).ShapeData(authorsResourceParameters.Fields)));
}
public IActionResult GetDogs([FromQuery] DogsResourceParameters parameters, [FromHeader(Name = "Accept")] string mediaType)
{
if (!MediaTypeHeaderValue.TryParse(mediaType, out MediaTypeHeaderValue parsedMediaType))
{
return(BadRequest());
}
if (!_propertyMappingService.ValidMappingExistsFor <DogDto, Dog>(parameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <DogDto>(parameters.Fields))
{
return(BadRequest());
}
var dogsFromRepo = _dogRepository.GetAllDogs(parameters);
Response.AddPagination(dogsFromRepo.TotalCount, dogsFromRepo.PageSize, dogsFromRepo.CurrentPage,
dogsFromRepo.TotalPages, null, null);
if (parsedMediaType.MediaType == "application/vnd.marvin.hateoas+json")
{
var linkedCollectionResource = GetLinkedCollectionResource(parameters, dogsFromRepo);
return(Ok(linkedCollectionResource));
}
return(Ok(_mapper.Map <IEnumerable <DogDto> >(dogsFromRepo).ShapeData(parameters.Fields)));
}
public async Task <IActionResult> GetCompanies([FromQuery] CompanyDtoParameters parameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <CompanyDto, Company>(parameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <CompanyDto>(parameters.Fields))
{
return(BadRequest());
}
var companies = await _companyRepository.GetCompaniesAsync(parameters);
//var previousPageLink = companies.HasPrevious
// ? CreateCompaniesResourceUri(parameters, ResourceUriType.PreviousPage)
// : null;
//var nextPageLink = companies.HasNext ?
// CreateCompaniesResourceUri(parameters, ResourceUriType.NextPage)
// : null;
var paginationMetadata = new
{
totalCount = companies.TotalCount,
pageSize = companies.PageSize,
currentPage = companies.CurrentPage,
totalPages = companies.TotalPages,
//previousPageLink,
//nextPageLink
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata,
new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var companyDtos = _mapper.Map <IEnumerable <CompanyDto> >(companies);
var shapedData = companyDtos.ShapeData(parameters.Fields);
var links = CreateLinksForCompany(parameters, companies.HasPrevious, companies.HasNext);
var shapedCompaniesWithLinks = shapedData.Select(c =>
{
var companyDict = c as IDictionary <string, object>;
var companyLinks = CreateLinksForCompany((Guid)companyDict["Id"], null);
companyDict.Add("links", companyLinks);
return(companyDict);
});
var linkedCollectionResource = new
{
value = shapedCompaniesWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
[HttpHead] //支持head
public async Task <IActionResult> GetCompanies([FromQuery] CompanyDtoParameters companyDtoParameters)
{
//验证http://localhost:5000/api/companies?orderBy=name参数 name是不符合的
if (!_mappingService.ValidMappingExistsFor <CompanyDto, Company>(companyDtoParameters.OrderBy))
{
//http://localhost:5000/api/companies/5efc910b-2f45-43df-afae-620d40542822?fields=id,name 解决请求CompanyDto有无name属性
return(BadRequest());
}
if (!_checkerService.TypeHasProperties <CompanyDto>(companyDtoParameters.Fields))
{
return(BadRequest());
}
//指定[FromQuery]可自动解析
//对异常处理 不可这样做
// throw new Exception("An Exception");
//get 请求数据所以需要Dto
//ActionResult<List<CompanyDto>> 在此可以替代IActionResult
var companiess = await _companyRepository.GetCompaniesAsync(companyDtoParameters);
// var previousPageLink = companiess.HasPrevious ? CreateCompaniesResourceUri(companyDtoParameters, ResourceUriType.PreviousPage) : null;
// var nextPageLink = companiess.HasNext ? CreateCompaniesResourceUri(companyDtoParameters, ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = companiess.TotalCount,
pageSize = companiess.PageSize,
currentPage = companiess.CurrentPage,
totalPages = companiess.TotalPages,
// previousPageLink,
// nextPageLink
};
Response.Headers.Add("X-Pagination", System.Text.Json.JsonSerializer.Serialize(paginationMetadata, new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var links = CreateLinksForCiampany(companyDtoParameters, companiess.HasPrevious, companiess.HasNext);
var companiessdto = _mapper.Map <IEnumerable <CompanyDto> >(companiess);
var shapeddata = companiessdto.ShapeData(companyDtoParameters.Fields);
var shapedCompaniesWithLinks = shapeddata.Select(c =>
{
var comoanydict = c as IDictionary <string, object>;
var companylinks = CreateLinksForCiampany((Guid)comoanydict["Id"], null);
comoanydict.Add("links", companylinks);
return(comoanydict);
});
var linksCollectionResource = new
{
value = shapedCompaniesWithLinks,
links
};
return(Ok(linksCollectionResource));
}
public async Task <IActionResult> GetRecruiter(Guid recruiterId, string fields, [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 <ExtendedUserDto>(fields))
{
return(BadRequest());
}
var recruiterFromRepo = await _repository.GetExtendedUserAsync(recruiterId);
if (recruiterFromRepo == null)
{
_logger.LogInformation($"Recruiter with id [{recruiterId}] wasn't found when GetRecruiter");
return(NotFound());
}
else
{
return(Ok(recruiterFromRepo));
}
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Entities.Author>
(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>
(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _courseLibraryRepository.GetAuthors(authorsResourceParameters);
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetadata));
var authorsToReturn = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo).ShapeData(authorsResourceParameters.Fields);
return(Ok(authorsToReturn));
}
public async Task <IActionResult> GetCompanies([FromQuery] CompanyDtoParameters parameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <CompanyDto, Company>(parameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <CompanyDto>(parameters.Fields))
{
return(BadRequest());
}
var companies = await _companyRepository.GetCompaniesAsync(parameters);
var paginationMetadata = new
{
totalCount = companies.TotalCount,
pageSize = companies.PageSize,
currentPage = companies.CurrentPage,
totalPages = companies.TotalPages
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata,
new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var companyDtos = _mapper.Map <IEnumerable <CompanyDto> >(companies);
var shapedData = companyDtos.ShapeData(parameters.Fields);
return(Ok(shapedData));
}
public async Task <IActionResult> GetTechJobOpening(Guid techJobOpeningId, string fields, [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 <TechJobOpeningDto>(fields))
{
return(BadRequest());
}
var techJobOpeningFromRepo = await _repository.GetTechJobOpeningAsync(techJobOpeningId);
if (techJobOpeningFromRepo == null)
{
_logger.LogInformation($"TechJobOpening with id [{techJobOpeningId}] wasn't found when GetTechJobOpening");
return(NotFound());
}
else
{
return(Ok(techJobOpeningFromRepo));
}
}
public IActionResult GetAuthors([FromQuery] AuthorResourceParameters authorsResourceParameters)
{
if (!_propertyCheck.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var x = _manager.GetAuthors(authorsResourceParameters);
if (x == null)
{
return(NotFound());
}
var links = CreateLinksForAuthors(authorsResourceParameters, x.HasNext, x.HasPrevious);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(x).ShapeData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary["Id"], null);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var LinkedCollectionResource = new
{
value = shapedAuthorsWithLinks,
links
};
return(Ok(LinkedCollectionResource));
}
public async Task <IActionResult> GetUserPost(int userPostId, string fields,
[FromHeader(Name = "Accept")] string mediaType)
{
// we will not return another type
if (!MediaTypeHeaderValue.TryParse(mediaType,
out MediaTypeHeaderValue parsedMediaType))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <UserPostDto>(fields))
{
return(BadRequest());
}
var userPostFromRepo = await Mediator.Send(new GetUserPostByIdQuery(userPostId));
if (userPostFromRepo == null)
{
return(NotFound());
}
//Check whether parsedMediaType contains hateoas
var includeLinks = parsedMediaType.SubTypeWithoutSuffix
.EndsWith("hateoas", StringComparison.InvariantCultureIgnoreCase);
IEnumerable <LinkDto> links = new List <LinkDto>();
var shapedUserPost = _mapper.Map <UserPostDto>(userPostFromRepo).ShapeData(fields) as IDictionary <string, object>;
if (includeLinks)
{
links = CreateLinksForUserPost(userPostId, fields);
shapedUserPost.Add("links", links);
}
return(Ok(shapedUserPost));
//var resourceToReturn = new {
// value=
//}
//we pass .hateoas to identify that what is accepted type. full or friendly
//var primaryMediaType = includeLinks ?
// parsedMediaType.SubTypeWithoutSuffix
// .Substring(0, parsedMediaType.SubTypeWithoutSuffix.Length - 8)
// : parsedMediaType.SubTypeWithoutSuffix;
//if(primaryMediaType == "vnd.marvin.userpos.full") {
// // i will return here userpost owner name and surname as Fulllname
// // else just send the userpost data
// var fullResourceToReturn = _mapper.Map<AuthorFullDto>(authorFromRepo)
// .ShapeData(fields) as IDictionary<string, object>;
//}
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters parameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>(parameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>(parameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _repository.GetAuthors(parameters);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo).ShapeData(parameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var dictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)dictionary["Id"]);
dictionary.Add("links", authorLinks);
return(dictionary);
});
var links = CreateLinksForAuthors(parameters, authorsFromRepo.HasNext, authorsFromRepo.HasPrevious);
var linkedCollectionResource = new { value = shapedAuthorsWithLinks, links };
AddPaginationMetaDataToHeader(authorsFromRepo);
return(Ok(linkedCollectionResource));
}
public async Task <IActionResult> GetBlog(int blogId, string fields, [FromHeader(Name = "Accept")] string mediaType)
{
if (!MediaTypeHeaderValue.TryParse(mediaType, out MediaTypeHeaderValue parsedMediaType))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <BlogDto>(fields))
{
return(BadRequest());
}
var includeLinks = parsedMediaType.SubTypeWithoutSuffix.
EndsWith("hateoas", System.StringComparison.InvariantCultureIgnoreCase);
IEnumerable <LinkDto> myLinks = new List <LinkDto>();
if (includeLinks)
{
myLinks = CreateLinksForBlogs(blogId, fields);
}
var primaryMediaType = includeLinks
? parsedMediaType.SubTypeWithoutSuffix.Substring(0, parsedMediaType.SubTypeWithoutSuffix.Length - 8)
: parsedMediaType.SubTypeWithoutSuffix;
if (primaryMediaType == "vnd.wuther.blogs.full")
{
var blog = await _blogsRepository.GetBlogAsync(blogId);
if (blog == null)
{
return(NotFound());
}
var full = _mapper.Map <Blogs, BlogFullDto>(blog);
var fullDic = full.ShapeData(fields) as IDictionary <string, object>;
if (includeLinks)
{
fullDic.Add("links", myLinks);
}
return(Ok(full));
}
else
{
var blog = await _blogsRepository.FindAsync(blogId);
if (blog == null)
{
return(NotFound());
}
var friendly = _mapper.Map <BlogDto>(blog).ShapeData(fields) as IDictionary <string, object>;
if (includeLinks)
{
friendly.Add("links", myLinks);
}
return(Ok(friendly));
}
}
public IActionResult GetEvents([FromQuery] EventsResourceParameters eventsResourceParameters, [FromHeader(Name = "Accept")] string mediaType)
{
if (!MediaTypeHeaderValue.TryParse(mediaType, out MediaTypeHeaderValue parsedMediaType))
{
return(BadRequest(new
{
message = "Accept header mediaType is not allowed"
}));
}
if (!_propertyMappingService.ValidMappingExistsFor <EventDto, Event> (eventsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <EventDto> (eventsResourceParameters.Fields))
{
return(BadRequest());
}
var events = _eventRepository.GetEvents(eventsResourceParameters);
var paginationMetadata = new
{
totalCount = events.TotalCount,
pageSize = events.PageSize,
currentPage = events.CurrentPage,
totalPages = events.TotalPages
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForEvents(eventsResourceParameters, events.HasNext, events.HasPrevious);
var shapeEvents = _mapper.Map <IEnumerable <EventDto> > (events).ShapeData(eventsResourceParameters.Fields);
if (parsedMediaType.MediaType == "application/vnd.marvin.hateoas+json")
{
var shapeEventsWithLinks = shapeEvents.Select(evt =>
{
var eventAsDictionary = evt as IDictionary <string, object>;
var eventLinks = CreateLinksForEvent((Guid)eventAsDictionary["Id"], null);
eventAsDictionary.Add("links", eventLinks);
return(eventAsDictionary);
});
var linkedCollectionResource = new
{
value = shapeEventsWithLinks,
links,
};
return(Ok(linkedCollectionResource));
}
return(Ok(shapeEvents));
}
[HttpHead] //添加对 Http Head 的支持，Head 请求只会返回 Header 信息，没有 Body（视频P16）
public async Task <IActionResult> GetCompanies([FromQuery] CompanyDtoParameters parameters)
{
//判断Uri query 字符串中的 orderby 是否合法（视频P38）
if (!_propertyMappingService.ValidMappingExistsFor <CompanyDto, Company>(parameters.OrderBy))
{
return(BadRequest()); //返回状态码400
}
//判断Uri query 字符串中的 fields 是否合法（视频P39）
if (!_propertyCheckerService.TypeHasProperties <CompanyDto>(parameters.Fields))
{
return(BadRequest()); //返回状态码400
}
//GetCompaniesAsync(parameters) 返回的是经过翻页处理的 PagedList<T>（视频P35）
var companies = await _companyRepository.GetCompaniesAsync(parameters);
//向 Header 中添加翻页信息（视频P35）
//上一页的 URI
var previousPageLink = companies.HasPrevious
? CreateCompaniesResourceUri(parameters, ResourceUnType.PreviousPage)
: null;
//下一页的 URI
var nextPageLink = companies.HasNext
? CreateCompaniesResourceUri(parameters, ResourceUnType.NextPage)
: null;
var paginationMetdata = new
{
totalCount = companies.TotalCount,
pageSize = companies.PageSize,
currentPage = companies.CurrentPage,
totalPages = companies.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetdata,
new JsonSerializerOptions //URI 中的‘&’、‘？’符号不应该被转义，因此改用不安全的 Encoder
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
//不使用 AutoMapper
//var companyDtos = new List<CompanyDto>();
//foreach(var company in companies)
//{
// companyDtos.Add(new CompanyDto
// {
// Id = company.Id,
// Name = company.Name
// });
//}
//
//使用 AutoMapper（视频P12）
var companyDtos = _mapper.Map <IEnumerable <CompanyDto> >(companies);
return(Ok(companyDtos.ShapeData(parameters.Fields))); //OK() 返回状态码200
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _courseLibraryRepository.GetAuthors(authorsResourceParameters);
if (authorsFromRepo == null)
{
return(NotFound());
}
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
// serializar so metadados
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForAuthors(authorsResourceParameters,
authorsFromRepo.HasNext,
authorsFromRepo.HasPrevious);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo)
.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary["Id"], null);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedAuthorsWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
// IActionResult - Defines an action return contract. Returns the result of an action method.
// The ActionResult types represent various HTTP status codes.
public async Task <IActionResult> GetAuthorsAsync(
// Complex type AuthorsResourceParameters requires a [FromQuery] attribute
// - else will result in 415 SC
[FromQuery] AuthorsResourceParameters resourceParameters)
{
// Validate incoming orderBy, if present
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>(resourceParameters.OrderBy))
{
// Return http 400 sc -bad request
return(BadRequest());
}
// Check data shaping fields. if present, are valid properties
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>(resourceParameters.Fields))
{
return(BadRequest());
}
var authors = await _authorLibraryRepository.GetAuthorsAsync(resourceParameters);
var paginationMetaData = new
{
totalCount = authors.TotalCount,
pageSize = authors.PageSize,
currentPage = authors.CurrentPage,
totalPages = authors.TotalPages,
};
// Add to header. Note: doesn't have to be JSON
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetaData));
var links = CreateLinksForAuthors(resourceParameters, authors.HasNext, authors.HasPrevious);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(authors)
.ShapeData(resourceParameters.Fields);
// create authors (collection) for return with HATEOAS support
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary["Id"]);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedAuthorsWithLinks,
links
};
// returns a http status code 200 - ok.
// Ok - allows for different payload types - content negotiation
return(Ok(linkedCollectionResource));
}
//FromQuery是重点,正常如果不指定fromquery就会报错
public async Task <IActionResult> GetCompanies([FromQuery] CompanyDtoParameters parameters)
{
if (!_propertyMappingService.ValidMappingExistFor <CompanyDto, Company>(parameters.OrderBy) ||
!_propertyCheckerService.TypeHasProperties <CompanyDto>(parameters.Fields))
{
return(BadRequest());
}
var companies = await _companyRepository.GetCompaniesAsync(parameters);
//var previousPageLink = companies.HasPrevious ?
// CreateCompaniesResourceUri(parameters, ResourceUriType.PreviousPage)
// : null;
//var nextPageLink = companies.HasNext ?
// CreateCompaniesResourceUri(parameters, ResourceUriType.NextPage)
// : null;
var oaginationMetadata = new
{
totalCount = companies.TotalCount,
totalPages = companies.TotalPages,
pageSize = companies.PageSize,
currentPage = companies.CurrentPage,
//previousPageLink,
//nextPageLink
};
//自定义header 返回分页数据, 因为如果在OK体内返回其他信息不符合Restful api的设计原则.
//方法是GetCompanies,应该只返回companies的数据,而不应该包含其他额外数据,额外数据应该通过自定义header返回.
Response.Headers.Add("X-Pagination", System.Text.Json.JsonSerializer.Serialize(oaginationMetadata, new System.Text.Json.JsonSerializerOptions
{
//http web 默认会将一些字符转义,保护url,添加此属性不会将&符号转义.
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var companyDtos = _mapper.Map <IEnumerable <CompanyDto> >(companies);
var shapedData = companyDtos.ShapeData(parameters.Fields);
var links = CreateLinksForCompany(parameters, companies.HasPrevious, companies.HasNext);
var shapedCompaniesWithLinks = shapedData.Select(a =>
{
var companyDic = a as IDictionary <string, object>;
var companyLinks = CreateLinksForCompany((Guid)companyDic["Id"], null);
companyDic.Add("links", companyLinks);
return(companyDic);
});
var linkedCollectionResource = new
{
value = shapedCompaniesWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
public ActionResult <IEnumerable <AuthorDto> > GetAuthors(
[FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, CourseLibrary.API.Entities.Author>
(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>
(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _courseLibraryRepository.GetAuthors(authorsResourceParameters);
var previousPageLink = authorsFromRepo.HasPrevious ?
CreateAuthorsResourceUri(authorsResourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = authorsFromRepo.HasNext ?
CreateAuthorsResourceUri(authorsResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForAuthors(authorsResourceParameters);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo)
.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary[])
});
return(Ok(_mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo)
.ShapeData(authorsResourceParameters.Fields)));
}
public async Task <ActionResult <IEnumerable <AuthorDto> > > GetAuthors(
[FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!string.IsNullOrWhiteSpace(authorsResourceParameters.Fields) &&
!authorsResourceParameters.Fields.Split(",").Contains("id"))
{
return(BadRequest($"Id field is required in {authorsResourceParameters.Fields}."));
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest($"No field with the name {authorsResourceParameters.Fields} was found."));
}
var authorsFromRepo = await _messages.Dispatch(new GetAuthorsListQuery(authorsResourceParameters.MainCategory,
authorsResourceParameters.PageNumber, authorsResourceParameters.PageSize));
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForAuthors(authorsResourceParameters,
authorsFromRepo.HasNext,
authorsFromRepo.HasPrevious);
var shapedAuthors = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo)
.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((long)authorAsDictionary["Id"], null);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedAuthorsWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
public async Task <IActionResult> GetBooksForAuthor(long authorId,
[FromQuery] BooksResourceParameters booksResourceParameters)
{
if (!_propertyCheckerService.TypeHasProperties <BookDto>(booksResourceParameters.Fields))
{
return(BadRequest($"No field with the name {booksResourceParameters.Fields} was found."));
}
var author = await _messages.Dispatch(new GetAuthorQuery(authorId));
if (author is null)
{
return(NotFound($"No author with id {authorId} was found."));
}
var books = await _messages.Dispatch(new GetBooksListQuery(authorId,
booksResourceParameters.SearchTitle, booksResourceParameters.PageNumber,
booksResourceParameters.PageSize));
var paginationMetadata = new
{
totalCount = books.TotalCount,
pageSize = books.PageSize,
currentPage = books.CurrentPage,
totalPages = books.TotalPages
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForBooks(booksResourceParameters, books.HasNext, books.HasPrevious);
var shapedBooks = _mapper.Map <IEnumerable <BookDto> >(books)
.ShapeData(booksResourceParameters.Fields);
var shapedBooksWithLinks = shapedBooks.Select(book =>
{
var bookAsDictionary = book as IDictionary <string, object>;
var bookLinks = CreateLinksForBook((long)bookAsDictionary["AuthorId"], (long)bookAsDictionary["Id"], null);
bookAsDictionary.Add("links", bookLinks);
return(bookAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedBooksWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
//[ResponseCache(Duration = 0)]
public IActionResult GetContactsList(
[FromQuery] ContactsResourceParameters contactsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <ContactDto, Contact>
(contactsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <Contact>
(contactsResourceParameters.Fields))
{
return(BadRequest());
}
var ContactsFromRepo = _contactRepo.GetContacts(contactsResourceParameters);
var paginationMetaData = new
{
totalCount = ContactsFromRepo.TotalCount,
pageSize = ContactsFromRepo.PageSize,
currentPage = ContactsFromRepo.CurrentPage,
totalPages = ContactsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetaData));
var links = CreateLinksForContacts(contactsResourceParameters,
ContactsFromRepo.HasNext, ContactsFromRepo.HasPrevious);
var shapedContacts = ContactsFromRepo.ShapeDatas(contactsResourceParameters.Fields);
var shapedContactsWithLinks = shapedContacts.Select(contact =>
{
var contactAsDictionary = contact as IDictionary <string, object>;
//var contactLinks = CreateLinksForContact((int)contactAsDictionary["Id"], null);
//contactAsDictionary.Add("links", contactLinks);
return(contactAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedContactsWithLinks,
links
};
return(Ok(shapedContacts));
}
public IActionResult GetAll([FromQuery] GetResources getResources)
{
if (!_propertyMappingService.ValidMappingExistsFor <Resource, ResourceDto>(getResources.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <ResourceDto>(getResources.Fields))
{
return(BadRequest());
}
var resources = _repository.GetAll(getResources.PageNumber, getResources.PageSize, getResources.OrderBy);
var dtos = resources.Select(r => new ResourceDto
{
Id = r.Id,
Name = $"{r.FirstName} {r.LastName}",
Age = DateTime.Now.Year - r.DateOfBirth.Year
});
var paginationMetadata = new
{
totalCount = resources.TotalCount,
pageSize = resources.PageSize,
currentPage = resources.CurrentPage,
totalPages = resources.TotalPages
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata));
var shapedResources = dtos.ShapeData(getResources.Fields);
var shapedResourcesWithLinks = shapedResources.Select(r =>
{
var resourceAsDictionary = r as IDictionary <string, object>;
var resourceLinks = GetLinksForResource((Guid)resourceAsDictionary["Id"], null);
resourceAsDictionary.Add("links", resourceLinks);
return(resourceAsDictionary);
});
var links = GetLinksForResources(getResources, resources.HasPrevious, resources.HasNext);
var linkedCollectionResource = new
{
value = shapedResourcesWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
public ActionResult <CollectionResourceDto> GetPets(
[FromQuery] PetsResourceParameters resourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <PetDto, Pet>(resourceParameters.OrderBy))
{
throw new AppException(nameof(resourceParameters.OrderBy));
}
if (!_propertyCheckerService.TypeHasProperties <PetDto>(resourceParameters.Fields))
{
throw new AppException(nameof(resourceParameters.Fields));
}
var itemsFromRepo = _unitOfWork.Pets.Get(resourceParameters, Account);
var paginationMetadata = new PaginationDto
(
itemsFromRepo.TotalCount,
itemsFromRepo.PageSize,
itemsFromRepo.CurrentPage,
itemsFromRepo.TotalPages
);
var shapedItems = _mapper.Map <IEnumerable <PetDto> >(itemsFromRepo)
.ShapeData(resourceParameters.Fields);
var collectionResource = new CollectionResourceDto(shapedItems, paginationMetadata);
return(Ok(collectionResource));
}
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());
}
}
public ActionResult <DogDto> GetDogForOwner(int ownerId, int dogId, string fields, [FromHeader(Name = "Accept")] string mediaType)
{
if (!MediaTypeHeaderValue.TryParse(mediaType, out MediaTypeHeaderValue parsedMediaType))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <DogDto>(fields))
{
return(BadRequest());
}
if (!_ownerRepository.OwnerExists(ownerId))
{
return(NotFound());
}
var dogForOwnerFromRepo = _dogRepository.GetDogByOwner(ownerId, dogId);
if (dogForOwnerFromRepo == null)
{
return(NotFound());
}
var includeLinks =
parsedMediaType.SubTypeWithoutSuffix.EndsWith("hateoas", StringComparison.InvariantCultureIgnoreCase);
IEnumerable <LinkDto> links = new List <LinkDto>();
if (includeLinks)
{
links = CreateLinksForDogForOwner(dogId, dogForOwnerFromRepo.OwnerId, fields);
}
var primaryMediaType = includeLinks ?
parsedMediaType.SubTypeWithoutSuffix
.Substring(0, parsedMediaType.SubTypeWithoutSuffix.Length - 8)
: parsedMediaType.SubTypeWithoutSuffix;
if (primaryMediaType == "vnd.marvin.dogforowner.primary")
{
var primaryResourceToReturn =
_mapper.Map <DogPrimaryDto>(dogForOwnerFromRepo).ShapeData(fields) as IDictionary <string, object>;
if (includeLinks)
{
primaryResourceToReturn.Add("links", links);
}
return(Ok(primaryResourceToReturn));
}
var fullResourceToReturn = _mapper.Map <DogDto>(dogForOwnerFromRepo).ShapeData(fields) as IDictionary <string, object>;
if (includeLinks)
{
fullResourceToReturn.Add("links", links);
}
return(Ok(fullResourceToReturn));
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _context.GetAuthors(authorsResourceParameters);
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
var option = new JsonSerializerOptions();
option.Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping;
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetadata, option));
var links = CreateLinksForAuthors(authorsResourceParameters,
authorsFromRepo.HasNext, authorsFromRepo.HasPrevious);
var shapedAutors = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo)
.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorWithLinks = shapedAutors.Select(author => {
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary["Id"], null);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedAuthorWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
public IActionResult GetAuthors(
[FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_propertyCheckerService.TypeHasProperties <AuthorDto>
(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _courseLibraryRepository.GetAuthors(authorsResourceParameters);
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination",
JsonSerializer.Serialize(paginationMetadata));
var links = CreateLinksForAuthor(authorsResourceParameters,
authorsFromRepo.HasNext, authorsFromRepo.HasPrevious);
//retorna um IE do expandoObject
var modelandoAutores = _mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo)
.ShapeData(authorsResourceParameters.Fields);
var modelandoAutoresComLinks = modelandoAutores.Select(author =>
{
//selecionamos cada um deles,e inclui um autor ao dicionario juntamente com o links, reutilizando o mesmo codigo do get author,passa um recurso de autores como valor para os links
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary["Id"], null);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linksCollectionResource = new
{//criamos um tipo anonimo e devolvemos
value = modelandoAutoresComLinks,
links
};
return(Ok(linksCollectionResource));
}
public IActionResult GetCoursesForAuthor(
[FromRoute] Guid authorId,
[FromQuery] string fields)
{
if (!AuthorExists(authorId))
{
return(NotFound());
}
if (!_propertyCheckerService.TypeHasProperties <CourseDto>(fields))
{
return(BadRequest());
}
// TODO: Add Courses Pagination
IEnumerable <Course> coursesFromRepo = _courseLibraryRepository.GetCourses(authorId);
return(Ok(_mapper.Map <IEnumerable <Course> >(coursesFromRepo).ShapeData(fields)));
}
public object GetAllMovies(long userId, ResourceParameters parameters = null)
{
//provera da li postoji user za svaki slucaj:
var user = _uow.Users.FirstOrDefault(a => a.Id == userId, "");
ValidationHelper.ValidateNotNull(user);
if (parameters != null)
{
// provera da li postoje polja za sort
if (!_propertyMappingService.ValidMappingExistsFor <WatchedMovieModel, MovieJMDBApi>
(parameters.OrderBy))
{
throw new ValidationException($"{parameters.OrderBy} fields for ordering do not exist!");
}
//provera da li postoji properti za data shaping
if (!_servicePropertyChecker.TypeHasProperties <WatchedMovieModel>
(parameters.Fields))
{
throw new ValidationException($"{parameters.Fields} fields for shaping do not exist!");
}
}
var watchedMovies = _uow.WatchedMovies.Find(m => m.UserId == userId, "MovieJMDBApi").ToList(); //pronalazi sve odgledane filmove za tog usera
List <MovieJMDBApi> usersWatchedMovies = new List <MovieJMDBApi>();
foreach (var movie in watchedMovies) // za sve te odgledane filmove uzima njihove detalje
{
usersWatchedMovies.Add(movie.MovieJMDBApi);
}
if (parameters != null)
{
return(generateResult(usersWatchedMovies, parameters));
}
else
{
return(usersWatchedMovies);
}
}
public IActionResult GetUsers([FromQuery] UsersResourceParameters usersResourceParameters)
{
//Checks weather or not users has a valid property
if (!_propertyCheckerService.TypeHasProperties <UserDto>(usersResourceParameters.Fields))
{
//If not, returnb bad request
return(BadRequest());
}
//Get user from repository
var usersFromRepo = _userLibraryRepository.GetUsers(usersResourceParameters);
#region Paging
//Check if there is a preveous page
var previousPageLink = usersFromRepo.HasPrevious ?
CreateUsersResourceUri(usersResourceParameters,
ResourceUriType.PreviousPage) : null;
//Check if there is a next page
var nextPageLink = usersFromRepo.HasNext ?
CreateUsersResourceUri(usersResourceParameters,
ResourceUriType.NextPage) : null;
//Creating metadata
var paginationMetadata = new
{
totalCount = usersFromRepo.TotalCount,
pageSize = usersFromRepo.PageSize,
currentPage = usersFromRepo.CurrentPage,
totalPages = usersFromRepo.TotalPages,
previousPageLink,
nextPageLink
};
//Adding a custom header for a response
Response.Headers.Add("Pagination", JsonSerializer.Serialize(paginationMetadata));
#endregion Paging
//Return result using data shaping
return(Ok(_mapper.Map <IEnumerable <UserDto> >(usersFromRepo)
.ShapeData(usersResourceParameters.Fields)));
}