public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idcategoria <= 0)
{
return(BadRequest(ModelState));
}
var categoria = await _context.Categorias.FirstOrDefaultAsync(c => c.idcategoria == model.idcategoria);
if (categoria == null)
{
NotFound();
}
categoria.nombre = model.nombre;
categoria.descripcion = model.descripcion;
_context.Entry(categoria).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar en LOG
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> PutMunicipio(int id, Municipio municipio)
{
if (id != municipio.Id_Municipio)
{
return(BadRequest());
}
_context.Entry(municipio)
.State = EntityState.Modified;
try
{
await _context
.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MunicipioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCategotia(int id, Categoria categoria)
{
if (id != categoria.idcategoria)
{
return(BadRequest());
}
_context.Entry(categoria).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoriaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCategoria(int id, Categoria categoria)
{
if (id != categoria.idcategoria)
{
return(BadRequest());
}
//MI ENTIDAD YA TIENE LAS PROPIEDADDES O INFO QUE VOY A GUARDAR EN MY DB
_context.Entry(categoria).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CategoriaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutImagenes(int id, Imagenes imagenes)
{
if (id != imagenes.idimagen)
{
return(BadRequest());
}
_context.Entry(imagenes).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ImagenesExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> putusuario(int id, usuario usuario)
{
if (id != usuario.idUsuario)
{
return(BadRequest());
}
//MI ENTIDAD YA TIENE LAS PROPIEDADES QUE VOY A AGUARDAR EN MI BD
_context.Entry(usuario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutDocumento(int id, Documento documento)
{
if (id != documento.idDocumento)
{
return(BadRequest());
}
_context.Entry(documento).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DocumentoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutIngreso(int id, Ingreso ingreso)
{
//valido que el id sea diferente
if (id != ingreso.idIngreso)
{
return(BadRequest());
}
_context.Entry(ingreso).State = EntityState.Modified;
//a revisar que lo que subamos por medio de la api no sea basura
try
{
await _context.SaveChangesAsync();
}
//ESTO PORQUE REVIERTE LA OPERACION SI EN CASO HAY ERROR
//POR EJEMPLO QUE EL ID YA EXISTE.
catch (DbUpdateConcurrencyException)
{
if (IngresoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutTipoPersona(int id, TipoPersona tipoPersona)
{
if (id != tipoPersona.idTipoPersona)
{
return(BadRequest());
}
_context.Entry(tipoPersona).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoPersonaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Anular([FromRoute] int id)
{
if (id <= 0)
{
return(BadRequest(ModelState));
}
var ingreso = await _context.Ingresos.FirstOrDefaultAsync(i => i.idingreso == id);
if (ingreso == null)
{
NotFound();
}
ingreso.estado = "Anulado";
_context.Entry(ingreso).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar en LOG
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> PutComprobante(int id, Comprobante comprobante)
{
if (id != comprobante.idComprobante)
{
return(BadRequest());
}
_context.Entry(comprobante).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComprobanteExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutRol(int id, Rol rol)
{
if (id != rol.idrol)
{
return(BadRequest());
}
_context.Entry(rol).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RolExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> puttbl_Detalle_venta(int id, tbl_Detalle_venta tbl_Detalle_venta)
{
if (id != tbl_Detalle_venta.IdDetalleVenta)
{
return(BadRequest());
}
//MI ENTIDAD YA TIENE LAS PROPIEDADES QUE VOY A AGUARDAR EN MI BD
_context.Entry(tbl_Detalle_venta).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!tbl_Detalle_ventaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutVenta(int id, venta venta)
{
if (id != venta.idventa)
{
return(BadRequest()); // si es diferente no da un badrequest
}
_context.Entry(venta).State = EntityState.Modified; /*indicar al dbcontexr con el entity que lo que hay en venta
* vamos a realizar una modificacion , las entidad ya tiene las propiedades
* o informacion que vamos a guardar*/
/*el manejo de erro try nos evitará tener problemas a evitar que si hay error que la api no falle*/
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)//esto lo que hara un rollback a la operacion que se esta realizando
{
if (!VentaExists(id))
{
return(NotFound());
}
else
{
throw;// por si desconocemos el error
}
}
return(NoContent());
}
public async Task <IActionResult> PutConsumoHist([FromRoute] int id, [FromBody] ConsumoHist consumoHist)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != consumoHist.Id)
{
return(BadRequest());
}
_context.Entry(consumoHist).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ConsumoHistExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> putCategoria(int id, ventas_ ventas_)
{
if (id != ventas_.idVenta_)
{
return(BadRequest());
}
//MI ENTIDAD YA TIENE LAS PROPIEDADES QUE VOY A AGUARDAR EN MI BD
_context.Entry(ventas_).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!Ventas_Exists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutEstadoIngreso(int id, EstadoIngreso estadoIngreso)
{
if (id != estadoIngreso.idEstadoIngreso)
{
return(BadRequest());
}
_context.Entry(estadoIngreso).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EstadoIngresoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> putarticulo_(int id, articulo_ articulo_)
{
if (id != articulo_.idCodigoArticulo)
{
return(BadRequest());
}
//MI ENTIDAD YA TIENE LAS PROPIEDADES QUE VOY A AGUARDAR EN MI BD
_context.Entry(articulo_).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!articulo_Exists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutHistPerso1([FromRoute] string id, [FromBody] HistPerso1 histPerso1)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != histPerso1.ZAUSW)
{
return(BadRequest());
}
_context.Entry(histPerso1).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HistPerso1Exists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idusuario <= 0)
{
return(BadRequest(ModelState));
}
var usuario = await _context.Usuarios.FirstOrDefaultAsync(u => u.idusuario == model.idusuario);
if (usuario == null)
{
NotFound();
}
usuario.idrol = model.idrol;
usuario.nombre = model.nombre;
usuario.tipo_documento = model.tipo_documento;
usuario.telefono = model.telefono;
usuario.direccion = model.direccion;
usuario.num_documento = model.num_documento;
usuario.email = model.email.ToLower();
if (model.act_password)
{
CrearPasswordHash(model.password, out byte[] passwordHash, out byte[] passwordSalt);
usuario.password_hash = passwordHash;
usuario.password_salt = passwordSalt;
}
_context.Entry(usuario).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar en LOG
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Anular([FromRoute] int id)
{
if (id <= 0)
{
return(BadRequest(ModelState));
}
var venta = await _context.Ventas.FirstOrDefaultAsync(v => v.idventa == id);
if (venta == null)
{
NotFound();
}
venta.estado = "Anulado";
_context.Entry(venta).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
// Inicio de código para devolver stock
// 1. Obtenemos los detalles
var detalle = await _context.DetallesVentas.Include(a => a.articulo).Where(d => d.idventa == id).ToListAsync();
//2. Recorremos los detalles
foreach (var det in detalle)
{
//Obtenemos el artículo del detalle actual
var articulo = await _context.Articulos.FirstOrDefaultAsync(a => a.idarticulo == det.articulo.idarticulo);
//actualizamos el stock
articulo.stock = det.articulo.stock + det.cantidad;
//Guardamos los cambios
await _context.SaveChangesAsync();
}
// Fin del código para devolver stock
}
catch (DbUpdateConcurrencyException)
{
//Guardar en LOG
return(BadRequest());
}
return(Ok());
}
public ActionResult Put(int id, [FromBody] Persona value)
{
if (id != value.IdPersona)
{
return(BadRequest());
}
else
{
context.Entry(value).State = EntityState.Modified;
context.SaveChanges();
return(Ok());
}
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idarticulo <= 0)
{
return(BadRequest(ModelState));
}
var articulo = await _context.Articulos.FirstOrDefaultAsync(a => a.idarticulo == model.idarticulo);
if (articulo == null)
{
NotFound();
}
articulo.precio_venta = model.precio_venta;
articulo.stock = model.stock;
articulo.idcategoria = model.idcategoria;
articulo.nombre = model.nombre;
articulo.descripcion = model.descripcion;
_context.Entry(articulo).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar en LOG
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idpersona <= 0)
{
return(BadRequest(ModelState));
}
var persona = await _context.Personas.FirstOrDefaultAsync(p => p.idpersona == model.idpersona);
if (persona == null)
{
NotFound();
}
persona.tipo_persona = model.tipo_persona;
persona.tipo_documento = model.tipo_documento;
persona.num_documento = model.num_documento;
persona.nombre = model.nombre;
persona.direccion = model.direccion;
persona.telefono = model.telefono;
persona.email = model.email.ToLower();
_context.Entry(persona).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar en LOG
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> PutDetalleVenta(int id, detalle_venta detVenta)
{
if (id != detVenta.id_detalle_venta)
{
return(BadRequest());
}
_context.Entry(detVenta).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DetalleVentaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}