public IActionResult Post([FromBody] AuthorRequestModel author)
{
if (!ModelState.IsValid)
{
return(BadRequest("Fill out all the required fields!"));
}
Author newAuthor = new Author()
{
FullName = author.FullName,
BirthDate = author.BirthDate
};
if (author.BooksIds != null && author.BooksIds.Any())
{
for (int i = 0; i < author.BooksIds.Length; i++)
{
if (!libraryDBContext.Authors.Any(a => a.Id == author.BooksIds[i]))
{
return(NotFound($"Book with id '{author.BooksIds[i]}' wasn't found."));
}
newAuthor.BookAuthors.Add(new BookAuthor(newAuthor.Id, author.BooksIds[i]));
}
}
libraryDBContext.Authors.Add(newAuthor);
libraryDBContext.Entry <Author>(newAuthor).State = EntityState.Added;
libraryDBContext.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel model)
{
var id = await this.authors
.CreateAsync(model.Firstname, model.Lastname);
return(Ok(id));
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel model)
{
var id = await this.authorService.Create(
model.FirstName.Trim(),
model.LastName.Trim());
return(Ok(id));
}
public async Task <AuthorResponseModel> FilterAsync(AuthorRequestModel authorRequestModel)
{
var authorRequestDataModel = AuthorRequestMapper.Map(authorRequestModel);
var authorResponseDataModel = await _authorRepository.FilterAsync(authorRequestDataModel);
var authorResponseModel = AuthorResponseMapper.Map(authorResponseDataModel);
return(authorResponseModel);
}
public IActionResult Authors(AuthorRequestModel author)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(this.ModelState));
}
//bii go w bazata
return(Ok());
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel model)
{
//if (!ModelState.IsValid)
//{
// return BadRequest(ModelState);
//}
var id = await this.authors.CreateAsync(model.FirstName, model.LastName);
return(Ok(id));
}
public async Task <IActionResult> Post(AuthorRequestModel model)
{
var id = await this.authorService.CreateAsync(model.FirstName, model.LastName);
if (id < 0)
{
return(this.BadRequest(WebConstants.AuthorNotCreatedMsg));
}
return(this.CreatedAtAction(nameof(Get), new { id }, model));
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var id = await this.authors.Create(model.FirstName, model.LatsName);
return(Ok(id));
}
public IHttpActionResult Create(AuthorRequestModel model)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var newAuthor = this.Mapper.Map <Author>(model);
this.authors.Add(newAuthor);
return(this.StatusCode(HttpStatusCode.Created));
}
public async Task <IActionResult> Put(int id, [FromBody] AuthorRequestModel author)
{
if (id < 0)
{
return(BadRequest($"'{nameof(id)}' have to be bigger than Zero!"));
}
Author authorToUpdate = await libraryDBContext.Authors
.Include(a => a.BookAuthors)
.FirstOrDefaultAsync(a => a.Id == id);
if (authorToUpdate == null)
{
return(NotFound($"Author with id '{id}' doesn't exist!"));
}
authorToUpdate.FullName = author.FullName;
authorToUpdate.BirthDate = author.BirthDate;
if (author.BooksIds != null && author.BooksIds.Any())
{
foreach (var bid in author.BooksIds)
{
if (authorToUpdate.BookAuthors.Any(ba => ba.BookId == bid))
{
continue;
}
if (!libraryDBContext.Books.Any(a => a.Id == bid))
{
return(NotFound($"Book with id '{bid}' wasn't found."));
}
authorToUpdate.BookAuthors.Add(new BookAuthor(bid, authorToUpdate.Id));
}
authorToUpdate.BookAuthors = authorToUpdate.BookAuthors.Where(ba => author.BooksIds.Any(b => b == ba.BookId)).ToList();
}
else
{
authorToUpdate.BookAuthors = new List <BookAuthor>();
}
libraryDBContext.Authors.Update(authorToUpdate);
libraryDBContext.Entry <Author>(authorToUpdate).State = EntityState.Modified;
libraryDBContext.SaveChanges();
return(Ok());
}
public IActionResult Update(AuthorRequestModel authorRequest)
{
Author author = _authorRepository.Find(a => a.AuthorId == authorRequest.AuthorID).FirstOrDefault();
if (author == null)
{
return(NotFound());
}
author.Name = authorRequest.AuthorName;
_authorRepository.Update(author);
return(Ok(author));
}
public async Task <AuthorDetailsServiceModel> Create(AuthorRequestModel model)
{
var author = new Author
{
FirstName = model.FirstName.Trim(),
LastName = model.LastName.Trim()
};
await _appContext.Authors.AddAsync(author);
await _appContext.SaveChangesAsync();
return(Mapper.Map <AuthorDetailsServiceModel>(author));
}
public static AuthorRequestDataModel Map(AuthorRequestModel filterModel)
{
if (filterModel is null)
{
return(new AuthorRequestDataModel());
}
var filter = new AuthorRequestDataModel
{
Paging = _pagingMapper.Map(filterModel.Paging),
SortPropertyName = filterModel.SortPropertyName,
SortType = filterModel.SortType
};
return(filter);
}
public async Task <AuthorResponseModel> GetAsync(AuthorRequestModel requestModel)
{
AuthorRequestParameters parameters = requestModel.MapToRequestParameters();
(List <AuthorWithNestedObjects> authors, int count) = await _authorRepository.GetWithParamsAsync(parameters);
List <AuthorModel> authorModels = authors.Select(item => new AuthorModel(item)).ToList();
AuthorResponseModel responseModel = new AuthorResponseModel
{
Count = count,
AuthorsList = authorModels
};
return(responseModel);
}
public IActionResult Create(AuthorRequestModel authorRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (_authorRepository.GetAll().Where(x => x.Name == authorRequest.AuthorName).Any())
{
return(Content("this author already exists on Database!"));
}
else
{
var author = new Author()
{
Name = authorRequest.AuthorName
};
_authorRepository.Create(author);
return(Ok(authorRequest));
}
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel author)
{
int id = await authorService.CreateAsync(author.FirstName, author.LastName);
return(Ok(id));
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel model)
{
return(Ok(await _authorService.Create(model)));
}
public async Task <IActionResult> GetFiltered([FromBody] AuthorRequestModel authorRequestModel)
{
var authorsResponse = await _authorService.FilterAsync(authorRequestModel);
return(Ok(authorsResponse));
}
public async Task <IActionResult> Post([FromBody] AuthorRequestModel model)
=>
Ok(await this.authors.Create(
model.FirstName,
model.LastName));
public IActionResult Post([FromBody] AuthorRequestModel model)
{
var author = this.authorService.CreateAuthor(model.FirstName, model.LastName);
return(Ok(author));
}
public IActionResult Post([FromBody] AuthorRequestModel model)
=> Ok(this.authors.Create(
model.FirstName,
model.LastName));
public async Task <AuthorResponseModel> GetAuthors([FromBody] AuthorRequestModel requestModel)
{
AuthorResponseModel responseModel = await _authorService.GetAsync(requestModel);
return(responseModel);
}
public async Task <IActionResult> Post(AuthorRequestModel author)
{
int id = await this.authorService.Create(author.FirstName, author.LastName);
return(this.Ok(id));
}
