public async Task <IActionResult> Edit(int id, [Bind("LeaseId,BookId,UserId,Date")] Lease lease) { if (id != lease.LeaseId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(lease); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!LeaseExists(lease.LeaseId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["BookId"] = new SelectList(_context.Book, "BookId", "BookId", lease.BookId); ViewData["UserId"] = new SelectList(_context.User, "UserId", "Login", lease.UserId); return(View(lease)); }
public async Task <IActionResult> Edit(int id, [Bind("id,title")] Chapter chapter) { if (id != chapter.id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(chapter); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ChapterExists(chapter.id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(chapter)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,CityId,ConferenceId,Year,Bibliography,SupervisorId,ConferenceStartDate,ConferenceEndDate,PublicationDate,Pages,Page,Volume,ConferenceNumber")] Article article) { if (id != article.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(article); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ArticleExists(article.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["CityId"] = new SelectList(_context.City, "Id", "Name", article.CityId); ViewData["ConferenceId"] = new SelectList(_context.Conference, "Id", "Name", article.ConferenceId); ViewData["SupervisorId"] = new SelectList(_context.Author, "Id", "LastName", article.SupervisorId); return(View(article)); }
public async Task <IActionResult> Edit(int id, [Bind("StudentId,Name,RollNo,NRC,Grade")] Student student) { if (id != student.StudentId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(student); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!StudentExists(student.StudentId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(student)); }
public async Task <IActionResult> Edit(long id, [Bind("Id,Title,Content,CreationDate")] Draft draft) { if (id != draft.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(draft); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!DraftExists(draft.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(draft)); }
public async Task <IActionResult> Edit(int id, [Bind("UserId,Name,Surname,AddressId,UserType,Login,Password")] User user) { if (id != user.UserId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(user); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(user.UserId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["AddressId"] = new SelectList(_context.Address, "AddressId", "AddressId", user.AddressId); return(View(user)); }
public async Task <IActionResult> Edit(int id, [Bind("AddressId,City,Street,StreetNumber,PostalCode")] Address address) { if (id != address.AddressId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(address); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AddressExists(address.AddressId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(address)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,BookId,ApplicationUserId,StartDate,MaxDate,EndDate, Description")] Borrowing borrowing) { if (id != borrowing.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(borrowing); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BorrowingExists(borrowing.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["ApplicationUserId"] = new SelectList(_context.ApplicationUser, "Id", "UserName", borrowing.ApplicationUserId); ViewData["BookId"] = new SelectList(_context.Book, "Id", "Title", borrowing.BookId); return(View(borrowing)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,BookId,StudentId,RentDate,Qty")] BookRent bookRent) { if (id != bookRent.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(bookRent); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BookRentExists(bookRent.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["BookId"] = new SelectList(_context.Book, "BookId", "BookId", bookRent.BookId); ViewData["StudentId"] = new SelectList(_context.Student, "StudentId", "StudentId", bookRent.StudentId); return(View(bookRent)); }
public async Task <IActionResult> Edit(int id, [Bind("ArticleId,KeywordId")] ArticleKeyword articleKeyword) { if (id != articleKeyword.ArticleId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(articleKeyword); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ArticleKeywordExists(articleKeyword.ArticleId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["ArticleId"] = new SelectList(_context.Article, "Id", "Name", articleKeyword.ArticleId); ViewData["KeywordId"] = new SelectList(_context.Keyword, "Id", "Name", articleKeyword.KeywordId); return(View(articleKeyword)); }
public async Task <IActionResult> Edit(int id, [Bind("id,firstName,lastName,date,book_title")] Readers_Card readers_Card) { if (id != readers_Card.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(readers_Card); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!Readers_CardExists(readers_Card.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(readers_Card)); }
public async Task <IActionResult> Edit(int id, [Bind("ReturnId,Qty,ReturnDate,Id")] ReturnBook returnBook) { if (id != returnBook.ReturnId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(returnBook); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ReturnBookExists(returnBook.ReturnId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["Id"] = new SelectList(_context.Bookrent, "Id", "Id", returnBook.Id); return(View(returnBook)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Description,Goal,Tasks,Progress")] Research research) { if (id != research.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(research); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ResearchExists(research.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(research)); }
public async Task <IActionResult> Edit(int id, [Bind("DisciplineId,AuthorId")] DisciplineAuthor disciplineAuthor) { if (id != disciplineAuthor.DisciplineId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(disciplineAuthor); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!DisciplineAuthorExists(disciplineAuthor.DisciplineId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["AuthorId"] = new SelectList(_context.Author, "Id", "LastName", disciplineAuthor.AuthorId); ViewData["DisciplineId"] = new SelectList(_context.Discipline, "Id", "Name", disciplineAuthor.DisciplineId); return(View(disciplineAuthor)); }
public async Task <IActionResult> Edit(int id, [Bind("CategoryId,CategoryName,Description")] Category category) { if (id != category.CategoryId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(category); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!CategoryExists(category.CategoryId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(category)); }
public async Task <IActionResult> Edit(int id, [Bind("ID,Title,Author,ISBN,PublicationYear,Publisher,Country")] Book book) { if (id != book.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(book); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BookExists(book.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(book)); }
public async Task <IActionResult> Edit(int id, [Bind("LoanID,UserID,BookID")] Loan loan) { if (id != loan.LoanID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(loan); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!LoanExists(loan.LoanID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["BookID"] = new SelectList(_context.Books, "ID", "ID", loan.BookID); ViewData["UserID"] = new SelectList(_context.Users, "ID", "ID", loan.UserID); return(View(loan)); }
public async Task <IActionResult> Edit(int id, [Bind("Id, Title, Year, Cost, ImageUrl, NumberOfCopies, ISBN, Author, DeweyIndex, LocationId")] Asset libraryAsset) { if (id != libraryAsset.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(libraryAsset); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!LibraryAssetExists(libraryAsset.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("Index", "Asset")); } return(View(libraryAsset)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,FirstName,LastName,Address,DateOfBirth,TelephoneNumber,HomeLibraryBranchId")] Patron patron) { if (id != patron.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(patron); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!PatronExists(patron.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("Index", "Patron")); } return(View(patron)); }
public async Task <IActionResult> Edit(int id, [Bind("ResearchId,ThemeId")] ResearchTheme researchTheme) { if (id != researchTheme.ResearchId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(researchTheme); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ResearchThemeExists(researchTheme.ResearchId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["ResearchId"] = new SelectList(_context.Research, "Id", "Name", researchTheme.ResearchId); ViewData["ThemeId"] = new SelectList(_context.Theme, "Id", "Name", researchTheme.ThemeId); return(View(researchTheme)); }
public async Task <IActionResult> Edit(int id, [Bind("ThemeId,ArticleId")] ThemeArticle themeArticle) { if (id != themeArticle.ThemeId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(themeArticle); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ThemeArticleExists(themeArticle.ThemeId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["ArticleId"] = new SelectList(_context.Article, "Id", "Name", themeArticle.ArticleId); ViewData["ThemeId"] = new SelectList(_context.Theme, "Id", "Name", themeArticle.ThemeId); return(View(themeArticle)); }
public async Task <IActionResult> Edit(int id, [Bind("id,firstName,lastName,dateOfBirth,books_amount")] Author author) { if (id != author.id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(author); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AuthorExists(author.id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(author)); }
public async Task <IActionResult> Edit(int id, [Bind("BookId,Title,AuthorId,Description,BookType")] Book book) { if (id != book.BookId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(book); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!BookExists(book.BookId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["AuthorId"] = new SelectList(_context.Author, "AuthorId", "AuthorId", book.AuthorId); return(View(book)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,Address,Telephone,Description,OpenDate,ImageUrl")] Branch libraryBranch) { if (id != libraryBranch.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(libraryBranch); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!LibraryBranchExists(libraryBranch.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction("Index", "Branch")); } return(View(libraryBranch)); }
public async Task <IActionResult> Edit(int id, [Bind("ID,LastName,FirstMidName")] User user) { if (id != user.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(user); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(user.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(user)); }
public async Task <IActionResult> Edit(int id, [Bind("AuthorId,BookId")] AuthorBook authorBook) { if (id != authorBook.AuthorId) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(authorBook); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AuthorBookExists(authorBook.AuthorId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["AuthorId"] = new SelectList(_context.Author, "Id", "LastName", authorBook.AuthorId); ViewData["BookId"] = new SelectList(_context.Book, "Id", "Name", authorBook.BookId); return(View(authorBook)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name,ContentType,Data,TypeId,Version,ArticleId")] FileArticle fileArticle) { if (id != fileArticle.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(fileArticle); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!FileArticleExists(fileArticle.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } ViewData["ArticleId"] = new SelectList(_context.Article, "Id", "Name", fileArticle.ArticleId); ViewData["TypeId"] = new SelectList(_context.FileType, "Id", "Name", fileArticle.TypeId); return(View(fileArticle)); }
public async Task <IActionResult> Edit(long id, [Bind("Id,Name,Content,Explanation")] Hypothesis hypothesis) { if (id != hypothesis.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(hypothesis); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!HypothesisExists(hypothesis.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(hypothesis)); }
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] Scale scale) { if (id != scale.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(scale); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ScaleExists(scale.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(scale)); }
public async Task <IActionResult> Edit(int id, [Bind("ID,TestDate,NoOfParticipants")] TestDetails testDetails) { if (id != testDetails.ID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(testDetails); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TestDetailsExists(testDetails.ID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(testDetails)); }