public async Task <IActionResult> Edit(int id, [Bind("AdmittedId,Name")] Admition admition)
{
if (id != admition.AdmittedId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(admition);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AdmitionExists(admition.AdmittedId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(admition));
}
public async Task <IActionResult> Edit(int id, [Bind("CompetitionId,Name,Place,StartTax,StartTime,IdComplexity,IdType")] Competition competition)
{
if (id != competition.CompetitionId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(competition);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompetitionExists(competition.CompetitionId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdComplexity"] = new SelectList(_context.Complexities, "ComplexityId", "Name", competition.IdComplexity);
ViewData["IdType"] = new SelectList(_context.Types, "TypeId", "Name", competition.IdType);
return(View(competition));
}
public async Task <IActionResult> Edit(int id, [Bind("CompetitionTeamId,CompetitionId,TeamId,AdmittedId,ResultTime,Penalty,Position")] CompetitionTeam competitionTeam)
{
if (id != competitionTeam.CompetitionTeamId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(competitionTeam);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CompetitionTeamExists(competitionTeam.CompetitionTeamId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["AdmittedId"] = new SelectList(_context.Admitions, "AdmittedId", "Name", competitionTeam.AdmittedId);
ViewData["CompetitionId"] = new SelectList(_context.Competitions, "CompetitionId", "Name", competitionTeam.CompetitionId);
ViewData["TeamId"] = new SelectList(_context.Teams, "TeamId", "Comment", competitionTeam.TeamId);
return(View(competitionTeam));
}
public async Task <IActionResult> Edit(int id, [Bind("TeamPartisipantId,PartisipantId,TeamId,Participated")] TeamPartisipant teamPartisipant)
{
if (id != teamPartisipant.TeamPartisipantId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(teamPartisipant);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeamPartisipantExists(teamPartisipant.TeamPartisipantId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PartisipantId"] = new SelectList(_context.Partisipants, "ParticipantId", "Name", teamPartisipant.PartisipantId);
ViewData["TeamId"] = new SelectList(_context.Teams, "TeamId", "Comment", teamPartisipant.TeamId);
return(View(teamPartisipant));
}
public async Task <IActionResult> Edit(int id, [Bind("TeamId,Name,FileDocument,Comment")] Team team)
{
if (id != team.TeamId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(team);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeamExists(team.TeamId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(team));
}
public async Task <IActionResult> Edit(int id, [Bind("RankId,Name")] Rank rank)
{
if (id != rank.RankId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(rank);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RankExists(rank.RankId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(rank));
}
public async Task <IActionResult> Edit(int id, [Bind("ObstacleCompetitionId,ObstacleId,CompetitionId")] ObstacleCompetition obstacleCompetition)
{
if (id != obstacleCompetition.ObstacleCompetitionId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(obstacleCompetition);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ObstacleCompetitionExists(obstacleCompetition.ObstacleCompetitionId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["CompetitionId"] = new SelectList(_context.Competitions, "CompetitionId", "Name", obstacleCompetition.CompetitionId);
ViewData["ObstacleId"] = new SelectList(_context.Obstacles, "ObstacleId", "Name", obstacleCompetition.ObstacleId);
return(View(obstacleCompetition));
}
public async Task <IActionResult> Edit(int id, [Bind("ObstacleId,Name,AdditionalDescription,EquipmentStart,EquipmentObstacle,EquipmentTarget,Length,Height,MovementFirst,ConditionsOvercoming,ConditionalComplexity,ObstacleEvaluation")] Obstacle obstacle)
{
if (id != obstacle.ObstacleId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(obstacle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ObstacleExists(obstacle.ObstacleId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(obstacle));
}
public async Task <IActionResult> Edit(int id, [Bind("RankPartisipantId,RankId,PartisipantId,DateOfAchievement")] RankPartisipant rankPartisipant)
{
if (id != rankPartisipant.RankPartisipantId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(rankPartisipant);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RankPartisipantExists(rankPartisipant.RankPartisipantId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PartisipantId"] = new SelectList(_context.Partisipants, "ParticipantId", "Name", rankPartisipant.PartisipantId);
ViewData["RankId"] = new SelectList(_context.Ranks, "RankId", "Name", rankPartisipant.RankId);
return(View(rankPartisipant));
}
public async Task <IActionResult> Edit(int id, [Bind("ParticipantId,Name,DateOfBirth,IdSex,PhoneNumber,IdRole,FileInsurance")] Partisipant partisipant)
{
if (id != partisipant.ParticipantId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(partisipant);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PartisipantExists(partisipant.ParticipantId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IdRole"] = new SelectList(_context.Roles, "RolesId", "Name", partisipant.IdRole);
ViewData["IdSex"] = new SelectList(_context.Sexes, "SexId", "Name", partisipant.IdSex);
return(View(partisipant));
}
public async Task <IActionResult> Edit(int id, [Bind("ResultId,PartisipantId,ObstacleCompetitionId,Time,Penalty")] Result result)
{
if (id != result.ResultId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(result);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResultExists(result.ResultId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ObstacleCompetitionId"] = new SelectList(_context.ObstacleCompetitions, "ObstacleCompetitionId", "ObstacleCompetitionId", result.ObstacleCompetitionId);
ViewData["PartisipantId"] = new SelectList(_context.Partisipants, "ParticipantId", "Name", result.PartisipantId);
return(View(result));
}
public async Task <IActionResult> Edit(int id, [Bind("ComplexityId,Name")] Complexity complexity)
{
if (id != complexity.ComplexityId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(complexity);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ComplexityExists(complexity.ComplexityId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(complexity));
}
