public async Task <IActionResult> Create([FromBody] BookCreateModel book) { if (ModelState.IsValid) { BookResultModel response = await this.bookService.CreateBook(book.Name, book.Description, book.ImageUrl, book.Author, book.ReleaseDate, book.Categories); if (!response.Success) { FailedResponseModel badResponse = new FailedResponseModel() { Errors = response.Errors }; return(BadRequest(badResponse)); } BookSuccessResponseModel successResponse = new BookSuccessResponseModel() { Name = response.Name }; return(Ok(successResponse)); } return(BadRequest(new FailedResponseModel { Errors = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage)) })); }
public async Task <IActionResult> Create(BookCreateModel model) { if (ModelState.IsValid) { Book book = new Book { Caption = model.Caption, PublishedDate = model.PublishedDate, WriterBooks = new List <WriterBook>() }; foreach (var id in model.WriterIds) { book.WriterBooks.Add(new WriterBook { WriterId = id }); } _bookRepository.Add(book); return(RedirectToAction("Index")); } foreach (var w in _writerRepository.Get()) { model.Writers.Add(new SelectListItem { Value = w.Id.ToString(), Text = $"{w.LastName} {w.FirstName}" }); } return(View(model)); }
public async Task CreateAsync(BookCreateModel bookCreateModel, int[] storesId) { var book = new Book() { Name = bookCreateModel.Name, Author = bookCreateModel.AuthorId == 0 ? null : await _authorService.GetAsync(bookCreateModel.AuthorId), ISBN = bookCreateModel.ISBN, Price = bookCreateModel.Price, Description = bookCreateModel.Description }; if (bookCreateModel.Image != null) { if (bookCreateModel.Image.Length > 0) { book.Cover = ImageToByte(bookCreateModel.Image); } } await _context.AddAsync(book); //Сначало сохраняем, чтобы записать сущность в бд await _context.SaveChangesAsync(); // Передаем Id сущностей Store и создаем многосвязную таблицу Books - Stores (RelStoreBook) if (storesId.Length != 0) { var createdBook = await _context.Books .FirstOrDefaultAsync(x => x.Name == book.Name && x.Author == book.Author && x.ISBN == book.ISBN); await CreateOrUpdateBookStores(createdBook, storesId); await _context.SaveChangesAsync(); } }
public async Task <ActionResult> Create([FromBody] BookCreateModel model) { if (Request.Cookies.ContainsKey("role")) { var role = Request.Cookies["admin"]; if (role != "admin") { return(BadRequest("Error")); } } else { return(BadRequest("Error")); } try { using var service = _bookService; var result = await service.AddBook(model); return(Ok(result)); } catch (Exception e) { return(BadRequest($"Error {e}")); } }
public int Post(BookCreateModel model) { if (!ModelState.IsValid) { throw new Exception("Form is invalid."); } return(_bookService.AddBook(model, _userManager.GetUserId(User))); }
public IHttpActionResult Post(BookCreateModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var id = _bookStoreManager.Create(model); return(Created(Url.Content($"~/edit/{id}"), id)); }
public static ServiceBook CreateModelToServiceBook(this BookCreateModel bkm) { ServiceBook sb = new ServiceBook() { AgeCategory = bkm.AgeCategory, FirstPublication = bkm.PublishDate, Name = bkm.Name }; return(sb); }
public async Task <IActionResult> Post(BookCreateModel book) { var bookEntity = _mapper.Map <Book>(book); if (!_bookValidationService.IsBookBelongsToCategory(bookEntity)) { return(BadRequest($"Can not save book. Category by id {book.CategoryId} was not found.")); } await _bookService.Create(bookEntity); return(Ok()); }
public ActionResult EditBook(int id, BookCreateModel bookModel) { Book updatedBook = new Book(id, bookModel.Title, bookModel.Price, bookModel.Author); int retCode = _repository.UpdateBook(id, updatedBook); if (retCode != 0) // error { return(NotFound()); } return(NoContent()); }
public ActionResult <Book> AddBook(BookCreateModel bookModel) { Book inputBook = new Book(bookModel.Title, bookModel.Price, bookModel.Author); Book addedBook = _repository.AddBook(inputBook); if (addedBook == null) { return(StatusCode(500)); } return(CreatedAtAction("ListBooks", new { id = addedBook.Id }, addedBook)); }
public async Task <IActionResult> Create() { BookCreateModel book = new BookCreateModel(); foreach (var w in _writerRepository.Get()) { book.Writers.Add(new SelectListItem { Value = w.Id.ToString(), Text = $"{w.LastName} {w.FirstName}" }); } return(View(book)); }
public IHttpActionResult Post([FromBody] BookCreateModel bookModel) { if (!ModelState.IsValid) { return(BadRequest()); } var newBook = Mapper.Map <Book>(bookModel); var id = _bookRepository.Add(newBook); var location = new Uri(Request.RequestUri + "/" + id); return(Created(location, id)); }
public IActionResult Create() { var categories = this.categoryService.AllCategories().Select(x => x.Name).ToList(); var authors = this.authorService.AllAuthors().Select(x => x.Name).ToList(); var model = new BookCreateModel { Categories = categories, Authors = authors }; return(View(model)); }
public async Task AddBookAsync(BookCreateModel bookCreateModel) { string path = "/img/" + bookCreateModel.ImgFile.FileName; using (var fileStream = new FileStream(_appEnvironment.WebRootPath + path, FileMode.Create)) { await bookCreateModel.ImgFile.CopyToAsync(fileStream); } bookCreateModel.ImgPath = path; await _bookService.AddBookAsync(_mapper.Map <BookDTO>(bookCreateModel)); }
public async Task <IActionResult> Post([FromBody] BookCreateModel cm) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } cm.IPAddress = HttpContext.Connection.RemoteIpAddress.ToString(); var vm = await this.service.AddAsync(cm); return(Ok(vm)); }
public Book Update(long id, BookCreateModel model) { if (!ModelState.IsValid) { return(null); } var entity = _repository.Get(id); entity.Title = model.Title; entity.AuthorId = model.AuthorId; _repository.Update(entity); return(entity); }
public IHttpActionResult Post([FromUri] BookCreateModel book) { IHttpActionResult badRequest; if (!this.IsModelValid(ModelState, book, out badRequest)) { return(badRequest); } var bookEntity = Mapper.Map <Book>(book); Database <Book> .Create(bookEntity); var bookReadModel = Mapper.Map <BookReadModel>(bookEntity); return(CreatedAtRoute("DefaultApi", new { controller = "books", id = bookReadModel.Id }, bookReadModel)); }
public Book Post(BookCreateModel model) { if (!ModelState.IsValid) { return(null); } var entity = new Book { Title = model.Title, AuthorId = model.AuthorId, CreatedDate = DateTime.Now }; _repository.Insert(entity); return(entity); }
public void AddBook_BadArgument_Exception() { var bookCreateModel = new BookCreateModel { Name = "SomeBookName", BookUrl = "SomeBookUrl", ImageUrl = "SomeImageUrl", Description = "SomeBookDescription", Year = 2020, Authors = new List <string>(), Genres = new List <string>() }; _mockBookRepository.Setup(w => w.GetAll()).ReturnsAsync(_books); _mockBookRepository.Setup(w => w.Add(It.IsAny <Book>())).ReturnsAsync(_book); using var bookService = new BookService(_mockBookRepository.Object, _mapper); Assert.ThrowsAsync <CustomException>(() => bookService.AddBook(bookCreateModel)); }
public void AddBook_GoodArgument_Success() { var bookCreateModel = new BookCreateModel { Name = "SomeBookName1", BookUrl = "SomeBookUrl", ImageUrl = "SomeImageUrl", Description = "SomeBookDescription", Year = 2020, Authors = new List <string>(), Genres = new List <string>() }; _mockBookRepository.Setup(w => w.GetAll()).ReturnsAsync(_books); _mockBookRepository.Setup(w => w.Add(It.IsAny <Book>())).ReturnsAsync(_book); using var bookService = new BookService(_mockBookRepository.Object, _mapper); Assert.That(bookService.AddBook(bookCreateModel).Result, Is.TypeOf <string>()); }
public async Task <IActionResult> Create(BookCreateModel collection) { var errors = ModelState.Values.SelectMany(v => v.Errors); if (ModelState.IsValid) { await m_bookService.Create(collection); return(RedirectToAction(nameof(Index))); } else { ViewBag.PublishersList = await GetPublishersSelectList(); ViewBag.AuthorsList = await GetAuthorsSelectList(); return(View(collection)); } }
public ActionResult Create([FromBody] BookCreateModel model) { try { if (string.IsNullOrEmpty(model.Title) || string.IsNullOrEmpty(model.Author)) { var result = new ContentResult(); result.Content = "Invalid data."; return(result); } _bookService.Create(model.Title, model.Author); return(Redirect("/Home/index")); } catch { return(View()); } }
public int Create(BookCreateModel model) { var book = new DbBook(); book.ISBN = model.ISBN; book.Image = model.Image; book.Pages = model.Pages; book.PublishDate = model.PublishDate; book.Publisher = model.Publisher; book.Title = model.Title; var id = _bookRepository.Create(book); var author = new DbAuthor(); author.BookId = id; author.FirstName = model.AuthorFirstName; author.LastName = model.AuthorLastName; _authorRepository.Create(author); return(id); }
public ActionResult Create(BookCreateModel model) { try { if (ModelState.IsValid) { int userID = (int)Profile["ID"]; int id = Book.SaveBook(model, userID, Server); return RedirectToAction("Details", new {id = id}); } var bcm = Book.GetBookCreateModel(); model.AuthorList = bcm.AuthorList; model.GenreList = bcm.GenreList; model.TagList = bcm.TagList; return View(model); } catch (Exception ex) { logger.Error(ex); return View("Error"); } }
/// <summary> /// 예약 추가 /// </summary> /// <param name="cm"></param> /// <returns></returns> public async Task <BookViewModel> AddAsync(BookCreateModel cm) { try { cm.Id = Guid.NewGuid(); var em = Mapper.Map <Book>(cm); var ok = await base.AddAsync(em); if (ok) { IncreaseBookCache(em); return(await OrderAsync(em)); } } catch (Exception ex) { logger.LogError(ex, ex.Message, cm); throw; } return(null); }
public async Task <IActionResult> Create([Bind("Numberofpages,Genre,Booklanguage,Bookname,Plot,AuthorName")] BookCreateModel books) { if (ModelState.IsValid) { var maxId = 0; if (_context.Books.Count() == 0) { maxId = 0; } else { maxId = _context.Books.Max(x => x.Id); } var book = new Books(); book.Id = ++maxId; book.Numberofpages = books.Numberofpages; book.Genre = books.Genre; book.Booklanguage = books.Booklanguage; book.Bookname = books.Bookname; book.Plot = books.Plot; book.Numberofsamples = 0; _context.Add(book); await _context.SaveChangesAsync(); //dodadi red vo writtenby tabelata var author = _context.Authors.Where(x => x.Authorname == books.AuthorName).FirstOrDefault(); var row = new Writtenby(); row.Authorid = author.Id; row.Bookid = book.Id; _context.Add(row); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewBag.UserId = _httpContextAccessor.HttpContext.Request.Cookies["id"]; ViewBag.UserName = _httpContextAccessor.HttpContext.Request.Cookies["username"]; ViewBag.UserRole = _httpContextAccessor.HttpContext.Request.Cookies["userrole"]; return(View(books)); }
public async Task <string> AddBook(BookCreateModel bookCreateModel) { if (bookCreateModel == null || bookCreateModel.Name.IsNullOrEmpty() || bookCreateModel.Description.IsNullOrEmpty()) { throw new CustomException("Некоректные данные"); } var books = await _bookRepository.GetAll(); if (books == null) { throw new ServerException("Сервер вернул null"); } if (books.Any(w => string.Equals(w.Name, bookCreateModel.Name))) { throw new CustomException("Книга с таким именем уже есть"); } var result = await _bookRepository.Add(_mapper.Map <Book>(bookCreateModel)); if (result == null) { throw new ServerException("Сервер вернул null"); } return(result.Id); }
public async Task <IActionResult> Create([Bind("Title, Description, Image")] BookCreateModel bookCreateModel) { if (!ModelState.IsValid) { return(View(bookCreateModel)); } var value = Guid.NewGuid(); var path = Path.Combine(_env.WebRootPath, "Books/" + value); if (bookCreateModel.Image.Length > 0) { if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } using (var fileStream = new FileStream(Path.Combine(path, bookCreateModel.Image.FileName), FileMode.Create)) { await bookCreateModel.Image.CopyToAsync(fileStream); } } var absolutePath = "~/Books/" + value; _repository.CreateBook( Book.CreateBook( bookCreateModel.Title, bookCreateModel.Description, absolutePath, bookCreateModel.Image.FileName ) ); return(RedirectToAction(nameof(Index))); }
public static int SaveBook(BookCreateModel model, int userID, HttpServerUtilityBase server) { int id = manager.bookService.AddBook(model.CreateModelToServiceBook()); var book = manager.bookService.GetBookById(id); var authors = manager.authorService.GetAllAuthors().ToList(); //Adding authors foreach (var author in model.Authors?.Select(authorID => authors.FirstOrDefault(e => e.ID == authorID)).Where(e => e != null) ?? new List <ServiceAuthor>()) { manager.authorService.AddAuthorBook(author, book); } var genres = manager.listService.GetAllGenres().ToList(); //Adding genres foreach (var genre in model.Genres?.Select(genreID => genres.FirstOrDefault(e => e.ID == genreID)).Where(genre => genre != null) ?? new List <ServiceGenre>()) { manager.listService.AddBookGenre(book, genre); } var tags = manager.listService.GetAllTags().ToList(); //Adding tags foreach (var tag in model.Tags?.Select(tagID => tags.FirstOrDefault(e => e.ID == tagID)).Where(tag => tag != null) ?? new List <ServiceTag>()) { manager.listService.AddBookTag(book, tag); } //Adding files if (model.Files != null) { foreach (var file in model.Files) { if (file != null) { string filepath = File.SaveFile(server, file, "~/App_Data/Uploads/Files/"); manager.bookService.AddFile(book, new ServiceFile { BookID = id, Path = filepath, Format = Path.GetExtension(filepath) }); } } } if (model.Covers != null) { //Adding covers foreach (var cover in model.Covers) { if (cover != null) { string filepath = File.SaveFile(server, cover, "~/App_Data/Uploads/Covers/Books"); manager.bookService.AddCover(book, new ServiceCover { BookID = id, ImagePath = filepath }); } } } //Adding content if (model.Content != null) { manager.commentService.AddContent(new ServiceContent() { BookID = book.ID, Text = model.Content, UserID = userID }); } return(id); }
public ActionResult Create(BookCreateModel model, bool downloadable) { if (!this.ModelState.IsValid) { return(this.View(model)); } var userId = this.User.Identity.GetUserId(); var book = new Book { Title = model.Title, Description = model.Description, RequredMoney = model.RequredMoney }; if (model.File != null) { int idx = model.File.FileName.LastIndexOf('.'); if (idx == -1) { this.ModelState.AddModelError(string.Empty, "File must have an extention!"); return(this.View()); } var fileName = model.File.FileName.Substring(0, idx); var fileExtention = model.File.FileName.Substring(idx + 1); if (!Regex.IsMatch(fileExtention, ValidationConstants.FileExtentionRegex)) { this.ModelState.AddModelError(string.Empty, "File extention not supported!"); return(this.View()); } using (var memory = new MemoryStream()) { model.File.InputStream.CopyTo(memory); var content = memory.GetBuffer(); book.BookFile = new BookFile { Downloadable = downloadable, Content = content, Name = fileName, FileExtension = fileExtention }; } } var user = this.users.GetUser(this.User.Identity.GetUserId()); var creationResult = this.books.Create(book); this.users.BindBookAndUser(user.Id, creationResult.Id); this.TempData.Clear(); this.TempData[GlobalConstants.MessageNameSuccess] = "You've successfuly created a book!"; return(this.RedirectToAction("Details", new { id = creationResult.Id })); }