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> PutTransaction(int id, Transaction transaction)
{
if (id != transaction.TransactionId)
{
return(BadRequest());
}
_context.Entry(transaction).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <GetBookDetailsResponse> > AddABook([FromBody] BookCreateRequest bookToAdd)
{
// 1. Validate the incoming entity
if (!ModelState.IsValid)
{
// -- if it fails, send back a 400 with our without details.
return(BadRequest(ModelState));
}
else
{
// 2. Change the domain
// - add the book to the database. (BookCreateRequest -> Book)
var book = _mapper.Map <Book>(bookToAdd);
_context.Books.Add(book);
await _context.SaveChangesAsync();
var response = _mapper.Map <GetBookDetailsResponse>(book);
// 3. Return
// 201 Created
// Location Header (what is the name of the new book (name being the URI))
// Give them a copy of the thing.
return(CreatedAtRoute("books#getbookbyid", new { bookId = response.Id }, response));
}
}
public async Task <GetABookResponse> AddABook(PostBooksRequest bookToAdd)
{
// 1. Decide if it is worthy. (validate it) -- curently validation on controller
// If Not, send a 400 Bad Request
// 2. Add it the database.
// 3. Return:
// a 201 Created
// Location header with the URL of the newly created resource (like a birth announcment)
// Just attach a copy of whatever they would get by following the location header.
//var book = new Book
//{
// Title = bookToAdd.Title,
// Author = bookToAdd.Author,
// Genre = bookToAdd.Genre,
// InInventory = true,
// NumberOfPages = bookToAdd.NumberOfPages
//};
var book = Mapper.Map <Book>(bookToAdd);
Context.Books.Add(book);
await Context.SaveChangesAsync();
var response = Mapper.Map <GetABookResponse>(book);
return(response);
}
public async Task <ActionResult <GetBookDetailsResponse> > AddABook([FromBody] PostBookRequst request)
{
// 1 Validate it. If Not - return a 400 Bad Request, optionally with some info
// progamatic, imparative validation
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// 2. Save it in the database
// - Turn a PostBookRequest -> Book
var bookToSave = _mapper.Map <Book>(request);
// - Add it to the Context
_context.Books.Add(bookToSave);
// - Tell the context to save the changes.
await _context.SaveChangesAsync();
// - Turn that saved book into a GetBookDetailsResponse
var response = _mapper.Map <GetBookDetailsResponse>(bookToSave);
// 3. Return:
// - 201 Created Status Code
// - A location header with the Url of the newly created book.
// - A copy of the newly created book (what they would get if they followed the location)
return(CreatedAtRoute("books#getbookbyrid", new { id = response.Id }, response));
}
public async Task <IActionResult> AddABook([FromBody] PostBookRequest bookToAdd)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var book = new Book
{
Title = bookToAdd.Title,
Author = bookToAdd.Author,
Genre = bookToAdd.Genre ?? "Unknown"
};
Context.Books.Add(book);
await Context.SaveChangesAsync();
var bookToReturn = new GetBookResponseDocument
{
Id = book.Id,
Title = book.Title,
Author = book.Author,
Genre = book.Genre
};
return(CreatedAtRoute("books#getabook", new { id = book.Id }, bookToReturn));
}
public async Task <ActionResult <GetABookResponse> > AddABook([FromBody] PostBookRequest bookToAdd)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var book = new Book
{
Title = bookToAdd.Title,
Author = bookToAdd.Author,
Genre = bookToAdd.Genre,
InInventory = true,
NumberOfPages = bookToAdd.NumberOfPages
};
Context.Books.Add(book);
await Context.SaveChangesAsync();
var response = new GetABookResponse
{
Id = book.Id,
Title = book.Title,
Author = book.Author,
Genre = book.Genre,
NumberOfPages = book.NumberOfPages
};
return(CreatedAtRoute("books#getabook", new { id = book.Id }, response));
}
public async Task <GetBookDetailsResponse> AddBook(PostBookRequest bookToAdd)
{
var book = _mapper.Map <Book>(bookToAdd);
_context.Books.Add(book);
await _context.SaveChangesAsync();
var response = _mapper.Map <GetBookDetailsResponse>(book);
return(response);
}
public async Task <GetABookResponse> AddABook(PostBooksRequest bookToAdd)
{
var book = Mapper.Map <Book>(bookToAdd);
Context.Books.Add(book);
await Context.SaveChangesAsync();
var response = Mapper.Map <GetABookResponse>(book);
return(response);
}
public async Task <ActionResult> RemoveBookFromInventory(int bookId)
{
var book = await _context.Books.SingleOrDefaultAsync(b => b.Id == bookId && b.RemovedFromInventory == false);
if (book != null)
{
book.RemovedFromInventory = true;
await _context.SaveChangesAsync();
}
return(NoContent()); //Fine
}
public async Task <IActionResult> RemoveABook(int id)
{
var book = await Context.Books.Where(b => b.Id == id && b.InInventory).SingleOrDefaultAsync();
if (book != null)
{
book.InInventory = false;
await Context.SaveChangesAsync();
}
return(NoContent());
}
public async Task <ActionResult <Reservation> > AddReservation([FromBody] Reservation reservationToAdd)
{
var numberOfBooksInReservation = reservationToAdd.Books.Count(c => c == ',');
reservationToAdd.ReservationCreated = DateTime.Now;
reservationToAdd.Status = ReservationStatus.Processing;
Context.Reservations.Add(reservationToAdd);
await Context.SaveChangesAsync();
Queue.SendReservationForProcessing(reservationToAdd);
return(CreatedAtRoute("reservations#get", new { id = reservationToAdd.Id, }, reservationToAdd));
}
public async Task <IActionResult> UpdateTheGenre(int id, [FromBody] string newGenre)
{
var book = await GetBooksInInventory(_libContext).SingleOrDefaultAsync(b => b.Id == id);
if (book == null)
{
return(NotFound());
}
book.Genre = newGenre;
await _libContext.SaveChangesAsync();
return(NoContent());
}
public async Task <ActionResult> AddReservation([FromBody] PostReservationRequest reqest)
{
var reservation = _mapper.Map <Reservation>(reqest);
reservation.Status = ReservationStatus.Pending;
_context.Reservations.Add(reservation);
await _context.SaveChangesAsync();
var response = _mapper.Map <ReservationDetailsResponse>(reservation);
await _reservationLogger.WriteAsync(reservation);
return(CreatedAtRoute("reservations#getbyid", new { id = response.Id }, response));
}
public async Task <ActionResult> CreateReservationAsync([FromBody] PostReservationRequest request)
{
var reservation = _mapper.Map <Reservation>(request);
reservation.Status = ReservationStatus.Pending;
_context.Reservations.Add(reservation);
await _context.SaveChangesAsync();
await _reservationProcessor.ProcessReservation(reservation);
var response = _mapper.Map <GetReservationDetailsResponse>(reservation);
return(CreatedAtRoute("reservations#getareservation", new { id = response.Id }, response));
}
public async Task <ActionResult> UpdateTitle([FromRoute] int bookId, [FromBody] string title)
{
var book = await _context.BooksInInventory().SingleOrDefaultAsync(b => b.Id == bookId);
if (book == null)
{
return(NotFound());
}
else
{
book.Title = title;
await _context.SaveChangesAsync();
return(NoContent());
}
}
public async Task <bool> UpdateGenreFor(int id, string genre)
{
var book = await GetBooksInInventory().SingleOrDefaultAsync(b => b.Id == id);
if (book == null)
{
return(false);
}
else
{
book.Genre = genre;
await Context.SaveChangesAsync();
return(true);
}
}
public async Task <ActionResult> ReservationApproved([FromBody] GetReservationItemResponse req)
{
var reservation = await Context.Reservations.Where(r => r.Id == req.Id).SingleOrDefaultAsync();
if (reservation == null)
{
return(BadRequest("No pending reservation"));
}
else
{
reservation.Status = ReservationStatus.Approved;
await Context.SaveChangesAsync();
return(Accepted()); // NoContent()
}
}
public static void ReinitializeDb(LibraryDataContext db)
{
db.Books.RemoveRange(db.Books); // delete all the books.
var x = db.SaveChangesAsync().Result;
Initialize(db);
}
public async Task <IActionResult> UpdateMember([FromBody] AddMemberModel member)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var MemberUpdate = await appDbContext.Members.SingleOrDefaultAsync(s => s.MemberId == member.MemberId);
if (MemberUpdate != null)
{
MemberUpdate.FirstName = member.FirstName;
MemberUpdate.LastName = member.LastName;
MemberUpdate.JoiningDate = member.JoiningDate;
var ContactUpdate = await appDbContext.ContactDetails.SingleOrDefaultAsync(s => s.MemberId == member.MemberId);
if (ContactUpdate != null)
{
ContactUpdate.EmailAddress = member.EmailAddress;
ContactUpdate.MobileNo = member.MobileNo;
}
var AddressUpdate = await appDbContext.Addresses.SingleOrDefaultAsync(s => s.MemberId == member.MemberId);
if (AddressUpdate != null)
{
AddressUpdate.AddressLine = member.AddressLine;
AddressUpdate.CityName = member.CityName;
AddressUpdate.StateName = member.StateName;
}
}
await appDbContext.SaveChangesAsync();
return(new OkObjectResult("{}"));
}
public async Task <GetABookResponse> AddBook(PostBookCreate bookToAdd)
{
//var book = new Book
//{
// Title = bookToAdd.Title,
// Author = bookToAdd.Author,
// Genre = bookToAdd.Genre,
// NumberOfPages = bookToAdd.NumberOfPages,
// InStock = true
//};
var book = Mapper.Map <Book>(bookToAdd);
Context.Books.Add(book); // I have not Id!
await Context.SaveChangesAsync(); // Suddenly I have an Id!
// Book -> GetA BookResponse
//var response = new GetABookResponse
//{
// Id = book.Id,
// Title = book.Title,
// Author = book.Author,
// Genre = book.Genre,
// NumberOfPages = book.NumberOfPages
//};
var response = Mapper.Map <GetABookResponse>(book);
return(response);
}
public async Task <ActionResult> UpdateGenre(int id, [FromBody] string genre)
{
var storedBook = await _context.GetBooksInInventory().SingleOrDefaultAsync(b => b.Id == id);
if (storedBook != null)
{
storedBook.Genre = genre; // you need to validate it.
await _context.SaveChangesAsync();
return(NoContent());
}
else
{
return(NotFound());
}
}
public async Task <ActionResult> UpdateGenre(int id, [FromBody] string genre)
{
var book = await _context.AvailableBooks.SingleOrDefaultAsync(b => b.Id == id);
if (book != null)
{
book.Genre = genre; // One "Gotcha" - we aren't validating here.
await _context.SaveChangesAsync();
return(Accepted()); // 202 means "I did it", could also use "No Content"
}
else
{
return(NotFound());
}
}
public async Task <ActionResult <Reservation> > AddReservation([FromBody] Reservation reservationToAdd)
{
var numberOfBooksInReservation = reservationToAdd.Books.Count(c => c == ',');
//for(var t =0; t< numberOfBooksInReservation; t++)
//{
// await Task.Delay(1000); // take a second to process each book.
//}
reservationToAdd.ReservationCreated = DateTime.Now;
reservationToAdd.Status = ReservationStatus.Processing;
Context.Reservations.Add(reservationToAdd);
await Context.SaveChangesAsync();
Queue.SendReservationForProcessing(reservationToAdd);
return(CreatedAtRoute("reservations#get", new { id = reservationToAdd.Id, }, reservationToAdd));
}
public async Task <IActionResult> Post([FromBody] RegistrationViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = model.Email, Email = model.Email
};
var result = await userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(new BadRequestObjectResult(Errors.AddErrorsToModelState(result, ModelState)));
}
await appDbContext.Admins.AddAsync(
new Admin { IdentityId = user.Id, FirstName = model.FirstName, LastName = model.LastName });
await appDbContext.SaveChangesAsync();
return(new OkObjectResult("{}"));
}
public async Task <ActionResult> UpdateGenre(int id, [FromBody] string genre)
{
var book = await _context.AvailableBooks.SingleOrDefaultAsync(b => b.Id == id);
if (book != null)
{
book.Genre = genre; // Beware, we aren't validating here. You'd have to find another way to apply validation rules.
await _context.SaveChangesAsync();
return(Accepted());
}
else
{
return(NotFound());
}
}
public async Task <ActionResult> ApproveReservation([FromBody] GetReservationResponse request)
{
var savedReservation = await _context.Reservations
.SingleOrDefaultAsync(b => b.Id == request.Id);
if (savedReservation == null)
{
return(BadRequest("Could not find that reservation"));
}
else
{
savedReservation.Status = BookReservationStatus.Approved;
await _context.SaveChangesAsync();
return(Ok());
}
}
public async Task <ActionResult <GetBookDetailsResponse> > AddBook([FromBody] BookCreateRequest bookToAdd)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
else
{
var book = _mapper.Map <Book>(bookToAdd);
_context.Books.Add(book);
await _context.SaveChangesAsync();
var response = _mapper.Map <GetBookDetailsResponse>(book);
return(CreatedAtRoute("books#getbookbyid", new { bookId = response.Id }, response));
}
}
public async Task <GetABookResponse> AddABook(PostBooksRequest bookToAdd)
{
var book = new Book
{
Title = bookToAdd.Title,
Author = bookToAdd.Author,
Genre = bookToAdd.Genre,
InInventory = true,
NumberOfPages = bookToAdd.NumberOfPages
};
Context.Books.Add(book);
await Context.SaveChangesAsync();
var response = Mapper.Map <GetABookResponse>(book);
return(response);
}
public async Task <ActionResult> UpdateNumberOfPages(int id, [FromBody] int newPages)
{
var book = await GetBooksInInventory()
.Where(b => b.Id == id)
.SingleOrDefaultAsync();
if (book == null)
{
return(NotFound());
}
else
{
book.NumberOfPages = newPages;
await Context.SaveChangesAsync();
return(NoContent());
}
}