public async Task <IActionResult> Detale(int id, [Bind("id_zamowienia,id_ksiazki,tytul,ilosc")] ZamowienieKsiazkiViewModel zamowienie_ksiazki)
{
if (zamowienie_ksiazki.ilosc > 1000 || zamowienie_ksiazki.ilosc < 1)
{
ModelState.AddModelError("", "Ilość książek musi mieścić się w przedziale 1-1000");
return(RedirectToAction("Detale", "Zamowienia", id));
}
if (ModelState.IsValid)
{
var temp = new Zamowienie_ksiazki();
temp.id_zamowienia = id;
temp.id_ksiazki = zamowienie_ksiazki.id_ksiazki;
temp.ilosc = zamowienie_ksiazki.ilosc;
var duplikat = await _context.Zamowienie_ksiazki.FirstOrDefaultAsync(m => m.id_zamowienia == id && m.id_ksiazki == temp.id_ksiazki);
if (duplikat != null)
{
duplikat.ilosc += temp.ilosc;
_context.Update(duplikat);
}
else
{
_context.Add(temp);
}
await _context.SaveChangesAsync();
return(RedirectToAction("Detale", "Zamowienia", new { id = id }));
}
ViewData["id_ksiazki"] = new SelectList(_context.Ksiazki, "id_ksiazki", "tytuł", zamowienie_ksiazki.id_ksiazki);
return(View(zamowienie_ksiazki.id_zamowienia));
}
/// <summary>
/// ApproveAsync
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public async Task ApproveAsync(int id)
{
var order = await _context.Orders.FindAsync(id);
order.OrderStateId = 2;
await _context.SaveChangesAsync();
}
public async Task <T> AddAsync(T entity)
{
_dbContext.Set <T>().Add(entity);
await _dbContext.SaveChangesAsync();
return(entity);
}
public async Task <IActionResult> AddMovie(MovieViewModel model)
{
var newMovie = new Movie
{
Name = model.Name,
Country = model.Country,
MovieGenres = model.MovieGenres.Select(d => new MovieGenre {
GenreId = d
}).ToList(),
Actors = model.Actors,
Price = model.Price,
Summary = model.Summary,
Director = model.Director,
ReleaseDate = model.ReleaseDate,
};
var file = this.HttpContext.Request.Form.Files.FirstOrDefault();
if (file != null && file.Length > 0)
{
var fileName = ImageHelper.UploadImage(file, Path.Combine(this.environment.WebRootPath, "MovieImages"));
newMovie.Image = fileName;
}
db.Movies.Add(newMovie);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> PutLibraryAssett([FromRoute] int id, [FromBody] LibraryAsset libraryAssett)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != libraryAssett.Id)
{
return(BadRequest());
}
_context.Entry(libraryAssett).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LibraryAssettExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutBook(int id, Book book)
{
if (id != book.Id)
{
return(BadRequest());
}
_context.Entry(book).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutBookAuthor(int authorid, string isbn, BookAuthor bookAuthor)
{
if (authorid != bookAuthor.AuthorID || isbn != bookAuthor.ISBN || !ModelState.IsValid)
{
return(BadRequest(ModelState.SelectMany(x => x.Value.Errors)));
}
_context.Entry(bookAuthor).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookAuthorExists(authorid, isbn))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> UpdateLibrary(long id, LibraryDTO libraryDTO)
{
if (id != libraryDTO.Id)
{
return(BadRequest());
}
var library = await _context.Libraries.FindAsync(id);
if (library == null)
{
return(NotFound());
}
library.Id = libraryDTO.Id;
library.Address = libraryDTO.Address;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException) when(!LibraryExists(id))
{
return(NotFound());
}
return(NoContent());
}
public async Task <IActionResult> Edytuj(int id, Ksiazki ksiazka)
{
if (id != ksiazka.id_ksiazki)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(ksiazka);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!KsiazkaExists(ksiazka.id_ksiazki))
{
return(NotFound());
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(ksiazka));
}
public async Task <Character> AddCharacter(CharacterDto character)
{
AppUserCharacter appUserChar;
var user = await _userManager.FindByEmailAsync(User.FindFirstValue(ClaimTypes.Email));
var characterInDb = _dbContext.Characters.FirstOrDefault(c => c.CharacterId == character.Id);
if (characterInDb is null)
{
appUserChar = new AppUserCharacter
{
AppUserId = user.Id,
Character = new Character
{
CharacterId = character.Id,
}
};
}
else
{
appUserChar = new AppUserCharacter
{
AppUserId = user.Id,
Character = characterInDb
};
}
await _dbContext.AppUserCharacters.AddAsync(appUserChar);
await _dbContext.SaveChangesAsync();
return(appUserChar.Character);
}
public async Task <IActionResult> PutBorrowing(int borrowerid, int inventoryid, Borrowing borrowing)
{
if (borrowerid != borrowing.BorrowerID || inventoryid != borrowing.InventoryID || !ModelState.IsValid)
{
return(BadRequest(ModelState.SelectMany(x => x.Value.Errors)));
}
_context.Entry(borrowing).State = EntityState.Modified;
InventoryItem item = await _context.InventoryItems.FirstOrDefaultAsync(i => i.InventoryID == inventoryid);
try
{
if (borrowing.ReturnDate != null) //I de allra flesta fall är nu boken återlämnad.
{
item.Available = true; //Skulle väl vara i ev. klientprogrammet som säkerheten gällande returdatum ska skötas?
}
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BorrowingExists(inventoryid, borrowerid))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutInventoryItem(int id, InventoryItem inventoryItem)
{
if (id != inventoryItem.InventoryID || !ModelState.IsValid)
{
return(BadRequest(ModelState.SelectMany(x => x.Value.Errors)));
}
_context.Entry(inventoryItem).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!InventoryItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <T> InsertAsync <T>(T entity) where T : BaseEntity
{
await _dbContext.Set <T>().AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(entity);
}
public async Task <IdentityResult> CreateAsync(Uzytkownicy user, CancellationToken cancellationToken)
{
_libraryDbContext.Add(user);
await _libraryDbContext.SaveChangesAsync(cancellationToken);
return(await Task.FromResult(IdentityResult.Success));
}
public async Task <BookModel> AddBook(Book entity)
{
var data = await _dbContext.Books.AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(data.Entity.BookExtensions());
}
public async Task <IActionResult> Create(Author author)
{
await _context.Authors.AddAsync(author);
await _context.SaveChangesAsync();
return(View());
}
/// <summary>
/// Adds the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <returns></returns>
public virtual async Task <TId> Add(T item)
{
await _dataSet.AddAsync(item);
await _context.SaveChangesAsync();
return(item.Id);
}
public async Task <AuthorModel> AddAuthor(Author entity)
{
var data = await _dbContext.Authors.AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(data.Entity.AuthorExtensions());
}
public async Task <bool> Add(LibraryAssetDto assetDto)
{
var newAsset = _mapper.Map <Asset>(assetDto);
await _context.AddAsync(newAsset);
await _context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> Create([Bind("ID, Name, Genre")] Author author)
{
await _context.Authors.AddAsync(author);
await _context.SaveChangesAsync();
int id = author.ID;
return(View());
}
/// <summary>
/// CreateAsync
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task CreateAsync(CreateAuthorViewModel model)
{
var author = new Entities.Author
{
Name = model.Name
};
await _context.Authors.AddAsync(author);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Create([Bind("Id,CollectionName,Restrictions,ContactInstructions")] SpecialCollection specialCollection)
{
if (ModelState.IsValid)
{
_context.Add(specialCollection);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(specialCollection));
}
public async Task <IActionResult> Create([Bind("Id,RoomName,FloorNumber,Capacity")] Room room)
{
if (ModelState.IsValid)
{
_context.Add(room);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(room));
}
public async Task <IActionResult> Create([Bind("CustomerId,Name")] Customer customer)
{
if (ModelState.IsValid)
{
_context.Add(customer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <IActionResult> Create([Bind("UserId,UserName,UserFirstName,UserLastName")] User user)
{
if (ModelState.IsValid)
{
_context.Add(user);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public async Task <IActionResult> Create([Bind("Id,StaffName,StaffPassword")] Staff staff)
{
if (ModelState.IsValid)
{
_context.Add(staff);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(staff));
}
public async Task <IActionResult> Create([Bind("BookId,BookName,BookAuthor,BookPublisher,BookPrice,Description,Stock,Image")] Book book)
{
if (ModelState.IsValid)
{
_context.Add(book);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(book));
}
public async Task <IActionResult> Create([Bind("Id,AuthorName")] Author author)
{
if (ModelState.IsValid)
{
_context.Add(author);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(author));
}
public async Task <IActionResult> Create([Bind("Id,Titulo,IdEditorial,Fecha,Costo,PrecioSugerido,Autor")] Libro libro)
{
if (ModelState.IsValid)
{
_context.Add(libro);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(libro));
}
public async Task <IActionResult> Create([Bind("Id,Active,ExpirationDate,StudentId")] LibraryCard libraryCard)
{
if (ModelState.IsValid)
{
_context.Add(libraryCard);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["StudentId"] = new SelectList(_context.Student, "Id", "Id", libraryCard.StudentId);
return(View(libraryCard));
}
