public IActionResult BookInfo(int book_id, string type)
{
BookInfoContainerViewModel bookInfo = new BookInfoContainerViewModel
{
Type = type,
};
switch (type)
{
case "text":
TextBook textBook = db.TextBooks.Find(book_id);
if (textBook == null)
{
return(NotFound());
}
bookInfo.TextBook = textBook;
bookInfo.IsAccessible = User.IsInRole("admin") || UserHelper.GetUserSubscriptionType(User, db).Level >= textBook.SubscriptionType.Level;
break;
case "audio":
AudioBook audioBook = db.AudioBooks.Find(book_id);
if (audioBook == null)
{
return(NotFound());
}
bookInfo.AudioBook = audioBook;
bookInfo.IsAccessible = User.IsInRole("admin") || UserHelper.GetUserSubscriptionType(User, db).Level >= audioBook.SubscriptionType.Level;
break;
default: return(NotFound());
}
return(View(bookInfo));
}
public ActionResult AudioBookPost(LibraryItem libraryItem)
{
if (libraryItem == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Have to create the right class (audioBook here) so that the required fields are right.
var audioBook = new AudioBook {
};
if (TryUpdateModel(audioBook, "",
new string[] { "Title", "RunTimeMinutes" }))
{
try
{
libraryItem.IsBorrowable = true;
db.LibraryItem.Add(libraryItem);
db.SaveChanges();
return(RedirectToAction("Details", new { id = libraryItem.Id }));
}
catch (DataException /* dex */)
{
//Log the error (uncomment dex variable name and add a line here to write a log.
ModelState.AddModelError("", "Unable to save changes. Try again, and if the problem persists, see your system administrator.");
}
}
return(View(audioBook));
}
public static AudioBook GetUpdatedAudioBook(ApplicationContext db, AudioBookInputViewModel inputModel)
{
AudioBook book = db.AudioBooks.Find(inputModel.Id);
if (book == null)
{
return(null);
}
book.BookName = inputModel.BookName;
book.Author = inputModel.Author;
book.ReadingTime = inputModel.ReadingTime;
book.ContentFilePath = inputModel.ContentFilePath;
book.CoverFilePath = inputModel.CoverFilePath;
book.Description = inputModel.Description;
book.Genres.Clear();
ICollection <Genre> genres = GetGenresList(db, inputModel.GenresList);
foreach (Genre g in genres)
{
book.Genres.Add(g);
}
SubscriptionType type = db.SubscriptionTypes.FirstOrDefault(s => s.Name == inputModel.SubscriptionType);
if (type == null)
{
return(null);
}
book.SubscriptionType = type;
return(book);
}
public async Task <IActionResult> Edit(Guid id, [Bind("Id,Title,Subtitle,Summary")] AudioBook audioBook)
{
if (id != audioBook.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(audioBook);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AudioBookExists(audioBook.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(audioBook));
}
public static AudioBook GetNewAudioBook(ApplicationContext db, AudioBookInputViewModel inputModel)
{
AudioBook book = new AudioBook
{
BookName = inputModel.BookName,
Author = inputModel.Author,
ReadingTime = inputModel.ReadingTime,
ContentFilePath = inputModel.ContentFilePath,
CoverFilePath = inputModel.CoverFilePath,
Description = inputModel.Description
};
ICollection <Genre> genres = GetGenresList(db, inputModel.GenresList);
foreach (Genre g in genres)
{
book.Genres.Add(g);
}
SubscriptionType type = db.SubscriptionTypes.FirstOrDefault(s => s.Name == inputModel.SubscriptionType);
if (type == null)
{
return(null);
}
book.SubscriptionType = type;
return(book);
}
public ActionResult CreateBook(AudioBookDto audioBookDto)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
//var movie = new Movie
//{
// Name = movieDto.Name,
// GenreId = movieDto.GenreId,
// DateAdded = DateTime.Now,
// ReleaseDate = movieDto.ReleaseDate,
// NumberInStock = movieDto.NumberInStock
//};
var audioBook = new AudioBook();
audioBook = _mapper.Map(audioBookDto, audioBook);
audioBookDto.Id = audioBook.Id;
_context.AudioBooks.Add(audioBook);
_context.SaveChanges();
return(Ok(audioBookDto));
}
public ABKarticaControl(AudioBook ab, bool aa, int i)
{
index = i;
adminAccess = aa;
Book = ab;
Member user = mongoDB.GetCollection <Member>().FindOneById(Book.UpdatedBy.Id);
if (user == null)
{
user = mongoDB.GetCollection <Admin>().FindOneById(Book.UpdatedBy.Id);
}
InitializeComponent();
if (!adminAccess)
{
btnDelete.Visible = false;
}
llblName.Text = Book.Name;
lblAuthor.Text = Book.Author;
lblInfo.Text = "Posted: " + Book.DateUpdated.Date.ToString() + " by " + user.Name;
if (Book.Cover != null)
{
pbCover.Image = Book.getImg();
pbCover.SizeMode = PictureBoxSizeMode.StretchImage;
}
}
public void FlatDirectoryToAudioBook()
{
DirectoryScanner scanner = new DirectoryScanner();
List <AudioBook> audioBooks = scanner.ScanForBooks(ScanDirectory);
Assert.Equal(2, audioBooks.Count);
Assert.Contains(audioBooks, book => book.Files.Count == 2);
Assert.Contains(audioBooks, book => book.Files.Count == 3);
AudioBook aFrequency = audioBooks.Find(x => x.Files.Count == 2);
AudioBook lifeOfNoise = audioBooks.Find(x => x.Files.Count == 3);
Assert.Equal(1, aFrequency.Files[0].TrackNumber);
Assert.Equal("1 minute A", aFrequency.Files[0].Name);
Assert.Equal(2, aFrequency.Files[1].TrackNumber);
Assert.Equal("30 minute A", aFrequency.Files[1].Name);
Assert.Equal(1, lifeOfNoise.Files[0].TrackNumber);
Assert.Equal("Pink", lifeOfNoise.Files[0].Name);
Assert.Equal(2, lifeOfNoise.Files[1].TrackNumber);
Assert.Equal("Brown", lifeOfNoise.Files[1].Name);
Assert.Equal(3, lifeOfNoise.Files[2].TrackNumber);
Assert.Equal("White", lifeOfNoise.Files[2].Name);
}
public ActionResult Save(AudioBook audioBook)
{
// var movieInDb = _context.Movies.SingleOrDefault(m => m.Id == id);
if (!ModelState.IsValid)
{
var viewmodel = new AudioBookFormViewModel(audioBook);
return(View("BookForm", viewmodel));
}
if (audioBook.Id == 0)
{
_context.Books.Add(audioBook);
}
else
{
var booInDb = _context.Books.Single(c => c.Id == audioBook.Id);
booInDb.Name = audioBook.Name;
booInDb.Category = audioBook.Category;
booInDb.Description = audioBook.Description;
booInDb.Price = audioBook.Price;
}
_context.SaveChanges();
return(RedirectToAction("AdminList", "Books", new { page = 1 }));
}
public AudioBookFormViewModel(AudioBook audioBook)
{
Id = audioBook.Id;
Name = audioBook.Name;
Description = audioBook.Description;
Category = audioBook.Category;
Price = audioBook.Price;
}
public IActionResult DeleteAudioBook(int id)
{
AudioBook toDelete = db.AudioBooks.Find(id);
db.AudioBooks.Remove(toDelete);
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public ActionResult DeleteAudio(int idBook, int idAudioBook)
{
AudioBook audio = _audioBookService.GetAudioBookByID_Service(idBook, idAudioBook);
_audioBookService.Delete(audio);
//_audioBookService.Save();
System.IO.File.Delete(Server.MapPath(audio.FileAudioPath));
return(RedirectToAction("Index"));
}
public AudioBook Add(AudioBook audioBook)
{
audioBook.Id = Guid.NewGuid();
var audioBookReturnValue = _context.AudioBooks.Add(audioBook);
_context.SaveChanges();
return(audioBookReturnValue.Entity);
}
public async Task <int> CreateAudioBook(AudioBook model)
{
// todo: validate
//add to context
_context.AudioBooks.Add(model);
await _context.SaveChangesAsync();
return(model.Id);
}
public async Task <bool> UpdateAudioBook(AudioBook model)
{
// todo: validate
//add to context
var audiobook = _context.AudioBooks.FirstOrDefault(a => a.Id == model.Id);
_context.Entry(model).State = EntityState.Modified;
return(await _context.SaveChangesAsync() > 0);
}
static void AssertAudioBook(AudioBook audioBook, AudioBookOptions options)
{
AssertAudioItem(audioBook, options);
Assert.AreEqual(audioBook.StorageMedium, options.StorageMedium);
Assert.AreEqual(audioBook.Date, options.Date);
Assert.IsTrue(audioBook.Producers.IsReadOnly);
Assert.IsTrue(audioBook.Contributors.IsReadOnly);
CollectionAssert.AreEqual(audioBook.Producers, options.Producers);
CollectionAssert.AreEqual(audioBook.Contributors, options.Contributors);
}
public async Task <IActionResult> Create([Bind("Id,Title,Subtitle,Summary")] AudioBook audioBook)
{
if (ModelState.IsValid)
{
await _audioBookService.Add(audioBook);
return(RedirectToAction(nameof(Index)));
}
return(View(audioBook));
}
public async Task <AudioBook> Add(AudioBook audioBook)
{
audioBook.Id = Guid.NewGuid();
var audioBookReturnValue = _context.AudioBooks.Add(audioBook);
await _context.SaveChangesAsync();
return(audioBookReturnValue.Entity);
}
public void AudioBookInstantiation()
{
var options = new AudioBookOptions();
SetAudioBookOptions(options);
var audio_book = new AudioBook("-1", "-1", options);
AssertAudioBook(audio_book, options);
AssertAudioBook(audio_book, audio_book.GetOptions());
}
public IActionResult SaveAudioBookChanges(BookInputContainerViewModel bicvm)
{
AudioBook book = ModelConvertationHelper.GetUpdatedAudioBook(db, bicvm.AudioBookPresentation);
if (book == null)
{
return(View("~/Views/Shared/Error.cshtml"));
}
db.Entry(book).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index", "Home"));
}
public async Task Create_DataPassed_ViewWithInformationReturned()
{
var audioBook = new AudioBook();
var audioBooksService = new Mock<IAudioBookServiceAsync>();
audioBooksService.Setup(x => x.Add(It.IsAny<AudioBook>())).Returns(Task.FromResult(audioBook));
var controller = new AudioBookManualController(audioBooksService.Object);
var result = await controller.Create(audioBook);
Assert.IsType<RedirectToActionResult>(result);
}
public async Task Delete_NullCondition_NotFoundReturned()
{
var audioBook = new AudioBook();
var audioBooksService = new Mock<IAudioBookServiceAsync>();
audioBooksService.Setup(x => x.Delete(It.IsAny<Guid>())).Returns(Task.FromResult(audioBook));
var controller = new AudioBookManualController(audioBooksService.Object);
var result = await controller.Delete(null);
Assert.IsType<NotFoundResult>(result);
}
public AudioBook Update(Guid id, AudioBook audioBook)
{
if (!_context.AudioBooks.Any(x => x.Id == id))
{
throw new InvalidOperationException();
}
var audioBookReturnValue = _context.AudioBooks.Update(audioBook);
_context.SaveChanges();
return(audioBookReturnValue.Entity);
}
public ActionResult AudioBook(LibraryItem libraryItem)
{
/*if (libraryItem.Id == null)
* {
* return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
* }*/
var audioBook = new AudioBook {
};
//LibraryItem Item = db.LibraryItem.Find(libraryItem.Id);
return(View(audioBook));
}
public async Task <IActionResult> Create([Bind("Id,Title,Subtitle,Summary")] AudioBook audioBook)
{
if (ModelState.IsValid)
{
audioBook.Id = Guid.NewGuid();
_context.Add(audioBook);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(audioBook));
}
static void Main(string[] args)
{
Book b = new Book(14.99m, 5, "The Mafia Exchange", "Steve Berry", "FBDKSVBDSJKLFBD", 20);
Newspaper n = new Newspaper(3.99m, 1, "Der Standart", new DateTime(2020, 10, 20));
AudioBook a = new AudioBook(7.99m, 1, "Alea Aquarius 6: Der Fluss des Vergessens", "Tanya Stewner", "GKFLSGGHFDL", 536, 30);
Console.WriteLine(b.ToString());
Console.WriteLine(n.ToString());
Console.WriteLine(a.ToString());
Console.ReadKey();
}
//Update audio
public ActionResult GetAudiobyID(int idBook, int idAudioBook)
{
AudioBook audio = _audioBookService.GetAudioBookByID_Service(idBook, idAudioBook);
return(Json(new
{
BookID = audio.BookID,
AudioID = audio.AudioID,
AudioName = audio.AudioName,
Alias = audio.Alias,
UrlSave = audio.FileAudioPath
}, JsonRequestBehavior.AllowGet));
}
public async Task Create_ModelNotValid_ViewReturned()
{
var audioBook = new AudioBook();
var audioBooksService = new Mock<IAudioBookServiceAsync>();
audioBooksService.Setup(x => x.Add(It.IsAny<AudioBook>())).Returns(Task.FromResult(audioBook));
var controller = new AudioBookManualController(audioBooksService.Object);
controller.ModelState.AddModelError("Author", "Required");
var result = await controller.Create(audioBook);
Assert.IsType<ViewResult>(result);
}
void deleteBook(AudioBook book, int index)
{
book.Delete();
ABKarticaControl tmp;
panel1.Controls.RemoveAt(index);
for (int i = index + 1; i < panel1.Controls.Count; i++)
{
tmp = (ABKarticaControl)panel1.Controls[i];
tmp.Location = new Point(0, tmp.Location.Y - tmp.Height - space);
tmp.index = i - 1;
}
}
public AudioBookForm(AudioBook book, Member visitor)
{
InitializeComponent();
Book = book;
Visitor = visitor;
postedBy = mongoDB.GetCollection <Member>().FindOneById(Book.UpdatedBy.Id);
if (postedBy == null)
{
mongoDB.GetCollection <Admin>().FindOneById(Book.UpdatedBy.Id);
}
approvedBy = mongoDB.GetCollection <Admin>().FindOneById(Book.ApprovedBy.Id);
InitBookFields();
InitUserControls();
}
private string GetExternalAudioBookImageUri(AudioBook abook, bool fetchThumbnail)
{
var isbn = abook.Isbn;
var xmlBook = new BokbasenRepository(_documentRepository).GenerateBookFromXml(_xmluri + "&ISBN=" + isbn);
if (fetchThumbnail)
return !string.IsNullOrEmpty(xmlBook.Thumb_Cover_Picture) ? xmlBook.Thumb_Cover_Picture : string.Empty;
return !string.IsNullOrEmpty(xmlBook.Large_Cover_Picture) ? xmlBook.Large_Cover_Picture : string.Empty;
}
