/// <summary>
/// The login action.
/// </summary>
/// <param name="username">The username.</param>
/// <param name="password">The password.</param>
/// <returns>Redirect to index view result.</returns>
public ActionResult Login(string username, string password)
{
// Build the request
var request = new AuthenticateRequest
{
Username = username,
Password = password
};
// Call the service and get a response
AuthenticateResponse response;
using (var client = new AuthenticationServiceClient())
{
response = client.AuthenticateUser(request);
}
// If not authenticated, make a note for model state
if (!response.IsAuthenticated)
{
TempData.Add("Authentication", "The username/password did not match any user.");
}
// Redirect to the index view
return RedirectToAction("Index");
}
public async Task <IActionResult> UserAuthentication(AuthenticateRequest loginUser)
{
if (ModelState.IsValid)
{
var result = await _userService.AuthenticateUser(loginUser.Email, loginUser.Password);
if (result.IsSuccess)
{
Response.Headers.Add("Authorization", result.Token);
return(Ok(result));
}
}
return(BadRequest("Something went wrong"));
}
public AuthenticateResponse Authenticate(AuthenticateRequest model)
{
var user = _users.SingleOrDefault(x => x.Username == model.Username && x.Password == model.Password);
// return null if user not found
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = generateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public AuthenticateResponse Authenticate(AuthenticateRequest body)
{
var user = _users.SingleOrDefault(x =>
x.UserName == body.Username && x.Password == body.Password);
//Return null when user not found
if (user == null)
{
return(null);
}
var token = generateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public AuthenticateResponse Authenticate(AuthenticateRequest request)
{
var user = _users.SingleOrDefault(x => x.Username == request.Username && x.Password == request.Password);
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = GenerateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public string GetToken(AuthenticateRequest request)
{
var token = string.Empty;
var user = _userService.GetAll()
.FirstOrDefault(x => x.Username == request.Username &&
x.Password == request.Password
);
if (user != null)
{
token = _userService.generateToken(user);
}
return(token);
}
public ActionResult <AuthenticateResponse> Login([FromBody] AuthenticateRequest login)
{
var resultado = _loginService.validateUser(login);
if (resultado != null)
{
var token = generateJwtToken(resultado);
return(new AuthenticateResponse(resultado, token));
}
else
{
return(Unauthorized());
}
}
public IActionResult Register([FromBody] AuthenticateRequest request)
{
var user = Models.User.From(request);
try
{
_userService.Create(user, request.Password);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> Index(AuthenticateRequest req)
{
try
{
if (ModelState.IsValid)
{
var user = await _context.Users
.FirstOrDefaultAsync(u => u.UserName.ToLower().Equals(req.UserName.ToLower()) && u.Deleted != 1);
if (user == null)
{
TempData["Error"] = "Wrong username or password";
return(RedirectToAction("Index"));
}
if (!verifyPassword(req.Password, user.Password))
{
TempData["Error"] = "Wrong username or password";
return(RedirectToAction("Index"));
}
var jwtToken = generateJwtToken(user);
var response = new AuthenticateResponse
{
FullName = user.FullName,
Id = user.ID,
UserName = user.UserName,
Token = jwtToken,
};
if (response != null)
{
setTokenCookie(response.Token);
TempData["Success"] = MESSAGE_SUCCESS;
return(RedirectToAction("Index", "Home"));
}
TempData["Error"] = "Something wrong";
return(RedirectToAction("Index"));
}
return(View(req));
}
catch (Exception ex)
{
TempData["Error"] = ex.Message;
return(RedirectToAction("Index"));
}
}
public async Task <ActionResult <AuthenticateResponse> > Authenticate([FromBody] AuthenticateRequest request)
{
var user = _user.Authentificate(request.Username, request.Password);
if (user is null)
{
return(NotFound());
}
var tokenString = CreateToken(user);
AuthenticateResponse response = CreateResponse(tokenString, user);
return(Ok(response));
}
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model)
{
var user = await _context.User.FirstOrDefaultAsync(x => x.Name == model.Username && x.Password == model.Password);
if (user == null)
{
return(null);
}
var token = generateJwtToken(user);
return(new AuthenticateResponse(new User {
Username = user.Name
}, token));
}
public void Initialize()
{
userService = new Mock <IUserService>();
logger = new Mock <ILogger <LoginController> >();
loginController = new LoginController(logger.Object);
var user = new User {
Cpf = "01234567895", Email = "*****@*****.**", Name = "Teste", Role = "Usuario", CreatedAt = new DateTimeOffset(), Id = "5f0e43f02f695b5ae0d8526e"
};
authenticateResponse = new AuthenticateResponse(user, "5f0e43f02f695b5ae0d8526e");
authenticateRequest = new AuthenticateRequest {
Email = "*****@*****.**", Password = "******"
};
}
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model)
{
var user = await GetUser(model.Mail, model.Password);
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = generateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public async Task <IActionResult> Authenticate(AuthenticateRequest request)
{
Guard.AgainstNull(request, nameof(request));
var(valid, response) = await _userService.Authenticate(
email : request.Email,
password : request.Password,
getExpires : () => DateTime.Now.AddDays(1)
);
return(!valid
? (IActionResult)Unauthorized()
: Ok(response));
}
/**
* get token from etcd with name and password.
*
* @param channel channel to etcd
* @param username auth name
* @param password auth password
* @return authResp
*/
private static AuthenticateResponse Authenticate(Channel channel, ByteSequence username, ByteSequence password)
{
AuthenticateRequest requet = new AuthenticateRequest
{
Name = username.ToString(),
Password = password.ToString()
};
Auth.AuthClient authClient = new Auth.AuthClient(channel);
var rsp = authClient.Authenticate(requet);
AuthenticateResponse response = new AuthenticateResponse(rsp);
return(response);
}
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model)
{
var user = await _userRepo.GetUserByUserName(model.Username);
if (user != null && PasswordUtility.CheckPassword(user.PasswordHash, model.Password))
{
var token = generateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
else
{
return(null);
}
}
private void Authenticate()
{
if (log.IsDebugEnabled)
{
log.DebugFormat("TestClient, Authenticate {0}", userId);
}
var operation = new AuthenticateRequest {
Token = this.token
};
var request = new OperationRequest((byte)OperationCode.Authenticate, operation);
this.gameServerClient.SendOperationRequest(request, new SendParameters());
}
public AuthenticateResponse Authenticate(AuthenticateRequest model)
{
// return null if user not found
if (model.Username == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = generateJwtToken(model);
return(token);
}
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model)
{
//var a = new Guid();
//chú ý, async func đi với async, nên khi func nào dùng cái này cũng thành async func
var b = model.UserName;
var user = await _userManager.FindByNameAsync(b);
var userRole = await _userManager.GetRolesAsync(user);
var token = GenerateJwtToken(user, userRole);
var response = new AuthenticateResponse(user, token);
return(response);
}
public AuthenticateResponse Authenticate(AuthenticateRequest model)
{
var user = _dbContext.Users.SingleOrDefault(o => o.Username == model.Username);
// return null if user not found
if (user == null || !_hashService.Verify(model.Password, user.PasswordHash))
{
return(null);
}
// authentication successful so generate jwt token
var token = GenerateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public async Task <IActionResult> Login(AuthenticateRequest request)
{
string response = string.Empty;
// Sign user using the ASP.NET Identity platform.
Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(request.Username, request.Password, false, true);
if (result.Succeeded)
{
response = await _tokenClaimsService.GetTokenAsync(request.Username);
}
return(Ok(response));
}
public IActionResult Authenticate([FromBody] AuthenticateRequest request)
{
request.Password = EncryptionService.Encrypt(request.Password, jwtOptions.Secret);
User user = _context.Users.FirstOrDefault(x => x.Email == request.Email && x.Password == request.Password);
if (user == null)
{
return(BadRequest(new AuthResponse
{
Message = "Prisijungti nepavyko, patikrinti įvestį."
}));
}
return(Ok(GenerateAuthentificationResultForUser(user)));
}
public AuthenticateResponse Authenticate(AuthenticateRequest request)
{
var user = users.Find(u => u.Email == request.UserName &&
u.Password == Helpers.GetSHA256Hash(request.Password));
if (user == null)
{
return(new AuthenticateResponse());
}
var token = GenerateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public async Task <AuthenticateResponse> AuthenticateAsync(AuthenticateRequest model)
{
var user = await _user.Find(u => u.UserId == model.UserId && u.Password == model.Password).FirstOrDefaultAsync();
if (user == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = generateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public async Task <IActionResult> RefreshToken([FromBody] AuthenticateRequest authenticateRequest)
{
var refreshToken = Request.Cookies["refeshToken"];
var response = await _userService.RefreshToken(refreshToken);
if (refreshtoken == null)
{
return(BadRequest(new { message = "Invalid username or password" }));
}
SetCookieToken(response.RerfershTokens);
return(Ok(response));
}
public AuthenticateResponse Authenticate(AuthenticateRequest model)
{
var user = _users.SingleOrDefault
(x => x.Username == model.Username && x.Password == model.Password);
if (user == null)
{
return(null);
}
var token = generateJwt(user);
return(new AuthenticateResponse(user, token));
}
public async Task <AuthenticateResponse> Authenticate(AuthenticateRequest model)
{
var hash = GetPasswordHash(model.Password);
var user = await _context.Users.FirstOrDefaultAsync(x => model.UserName == x.UserName && hash == x.PasswordHash);
if (user == null || user.PasswordHash != hash)
{
return(null);
}
var token = GenerateJwtToken(user);
return(new AuthenticateResponse(user, token));
}
public async Task <IActionResult> Login([FromBody] AuthenticateRequest login)
{
if (login != null)
{
var remoteIp = Request.HttpContext.Connection.RemoteIpAddress?.ToString();
var result = await _accountService.Authenticate(login, remoteIp);
if (result != null)
{
return(Ok(result));
}
}
return(BadRequest("Invalid username or password"));
}
public AuthenticateResponse Authenticate(AuthenticateRequest model)
{
var admin = context.Admins.SingleOrDefault(x => x.Username == model.Username);
// return null if user not found
if (admin == null || !BC.Verify(model.Password, admin.Password))
{
return(null);
}
// authentication successful so generate jwt token
var token = generateJwtToken(admin);
return(new AuthenticateResponse(admin, token));
}
public AuthenticateResponse Authenticate(AuthenticateRequest req)
{
User user = _users.SingleOrDefault(x => x.UserName == req.UserName && x.Password == req.Password);
if (user == null)
{
return(null);
}
AuthenticateResponse res = new AuthenticateResponse();
res.Token = GetJWTToken(user);
return(res);
}
public AuthenticateResponse Authenticate(AuthenticateRequest model)
{
var account = _context.Accounts.SingleOrDefault(x => x.Email == model.Email && x.Password == HashPassword(model.Password));
// return null if user not found
if (account == null)
{
return(null);
}
// authentication successful so generate jwt token
var token = generateJwtToken(account);
return(new AuthenticateResponse(account, token));
}
public static HttpSelfHostServer Create(string url)
{
/*AppDomain.CurrentDomain.FirstChanceException +=
(object source, FirstChanceExceptionEventArgs e) =>
{
Console.WriteLine("FirstChanceException event raised in {0}: {1}",
AppDomain.CurrentDomain.FriendlyName, e.Exception.Message);
};*/
var config = new HttpSelfHostConfiguration(url);
config.Routes.MapHttpRoute("API Default", "api/{controller}/{id}",
constraints: null,
defaults: new {id = RouteParameter.Optional});
config.Formatters.JsonFormatter.SerializerSettings.Formatting = Formatting.Indented;
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
HeimdallConfig.AllowPath("/api/clone");
HeimdallConfig.AllowPath("/api/clones");
HeimdallConfig.AllowPath("/api/clonesdelete");
HeimdallConfig.AllowPath("/api/cloneskill");
HeimdallConfig.AllowPath("/api/executeasync");
HeimdallConfig.AllowPath("/api/execute");
HeimdallConfig.AllowPath("/api/exit");
HeimdallConfig.AllowPath("/api/info");
HeimdallConfig.AllowPath("/api/ping");
HeimdallConfig.AllowPath("/api/trace");
HeimdallConfig.AllowPath("/api/upload");
var authenticateRequest = new AuthenticateRequest(new UserRepository());
config.MessageHandlers.Add(new HmacAuthenticationHandler(authenticateRequest));
var server = new HttpSelfHostServer(config);
server.OpenAsync().Wait();
return server;
}
/// <summary>
/// Authenticates a user.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>The resposne.</returns>
public AuthenticateResponse AuthenticateUser(AuthenticateRequest request)
{
AuditStack.Push(request);
try
{
var response = new AuthenticateResponse();
using (var tx = new TransactionScope())
using (var session = Db.OpenSession())
{
var user = session.Query<User>().FirstOrDefault(x => x.Username == request.Username && x.Password == request.Password);
if (user == null)
{
response.IsAuthenticated = false;
}
else
{
response.IsAuthenticated = true;
user.NumberOfLogins++;
session.Store(user);
session.SaveChanges();
}
tx.Complete();
}
AuditStack.Push(response);
return response;
}
catch (Exception ex)
{
ElmahLogger.Log(ex);
throw;
}
}
/// <summary>
/// Starts the authentication process
/// </summary>
/// <returns></returns>
public IStatusIndicator Authenticate()
{
AuthenticateRequest request = new AuthenticateRequest(_ctx);
return (request.Execute() as IStatusIndicator);
}
