public async Task <ActionResult <IEnumerable <PaperBriefDetailDto> > > GetUserPublicPapers(
Guid userId,
[FromQuery] PaperDtoParameters parameters)
{
if (!await userService.UserExistsAsync(userId))
{
return(NotFound());
}
var papers = await userService.GetUserPublicPaperAsync(userId, parameters);
if (papers == null)
{
return(NoContent());
}
var previousLink = papers.HasPrevious ?
CreatePapersResourceUri(nameof(GetUserPublicPapers), parameters, ResourceUriType.PreviousPage) : null;
var nextLink = papers.HasNext ?
CreatePapersResourceUri(nameof(GetUserPublicPapers), parameters, ResourceUriType.NextPage) : null;
var paginationMetaData = new
{
currentPage = papers.CurrentPage,
pageSize = papers.PageSize,
totalPages = papers.TotalPages,
totalCount = papers.TotalCount,
previousLink,
nextLink
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetaData, new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var paperDtos = mapper.Map <IEnumerable <PaperBriefDetailDto> >(papers);
var shapeData = paperDtos.ShapeDate(parameters.fields);
var links = CreateLinkForUserHome(nameof(GetUserPublicPapers), parameters, papers.HasPrevious, papers.HasNext);
var shapedWithUserPaper = shapeData.Select(u =>
{
var paperDic = u as IDictionary <string, object>;
var paperLinks = CreateLinkForUserHome(nameof(GetUserPublicPapers), (Guid)paperDic["UserId"], (Guid)paperDic["Id"], null);
paperDic.Add("links", paperLinks);
return(paperDic);
});
var collectionPaper = new
{
value = shapedWithUserPaper,
links
};
return(Ok(collectionPaper));
}
public async Task <PagedList <Paper> > GetUserPublicPaperAsync(Guid userId, PaperDtoParameters parameters)
{
if (userId == Guid.Empty)
{
throw new ArgumentNullException(nameof(userId));
}
/*
* if (parameters == null)
* {
* return await context.papers
* .Where(x => x.UserId == userId && x.Auth == true)
* .OrderBy(x => x.StartTime)
* .ToListAsync();
* }*/
var items = context.papers as IQueryable <Paper>;
items = items.Where(x => x.UserId == userId && x.Auth == true);
if (!string.IsNullOrWhiteSpace(parameters.Title))
{
parameters.Title = parameters.Title.Trim();
items = items.Where(x => x.Title.Contains(parameters.Title));
}
if (!string.IsNullOrWhiteSpace(parameters.Lable))
{
parameters.Lable = parameters.Lable.Trim();
items = items.Where(x => x.Lable.Contains(parameters.Lable));
}
if (!string.IsNullOrWhiteSpace(parameters.SearchTerm))
{
parameters.SearchTerm = parameters.SearchTerm.Trim();
items = items.Where(x => x.Title.Contains(parameters.SearchTerm) ||
x.Description.Contains(parameters.SearchTerm) ||
x.Lable.Contains(parameters.SearchTerm));
}
//Get Mapping relations
var mappingDictionary = propertyMappingService.GetPropertyMapping <PaperDto, Paper>();
//Order By
items = items.ApplySort(parameters.OrderBy, mappingDictionary);
var returnItems = await PagedList <Paper> .CreateAsync(items, parameters.PageNumber, parameters.PageSize);
//Take the Data From DataBase
foreach (var paper in returnItems)
{
paper.Author = await context.users
.Where(x => x.Id == paper.UserId)
.FirstOrDefaultAsync();
}
return(returnItems);
}
public async Task <ActionResult <IEnumerable <PaperBriefDetailDto> > > GetPublicPapersForUser(
Guid userId,
[FromQuery] PaperDtoParameters parameters)
{
if (!await userService.UserExistsAsync(userId))
{
return(NotFound());
}
var papers = await userService.GetUserPublicPaperAsync(userId, parameters);
var paperDtos = mapper.Map <IEnumerable <PaperBriefDetailDto> >(papers);
return(Ok(paperDtos));
}
private string CreatePapersResourceUri(string routeName, PaperDtoParameters parameters, ResourceUriType type)
{
switch (type)
{
case ResourceUriType.PreviousPage:
return(Url.Link(routeName, new
{
orderBy = parameters.OrderBy,
pageNumber = parameters.PageNumber - 1,
pageSize = parameters.PageSize,
title = parameters.Title,
lable = parameters.Lable,
searchTerm = parameters.SearchTerm,
}));
case ResourceUriType.NextPage:
return(Url.Link(routeName, new
{
orderBy = parameters.OrderBy,
pageNumber = parameters.PageNumber + 1,
pageSize = parameters.PageSize,
title = parameters.Title,
lable = parameters.Lable,
searchTerm = parameters.SearchTerm,
}));
default:
return(Url.Link(routeName, new
{
orderBy = parameters.OrderBy,
pageNumber = parameters.PageNumber,
pageSize = parameters.PageSize,
title = parameters.Title,
lable = parameters.Lable,
searchTerm = parameters.SearchTerm,
}));
}
}
private IEnumerable <LinkDto> CreateLinkForUserHome(string routeName, PaperDtoParameters parameters, bool hasPrevious, bool hasNext)
{
List <LinkDto> links = new List <LinkDto>();
links.Add(new LinkDto(CreatePapersResourceUri(routeName, parameters, ResourceUriType.CurrentPage),
"self",
"GET"));
if (hasPrevious)
{
links.Add(new LinkDto(CreatePapersResourceUri(routeName, parameters, ResourceUriType.PreviousPage),
"perviousPage",
"GET"));
}
if (hasNext)
{
links.Add(new LinkDto(CreatePapersResourceUri(routeName, parameters, ResourceUriType.NextPage),
"nextPage",
"GET"));
}
return(links);
}
public async Task <ActionResult <IEnumerable <PaperDto> > > GetPrivatePapersForUserList(Guid userId,
[FromRoute]
[ModelBinder(BinderType = typeof(ArrayModelBinder))]
IEnumerable <Guid> paperIds,
[FromQuery] PaperDtoParameters parameters = null)
{
if (!await userService.UserExistsAsync(userId))
{
return(NotFound());
}
if (paperIds == null)
{
var papers = await userService.GetUserPrivatePapersAsync(userId, parameters);
var paperDtos = mapper.Map <IEnumerable <PaperBriefDetailDto> >(papers);
return(Ok(paperDtos));
}
var entities = await userService.GetUserPrivatePapersAsync(userId, paperIds);
if (entities.Count() != paperIds.Count())
{
return(NotFound());
}
var returnDto = mapper.Map <IEnumerable <PaperBriefDetailDto> >(entities);
return(Ok(returnDto));
}
public async Task <IActionResult> GetBriefPapers([FromQuery] PaperDtoParameters paperDtoParameters)
{
if (!string.IsNullOrWhiteSpace(paperDtoParameters.fields))
{
var fields = paperDtoParameters.fields.Split(",");
if (!fields.Contains("Id") && !fields.Contains("userId"))
{
return(UnprocessableEntity());
}
}
if (!propertyMappingService.ValidMappingExists <PaperDto, Paper>(paperDtoParameters.OrderBy))
{
return(BadRequest());
}
if (!propertyCheckerService.TypeHasProperties <PaperDto>(paperDtoParameters.fields))
{
return(BadRequest());
}
var papers = await paperService.GetPapersAsync(paperDtoParameters);
var previousLink = papers.HasPrevious ?
CreatePapersResourceUri(paperDtoParameters, ResourceUriType.PreviousPage) : null;
var nextLink = papers.HasNext ?
CreatePapersResourceUri(paperDtoParameters, ResourceUriType.NextPage) : null;
var paginationMetaData = new
{
currentPage = papers.CurrentPage,
pageSize = papers.PageSize,
totalPages = papers.TotalPages,
totalCount = papers.TotalCount,
previousLink,
nextLink
};
Response.Headers.Add("X-Pagination", JsonSerializer.Serialize(paginationMetaData, new JsonSerializerOptions
{
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping
}));
var papersDto = mapper.Map <IEnumerable <PaperBriefDetailDto> >(papers);
var shapeData = papersDto.ShapeDate(paperDtoParameters.fields);
var links = CreateLinkForHome(paperDtoParameters, papers.HasPrevious, papers.HasNext);
var shapedWithPapers = shapeData.Select(p =>
{
var paperDic = p as IDictionary <string, object>;
var paperLinks = CreateLinkForHome((Guid)paperDic["UserId"], (Guid)paperDic["Id"], null);
paperDic.Add("links", paperLinks);
return(paperDic);
});
var collectionPaper = new
{
value = shapedWithPapers,
links
};
return(Ok(collectionPaper));
}
