public async Task <IActionResult> Edit(int id, [Bind("Id,ResumeId,Clearance,IssuedBy,InvestigationType,ProgramAccess,AdditionalInvestigations")] TblResumeClearance tblResumeClearance)
{
if (id != tblResumeClearance.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResumeClearance);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResumeClearanceExists(tblResumeClearance.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResumeClearance));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResumeId,ProjectTitle,StartDate,EndDate,ProjectExperienceDetails,CompanyOrganizationName,SortOrderNum")] TblResumeProjectExperience tblResumeProjectExperience)
{
if (id != tblResumeProjectExperience.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResumeProjectExperience);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResumeProjectExperienceExists(tblResumeProjectExperience.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResumeProjectExperience));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResumeId,PositionTitle,DepartmentDivision,CompanyOrganizationName,StartDate,EndDate,PresentPosition,SortOrderNum")] TblResumePositionHistory tblResumePositionHistory)
{
if (id != tblResumePositionHistory.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResumePositionHistory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResumePositionHistoryExists(tblResumePositionHistory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResumePositionHistory));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResumeId,AdditionalTools")] TblResumeAdditionalRelevantTool tblResumeAdditionalRelevantTool)
{
if (id != tblResumeAdditionalRelevantTool.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResumeAdditionalRelevantTool);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResumeAdditionalRelevantToolExists(tblResumeAdditionalRelevantTool.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResumeAdditionalRelevantTool));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResourceId,ReviewDate,ReviewerId,ReviewStatusId,ReviewName")] TblAnnualReview tblAnnualReview)
{
if (id != tblAnnualReview.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblAnnualReview);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblAnnualReviewExists(tblAnnualReview.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblAnnualReview));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResourceId,LastName,MiddleName,FirstName,FullName,Suffix,DepartmentId,Image,Email,Phone,StatusId,StartDate,EndDate,ReportsToId,RoleId")] TblResource tblResource)
{
if (id != tblResource.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResource);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResourceExists(tblResource.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResource));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,QuestionNumber,QuestionText")] TblAnnualReviewGeneralQuestion tblAnnualReviewGeneralQuestion)
{
if (id != tblAnnualReviewGeneralQuestion.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblAnnualReviewGeneralQuestion);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblAnnualReviewGeneralQuestionExists(tblAnnualReviewGeneralQuestion.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblAnnualReviewGeneralQuestion));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AnnualReviewId,CompetencyNumber,CompetencyResponseExperienceCapabilityRatingId,CompetencyResponseIndustry,CompetencyResponseGrowthInterest,CompetencyResponseNotes")] TblAnnualReviewCompetencyResponse tblAnnualReviewCompetencyResponse)
{
if (id != tblAnnualReviewCompetencyResponse.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblAnnualReviewCompetencyResponse);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblAnnualReviewCompetencyResponseExists(tblAnnualReviewCompetencyResponse.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblAnnualReviewCompetencyResponse));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AssignedTo,TaskName,DueDate,TaskStatusId,TaskTypeId,AssociatedRecordId,DateCreated,LastModified,CreatedBy,ModifiedBy,Archived")] TblTask tblTask)
{
if (id != tblTask.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblTask);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblTaskExists(tblTask.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblTask));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ScaleNumber,ScaleDescription")] TblExperienceCapabilityScale tblExperienceCapabilityScale)
{
if (id != tblExperienceCapabilityScale.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblExperienceCapabilityScale);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblExperienceCapabilityScaleExists(tblExperienceCapabilityScale.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblExperienceCapabilityScale));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Agency")] TblClearanceAgency tblClearanceAgency)
{
if (id != tblClearanceAgency.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblClearanceAgency);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblClearanceAgencyExists(tblClearanceAgency.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblClearanceAgency));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ToolCategoryName")] TblAnnualReviewToolsoftheTradeCategory tblAnnualReviewToolsoftheTradeCategory)
{
if (id != tblAnnualReviewToolsoftheTradeCategory.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblAnnualReviewToolsoftheTradeCategory);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblAnnualReviewToolsoftheTradeCategoryExists(tblAnnualReviewToolsoftheTradeCategory.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblAnnualReviewToolsoftheTradeCategory));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AnnualReviewId,CompetencyResponseId,ToolId")] TblAnnualReviewCompetencyToolsResponse tblAnnualReviewCompetencyToolsResponse)
{
if (id != tblAnnualReviewCompetencyToolsResponse.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblAnnualReviewCompetencyToolsResponse);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblAnnualReviewCompetencyToolsResponseExists(tblAnnualReviewCompetencyToolsResponse.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblAnnualReviewCompetencyToolsResponse));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResumeId,EducationTrainingCertAfilliation,Abbreviation,IssuedBy")] TblResumeEducationTrainingCertsAffiliation tblResumeEducationTrainingCertsAffiliation)
{
if (id != tblResumeEducationTrainingCertsAffiliation.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResumeEducationTrainingCertsAffiliation);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResumeEducationTrainingCertsAffiliationExists(tblResumeEducationTrainingCertsAffiliation.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResumeEducationTrainingCertsAffiliation));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,From,Subject,Cc,Body,DateTimeReceived,AttachmentFileName,Archived")] TblKudosEmail tblKudosEmail)
{
if (id != tblKudosEmail.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblKudosEmail);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblKudosEmailExists(tblKudosEmail.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblKudosEmail));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,KudosToDisplayName,KudosToEmail,DateCreated,CreatedBy,CreatedByEmail,Note,Archived")] TblKudo tblKudo)
{
if (id != tblKudo.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblKudo);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblKudoExists(tblKudo.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblKudo));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,AnnualReviewId,Comments,CommentsBy,CommentsDate")] TblAnnualReviewsManagementComment tblAnnualReviewsManagementComment)
{
if (id != tblAnnualReviewsManagementComment.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblAnnualReviewsManagementComment);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblAnnualReviewsManagementCommentExists(tblAnnualReviewsManagementComment.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblAnnualReviewsManagementComment));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ResourceId,DateCreated,LastModified,CreatedBy,ModifiedBy,Overview,ResumeStatusId,ResumeName,ReviewedByManager")] TblResume tblResume)
{
if (id != tblResume.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(tblResume);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TblResumeExists(tblResume.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tblResume));
}
public async Task UpdateReview(Review review)
{
_reviewContext.Update(review);
await _reviewContext.SaveChangesAsync();
}
