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);
}
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));
}
}
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);
}
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());
}
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());
}
}
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()));
}
}
public async Task <T> GetById(int id)
{
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
return(await DbContext.Set <T>().FindAsync(id));
}
}
public async Task <List <T> > GetAll()
{
using (DbContext = new LojaContext())
{
DbContext.Configuration.AutoDetectChangesEnabled = false;
return(await DbContext.Set <T>().ToListAsync());
}
}
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()));
}
}
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);
}
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;
}
}
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();
}
public void Delete(int id, Cliente cliente)
{
cliente = lojaContext.Clientes.Find(id);
lojaContext.Set <Cliente>().Remove(cliente);
try
{
lojaContext.SaveChanges();
}
catch
{
}
}
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;
}
}
}
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());
}
}
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;
}));
}
// 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();
}
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();
}
public Repository(LojaContext context)
{
_context = context;
_db = context.Set <TEntity>();
}
// GET: Confeccao/Create
public IActionResult Create()
{
ViewData["tipoProdutoId"] = new SelectList(_context.Set <TipoProduto>(), "tipoProdutoId", "tipoProdutoId");
return(View());
}
public void Delete(int id, Venda venda)
{
venda = lojaContext.Vendas.Find(id);
lojaContext.Set <Venda>().Remove(venda);
lojaContext.SaveChanges();
}
public void Delete(int id, Produto produto)
{
produto = lojaContext.Produtos.Find(id);
lojaContext.Set <Produto>().Remove(produto);
lojaContext.SaveChanges();
}
public IList <T> ListAll()
{
return(context.Set <T>().ToList());
}