public async Task <Cliente> FindByEmail(string email, PaginacaoParametroDto paginacaoParametro)
        {
            var cliente = await GetByExpression(new PaginacaoParametroDto(),
                                                c => c.Pessoa.Email.ToLower().Contains(email.ToLower()), c => c.OrderBy(e => e.Pessoa.Nome), include);

            return(cliente.FirstOrDefault());
        }
        public async Task <IList <Entity> > GetByExpression(PaginacaoParametroDto paginacaoParametro, Expression <Func <Entity, bool> > filter = null,
                                                            Func <IQueryable <Entity>, IOrderedQueryable <Entity> > orderBy = null, params Expression <Func <Entity, object> >[] includes)
        {
            IQueryable <Entity> query = _dbSet;

            if (includes.Any())
            {
                foreach (var include in includes)
                {
                    query = query.AsQueryable().Include(include);
                }
            }

            if (filter != null)
            {
                query = query.Where(filter);
            }

            if (orderBy != null)
            {
                query = orderBy(query.AsQueryable());
            }

            if (paginacaoParametro != null)
            {
                query = query.Skip((paginacaoParametro.Pagina - 1) * paginacaoParametro.ItensPorPagina)
                        .Take(paginacaoParametro.ItensPorPagina)
                        .OrderBy(c => c.Id);
            }

            return(await query.AsNoTracking().ToListAsync());
        }
        public async Task <IList <Cliente> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro)
        {
            var result = await GetByExpression(new PaginacaoParametroDto(),
                                               c => c.Pessoa.Nome.ToLower().Contains(description.ToLower()) || c.Cpf.Contains(description) ||
                                               c.Pessoa.Email != null && c.Pessoa.Email.ToLower().Contains(description.ToLower()), null, include);

            return(result);
        }
        public virtual async Task <IActionResult> GetAll([FromQuery] PaginacaoParametroDto paginacaoParametro)
        {
            var result = await _baseService.GetAll(paginacaoParametro);

            var count = await _baseService.Count();

            return(Ok(new Resultado <Entity>(result, count)));
        }
        public async Task <IList <Livro> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro)
        {
            int.TryParse(description, out int result);

            var livros = await GetByExpression(paginacaoParametro, c => c.Titulo.ToLower().Contains(description.ToLower()) ||
                                               c.Autor.ToLower().Contains(description.ToLower()) || (c.Genero != null && c.Genero.Id == result), null, include);

            return(livros);
        }
Example #6
0
 public async Task <IList <Livro> > FindByTitulo(LivroPesquisa livroPesquisa, PaginacaoParametroDto paginacaoParametro)
 {
     if (livroPesquisa.generoId == 0)
     {
         return(await _livroRepository.FindByTitulo(livroPesquisa, paginacaoParametro));
     }
     else
     {
         return(await _livroRepository.FindByTituloAndGenero(livroPesquisa, paginacaoParametro));
     }
 }
        public virtual async Task <IList <Entity> > GetAll(PaginacaoParametroDto paginacaoParametro = null, params Expression <Func <Entity, object> >[] includes)
        {
            IQueryable <Entity> query = _dbSet;

            if (includes.Any())
            {
                foreach (var include in includes)
                {
                    query = query.Include(include);
                }
            }

            if (paginacaoParametro != null)
            {
                return(await query.OrderBy(c => c.Id)
                       .Skip((paginacaoParametro.Pagina - 1) * paginacaoParametro.ItensPorPagina)
                       .Take(paginacaoParametro.ItensPorPagina)
                       .AsNoTracking()
                       .ToListAsync());
            }

            return(await query.AsNoTracking().ToListAsync());
        }
 public async Task <Cliente> FindByEmail(string email, PaginacaoParametroDto paginacaoParametro)
 {
     return(await _clienteRepository.FindByEmail(email, paginacaoParametro));
 }
 public override Task <IList <Genero> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro)
 {
     throw new System.NotImplementedException();
 }
 public override async Task <IList <InstituicaoEnsino> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro)
 {
     return(await _instituicaoEnsinoRepository.FindByDescription(Uri.UnescapeDataString(description), paginacaoParametro));
 }
 public override async Task <IList <InstituicaoEnsino> > GetAll(PaginacaoParametroDto paginacaoParametro)
 {
     return(await base.GetAll(paginacaoParametro));
 }
        public async Task <IActionResult> FindByGenero(int id, [FromQuery] PaginacaoParametroDto paginacaoParametro)
        {
            var result = await _livroService.FindByGenero(id, paginacaoParametro);

            return(Ok(new Resultado <Livro>(result, result.Count)));
        }
 public override async Task <IList <Cliente> > GetAll(PaginacaoParametroDto paginacaoParametro)
 {
     return(await base.GetAll(paginacaoParametro));
 }
 public async Task <IList <Livro> > FindByGenero(int generoId, PaginacaoParametroDto paginacaoParametro)
 {
     return(await GetByExpression(paginacaoParametro, c => c.Genero.Id == generoId, c => c.OrderBy(e => e.Titulo), include));
 }
 public async Task <IList <Livro> > FindByAutor(LivroPesquisa livroPesquisa, PaginacaoParametroDto paginacaoParametro)
 {
     return(await GetByExpression(paginacaoParametro,
                                  c => c.Autor.ToLower().Contains(livroPesquisa.description.ToLower()), c => c.OrderBy(e => e.Autor), include));
 }
Example #16
0
 public async Task <IList <InstituicaoEnsino> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro)
 {
     return(await GetByExpression(paginacaoParametro, c => c.Cnpj.Contains(description) || c.Pessoa.Nome.ToLower().Contains(description.ToLower()), null, include));
 }
Example #17
0
 public async Task <IList <InstituicaoEnsino> > FindInstituicaoByName(string name, PaginacaoParametroDto paginacaoParametro)
 {
     return(await GetByExpression(paginacaoParametro, c => c.Pessoa.Nome.ToLower().Contains(name.ToLower()), null, include));
 }
        public async Task <IActionResult> FindByDescription(string description, [FromQuery] PaginacaoParametroDto paginacaoParametro)
        {
            var result = await _livroService.FindByDescription(description, paginacaoParametro);

            return(Ok(new Resultado <Livro>(result, result.Count)));
        }
 public async Task <IList <Cliente> > FindByName(string name, PaginacaoParametroDto paginacaoParametro)
 {
     return(await _clienteRepository.FindByName(name, paginacaoParametro));
 }
 public override async Task <IList <Cliente> > GetAll(PaginacaoParametroDto paginacaoParametro = null, params Expression <Func <Cliente, object> >[] includes)
 {
     return(await base.GetAll(paginacaoParametro, c => c.Pessoa));
 }
        public override async Task <IList <Cliente> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro)
        {
            var result = await _clienteRepository.FindByDescription(description, paginacaoParametro);

            return(result);
        }
 public virtual async Task <IList <Entity> > GetByExpression(PaginacaoParametroDto paginacaoParametro,
                                                             Expression <Func <Entity, bool> > filter = null, Func <IQueryable <Entity>, IOrderedQueryable <Entity> > orderBy = null, params Expression <Func <Entity, object> >[] includes)
 {
     return(await _repository.GetByExpression(paginacaoParametro, filter, orderBy, includes));
 }
        public async Task <IList <Livro> > FindByGeneroAndDescription(int generoId, string description, PaginacaoParametroDto paginacaoParametro)
        {
            var livros = await GetByExpression(paginacaoParametro, c => c.Titulo.ToLower().Contains(description.ToLower()) ||
                                               c.Autor.ToLower().Contains(description.ToLower()), null, include);

            return(livros.Where(c => c.Genero.Id == generoId).ToList());
        }
        public async Task <IActionResult> FindByTitulo(string titulo, [FromQuery] PaginacaoParametroDto paginacaoParametro)
        {
            var result = await _livroService.FindByTitulo(new LivroPesquisa(titulo, 0), paginacaoParametro);

            return(Ok(new Resultado <Livro>(result, result.Count)));
        }
 public async Task <IList <Cliente> > FindByName(string name, PaginacaoParametroDto paginacaoParametro)
 {
     return(await GetByExpression(new PaginacaoParametroDto(), c => c.Pessoa.Nome.ToLower().Contains(name.ToLower()), c => c.OrderBy(e => e.Pessoa.Nome), include));
 }
 public async Task <IList <Livro> > FindByTituloAndGenero(LivroPesquisa livroPesquisa, PaginacaoParametroDto paginacaoParametro)
 {
     return(await GetByExpression(paginacaoParametro, c => c.Titulo.ToLower().Contains(livroPesquisa.description.ToLower()) && c.Genero.Id == livroPesquisa.generoId,
                                  c => c.OrderBy(e => e.Titulo), include));
 }
 public virtual async Task <IList <Entity> > GetAll(PaginacaoParametroDto paginacaoParametro = null)
 {
     return(await _repository.GetAll(paginacaoParametro));
 }
 public override async Task <IList <Livro> > GetAll(PaginacaoParametroDto paginacaoParametro = null, params Expression <Func <Livro, object> >[] includes)
 {
     return(await base.GetAll(paginacaoParametro, include));
 }
 public abstract Task <IList <Entity> > FindByDescription(string description, PaginacaoParametroDto paginacaoParametro);
 public async Task <IList <InstituicaoEnsino> > FindInstituicaoByName(string name, PaginacaoParametroDto paginacaoParametro)
 {
     return(await _instituicaoEnsinoRepository.FindInstituicaoByName(name, paginacaoParametro));
 }