public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
//Se valida que el modelo que se recibe si este correcto
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//Se valida que tenga algun dato el modelo
if (model.idcategoria <= 0)
{
return(BadRequest());
}
//Me devuelve el dato que coincide con mi dato
var categoria = await _context.Categorias.FirstOrDefaultAsync(c => c.idcategoria == model.idcategoria);
//Se valida que el dato ingresado se igual alguno de la base de datos
if (categoria == null)
{
return(NotFound());
}
categoria.nombre = model.nombre;
categoria.descripcion = model.descripcion;
try
{//Se guardan los cambios en la base de datos
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idMedico <= 0)
{
return(BadRequest());
}
var medico = await _context.Medicos.FirstOrDefaultAsync(c => c.idMedico == model.idMedico);
medico.idMedico = model.idMedico;
medico.Nombre = model.Nombre;
medico.Direccion = model.Direccion;
medico.Telefono = model.Telefono;
medico.Correo = model.Correo;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
protected async Task HandleValidSubmit()
{
bool resultado;
if (int.TryParse(CategoriaId, NumberStyles.Integer, CultureInfo.InvariantCulture, out var categoriaId))
{
var categoria = new ActualizarViewModel
{
Id = categoriaId,
Nombre = this.Categoria.Nombre,
Descripcion = this.Categoria.Descripcion,
};
resultado = await this.CategoriaDataService.Actualizar(categoria).ConfigureAwait(false);
}
else
{
resultado = await this.CategoriaDataService.Crear(this.Categoria).ConfigureAwait(false);
}
this.Alert = new ShowAlert.Alert
{
Type = resultado ? "info" : "danger",
};
this.Saved = resultado;
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idactividadadm <= 0)
{
return(BadRequest());
}
var actividadadm = await _context.ActividadAdms.FirstOrDefaultAsync(c => c.idactividadadm == model.idactividadadm);
if (actividadadm == null)
{
return(NotFound());
}
actividadadm.nomactividadadm = model.nomactividadadm;
actividadadm.desactividadadm = model.desactividadadm;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// Guardar Excepción
return(BadRequest());
}
return(Ok());
}
protected async Task HandleValidSubmit()
{
bool resultado;
this.Administrador.RolId = int.Parse(this.RolId, NumberStyles.Integer, CultureInfo.InvariantCulture);
if (int.TryParse(AdministradorId, NumberStyles.Integer, CultureInfo.InvariantCulture, out var administradorId))
{
var administrador = new ActualizarViewModel
{
Id = administradorId,
Email = this.Administrador.Email,
Username = this.Administrador.Username,
RolId = this.Administrador.RolId,
Password = this.Administrador.Password,
};
administrador.ActPassword = administrador.Password != "123456789";
resultado = await this.AdministradorDataService.Actualizar(administrador).ConfigureAwait(false);
}
else
{
resultado = await this.AdministradorDataService.Crear(this.Administrador).ConfigureAwait(false);
}
this.Alert = new ShowAlert.Alert
{
Type = resultado ? "info" : "danger",
};
this.Saved = resultado;
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model) ///enviamos todo el objeto ActualizarViewModel
{
if (!ModelState.IsValid)
{//valido modelo de data anotation
return(BadRequest(ModelState));
}
if (model.iddistribuidor <= 0)// categoria existe
{
return(BadRequest());
}
var distribuidor = await baseDatos.Distribuidor.FirstOrDefaultAsync(a => a.iddistribuidor == model.iddistribuidor);// baseDatos.Distribuidor.FirstOrDefaultAsync: devuelve primer registro que encuentre
if (distribuidor == null)
{//si no encuntra nada
return(NotFound());
}
distribuidor.iddistribuidor = model.iddistribuidor;
distribuidor.nombre = model.nombre;
distribuidor.ciudad = model.ciudad; //indico a mi objeto Distribuidor que el nombre va a ser igual al del modelo
distribuidor.telefono = model.telefono;
try //captura excepcions
{
await baseDatos.SaveChangesAsync(); //guardamos los cambios
}
catch (DbUpdateConcurrencyException)
{
// guardar excepcion
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idEmpleado <= 0)
{
return(BadRequest());
}
var empleado = await _context.Empleados.FirstOrDefaultAsync(c => c.idEmpleado == model.idEmpleado);
if (empleado == null)
{
return(NotFound());
}
empleado.empleado = model.empleado;
empleado.idEstatus = model.idEstatus;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepcion
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idactividad <= 0)
{
return(BadRequest());
}
var actividad = await _context.Actividades.FirstOrDefaultAsync(a => a.idactividad == model.idactividad);
if (actividad == null)
{
return(NotFound());
}
actividad.nombre = model.nombre;
actividad.descripcion = model.descripcion;
//actividad.finalizada = model.finalizada;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idrol <= 0)
{
return(BadRequest());
}
var rol = await _context.Roles.FirstOrDefaultAsync(r => r.idrol == model.idrol);
if (rol == null)
{
return(NotFound());
}
rol.nombre = model.nombre;
rol.descripcion = model.descripcion;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//guardar Exception
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> AsignarTecnico([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idregistroshe <= 0)
{
return(BadRequest());
}
RegistroShe she = await _context.Registrosshe.FirstOrDefaultAsync(c => c.idregistroshe == model.idregistroshe);
if (she == null)
{
return(NotFound());
}
she.idtecnico = model.idtecnico;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idturno <= 0)
{
return(BadRequest());
}
var turno = await _context.Turnos.FirstOrDefaultAsync(c => c.idturno == model.idturno);
if (turno == null)
{
return(NotFound());
}
turno.nomturno = model.nomturno;
turno.horario = model.horario;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idclient <= 0)
{
return(BadRequest());
}
var vmclient = await _context.VMClients.FirstOrDefaultAsync(c => c.idclient == model.idclient);
if (vmclient == null)
{
return(NotFound());
}
vmclient.clientname = model.clientname;
vmclient.clientfullname = model.clientfullname;
vmclient.clientemail = model.clientemail;
vmclient.clientphone = model.clientphone;
vmclient.clientcontact = model.clientcontact;
vmclient.emailcontact_tecnico = model.emailcontact_tecnico;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idnw <= 0)
{
return(BadRequest());
}
var networkbond = await _context.NetworkBonds.FirstOrDefaultAsync(c => c.idnw == model.idnw);
if (networkbond == null)
{
return(NotFound());
}
networkbond.nwbond = model.nwbond;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idos <= 0)
{
return(BadRequest());
}
var osfamily = await _context.OSFamilys.FirstOrDefaultAsync(c => c.idos == model.idos);
if (osfamily == null)
{
return(NotFound());
}
osfamily.osfamilyname = model.osfamilyname;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idtiposol <= 0)
{
return(BadRequest());
}
var tiposol = await _context.TipoSols.FirstOrDefaultAsync(c => c.idtiposol == model.idtiposol);
if (tiposol == null)
{
return(NotFound());
}
tiposol.nomtiposol = model.nomtiposol;
tiposol.destiposol = model.destiposol;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> ActualizarUsuario([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.Id <= 0)
{
return(BadRequest());
}
var usuario = await _context.Usuarios.FirstOrDefaultAsync(u => u.Id == model.Id);
if (usuario == null)
{
return(NotFound());
}
usuario.Correo = model.Correo;
usuario.Usuario = model.Usuario;
usuario.Sexo = model.Sexo;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idpool <= 0)
{
return(BadRequest());
}
var pool = await _context.Poolss.FirstOrDefaultAsync(c => c.idpool == model.idpool);
if (pool == null)
{
return(NotFound());
}
pool.poolname = model.poolname;
pool.pooldescripcion = model.pooldescripcion;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> ActualizarPersona([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.IdPersona < 0)
{
return(BadRequest());
}
var persona = await _context.Personas.FirstOrDefaultAsync(c =>
c.IdPersona == model.IdPersona);
if (persona == null)
{
return(NotFound());
}
persona.Nombre = model.Nombre;
persona.Apellidos = model.Apellidos;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idperiodo <= 0)
{
return(BadRequest());
}
var periodo = await _context.Periodos.FirstOrDefaultAsync(c => c.idperiodo == model.idperiodo);
if (periodo == null)
{
return(NotFound());
}
periodo.dia1 = model.dia1;
periodo.dia2 = model.dia2;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idServicio <= 0)
{
return(BadRequest());
}
var servicio = await _context.Servicios.FirstOrDefaultAsync(s => s.idServicio == model.idServicio);
if (servicio == null)
{
return(NotFound());
}
servicio.nombre = model.nombre;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepcion
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idcategoria <= 0)
{
return(BadRequest());
}
var categoria = await _context.Categorias.FirstOrDefaultAsync(c => c.idcategoria == model.idcategoria);
if (categoria == null)
{
return(NotFound());
}
categoria.nombre = model.nombre;
categoria.descripcion = model.descripcion;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// Guardar Excepcion
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar(int id, ActualizarViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
if (model == null || id != model.Id)
{
return(this.BadRequest());
}
var fecha = DateTime.Now;
var marca = await this._context.Marcas
.AsNoTracking()
.FirstOrDefaultAsync(m => m.Nombre == model.Marca).ConfigureAwait(false) ?? new Marca();
if (marca.Id == 0)
{
marca.Nombre = model.Nombre;
marca.CreatedAt = fecha;
await this._context.Marcas.AddAsync(marca).ConfigureAwait(false);
try
{
await this._context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
return(this.BadRequest("Hubo un error al guardar sus datos."));
}
}
var producto = await this._context.Productos.FindAsync(id).ConfigureAwait(false);
producto.CategoriaId = model.CategoriaId;
producto.Nombre = model.Nombre;
producto.Descripcion = model.Descripcion;
producto.Precio = model.Precio;
producto.MarcaId = marca.Id;
producto.Stock = model.Stock;
producto.UpdatedAt = fecha;
try
{
await this._context.SaveChangesAsync().ConfigureAwait(false);
}
catch (DbUpdateConcurrencyException)
{
if (!this.ProductoExists(id))
{
return(this.NotFound());
}
return(this.BadRequest("Hubo un error al guardar sus datos."));
}
return(this.NoContent());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idsqlversion <= 0)
{
return(BadRequest());
}
var sqlversion = await _context.SQLVersions.FirstOrDefaultAsync(c => c.idsqlversion == model.idsqlversion);
if (sqlversion == null)
{
return(NotFound());
}
sqlversion.idsql = model.idsql;
sqlversion.mssqlversion = model.mssqlversion;
sqlversion.mssqldescription = model.mssqldescription;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idvmtype <= 0)
{
return(BadRequest());
}
var vmtype = await _context.VMTypes.FirstOrDefaultAsync(c => c.idvmtype == model.idvmtype);
if (vmtype == null)
{
return(NotFound());
}
vmtype.vmtypename = model.vmtypename;
vmtype.vmtypedescription = model.vmtypedescription;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idperiodo <= 0)
{
return(BadRequest());
}
var configmail = await _context.ConfigMails.FirstOrDefaultAsync(c => c.idperiodo == model.idperiodo);
if (configmail == null)
{
return(NotFound());
}
configmail.dia = model.dia;
configmail.asunto = model.asunto;
configmail.cuerpomail = model.cuerpomail;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idpartida <= 0)
{
return(BadRequest());
}
var partida = await _context.Partidas.FirstOrDefaultAsync(c => c.idpartida == model.idpartida);
if (partida == null)
{
return(NotFound());
}
partida.nompartida = model.nompartida;
partida.despartida = model.despartida;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <ActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idcategoria <= 0)
{
return(BadRequest());
}
var categoria = await _context.Categorias.FirstOrDefaultAsync(c => c.idcategoria == model.idcategoria);
if (categoria == null)
{
return(NotFound());
}
//El usuario solo puede modificar el nombre y la descripcion de la categoria
categoria.nombre = model.nombre;
categoria.descripcion = model.descripcion;
try
{//Cuando realiza el cambio de forma exitosa llama la funcion SaveChangeAsync
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//En caso de no poder guardar los cambios en los campos nombre descripcion
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.DMSLocalID <= 0)
{
return(BadRequest());
}
var dmslocal = await _context.DMSLocal.FirstOrDefaultAsync(c => c.DMSLocalID == model.DMSLocalID);
if (dmslocal == null)
{
return(NotFound());
}
dmslocal.DMSLocalName = model.DMSLocalName;
dmslocal.DMSLocalActive = model.DMSLocalActive;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> Actualizar([FromBody] ActualizarViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.idvps <= 0)
{
return(BadRequest());
}
var vps = await _context.VPSs.FirstOrDefaultAsync(c => c.idvps == model.idvps);
if (vps == null)
{
return(NotFound());
}
vps.idclient = model.idclient;
vps.vmname = model.vmname;
vps.vm_uuid = model.vm_uuid;
vps.vcpus = model.vcpus;
vps.ram = model.ram;
vps.hdisk = model.hdisk;
vps.bandw = model.bandw;
vps.idnw = model.idnw;
vps.idos = model.idos;
vps.idversion = model.idversion;
vps.idsql = model.idsql;
vps.idsqlversion = model.idsqlversion;
vps.internal_ip = model.internal_ip;
vps.external_ip = model.external_ip;
//vps.createon = model.createon;
vps.idusuario = model.idusuario;
vps.dnsname = model.dnsname;
vps.idvmtype = model.idvmtype;
vps.idpool = model.idpool;
vps.notes = model.notes;
vps.rmtaccesssal = model.rmtaccesssal;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
//Guardar Excepción
return(BadRequest());
}
return(Ok());
}
public async Task <bool> Actualizar(ActualizarViewModel model)
{
await this.AgregarToken().ConfigureAwait(false);
var modelJson =
new StringContent(JsonSerializer.Serialize(model), Encoding.UTF8, "application/json");
var response = await this._httpClient.PutAsync($"actualizar/{model.Id}", modelJson).ConfigureAwait(false);
modelJson.Dispose();
return(response.StatusCode == HttpStatusCode.NoContent);
}
