public async Task <IActionResult> Create([FromBody] CreateBookModel model)
{
model.Name = model.Name.ToLower();
if (await _dbContext.Books.AnyAsync(f => f.Name == model.Name))
{
return(BadRequest("duplicated name"));
}
await _dbContext.Books.AddAsync(new Infrastructure.Book()
{
Name = model.Name,
Code = model.Code,
SectionId = model.SectionId,
Note = model.Note,
AuthorName = model.AuthorName,
NamePrinting = model.NamePrinting,
Date = model.Date,
Path = model.Path,
Photos = model.Photos,
ShelfNumber = model.ShelfNumber
});
await _dbContext.SaveChangesAsync();
return(Ok("Book successfuly created"));
}
public ActionResult CreateBook(CreateBookModel createBookModel)
{
try
{
List <Genre> genres = createBookModel.CheckedGenreObjects.Where(genre => genre.Checked).Select(genre => context.Genres.First(g => g.Id == genre.Id)).ToList();
Book book = new Book
{
Author = createBookModel.Author,
PageCount = createBookModel.PageCount,
Year = createBookModel.Year,
CountryId = createBookModel.CountryId,
Description = createBookModel.Description,
Name = createBookModel.Name,
PurchaseUrl = createBookModel.PurchaseUrl,
Genres = genres
};
string fileName = Guid.NewGuid().ToString() + Path.GetExtension(createBookModel.File.FileName);
string path = Path.Combine(Server.MapPath("~/Content/BookImages"), fileName);
createBookModel.File.SaveAs(path);
book.ImageUrl = "../Content/BookImages/" + fileName;
context.Books.Add(book);
context.SaveChanges();
}
catch
{
}
return(RedirectToAction("Books"));
}
public IActionResult AddBook(
[Bind(nameof(CreateBookModel.Title),
nameof(CreateBookModel.imageFile),
nameof(CreateBookModel.Description),
nameof(CreateBookModel.Edition))] CreateBookModel model)
{
if (ModelState.IsValid)
{
try
{
model.Create();
model.Response = new ResponseModel("Book creation successful.", ResponseType.Success);
return(RedirectToAction("Index"));
}
catch (DuplicationException ex)
{
model.Response = new ResponseModel(ex.Message, ResponseType.Failure);
// error logger code
}
catch (Exception ex)
{
model.Response = new ResponseModel("Book creation failued.", ResponseType.Failure);
// error logger code
}
}
return(View(model));
}
public IActionResult AddBook(CreateBookModel model)
{
if (ModelState.IsValid)
{
_bookRepository.AddBook(model);
}
return(RedirectToAction("Index", "Home"));
}
/// <inheritdoc />
public async Task <Guid> Create(CreateBookModel model)
{
model.CreationDateTimeOffset = DateTimeOffset.Now;
var book = _mapper.Map <Book>(model);
_context.Books.Add(book);
await _context.SaveChangesAsync();
return(book.BookGuid);
}
public IActionResult Post([FromBody] CreateBookModel model)
{
var userId = this.GetAuthorizeUserId();
var book = TinyMapper.Map <Book>(model);
var bookId = this._bookRepository.AddBook(userId, book);
return(Created(string.Format("/api/books/{0}", book.Id), TinyMapper.Map <BookModel>(book)));
}
public async Task <IActionResult> Create(CreateBookModel book)
{
Book model = _mapper.Map <CreateBookModel, Book>(book);
Book dbObject = await _bookService.Create(model);
if (dbObject == null)
{
return(BadRequest());
}
return(Created("Created", _mapper.Map <Book, SuccessBookModel>(dbObject)));
}
public async Task <IActionResult> CreateBook(CreateBookModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var key = await _dataService.CreateBookAsync(model.Name);
return(RedirectToAction("Index", "Book", key));
}
public bool Create([FromBody] CreateBookModel model)
{
Context.BookRepos.Add(new BookRepo()
{
Name = model.Name,
Price = model.Price,
PublishDate = model.PublishDate,
Description = model.Description
});
return(Context.SaveChanges() > 0);
}
public Guid CreateBook(Guid authorId, CreateBookModel model)
{
var parent = _repository.Get(authorId);
var newBook = new Book
{
Genre = model.Genre,
Title = model.Title,
Summary = model.Summary,
};
parent.Books.Add(newBook);
return(newBook.Id);
}
public JsonResult Create(CreateBookModel model)
{
var book = model.ToDomain();
using (var bookRepo = new BookRepository())
{
bookRepo.Create(book);
}
return(new JsonResult {
Data = new { IsOk = true }
});
}
public IActionResult Create(CreateBookModel model) //post
{
this.ViewData["showError"] = "none";
if (!ModelState.IsValid)
{
this.ViewData["showError"] = "block";
this.ViewData["error"] = "write the correct data";
return(this.View());
}
this.books.Create(model.Title, model.Year, model.Author);
return(this.RedirectToAction(nameof(Create)));
}
public IActionResult Create([FromBody] CreateBookModel createBookModel)
{
if (this.ModelState.IsValid)
{
var result = this.bookService.CreateBook(createBookModel.Title, createBookModel.Description, createBookModel.Price, createBookModel.Copies, createBookModel.Edition, createBookModel.AgeRestriction, createBookModel.ReleaseDate, createBookModel.AuthorId, createBookModel.Categories);
if (result is null)
{
return(BadRequest());
}
return(Ok(result));
}
return(BadRequest(this.ModelState));
}
public void AddBook(CreateBookModel model)
{
Console.WriteLine(model.BookFile.FileName);
bool isWindows = System.Runtime.InteropServices.RuntimeInformation
.IsOSPlatform(OSPlatform.Windows);
string FilePath;
string PhotoPath;
string pathToWrite;
if (isWindows == true)
{
FilePath = "Books\\" + model.Name + ".pdf";
PhotoPath = "wwwroot\\images\\books\\" + model.Type + "\\" + model.Name + ".jpg";
pathToWrite = "../images/books/" + model.Type + "/" + model.Name + ".jpg";
}
else
{
FilePath = "Books/" + model.Name + ".pdf";
PhotoPath = "wwwroot/images/books/" + model.Type + "/" + model.Name + ".jpg";
pathToWrite = "../images/books/" + model.Type + "/" + model.Name + ".jpg";
}
if (model.BookFile.Length > 0)
{
using (var fileStream = new FileStream(FilePath, FileMode.Create))
{
model.BookFile.CopyTo(fileStream);
}
}
if (model.PhotoPath.Length > 0)
{
using (var fileStream = new FileStream(PhotoPath, FileMode.Create))
{
model.PhotoPath.CopyTo(fileStream);
}
}
Book book = Book.Create(model.Name, model.Type, model.Author, FilePath, pathToWrite, model.Description, DateTime.Now);
_databaseService.Books.Add(book);
_databaseService.SaveChanges();
}
public async Task <Response <Book> > Create(CreateBookModel bookViewModel)
{
var c1 = _clientFactory.CreateClient();
var a = await c1.GetDiscoveryDocumentAsync("https://localhost:44338/");
var tokenResponse = await c1.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
{
Address = a.TokenEndpoint,
ClientId = "my_client1_id",
ClientSecret = "my_client1_secret".ToSha256(),
Scope = "MyApi2"
});
var c2 = _clientFactory.CreateClient();
c2.SetBearerToken(tokenResponse.AccessToken);
c2.BaseAddress = new Uri(_apiBaseUrl);
//var ad = c2.PostAsync("books", new ReadOnlyMemoryContent())
return(null);
}
public ActionResult Index(CreateBookModel model)
{
if (ModelState.IsValid)
{
try
{
var result = Service.Create(new Booking()
{
CreatedOn = DateTime.Now,
Email = model.Email,
Name = model.Name,
NameOfSchool = model.NameOfSchool,
Telephone = model.Telephone,
What = model.What,
When = model.When,
YourLocation = model.YourLocation
});
if (result.Success)
{
model.BookingId = result.Entity.BookingId;
Dictionary <Func <CreateBookModel, string>, string> properties = new Dictionary <Func <CreateBookModel, string>, string>();
properties.Add((x) => x.BookingId.ToString(), "Id");
properties.Add((x) => x.Name, "Name");
properties.Add((x) => x.Email, "Email");
properties.Add((x) => x.Telephone, "Telephone");
properties.Add((x) => x.NameOfSchool, "Name Of School");
properties.Add((x) => x.YourLocation, "Location");
properties.Add((x) => x.When, "When they want it");
properties.Add((x) => x.What, "What they want");
var sb = new StringBuilder();
sb.AppendLine("Booking from Booking form is as follows:");
sb.AppendLine();
foreach (var item in properties)
{
sb.AppendFormat("{0} : {1}", item.Value, item.Key.Invoke(model));
sb.AppendLine();
sb.AppendLine();
}
var body = sb.ToString();
EmailHelper.SendBookingEmail(body);
return(RedirectToAction("BookingSuccess"));
}
else
{
if (result.Exception != null)
{
ModelState.AddModelError("Error:", "There was an error saving your booking details : " + result.Exception);
}
}
}
catch (Exception ex)
{
ModelState.AddModelError("Error:", "There was an error sending your booking details : " + ex.Message);
return(View(model));
}
}
return(View(model));
}
/// <inheritdoc />
public async Task ParsePiter()
{
var books = _piterParser.GetPiter();
#region Создание/Получение издательства
Guid publishingGuid = Guid.Empty;
CreatePublishingModel publishing = new CreatePublishingModel();
publishing.PublishingGuid = Guid.NewGuid();
publishing.Name = "Издательский дом 'Питер'";
publishing.City = "г. Санкт-Петербург";
publishing.Country = "Россия";
publishing.House = "дом № 29, литера А";
publishing.Postcode = 194044;
publishing.State = "Ленинградская обл.";
publishing.Street = "Большой Сампсониевский пр-кт";
var searchPublishing = await _publishingsService.Search(publishing.Name);
if (searchPublishing.Any())
{
var publishingModel = await _publishingsService.Read(searchPublishing.First().PublishingGuid);
publishingGuid = publishingModel.PublishingGuid;
}
else
{
publishingGuid = await _publishingsService.Create(publishing);
}
#endregion
foreach (var book in books)
{
try
{
CreateBookModel createBookModel = new CreateBookModel();
// Издательство и авторы
createBookModel.CreationDateTimeOffset = DateTimeOffset.Now;
createBookModel.PublishingGuid = publishingGuid;
createBookModel.AuthorGuid = new List <Guid>();
#region Создание/Добавление автора
foreach (var authorsName in book.AuthorsNames)
{
var fullname = authorsName.Split(' ');
CreateAuthorModel author = new CreateAuthorModel();
author.AuthorGuid = Guid.NewGuid();
author.Surname = fullname[0];
author.Name = fullname[1];
if (fullname.Length == 3)
{
author.Patronymic = fullname[2];
}
author.Note = "Автор книг: \"" + book.Title + "\"";
var searchAuthor = await _authorsService.Search(author.Surname);
if (searchAuthor.Any())
{
foreach (var item in searchAuthor)
{
UpdateAuthorModel updateAuthorModel = new UpdateAuthorModel();
updateAuthorModel.AuthorGuid = item.AuthorGuid;
updateAuthorModel.Name = item.Name;
updateAuthorModel.Surname = item.Surname;
updateAuthorModel.Patronymic = item.Patronymic;
if (!item.Note.Contains(book.Title))
{
updateAuthorModel.Note = item.Note + ", \"" + book.Title + "\"";
}
await _authorsService.Update(updateAuthorModel);
createBookModel.AuthorGuid.Add(item.AuthorGuid);
}
}
else
{
var guid = await _authorsService.Create(author);
createBookModel.AuthorGuid.Add(guid);
}
}
#endregion
#region Создание/Добавление сферы применения
// Сфера применения
CreateTechnologyModel technology = new CreateTechnologyModel();
technology.TechnologyGuid = Guid.NewGuid();
technology.Name = book.TechnologiesName;
technology.Description = "Серия книг: " + technology.Name;
technology.Language = "-";
var searchTechnologies = await _technologiesService.Search(technology.Name);
if (searchTechnologies.Any())
{
var technologyModel =
await _technologiesService.Read(searchTechnologies.First().TechnologyGuid);
createBookModel.TechnologyGuid = technologyModel.TechnologyGuid;
}
else
{
createBookModel.TechnologyGuid = await _technologiesService.Create(technology);
}
#endregion
createBookModel.BookGuid = Guid.NewGuid();
createBookModel.Title = book.Title;
createBookModel.Annotation = book.Annotation;
createBookModel.Cover = book.Cover;
try
{
createBookModel.NumberOfPages = Convert.ToInt32(book.NumberOfPages);
}
catch (Exception)
{
createBookModel.NumberOfPages = 0;
}
createBookModel.Format = book.Format;
createBookModel.Cost =
"Электронная книга: " + book.CostDigital + ";\nБумажная книга: " + book.CostPaper;
try
{
createBookModel.Year = Convert.ToInt32(book.Year);
}
catch (Exception)
{
createBookModel.Year = 2019;
}
createBookModel.BuyUri = book.BuyUri;
createBookModel.ImageUri = book.ImageUri;
var result = await _booksService.Create(createBookModel);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
}
public IActionResult Create(Guid authorId, [FromBody] CreateBookModel model)
{
var newlyCreated = BookService.CreateBook(authorId, model);
return(CreatedAtRoute("GetBook", new { authorId, bookid = newlyCreated }, newlyCreated));
}
public async Task <IActionResult> Post(CreateBookModel model)
{
await _bookService.InsertAsync(model);
return(Ok());
}
public IActionResult AddBook()
{
var model = new CreateBookModel();
return(View(model));
}
public async Task InsertAsync(CreateBookModel model)
{
var entity = _mapper.Map <Book>(model);
await _bookRepository.InsertAndSaveAsync(entity);
}
public IActionResult AddBook(CreateBookModel model)
{
model.Create();
return(View(model));
}
public async Task <IActionResult> CreateBook(CreateBookModel bookModel)
{
await _booksService.Create(bookModel);
return(RedirectToAction(nameof(ReadAll)));
}
