public IActionResult Create(Author author)
{
if (ModelState.IsValid)
{
_authorService.Add(author);
return(RedirectToAction(nameof(Index)));
}
return(View(author));
}
public (bool sucess, Guid id) Add(AuthorInputDto obj)
{
try
{
var author = _mapper.Map <AuthorInputDto, Author>(obj);
_authorService.Add(author);
return(unitOfWork.Commit(), author.Id);
}
catch (Exception)
{
throw;
}
}
public IActionResult Add(ArticleViewModel article)
{
try
{
_articleService.Add(article.Article);
var lastArticle = _articleService.GetLastArticle();
foreach (var item in article.Section)
{
var newSec = new Section
{
ArticleId = lastArticle.ArticleId,
Title = item.Title,
Description = item.Description
};
_sectionService.Add(newSec);
}
foreach (var item in article.Author)
{
var newAuthor = new Author
{
ArticleId = lastArticle.ArticleId,
FirstName = item.FirstName,
LastName = item.LastName
};
_authorService.Add(newAuthor);
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
return(Ok());
}
public async Task <ActionResult> AddAsync(Author author)
{
if (ModelState.IsValid)
{
var user = _userService.Find(author.UserId);
if (author.IsActive)
{
var result = await _userService.AddRoleToUserAsync(user, "Author");
if (!result.Succeeded)
{
return(RedirectToAction("Add"));
}
}
_authorService.Add(author);
return(RedirectToAction("Manage"));
}
var users = _userService.GetAll().Where(s => s.Author == null).ToList();
ViewBag.usersList = _userService.GetUserIdNamesList(users);
return(View(author));
}
public IActionResult AddAuthor(AddAuthorViewModel model)
{
if (ModelState.IsValid)
{
if (model == null)
{
return(RedirectToAction("Error"));
}
AuthorDTO newAuthor = new AuthorDTO
{
Name = model.Name.Trim(),
Description = model.Description,
Surname = model.Surname.Trim()
};
if (model.Image != null)
{
byte[] imageData = null;
using (var binaryReader = new BinaryReader(model.Image.OpenReadStream()))
{
imageData = binaryReader.ReadBytes((int)model.Image.Length);
}
newAuthor.Image = imageData;
}
else
{
return(RedirectToAction("Error"));
}
_authorService.Add(newAuthor);
}
return(RedirectToAction("AuthorsList"));
}
private void btnAuthorSave_Click(object sender, EventArgs e)
{
try
{
var id = ((Author)cmbAuthors.SelectedItem).Id;
if (id < 0)
{
_authorService.Add(new Author()
{
FullName = txtFirstName.Text
});
MessageBox.Show(@"Author added!");
}
else
{
_authorService.Update(new Author()
{
Id = id, FullName = txtFirstName.Text
});
MessageBox.Show(@"Author updated!");
}
FillAuthorComboBox();
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
}
}
public IHttpActionResult Add([FromBody] AuthorApiModel authorApiModel)
{
var authorModel = _mapper.Map <AuthorModel>(authorApiModel);
_authorService.Add(authorModel);
return(Ok());
}
public IActionResult Add(int id, int?authorId)
{
var author = _authorService.GetAuthor(id);
_authorService.Add(author);
return(RedirectToAction("List", new { authorId = authorId }));
}
public IActionResult CreateAuthor([FromBody] CreateAuthorRequest request)
{
Author author = new Author();
author.Name = request.Name;
author.IsActive = true;
_authorService.Add(author);
return(Ok());
}
public IActionResult addAuthor([FromBody] AuthorInsertDTO authorDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_authorService.Add(authorDTO);
return(Ok());
}
public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,Address")] AuthorModel author)
{
if (ModelState.IsValid)
{
await _context.Add(author);
return(RedirectToAction(nameof(Index)));
}
return(View(author));
}
private void btnNewauthor_Click(object sender, EventArgs e)
{
_authorService.Add(new Author
{
AuthorName = txtAname.Text,
AuthorSurname = txtAsurname.Text
});
MessageBox.Show("Added!");
loadAuthors();
}
public IActionResult Add(Author book)
{
var result = _authorService.Add(book);
if (result.Success)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult Add(Author author)
{
var result = _authorService.Add(author);
if (result.Success)
{
return(Ok());
}
return(BadRequest(result.Message));
}
public async Task <IActionResult> Create([Bind("Id,Name")] Author author)
{
if (ModelState.IsValid)
{
await _authorService.Add(author);
return(RedirectToAction(nameof(Index)));
}
return(View(author));
}
public JsonResult CreateAuthorAJAX(Author author)
{
if (author != null)
{
if (!string.IsNullOrEmpty(author.Name))
{
_authorService.Add(author);
return(Json(new { data = author }));
}
else
{
return(Json(new { data = "" }));
}
}
else
{
return(Json(new { data = "" }));
}
}
public IActionResult Post([FromBody] Author myNewAuthor)
{
var author = _authorService.Add(myNewAuthor);
if (author == null)
{
return(BadRequest());
}
return(CreatedAtAction("Get", new { Id = myNewAuthor.Id }, myNewAuthor));
}
public IActionResult Post([FromBody] AuthorModel newAuthor)
{
var author = _authorService.Add(newAuthor.ToDomainModel());
if (author == null)
{
return(BadRequest());
}
return(CreatedAtAction("Get", new { newAuthor.Id }, newAuthor));
}
public ActionResult Create(AuthorViewModel model)
{
if (ModelState.IsValid)
{
var authorModel = _mapper.Map <AuthorModel>(model);
_authorService.Add(authorModel);
return(RedirectToAction("Index"));
}
return(View());
}
public IActionResult Post([FromBody] JsonElement json)
{
var author = JsonSerializer.Deserialize <Author>(json.ToString());
var response = _authorService.Add(author);
if (response == 0)
{
return(NoContent());
}
return(Ok(response));
}
public void Post([FromBody] AuthorViewModel value)
{
AuthorDTO author = new AuthorDTO()
{
AuthorId = value.AuthorId,
Name = value.Name,
Surname = value.Surname
};
authorService.Add(author);
}
public void AddAuthor()
{
Author author = new Author();
author.AuthorName = txtAuthorName.Text;
author.BirthDate = dpAuthorBirthDay.Value;
author.Biography = rtxtAuthorBiography.Text;
_authorManager.Add(author);
MessageBox.Show(AuthorMessage.AddMessage());
}
public IActionResult Add(Author author)
{
try
{
return(Ok(_authorService.Add(author)));
}
catch (Exception)
{
return(BadRequest("Yazar eklenemedi"));
}
}
public async Task <ActionResult <ApiResponse> > Post([FromBody] AuthorDto entity)
{
var createdAuthor = await authorService.Add(mapper.Map <Author>(entity));
if (createdAuthor)
{
await cacheService.RemoveAsync(CacheConstants.AuthorList);
}
return(new ApiResponse("New author added.", createdAuthor));
}
public IActionResult Post([FromBody] Author author)
{
try
{
return(Ok(_authorService.Add(author).ToApiModel()));
}
catch (Exception ex)
{
ModelState.AddModelError("AddAuthor", ex.Message);
return(BadRequest(ModelState));
}
}
public ActionResult Post([FromBody] Author author)
{
try
{
AuthorServices.Add(author);
}
catch (System.Exception ex)
{
ModelState.AddModelError("addAuthor", ex.Message);
return(BadRequest(ModelState));
}
return(CreatedAtAction("Get", new { Id = author.Id }, author));
}
public IActionResult Post([FromBody] Author author)
{
try
{
_authorService.Add(author);
}
catch (Exception e)
{
ModelState.AddModelError("AddAuthor", e.Message);
return(BadRequest(ModelState));
}
return(CreatedAtAction("Post", new { Id = author.Id }, author));
}
public IActionResult Create([Bind("ID,FirstName,LastName")] Author author)
{
if (!ModelState.IsValid)
{
TempData["Fail"] = "Fail";
return(View(author));
}
if (ModelState.IsValid)
{
_authorService.Add(author);
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public IActionResult Post([FromBody] AuthorModel newAuthor)
{
try
{
_AuthorService.Add(newAuthor.ToDomainModel());
}
catch (System.Exception ex)
{
ModelState.AddModelError("AddAuthor", ex.GetBaseException().Message);
return(BadRequest(ModelState));
}
return(CreatedAtAction("Get", new { id = newAuthor.Id }, newAuthor));
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
var update = (Update)context.ActionArguments["update"];
_currentChatService.SetFromUpdate(update);
var currentAuthorId = _guidConverter.Convert(_currentChatService.CurrentChatId.Identifier);
_currentAuthorService.CurrentAuthorId = currentAuthorId; // For now, be careful with order. Whole application assumes that this value initialized.
if (!await _authorService.Exists(currentAuthorId))
{
await _authorService.Add(currentAuthorId);
}
await next();
}