Пример #1
0
        public async Task <int> InserirEditar(ProdutoInserirEditarDto produtoDto)
        {
            await _validarProduto.ValidateAndThrowAsync(produtoDto);

            Produto produto = null;

            if (produtoDto.Id == null)
            {
                produto = new Produto();

                _lojaContext.Add(produto);
            }
            else
            {
                produto = await _lojaContext
                          .Set <Produto>()
                          .Where(p => p.Id == produtoDto.Id)
                          .FirstOrDefaultAsync();

                ChecarSe.Encontrou(produto);
            }

            produto.Descricao = produtoDto.Descricao;
            produto.Valor     = produtoDto.Valor;

            await _lojaContext.SaveChangesAsync();

            return(produto.Id);
        }
Пример #2
0
        public async Task <IEnumerable <object> > GetAllPagination(int pageNumber,
                                                                   int pageSize,
                                                                   Func <T, int> orderByFunc,
                                                                   Func <T, bool> countFunc,
                                                                   Func <T, bool> predicate)
        {
            using (DbContext = new LojaContext())
            {
                DbContext.Configuration.AutoDetectChangesEnabled = false;
                var recordsTotal = DbContext.Set <T>().Count(countFunc);


                var list = DbContext.Set <T>()
                           .OrderBy(orderByFunc)
                           .Where(predicate)
                           .Skip(pageSize * (pageNumber - 1))
                           .Take(pageSize)
                           .ToList();

                var lista = new List <object>
                {
                    new
                    {
                        recordsTotal,
                        list
                    }
                };


                return(await Task.Factory.StartNew(() => lista));
            }
        }
Пример #3
0
            public async Task <int> Handle(Command request, CancellationToken cancellationToken)
            {
                await _validar.ValidateAndThrowAsync(request);

                Produto produto;

                if (request.Id == null)
                {
                    produto = new Produto();

                    _lojaContext.Add(produto);
                }
                else
                {
                    produto = await _lojaContext
                              .Set <Produto>()
                              .FirstOrDefaultAsync(p => p.Id == request.Id);

                    ChecarSe.Encontrou(produto);
                }

                Mapear(produto, request);

                await _lojaContext.SaveChangesAsync();

                return(produto.Id);
            }
Пример #4
0
 private async Task <bool> SerUnico(Command request, string descricao, CancellationToken arg2)
 {
     return(!await _lojaContext
            .Set <Produto>()
            .Where(p => p.Descricao == request.Descricao && p.Id != request.Id)
            .AnyAsync());
 }
 private async Task <bool> SerUnico(ProdutoInserirEditarDto produto, string descricao, CancellationToken arg2)
 {
     return(!await _lojaContext
            .Set <Produto>()
            .Where(p => p.Descricao == produto.Descricao && p.Id != produto.Id)
            .AnyAsync());
 }
Пример #6
0
 public new  async Task <UsuarioPerfil> GetById(int id)
 {
     using (DbContext = new LojaContext())
     {
         return(await DbContext.Set <UsuarioPerfil>().Where(perfil => perfil.UsuarioPerfilId == id)
                .Include(perfil => perfil.Usuarios).Include(perfil => perfil.ServicoUsuarioPerfil).FirstOrDefaultAsync());
     }
 }
Пример #7
0
 public async Task <List <T> > GetAll(Func <T, bool> predicate)
 {
     using (DbContext = new LojaContext())
     {
         DbContext.Configuration.AutoDetectChangesEnabled = false;
         return(await Task.Factory.StartNew(() => DbContext.Set <T>().Where(predicate).ToList()));
     }
 }
Пример #8
0
 public async Task <T> GetById(int id)
 {
     using (DbContext = new LojaContext())
     {
         DbContext.Configuration.AutoDetectChangesEnabled = false;
         return(await DbContext.Set <T>().FindAsync(id));
     }
 }
Пример #9
0
 public async Task <List <T> > GetAll()
 {
     using (DbContext = new LojaContext())
     {
         DbContext.Configuration.AutoDetectChangesEnabled = false;
         return(await DbContext.Set <T>().ToListAsync());
     }
 }
Пример #10
0
 public async Task <List <ServicoUsuarioPerfil> > GetServicoUsarioPerilList(Func <ServicoUsuarioPerfil, bool> predicate)
 {
     using (DbContext = new LojaContext())
     {
         DbContext.Configuration.AutoDetectChangesEnabled = false;
         return(await Task.Factory.StartNew(() => DbContext.Set <ServicoUsuarioPerfil>().
                                            Include(perfil => perfil.UsuarioPerfil).Include(perfil => perfil.Servico).Where(predicate).ToList()));
     }
 }
Пример #11
0
        public async Task <ClienteListarDto[]> Listar(PesquisaDto pesquisa)
        {
            var query = _lojaContext
                        .Set <Cliente>()
                        .AsNoTracking()
                        .AsQueryable();

            if (pesquisa.Nome != null && pesquisa.CpfOuCnpj != null)
            {
                query = query.Where(p => p.Nome == pesquisa.Nome || p.CpfOuCnpj == pesquisa.CpfOuCnpj);
            }
            else
            if (pesquisa.Nome != null)
            {
                query = query.Where(p => p.Nome == pesquisa.Nome);
            }
            else
            if (pesquisa.CpfOuCnpj != null)
            {
                query = query.Where(p => p.CpfOuCnpj == pesquisa.CpfOuCnpj);
            }

            switch (pesquisa.Ordenacao)
            {
            case PesquisaOrdenacaoDto.Nome:
                query = query.OrderBy(p => p.Nome);
                break;

            case PesquisaOrdenacaoDto.CpfOuCnpj:
                query = query.OrderBy(p => p.CpfOuCnpj);
                break;
            }

            var resultado = await query
                            .Select(p => new ClienteListarDto
            {
                Id   = p.Id,
                Nome = p.Nome
            })
                            .ToArrayAsync();

            return(resultado);
        }
Пример #12
0
        public async Task Add(T obj)
        {
            using (DbContext = new LojaContext())
            {
                DbContext.Configuration.AutoDetectChangesEnabled = false;
                DbContext.Set <T>().Add(obj);
                await DbContext.SaveChangesAsync();

                DbContext.Configuration.AutoDetectChangesEnabled = true;
            }
        }
Пример #13
0
            protected override async Task Handle(Command request, CancellationToken cancellationToken)
            {
                var produto = await _lojaContext
                              .Set <Produto>()
                              .FirstOrDefaultAsync(p => p.Id == request.Id);

                ChecarSe.Encontrou(produto);

                _lojaContext.Remove(produto);

                await _lojaContext.SaveChangesAsync();
            }
Пример #14
0
 public void Delete(int id, Cliente cliente)
 {
     cliente = lojaContext.Clientes.Find(id);
     lojaContext.Set <Cliente>().Remove(cliente);
     try
     {
         lojaContext.SaveChanges();
     }
     catch
     {
     }
 }
Пример #15
0
        public async Task Add(List <T> obj)
        {
            using (DbContext = new LojaContext())
            {
                foreach (var item in obj)
                {
                    DbContext.Configuration.AutoDetectChangesEnabled = false;
                    DbContext.Set <T>().Add(item);
                    await DbContext.SaveChangesAsync();

                    DbContext.Configuration.AutoDetectChangesEnabled = true;
                }
            }
        }
Пример #16
0
        public async Task <Usuario> Authenticantion(string email, string senha)
        {
            using (var loja = new LojaContext())
            {
                loja.Configuration.AutoDetectChangesEnabled = false;
                senha = PasswordAssertionConcern.Encrypt(senha);


                return(await loja.Set <Usuario>()
                       .Where(
                           user =>
                           user.Ativo == true && user.Email == email &&
                           user.Senha == senha)
                       .Include(usuario => usuario.UsuarioPerfil)
                       .Include(usuario => usuario.Empresa).FirstOrDefaultAsync());
            }
        }
Пример #17
0
            public async Task <ProdutoDto[]> Handle(Query request, CancellationToken cancellationToken)
            {
                var query = _lojaContext
                            .Set <Produto>()
                            .AsTracking()
                            .AsQueryable();

                if (!string.IsNullOrWhiteSpace(request.Pesquisa))
                {
                    query = query.Where(p => p.Descricao.StartsWith(request.Pesquisa));
                }

                return(await query
                       .Select(p => new ProdutoDto
                {
                    Id = p.Id,
                    Descricao = p.Descricao
                })
                       .OrderBy(p => p.Descricao)
                       .ToArrayAsync());
            }
        /// <summary>
        /// Sobre escrever o methodo retornar o incluid
        /// </summary>
        /// <param name="predicate"></param>
        /// <returns></returns>
        public new async Task <List <UsuarioPerfilMenu> > GetAll(Func <UsuarioPerfilMenu, bool> predicate)
        {
            var query = await Task.Factory.StartNew(() => _lojaContext.Set <UsuarioPerfilMenu>().
                                                    Include(menu => menu.Menu)
                                                    .Where(predicate).OrderBy(menu => menu.Menu.Ordem).ToList());

            return(query.FindAll(delegate(UsuarioPerfilMenu menu)
            {
                var listRemove = menu.Menu
                                 .MenuCollection
                                 .Where(m => !m.UsuarioPerfilMenus
                                        .Exists(perfilMenu => perfilMenu.UsuarioPerfilId == menu.UsuarioPerfilId))
                                 .ToList();

                foreach (var list in listRemove)
                {
                    menu.Menu.MenuCollection.Remove(list);
                }

                return true;
            }));
        }
Пример #19
0
 // GET: Pedido/Create
 public IActionResult Create()
 {
     ViewData["RoupaId"] = new SelectList(_context.Set <Roupa>(), "RoupaId", "RoupaId");
     return(View());
 }
 public void Delete(int id, Fornecedor fornecedor)
 {
     fornecedor = lojaContext.Fornecedores.Find(id);
     lojaContext.Set <Fornecedor>().Remove(fornecedor);
     lojaContext.SaveChanges();
 }
Пример #21
0
 public Repository(LojaContext context)
 {
     Context = context;
     DbSet   = context.Set <TEntity>();
 }
 public void Delete(int id, Usuario usuario)
 {
     usuario = lojaContext.Usuarios.Find(id);
     lojaContext.Set <Usuario>().Remove(usuario);
     lojaContext.SaveChanges();
 }
Пример #23
0
 public Repository(LojaContext context)
 {
     _context = context;
     _db      = context.Set <TEntity>();
 }
Пример #24
0
 // GET: Confeccao/Create
 public IActionResult Create()
 {
     ViewData["tipoProdutoId"] = new SelectList(_context.Set <TipoProduto>(), "tipoProdutoId", "tipoProdutoId");
     return(View());
 }
Пример #25
0
 public void Delete(int id, Venda venda)
 {
     venda = lojaContext.Vendas.Find(id);
     lojaContext.Set <Venda>().Remove(venda);
     lojaContext.SaveChanges();
 }
Пример #26
0
 public void Delete(int id, Produto produto)
 {
     produto = lojaContext.Produtos.Find(id);
     lojaContext.Set <Produto>().Remove(produto);
     lojaContext.SaveChanges();
 }
Пример #27
0
 public IList <T> ListAll()
 {
     return(context.Set <T>().ToList());
 }