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)));
        }
Пример #2
0
        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 <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)));
        }