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); }