public async Task <IActionResult> Login(LoginViewmodel loginModel)
{
var model = _mapper.Map <LoginModel>(loginModel);
var result = await _identityService.GetToken(model);
return(Ok(result));
}
public async Task <IActionResult> Login(LoginViewmodel model)
{
if (ModelState.IsValid)
{
// This doesn't count login failures towards account lockout
// To enable password failures to trigger account lockout, set lockoutOnFailure: true
var result = await signInManager.PasswordSignInAsync(model.Username, model.Password, false, lockoutOnFailure : false);
if (result.Succeeded)
{
return(RedirectToLocal(model.ReturnUrl));
}
if (result.RequiresTwoFactor)
{
// return RedirectToAction(nameof(SendCode), new { model.ReturnUrl });
}
if (result.IsLockedOut)
{
return(View("Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(View(new LoginViewmodel(model)));
}
}
return(View(new LoginViewmodel(model)));
}
public async Task <ActionResult> Login(LoginViewmodel viewmodel)
{
var user = viewmodel.user;
var result = _loginLogic.ValidateUser(user.Username, user.PasswordHash);
if (result != null)
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, result.Username)
};
var claimsIdentity = new ClaimsIdentity(
claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
ExpiresUtc = DateTime.UtcNow.AddMinutes(360)
};
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
return(RedirectToAction("Index", "Menu"));
}
return(View("Index", viewmodel));
}
public async Task <IActionResult> Login([FromBody] LoginViewmodel value)
{
var user = await _userManager.FindByEmailAsync(value.Email);
if (user != null && await _userManager.CheckPasswordAsync(user, value.Password))
{
_jwtTokenService.CreateToken(user);
}
return(Unauthorized());
}
private void OnApplicationStart(object sender, StartupEventArgs e)
{
LoginViewmodel vm = new LoginViewmodel();
LoginView view = new LoginView();
this.ShutdownMode = ShutdownMode.OnMainWindowClose;
view.DataContext = vm;
this.MainWindow = view;
view.ShowDialog();
}
public IActionResult Post(LoginViewmodel login)
{
// Busca o usuário pelo e-mail e senha
Usuarios usuarioBuscado = usuarioRepository.BuscarPorEmailSenha(login.Email, login.Senha);
// Caso não encontre nenhum usuário com o e-mail e senha informados
if (usuarioBuscado == null)
{
// Retorna NotFound com uma mensagem de erro
return(NotFound("E-mail ou senha inválidos"));
}
// Caso o usuário seja encontrado, prossegue para a criação do token
/*
* Instalar as dependências:
*
* Criar e validar o jwt
* System.IdentityModel.Tokens.Jwt(5.5.0 ou superior)
*
* Integrar a parte de autenticação
* Microsoft.AspNetCore.Authentication.JwtBearer(2.1.1 ou compatível com o .Net Core do projeto)
*/
// Define os dados que serão fornecidos no token - Payload
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.IdUsuario.ToString()),
new Claim(ClaimTypes.Role, usuarioBuscado.IdTipoUsuario.ToString())
};
// Define a chave de acesso ao token
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("Senatur-chave-autenticacao"));
// Define as credenciais do token - Header
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
// Gera o token
var token = new JwtSecurityToken(
issuer: "Senatur.WebApi", // emissor do token
audience: "Senatur.WebApi", // destinatário do token
claims: claims, // dados definidos acima
expires: DateTime.Now.AddMinutes(30), // tempo de expiração
signingCredentials: creds // credenciais do token
);
// Retorna Ok com o token
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
private UserViewModel Authenticate(LoginViewmodel login)
{
UserViewModel user = null;
if (login.username == "pablo" && login.password == "secret")
{
user = new UserViewModel {
username = "******"
};
}
return(user);
}
public void NavigateBack()
{
//TODO: view skal have viewmodel til datacontext + IOC hell
IUnityContainer container = new UnityContainer();
container.RegisterType <IAPIAccess, APIAccess>();
container.RegisterType <IEventAggregator, EventAggregator>();
LoginViewmodel vm = container.Resolve <LoginViewmodel>();
Application.Current.MainWindow.Content = new LoginView();
}
public ActionResult Login(LoginViewmodel loginViewModel)
{
if (ModelState.IsValid)
{
if (_membership.ValidateUser(loginViewModel.Email, loginViewModel.Password))
{
FormsAuthentication.SetAuthCookie(loginViewModel.Email, loginViewModel.RememberMe == "on");
return(RedirectToAction("Index", "Profile"));
}
}
return(View());
}
public dynamic Post([FromBody] LoginViewmodel login)
{
IActionResult response = new UnauthorizedResult();
var user = Authenticate(login);
if (user != null)
{
var tokenString = BuildToken(user);
//response = new OkResult(tokenString);
response = new OkResult();
}
return(response);
}
public IActionResult Login(LoginViewmodel login)
{
if (ModelState.IsValid)
{
login.Password = Convert.ToBase64String(SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(login.Password)));
var user = _context.Users.FirstOrDefaultAsync(u => u.Email == login.UserName && u.Password == login.Password);
if (user != null)
{
HttpContext.Session.SetString("UserName", login.UserName);
return(RedirectToAction("Index", "Users"));
}
ModelState.AddModelError("Result", "Gçersiz kullanıcı adı ve sifre");
}
return(View(login));
}
private void Application_Startup(object sender, StartupEventArgs e)
{
UnityContainer container = new UnityContainer();
container.RegisterType <IAPIAccess, APIAccess>();
container.RegisterType <IEventAggregator, EventAggregator>();
MainMoneda view = new MainMoneda();
LoginView loginview = new LoginView();
LoginViewmodel vm = container.Resolve <LoginViewmodel>();
loginview.DataContext = vm;
view.Content = loginview;
view.Show();
}
public async Task <ActionResult> Index()
{
var userSession = await _userSessionService.GetCurrentSession();
if (userSession == null)
{
var loginModel = new LoginViewmodel()
{
ZerodhaUserId = "PS6365",
ApiKey = "17fzkglzv7v07xx1",
ApiSecret = "tvr9hcb8mt6gf2joq8jl3kn61dt41l9h"
};
return(View(loginModel));
}
else
{
Session["userSession"] = AutoMapper.Mapper.Map <UserSessionModel>(userSession);
return(RedirectToAction("Index", "Home"));
}
}
public IActionResult Index(LoginViewmodel viewmodel)
{
if (loginlogic.LogIn(viewmodel.Username, viewmodel.Password) == true)
{
Account account = new Account()
{
id = 2,
name = "kechie"
};
HttpContext.Session.SetString("AccountSession", JsonConvert.SerializeObject(account));
viewmodel.Messsage = "inloggen gelukt";
return(View("../Home/index"));
}
else
{
viewmodel.Messsage = "Username/password onjuist";
return(View("../Login/index"));
}
}
public async Task <ActionResult> Index(LoginViewmodel model)
{
if (ModelState.IsValid)
{
kite = new KiteConnect.Kite(APIKey: model.ApiKey, Debug: true);
User user = kite.GenerateSession(model.RequestToken, model.ApiSecret);
var userSessionModel = new UserSessionModel()
{
AccessToken = user.AccessToken,
ApiKey = model.ApiKey,
AppSecret = model.ApiSecret,
UserId = model.ZerodhaUserId,
PublicToken = user.PublicToken
};
await _userSessionService.SetCurrentSession(userSessionModel);
Session["userSession"] = userSessionModel;
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("Something went wrong", "please contact admin");
return(View(model));
}
public ActionResult Login(LoginViewmodel model)
{
scholarDBContext DB = new scholarDBContext();
var user = DB.userTBs.FirstOrDefault(x => x.userMail == model.userMail && x.Password == model.Password);
if (user != null)
{
Session["userName"] = user.userName;
Session["userID"] = user.userID;
return(RedirectToAction("UserProfile", "User", new { user.userID }));
}
else
{
var instructor = DB.instructorTBs.FirstOrDefault(x => x.instructorMail == model.userMail && x.password == model.Password);
if (instructor != null)
{
Session["instructorName"] = instructor.instructorName;
Session["instructorID"] = instructor.instructorID;
return(RedirectToAction("InstructorProfile", "Instructor", new { instructor.instructorID }));
}
else
{
var admin = DB.adminTBs.FirstOrDefault(x => x.adminMail == model.userMail && x.adminPass == model.Password);
if (admin != null)
{
Session["adminName"] = admin.adminMail;
Session["adminID"] = admin.adminID;
return(RedirectToAction("AdminProfile", "Admin", new { admin.adminID }));
}
else
{
return(RedirectToAction("Login"));
}
}
}
}
public ActionResult Login(LoginViewmodel model, string returnUrl)
{
}
public MainWindow()
{
DataContext = new LoginViewmodel();
InitializeComponent();
}
public ListenCommand(LoginViewmodel viewModel)
{
this.ViewModel = viewModel;
}
public async Task <IActionResult> Login(LoginViewmodel model)
{
try
{
var key = config["Sys:Key"];
var issuer = config["Sys:Issuer"];
var audience = config["Sys:Audience"];
var keyBytes = Encoding.ASCII.GetBytes(key);
var user = await userManager.FindByNameAsync(model.Username);
// Try to get a user by email if there's no user returned by username.
if (user == null)
{
user = await userManager.FindByEmailAsync(model.Username);
}
// user service can only send the successful result or throw an error - no need to null check it.
var resultModel = await userService.Authenticate(model.Username, model.Password);
switch (resultModel.Role)
{
// Admin role doesn't take any special considerations so exclude it.
case SystemRoles.Company:
var companyUser = await context.CompanyUsers.Include(x => x.Company).Include(x => x.User).SingleAsync(x => x.User.Id == resultModel.UserId);
resultModel.UserTypeId = companyUser.Company.Id.ToString();
break;
case SystemRoles.Client:
var clientUser = await context.ClientUsers.Include(x => x.Client).Include(x => x.User).SingleAsync(x => x.User.Id == resultModel.UserId);
resultModel.UserTypeId = clientUser.Client.Id.ToString();
break;
}
// Serialize the model to json so that it can be added to a claim.
var modelJson = JsonSerializer.Serialize(resultModel);
var tokenHandler = new JwtSecurityTokenHandler();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString()),
new Claim(ClaimTypes.UserData, modelJson)
}),
Expires = DateTime.Now.AddDays(7),
Issuer = issuer,
IssuedAt = DateTime.Now,
Audience = audience,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(keyBytes), SecurityAlgorithms.HmacSha512Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(tokenHandler.WriteToken(token)));
}
catch (Exception ex)
{
_logger.LogError($"Unable to log in", ex);
return(BadRequest(ex.ToString()));
}
}
public IActionResult Post(LoginViewmodel login)
{
try
{
var emailValidator = new EmailAddressAttribute();
Usuario usuarioBuscado;
login.Email = login.Email.ToUpper();
// Se for um email.
if (emailValidator.IsValid(login.Email))
{
usuarioBuscado = _usuarioRepository.BuscarPorEmail(login.Email);
if (usuarioBuscado != null)
{
bool isValidUser = StringUtils.VerificarSenha(login.Senha, usuarioBuscado.Senha);
if (!isValidUser)
{
return(Unauthorized());
}
}
else
{
return(NotFound());
}
}
else
{
return(Unauthorized());
}
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Email, usuarioBuscado.Email),
new Claim(JwtRegisteredClaimNames.Jti, usuarioBuscado.IdUsuario.ToString()),
new Claim(ClaimTypes.Role, usuarioBuscado.IdTipoUsuario.ToString()),
new Claim("Role", usuarioBuscado.IdTipoUsuario.ToString()),
};
if (usuarioBuscado.IdTipoUsuario == (int)Enums.TipoUsuario.CANDIDATO)
{
claims.Add(new Claim("StatusUsuario", usuarioBuscado.Candidato.IdStatusUsuario.ToString()));
}
if (usuarioBuscado.IdTipoUsuario == (int)Enums.TipoUsuario.EMPRESA)
{
claims.Add(new Claim("StatusUsuario", usuarioBuscado.Empresa.IdStatusUsuario.ToString()));
}
// Define a chave de acesso ao token
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.GetBytes("ConexaoVagas-chave-autenticacao"));
// Define as credenciais do token - Header
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
// Gera o token
var token = new JwtSecurityToken(
issuer: "ConexaoVagasAPI", // emissor do token
audience: "ConexaoVagasAPI", // destinatário do token
claims: claims, // dados definidos acima
expires: DateTime.Now.AddMinutes(30), // tempo de expiração
signingCredentials: creds // credenciais do token
);
// Retorna Ok com o token
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
catch (Exception e)
{
// Retorna a resposta da requisição 400 - Bad Request e o erro ocorrido com uma mensagem personalizada
return(BadRequest(new
{
mensagem = "Não foi possível gerar o token",
e
}));
}
}
public OpenWindowCommand(BaseViewmodel viewModel)
{
ViewModel = viewModel;
LoginModel = LoginModel;
}
public LoginView()
{
InitializeComponent();
DataContext = new LoginViewmodel(this);
}
public ConnectCommand(LoginViewmodel viewModel)
{
this.ViewModel = viewModel;
}
//LoginPage
public IActionResult Index()
{
var viewmodel = new LoginViewmodel();
return(View(viewmodel));
}
