public async Task <Respuesta <IDetalleFacturaCompuestoDTO> > ConsultarDetalleFactura(IFacturaDTO factura)
{
return(await new Wrapper <IDetalleFacturaCompuestoDTO>().EjecutarTransaccionAsync(async() =>
{
List <IDetalleFacturaCompuestoDTO> detalles = await contexto.DetalleFactura
.Include(x => x.IdProductoNavigation)
.Where(x => x.IdFactura == factura.IdFactura)
.Select(x => new DetalleFacturaCompuestoDO()
{
IdDetalleFactura = x.IdDetalleFactura,
IdFactura = x.IdFactura,
IdProducto = x.IdProducto,
NombreProducto = x.IdProductoNavigation.Nombre,
Observaciones = x.Observaciones,
Precio = x.Precio
}).ToListAsync <IDetalleFacturaCompuestoDTO>();
if (detalles != null && detalles.Count > 0)
{
return FabricaRespuesta <IDetalleFacturaCompuestoDTO> .RespuestaConDatos(detalles);
}
else
{
return FabricaRespuesta <IDetalleFacturaCompuestoDTO> .RespuestaSinDatos();
}
}));
}
public async Task <Respuesta <IFacturaCompuestaDTO> > LeerFacturas()
{
return(await new Wrapper <IFacturaCompuestaDTO>().EjecutarTransaccionAsync(async() =>
{
List <IFacturaCompuestaDTO> facturas = await contexto.Factura
.Include(x => x.IdClienteNavigation)
.Include(x => x.DetalleFactura)
.Select(x => new FacturaCompuestaDO
{
IdFactura = x.IdFactura,
IdCliente = x.IdCliente,
NombreCliente = $"{x.IdClienteNavigation.PrimerNombre} {x.IdClienteNavigation.PrimerApellido}",
Fecha = x.Fecha,
CantidadProductos = x.DetalleFactura.Count,
ValorTotal = (float)x.DetalleFactura.Sum(x => x.Precio),
listaDetalle = x.DetalleFactura
.Select(det => new DetalleFacturaCompuestoDO {
IdDetalleFactura = det.IdDetalleFactura,
IdFactura = det.IdFactura,
IdProducto = det.IdProducto,
NombreProducto = det.IdProductoNavigation.Nombre,
Observaciones = det.Observaciones,
Precio = det.Precio
}).ToList <IDetalleFacturaCompuestoDTO>()
}).ToListAsync <IFacturaCompuestaDTO>();
return FabricaRespuesta <IFacturaCompuestaDTO> .RespuestaConDatos(facturas);
}));
}
public async Task <Respuesta <IProductoCompuestoDTO> > LeerProductos()
{
return(await new Wrapper <IProductoCompuestoDTO>().EjecutarTransaccionAsync(async() =>
{
List <IProductoCompuestoDTO> productos = await contexto.Producto
.Include(x => x.IdCategoriaNavigation)
.Include(x => x.InventarioProducto)
.Select(x => new ProductoCompuestoDO
{
IdProducto = x.IdProducto,
IdCategoria = x.IdCategoria,
Nombre = x.Nombre,
Precio = x.Precio,
Categoria = x.IdCategoriaNavigation.Descripcion,
Cantidad = (int)x.InventarioProducto.FirstOrDefault().Cantidad,
IdInventario = x.InventarioProducto.FirstOrDefault().IdInventario
}).ToListAsync <IProductoCompuestoDTO>();
if (productos != null && productos.Count > 0)
{
return FabricaRespuesta <IProductoCompuestoDTO> .RespuestaConDatos(productos);
}
else
{
return FabricaRespuesta <IProductoCompuestoDTO> .RespuestaSinDatos();
}
}));
}
public async Task <Respuesta <IProductoCompuestoDTO> > LeerProducto(IProductoDTO productoIn)
{
return(await new Wrapper <IProductoCompuestoDTO>().EjecutarTransaccionAsync(async() =>
{
IProductoCompuestoDTO producto = await contexto.Producto
.Include(x => x.IdCategoriaNavigation)
.Include(x => x.InventarioProducto)
.Where(x => x.IdProducto == productoIn.IdProducto)
.Select(x => new ProductoCompuestoDO
{
IdProducto = x.IdProducto,
IdCategoria = x.IdCategoria,
Nombre = x.Nombre,
Precio = x.Precio,
Categoria = x.IdCategoriaNavigation.Descripcion,
Cantidad = (int)x.InventarioProducto.FirstOrDefault().Cantidad,
IdInventario = x.InventarioProducto.FirstOrDefault().IdInventario
}).FirstOrDefaultAsync <IProductoCompuestoDTO>();
if (producto == null)
{
return FabricaRespuesta <IProductoCompuestoDTO> .RespuestaSinDatos();
}
return FabricaRespuesta <IProductoCompuestoDTO> .RespuestaConDatos(new List <IProductoCompuestoDTO> {
producto
});
}));
}
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 <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 <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 <IClienteDTO> > LeerCliente(IClienteDTO clienteIn)
{
return(await new Wrapper <IClienteDTO>().EjecutarTransaccionAsync(async() =>
{
Cliente cliente = await contexto.Cliente.FirstOrDefaultAsync(cli => cli.Cedula == clienteIn.Cedula);
if (cliente == null)
{
return FabricaRespuesta <IClienteDTO> .RespuestaSinDatos();
}
return FabricaRespuesta <IClienteDTO> .RespuestaConDatos(new List <IClienteDTO> {
clienteIn
});
}));
}
public async Task <Respuesta <IClienteDTO> > LeerClientes()
{
return(await new Wrapper <IClienteDTO>().EjecutarTransaccionAsync(async() =>
{
List <IClienteDTO> clientes = mapper.Map <List <IClienteDTO> >(await contexto.Cliente.ToListAsync());
if (clientes != null && clientes.Count > 0)
{
return FabricaRespuesta <IClienteDTO> .RespuestaConDatos(clientes);
}
else
{
return FabricaRespuesta <IClienteDTO> .RespuestaSinDatos();
}
}));
}
public async Task <Respuesta <ICategoriaDTO> > LeerCategoria(ICategoriaDTO categoriaIn)
{
return(await new Wrapper <ICategoriaDTO>().EjecutarTransaccionAsync(async() =>
{
Categoria categoria = await contexto.Categoria
.FirstOrDefaultAsync(cat => cat.IdCategoria == categoriaIn.IdCategoria);
if (categoria == null)
{
return FabricaRespuesta <ICategoriaDTO> .RespuestaSinDatos();
}
return FabricaRespuesta <ICategoriaDTO> .RespuestaConDatos(new List <ICategoriaDTO> {
categoria
});
}));
}
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 <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 <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 <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)));
}
public async Task <Respuesta <IFacturaCompuestaDTO> > LeerFactura(IFacturaDTO facturaIn)
{
return(await new Wrapper <IFacturaCompuestaDTO>().EjecutarTransaccionAsync(async() =>
{
IFacturaCompuestaDTO factura = await contexto.Factura
.Include(x => x.IdClienteNavigation)
.Include(x => x.DetalleFactura)
.Where(x => x.IdFactura == facturaIn.IdFactura)
.Select(x => new FacturaCompuestaDO
{
IdFactura = x.IdFactura,
IdCliente = x.IdCliente,
NombreCliente = $"{x.IdClienteNavigation.PrimerNombre} {x.IdClienteNavigation.PrimerApellido}",
Fecha = x.Fecha
}).FirstOrDefaultAsync <IFacturaCompuestaDTO>();
if (factura == null)
{
return FabricaRespuesta <IFacturaCompuestaDTO> .RespuestaSinDatos();
}
return FabricaRespuesta <IFacturaCompuestaDTO> .RespuestaConDatos(new List <IFacturaCompuestaDTO> {
factura
});
}));
}
