public async Task <IHttpActionResult> Post(CreateAuthorViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (var ctx = new NewsDbContext())
{
var author = new Author()
{
Name = model.Name
};
ctx.Authors.Add(author);
await ctx.SaveChangesAsync();
var data = new AuthorViewModel()
{
Id = author.Id,
Name = author.Name
};
return(Created(new Uri(Request.RequestUri + "api/authors" + data.Id), data));
}
}
public IActionResult Create(CreateAuthorViewModel authorVM)
{
if (!Admin.logged)
{
return(RedirectToAction("Login", "Admin", 0));
}
if (!ModelState.IsValid)
{
return(View(authorVM));
}
string cv = authorVM.Author.Image;
if (cv.Length > 1)
{
cv.Replace('\\', '/');
Console.WriteLine($"cover ===={cv}");
System.IO.File.Copy(cv, "C:/Users/Dagi/source/repos/LibraryManagement/wwwroot/images/" + "A" + authorVM.Author.AuthorId + ".jpg", true);
authorVM.Author.Image = "images/" + "A" + authorVM.Author.AuthorId + ".jpg";
}
_repository.Create(authorVM.Author);
if (!String.IsNullOrEmpty(authorVM.Referer))
{
return(Redirect(authorVM.Referer));
}
return(RedirectToAction("List"));
}
public ActionResult Create(CreateAuthorViewModel author)
{
var result = aAct.Add(author.Surname, author.Name, author.Patronymic, author.NickName, author.DateBirth, author.DateDeath);
ViewBag.Result = result;
return(View());
}
public IActionResult Create(CreateAuthorViewModel model)
{
AuthorDTO author = _mapper.Map <AuthorDTO>(model.Author);
NovelDTO novel = _mapper.Map <NovelDTO>(model.Novel);
_authorService.CreateAuthorAndNovel(author, novel);
return(View());
}
private Author OnPostCreateAuthor(CreateAuthorViewModel viewModel)
{
var author = this.mapper.Map <Author>(viewModel);
this.context.Authors.Add(author);
this.context.SaveChanges();
return(author);
}
public IActionResult Create()
{
var viewModel = new CreateAuthorViewModel {
Referer = Request.Headers["Referer"].ToString()
};
return(View(viewModel));
}
/// <summary>
/// CreateAsync
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public async Task CreateAsync(CreateAuthorViewModel model)
{
var author = new Entities.Author
{
Name = model.Name
};
await _context.Authors.AddAsync(author);
await _context.SaveChangesAsync();
}
public void Create(CreateAuthorViewModel authorViewModel)
{
var author = new Author()
{
Id = authorViewModel.Id,
Name = authorViewModel.Name
};
_authorRepository.Create(author);
}
public async Task <int> Create(CreateAuthorViewModel item)
{
var createdItem = Mapper.Map <CreateAuthorViewModel, Author>(item);
int createdItemId = await _authorRepository.Create(createdItem);
var books = Mapper.Map <ICollection <BookCreateAuthorViewModelItem>, List <Book> >(item.Books);
await _authorInBookRepository.AddBooksByAuthorId(createdItemId, books);
return(createdItemId);
}
public async Task <IActionResult> Create(CreateAuthorViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _authorService.CreateAsync(model);
return(RedirectToAction("GetAuthors"));
}
public IActionResult Create(CreateAuthorViewModel viewModel)
{
if (ModelState.IsValid)
{
var createdAuthor = OnPostCreateAuthor(viewModel);
return(RedirectToAction("Details", "Author", new { id = createdAuthor.Id }));
}
return(this.View(viewModel));
}
public ActionResult Create(CreateAuthorViewModel model)
{
Author author = new Author
{
Name = model.Name
};
authorRepository.Create(author);
return(RedirectToAction("Index"));
}
public CreateAuthorPage(LibraryContext context)
{
InitializeComponent();
Context = context;
CreateAuthorViewModel viewModel = new CreateAuthorViewModel(new AuthorRepository(Context));
Submit.Command = viewModel.CreateAuthorCommand;
DataContext = viewModel;
}
public void CreatePostAction_ModelError()
{
var mock = new Mock <IAuthorLogic>();
CreateAuthorViewModel author = new CreateAuthorViewModel();
AuthorController controller = new AuthorController(mock.Object);
controller.ModelState.AddModelError("Name", "Model have no name");
ViewResult result = controller.Create(author) as ViewResult;
Assert.IsNotNull(result);
}
public IActionResult CreateAuthor(Author author)
{
if (ModelState.IsValid)
{
authorRepository.Add(author);
return(RedirectToAction("DisplayAllAuthors"));
}
CreateAuthorViewModel viewModel = GetAuthorViewModel(new Author(), null);
return(View("Views/Admin/Author/CreateAuthor.cshtml", viewModel));
}
public IActionResult Create(CreateAuthorViewModel model)
{
if (ModelState.IsValid)
{
var author = model.ToEntity();
_unitOfWork.BookMetas.AddAuthor(author);
_unitOfWork.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult EditAuthor(int id)
{
Author currentAuthor = authorRepository.GetAuthor(id);
if (currentAuthor == null)
{
ViewBag.Object = "Author";
return(View("Views/Home/ObjectNotFound.cshtml", id));
}
CreateAuthorViewModel viewModel = GetAuthorViewModel(currentAuthor, currentAuthor.PersonId);
return(View("Views/Admin/Author/EditAuthor.cshtml", viewModel));
}
public IActionResult Create(CreateAuthorViewModel authorVM)
{
if (!ModelState.IsValid)
{
return(View(authorVM));
}
_authorRepository.Create(authorVM.Author);
if (!String.IsNullOrEmpty(authorVM.Referer))
{
return(Redirect(authorVM.Referer));
}
return(RedirectToAction("List"));
}
public ActionResult Create(CreateAuthorViewModel vm)
{
if (!ModelState.IsValid)
{
return(View(vm));
}
string [] allowedExtensions = new string[] { ".jpg", ".png", ".jpeg" };
string pic = Guid.NewGuid().ToString() + Path.GetFileName(vm.Image.FileName);
bool find = false;
foreach (string extension in allowedExtensions)
{
if (pic.Contains(extension))
{
find = true;
break;
}
}
if (!find)
{
ModelState.AddModelError("Errors", "არასწორი ფორმატი");
return(View(vm));
}
string path = Path.Combine(Server.MapPath("~/Content/uploads/"), pic);
vm.Image.SaveAs(path);
_context.Authors.Add(new Author
{
FirstName = vm.FirstName,
LastName = vm.LastName,
Email = vm.Email,
Image = pic,
BehanceLink = vm.BehanceLink,
GithubLink = vm.GithubLink,
LinkedinLink = vm.LinkedinLink,
DribbleLink = vm.DribbleLink
});
_context.SaveChanges();
return(RedirectToAction("Index", "Author"));
}
public async Task <IActionResult> Create([FromBody] CreateAuthorViewModel itemVM)
{
if (itemVM == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
int newItemId = await _service.Create(itemVM);
itemVM.Id = newItemId;
return(Ok(itemVM));
}
public IActionResult Create([FromBody] CreateAuthorViewModel author)
{
try
{
_authorService.Create(author);
return(Ok(author));
}
catch (BusinessLogicException exception)
{
return(BadRequest(exception.Message));
}
catch (Exception exception)
{
_logger.LogInformation(exception.Message);
return(StatusCode((int)HttpStatusCode.InternalServerError));
}
}
public ActionResult Create(CreateAuthorViewModel model)
{
var author = mapper.Map <CreateAuthorViewModel, Author>(model);
try
{
if (ModelState.IsValid)
{
if (authorLogic.Add(author))
{
return(RedirectToAction("Index"));
}
}
return(View(model));
}
catch
{
return(View(model));
}
}
public CreateAuthorViewModel GetAuthorViewModel(Author author, int?editPersonId)
{
var allPersons = personRepository.GetAllPersons();
List <int> usedPersonsIds = UsedPersonIds();
if (editPersonId != null)
{
usedPersonsIds.Remove((int)editPersonId);
}
List <Person> availablePersons = GetAvailablePersons(allPersons, usedPersonsIds);
CreateAuthorViewModel viewModel = new CreateAuthorViewModel
{
AllPersons = availablePersons,
Author = author
};
return(viewModel);
}
public IActionResult EditAuthor(Author author)
{
Author currentAuthor = authorRepository.GetAuthor(author.Id);
if (currentAuthor == null)
{
ViewBag.Object = "Author";
return(View("Views/Home/ObjectNotFound.cshtml", author.Id));
}
if (ModelState.IsValid)
{
authorRepository.Update(author);
return(RedirectToAction("DisplayAllAuthors"));
}
CreateAuthorViewModel viewModel = GetAuthorViewModel(currentAuthor, currentAuthor.PersonId);
return(View("Views/Admin/Author/EditAuthor.cshtml", viewModel));
}
public void OnGet()
{
Author = new CreateAuthorViewModel();
}
public ActionResult Create()
{
CreateAuthorViewModel vm = new CreateAuthorViewModel();
return(View(vm));
}
public IActionResult CreateAuthor()
{
CreateAuthorViewModel viewModel = GetAuthorViewModel(new Author(), null);
return(View("Views/Admin/Author/CreateAuthor.cshtml", viewModel));
}
public IActionResult Create([FromBody] CreateAuthorViewModel createAuthorViewModel)
{
_authorService.Insert(createAuthorViewModel);
return(Ok(createAuthorViewModel));
}
public static Author ToEntity(this CreateAuthorViewModel viewModel)
{
return(Mapper.Map <Author>(viewModel));
}
public void CreateAuthor(CreateAuthorViewModel createAuthorViewModel)
{
Author author = Mapper.Map <CreateAuthorViewModel, Author>(createAuthorViewModel);
_authorRepository.Create(author);
}
