public async Task BuscarEditoraPorId_DeveRetornarComSucesso()
{
var newId = Guid.NewGuid();
var mapper = new Mock <IMapper>();
var notificador = new Notificador();
var editora = new Domain.Entities.Editora(newId, "Editora Fake", "*****@*****.**", "Brasil");
var editoraViewModel = new EditoraViewModel
{
Id = editora.Id,
Nome = editora.Nome,
Email = editora.Email,
Pais = editora.Pais
};
var query = new Mock <IEditoraRepository>();
query.Setup(x => x.BuscarEditoraPorId(It.IsAny <Guid>()))
.ReturnsAsync(editora);
mapper.Setup(x => x.Map <EditoraViewModel>(It.IsAny <Domain.Entities.Editora>()))
.Returns(editoraViewModel);
var useCase = new BuscarEditoraPorIdUseCase(query.Object, notificador, mapper.Object);
var resultado = await useCase.Executar(newId);
resultado.Should().Be(editoraViewModel);
}
public ActionResult Cadastrar()
{
var viewModel = new EditoraViewModel();
viewModel.Editoras = _unit.EditoraRepository.Listar();
return(View(viewModel));
}
public ActionResult EditarEditora(int id)
{
IRepositorio repositorio = new Repositorio.Repositorio();
ActionResult action = ValidarLogin(HttpContext);
if (action != null)
{
return(action);
}
if (id == 0)
{
ViewBag.Adicionar = true;
return(View());
}
Editora editora = repositorio.SelecionarEditoraPorId(id);
EditoraViewModel model = new EditoraViewModel()
{
IdEditora = editora.IdEditora,
Nome = editora.Nome
};
ViewBag.Adicionar = false;
return(View(model));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome,DataCadastro,Status")] EditoraViewModel editoraViewModel)
{
if (id != editoraViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(editoraViewModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EditoraViewModelExists(editoraViewModel.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(editoraViewModel));
}
public EditoraViewModel Atualizar(EditoraViewModel editora)
{
var index = editoras.FindIndex(e => e.IdEditora == editora.IdEditora);
editoras[index] = editora;
return(editora);
}
public EditoraViewModel Atualizar(EditoraViewModel editora)
{
var model = _mapper.Map <EditoraViewModel, Editora>(editora);
model = _repository.Atualizar(model);
_repository.SaveChanges();
return(_mapper.Map <Editora, EditoraViewModel>(model));
}
public EditoraViewModel Novo(EditoraViewModel auto)
{
var model = _mapper.Map <EditoraViewModel, Editora>(auto);
model = _repository.Novo(model);
_repository.SaveChanges();
return(_mapper.Map <Editora, EditoraViewModel>(model));
}
public ActionResult Edit(int id, EditoraViewModel editoraViewModel)
{
editoraViewModel.EditoraId = id;
var editoraEntidade = Mapper.Map <EditoraViewModel, Editora>(editoraViewModel);
_editoraAppServico.Atualizar(editoraEntidade);
return(RedirectToAction("Index"));
}
public ActionResult Delete(int id, EditoraViewModel editora)
{
if (ModelState.IsValid)
{
var _editoraDomain = Mapper.Map <EditoraViewModel, Editora>(editora);
_editoraAppService.Remove(_editoraDomain);
return(RedirectToAction("Index"));
}
return(View(editora));
}
public ActionResult Create(EditoraViewModel editora)
{
if (ModelState.IsValid)
{
var _editora = Mapper.Map <EditoraViewModel, Editora>(editora);
_editoraAppService.Add(_editora);
return(RedirectToAction("Index"));
}
return(View(editora));
}
public ActionResult Delete(int id, EditoraViewModel editoraViewModel)
{
var editoraEntidade = _editoraApp.ObterPorId(id);
if (_editoraApp.Remover(editoraEntidade))
{
return(RedirectToAction("Index"));
}
return(RedirectToAction("Index", "Erro", new { msg = "Editora não pode ser excluída pois existe livro vinculado." }));
}
public async Task <IActionResult> Create([Bind("Id,Nome,DataCadastro,Status")] EditoraViewModel editoraViewModel)
{
if (ModelState.IsValid)
{
_context.Add(editoraViewModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(editoraViewModel));
}
public ActionResult Edit(int id, EditoraViewModel editoraViewModel)
{
if (ModelState.IsValid)
{
var editoraEntidade = Mapper.Map <EditoraViewModel, Editora>(editoraViewModel);
_editoraApp.Atualizar(editoraEntidade);
return(RedirectToAction("Index"));
}
return(View(editoraViewModel));
}
public ActionResult Create(EditoraViewModel editoraViewModel)
{
if (ModelState.IsValid)
{
var editoraEntidade = Mapper.Map <EditoraViewModel, Editora>(editoraViewModel);
_editoraAppServico.Adicionar(editoraEntidade);
return(RedirectToAction("Index"));
}
return(View(editoraViewModel));
}
public void Mapeamento_DeveMapear_Editora_ParaEditoraViewModel()
{
var editora = new Editora(Guid.NewGuid(), "Editora", "*****@*****.**", "Brasil");
var esperado = new EditoraViewModel
{
Id = editora.Id,
Nome = editora.Nome,
Email = editora.Email,
Pais = editora.Pais
};
var resultado = _mapper.Map <EditoraViewModel>(editora);
resultado.Should().BeEquivalentTo(esperado);
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
user.Claims.Add(new IdentityUserClaim <string> {
ClaimType = "Produtos", ClaimValue = "Ler"
});
user.Claims.Add(new IdentityUserClaim <string> {
ClaimType = "Produtos", ClaimValue = "Gravar"
});
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var editora = new EditoraViewModel
{
Id = Guid.Parse(user.Id),
Email = user.Email,
Nome = model.Nome,
CNPJ = model.CPF
};
_editoraAppService.Registrar(editora);
if (!OperacaoValida())
{
await _userManager.DeleteAsync(user);
return(View(model));
}
await _signInManager.SignInAsync(user, isPersistent : false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public void FormatarResposta_TipoRequisicao_DELETE()
{
var notificador = new Notificador();
var formatter = new ResponseFormatter(notificador);
var editora = new EditoraViewModel
{
Id = Guid.NewGuid(),
Nome = "Editora",
Email = "*****@*****.**",
Pais = "Brasil"
};
var resultado = formatter.FormatarResposta(TipoRequisicao.Delete, editora);
resultado.Should().BeOfType <NoContentResult>();
}
public async Task <IActionResult> Create(EditoraViewModel editoraViewModel)
{
if (!ModelState.IsValid)
{
return(View(editoraViewModel));
}
var editora = _mapper.Map <Editora>(editoraViewModel);
await _editoraService.Adicionar(editora);
if (!OperacaoValida())
{
return(View(editoraViewModel));
}
return(RedirectToAction("Index"));
}
public void TestPut()
{
var model = new EditoraViewModel
{
IdEditora = 1,
Nome = "Independente"
};
var result = autorController.Put(model);
var objectResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(model, objectResult.Value);
var resultGet = autorController.Get(1);
var objectResultGet = Assert.IsType <OkObjectResult>(resultGet);
Assert.Same(model, objectResultGet.Value);
}
public ActionResult Alterar(EditoraViewModel vm)
{
if (ModelState.IsValid)
{
var md = Mapper.Map <EditoraViewModel, Editora>(vm);
try
{
db.Entry <Editora>(md).State = System.Data.Entity.EntityState.Modified;
if (db.SaveChanges() > 0)
{
return(RedirectToAction("Index"));
}
}
catch { }
}
return(View("Cadastro", vm));
}
public ActionResult Edit(EditoraViewModel editora)
{
try
{
if (ModelState.IsValid)
{
var editoraDomain = Mapper.Map <EditoraViewModel, Editora>(editora);
_editoraApp.Update(editoraDomain);
return(RedirectToAction("Index"));
}
return(View(editora));
}
catch (Exception e)
{
return(View(e.Message));
}
}
public void TestPost()
{
var model = new EditoraViewModel
{
IdEditora = 2,
Nome = "Vide Editorial"
};
var result = autorController.Post(model);
var objectResult = Assert.IsType <OkObjectResult>(result);
Assert.Same(model, objectResult.Value);
var resultGet = autorController.Get();
var objectResultGet = Assert.IsType <OkObjectResult>(resultGet);
var valuesGet = Assert.IsAssignableFrom <IEnumerable <EditoraViewModel> >(objectResultGet.Value);
Assert.Equal(2, valuesGet.Count());
}
public ActionResult BuscarForm()
{
try
{
var response = _editoraService.Get();
if (!response.IsSuccessStatusCode)
{
return(Content("Erro", "Erro ao buscar editoras!"));
}
var editora = new EditoraViewModel();
return(View("_Form", editora));
}
catch (Exception ex)
{
return(Content("Erro", ex.Message));
}
}
public void FormatarResposta_ComErroComStatusCodeNotFound_ObjetoUnico()
{
var notificador = new Notificador();
notificador.AdicionarErro("erro", "mensagem", HttpStatusCode.NotFound);
var responseFormatter = new ResponseFormatter(notificador);
var editora = new EditoraViewModel
{
Id = Guid.NewGuid(),
Nome = "Editora",
Email = "*****@*****.**",
Pais = "Brasil"
};
var resultado = responseFormatter.FormatarResposta(TipoRequisicao.Get, editora);
resultado.Should().BeOfType <ObjectResult>()
.Which.StatusCode.Should().Be((int)HttpStatusCode.NotFound);
}
public ActionResult Post(EditoraViewModel editora)
{
try
{
var response = _editoraService.Post(new EditoraDto {
idEditora = editora.idEditora, nomeEditora = editora.nomeEditora
});
if (!response.IsSuccessStatusCode)
{
return(Content("Erro ao cadastrar editora"));
}
return(View("_Grid", editora));
}
catch (Exception ex)
{
return(Content("Erro", ex.Message));
}
}
public void FormatarResposta_TipoRequisicao_PATCH()
{
var notificador = new Notificador();
var formatter = new ResponseFormatter(notificador);
var editora = new EditoraViewModel
{
Id = Guid.NewGuid(),
Nome = "Editora",
Email = "*****@*****.**",
Pais = "Brasil"
};
var resposta = new Response <EditoraViewModel>(editora, notificador);
var resultado = formatter.FormatarResposta(TipoRequisicao.Patch, editora);
resultado.Should().BeOfType <AcceptedResult>()
.Which.Value.Should().BeEquivalentTo(resposta);
resultado.Should().BeOfType <AcceptedResult>()
.Which.StatusCode.Should().Be((int)HttpStatusCode.Accepted);
}
public async Task <IActionResult> Edit(Guid id, EditoraViewModel editoraViewModel)
{
if (id != editoraViewModel.Id)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(View(editoraViewModel));
}
var editora = _mapper.Map <Editora>(editoraViewModel);
await _editoraService.Atualizar(editora);
if (!OperacaoValida())
{
return(View(editoraViewModel));
}
return(RedirectToAction("Index"));
}