public async Task <Respuesta <IClienteDTO> > ActualizarCliente(IClienteDTO cliente)
{
return(await new Wrapper <IClienteDTO>().EjecutarTransaccionAsync(async() =>
{
contexto.Entry(mapper.Map <Cliente>(cliente)).State = EntityState.Modified;
await contexto.SaveChangesAsync();
return FabricaRespuesta <IClienteDTO> .RespuestaEdicionExitosa(new List <IClienteDTO> {
cliente
});
}, async() => await FabricaRespuesta <IClienteDTO> .RespuestaFallida(Mensajes.ErrorEnEdición)));
}
public async Task <Respuesta <IClienteDTO> > CrearCliente(IClienteDTO cliente)
{
return(await new Wrapper <IClienteDTO>().EjecutarTransaccionAsync(async() =>
{
Cliente nuevoCliente = mapper.Map <Cliente>(cliente);
contexto.Add(nuevoCliente);
await contexto.SaveChangesAsync();
return FabricaRespuesta <IClienteDTO> .RespuestaCreacionExitosa(new List <IClienteDTO> {
nuevoCliente
});
}, async() => await FabricaRespuesta <IClienteDTO> .RespuestaFallida(Mensajes.ErrorEnCreacion)));
}
public async Task <Respuesta <ICategoriaDTO> > CrearCategoria(ICategoriaDTO categoria)
{
return(await new Wrapper <ICategoriaDTO>().EjecutarTransaccionAsync(async() =>
{
Categoria nuevaCategoria = mapper.Map <Categoria>(categoria);
contexto.Add(nuevaCategoria);
await contexto.SaveChangesAsync();
return FabricaRespuesta <ICategoriaDTO> .RespuestaCreacionExitosa(new List <ICategoriaDTO> {
nuevaCategoria
});
}, async() => await FabricaRespuesta <ICategoriaDTO> .RespuestaFallida(Mensajes.ErrorEnCreacion)));
}
public async Task <Respuesta <IFacturaDTO> > CrearFactura(IFacturaDTO factura)
{
return(await new Wrapper <IFacturaDTO>().EjecutarTransaccionAsync(async() =>
{
Factura nuevaFactura = mapper.Map <Factura>(factura);
contexto.Add(nuevaFactura);
await contexto.SaveChangesAsync();
return FabricaRespuesta <IFacturaDTO> .RespuestaCreacionExitosa(new List <IFacturaDTO> {
nuevaFactura
});
}, async() => await FabricaRespuesta <IFacturaDTO> .RespuestaFallida(Mensajes.ErrorEnCreacion)));
}
public async Task <Respuesta <IProductoCompuestoDTO> > ActualizarProducto(IProductoCompuestoDTO producto)
{
return(await new Wrapper <IProductoCompuestoDTO>().EjecutarTransaccionAsync(async() =>
{
InventarioProducto inventario = await contexto.InventarioProducto
.FirstOrDefaultAsync(pro => pro.IdProducto == producto.IdProducto);
inventario.Cantidad = producto.Cantidad;
contexto.Entry(mapper.Map <Producto>(producto)).State = EntityState.Modified;
contexto.Entry(inventario).State = EntityState.Modified;
await contexto.SaveChangesAsync();
return FabricaRespuesta <IProductoCompuestoDTO> .RespuestaEdicionExitosa(new List <IProductoCompuestoDTO> {
producto
});
}, async() => await FabricaRespuesta <IProductoCompuestoDTO> .RespuestaFallida(Mensajes.ErrorEnEdición)));
}
public async Task <Respuesta <IFacturaDTO> > EliminarFactura(IFacturaDTO factura)
{
return(await new Wrapper <IFacturaDTO>().EjecutarTransaccionAsync(async() =>
{
int facturaId = await contexto.Factura.Select(fac => fac.IdFactura)
.FirstOrDefaultAsync(x => x == factura.IdFactura);
if (facturaId == default)
{
return FabricaRespuesta <IFacturaDTO> .RespuestaEliminacionFallida();
}
else
{
contexto.Factura.Remove(new Factura {
IdFactura = facturaId
});
await contexto.SaveChangesAsync();
return FabricaRespuesta <IFacturaDTO> .RespuestaEliminacionExitosa();
}
}, async() => await FabricaRespuesta <IFacturaDTO> .RespuestaFallida(Mensajes.ErrorEnEliminacion)));
}
public async Task <Respuesta <IProductoDTO> > EliminarProducto(IProductoDTO producto)
{
return(await new Wrapper <IProductoDTO>().EjecutarTransaccionAsync(async() =>
{
int IdProducto = await contexto.Producto.Select(Prod => Prod.IdProducto)
.FirstOrDefaultAsync(x => x == producto.IdProducto);
if (IdProducto == default)
{
return FabricaRespuesta <IProductoDTO> .RespuestaEliminacionFallida();
}
else
{
contexto.Producto.Remove(new Producto {
IdProducto = IdProducto
});
await contexto.SaveChangesAsync();
return FabricaRespuesta <IProductoDTO> .RespuestaEliminacionExitosa();
}
}, async() => await FabricaRespuesta <IProductoDTO> .RespuestaFallida(Mensajes.RespuestaFallida)));
}
public async Task <Respuesta <ICategoriaDTO> > EliminarCategoria(ICategoriaDTO categoria)
{
return(await new Wrapper <ICategoriaDTO>().EjecutarTransaccionAsync(async() =>
{
int categoriaId = await contexto.Categoria.Select(cat => cat.IdCategoria)
.FirstOrDefaultAsync(x => x == categoria.IdCategoria);
if (categoriaId == default)
{
return FabricaRespuesta <ICategoriaDTO> .RespuestaEliminacionFallida();
}
else
{
contexto.Categoria.Remove(new Categoria {
IdCategoria = categoriaId
});
await contexto.SaveChangesAsync();
return FabricaRespuesta <ICategoriaDTO> .RespuestaEliminacionExitosa();
}
}, async() => await FabricaRespuesta <ICategoriaDTO> .RespuestaFallida(Mensajes.ErrorEnEliminacion)));
}
public async Task <Respuesta <IDetalleFacturaCompuestoDTO> > ActualizarDetalleFactura(IDetalleFacturaCompuestoDTO factura)
{
return(await new Wrapper <IDetalleFacturaCompuestoDTO>().EjecutarTransaccionAsync(async() =>
{
DetalleFactura detalleFactura = new DetalleFactura()
{
IdDetalleFactura = factura.IdDetalleFactura,
IdFactura = factura.IdFactura,
IdProducto = factura.IdProducto,
Observaciones = factura.Observaciones,
Precio = factura.Precio
};
contexto.Entry(detalleFactura).State = EntityState.Modified;
await contexto.SaveChangesAsync();
return FabricaRespuesta <IDetalleFacturaCompuestoDTO> .RespuestaEdicionExitosa(
new List <IDetalleFacturaCompuestoDTO> {
factura
}
);
}, async() => await FabricaRespuesta <IDetalleFacturaCompuestoDTO> .RespuestaFallida(Mensajes.ErrorEnEdición)));
}
public async Task <Respuesta <IProductoCompuestoDTO> > CrearProducto(IProductoCompuestoDTO producto)
{
return(await new Wrapper <IProductoCompuestoDTO>().EjecutarTransaccionAsync(async() =>
{
Producto nuevoProducto = mapper.Map <Producto>(producto);
contexto.Add(nuevoProducto);
await contexto.SaveChangesAsync();
InventarioProducto inventario = new InventarioProducto()
{
IdProducto = nuevoProducto.IdProducto,
Cantidad = producto.Cantidad
};
contexto.Add(inventario);
await contexto.SaveChangesAsync();
producto.IdInventario = inventario.IdInventario;
producto.IdProducto = nuevoProducto.IdProducto;
return FabricaRespuesta <IProductoCompuestoDTO> .RespuestaCreacionExitosa(new List <IProductoCompuestoDTO> {
producto
});
}, async() => await FabricaRespuesta <IProductoCompuestoDTO> .RespuestaFallida(Mensajes.ErrorEnCreacion)));
}
public async Task <Respuesta <IClienteDTO> > EliminarCliente(IClienteDTO cliente)
{
return(await new Wrapper <IClienteDTO>().EjecutarTransaccionAsync(async() =>
{
int clienteId = await contexto.Cliente
.Select(Cli => Cli.IdCliente)
.FirstOrDefaultAsync(x => x == cliente.IdCliente);
if (clienteId == default)
{
return FabricaRespuesta <IClienteDTO> .RespuestaEliminacionFallida();
}
else
{
List <Factura> facturasCliente = await contexto.Factura
.Include(fac => fac.DetalleFactura)
.Where(cli => cli.IdCliente == cliente.IdCliente)
.ToListAsync();
foreach (Factura factura in facturasCliente)
{
contexto.RemoveRange(factura.DetalleFactura);
await contexto.SaveChangesAsync();
}
contexto.RemoveRange(facturasCliente);
await contexto.SaveChangesAsync();
contexto.Cliente.Remove(new Cliente {
IdCliente = clienteId
});
await contexto.SaveChangesAsync();
return FabricaRespuesta <IClienteDTO> .RespuestaEliminacionExitosa();
}
}, async() => await FabricaRespuesta <IClienteDTO> .RespuestaFallida(Mensajes.ErrorEnEliminacion)));
}