public async Task <IActionResult> Edit(int id, [Bind("IdCitacionVoluntario,IdVoluntario,IdCitacion")] CitacionVoluntario citacionVoluntario)
{
if (id != citacionVoluntario.IdCitacionVoluntario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(citacionVoluntario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CitacionVoluntarioExists(citacionVoluntario.IdCitacionVoluntario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCitacion"] = new SelectList(_context.Citacion, "IdCitacion", "IdCitacion", citacionVoluntario.IdCitacion);
ViewData["IdVoluntario"] = new SelectList(_context.Voluntario, "IdVoluntario", "IdVoluntario", citacionVoluntario.IdVoluntario);
return(View(citacionVoluntario));
}
public async Task <IActionResult> Edit(int id, [Bind("IdMarcaVoluntario,IdVoluntario,IdTipoMarca,Fecha")] MarcaVoluntario marcaVoluntario)
{
if (id != marcaVoluntario.IdMarcaVoluntario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(marcaVoluntario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MarcaVoluntarioExists(marcaVoluntario.IdMarcaVoluntario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdTipoMarca"] = new SelectList(_context.TipoMarca, "IdTipoMarca", "DescripcionTipoMarca", marcaVoluntario.IdTipoMarca);
ViewData["IdVoluntario"] = new SelectList(_context.Voluntario, "IdVoluntario", "IdVoluntario", marcaVoluntario.IdVoluntario);
return(View(marcaVoluntario));
}
public async Task <IActionResult> Edit(int id, [Bind("IdComuna,NombreComuna")] Comuna comuna)
{
if (id != comuna.IdComuna)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(comuna);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComunaExists(comuna.IdComuna))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(comuna));
}
public async Task <IActionResult> Edit(int id, [Bind("IdEstadoUsuario,DescripcionEstadoUsuario")] EstadoUsuario estadoUsuario)
{
if (id != estadoUsuario.IdEstadoUsuario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(estadoUsuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EstadoUsuarioExists(estadoUsuario.IdEstadoUsuario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(estadoUsuario));
}
public async Task <IActionResult> Edit(int id, [Bind("IdTipoCitacion,DescripcionTipoCitacion")] TipoCitacion tipoCitacion)
{
if (id != tipoCitacion.IdTipoCitacion)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tipoCitacion);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TipoCitacionExists(tipoCitacion.IdTipoCitacion))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipoCitacion));
}
public async Task <IActionResult> Edit(int id, [Bind("IdDireccionCompania,IdCompania,IdComuna,Calle,Numero,Departamento")] DireccionCompania direccionCompania)
{
if (id != direccionCompania.IdDireccionCompania)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(direccionCompania);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DireccionCompaniaExists(direccionCompania.IdDireccionCompania))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCompania"] = new SelectList(_context.Compania, "IdCompania", "DenominacionCompania", direccionCompania.IdCompania);
ViewData["IdComuna"] = new SelectList(_context.Comuna, "IdComuna", "NombreComuna", direccionCompania.IdComuna);
return(View(direccionCompania));
}
public async Task <IActionResult> Edit(int id, [Bind("IdVoluntarioCargo,IdCargo,IdVoluntario,FechaInicio,FechaTermino")] VoluntarioCargo voluntarioCargo)
{
if (id != voluntarioCargo.IdVoluntarioCargo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(voluntarioCargo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VoluntarioCargoExists(voluntarioCargo.IdVoluntarioCargo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCargo"] = new SelectList(_context.Cargo, "IdCargo", "DescripcionCargo", voluntarioCargo.IdCargo);
ViewData["IdVoluntario"] = new SelectList(_context.Voluntario, "IdVoluntario", "IdVoluntario", voluntarioCargo.IdVoluntario);
return(View(voluntarioCargo));
}
public async Task <IActionResult> Edit(int id, [Bind("IdCuerpo,Rut,DigitoVerificador,Denominacion,NombreFantasia")] Cuerpo cuerpo)
{
if (id != cuerpo.IdCuerpo)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cuerpo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CuerpoExists(cuerpo.IdCuerpo))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cuerpo));
}
public async Task <IActionResult> Edit(int id, [Bind("IdUsuario,IdPerfil,IdEstadoUsuario,NombreUsuario,Nombres,ApellidoPaterno,ApellidoMaterno,CorreoElectronico,Password")] Usuario usuario)
{
if (id != usuario.IdUsuario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(usuario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UsuarioExists(usuario.IdUsuario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdEstadoUsuario"] = new SelectList(_context.EstadoUsuario, "IdEstadoUsuario", "DescripcionEstadoUsuario", usuario.IdEstadoUsuario);
ViewData["IdPerfil"] = new SelectList(_context.Perfil, "IdPerfil", "DescripcionPerfil", usuario.IdPerfil);
return(View(usuario));
}
public async Task <IActionResult> Edit(int id, [Bind("IdCompania,IdCuerpo,DenominacionCompania,NombreFantasia")] Compania compania)
{
if (id != compania.IdCompania)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(compania);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompaniaExists(compania.IdCompania))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCuerpo"] = new SelectList(_context.Cuerpo, "IdCuerpo", "Denominacion", compania.IdCuerpo);
return(View(compania));
}
public async Task <IActionResult> Edit(int id, [Bind("IdPerfil,DescripcionPerfil")] Perfil perfil)
{
if (id != perfil.IdPerfil)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(perfil);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PerfilExists(perfil.IdPerfil))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(perfil));
}
public async Task <IActionResult> Edit(int id, [Bind("IdFuncionalidadPerfil,IdFuncionalidad,IdPerfil")] FuncionalidadPerfil funcionalidadPerfil)
{
if (id != funcionalidadPerfil.IdFuncionalidadPerfil)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(funcionalidadPerfil);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionalidadPerfilExists(funcionalidadPerfil.IdFuncionalidadPerfil))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdFuncionalidad"] = new SelectList(_context.Funcionalidad, "IdFuncionalidad", "Controller", funcionalidadPerfil.IdFuncionalidad);
ViewData["IdPerfil"] = new SelectList(_context.Perfil, "IdPerfil", "DescripcionPerfil", funcionalidadPerfil.IdPerfil);
return(View(funcionalidadPerfil));
}
public async Task <IActionResult> Edit(int id, [Bind("IdDisponibilidad,IdVoluntario,IdCompania")] Disponibilidad disponibilidad)
{
if (id != disponibilidad.IdDisponibilidad)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(disponibilidad);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DisponibilidadExists(disponibilidad.IdDisponibilidad))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCompania"] = new SelectList(_context.Compania, "IdCompania", "DenominacionCompania", disponibilidad.IdCompania);
ViewData["IdVoluntario"] = new SelectList(_context.Voluntario, "IdVoluntario", "IdVoluntario", disponibilidad.IdVoluntario);
return(View(disponibilidad));
}
public async Task <IActionResult> Edit(int id, [Bind("IdVoluntario,IdCompania,IdEstadoVoluntario,Rut,DigitoVerificador,Nombres,ApellidoPaterno,ApellidoMaterno,FechaNacimiento,FechaIncorporacion")] Voluntario voluntario)
{
if (id != voluntario.IdVoluntario)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(voluntario);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!VoluntarioExists(voluntario.IdVoluntario))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdCompania"] = new SelectList(_context.Compania, "IdCompania", "DenominacionCompania", voluntario.IdCompania);
ViewData["IdEstadoVoluntario"] = new SelectList(_context.EstadoVoluntario, "IdEstadoVoluntario", "DescripcionEstadoVoluntario", voluntario.IdEstadoVoluntario);
return(View(voluntario));
}
public async Task <IActionResult> Edit(int id, [Bind("IdFuncionalidad,DescripcionFuncionalidad,Controller,Metodo")] Funcionalidad funcionalidad)
{
if (id != funcionalidad.IdFuncionalidad)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(funcionalidad);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FuncionalidadExists(funcionalidad.IdFuncionalidad))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(funcionalidad));
}