public IActionResult AddBook([FromForm] BookRequestModel bookRequestModel)
{
try
{
if (bookRequestModel.BookName == null || bookRequestModel.AuthorName == null || bookRequestModel.Description == null || bookRequestModel.Price == null)
{
throw new BookStoreException(BookStoreException.ExceptionType.NULL_FIELD_EXCEPTION, "Null Field");
}
else if (bookRequestModel.BookName == "" || bookRequestModel.AuthorName == "" || bookRequestModel.Description == "" || bookRequestModel.Price == "")
{
throw new BookStoreException(BookStoreException.ExceptionType.EMPTY_FIELD_EXCEPTION, "Empty Field");
}
// Call the Add Book Method of Book class
var response = this.bookBuiseness.AddBook(bookRequestModel);
// check if Id is not equal to zero
if (!response.BookId.Equals(0))
{
bool status = true;
var message = "Book Added Successfully";
return(this.Ok(new { status, message, data = response }));
}
else
{
bool status = false;
var message = "Failed to add";
return(this.BadRequest(new { status, message }));
}
}
catch (Exception e)
{
return(this.BadRequest(new { status = false, message = e.Message }));
}
}
public async Task <IActionResult> Post(BookRequestModel book)
{
bool authorExists = await this.authorService.Exists(book.AuthorId);
if (!authorExists)
{
return(this.BadRequest("Author does not exist"));
}
var bookInputModel = this.mapper.Map <BookInputServiceModel>(book);
if (book.Categories != null)
{
var categoryIds = new List <int>();
foreach (var categoryName in book.Categories)
{
var category = await this.categoryService.GetByName(categoryName);
if (category == null)
{
categoryIds.Add(await this.categoryService.Create(categoryName));
}
else
{
categoryIds.Add(category.Id);
}
}
bookInputModel.CategoryIds = categoryIds;
}
int bookId = await this.bookService.Create(bookInputModel);
return(this.Ok(bookId));
}
public IActionResult Post([FromBody] BookRequestModel book)
{
if (!ModelState.IsValid)
{
return(BadRequest("Fill out all the required fields!"));
}
Book newBook = new Book()
{
Name = book.Name,
Description = book.Description,
Year = book.Year,
PagesAmount = book.PagesAmount
};
if (book.AuthorsIds != null && book.AuthorsIds.Any())
{
foreach (var aid in book.AuthorsIds)
{
if (!libraryDBContext.Authors.Any(a => a.Id == aid))
{
return(NotFound($"Author with id '{aid}' wasn't found."));
}
newBook.BookAuthors.Add(new BookAuthor(newBook.Id, aid));
}
}
libraryDBContext.Books.Add(newBook);
libraryDBContext.Entry <Book>(newBook).State = EntityState.Added;
libraryDBContext.SaveChanges();
return(Ok());
}
public IActionResult Put(int id, [FromBody] BookRequestModel model)
{
if (!this.books.Exists(id))
{
return(this.BadRequest("Book does not exists!"));
}
bool successfullyUpdated = this.books.Update(
id,
model.Title,
model.Description,
model.Price,
model.Copies,
model.Edition,
model.AgeRestriction,
model.ReleaseDate,
model.AuthorId);
if (!successfullyUpdated)
{
return(this.BadRequest("Unsuccessful update!"));
}
return(this.Ok());
}
public BookRequest(BookRequestModel model)
{
client = Archive.Clients[model.client.card.id];
book = new Book(model.book);
id = model.id;
curId = BookRequestModel.curId;
}
public async Task <IActionResult> Put(int id, [FromBody] BookRequestModel model)
{
var bookExists = await this._books.Exists(id);
if (!bookExists)
{
return(this.BadRequest("The book does't exist"));
}
var authorExists = await this._authors.Exists(model.AuthorId);
if (!authorExists)
{
return(this.BadRequest("The book does't exist"));
}
int bookId = await this._books.Update(
id,
model.Title,
model.Description,
model.Price,
model.Copies,
model.Edition,
model.AgeRestriction,
model.ReleaseDate,
model.AuthorId);
return(this.Ok(bookId));
}
public async Task <LessonModel> PostAsync([FromBody] BookRequestModel model)
{
var userId = int.Parse(HttpContext.User.FindFirst(c => c.Type == ClaimTypes.Sid).Value);
var lesson = await _bookingService.AddLessonRequestAsync(model.OfferId, model.SlotIds, userId);
return(_mapper.Map <LessonModel>(lesson));
}
public BookResponse AddBook(BookRequestModel bookRequest)
{
try
{
var response = this.dbContext.BookDetails.FirstOrDefault(value => ((value.BookName == bookRequest.BookName)) && ((value.AuthorName == bookRequest.AuthorName)));
if (response != null)
{
response.Quantity = response.Quantity + bookRequest.Quantity;
this.dbContext.BookDetails.Update(response);
this.dbContext.SaveChanges();
return(Response(response));
}
else
{
string image = AddImage(bookRequest);
bookModel.BookName = bookRequest.BookName;
bookModel.AuthorName = bookRequest.AuthorName;
bookModel.Description = bookRequest.Description;
bookModel.Price = bookRequest.Price;
bookModel.Quantity = bookRequest.Quantity;
bookModel.CreatedDate = DateTime.Now;
bookModel.Image = image;
bookModel.IsDeleted = "No";
this.dbContext.BookDetails.Add(bookModel);
this.dbContext.SaveChanges();
return(Response(bookModel));
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public IActionResult UpdateBook([FromRoute] int Id, [FromForm] BookRequestModel updateBookModel)
{
try
{
if (updateBookModel.BookName == null || updateBookModel.AuthorName == null || updateBookModel.Description == null || updateBookModel.Price == null)
{
throw new BookStoreException(BookStoreException.ExceptionType.NULL_FIELD_EXCEPTION, "Null Variable Field");
}
else if (updateBookModel.BookName == "" || updateBookModel.AuthorName == "" || updateBookModel.Description == "" || updateBookModel.Price == "")
{
throw new BookStoreException(BookStoreException.ExceptionType.EMPTY_FIELD_EXCEPTION, "Empty Variable Field");
}
// Call the User Add Book Method of BookBL classs
var response = this.bookBuiseness.UpdateBook(Id, updateBookModel);
// check if Id is not equal to zero
if (!response.BookId.Equals(0))
{
bool status = true;
var message = "Book Updated Successfully";
return(this.Ok(new { status, message, data = response }));
}
else
{
bool status = false;
var message = "BookId Not Found";
return(this.NotFound(new { status, message }));
}
}
catch (Exception e)
{
return(this.BadRequest(new { status = false, message = e.Message }));
}
}
public async Task <IActionResult> Put(int id, [FromBody] BookRequestModel model)
{
var bookExists = await this.bookService.Exists(id);
if (!bookExists)
{
return(NotFound("Book does not exist."));
}
var authorExists = await this.authorService.Exists(model.AuthorId);
if (!authorExists)
{
return(BadRequest("Author does not exist."));
}
await this.bookService.Update(
id,
model.Title.Trim(),
model.Description.Trim(),
model.Price,
model.Copies,
model.Edition,
model.AgeRestriction,
model.ReleaseDate,
model.AuthorId);
return(Ok());
}
public IHttpActionResult Post(BookRequestModel book)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var author = this.authorsRepository
.All()
.FirstOrDefault(a => a.UserName == book.AuthorUsername);
if (author == null)
{
return(this.BadRequest("Author does not exist!"));
}
var newBook = new Book
{
Title = book.Title,
Description = book.Description,
Author = author
};
this.booksRepository.Add(newBook);
this.booksRepository.SaveChanges();
return(this.Created(string.Format("/Books/GetById/{0}", newBook.Id), Mapper.Map <BookResponseModel>(newBook)));
}
public BookResponse UpdateBook(int Id, BookRequestModel updateBookModel)
{
try
{
var response = this.dbContext.Books.FirstOrDefault(value => ((value.BookId == Id)) && ((value.IsDeleted == "No")));
if (response != null)
{
string image = AddImage(updateBookModel);
response.BookName = updateBookModel.BookName;
response.AuthorName = updateBookModel.AuthorName;
response.Description = updateBookModel.Description;
response.Price = updateBookModel.Price;
response.Quantity = updateBookModel.Quantity;
response.ModificationDate = DateTime.Now;
response.Image = image;
response.IsDeleted = "No";
this.dbContext.Books.Update(response);
this.dbContext.SaveChanges();
return(Response(response));
}
return(bookResponse);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public IHttpActionResult Post(BookRequestModel book)
{
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var author = this.authorsRepository
.All()
.FirstOrDefault(a => a.UserName == book.AuthorUsername);
if (author == null)
{
return this.BadRequest("Author does not exist!");
}
var newBook = new Book
{
Title = book.Title,
Description = book.Description,
Author = author
};
this.booksRepository.Add(newBook);
this.booksRepository.SaveChanges();
return this.Created(string.Format("/Books/GetById/{0}", newBook.Id), Mapper.Map<BookResponseModel>(newBook));
}
public async Task <IActionResult> AddBook([FromBody] BookRequestModel model)
{
var dbProvider = _dbBuilder.SetConnectionString(_dbConfiguration.ConnectionString)
.SetDatabase(_dbConfiguration.Database)
.SetCollection(_dbConfiguration.BooksCollection)
.Build();
var book = await dbProvider.FindRecordAsync <Book>("isbn", model.Isbn);
dbProvider.Collection = _dbConfiguration.UsersCollection;
var givenName = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.GivenName);
var user = await dbProvider.FindRecordAsync <User>("givenname", givenName.Value);
if (user == null)
{
// move to the fabric
var newUser = new User {
GivenName = givenName.Value, Books = new List <Book> {
book
}
};
await dbProvider.InsertAsync <User>(newUser);
}
else
{
var existingBook = user.Books.Contains(book);
if (!existingBook)
{
user.Books.Add(book);
await dbProvider.UpdateAsync <User>(user, "givenname", givenName.Value);
}
}
return(Ok());
}
public static Book toEntity(this BookRequestModel bookRequest)
{
return(new Book()
{
CategoryId = bookRequest.categoryId,
Title = bookRequest.title,
AuthorId = bookRequest.authorID,
BookId = bookRequest.bookId
});
}
public async Task <IActionResult> Put(int id, [FromBody] BookRequestModel book)
{
if (id < 0)
{
return(BadRequest($"'{nameof(id)}' have to be bigger than Zero!"));
}
Book bookToUpdate = await libraryDBContext.Books
.Include(a => a.BookAuthors)
.FirstOrDefaultAsync(a => a.Id == id);
if (bookToUpdate == null)
{
return(NotFound($"Book with id '{id}' doesn't exist!"));
}
bookToUpdate.Name = book.Name;
bookToUpdate.Description = book.Description;
bookToUpdate.PagesAmount = book.PagesAmount;
bookToUpdate.Year = book.Year;
if (book.AuthorsIds != null && book.AuthorsIds.Any())
{
foreach (var aid in book.AuthorsIds)
{
if (bookToUpdate.BookAuthors.Any(ba => ba.AuthorId == aid))
{
continue;
}
if (!libraryDBContext.Authors.Any(a => a.Id == aid))
{
return(NotFound($"Author with id '{aid}' donesn't exist."));
}
bookToUpdate.BookAuthors.Add(new BookAuthor(bookToUpdate.Id, aid));
}
bookToUpdate.BookAuthors = bookToUpdate.BookAuthors.Where(ba => book.AuthorsIds.Any(a => a == ba.AuthorId)).ToList();
}
else
{
bookToUpdate.BookAuthors = new List <BookAuthor>();
}
libraryDBContext.Books.Update(bookToUpdate);
libraryDBContext.Entry <Book>(bookToUpdate).State = EntityState.Modified;
libraryDBContext.SaveChanges();
return(Ok());
}
public static void AddRequest(BookRequestModel request)
{
using (var context = new librarydbEntities())
{
context.requests.Add(new request
{
book = context.books.Single(bk => bk.isbn == request.book.isbn),
client = context.clients.Single(cl => cl.clientId == request.client.card.id),
});
context.SaveChanges();
}
}
public BookResponse AddBook(BookRequestModel bookRequestModel)
{
try
{
// Call the AddBook Method of Books Repository Class
var response = this.bookRepository.AddBook(bookRequestModel);
return(response);
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
public IActionResult Update(BookRequestModel bookRequest)
{
Book book = _bookRepository.FindWithAuthor(a => a.BookId == bookRequest.bookId).FirstOrDefault();
if (book == null)
{
return(NotFound());
}
book.Title = bookRequest.title;
book.AuthorId = bookRequest.authorID;
book.CategoryId = bookRequest.categoryId;
_bookRepository.Update(book);
return(Ok());
}
public async Task <ActionResult> CreateABook([FromForm] BookRequestModel request)
{
var userId = User.Claims.Where(c => c.Type == "sub")
.Select(c => c.Value).SingleOrDefault();
Book aBook = new Book()
{
Title = request.Title,
Description = request.Description,
Price = request.Price,
Quantity = request.Quantity,
ApplicationUserId = userId,
CategoryId = request.CategoryId,
IsApproved = false
};
if (request.ImageUrl != null && request.ImageUrl.Length > 0)
{
var fileName = Path.GetFileName(request.ImageUrl.FileName);
var filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot\\images", fileName);
using (var fileSteam = new FileStream(filePath, FileMode.Create))
{
await request.ImageUrl.CopyToAsync(fileSteam);
}
aBook.ImageUrl = fileName;
}
await _context.Books.AddAsync(aBook);
if (await _context.SaveChangesAsync() > 0)
{
// var adminUser = _
BackgroundJob.Enqueue <ILoginService>(x => x.SendEMailAdmin());
var mybook = aBook;
return(Ok(new
{
aBook.Title,
aBook.ImageUrl,
aBook.BookId,
aBook.CategoryId,
aBook.Price,
aBook.ApplicationUserId,
}));
}
return(BadRequest());
}
private async Task <BookDetailsServiceModel> Update(int bookId, BookRequestModel model)
{
var book = await _appContext.Books.FindAsync(bookId);
book.AuthorId = model.AuthorId; // TODO: use automapper in here
book.Title = model.Title;
book.Description = model.Description;
book.Price = model.Price;
book.Copies = model.Copies;
book.Edition = model.Edition;
book.ReleaseDate = model.ReleaseDate;
book.AgeRestriction = model.AgeRestriction;
await _appContext.SaveChangesAsync();
return(Mapper.Map <BookDetailsServiceModel>(book));
}
public string AddImage(BookRequestModel requestModel)
{
Account account = new Account(
configuration["CloudinarySettings:CloudName"],
configuration["CloudinarySettings:ApiKey"],
configuration["CloudinarySettings:ApiSecret"]);
var path = requestModel.Image.OpenReadStream();
Cloudinary cloudinary = new Cloudinary(account);
var uploadParams = new ImageUploadParams()
{
File = new FileDescription(requestModel.Image.FileName, path)
};
var uploadResult = cloudinary.Upload(uploadParams);
return(uploadResult.Url.ToString());
}
public bool Add(BookRequestModel bookRequestModel)
{
bool result = false;
try
{
bookRequestModel.StatusID = (int)Enums.Status.pending_verification;
var bookRequest = Mapper.Map <BookRequestModel, BookRequest>(bookRequestModel);
bookRequest.CreateDate = DateTime.Now;
_unitOfWork.BookRequestRepository.Insert(bookRequest);
_unitOfWork.Save();
result = true;
}
catch
{
//Log Error Future Work
}
return(result);
}
public IActionResult Create([FromBody] BookRequestModel bookRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
// bookRequest.Authors = _bookRepository.GetAll();
}
if (_bookRepository.GetAll().Where(x => x.Title == bookRequest.title &&
x.AuthorId == bookRequest.authorID).Any())
{
return(Content("The Book Title is in Database Already!"));
}
else
{
_bookRepository.Create(bookRequest.toEntity());
return(Ok(bookRequest));
}
}
public async Task <BookResult> CreateBookAsync(BookRequestModel bookRequestModel)
{
var command = bookRequestModel.ToCommand();
var validationErrors = _commandRunner.Validate(command, null);
if (validationErrors.Any())
{
return(new BookResult {
ValidationErrors = validationErrors
});
}
var id = await _commandRunner.Execute(command, null);
var bookDto = await GetBookByIdAsync(id);
return(new BookResult {
BookDto = bookDto
});
}
public async Task <IActionResult> CreateBook([FromBody] BookRequestModel bookRequestModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
try
{
var result = await _bookService.CreateBookAsync(bookRequestModel);
if (result.HasErrors())
{
return(BadRequest(result.ValidationErrors));
}
return(CreatedAtAction(nameof(GetBookById), new { id = result.BookDto.BookId }, result.BookDto));
}
catch (ValidationException validationException)
{
return(StatusCode(500, validationException.Message));
}
}
public BookResponse AddBook(BookRequestModel createBookModel)
{
try
{
string image = AddImage(createBookModel);
bookModel.BookName = createBookModel.BookName;
bookModel.AuthorName = createBookModel.AuthorName;
bookModel.Description = createBookModel.Description;
bookModel.Price = createBookModel.Price;
bookModel.Quantity = createBookModel.Quantity;
bookModel.CreatedDate = DateTime.Now;
bookModel.Image = image;
bookModel.IsDeleted = "No";
this.dbContext.Books.Add(bookModel);
this.dbContext.SaveChanges();
return(Response(bookModel));
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public async Task <IActionResult> DeleteBook([FromBody] BookRequestModel model)
{
var dbProvider = _dbBuilder.SetConnectionString(_dbConfiguration.ConnectionString)
.SetDatabase(_dbConfiguration.Database)
.SetCollection(_dbConfiguration.BooksCollection)
.Build();
var book = await dbProvider.FindRecordAsync <Book>("isbn", model.Isbn);
dbProvider.Collection = _dbConfiguration.UsersCollection;
var givenName = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.GivenName);
var user = await dbProvider.FindRecordAsync <User>("givenname", givenName.Value);
if (user != null && book != null)
{
var existingBook = user.Books.Contains(book);
if (existingBook)
{
user.Books.Remove(book);
await dbProvider.UpdateAsync <User>(user, "givenname", givenName.Value);
}
}
return(Ok());
}
public async Task <Option <BookDetailsServiceModel, Error> > UpdateByModelAndId(int bookId, BookRequestModel model)
{
if (await Exists(bookId))
{
if (await _authorService.Exists(model.AuthorId))
{
return((await Update(bookId, model)).Some <BookDetailsServiceModel, Error>());
}
return(Option.None <BookDetailsServiceModel, Error>($"Author with ID:{model.AuthorId} does not exists!".ToError()));
}
return(Option.None <BookDetailsServiceModel, Error>($"Book with ID:{bookId} does not exists!".ToError()));
}
public async Task <IActionResult> Put(int id, [FromBody] BookRequestModel model) => (await _bookService.UpdateByModelAndId(id, model)) .Match(Ok, Error);
public static ArchiveModel LoadFromDb()
{
ArchiveModel model = new ArchiveModel();
using (var context = new librarydbEntities())
{
var authors = context.authors.ToList();
var books = context.books.ToList();
var clients = context.clients.ToList();
var offers = context.offers.ToList();
var requests = context.requests.ToList();
foreach (var book in books)
{
BookModel bm = BookModelFromEntity(book);
model.books.Add(bm.isbn, bm);
model.amounts[bm.isbn] = (int)book.amount;
}
foreach (var client in clients)
{
ClientModel cm = new ClientModel
{
birth_year = client.age,
balance = client.balance,
card = new ClientCardModel
{
completedOffers = client.offers.Where(off => off.status == "Completed").Select(off => off.id).ToList(),
pendingOffers = client.offers.Where(off => off.status == "Pending").Select(off => off.id).ToList(),
id = client.clientId,
requests = client.requests.Select(req => req.idRequests).ToList()
},
login = client.login,
password = client.password,
name = client.name,
sex = "male"
};
model.clients.Add(cm.card.id, cm);
}
foreach (var request in requests)
{
BookRequestModel br = new BookRequestModel
{
id = request.idRequests,
book = model.books[request.book.isbn],
client = model.clients[request.client_id]
};
model.requests.Add(br);
}
foreach (var offer in offers)
{
OfferModel off = new OfferModel
{
id = offer.id,
returnDate = Convert.ToDateTime(offer.deadline),
status = (OfferStatus)Enum.Parse(typeof(OfferStatus), offer.status),
book = model.books[offer.book.isbn],
client = model.clients[offer.client_id]
};
if (off.status == OfferStatus.Completed)
{
model.completedOffers.Add(off.id, off);
}
else if (off.status == OfferStatus.Pending)
{
model.pendingOffers.Add(off.id, off);
}
}
}
return(model);
}
