public async Task <ActionResult <Data.Models.Book> > UpdateBook(int bookId, Data.Models.BookForUpdate updatedBook)
{
try
{
Data.Entities.Book dbBook = await _repository.GetBookAsync(bookId);
if (dbBook == null)
{
return(NotFound());
}
_mapper.Map(updatedBook, dbBook);
if (await _repository.SaveChangesAsync())
{
Data.Models.Book savedBook = _mapper.Map <Data.Models.Book>(dbBook);
return(Ok(savedBook));
}
else
{
return(BadRequest("Failed to update."));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
}
}
public async Task <ActionResult <Data.Models.Book> > PatchBook(int bookId, JsonPatchDocument <Data.Models.BookForUpdate> patchDocument)
{
try
{
Data.Entities.Book dbBook = await _repository.GetBookAsync(bookId);
if (dbBook == null)
{
return(NotFound());
}
var updatedBook = _mapper.Map <Data.Models.BookForUpdate>(dbBook);
patchDocument.ApplyTo(updatedBook, ModelState);
_mapper.Map(updatedBook, dbBook);
if (await _repository.SaveChangesAsync())
{
Data.Models.Book savedBook = _mapper.Map <Data.Models.Book>(await _repository.GetBookAsync(bookId));
return(Ok(savedBook));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to save to database"));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Unable to patch book " + ex.Message));
}
}
public async Task <Data.Entities.Book> PostBook(Data.Entities.Book book)
{
_context.Books.Add(book);
await _context.SaveChangesAsync();
return(book);
}
public async Task <ActionResult <Data.Models.Book> > CreateNewBook(Data.Models.BookForCreate newBook)
{
Data.Entities.Book dbNewBook = null;
try
{
dbNewBook = _mapper.Map <Data.Entities.Book>(newBook);
}
catch (Exception ex)
{
return(BadRequest("Input is in invalid format: " + ex.Message));
}
if (dbNewBook == null)
{
return(BadRequest("Input is in invalid format"));
}
await _repository.AddAsync <Data.Entities.Book>(dbNewBook);
await _repository.SaveChangesAsync();
Data.Models.Book addedBook = _mapper.Map <Data.Models.Book>(dbNewBook);
var url = _linkgenerator.GetPathByAction(HttpContext, "GetBookByBookId", "Books", addedBook);
return(this.Created(url, addedBook));
}
public IActionResult AddOrEdit(AddOrEdit addOrEdit)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction("AddOrEdit"));
}
Data.Entities.Book book = addOrEdit.Id == null ? new Data.Entities.Book() : this.bookRepository.GetById((int)addOrEdit.Id);
this.CreateOrUpdateLocalizationsFor(book);
book.Year = addOrEdit.Year;
if (addOrEdit.Id == null)
{
this.bookRepository.Create(book);
}
else
{
this.bookRepository.Update(book);
}
this.storage.SaveChanges();
return(this.RedirectToAction("Index"));
}
public async Task <Data.Entities.Book> PutBook(int id, Data.Entities.Book book)
{
_context.Entry(book).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(book);
}
public async Task <Models.Book> PutBook(int id, Models.Book book)
{
Data.Entities.Book bookEnt = _mapper.Map <Data.Entities.Book>(book);
Data.Entities.Book bookReturn = await _bookRepository.PutBook(id, bookEnt);
return(_mapper.Map <Models.Book>(bookReturn));
}
public IActionResult SetBook([FromBody] Data.Dtos.BookDto bookDto)
{
var baseDatabase = Helper.JsonHelper.GetDatabase();
if (bookDto.Id == Guid.Empty)//yeni kayıt
{
var bookEntity = new Data.Entities.Book()
{
Name = bookDto.Name,
Id = Guid.NewGuid()
};
baseDatabase.Books.Add(bookEntity);
Helper.JsonHelper.SetDatabase(baseDatabase);
}
else//güncelleme
{
var bookEntity = baseDatabase.Books.SingleOrDefault(a => a.Id == bookDto.Id);
if (bookEntity != null)
{
bookEntity.Name = bookDto.Name;
Helper.JsonHelper.SetDatabase(baseDatabase);
}
}
return(new JsonResult(baseDatabase));
}
private static void CalifyBook(Data.Entities.Book book, int stars)
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
book.Stars = Convert.ToUInt16(stars);
_bookRepository.Update(book);
Electron.IpcMain.Send(mainWindow, "reload-screen");
}
public async Task <Models.Book> PostBook(Models.Book book)
{
Data.Entities.Book bookEnt = _mapper.Map <Data.Entities.Book>(book);
var result = await _bookRepository.PostBook(bookEnt);
Models.Book bookModel = _mapper.Map <Models.Book>(result);
return(bookModel);
}
private static void PopupContextMenu(Data.Entities.Book book)
{
var mainWindow = Electron.WindowManager.BrowserWindows.First();
var menu = new MenuItem[]
{
new MenuItem
{
Label = "Leer libro",
Click = async() => Electron.IpcMain.Send(mainWindow, "read-book", book.Path)
},
// new MenuItem { Type = MenuType.separator },
new MenuItem {
Label = "Eliminar libro de la biblioteca",
Type = MenuType.normal,
Click = async() => {
var result = await Electron.Dialog.ShowMessageBoxAsync(new MessageBoxOptions("¿Seguro que deseas eliminar el libro de tu biblioteca?") {
Type = MessageBoxType.question,
Buttons = new string[] { "Sí", "No" },
Title = "Eliminar libro de tu biblioteca"
});
if (result.Response == 1)
{
_bookRepository.Delete(book);
Electron.IpcMain.Send(mainWindow, "reload-screen");
}
}
},
new MenuItem {
Type = MenuType.submenu, Label = "Calificar", Submenu = new MenuItem[] {
new MenuItem {
Label = "1 estrella", Type = MenuType.checkbox, Checked = book.Stars == 1, Click = () => CalifyBook(book, 1)
},
new MenuItem {
Label = "2 estrellas", Type = MenuType.checkbox, Checked = book.Stars == 2, Click = () => CalifyBook(book, 2)
},
new MenuItem {
Label = "3 estrellas", Type = MenuType.checkbox, Checked = book.Stars == 3, Click = () => CalifyBook(book, 3)
},
new MenuItem {
Label = "4 estrellas", Type = MenuType.checkbox, Checked = book.Stars == 1, Click = () => CalifyBook(book, 4)
},
new MenuItem {
Label = "5 estrellas", Type = MenuType.checkbox, Checked = book.Stars == 5, Click = () => CalifyBook(book, 5)
}
}
}
};
Electron.Menu.SetContextMenu(mainWindow, menu);
Electron.Menu.ContextMenuPopup(mainWindow);
}
public async Task <int?> DeleteBook(string id)
{
Data.Entities.Book _book = await _context.Books.FirstOrDefaultAsync(x => x.Id.ToLower() == id.ToLower());
if (_book == null)
{
return(null);
}
_book.IsDeleted = true;
_book.UpdateDate = UnixTimeNow(DateTime.UtcNow);
var result = await _context.SaveChangesAsync();
return(result);
}
public async Task <IActionResult> DeleteBook(int bookId)
{
try
{
Data.Entities.Book dbBook = await _repository.GetBookAsync(bookId);
if (dbBook == null)
{
return(NotFound());
}
_repository.Delete <Data.Entities.Book>(dbBook);
await _repository.SaveChangesAsync();
return(NoContent());
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Database exception: " + ex.Message));
}
}
public IActionResult AddOrEdit(int?id)
{
AddOrEdit addOrEdit = new AddOrEdit();
if (id == null)
{
addOrEdit.NameLocalizations = this.CreateEmptyLocalizations();
addOrEdit.DescriptionLocalizations = this.CreateEmptyLocalizations();
addOrEdit.AuthorLocalizations = this.CreateEmptyLocalizations();
addOrEdit.Year = DateTime.Now.Year;
}
else
{
Data.Entities.Book book = this.bookRepository.GetById((int)id);
addOrEdit.NameLocalizations = this.CreateLocalizationsFor(book.Name);
addOrEdit.DescriptionLocalizations = this.CreateLocalizationsFor(book.Description);
addOrEdit.AuthorLocalizations = this.CreateLocalizationsFor(book.Author);
addOrEdit.Year = book.Year;
}
return(this.View(addOrEdit));
}
