public async Task <IActionResult> Edit(int id, [Bind("ProjectId,ProScholType,Title,Description,FkFacultyProject")] ProjectScholarship projectScholarship)
{
if (id != projectScholarship.ProjectId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(projectScholarship);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectScholarshipExists(projectScholarship.ProjectId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkFacultyProject"] = new SelectList(_context.Faculty, "FacultyId", "FacultyId", projectScholarship.FkFacultyProject);
return(View(projectScholarship));
}
public async Task <IActionResult> Edit(int id, [Bind("ResearchAreaId,FieldName,AreaDescription")] Researcharea researcharea)
{
if (id != researcharea.ResearchAreaId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(researcharea);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResearchareaExists(researcharea.ResearchAreaId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(researcharea));
}
public async Task <IActionResult> Edit(string id, [Bind("IitianName,IitianMail,SemesterCi,Connected,LastUpdate")] Iitian iitian)
{
if (id != iitian.IitianMail)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(iitian);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IitianExists(iitian.IitianMail))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(iitian));
}
public async Task <IActionResult> Edit(int id, [Bind("ImageId,Img,ImgName")] Image image)
{
if (id != image.ImageId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(image);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ImageExists(image.ImageId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(image));
}
public async Task <IActionResult> Edit(string id, [Bind("FacultyId,Name,Designation,Qualification,Links,Status,AboutMe,Teachings,FkFacultyImage")] Faculty faculty)
{
if (id != faculty.FacultyId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(faculty);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FacultyExists(faculty.FacultyId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkFacultyImage"] = new SelectList(_context.Image, "ImageId", "ImgName", faculty.FkFacultyImage);
return(View(faculty));
}
public async Task <IActionResult> Edit(int id, [Bind("IdeventImage,Caption,FkEventEvemge,FkImageEvemge")] EventImage eventImage)
{
if (id != eventImage.IdeventImage)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(eventImage);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventImageExists(eventImage.IdeventImage))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkEventEvemge"] = new SelectList(_context.Event, "EventId", "EventId", eventImage.FkEventEvemge);
ViewData["FkImageEvemge"] = new SelectList(_context.Image, "ImageId", "ImgName", eventImage.FkImageEvemge);
return(View(eventImage));
}
public async Task <IActionResult> Edit(int id, [Bind("ResearchId,Title,Description,FkFacultyResearch")] Research research)
{
if (id != research.ResearchId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(research);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ResearchExists(research.ResearchId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkFacultyResearch"] = new SelectList(_context.Faculty, "FacultyId", "FacultyId", research.FkFacultyResearch);
return(View(research));
}
public async Task <IActionResult> Edit(int id, [Bind("AcDocId,Note,FkAcademicAcdoc,FkDocumentAcdoc")] AcademicDocument academicDocument)
{
if (id != academicDocument.AcDocId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(academicDocument);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AcademicDocumentExists(academicDocument.AcDocId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkAcademicAcdoc"] = new SelectList(_context.Academic, "AcademicId", "AcademicAdmission", academicDocument.FkAcademicAcdoc);
ViewData["FkDocumentAcdoc"] = new SelectList(_context.Document, "DocumentId", "PdfName", academicDocument.FkDocumentAcdoc);
return(View(academicDocument));
}
public async Task <IActionResult> Edit(int id, [Bind("PubDocId,FkPublicationPubdoc,FkDocumentPubdoc")] PublicationDocument publicationDocument)
{
if (id != publicationDocument.PubDocId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(publicationDocument);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PublicationDocumentExists(publicationDocument.PubDocId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkDocumentPubdoc"] = new SelectList(_context.Document, "DocumentId", "PdfName", publicationDocument.FkDocumentPubdoc);
ViewData["FkPublicationPubdoc"] = new SelectList(_context.Publication, "PublicationId", "PublicationId", publicationDocument.FkPublicationPubdoc);
return(View(publicationDocument));
}
public async Task <IActionResult> Edit(int id, [Bind("AcademicId,AcademicSection,Programs,AcademicInfo,AcademicAdmission")] Academic academic)
{
if (id != academic.AcademicId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(academic);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AcademicExists(academic.AcademicId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(academic));
}
public async Task <IActionResult> Edit(int id, [Bind("FacPubId,FkFacultyFacpub,FkPublicationFacpub")] FacultyPublication facultyPublication)
{
if (id != facultyPublication.FacPubId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(facultyPublication);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!FacultyPublicationExists(facultyPublication.FacPubId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkFacultyFacpub"] = new SelectList(_context.Faculty, "FacultyId", "FacultyId", facultyPublication.FkFacultyFacpub);
ViewData["FkPublicationFacpub"] = new SelectList(_context.Publication, "PublicationId", "PublicationId", facultyPublication.FkPublicationFacpub);
return(View(facultyPublication));
}
public async Task <IActionResult> Edit(string id, [Bind("CrMailId,Semester")] Cr cr)
{
if (id != cr.CrMailId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cr);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CrExists(cr.CrMailId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cr));
}
public async Task <IActionResult> Edit(int id, [Bind("IndustryId,Featured,IndustryName,IndIcon,IndLink")] Industry industry)
{
if (id != industry.IndustryId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(industry);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!IndustryExists(industry.IndustryId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["IndIcon"] = new SelectList(_context.Image, "ImageId", "ImgName", industry.IndIcon);
return(View(industry));
}
public async Task <IActionResult> Edit(int id, [Bind("StaffsId,Name,Designation,FkStaffImage")] Staff staff)
{
if (id != staff.StaffsId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(staff);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StaffExists(staff.StaffsId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkStaffImage"] = new SelectList(_context.Image, "ImageId", "ImgName", staff.FkStaffImage);
return(View(staff));
}
public async Task <IActionResult> Edit(int id, [Bind("RoutineId,Date,CourseCode,BeginTime,EndTime,Semester,Dayname,FkInstructorId")] Routine routine)
{
if (id != routine.RoutineId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(routine);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RoutineExists(routine.RoutineId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkInstructorId"] = new SelectList(_context.Instructor, "InstructorId", "InstructorId", routine.FkInstructorId);
return(View(routine));
}
public async Task <IActionResult> Edit(int id, [Bind("AnoId,Aim")] Ano ano)
{
if (id != ano.AnoId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ano);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AnoExists(ano.AnoId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(ano));
}
public async Task <IActionResult> Edit(int id, [Bind("NoticeId,Title,Section,Description,Date,Time,FkNoticeDocument")] Notice notice)
{
if (id != notice.NoticeId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(notice);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!NoticeExists(notice.NoticeId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkNoticeDocument"] = new SelectList(_context.Document, "DocumentId", "PdfName", notice.FkNoticeDocument);
return(View(notice));
}
public async Task <IActionResult> Edit(int id, [Bind("AchievementId,Title,Description,Date,Venue,FkAchievementImage,ImageCaption")] Achievement achievement)
{
if (id != achievement.AchievementId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(achievement);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AchievementExists(achievement.AchievementId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkAchievementImage"] = new SelectList(_context.Image, "ImageId", "ImgName", achievement.FkAchievementImage);
return(View(achievement));
}
public async Task <IActionResult> Edit(int id, [Bind("DocumentId,PdfName,Pdf")] Document document)
{
if (id != document.DocumentId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(document);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!DocumentExists(document.DocumentId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(document));
}
public async Task <IActionResult> Edit(int id, [Bind("EventId,Title,Description,Date,Time,Venue")] Event @event)
{
if (id != @event.EventId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(@event);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EventExists(@event.EventId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(@event));
}
public async Task <IActionResult> Edit(int id, [Bind("HistoryId,HeadingText,DirectorName,ActFrom,ActTo,RohTable")] History history)
{
if (id != history.HistoryId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(history);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HistoryExists(history.HistoryId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(history));
}
public async Task <IActionResult> Edit(int id, [Bind("PublicationId,Title,PubType,PubYear")] Publication publication)
{
if (id != publication.PublicationId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(publication);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PublicationExists(publication.PublicationId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(publication));
}
public async Task <IActionResult> Edit(int id, [Bind("InstitutionId,InstHeader,InstDescription,FkInstImage")] Institution institution)
{
if (id != institution.InstitutionId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(institution);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstitutionExists(institution.InstitutionId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["FkInstImage"] = new SelectList(_context.Image, "ImageId", "ImgName", institution.FkInstImage);
return(View(institution));
}
public async Task <IActionResult> Edit(string id, [Bind("InstructorId,InstructorMail,InstructorName")] Instructor instructor)
{
if (id != instructor.InstructorId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(instructor);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InstructorExists(instructor.InstructorId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(instructor));
}