public PageList <Post> GetPosts(PostQueryFilter filters)
{
filters.PageIndex = filters.PageIndex == 0 ? _paginationOptions.DefaultPageIndex : filters.PageIndex;
filters.PageSize = filters.PageSize == 0 ? _paginationOptions.DefaultPageSize : filters.PageSize;
var posts = _unitOfWork.RepoPost.GetAll();
#region Filtros
if (filters.UserId.HasValue)
{
posts = posts.Where(ele => ele.UserId == filters.UserId);
}
if (filters.Date.HasValue)
{
posts = posts.Where(ele => ele.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (!string.IsNullOrWhiteSpace(filters.Description))
{
posts = posts.Where(ele => ele.Description.ToLower().Contains(filters.Description.ToLower()));
}
#endregion
#region Paginacion
var pagePosts = PageList <Post> .Create(posts, filters.PageIndex, filters.PageSize);
#endregion
return(pagePosts);
}
public static DynamicSql SqlJoin(
this DynamicSql query, PostQueryProjection model,
PostQueryFilter filter)
{
query = DynamicSql.DeepClone(query);
var joins = model.GetFieldsArr()
.Where(f => PostQueryProjection.Joins.ContainsKey(f))
.Select(f => PostQueryProjection.Joins[f]);
if (joins.Any())
{
var joinClause = string.Join('\n', joins);
query.DynamicForm = query.DynamicForm
.Replace(DynamicSql.JOIN, joinClause);
if (filter != null)
{
var contentFilters = new List <string>();
if (filter.lang != null)
{
var paramName = query.AddAutoIncrParam(filter.lang);
var postContentLang = $"{nameof(PostContent)}.{nameof(PostContent.Lang)}";
contentFilters.Add($"{postContentLang}=@{paramName}");
}
if (contentFilters.Any())
{
var whereClause = "WHERE " + string.Join(" AND ", contentFilters);
query.DynamicForm = query.DynamicForm
.Replace(PostQueryPlaceholder.POST_CONTENT_FILTER, whereClause);
}
}
}
return(query);
}
public Uri GetPostPaginationUri(PostQueryFilter filter, string actionUrl)
{
// Working with string interpolation.
string baseUrl = $"{_baseUri}{actionUrl}";
return(new Uri(baseUrl));
}
public PagedList <Post> GetPosts(PostQueryFilter postQueryFilter)
{
postQueryFilter.PageNumber = postQueryFilter.PageNumber == 0 ? _options.DefaultPageNumber : postQueryFilter.PageNumber;
postQueryFilter.PageSize = postQueryFilter.PageSize == 0 ? _options.DefaultPageSize : postQueryFilter.PageSize;
var posts = _unitOfWork.PostRepository.GetAll();
if (postQueryFilter.UserId != null)
{
posts = posts.Where(x => x.UserId == postQueryFilter.UserId);
}
if (postQueryFilter.Date != null)
{
posts = posts.Where(x => x.Date.ToShortDateString() == postQueryFilter.Date?.ToShortDateString());
}
if (postQueryFilter.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(postQueryFilter.Description.ToLower()));
}
var pagedPosts = PagedList <Post> .Create(posts, postQueryFilter.PageNumber, postQueryFilter.PageSize);
return(pagedPosts);
}
public IActionResult GetPosts([FromQuery] PostQueryFilter postQueryFilter)
{
PagedList <Post> posts = _getPostsInput.GetPosts(postQueryFilter);
IEnumerable <PostDto> postDtos = _mapper.Map <IEnumerable <PostDto> >(posts);
var metadata = new Metadata
{
TotalCount = posts.TotalCount,
PageSize = posts.PageSize,
CurrentPage = posts.CurrentPage,
TotalPages = posts.TotalPages,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
NextPageUrl = _uriService.GetPostPaginationUri(postQueryFilter, Url.RouteUrl(nameof(GetPosts))).ToString(),
PreviousPageUrl = _uriService.GetPostPaginationUri(postQueryFilter, Url.RouteUrl(nameof(GetPosts))).ToString()
};
ApiResponse <IEnumerable <PostDto> > apiResponse = new ApiResponse <IEnumerable <PostDto> >(postDtos)
{
Meta = metadata
};
//Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(apiResponse));
}
/// <summary>
///
/// </summary>
/// <param name="filter"></param>
/// <param name="actionUri"></param>
/// <returns></returns>
public Uri GetPostPaginationUri(PostQueryFilter filter,
string actionUri)
{
string baseUrl = $"{_baseURI}{actionUri}";
return(new Uri(baseUrl));
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postService.GetPosts(filters);
var postsDto = _mapper.Map <IEnumerable <PostDto> >(posts);
// var response = new ApiResponse<IEnumerable<PostDto>>(postsDto);
var metadata = new Metadata
{
TotalCount = posts.TotalCount,
PageSize = posts.PageSize,
CurrentPage = posts.CurrentPage,
TotalPages = posts.TotalPages,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
// NextPageUrl = posts.NextPageNumber,
// PreviousPageUrl = posts.PreviousPageNumber,
};
var response = new ApiResponse <IEnumerable <PostDto> >(postsDto)
{
Meta = metadata
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
public PagedList <Post> GetPosts(PostQueryFilter filters)
{
//Cuando es un IEnumerable, aun no esta cargada la informacion en memoria, por tanto, se puede usar los filtros en esta clase, si usa un tolist se debe pasar los filtros hasta la parte del repositorio
IEnumerable <Post> posts = unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
posts = posts.Where(x => x.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(x => x.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(filters.Description.ToLower()));
}
//paginacion
PagedList <Post> pagedPosts = PagedList <Post> .Create(posts, filters.PageNumber, filters.PageSize);
return(pagedPosts);
}
public async Task <IActionResult> Get([FromQuery] PostQueryFilter filter,
[FromQuery] PostQuerySort sort,
[FromQuery] PostQueryProjection projection,
[FromQuery] PostQueryPaging paging,
[FromQuery] PostQueryOptions options)
{
var validationResult = _service.ValidateGetPosts(
User, filter, sort, projection, paging, options);
if (!validationResult.Valid)
{
return(BadRequest(validationResult.Result));
}
var result = await _service.QueryPostDynamic(
projection, options, filter, sort, paging);
if (options.single_only)
{
if (result == null)
{
return(NotFound(new AppResultBuilder().NotFound()));
}
return(Ok(new AppResultBuilder().Success(result.SingleResult)));
}
return(Ok(new AppResultBuilder().Success(result)));
}
public PagedList <Post> GetPost(PostQueryFilter filters)
{
filters.PageNumber = filters.PageNumber == 0 ? paginationOptions.DefaultPageNumber : filters.PageNumber;
filters.PageSize = filters.PageSize == 0 ? paginationOptions.DefaultPageSize : filters.PageSize;
var posts = this.unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
posts = posts.Where(x => x.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(x => x.Date.ToShortDateString() == filters.Date.Value.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(filters.Description.ToLower()));
}
var pagedPosts = PagedList <Post> .Create(posts, filters.PageNumber, filters.PageSize);
return(pagedPosts);
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)//FromQuery conseguimos mapear las querys de entrada en el objeto QueryFilter
{
var posts = _postService.GetPosts(filters);
/*var postsDto = posts.Select(x => new PostDto
* {
* PostId = x.PostId,
* Description = x.Description,
* Date = x.Date,
* Image = x.Image,
* UserId = x.UserId
* }) ;*/
var postsDto = _mapper.Map <IEnumerable <PostDto> >(posts);
var metadata = new Metadata
{
TotalCount = posts.TotalCount,
PageSize = posts.PageSize,
CurrentPage = posts.CurrentPage,
TotalPages = posts.TotalPages,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
NextPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString()
};
/* Opcion 1: Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata)); */
//Opcion 2
var response = new ApiResponse <IEnumerable <PostDto> >(postsDto)
{
Meta = metadata
};
return(Ok(response));
}
public IActionResult GetPosts([FromQuery] PostQueryFilter postQueryFilter)
{
var posts = _postService.GetPosts(postQueryFilter);
var postsDTO = _mapper.Map <IEnumerable <PostDTO> >(posts);
var metadata = new Meta
{
TotalCount = posts.TotalCount,
TotalPages = posts.TotalPages,
PageNumber = posts.PageNumber,
PageSize = posts.PageSize,
HasPreviousPage = posts.HasPreviousPage,
HasNextPage = posts.HasNextPage,
PreviousPageNumber = posts.PreviousPageNumber,
NextPageNumber = posts.NextPageNumber,
NextPageUrl = string.Empty,
PreviousPageUrl = string.Empty
};
var response = new ApiResponse <IEnumerable <PostDTO> >(postsDTO)
{
Meta = metadata
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
//public IEnumerable<Post> GetPosts(PostQueryFilter filters)
public PagedList <Post> GetPosts(PostQueryFilter filters)
{
filters.PageNumber = filters.PageNumber == 0 ? _paginationOptions.DefaultPageNumber : filters.PageNumber;
filters.PageSize = filters.PageSize == 0 ? _paginationOptions.DefaultPageSize : filters.PageSize;
var posts = _unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
posts = posts.Where(p => p.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(p => p.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(p => p.Description.ToLower().Contains(filters.Description.ToLower()));
}
//Implementar Paginacion
var pagePosts = PagedList <Post> .Create(posts, filters.PageNumber, filters.PageSize);
return(pagePosts);
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postService.GetPosts(filters);
var postsDtos = _mapper.Map <IEnumerable <PostDto> >(posts);
// var postsDto = posts.Select(x => new PostDto
// {
// PostId = x.PostId,
// Date = x.Date,
// Description = x.Description,
// Image = x.Image,
// UserId = x.UserId
// });
var metadata = new Metadata
{
TotalCount = posts.TotalCount,
PageSize = posts.PageSize,
CurrentPage = posts.CurrentPage,
TotalPages = posts.TotalPages,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
NextPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString(),
PreviousPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString()
};
var response = new ApiResponse <IEnumerable <PostDto> >(postsDtos)
{
Meta = metadata
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postService.GetPosts(filters);
/*var postDtos = posts.Select(post => new PostDto{
* Date = post.Date,
* Description = post.Description
* });
* // Remplace with _mapper : AutoMapper
*/
/* commet for page*/
var postDtos = _mapper.Map <IEnumerable <PostDto> >(posts);
var response = new ApiResponse <IEnumerable <PostDto> >(postDtos);
var metadata = new
{
posts.TotalCount,
posts.PageSize,
posts.CurrentPage,
posts.TotalPages,
posts.HasNextPage,
posts.HasPreviousPage
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
public PagedList <Post> GetPosts(PostQueryFilter filters)
{
filters.PageNumber = filters.PageNumber == 0 ? _paginationOptions.DefaultPageNumber : filters.PageNumber;
filters.PageSize = filters.PageSize == 0 ? _paginationOptions.DefaultPageSize : filters.PageSize;
IEnumerable <Post> posts = _unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
posts = posts.Where(post => post.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(post => post.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(posts => posts.Description.ToLower().Contains(filters.Description.ToLower()));
}
return(PagedList <Post> .Create(posts, filters.PageNumber, filters.PageSize));
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postService.GetPosts(filters);
var postsDto = _mapper.Map <IEnumerable <PostDto> >(posts);
var metadata = new Metadata
{
TotalCount = posts.TotalCount,
TotalPage = posts.TotalPage,
PageSize = posts.PageSize,
CurrentPage = posts.CurrentPage,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
NextPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString(),
PreviousPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString()
};
var response = new ApiResponse <IEnumerable <PostDto> >(postsDto)
{
meta = metadata
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public PageList <Post> Get(PostQueryFilter filters)
{
filters.PageNumer = filters.PageNumer == 0 ? _paginationOptions.DefaultPageNumber : filters.PageNumer;
filters.PageSize = filters.PageSize == 0 ? _paginationOptions.DefaultPageSize : filters.PageSize;
var post = _unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
post = post.Where(x => x.UserId == filters.UserId);
}
if (filters.Date != null)
{
post = post.Where(
x => x.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (filters.Description != null)
{
post = post.Where(
x => x.Description.ToLower() == filters.Description.ToLower());
}
var pagePost = PageList <Post> .Create(post, filters.PageNumer, filters.PageSize);
return(pagePost);
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postService.GetPosts(filters);
var postsDto = _mapper.Map <IEnumerable <PostDto> >(posts);
var response = new ApiResponse <IEnumerable <PostDto> >(postsDto);
return(Ok(response));
}
public ValidationResult ValidateGetPosts(
ClaimsPrincipal principal,
PostQueryFilter filter,
PostQuerySort sort,
PostQueryProjection projection,
PostQueryPaging paging,
PostQueryOptions options)
{
return(ValidationResult.Pass());
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
//var posts = new PostRepository().GetPosts();}
var posts = postServices.GetPosts(filters);
//var postDto = _mapper.Map<PostDto>(posts);
//AutoMapper
var postsDto = _mapper.Map <IEnumerable <PostDto> >(posts);
var metadata = new Metadata
{
TotalPage = posts.TotalPages,
PageSize = posts.PageSize,
TotalCount = posts.TotalCount,
CurrentPage = posts.CurrentPage,
HasNextPage = posts.HasNextPage,
HasPreviuosPage = posts.HasPreviousPage,
//NexPageUrl = _uriService.GetPostPaginationUri(filters,"/api/Post").ToString()
NexPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString(),
PreviuosPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString()
};
var response = new ApiResponse <IEnumerable <PostDto> >(postsDto)
{
Meta = metadata
};
////Implementar Paginacion ojo ** se dejo igual porque el PagedList hereda de un list
//var postsDto = _mapper.Map<PagedList<PostDto>>(posts);
//var response = new ApiResponse<PagedList<PostDto>>(postsDto);
//-------------------------------------------------------------------------------------
//var postsDto = posts.Select(x => new PostDto
//{
// Postid = x.Postid,
// Date = x.Date,
// Image = x.Image,
// UserId = x.UserId
//});
//var metadata = new
//{
// posts.TotalPages,
// posts.PageSize,
// posts.TotalCount,
// posts.CurrentPage,
// posts.HasNextPage,
// posts.HasPreviousPage
//};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata)); ///primera opcion de paginacion
return(Ok(response));
}
public static DynamicSql SqlFilter(
this DynamicSql query, PostQueryFilter filter)
{
query = DynamicSql.DeepClone(query);
var listFilters = new List <string>();
if (filter.id != null)
{
var paramName = query.AddAutoIncrParam(filter.id);
listFilters.Add($"{nameof(Post)}.{nameof(Post.Id)}=@{paramName}");
}
if (filter.type != null)
{
var paramName = query.AddAutoIncrParam(filter.type);
listFilters.Add($"{nameof(Post)}.{nameof(Post.Type)}=@{paramName}");
}
if (filter.loc_id != null)
{
var paramName = query.AddAutoIncrParam(filter.loc_id);
listFilters.Add($"{nameof(Post)}.{nameof(Post.LocationId)}=@{paramName}");
}
if (filter.not_eq_id != null)
{
var paramName = query.AddAutoIncrParam(filter.not_eq_id);
listFilters.Add($"{nameof(Post)}.{nameof(Post.Id)}!=@{paramName}");
}
if (filter.title_contains != null)
{
var paramName = query.AddAutoIncrParam(filter.title_contains);
listFilters.Add($"CHARINDEX(@{paramName}, {nameof(PostContent)}" +
$".{nameof(PostContent.Title)}) > 0");
}
if (filter.ids != null)
{
var listDataParams = query.AddAutoIncrSqlInParam(filter.ids);
listFilters.Add($"{nameof(Post)}.{nameof(Post.Id)} IN ({listDataParams.Placeholder})");
}
if (filter.archived != 2)
{
var paramName = query.AddAutoIncrParam(filter.archived);
listFilters.Add($"{nameof(Post)}.{nameof(Post.Archived)}=@{paramName}");
}
if (listFilters.Any())
{
var whereClause = "WHERE " + string.Join(" AND ", listFilters);
query.DynamicForm = query.DynamicForm.Replace(DynamicSql.FILTER, whereClause);
}
return(query);
}
public PageList <Post> GetPosts(PostQueryFilter filters)
{
var posts = _postRepository.GetPosts();
if (filters.UserId != null)
{
posts = posts.Where(x => x.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(x => x.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(filters.Description.ToLower()));
}
var pagedPosts = PageList <Post> .Create(posts, filters.PageNumber, filters.PageSize);
return(pagedPosts);
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postBusiness.GetPosts(filters);
var postsDto = _mapper.Map <IEnumerable <PostDto> >(posts);
var response = new ApiResponse <IEnumerable <PostDto> >(postsDto);
var metadata = new
{
posts.TotalCount,
posts.PageSize,
posts.CurrentPage,
posts.TotalPages,
posts.HasNextPage,
posts.HasPreviousPage
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters) //PostQueryFilter objeto complejo para mandar multiples parametros
{
PagedList <Post> posts = postService.GetPosts(filters);
PagedList <PostDTO> postsDTO = mapper.Map <PagedList <PostDTO> >(posts);
ApiResponse <PagedList <PostDTO> > response = new ApiResponse <PagedList <PostDTO> >(postsDTO);
//Agregando al header de la respuesta un json
var metadata = new {
posts.TotalCount,
posts.TotalPages,
posts.PageSize,
posts.CurrentPage,
posts.HasNextPage,
posts.HasPreviousPage
};
Response.Headers.Add("X-pagination", JsonConvert.SerializeObject(metadata));
return(Ok(response));
}
public ActionResult Get([FromQuery] PostQueryFilter filters)
{
PagedList <Post> posts = _service.GetPosts(filters);
var uri = _uriService.getPostPaginatedUri(filters, Url.RouteUrl("Post-List"));
var pagginationData = new Metadata
{
Total = posts.TotalPage,
TotalCount = posts.TotalCount,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
NextPageUrl = uri.ToString()
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(pagginationData));
ApiResponse <IEnumerable <PostDto> > response = new ApiResponse <IEnumerable <PostDto> >(
_mapper.Map <List <PostDto> >(posts))
{
meta = pagginationData
};
return(Ok(response));
}
//public IEnumerable<Post> GetPosts()
// (12) Better user query filters:
// public IEnumerable<Post> GetPosts(PostQueryFilter filters)
// (13) Better work with out paginated list entity:
public PagedList <Post> GetPosts(PostQueryFilter filters)
{
//return await _postRepository.GetPosts();
// (10) Better use the generic class:
//return await _postRepository.GetAll();
// (10) Better use unit of work to get access to all repositories in the application
// return await _unitOfWork.PostRepository.GetAll();
// (11) Previous line call is no loger async.
//return _unitOfWork.PostRepository.GetAll();
// (14) Handling empty filters
filters.PageNumber = filters.PageNumber == 0 ? _paginationOptions.DefaultPageNumber : filters.PageNumber;
filters.PageSize = filters.PageSize == 0 ? _paginationOptions.DefaultPageSize : filters.PageSize;
// (12) Better implement filtering
// (12) Filtering logic
var posts = _unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
posts = posts.Where(x => x.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(x => x.Date.Value.ToShortDateString() == filters.Date.Value.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(filters.Description.ToLower()));
}
// (13) Pagination goes after filtering data.
var pagedPosts = PagedList <Post> .Create(posts, filters.PageNumber, filters.PageSize);
return(pagedPosts);
}
public IActionResult GetPosts([FromQuery] PostQueryFilter filters)
{
var posts = _postService.GetPosts(filters);
var postsDtos = _mapper.Map <IEnumerable <PostDTO> >(posts);
var metadata = new Metadata
{
TotalCount = posts.TotalCount,
PageSize = posts.PageSize,
CurrentPage = posts.CurrentPage,
HasNextPage = posts.HasNextPage,
HasPreviousPage = posts.HasPreviousPage,
NextPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString(),
PreviousPageUrl = _uriService.GetPostPaginationUri(filters, Url.RouteUrl(nameof(GetPosts))).ToString()
};
var response = new ApiResponse <IEnumerable <PostDTO> >(postsDtos)
{
Meta = metadata
};
return(Ok(response));
}
public PagedList <Post> GetPosts(PostQueryFilter postQueryFilter)
{
IEnumerable <Post> posts = _getPostsOutput.GetPosts();
postQueryFilter.PageNumber = postQueryFilter.PageNumber == 0 ? _paginationOptions.DefaultPageNumber : postQueryFilter.PageNumber;
postQueryFilter.PageSize = postQueryFilter.PageSize == 0 ? _paginationOptions.DefaultPageSize : postQueryFilter.PageSize;
if (postQueryFilter.UserId != null)
{
posts = posts.Where(x => x.UserId == postQueryFilter.UserId);
}
if (postQueryFilter.Date != null)
{
posts = posts.Where(x => x.Date.ToShortDateString() == postQueryFilter.Date?.ToShortDateString());
}
if (postQueryFilter.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(postQueryFilter.Description.ToLower()));
}
return(PagedList <Post> .Create(posts, postQueryFilter.PageNumber, postQueryFilter.PageSize));
}
public PagedList <Post> GetPosts(PostQueryFilter filters)
{
filters.PageNumber = filters.PageNumber == 0 ? _paginationOption.DefaultPageNumber : filters.PageNumber;
filters.PageSize = filters.PageSize == 0 ? _paginationOption.DefaultPageSize : filters.PageSize;
//A nivel de dominio no debo tener referencia ef ni a temas de infraestructura
var posts = _unitOfWork.PostRepository.GetAll();
if (filters.UserId != null)
{
posts = posts.Where(x => x.UserId == filters.UserId);
}
if (filters.Date != null)
{
posts = posts.Where(x => x.Date.ToShortDateString() == filters.Date?.ToShortDateString());
}
if (filters.Description != null)
{
posts = posts.Where(x => x.Description.ToLower().Contains(filters.Description.ToLower()));
}
var pagedPosts = PagedList <Post> .Create(posts, filters.PageNumber, filters.PageSize);
return(pagedPosts);
}
