public IHttpActionResult Login([FromBody] DTOUsuario usuario)
{
try
{
AutenticacaoService authService = new AutenticacaoService();
SenhaAcesso usuarioLogado;
var response = new DefaultResponse <SenhaAcesso>
{
data = new List <SenhaAcesso>()
};
if (authService.Autenticar(usuario, out usuarioLogado))
{
FormsAuthentication.SetAuthCookie(usuarioLogado.Usuario, true);
response.success = true;
response.message = "Conectado(a) com sucesso.";
return(Ok(response));
}
else
{
response.success = false;
response.message = "Usuário ou senha incorretos.";
return(Ok(response));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public IHttpActionResult AtualizarSenha([FromBody] DTOUsuario usuario)
{
try
{
AutenticacaoService autenticacaoService = new AutenticacaoService();
string usuarioAtual = HttpContext.Current.User.Identity.Name;
usuario.Usuario = usuarioAtual;
autenticacaoService.AtualizarSenha(usuario);
return(Ok(new
{
message = "Senha alterada com sucesso.",
data = new List <string>(),
success = true
}));
}
catch (Exception ex)
{
return(Ok(new
{
message = $"Oops, não foi possível atualizar sua senha pelo seguinte motivo: {ex.Message}",
data = new List <string>(),
success = false
}));
}
}
public IHttpActionResult Cadastrar([FromBody] DTOUsuario usuario)
{
try
{
AutenticacaoService authService = new AutenticacaoService();
var usuarioCadastrado = authService.Cadastrar(usuario);
if (usuarioCadastrado != null)
{
var response = new DefaultResponse <SenhaAcesso>
{
message = "Cadastrado efetuado com sucesso.",
data = new List <SenhaAcesso>(),
success = true
};
response.data.Add(usuarioCadastrado);
return(Created(HttpContext.Current.Request.RawUrl, response));
}
else
{
return(BadRequest("Houve um erro ao cadastrar."));
}
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult Logar(LoginViewModel model)
{
if (!ModelState.IsValid)
{
return View("Index", model);
}
AutenticacaoService service = new AutenticacaoService();
Stopwatch sw = Stopwatch.StartNew();
bool resultado = service.Autenticar(model.Usuario, model.Senha);
sw.Stop();
Trace.WriteLine("Autenticar em " + sw.ElapsedMilliseconds);
if (!resultado)
{
ModelState.AddModelError("Usuario",
"Usuário ou senha inválidos");
return View("Index", model);
}
return Content("TOP SECRET!");
}
private void login_Clicked(object sender, EventArgs e)
{
Login login = new Login
{
email = Email_entry.Text,
senha = Senha_entry.Text
};
try
{
AutenticacaoService autenticacaoService = new AutenticacaoService();
LoginRetorno retornoLogin = autenticacaoService.Autenticar(login);
if (retornoLogin.ativo)
{
Navigation.PushAsync(new Publicacoes());
}
else
{
DisplayAlert("Atenção", "Usuário ou senha inválidos!", "Ok");
}
}
catch (Exception ex)
{
DisplayAlert("Atenção", ex.Message, "Ok");
}
}
public ActionResult Registrar(RegistroViewModel model)
{
if (ModelState.IsValid)
{
var usuario = new WCF.DataContracts.Usuario
{
Nome = model.Nome,
Senha = model.SenhaHash,
Email = model.Email
};
var result = usuarioClient.CadastrarUsuario(usuario);
if (result.Sucesso)
{
AutenticacaoService.Autenticar(usuario.Nome, usuario.Email, result.Data.Id, Request);
return(RetornarJsonRedirect("Index", "Home"));
}
else
{
ModelState.AddModelError("", result.Mensagem);
return(RetornarComErro(ModelState));
}
}
else
{
return(RetornarComErro(ModelState));
}
}
public ActionResult AlterarDados(AlterarDadosViewModel model)
{
if (ModelState.IsValid)
{
var usuarioId = AutenticacaoService.BuscarIdUsuario(User.Identity as ClaimsIdentity);
var result = usuarioClient.AlterarNomeUsuario(model.Nome, usuarioId);
if (result.Sucesso)
{
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
AutenticacaoService.Autenticar(model.Nome, AutenticacaoService.BuscarEmail(User.Identity as ClaimsIdentity), usuarioId, Request);
return(Json(new { Sucesso = true }));
}
else
{
ModelState.AddModelError("", result.Mensagem);
return(RetornarComErro(ModelState));
}
}
else
{
return(RetornarComErro(ModelState));
}
}
public async Task <ResponsePedidoPost> Post([FromBody] Carrinho carrinho)
{
ResponsePedidoPost response = new ResponsePedidoPost();
Pedido pedido = new Pedido();
// Valida autenticacao
var usuarioAutenticado = await AutenticacaoService.ValidaAutenticacao(
new AutenticacaoModel
{
Token = carrinho.Usuario.Token
});
if (!usuarioAutenticado)
{
response.IndicadorErro = 1;
response.DescricaoErro = "Usuario não autenticado!";
}
else
{
// Adiciona itens do carrinho ao pedido
pedido.AddRangeItemPedido(carrinho.Itens);
pedido.DataPedido = DateTime.Now;
pedido.Status = StatusPedido.Confirmado;
// Persistir pedido e verificar se esta ok
if (pedido != null)
{
response.NumeroPedido = pedido.NumeroPedido;
}
}
return(response);
}
public List <string> validate()
{
List <string> erros = new List <string>();
if (nome == null || nome == "")
{
erros.Add("Nome do aluno não pode ser vazio.");
}
if (email == null || email == "")
{
erros.Add("E-mail não pode ser vazio.");
}
else
{
if (AutenticacaoService.ExisteAlunoComEmail(email))
{
erros.Add("E-mail já cadastrado para outro aluno.");
}
}
if (cpf == null || cpf.Length < 11 || cpf.Length > 12)
{
erros.Add("O CPF está incorreto.");
}
else
{
if (AutenticacaoService.ExisteAlunoComCPF(cpf))
{
erros.Add("CPF já cadastrado para outro aluno.");
}
}
return(erros);
}
public AutenticacaoController(
IUsuario usuario,
IConfiguration configuration,
AutenticacaoService autenticacaoService)
{
_usuario = usuario;
_configuration = configuration;
_autenticacaoService = autenticacaoService;
}
public ActionResult Edit(string NomeUsuario)
{
AutenticacaoService.RecuperaUsuario(NomeUsuario);
Usuario user = UsuarioDao.FindByLogin(NomeUsuario);
ViewBag.erros = new List <string>();
return(View(new UsuarioSimplesDTO(user)));
}
public async Task AutenticacaoService_Registrar_DeveRetornarCampoNuloAsync(string cpf, string email, string senha)
{
var autService = new AutenticacaoService(_signInManagerMock.Object, _userManagerMock.Object, _settingsMock.Object);
//Act
var retorno = await autService.Registrar(cpf, email, senha);
//Assert
Assert.False(retorno.Successo);
Assert.Null(retorno.Token);
}
public ActionResult Login(UsuarioSimplesDTO login)
{
bool autenticado = AutenticacaoService.login(login);
if (autenticado)
{
return(RedirectToAction("Index", "Dashboards"));
}
SessionHelper.AddMensagemToView("Login não encotrado", MensagemDTO.EnumTipoMensagem.error);
return(View(login));
}
public async Task AutenticacaoService_Registrar_DeveRetornarInvalidoAsync()
{
//Arrange
_userManagerMock.Setup((foo) => foo.CreateAsync(It.IsAny <IdentityUser>(), "123456")).ReturnsAsync(new IdentityResult());
var autService = new AutenticacaoService(_signInManagerMock.Object, _userManagerMock.Object, _settingsMock.Object);
//Act
var retorno = await autService.Registrar("teste", "teste@teste", "123456");
//Assert
Assert.False(retorno.Successo);
Assert.Null(retorno.Token);
}
public async Task AutenticacaoService_Autenticar_DeveRetornarValidoAsync()
{
//Arrange
_signInManagerMock.Setup((foo) => foo.PasswordSignInAsync(It.IsAny <string>(), It.IsAny <string>(), false, false)).ReturnsAsync(SignInResult.Success);
var autService = new AutenticacaoService(_signInManagerMock.Object, _userManagerMock.Object, _settingsMock.Object);
//Act
var retorno = await autService.Autenticar("teste", "teste@teste");
//Assert
Assert.True(retorno.Successo);
Assert.NotNull(retorno.Token);
}
public ActionResult Login(DTOUsuario usuario)
{
AutenticacaoService authService = new AutenticacaoService();
SenhaAcesso usuarioLogado;
if (authService.Autenticar(usuario, out usuarioLogado))
{
FormsAuthentication.SetAuthCookie(usuarioLogado.Usuario, true);
return(View("Index"));
}
else
{
return(View());
}
}
public void FillAppConfig()
{
var apiConfigs = GetApiConfigs();
AppConfig.ApiUrl = apiConfigs.Item1;
AppConfig.ApiUsername = apiConfigs.Item2;
AppConfig.ApiPassword = apiConfigs.Item3;
AppConfig.ApiCurrentSemester = apiConfigs.Item4;
AutenticacaoService service = new AutenticacaoService(AppConfig.ApiUrl);
service.BaseUrl = AppConfig.ApiUrl;
Autenticacao autenticacao = (Autenticacao)service.Autenticar(AppConfig.ApiUsername, AppConfig.ApiPassword);
AppConfig.Token = autenticacao.Token;
}
public ActionResult Cadastrar()
{
if (System.Web.HttpContext.Current.User.Identity.IsAuthenticated)
{
return(RedirectToAction("Index"));
}
AutenticacaoService service = new AutenticacaoService();
var qtdUsuarios = service.Listar().Count;
if (qtdUsuarios >= 2)
{
return(RedirectToActionPermanent("Login"));
}
return(View());
}
public IActionResult Entrar(Login model)
{
try
{
var service = new AutenticacaoService();
var usuario = service.Autenticar(model);
if (usuario == null)
{
return(Unauthorized(new { message = "Usuário e/ou senha inválidos." }));
}
return(Ok(usuario));
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
private async Task <DialogTurnResult> ConfirmAuthenticationStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken)
{
stepContext.Values["senha"] = (string)stepContext.Result;
var userAuth = await _userProfileAccessor.GetAsync(stepContext.Context, () => new UserAuthModel(), cancellationToken);
userAuth.Email = (string)stepContext.Values["email"];
userAuth.Senha = (string)stepContext.Values["senha"];
if (AutenticacaoService.AutenticarUsuario(userAuth.Email, userAuth.Senha))
{
Log = true;
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Você iniciou sua sessão. Para finalizar, digite 'sair'."), cancellationToken);
UltimaMensagem = stepContext.Context.Activity.Text;
return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken));
}
Log = false;
await stepContext.Context.SendActivityAsync(MessageFactory.Text("Credenciais inválidas."), cancellationToken);
return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken));
}
public List <string> validate()
{
List <string> erros = new List <string>();
if (nome == null || nome == "")
{
erros.Add("Nome do usuário não pode ser vazio.");
}
if (login == null || login == "")
{
erros.Add("Login não pode ser vazio.");
}
else
{
bool userExistente = AutenticacaoService.ExisteUsuarioComLogin(login);
if (userExistente)
{
erros.Add("Já existe um usuário com esse login cadastrado no sistema.");
}
}
if (email == null || email == "")
{
erros.Add("E-mail não pode ser vazio.");
}
else
{
if (AutenticacaoService.ExisteUsuarioComEmail(email))
{
erros.Add("E-mail já cadastrado para outro usuário.");
}
}
if (senha == null || senha.Length < 6 || senha.Length > 20)
{
erros.Add("A senha deve possuir entre 6 e 20 digitos.");
}
return(erros);
}
public LoginController(AutenticacaoService autenticacaoService) => this.autenticacaoService = autenticacaoService;
public LoginController(AutenticacaoService autenticacaoService, UserSession userSession)
{
this.autenticacaoService = autenticacaoService;
this.userSession = userSession;
}
public MainWindowViewModel()
{
#region Main
LoginCommand = new Command((p) =>
{
var usuario = new Usuario()
{
Login = this.Login,
Senha = this.Senha
};
IsLogado = AutenticacaoService.Autenticado(usuario);
});
#endregion
#region Usuario
CadastrarUsuarioCommand = new Command((p) =>
{
var view = new CadastroUsuarioView();
var viewModel = new CadastroUsuarioViewModel();
view.DataContext = viewModel;
viewModel.View = view;
viewModel.Exibir();
});
GerenciarUsuarioCommand = new Command((p) =>
{
var view = new GerenciarUsuarioView();
var viewModel = new GerenciarUsuarioViewModel();
view.DataContext = viewModel;
viewModel.View = view;
viewModel.Exibir();
});
#endregion
#region Desaparecido
CadastrarDesaparecidoCommand = new Command(p =>
{
var view = new CadastroDesaparecidoView();
var viewModel = new CadastroDesaparecidoViewModel();
view.DataContext = viewModel;
viewModel.View = view;
viewModel.Exibir();
});
GerenciarDesaparecidoCommand = new Command(p =>
{
var view = new GerenciarDesaparecidoView();
var viewModel = new GerenciarDesaparecidoViewModel();
view.DataContext = viewModel;
viewModel.View = view;
viewModel.Exibir();
});
#endregion
}
public AutenticacaoFacade(ModelStateDictionary modelState)
: base(modelState)
{
servicoAutenticacao = new AutenticacaoService();
}
/// <summary>
/// Lista de Usuários
/// </summary>
/// <returns></returns>
///
public ActionResult Index()
{
return(View(AutenticacaoService.listarTodosUsuarios()));
}
