public async virtual Task <IHttpActionResult> Get(int id, [FromUri] PaggingCriteria <Edicao> pagging)
{
try
{
// validate
if (id == 0)
{
return(BadRequest("Identifier is required."));
}
// partial pagging
ApplyDetailPagging(pagging);
var result = await FacadeBO.Edicao.GetByIdAsync(id, pagging);
if (result == null)
{
return(NotFound());
}
// apply hateaos
var links = new List <LinkResult>();
links.Add(GetLinkSelf("edicao_get_id", new { id = id }));
links.Add(GetLinkCollection("edicao_get"));
links.Add(GetLinkItemCreate("edicao_add"));
links.Add(GetLinkItemEdit("edicao_modify"));
links.Add(GetLinkItemDelete("edicao_delete"));
return(Ok(ItemResult(result, links.ToArray())));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public void SetLinkPaging <T, U>(string routeName, PaggingResult <T> result, PaggingCriteria <U> pagging, HateoasMethodType method)
{
var link = HateoasHelper.CreateLink(Request, routeName, result, pagging, HateoasType.First, method);
if (link != null)
{
result.Links.Add(link);
}
link = HateoasHelper.CreateLink(Request, routeName, result, pagging, HateoasType.Previous, method);
if (link != null)
{
result.Links.Add(link);
}
link = HateoasHelper.CreateLink(Request, routeName, result, pagging, HateoasType.Next, method);
if (link != null)
{
result.Links.Add(link);
}
link = HateoasHelper.CreateLink(Request, routeName, result, pagging, HateoasType.Last, method);
if (link != null)
{
result.Links.Add(link);
}
}
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Logic.IQueryBaseBO{T}.GetByIdAsync(int, PaggingCriteria{T})"/>
/// </summary>
public virtual Task <T> GetByIdAsync(object id, PaggingCriteria <T> criteria)
{
try
{
return(this.UnitOfWork.GetRepository <T>().GetByIdAsync(id, criteria));
}
catch (Exception ex)
{
Logging.Error(ex);
}
return(TaskResult(default(T)));
}
public virtual R MapperGetById <R>(object id, PaggingCriteria <T> criteria)
{
try
{
PaggingResult <T> .InitializeMapper <R>();
var result = this.UnitOfWork.GetRepository <T>().GetById(id, criteria);
return(Mapper.Map <T, R>(result));
}
catch (Exception ex)
{
Logging.Error(ex);
}
return(default(R));
}
public virtual Task <R> MapperGetByIdAsync <R>(object id, PaggingCriteria <T> criteria)
{
try
{
PaggingResult <T> .InitializeMapper <R>();
return(Task.FromResult(Mapper.Map <T, R>(this.UnitOfWork.GetRepository <T>().GetById(id, criteria))));
}
catch (Exception ex)
{
Logging.Error(ex);
}
return(TaskResult(default(R)));
}
public async virtual Task <IHttpActionResult> Get([FromUri] PaggingCriteria <Edicao> pagging, [FromUri] Edicao model)
{
try
{
if (pagging == null)
{
pagging = new PaggingCriteria <Edicao>();
}
// partial filters
var clauseExpr = PredicateBuilder.True <Edicao>();
if (model != null)
{
ApplyListFilter(model, ref clauseExpr);
}
// partial pagging
ApplyListPagging(pagging);
// get by filters
var result = await FacadeBO.Edicao.GetByAsync(clauseExpr, pagging);
if (result == null || result.Data.Count == 0)
{
return(NotFound());
}
SetLinkPaging("edicao_get", result, pagging);
result.Links.Add(GetLinkSelf("edicao_get", result, pagging));
result.Links.Add(GetLinkItem("edicao_get_id"));
result.Links.Add(GetLinkItemCreate("edicao_add"));
result.Links.Add(GetLinkItemEdit("edicao_modify"));
result.Links.Add(GetLinkItemDelete("edicao_delete"));
return(Ok(result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public virtual Task <PaggingResult <R> > MapperListAsync <R>(PaggingCriteria <T> criteria)
{
try
{
int limit = MaxQtyByQueryPage;
int offset = 0;
if (criteria != null)
{
limit = criteria.Limit > 0 ? criteria.Limit : limit;
offset = criteria.Offset;
}
var repo = UnitOfWork.GetRepository <T>();
var totalCount = repo.ListCount();
var totalPages = (int)Math.Ceiling((double)totalCount / limit);
var items = repo.List(criteria);
var result = PaggingResult <R> .TaskMapper(items,
new PageResult()
{
Count = items.Count,
Offset = offset,
Limit = limit
}, new SummaryResult()
{
TotalCount = totalCount,
TotalPages = totalPages
});
return(result);
}
catch (Exception ex)
{
Logging.Error(ex);
}
return(TaskResult(new PaggingResult <R>()));
}
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Logic.IQueryBaseBO{T}.GetBy(Expression{Func{T, bool}}, PaggingCriteria{T})"/>
/// </summary>
public virtual PaggingResult <T> GetBy(Expression <Func <T, bool> > clause, PaggingCriteria <T> criteria)
{
try
{
int limit = MaxQtyByQueryPage;
int offset = 0;
if (criteria != null)
{
limit = criteria.Limit > 0 ? criteria.Limit : limit;
offset = criteria.Offset;
}
var repo = UnitOfWork.GetRepository <T>();
var totalCount = repo.GetByCount(clause);
var totalPages = (int)Math.Ceiling((double)totalCount / limit);
var items = repo.GetBy(clause, criteria);
var result = PaggingResult <T> .Create(items,
new PageResult()
{
Count = items.Count,
Offset = offset,
Limit = limit
}, new SummaryResult()
{
TotalCount = totalCount,
TotalPages = totalPages
});
return(result);
}
catch (Exception ex)
{
Logging.Error(ex);
}
return(new PaggingResult <T>());
}
public async virtual Task <IHttpActionResult> GetLookup([FromUri] PaggingCriteria <Livro> pagging, [FromUri] Livro model)
{
try
{
if (pagging == null)
{
pagging = new PaggingCriteria <Livro>();
}
// partial filters
var clauseExpr = PredicateBuilder.True <Livro>();
if (model != null)
{
ApplyLookupFilter(model, ref clauseExpr);
}
// partial pagging
ApplyLookupPagging(pagging);
// get by filters
var result = await FacadeBO.Livro.MapperGetByAsync <LivroLookup>(clauseExpr, pagging);
if (result == null || result.Data.Count == 0)
{
return(NotFound());
}
SetLinkPaging("livro_get", result, pagging);
result.Links.Add(GetLinkSelf("livro_get", result, pagging));
result.Links.Add(GetLinkItem("livro_get_id"));
result.Links.Add(GetLinkCollection("livro_get"));
return(Ok(result));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyDetailPagging(PaggingCriteria <EditoraTelefone> pagging);
partial void ApplyListPagging(PaggingCriteria <Livro> paging)
{
//paging.NavigationExpression.Add(n => n.LivroGeneroObject);
}
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyListPagging(PaggingCriteria <LivroGenero> pagging);
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyListPagging(PaggingCriteria <EditoraTelefone> pagging);
public void SetLinkPaging <T, U>(string routeName, PaggingResult <T> result, PaggingCriteria <U> pagging)
{
SetLinkPaging(routeName, result, pagging, HateoasMethodType.GET);
}
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyDetailPagging(PaggingCriteria <LivroGenero> pagging);
IQueryable <T> GetQuery(PaggingCriteria <T> clause, bool onlyNavigation = false)
{
// TODO: apply filter global
// QueryFilterManager.Filter<EntityBase>(q => q.Where(x => x.RemovedOn == null));
// TODO: apply column filter with logical exclusion
// var query = this.dbEntities.Where(x => x.RemovedOn == null);
var query = this.dbEntities.AsQueryable();
var ordered = false;
if (clause != null)
{
// navigation by expression
if (clause.NavigationExpression != null && clause.NavigationExpression.Count > 0)
{
foreach (var nav in clause.NavigationExpression)
{
query = query.Include(nav);
}
}
// navigation by string
if (clause.Navigation != null && clause.Navigation.Count > 0)
{
foreach (var nav in clause.Navigation)
{
query = query.Include(nav);
}
}
}
if (!onlyNavigation)
{
int offset = 0;
int limit = MaxQtyByQueryPage;
if (clause != null)
{
// ordination
if (clause.OrderBy != null && clause.OrderBy.Count > 0)
{
IOrderedQueryable <T> queryOrdered = null;
foreach (var ord in clause.OrderBy)
{
if (queryOrdered == null)
{
ordered = true;
queryOrdered = query.OrderBy(ord);
}
else
{
queryOrdered = queryOrdered.ThenBy(ord);
}
}
query = queryOrdered ?? query;
}
// pagging
offset = clause.Offset;
limit = clause.Limit > 0 ? clause.Limit : limit;
}
if (!ordered)
{
query = SortByKey(query, GetKeyInfo());
}
// page index
query = query.Skip(limit * offset);
// number of records per page
query = query.Take(limit);
}
return(query);
}
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyDetailPagging(PaggingCriteria <Edicao> pagging);
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyDetailPagging(PaggingCriteria <LivroAutor> pagging);
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyDetailPagging(PaggingCriteria <AutorTelefone> pagging);
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Data.IRepository.GetBy(Expression{Func{T, bool}}, PaggingCriteria{T})"/>
/// </summary>
public IList <T> GetBy(Expression <Func <T, bool> > clause, PaggingCriteria <T> criteria)
{
return(GetQuery(criteria).Where(clause).ToList());
}
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Data.IRepository.ListAsync(PaggingCriteria{T})"/>
/// </summary>
public Task <List <T> > ListAsync(PaggingCriteria <T> clause)
{
return(GetQuery(clause).ToListAsync());
}
public LinkResult GetLinkCollection <T, U>(string routeName, PaggingResult <T> result, PaggingCriteria <U> pagging)
{
return(GetLinkCollection(routeName, result, pagging, HateoasMethodType.GET));
}
partial void ApplyLookupPagging(PaggingCriteria <Livro> paging)
{
ApplyListPagging(paging);
}
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Data.IRepository.List(PaggingCriteria{T})"/>
/// </summary>
public IList <T> List(PaggingCriteria <T> clause)
{
return(GetQuery(clause).ToList());
}
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyListPagging(PaggingCriteria <Edicao> pagging);
/// <summary> /// Apply pagging for listing /// </summary> partial void ApplyListPagging(PaggingCriteria <LivroAutor> pagging);
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Data.IRepository.GetByAsync(Expression{Func{T, bool}}, PaggingCriteria{T})"/>
/// </summary>
public Task <List <T> > GetByAsync(Expression <Func <T, bool> > clause, PaggingCriteria <T> criteria)
{
return(GetQuery(criteria).Where(clause).ToListAsync());
}
public LinkResult GetLinkCollection <T, U>(string routeName, PaggingResult <T> result, PaggingCriteria <U> pagging, HateoasMethodType method)
{
return(HateoasHelper.CreateLink(Request, routeName, result, pagging, HateoasType.Collection, method));
}
partial void ApplyListPagging(PaggingCriteria <LivroGenero> pagging)
{
// pagging.NavigationExpression.Add(x => x.LivroList);
}
/// <summary>
/// <see cref="SistemaBiblioteca.Domain.Contract.Data.IRepository.GetByIdAsync(int, PaggingCriteria{T})"/>
/// </summary>
public Task <T> GetByIdAsync(object id, PaggingCriteria <T> clause)
{
return(GetDynamicFilter(GetQuery(clause, true), GetKeyInfo(), id).SingleOrDefaultAsync());
}
