public async Task GetRecursoQuery_Handle()
{
// Arrange
IUnitOfWork unitOfWork = DbContextHelper.GetContext();
IMapper mapper = AutoMapperHelper.GetMappings();
ICryptographyManager manager = CryptographyHelper.GetInstance();
Guid recursoId = Guid.NewGuid();
await unitOfWork.RecursoRepository.AddAsync(MockEntityHelper.GetNewRecurso(recursoId));
await unitOfWork.SaveChangesAsync();
GetRecursoQuery request = new()
{
Id = recursoId
};
// Act
RecursoHandler handler = new(unitOfWork, mapper, manager);
RecursoViewModel response = await handler.Handle(request, CancellationToken.None);
// Assert
Assert.True(response != null);
Assert.True(response.Id != Guid.Empty);
Assert.True(response.DataInclusao.Ticks != 0);
Assert.True(response.Senha == null);
Assert.True(response.Salt == null);
}
public void Test_OnPost(string nome, string login, string senha, string confirmarSenha, bool ativo)
{
// Arrange
Guid id = Guid.NewGuid();
RecursoViewModel recursoMock = new RecursoViewModel {
Id = id, Nome = nome, Login = login, Senha = senha, ConfirmarSenha = confirmarSenha, Ativo = ativo
};
_recursoAppService.Setup(x => x.Alterar(recursoMock));
AlterarModel pageModel = new AlterarModel(_recursoAppService.Object);
PageModelTester <AlterarModel> pageTester = new PageModelTester <AlterarModel>(pageModel);
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.WhenModelStateIsValidEquals(false)
.TestPage();
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.WhenModelStateIsValidEquals(true)
.TestRedirectToPage("Listar");
// Assert
Validation.For(recursoMock).ShouldReturn.NoErrors();
}
public ActionResult CadastrarAmbiente()
{
AmbienteViewModel viewModel = null;
try
{
viewModel = new AmbienteViewModel();
//List<TipoAmbienteViewModel> tipoAmbiente = TipoAmbienteViewModel.MapToListViewModel(speDominioService.GetTipoAmbienteAll().ToList());
List <TipoAmbienteViewModel> tipoAmbiente = TipoAmbienteViewModel.MapToListViewModel(BL.TipoAmbiente.Get().ToList());
viewModel.ListaTipoAmbiente = tipoAmbiente;
//List<LocalAmbienteViewModel> localAmbiente = LocalAmbienteViewModel.MapToListViewModel(speDominioService.GetLocalAmbienteAll().ToList());
List <LocalAmbienteViewModel> localAmbiente = LocalAmbienteViewModel.MapToListViewModel(BL.LocalAmbiente.Get().ToList());
viewModel.ListaLocalidade = localAmbiente;
//List<RecursoViewModel> recursos = RecursoViewModel.MapToListViewModel(speDominioService.GetFilteredRecurso(a => true, b => b.OrderBy(x => x.Descr), "TipoRecurso").ToList());
List <RecursoViewModel> recursos = RecursoViewModel.MapToListViewModel(BL.Recurso.Get(a => true, b => b.OrderBy(x => x.Descr), "TipoRecurso").ToList());
viewModel.ListaRecurso = recursos;
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página.";
Logging.getInstance().Error("Erro ao carregar página CadastrarAmbiente", ex);
}
return(View(viewModel));
}
public static bool RecursoCreate(RecursoViewModel entrada, out Recurso modelo, ContextPage contexto)
{
modelo = new Recurso();
modelo = entrada.recurso;
SqlGeneric sqlServic = new SqlGeneric();
modelo.codigo = sqlServic.RetornaNovaPosicao(22, contexto.idOrganizacao);
if (modelo.codigo != null)
{
//************ Objetos de controle de acesso ******************
modelo.criadoEm = DateTime.Now;
modelo.criadoPor = contexto.idUsuario;
modelo.criadoPorName = contexto.nomeUsuario;
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = contexto.idUsuario;
modelo.modificadoPorName = contexto.nomeUsuario;
modelo.idOrganizacao = contexto.idOrganizacao;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
return(false);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
if (!ModelState.IsValid)
{
return(Page());
}
RecursoViewModel recurso = await _recursoGrpcService.AutenticarAsync(Login.Usuario, Login.Senha);
if (recurso.Id == Guid.Empty)
{
ModelState.AddModelError(string.Empty, "Usuário ou senha inválidos.");
return(Page());
}
IEnumerable <Claim> claims = new[]
{
new Claim(ClaimTypes.PrimarySid, recurso.Id.ToString()),
};
ClaimsPrincipal principal = ClaimsService.CreateClaimsPrincipal(claims);
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
principal,
new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTime.UtcNow.AddMinutes(_systemConfiguration.CookieExpires)
});
return(RedirectToLocal(returnUrl));
}
public ActionResult <RecursoViewModel> Post([FromBody] RecursoViewModel obj)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_recursoAppService.Incluir(obj);
}
catch (DbUpdateException)
{
if (ObjExists(obj.Id))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction(nameof(Get), new { id = obj.Id }, obj));
}
public IActionResult Put(Guid id, [FromBody] RecursoViewModel obj)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != obj.Id)
{
return(BadRequest());
}
try
{
_recursoAppService.Alterar(obj);
}
catch (DbUpdateConcurrencyException)
{
if (!ObjExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Test_OnPost(string nome, string login, string senha, string confirmarSenha, bool ativo)
{
// Arrange
RecursoViewModel recursoMock = new RecursoViewModel {
Nome = nome, Login = login, Senha = senha, ConfirmarSenha = confirmarSenha, Ativo = ativo
};
IncluirModel pageModel = new IncluirModel(_recursoAppService.Object)
{
PageContext = PageContextManager.CreatePageContext()
};
_recursoAppService.Setup(x => x.Incluir(recursoMock));
PageModelTester <IncluirModel> pageTester = new PageModelTester <IncluirModel>(pageModel);
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.WhenModelStateIsValidEquals(false)
.TestPage();
// Act
pageTester
.Action(x => x.OnPost)
// Assert
.WhenModelStateIsValidEquals(true)
.TestRedirectToPage("Listar");
// Assert
Validation.For(recursoMock).ShouldReturn.NoErrors();
}
public async Task <RecursoViewModel> GetAsync(Guid id)
{
RecursoViewModel result = _mapper.Map <RecursoViewModel>(await _unitOfWork.RecursoRepository.GetAsync(id));
result.Senha = null;
result.Salt = null;
return(result);
}
public async Task UpdateAsync(RecursoViewModel viewModel)
{
_cryptographyManager.CryptPbkdf2(viewModel.Senha, out string senhaCrypt, out string salt);
viewModel.Senha = senhaCrypt;
viewModel.Salt = salt;
_unitOfWork.RecursoRepository.Update(_mapper.Map <Recurso>(viewModel));
await _unitOfWork.SaveChangesAsync();
}
public ViewResult FormCreateRecurso()
{
RecursoViewModel modelo = new RecursoViewModel();
modelo.recurso = new Recurso();
modelo.contexto = contexto;
modelo.recurso.criadoEm = DateTime.Now;
modelo.recurso.criadoPorName = contexto.nomeUsuario;
return(View(modelo));
}
public ActionResult <RecursoViewModel> Get(Guid id)
{
RecursoViewModel recurso = _recursoAppService.Consultar(id);
if (recurso == null)
{
return(NotFound());
}
return(Ok(recurso));
}
public async Task <RecursoViewModel> Handle(GetRecursoQuery request, CancellationToken cancellationToken)
{
RecursoViewModel result = _mapper.Map <RecursoViewModel>(await _unitOfWork.RecursoRepository.GetAsync(request.Id));
if (result != null)
{
result.Senha = null;
result.Salt = null;
}
return(result);
}
public async Task <RecursoViewModel> AddAsync(RecursoViewModel viewModel)
{
_cryptographyManager.CryptPbkdf2(viewModel.Senha, out string senhaCrypt, out string salt);
viewModel.Senha = senhaCrypt;
viewModel.Salt = salt;
RecursoViewModel result = _mapper.Map <RecursoViewModel>(await _unitOfWork.RecursoRepository.AddAsync(_mapper.Map <Recurso>(viewModel)));
await _unitOfWork.SaveChangesAsync();
return(result);
}
public static bool RecursoUpdate(RecursoViewModel entrada, out Recurso modelo)
{
modelo = new Recurso();
//************ Objetos de controle de acesso *******************
modelo = entrada.recurso;
modelo.modificadoEm = DateTime.Now;
modelo.modificadoPor = entrada.contexto.idUsuario;
modelo.modificadoPorName = entrada.contexto.nomeUsuario;
//************ FIM Objetos de controle de acesso ***************
return(true);
}
public IActionResult Delete(Guid id)
{
RecursoViewModel obj = _recursoAppService.Consultar(id);
if (obj == null)
{
return(NotFound());
}
_recursoAppService.Remover(id);
return(NoContent());
}
public async Task <IActionResult> OnGetAsync(Guid id)
{
try
{
Recurso = await _recursoApiService.ConsultarAsync(Token, id);
return(Page());
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(Page());
}
}
public async Task <IActionResult> OnGetAsync(Guid id)
{
try
{
Recurso = await _cpnucleoApiService.GetAsync <RecursoViewModel>("recurso", Token, id);
return(Page());
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(Page());
}
}
public async Task <ActionResult <RecursoViewModel> > Incluir(RecursoViewModel recursoViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var recurso = _mapper.Map <Recurso>(recursoViewModel);
await _recursoService.Incluir(recurso);
recursoViewModel.Id = recurso.Id;
return(Ok(recursoViewModel));
}
public async Task <ActionResult> Atualizar(int id, RecursoViewModel recursoViewModel)
{
if (!ModelState.IsValid || id != recursoViewModel.Id)
{
return(BadRequest());
}
var recursoAtualizacao = await _recursoService.Obter(id);
recursoAtualizacao.Titulo = recursoViewModel.Titulo;
recursoAtualizacao.Descricao = recursoViewModel.Descricao;
await _recursoService.Atualizar(_mapper.Map <Recurso>(recursoAtualizacao));
return(Ok(recursoViewModel));
}
public ViewResult Index()
{
List <RecursoViewModel> recurso = null;
try
{
var listaRecurso = BL.Recurso.Get(a => true, b => b.OrderBy(x => x.Descr), "TipoRecurso");
recurso = RecursoViewModel.MapToListViewModel(listaRecurso.ToList());
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página";
Logging.getInstance().Error("Erro ao carregar página de Index", ex);
}
return(View(recurso));
}
public ActionResult CadastrarRecurso()
{
RecursoViewModel viewModel = null;
try
{
viewModel = new RecursoViewModel();
viewModel.ListaTipoRecurso = TipoRecursoViewModel.MapToListViewModel(BL.TipoRecurso.Get(a => true, b => b.OrderBy(c => c.Descr)).ToList());
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página";
Logging.getInstance().Error("Erro ao carregar página CadastrarRecurso", ex);
}
return(View(viewModel));
}
public ActionResult EditarRecurso(RecursoViewModel recursoViewModel)
{
try
{
var model = RecursoViewModel.MapToModel(recursoViewModel);
BL.Recurso.AtualizarRecurso(model);
TempData["Sucesso"] = true;
TempData["SucessoMessage"] = "Edição de Recurso realizado com sucesso.";
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = (ex.GetType().Name == "CustomException") ? ex.Message : "Erro ao editar Recurso";
Logging.getInstance().Error(TempData["ErrorMessage"].ToString(), ex);
}
return(RedirectToAction("Index"));
}
public ViewResult DetalharRecurso(int id)
{
RecursoViewModel recursoViewModel = null;
try
{
var recurso = BL.Recurso.GetById(id);
recursoViewModel = RecursoViewModel.MapToViewModel(recurso);
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página";
Logging.getInstance().Error("Erro ao carregar página DetalharRecurso", ex);
return(View());
}
return(View(recursoViewModel));
}
public ActionResult EditarRecurso(int id)
{
RecursoViewModel recursoViewModel = null;
try
{
var recurso = BL.Recurso.GetById(id);
recursoViewModel = RecursoViewModel.MapToViewModel(recurso);
recursoViewModel.ListaTipoRecurso = TipoRecursoViewModel.MapToListViewModel(BL.TipoRecurso.Get(a => true, b => b.OrderBy(c => c.Descr)).ToList());
}
catch (Exception ex)
{
TempData["Error"] = true;
TempData["ErrorMessage"] = "Erro ao carregar a página";
Logging.getInstance().Error("Erro ao carregar página EditarRecurso", ex);
}
return(View(recursoViewModel));
}
public async Task UpdateRecursoCommand_Handle()
{
// Arrange
IUnitOfWork unitOfWork = DbContextHelper.GetContext();
IMapper mapper = AutoMapperHelper.GetMappings();
ICryptographyManager manager = CryptographyHelper.GetInstance();
Guid recursoId = Guid.NewGuid();
DateTime dataInclusao = DateTime.Now;
Recurso recurso = MockEntityHelper.GetNewRecurso(recursoId);
await unitOfWork.RecursoRepository.AddAsync(recurso);
await unitOfWork.SaveChangesAsync();
unitOfWork.RecursoRepository.Detatch(recurso);
UpdateRecursoCommand request = new()
{
Recurso = MockViewModelHelper.GetNewRecurso(recursoId, dataInclusao)
};
GetRecursoQuery request2 = new()
{
Id = recursoId
};
// Act
RecursoHandler handler = new(unitOfWork, mapper, manager);
OperationResult response = await handler.Handle(request, CancellationToken.None);
RecursoViewModel response2 = await handler.Handle(request2, CancellationToken.None);
// Assert
Assert.True(response == OperationResult.Success);
Assert.True(response2 != null);
Assert.True(response2.Id == recursoId);
Assert.True(response2.DataInclusao.Ticks == dataInclusao.Ticks);
Assert.True(response2.Senha == null);
Assert.True(response2.Salt == null);
}
}
public void Test_OnGet()
{
// Arrange
Guid id = Guid.NewGuid();
RecursoViewModel recursoMock = new RecursoViewModel {
};
_recursoAppService.Setup(x => x.Consultar(id)).Returns(recursoMock);
AlterarModel pageModel = new AlterarModel(_recursoAppService.Object);
PageModelTester <AlterarModel> pageTester = new PageModelTester <AlterarModel>(pageModel);
// Act
pageTester
.Action(x => () => x.OnGet(id))
// Assert
.TestPage();
}
public ActionResult <RecursoViewModel> Autenticar([FromQuery] string login, [FromQuery] string senha)
{
RecursoViewModel recurso = _recursoAppService.Autenticar(login, senha, out bool valido);
if (recurso == null)
{
return(NotFound());
}
if (!valido)
{
return(NotFound());
}
else
{
recurso.Token = _jwtManager.GenerateToken(recurso.Id.ToString(), _systemConfiguration.JwtExpirationDate);
return(Ok(recurso));
}
}
public ActionResult <RecursoViewModel> Autenticar(string login, string senha)
{
RecursoViewModel recurso = _recursoAppService.Autenticar(login, senha, out bool valido);
if (recurso == null)
{
return(NotFound());
}
if (!valido)
{
return(NotFound());
}
else
{
recurso.Token = TokenService.GenerateToken(recurso.Id.ToString(), _systemConfiguration.JwtKey, _systemConfiguration.JwtIssuer, _systemConfiguration.JwtExpires);
return(Ok(recurso));
}
}
public async Task <IActionResult> OnPostAsync()
{
try
{
if (!ModelState.IsValid)
{
Recurso = await _cpnucleoApiService.GetAsync <RecursoViewModel>("recurso", Token, Recurso.Id);
return(Page());
}
await _cpnucleoApiService.PutAsync("recurso", Token, Recurso.Id, Recurso);
return(RedirectToPage("Listar"));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(Page());
}
}
