public async Task <IActionResult> PutDetalleCotizacion(int id, DetalleCotizacion detalleCotizacion)
        {
            if (id != detalleCotizacion.idDetalle)
            {
                return(BadRequest());
            }

            _context.Entry(detalleCotizacion).State = EntityState.Modified;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!DetalleCotizacionExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(NoContent());
        }
        public async Task <IActionResult> PutCategoria(int id, Categoria categoria)
        {
            if (id != categoria.idCategoria)
            {
                return(BadRequest());
            }

            _context.Entry(categoria).State = EntityState.Modified;
            await _context.SaveChangesAsync();


            return(NoContent());
        }
Esempio n. 3
0
        public async Task <IActionResult> PutUsuario(int id, Usuario usuario)
        {
            if (id != usuario.idUsuario)
            {
                return(BadRequest());
            }

            _context.Entry(usuario).State = EntityState.Modified;


            await _context.SaveChangesAsync();

            return(NoContent());
        }
Esempio n. 4
0
        public async Task <IActionResult> PutProducto(int id, Producto producto)
        {
            if (id != producto.idProducto)
            {
                return(BadRequest());
            }

            _context.Entry(producto).State = EntityState.Modified;


            await _context.SaveChangesAsync();

            return(NoContent());
        }
        public async Task <IActionResult> PutCotizacion(int id, Cotizacion cotizacion)
        {
            if (id != cotizacion.idCotizacion)
            {
                return(BadRequest());
            }

            _context.Entry(cotizacion).State = EntityState.Modified;


            await _context.SaveChangesAsync();


            return(NoContent());
        }
Esempio n. 6
0
        public async Task <IActionResult> PutCliente(int id, Cliente cliente)
        {
            if (id != cliente.idCliente)
            {
                return(BadRequest());
            }

            _context.Entry(cliente).State = EntityState.Modified;


            await _context.SaveChangesAsync();


            return(NoContent());
        }
Esempio n. 7
0
        public async Task <string> PostClienteApplicationService(Cliente cliente)
        {
            var  respuestaDomainService    = _clienteDomainService.PostClienteDomainService(cliente);
            bool hayErrorEnElDomainService = respuestaDomainService != null;

            if (hayErrorEnElDomainService)
            {
                return(respuestaDomainService);
            }

            _baseDatos.Clientes.Add(cliente);
            await _baseDatos.SaveChangesAsync();

            return(null);
        }
        public async Task <string> PostUsuarioApplicationService(Usuario usuario)
        {
            var respuestaDomainService = _usuarioDomainService.PostUsuarioDomainService(usuario);

            bool hayErrorEnElDomainService = respuestaDomainService != null;

            if (hayErrorEnElDomainService)
            {
                return(respuestaDomainService);
            }
            _baseDatos.Usuarios.Add(usuario);
            await _baseDatos.SaveChangesAsync();

            return(null);
        }
        public async Task <string> PostCotizacionApplicationService(Cotizacion cotizacion)
        {
            var respuestaDomainService = _cotizacionDomainService.PostCotizacionDomainService(cotizacion);

            bool hayErrorEnElDomainService = respuestaDomainService != null;

            if (hayErrorEnElDomainService)
            {
                return(respuestaDomainService);
            }

            _baseDatos.Cotizaciones.Add(cotizacion);
            await _baseDatos.SaveChangesAsync();

            return(null);
        }
        public async Task <string> PostDetalleCotizacionApplicationService(DetalleCotizacion detalleCotizacion)
        {
            var respuestaDomainService = _detalleCotizacionDomainService.PostDetalleCotizacionDomainService(detalleCotizacion);

            bool hayErrorEnElDomainService = respuestaDomainService != null;

            if (hayErrorEnElDomainService)
            {
                return(respuestaDomainService);
            }

            _baseDatos.DetallesCotizacion.Add(detalleCotizacion);
            await _baseDatos.SaveChangesAsync();

            return(null);
        }
Esempio n. 11
0
        public async Task <string> PostProductoApplicationService(Producto producto)
        {
            var respuestaDomainService = _productoDomainService.PostProductoDomainService(producto);

            bool hayErrorEnElDomainService = respuestaDomainService != null;

            if (hayErrorEnElDomainService)
            {
                return(respuestaDomainService);
            }

            _baseDatos.Productos.Add(producto);
            await _baseDatos.SaveChangesAsync();

            return(null);
        }
Esempio n. 12
0
        public async Task <string> PostCategoriaApplicationService(Categoria categoria)
        {
            var respuestaDomainService = _categoriaDomainService.PostCategoriaDomainService(categoria);

            bool hayErrorEnElDomainService = respuestaDomainService != null;

            if (hayErrorEnElDomainService)
            {
                return(respuestaDomainService);
            }

            _baseDatos.Categorias.Add(categoria);
            await _baseDatos.SaveChangesAsync();

            return(null);
        }