public async Task <TerciarizacionDTO> Actualizar(TerciarizacionDTO terciarizacionDTO)
{
try
{
if (terciarizacionDTO != null)
{
Terciarizacion terciarizaDB = await db.Terciarizaciones.Include(i => i.Proveedor).SingleAsync(f => f.Id == terciarizacionDTO.Id);
Terciarizacion terciariza = mapper.Map <TerciarizacionDTO, Terciarizacion>(terciarizacionDTO, terciarizaDB);
db.Entry(terciariza.Proveedor).State = EntityState.Unchanged;
var update = db.Terciarizaciones.Update(terciariza);
await db.SaveChangesAsync();
return(mapper.Map <Terciarizacion, TerciarizacionDTO>(update.Entity));
}
else
{
return(null);
}
}
catch (Exception e)
{
return(null);
}
}
public async Task <FuncionarioDTO> Actualizar(FuncionarioDTO funcionarioDTO)
{
try
{
if (funcionarioDTO != null)
{
Funcionario funcionarioDB = await db.Funcionarios.Include(i => i.Proveedor).SingleAsync(f => f.Id == funcionarioDTO.Id);
Funcionario funcionario = mapper.Map <FuncionarioDTO, Funcionario>(funcionarioDTO, funcionarioDB);
db.Entry(funcionario.Proveedor).State = EntityState.Unchanged;
var updateFuncionario = db.Funcionarios.Update(funcionario);
await db.SaveChangesAsync();
return(mapper.Map <Funcionario, FuncionarioDTO>(updateFuncionario.Entity));
}
else
{
return(null);
}
}
catch (Exception e)
{
return(null);
}
}
public async Task <IngresoDTO> Actualizar(IngresoDTO ingresoDTO)
{
try
{
if (ingresoDTO != null)
{
Ingreso ingresoDB = await db.Ingresos.Include(i => i.Proveedor).SingleAsync(s => s.Id == ingresoDTO.Id);
Ingreso ingreso = mapper.Map <IngresoDTO, Ingreso>(ingresoDTO, ingresoDB);
db.Entry(ingreso.Proveedor).State = EntityState.Unchanged;
db.Entry(ingreso.Funcionario).State = EntityState.Unchanged;
var updateIngreso = db.Ingresos.Update(ingreso);
await db.SaveChangesAsync();
return(mapper.Map <Ingreso, IngresoDTO>(updateIngreso.Entity));
}
else
{
return(null);
}
}
catch (Exception e)
{
return(null);
}
}
public async Task <UsuarioDTO> Agregar(UsuarioDTO usuarioDTO)
{
try
{
string passInicial = Generador.GenerarPassword(25);
usuarioDTO.Token = Generador.GenerarToken();
Usuario usuario = mapper.Map <UsuarioDTO, Usuario>(usuarioDTO);
usuario.Password = Encriptacion.GetSHA256(passInicial);
Proveedor proveedorBuscado = null;
if (usuarioDTO.Proveedor != null)
{
proveedorBuscado = await db.Proveedores.FindAsync(usuarioDTO.Proveedor.Id);
}
if (proveedorBuscado != null && usuarioDTO.TipoUsuario == SD.TipoUsuario.ProveedorIngPlt.ToString())
{
//guardar en BD
db.Entry(proveedorBuscado).State = EntityState.Unchanged;
usuario.Proveedor = proveedorBuscado;
var addUsuario = await db.Usuarios.AddAsync(usuario);
await db.SaveChangesAsync();
UsuarioDTO uFinal = mapper.Map <Usuario, UsuarioDTO>(addUsuario.Entity);
uFinal.PassInicial = passInicial;
return(uFinal);
}
else if (usuarioDTO.TipoUsuario != SD.TipoUsuario.ProveedorIngPlt.ToString())
{
var addUsuario = await db.Usuarios.AddAsync(usuario);
await db.SaveChangesAsync();
UsuarioDTO uFinal = mapper.Map <Usuario, UsuarioDTO>(addUsuario.Entity);
uFinal.PassInicial = passInicial;
return(uFinal);
}
else
{
return(null);
}
}
catch (Exception e)
{
return(null);
}
}
public async Task Handle(ClienteCrearComando comando, CancellationToken cancellation)
{
await _context.AddAsync(new Cliente
{
Nombre = comando.Nombre
});
await _context.SaveChangesAsync();
}
public async Task Handle(ProductoCrearComando comando, CancellationToken cancellation)
{
await _context.AddAsync(new Producto
{
Nombre = comando.Nombre,
Descripcion = comando.Descripcion,
Precio = comando.Precio
});
await _context.SaveChangesAsync();
}
public async Task <IngresoDiarioDTO> Actualizar(IngresoDiarioDTO funcionarioDTO)
{
try
{
if (funcionarioDTO != null)
{
IngresoDiario ingDiarioBD = await db.IngresosDiarios.FindAsync(funcionarioDTO.Id);
IngresoDiario ingresoDiario = mapper.Map <IngresoDiarioDTO, IngresoDiario>(funcionarioDTO, ingDiarioBD);
var updateIngresoDiario = db.IngresosDiarios.Update(ingresoDiario);
await db.SaveChangesAsync();
return(mapper.Map <IngresoDiario, IngresoDiarioDTO>(updateIngresoDiario.Entity));
}
else
{
return(null);
}
}
catch (Exception e)
{
return(null);
}
}
public async Task <ProveedorDTO> ActualizarProveedor(int proveedorId, ProveedorDTO proveedorDTO)
{
try
{
if (proveedorId == proveedorDTO.Id)
{
Proveedor proveedorDB = await db.Proveedores.FindAsync(proveedorId);
Proveedor proveedor = mapper.Map <ProveedorDTO, Proveedor>(proveedorDTO, proveedorDB);
proveedor.Activo = true;
var updateProveedor = db.Proveedores.Update(proveedor);
await db.SaveChangesAsync();
return(mapper.Map <Proveedor, ProveedorDTO>(updateProveedor.Entity));
}
else
{
return(null);
}
}catch (Exception e)
{
return(null);
}
}
public async Task Handle(ProductoEnStockActualizarComnando comando, CancellationToken cancellation)
{
_logger.LogInformation("--- ProductoEnStockActualizarComnando inicia");
var productos = comando.Items.Select(x => x.ProductoId);
var stocks = await _context.Stocks.Where(x => productos.Contains(x.ProductoId)).ToListAsync();
_logger.LogInformation("--- Obtuvo los productos de la base de datos");
foreach (var item in comando.Items)
{
var entry = stocks.SingleOrDefault(x => x.ProductoId == item.ProductoId);
if (item.Accion == ProductoEnStockAccion.Substract)
{
if (entry == null || item.Stock > entry.Stock)
{
_logger.LogError($"--- Producto {entry.ProductoId} no tiene suficiente stock");
throw new ProductoEnStockActualizarComnandoExcepcion($"Producto {entry.ProductoId} no tiene suficiente stock");
}
entry.Stock -= item.Stock;
_logger.LogInformation($"--- El producto {entry.ProductoId} fue sustraido. Ahora tiene {entry.Stock}");
}
else //Add
{
if (entry == null)
{
entry = new ProductoEnStock
{
ProductoId = item.ProductoId
};
await _context.AddAsync(entry);
_logger.LogInformation($"--- Nuevo stock fue creado del producto {entry.ProductoId}");
}
entry.Stock += item.Stock;
_logger.LogInformation($"--- Al producto {entry.ProductoId} se le añadió el stock {entry.Stock}");
}
}
await _context.SaveChangesAsync();
_logger.LogInformation("--- ProductoEnStockActualizarComnando finaliza");
}
