[HttpHead] // Use head for validity, accessibility and recent modification
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters, [FromHeader(Name = "Accept")] string mediaType)
{
if (!_propertyMappingService.ValidMappingExistFor <AuthorDto, Author>(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _libraryRepository.GetAuthors(authorsResourceParameters);
var authors = Mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo);
if (mediaType == "application/vnd.ifeanyi.hateoas+json")
{
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages,
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
var links = CreateLinksForAuthors(authorsResourceParameters, authorsFromRepo.HasNext, authorsFromRepo.HasPrevious);
var shapedAuthors = authors.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor((Guid)authorAsDictionary["Id"], authorsResourceParameters.Fields);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new { value = shapedAuthorsWithLinks, links = links };
return(Ok(linkedCollectionResource));
}
else
{
var previousPageLink = authorsFromRepo.HasPrevious ? CreateAuthorsResourceUri(authorsResourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = authorsFromRepo.HasNext ? CreateAuthorsResourceUri(authorsResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
previousPageLink = previousPageLink,
nextPageLink = nextPageLink,
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
return(Ok(authors.ShapeData(authorsResourceParameters.Fields)));
}
}
public async Task <IActionResult> GetAuthors(AuthorsResourceParameters authorsResourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>
(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
try
{
var entityAuthors = _libraryRepository.GetAuthors(authorsResourceParameters);
var paginationMetadata = new
{
totalCount = entityAuthors.TotalCount,
pageSize = entityAuthors.PageSize,
currentPage = entityAuthors.CurrentPage,
totalPages = entityAuthors.TotalPages
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));
var authors = Mapper.Map <IEnumerable <AuthorDto> >(entityAuthors);
var links = CreateLinksForAuthors(authorsResourceParameters,
entityAuthors.HasNext, entityAuthors.HasPrevious);
var shapedAuthors = authors.ShapeData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks =
CreateLinksForAuthor((int)authorAsDictionary["Id"], authorsResourceParameters.Fields);
authorAsDictionary.Add("links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedAuthorsWithLinks,
links
};
return(Ok(linkedCollectionResource));
}
catch (Exception ex)
{
await _logger.LogCustomExceptionAsync(ex, null);
return(RedirectToAction("Error", "Home"));
}
}
public IActionResult GetAnnouncements([FromQuery] AnnouncementsResourceParameters announcementsResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <AnnouncementForGetting>(announcementsResourceParameters.Fields))
{
return(BadRequest());
}
var announcementsFromDb = _announcementsRepository.GetAnnouncements(announcementsResourceParameters);
var previousPageLink = announcementsFromDb.HasPrevious ?
CreateAnnouncementsResourceUri(announcementsResourceParameters, ResourceUriType.PreviousPage) : null;
var nextPageLink = announcementsFromDb.HasNext ?
CreateAnnouncementsResourceUri(announcementsResourceParameters, ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = announcementsFromDb.TotalCount,
pageSize = announcementsFromDb.PageSize,
currentPage = announcementsFromDb.CurrentPage,
totalPages = announcementsFromDb.TotalPages,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));
var announcementsForGetting = Mapper.Map <IEnumerable <AnnouncementForGetting> >(announcementsFromDb);
return(Ok(announcementsForGetting.ShapeData(announcementsResourceParameters.Fields)));
}
public IActionResult GetAuthors(AuthorsResourceParameters authorsResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <AuthorDto>
(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _libraryRepository.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 = previousPageLink,
nextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination",
Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
var authors = Mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo);
return(Ok(authors.ShapeData(authorsResourceParameters.Fields)));
}
public async Task <IActionResult> GetHateoas(PostParameters postParameters)
{
if (!_propertyMappingContainer.ValidateMappingExistsFor <PostResource, Post>(postParameters.OrderBy))
{
return(BadRequest("Can't finds fields for sorting."));
}
if (!_typeHelperService.TypeHasProperties <PostResource>(postParameters.Fields))
{
return(BadRequest("Fields not exist."));
}
var postList = await _postRepository.GetAllPostsAsync(postParameters);
var postResource = _mapper.Map <IEnumerable <Post>, IEnumerable <PostResource> >(postList);
var shapedPostResource = postResource.ToDynamicIEnumerable(postParameters.Fields);
var proviousPage = postList.HasPrevious ? CreatePostUri(postParameters, PaginationResourceUriType.PreviousPage) : null;
var nextPage = postList.HasNext ? CreatePostUri(postParameters, PaginationResourceUriType.NextPage) : null;
var meta = new
{
PageIndex = postList.PageIndex,
PageSize = postList.PageSize,
TotalItemsCount = postList.TotalItemsCount,
PageCount = postList.Count,
proviousPage,
nextPage
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
return(Ok(shapedPostResource));
}
public async Task <IActionResult> GetStoreAsync(Guid id, [FromQuery] string fields)
{
if (!_typeHelperService.TypeHasProperties <StoreUiModel>
(fields))
{
return(BadRequest());
}
var storeFromRepo = await _inquiryStoreProcessor.GetStoreByIdAsync(id);
if (storeFromRepo == null)
{
return(NotFound());
}
var store = Mapper.Map <StoreUiModel>(storeFromRepo);
var links = CreateLinksForStore(id, fields);
var linkedResourceToReturn = store.ShapeData(fields)
as IDictionary <string, object>;
linkedResourceToReturn.Add("links", links);
return(Ok(linkedResourceToReturn));
}
public async Task <IActionResult> GetBetHistory([FromQuery] string Userid, [FromQuery] ResourceParameter parameter)
{
if (!_typeHelperService.TypeHasProperties <UserListViewDto>(parameter.Fields))
{
return(BadRequest());
}
var users = await _AccountService.GetBetHistory(Userid, parameter);
var prevLink = users.HasPrevious ?
CreateUsersResourceUri(parameter, ResourceUriType.PreviousPage) : null;
var nextLink = users.HasNext ?
CreateUsersResourceUri(parameter, ResourceUriType.NextPage) : null;
var paginationMetaData = new
{
totalCount = users.TotalCount,
pageSize = users.PageSize,
totalPages = users.TotalPages,
currentPage = users.CurrentPage,
PreviousPageLink = prevLink,
NextPageLink = nextLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetaData));
Response.Headers.Add("Access-Control-Expose-Headers", "X-Pagination");
var userMap = _mapper.Map <IEnumerable <BetViewDto> >(users);
return(Ok(userMap.ShapeData(parameter.Fields)));
}
public async Task <IActionResult> GetShapedArtists([FromQuery] RequestParameters requestParameters)
{
if (string.IsNullOrWhiteSpace(requestParameters.OrderBy))
{
requestParameters.OrderBy = "StageName";
}
if (!_typeHelperService.TypeHasProperties <ArtistDto>(requestParameters.Fields))
{
return(BadRequest());
}
var artistPagedList = await GetPagedListOfArtists(requestParameters);
var paginationMetaData = _controllerHelper.CreatePaginationMetadataObject(artistPagedList, requestParameters, "Getartists");
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetaData));
var artists = Mapper.Map <IEnumerable <ArtistDto> >(artistPagedList);
if (requestParameters.IncludeMetadata)
{
var shapedArtists = artists.ShapeData(requestParameters.Fields);
var artistsWithMetadata = new EntityWithPaginationMetadataDto <ExpandoObject>(paginationMetaData, shapedArtists);
return(Ok(artistsWithMetadata));
}
return(Ok(artists.ShapeData(requestParameters.Fields)));
}
public async Task <IActionResult> GetAllJobsAsync(
[FromQuery, SwaggerParameter("Request which fields you want returned")] string fields,
[FromHeader(Name = "Accept"), SwaggerParameter("Request Hateoas")] string mediaType)
{
if (!string.IsNullOrWhiteSpace(fields))
{
if (!_typeHelperService.TypeHasProperties <JobDto>(fields))
{
return(BadRequest());
}
}
var foundJobs = await _jobRepository.GetAllAsync();
var jobs = Mapper.Map <IEnumerable <JobDto> >(foundJobs);
var shapedJobs = jobs.ShapeData(fields);
if (mediaType == "application/vnd.AO.json+hateoas")
{
var shapedAndLinkedJobs = _controllerHelper.AddLinksToShapedObjects(shapedJobs, "Job", fields);
var linkedResourceCollection = _controllerHelper.AddLinksToCollection(shapedAndLinkedJobs, "Job", null);
return(Ok(linkedResourceCollection));
}
return(Ok(shapedJobs));
}
public async Task <IActionResult> GetHateoas(PostParameters parameters)
{
//验证排序属性映射是否存在
if (!_propertyMappingContainer.ValidateMappingExistsFor <PostDTO, Post>(parameters.OrderBy))
{
return(BadRequest("Can't finds fields for sorting."));
}
//验证Filed是否存在
if (!_typeHelperService.TypeHasProperties <PostDTO>(parameters.Fields))
{
return(BadRequest("Filed not exits"));
}
var posts = await _postRepository.GetPostsAsync(parameters);
var postDto = _mapper.Map <IEnumerable <Post>, IEnumerable <PostDTO> >(posts);
var shapePostDTO = postDto.ToDynamicIEnumerable(parameters.Fields);
var previousPageLink = posts.HasPrevious ?
CreatePostUri(parameters, PaginationResourceUriType.PreviousPage) : null;
var nextPageLink = posts.HasNext ?
CreatePostUri(parameters, PaginationResourceUriType.NextPage) : null;
var shapedWithLinks = shapePostDTO.Select(x =>
{
var dict = x as IDictionary <string, object>;
var postLinks = CreateLinksForPost((int)dict["Id"], parameters.Fields);
dict.Add("links", postLinks);
return(dict);
});
var links = CreateLinksForPosts(parameters, posts.HasPrevious, posts.HasNext);
var result = new
{
value = shapedWithLinks,
links
};
var meta = new
{
PageSize = posts.PageSize,
PageIndex = posts.PageIndex,
TotalItemCount = posts.TotalItemsCount,
PageCount = posts.PageCount,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
return(Ok(result));
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters parameters,
[FromHeader(Name = Headers.Accept)] string mediaType)
{
if (!_propertyMappingService.ValidMappingExistsFor <Author, Entities.Author>(parameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <Author>(parameters.Fields))
{
return(BadRequest());
}
var authors = _repo.GetAuthors(parameters);
var currentMediaType = new MediaType(mediaType);
var includeLinks = currentMediaType.IsSubsetOf(VendorMediaType.HateoasLinksMediaType);
var prev = authors.HasPrevious ? CreateAuthorsResourceUri(parameters, ResourceUriType.Previous) : null;
var next = authors.HasNext ? CreateAuthorsResourceUri(parameters, ResourceUriType.Next) : null;
var result = Mapper.Map <IEnumerable <Author> >(authors);
var pagination = new Pagination()
{
IncludeLinks = !includeLinks,
TotalCount = authors.TotalCount,
PageSize = authors.PageSize,
CurrentPage = authors.CurrentPage,
TotalPages = authors.TotalPages,
NextPageLink = next,
PreviousPageLink = prev,
};
Pagination.AddHeader(Response, pagination);
if (includeLinks)
{
var links = CreateLinks(parameters, authors.HasNext, authors.HasPrevious);
var shapedAuthors = result.ShapeData(parameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(a =>
{
var authorDictionary = a as IDictionary <string, object>;
var authorLinks = CreateLinks((Guid)authorDictionary[nameof(Author.Id)], parameters.Fields);
authorDictionary.Add("links", authorLinks);
return(authorDictionary);
}
);
var linkCollection = new { value = shapedAuthorsWithLinks, links };
return(Ok(linkCollection));
}
return(Ok(result));
}
public async Task <IActionResult> GetAllShowtimesAsync([FromRoute] Guid movieId, [FromQuery] RequestParameters requestParameters, [FromHeader(Name = "Accept")] string mediaType)
{
if (!await _showtimeRepository.MovieExists(movieId))
{
return(NotFound());
}
if (string.IsNullOrWhiteSpace(requestParameters.OrderBy))
{
// TODO: change to order by when playing
requestParameters.OrderBy = "Id";
}
if (!_propertyMappingService.ValidMappingExistsFor <ShowtimeDto, Showtime>(requestParameters.Fields))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <ShowtimeDto>(requestParameters.Fields))
{
return(BadRequest());
}
var showtimesPagedList = await _showtimeRepository.GetAllShowtimesAsync(movieId, requestParameters.OrderBy, requestParameters.PageNumber, requestParameters.PageSize);
var showtimes = Mapper.Map <IEnumerable <ShowtimeDto> >(showtimesPagedList);
if (mediaType == "application/vnd.biob.json+hateoas")
{
return(Ok(CreateHateoasResponse(showtimesPagedList, requestParameters)));
}
else
{
var previousPageLink = showtimesPagedList.HasPrevious ? CreateUrlForResource(requestParameters, PageType.PreviousPage) : null;
var nextPageLink = showtimesPagedList.HasNext ? CreateUrlForResource(requestParameters, PageType.NextPage) : null;
var paginationMetadata = new PaginationMetadata()
{
TotalCount = showtimesPagedList.TotalCount,
PageSize = showtimesPagedList.PageSize,
CurrentPage = showtimesPagedList.CurrentPage,
TotalPages = showtimesPagedList.TotalPages,
PreviousPageLink = previousPageLink,
NextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
if (requestParameters.IncludeMetadata)
{
var showtimesWithMetadata = new EntityWithPaginationMetadataDto <ShowtimeDto>(paginationMetadata, showtimes);
return(Ok(showtimesWithMetadata));
}
return(Ok(showtimes));
}
}
public IActionResult GetAuthors([FromQuery] AuthorsResourceParameters authorsResourceParameters)
{
authorsResourceParameters ??= new AuthorsResourceParameters();
if (!_propertyMappingService.ValidMappingExistsFor <AuthorDto, Author>
(authorsResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <AuthorDto>(authorsResourceParameters.Fields))
{
return(BadRequest());
}
var authorsFromRepo = _libraryRepository.GetAuthors(authorsResourceParameters);
var authors = authorsFromRepo.Map();
var paginationMetadata = new
{
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetadata));
var links = CreateLinksForAuthors(authorsResourceParameters,
authorsFromRepo.HasNext, authorsFromRepo.HasPrevious);
var shapedAuthors = authors.ShapedData(authorsResourceParameters.Fields);
var shapedAuthorsWithLinks = shapedAuthors.Select(author =>
{
var authorAsDictionary = author as IDictionary <string, object>;
var authorLinks = CreateLinksForAuthor(
(Guid)authorAsDictionary["Id"], authorsResourceParameters.Fields);
authorAsDictionary.Add("_links", authorLinks);
return(authorAsDictionary);
});
var linkedCollectionResource = new
{
value = shapedAuthorsWithLinks,
links = links
};
var str = JsonConvert.SerializeObject(linkedCollectionResource);
return(Ok(str));
}
public async Task <IActionResult> GetAllMoviesAsync(
[FromQuery] RequestParameters requestParameters,
[FromHeader(Name = "Accept")] string mediaType)
{
if (string.IsNullOrWhiteSpace(requestParameters.OrderBy))
{
requestParameters.OrderBy = "Title";
}
if (!_propertyMappingService.ValidMappingExistsFor <MovieDto, Movie>(requestParameters.Fields))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <MovieDto>(requestParameters.Fields))
{
return(BadRequest());
}
var moviesPagedList = await _movieRepository.GetAllMoviesAsync(requestParameters.OrderBy,
requestParameters.SearchQuery,
requestParameters.PageNumber, requestParameters.PageSize);
var movies = Mapper.Map <IEnumerable <MovieDto> >(moviesPagedList);
if (mediaType == "application/vnd.biob.json+hateoas")
{
return(Ok(CreateHateoasResponse(moviesPagedList, requestParameters)));
}
else
{
var previousPageLink = moviesPagedList.HasPrevious ? CreateUrlForResource(requestParameters, PageType.PreviousPage) : null;
var nextPageLink = moviesPagedList.HasNext ? CreateUrlForResource(requestParameters, PageType.NextPage) : null;
var paginationMetadata = new PaginationMetadata()
{
TotalCount = moviesPagedList.TotalCount,
PageSize = moviesPagedList.PageSize,
CurrentPage = moviesPagedList.CurrentPage,
TotalPages = moviesPagedList.TotalPages,
PreviousPageLink = previousPageLink,
NextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
if (requestParameters.IncludeMetadata)
{
var shapedMovies = movies.ShapeData(requestParameters.Fields);
var moviesWithMetadata = new EntityWithPaginationMetadataDto <ExpandoObject>(paginationMetadata, shapedMovies);
return(Ok(moviesWithMetadata));
}
return(Ok(movies.ShapeData(requestParameters.Fields)));
}
}
public async Task <IActionResult> GetReviews([FromQuery] ReviewsResourceParameters reviewsResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <ReviewReturnModel>(
reviewsResourceParameters.Fields))
{
return(BadRequest());
}
var reviews = await _reviewData.GetReviews(reviewsResourceParameters);
var returnModel = Mapper.Map <List <ReviewReturnModel> >(reviews);
var pagedReturnModel = await PagedList <ReviewReturnModel> .Create(returnModel,
reviewsResourceParameters.PageNumber,
reviewsResourceParameters.PageSize);
var previousPageLink = pagedReturnModel.HasPrevious ?
CreateReviewsResourceUri(reviewsResourceParameters,
ResourceUriType.PreviousPage) : null;
var nextPageLink = pagedReturnModel.HasNext ?
CreateReviewsResourceUri(reviewsResourceParameters,
ResourceUriType.NextPage) : null;
var paginationMetadata = new
{
totalCount = pagedReturnModel.TotalCount,
pageSize = pagedReturnModel.PageSize,
currentPage = pagedReturnModel.CurrentPage,
totalPages = pagedReturnModel.TotalPages,
previousPageLink = previousPageLink,
nextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination",
Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetadata));
var links = CreateLinksForReviews(reviewsResourceParameters,
pagedReturnModel.HasNext, pagedReturnModel.HasPrevious);
var shapedReturnModel = pagedReturnModel.AsEnumerable().ShapeData(reviewsResourceParameters.Fields);
var shapedReturnModelWithLinks = shapedReturnModel.Select(review =>
{
var reviewAsDictionary = review as IDictionary <string, object>;
var reviewLinks = CreateLinksForReview(
(int)reviewAsDictionary["Id"], reviewsResourceParameters.Fields);
reviewAsDictionary.Add("links", reviewLinks);
return(reviewAsDictionary);
});
return(Ok(shapedReturnModelWithLinks));
}
public IActionResult GetAllProductGroups(ProductGroupResourceParameters resourceParameters)
{
if (!_typeHelperService.TypeHasProperties <ProductGroupDto>(resourceParameters.Fields))
{
return(BadRequest());
}
var entities = _productGroupRepository.GetAll();
var productGroups = Mapper.Map <IEnumerable <ProductGroupDto> >(entities).ShapeData(resourceParameters.Fields);
return(Ok(productGroups));
}
public void Given_A_Object_When_I_Call_TypeHasProperties_On_That_Object_With_A_Valid_Field_Then_Returns_True()
{
// Arrange
var usersResourceParameters = new UsersResourceParameters {
Fields = "Id"
};
// Act
var typeHasProperties = _typeHelperService.TypeHasProperties <User>(usersResourceParameters.Fields);
// Assert
Assert.True(typeHasProperties);
}
public async Task <IActionResult> GetHateoas(PostParameters postParameters)
{
if (!_propertyMappingContainer.ValidateMappingExistsFor <PostResource, Post>(postParameters.OrderBy))
{
return(BadRequest("Can't finds fields for sorting."));
}
if (!_typeHelperService.TypeHasProperties <PostResource>(postParameters.Fields))
{
return(BadRequest("Fields not exist."));
}
var postList = await _postRepository.GetAllPostsAsync(postParameters);
var postResources = _mapper.Map <IEnumerable <Post>, IEnumerable <PostResource> >(postList);
// 资源塑形
var shapedPostResources = postResources.ToDynamicIEnumerable(postParameters.Fields);
var shapedWithLinks = shapedPostResources.Select(x =>
{
var dict = x as IDictionary <string, object>;
var postlinks = CreateLinksForPost((int)dict["Id"], postParameters.Fields);
dict.Add("links", postlinks);
return(dict);
});
var links = CreateLinksForPosts(postParameters, postList.HasPrevious, postList.HasNext);
var result = new
{
value = shapedWithLinks,
links
};
var meta = new
{
postList.PageSize,
postList.PageIndex,
postList.TotalItemsCount,
postList.PageCount,
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
return(Ok(result));
}
public async Task <IActionResult> GetHateaos(OrderQueryParameter parameter)
{
if (!_propertyMappingContainer.ValidateMappingExsitFor <OrderResourceModel, Order>(parameter.OrderBy))
{
return(BadRequest("Can't finds fields for sorting"));
}
if (!_typeHelperService.TypeHasProperties <OrderResourceModel>(parameter.Fields))
{
return(BadRequest("Fields not exist"));
}
var paginatedList = await _orderRepository.GetOrdersAsync(parameter);
var orderResourceModel = _mapper.Map <IEnumerable <Order>, IEnumerable <OrderResourceModel> >(paginatedList);
var previousPageLink = paginatedList.HasPrevious ? CreateOrderUrl(parameter, PaginatedUrlType.PreviousPage) : null;
var nextPageLink = paginatedList.HasNext ? CreateOrderUrl(parameter, PaginatedUrlType.NextPage) : null;
var meta = new
{
paginatedList.PageIndex,
paginatedList.PageSize,
paginatedList.TotalItemCount,
paginatedList.PageCount,
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
}));
var shapeOrderResources = orderResourceModel.ToDynamicIEnumerable(parameter.Fields);
_logger.LogInformation(JsonConvert.SerializeObject(shapeOrderResources));
var shapedWithLinks = shapeOrderResources.Select(x =>
{
var dict = x as IDictionary <string, object>;
var orderLinks = CreateLinksForOrder((Guid)dict["Id"], parameter.Fields);
dict.Add("links", orderLinks);
return(dict);
});
var links = CreateLinksForOrders(parameter, paginatedList.HasPrevious, paginatedList.HasNext);
var result = new
{
value = shapedWithLinks,
links
};
return(Ok(result));
}
public async Task <IActionResult> GetAllEmployeesAsync([FromQuery] RequestParameters request, [FromHeader(Name = "accept")] string mediaType)
{
if (string.IsNullOrWhiteSpace(request.OrderBy))
{
request.OrderBy = "Name";
}
if (!_typeHelperService.TypeHasProperties <EmployeeDtoForMultiple>(request.Fields))
{
return(BadRequest());
}
var pagedEmployeeList = await _employeeRepository.GetEmployeesAsync(
request.OrderBy, request.SearchQuery, request.PageNumber,
request.PageSize, _propertyMappingService.GetPropertyMapping <EmployeeDtoForMultiple, Employee>());
var paginationMetaData = _controllerHelper.CreatePaginationMetadataObject(pagedEmployeeList, request, "GetEmployees");
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(paginationMetaData));
var employees = Mapper.Map <IEnumerable <EmployeeDtoForMultiple> >(pagedEmployeeList);
var shapedEmployees = employees.ShapeData(request.Fields);
if (mediaType == "application/vnd.AO.json+hateoas")
{
var shapedAndLinkedEmployees = _controllerHelper.AddLinksToShapedObjects(shapedEmployees, "Employee", request.Fields);
var linkedResourceCollection = _controllerHelper.AddLinksToCollection(shapedAndLinkedEmployees, request, pagedEmployeeList.HasNext, pagedEmployeeList.HasPrevious, "Employee");
if (request.IncludeMetadata)
{
((IDictionary <string, object>)linkedResourceCollection).Add("metadata", paginationMetaData);
return(Ok(linkedResourceCollection));
}
return(Ok(linkedResourceCollection));
}
if (request.IncludeMetadata)
{
var entityWithMeaData = new ExpandoObject();
((IDictionary <string, object>)entityWithMeaData).Add("metadata", paginationMetaData);
((IDictionary <string, object>)entityWithMeaData).Add("records", shapedEmployees);
return(Ok(entityWithMeaData));
}
return(Ok(shapedEmployees));
}
public async Task <IActionResult> GetReviewsForAlbum([FromRoute] Guid albumId, RequestParameters reviewRequestParameters)
{
if (string.IsNullOrWhiteSpace(reviewRequestParameters.OrderBy))
{
reviewRequestParameters.OrderBy = "Submitted";
}
if (!_propertyMappingService.ValidMappingExistsFor <ReviewDto, Review>(reviewRequestParameters.Fields))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <ReviewDto>(reviewRequestParameters.Fields))
{
return(BadRequest());
}
var reviewsForAlbumPagedList = await _reviewRepository.GetReviewsForAlbumAsync(
albumId, reviewRequestParameters.OrderBy,
reviewRequestParameters.PageNumber, reviewRequestParameters.PageSize,
_propertyMappingService.GetPropertyMapping <ReviewDto, Review>());
var previousPageLink = reviewsForAlbumPagedList.HasPrevious ? CreateUrlForReviewResource(reviewRequestParameters, PageType.PreviousPage) : null;
var nextPageLink = reviewsForAlbumPagedList.HasNext ? CreateUrlForReviewResource(reviewRequestParameters, PageType.NextPage) : null;
var paginationMetaData = new PaginationMetadata()
{
TotalCount = reviewsForAlbumPagedList.TotalCount,
PageSize = reviewsForAlbumPagedList.PageSize,
CurrentPage = reviewsForAlbumPagedList.CurrentPage,
TotalPages = reviewsForAlbumPagedList.TotalPages,
PreviousPageLink = previousPageLink,
NextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetaData));
var reviews = Mapper.Map <IEnumerable <ReviewDto> >(reviewsForAlbumPagedList);
if (reviewRequestParameters.IncludeMetadata)
{
var records = reviews.ShapeData(reviewRequestParameters.Fields);
var artistsWithMetadata = new EntityWithPaginationMetadataDto <ExpandoObject>(paginationMetaData, records);
return(Ok(artistsWithMetadata));
}
return(Ok(reviews.ShapeData(reviewRequestParameters.Fields)));
}
/// <summary>
/// 判断相应的字段是否能塑形
/// </summary>
/// <param name="fields"></param>
/// <returns></returns>
protected void ValidateFields <TResource>(string fields)
{
if (!_typeHelperService.TypeHasProperties <TResource>(fields))
{
Results.Add(BadRequest(new BadRequestFieldsMessage()));
}
}
public async Task <IActionResult> Get(int id, string fields)
{
if (!_typeHelperService.TypeHasProperties <PostResource>(fields))
{
return(BadRequest("Fields not exist."));
}
var post = await this._postRepository.GetPostByIdAsync(id);
if (post == null)
{
return(NotFound());
}
var postResource = this._mapper.Map <Post, PostResource>(post);
var shapedResource = postResource.ToDynamic(fields);
var links = this.CreateLinksForPost(id, fields);
var result = shapedResource as IDictionary <string, object>;
result.Add("links", links);
return(Ok(result));
}
public async Task <IActionResult> GetProductAsync(Guid id, [FromQuery] string fields)
{
if (!_typeHelperService.TypeHasProperties <ProductUiModel>
(fields))
{
return(BadRequest());
}
var productFromRepo = await _inquiryProductProcessor.GetProductByIdAsync(id);
if (productFromRepo == null)
{
return(NotFound("ERROR_PRODUCT_RETRIEVAL"));
}
var product = Mapper.Map <ProductUiModel>(productFromRepo);
var links = CreateLinksForProduct(id, fields);
var linkedResourceToReturn = product.ShapeData(fields)
as IDictionary <string, object>;
linkedResourceToReturn.Add("links", links);
return(Ok(linkedResourceToReturn));
}
public async Task <IActionResult> GetEmployeeJobAsync(
[FromRoute, SwaggerParameter("Id of the employee to find job by", Required = true)] Guid employeeId,
[FromQuery, SwaggerParameter("Request which fields you want returned")] string fields,
[FromHeader(Name = "Accept"), SwaggerParameter("Request Hateoas")] string mediaType)
{
if (!string.IsNullOrWhiteSpace(fields))
{
if (!_typeHelperService.TypeHasProperties <JobDto>(fields))
{
return(BadRequest());
}
}
if (!await _jobRepository.EntityExists <Employee>(e => e.Id == employeeId))
{
return(NotFound());
}
var foundEmployeeJob = await _jobRepository.GetJobByEmployeeId(employeeId);
var emplooyeJob = Mapper.Map <JobDto>(foundEmployeeJob);
var shapedEmployeeJob = emplooyeJob.ShapeData(fields);
if (mediaType == "application/vnd.AO.json+hateoas")
{
((IDictionary <string, object>)shapedEmployeeJob)
.Add("links", _controllerHelper.CreateLinksForResource(foundEmployeeJob.Id, fields, "EmployeeJob"));
}
return(Ok(shapedEmployeeJob));
}
public async Task <IActionResult> GetDictionaries([FromQuery] DictionariesParameters parameters)
{
try
{
//验证排序的字段是否存在
if (!propertyMappingContainer.ValidateMappingExistsFor <DictionariesViewModel, Dictionaries>(parameters.OrderBy))
{
return(BadRequest("order by Fidled not exist"));
}
//验证过滤的字段是否存在
if (!typeHelperService.TypeHasProperties <DictionariesViewModel>(parameters.Fields))
{
return(BadRequest("fidled not exist"));
}
var users = await repository.GetAllDicAsync(parameters);
var userViewModel = mapper.Map <IEnumerable <Dictionaries>, IEnumerable <DictionariesViewModel> >(users);
return(Ok(new BaseResponse()
{
success = true, dynamicObj = userViewModel, TotalRecord = users.TotalItemsCount
}));
}
catch (Exception ex)
{
return(Ok(new BaseResponse()
{
success = false, message = ex.Message
}));
}
}
public async Task <IActionResult> Get(PostParameters postParameters)
{
//检查按照某个字段排序时该字段是否存在
if (!_propertyMappingContainer.ValidateMappingExistsFor <PostResource, Post>(postParameters.OrderBy))
{
return(BadRequest("OrderBy is not exist"));
}
//检查资源塑性字段是否存在
if (!_typeHelperService.TypeHasProperties <PostResource>(postParameters.Fields))
{
return(BadRequest("Fields is not exist"));
}
var postList = await _postRepository.GetAllPostsAsync(postParameters);
//转化实体
var postResources = _mapper.Map <IEnumerable <Post>, IEnumerable <PostResource> > (postList);
//资源塑性
var shapedPostResources = postResources.ToDynamicIEnumerable(postParameters.Fields);
//前一页
var previousPageLink = postList.HasPrevious ?
CreatePostUri(postParameters,
PaginationResourceUriType.PreviousPage) : null;
//后一页
var nextPageLink = postList.HasNext ?
CreatePostUri(postParameters,
PaginationResourceUriType.NextPage) : null;
var meta = new
{
PageSize = postList.PageSize,
PageIndex = postList.PageIndex,
TotalItemsCount = postList.TotalItemsCount,
PageCount = postList.PageCount,
previousPageLink,
nextPageLink
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(meta, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver() //转化数据不管大小写，首字母都转化为小写
}));
return(Ok(shapedPostResources));
}
public ProjectQueryDTOValidator(IPropertyMappingContainer propertyMappingContainer, ITypeHelperService typeHelperService)
{
RuleFor(e => e.OrderBy).Must(order => propertyMappingContainer.ValidMappingExistsFor <ProductDTO, Product>(order))
.WithMessage("Can't find the fields in {PropertyName} for sorting.");
RuleFor(e => e.Fields).Must(fields => typeHelperService.TypeHasProperties <ProductDTO>(fields))
.WithMessage("Can't find the fields in {PropertyName} on DTO.");
}
public ActionResult <LinkedCollectionResourceWrapperDto <AuditLogIdentifierDto> > GetAuditLogsByIdentifier(
[FromQuery] AuditLogResourceParameters auditLogResourceParameters)
{
if (!_typeHelperService.TypeHasProperties <AuditLogIdentifierDto>
(auditLogResourceParameters.OrderBy))
{
return(BadRequest());
}
var mappedAuditLogsWithLinks = GetAuditLogs <AuditLogIdentifierDto>(auditLogResourceParameters);
var wrapper = new LinkedCollectionResourceWrapperDto <AuditLogIdentifierDto>(mappedAuditLogsWithLinks.TotalCount, mappedAuditLogsWithLinks);
var wrapperWithLinks = CreateLinksForAuditLogs(wrapper, auditLogResourceParameters,
mappedAuditLogsWithLinks.HasNext, mappedAuditLogsWithLinks.HasPrevious);
return(Ok(wrapperWithLinks));
}
public IActionResult GetAuthors(AuthorsResourceParameters authorResourceParameters)
{
if (!_propertyMappingService.ValidateMappingExistsFor <AuthorDto, Author>(authorResourceParameters.OrderBy))
{
return(BadRequest());
}
if (!_typeHelperService.TypeHasProperties <AuthorDto>(authorResourceParameters.Fields))
{
return(BadRequest());
}
IEnumerable <AuthorDto> authors = null;
var authorsFromRepo = _libraryRepository.GetAuthors(authorResourceParameters);
//var previousPageLink = authorsFromRepo.HasPreviousPage ?
// this.CreateAuthorsResourceUri(authorResourceParameters, ResourceUriType.PreviousPage) : null;
//var nextPageLink = authorsFromRepo.HasNext ?
// this.CreateAuthorsResourceUri(authorResourceParameters, ResourceUriType.NextPage) : null;
var paginationMetaData = new {
totalCount = authorsFromRepo.TotalCount,
pageSize = authorsFromRepo.PageSize,
currentPage = authorsFromRepo.CurrentPage,
totalPages = authorsFromRepo.TotalPages,
//previousPageLink = previousPageLink,
//nextPageLink = nextPageLink
};
Response.Headers.Add("X-Pagination", Newtonsoft.Json.JsonConvert.SerializeObject(paginationMetaData));
authors = AutoMapper.Mapper.Map <IEnumerable <AuthorDto> >(authorsFromRepo);
var links = this.CreateLinksForAuthors(authorResourceParameters, authorsFromRepo.HasNext, authorsFromRepo.HasPreviousPage);
var shapedAuthors = authors.ShapeData(authorResourceParameters.Fields);
var shapedAuthorwithLink = shapedAuthors.Select(item => {
var authorAsDictionary = item as IDictionary <string, object>;
var authorLink = this.CreateLinksForAuthor((Guid)authorAsDictionary["Id"], authorResourceParameters.Fields);
authorAsDictionary.Add("links", authorLink);
return(authorAsDictionary);
});
var linkedCollectionResource = new { value = shapedAuthorwithLink, links = links };
return(Ok(linkedCollectionResource));
}