public LoginResultDTO AuthenticateUser(string UserName, string Password)
{
var user = _userRepository.All.FirstOrDefault(m => m.Username == UserName);
if (user != null && user.Password == Password)
{
var LoginResult = new LoginResultDTO()
{
LoginResult = Backbone.Enums.LoginResult.Success,
ArtifexUser = new ArtifexUser()
{
Id = 1, Username = "******"
},
};
if (LoginResult.LoginResult == Backbone.Enums.LoginResult.Success)
{
String Token = _tokenGenerator.GenerateToken(LoginResult.ArtifexUser);
LoginResult.CreateProfile();
LoginResult.User.Token = Token;
return(LoginResult);
}
}
//TODO: Authenticate from database
return(null);
}
public async Task <IActionResult> Login([FromBody] UserDTO model)
{
var claims = await GetIdentity(model.Email, model.Password);
if (claims == null)
{
LoginResultDTO resp = new LoginResultDTO
{
Successful = false,
Error = "Username and password are invalid."
};
return(Ok(resp));
}
var now = DateTime.UtcNow;
// создаем JWT-токен
var jwt = new JwtSecurityToken(
issuer: _configuration["ISSUER"],
audience: _configuration["AUDIENCE"],
notBefore: now,
claims: claims,
expires: now.Add(TimeSpan.FromMinutes(Convert.ToInt32(_configuration["LIFETIME"]))),
signingCredentials: new SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_configuration["KEY"])), SecurityAlgorithms.HmacSha256));
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
LoginResultDTO LoginResultDTO = new LoginResultDTO
{
Successful = true,
Token = encodedJwt
};
return(Ok(LoginResultDTO));
}
public Response <LoginResultDTO> SignUp(SignUpDTO request)
{
LoginResultDTO result = null;
BusinessProcess.Current.Process(p =>
{
result = IoC.Get <IAccountBusiness>().SignUp(request);
});
return(BusinessProcess.Current.ToResponse(result));
}
public Response <LoginResultDTO> Relogin(AccountDTO dto)
{
LoginResultDTO result = null;
BusinessProcess.Current.Process(p =>
{
result = IoC.Get <IAccountBusiness>().Relogin(dto);
});
return(BusinessProcess.Current.ToResponse(result));
}
public async Task <IActionResult> Login([FromBody] LoginViewModel model)
{
model.RememberMe = false;
try
{
if (!ModelState.IsValid)
{
var query = from state in ModelState.Values
from error in state.Errors
select error.ErrorMessage;
var errorList = query.ToList();
return(BadRequest(new LoginResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "Sign in failed",
UserSignInResult = null,
ErrorList = errorList
}));
}
var loginResult = await _identityService.LoginAsync(model.email, model.password, model.RememberMe);
if (loginResult.Status == "success")
{
return(Ok(loginResult));
}
else
{
return(BadRequest(loginResult));
}
}
catch (Exception ex)
{
var OtherErrors = new LoginResultDTO
{
Status = "fail",
ResponseCode = "02",
ResponseMessage = ex.Message.ToString(),
UserSignInResult = null,
ErrorList = null
};
return(StatusCode(500, OtherErrors));
}
}
public (bool IsValid, Dictionary <string, string> Payload, LoginResultDTO result) IsValid(LoginRequest loginRequest)
{
// some validation logic ..
LoginResultDTO result = null;
result = new LoginResultDTO()
{
UserId = "userId",
UserName = "******"
};
var dict = new Dictionary <string, string>();
dict.Add("RESTfulAPITemplateUserName", loginRequest.Username);
return(true, dict, result);
}
public async Task <LoginResultDTO> ExternalLogin(ExternalLoginDTO loginDTO)
{
if (loginDTO.LoginProvider == DictionaryResources.Facebook)
{
await ValidateFacebookToken(loginDTO.Token);
}
else
{
await ValidateGoogleToken(loginDTO.Token);
}
var user = _userManager.Users
.SingleOrDefault(u => u.Email == loginDTO.Email);
if (user == null)
{
user = await ExternalRegister(loginDTO);
}
var loggedUser = await _userRepository.GetUserLogin(loginDTO.LoginProvider, user.Id);
if (loggedUser == null)
{
await AddLogin(loginDTO, user);
}
var result = await _signInManager
.ExternalLoginSignInAsync(loginDTO.LoginProvider, loginDTO.ProviderKey, false);
if (!result.Succeeded)
{
throw new ApplicationException(DictionaryResources.InvalidLoginAttempt);
}
var loginResult = new LoginResultDTO
{
Token = GenerateJwtToken(user),
Id = user.Id
};
return(loginResult);
}
public async Task <LoginResultDTO> Login(LoginInfo loginInfo)
{
var user = await _userManager.FindByNameAsync(loginInfo.username);
if (user != null && await _userManager.CheckPasswordAsync(user, loginInfo.password))
{
var userRoles = await _userManager.GetRolesAsync(user);
var authClaims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, GenerateGd().ToString()),
};
foreach (var userRole in userRoles)
{
authClaims.Add(new Claim(ClaimTypes.Role, userRole));
}
var authSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JWT:Secret"]));
var token = new JwtSecurityToken(
issuer: _configuration["JWT:ValidIssuer"],
audience: _configuration["JWT:ValidAudience"],
expires: DateTime.Now.AddHours(6),
claims: authClaims,
signingCredentials: new SigningCredentials(authSigningKey, SecurityAlgorithms.HmacSha256)
);
LoginResultDTO loginResult = new LoginResultDTO();
loginResult.gd = user.gd;
loginResult.token = new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
};
return(loginResult);
}
return(null);
}
public async Task <(bool IsAuthenticated, LoginResultDTO Token)> IsAuthenticated(LoginCommandDTO request)
{
var loginCommand = _mapper.Map <LoginCommand>(request);
// larsson：这里应可以用消息队列（如MediatR）来解耦，实现CQRS
var loginResult = await _userService.IsUserLoginValid(loginCommand.Username, loginCommand.Password);
if (!loginResult.IsValid)
{
return(false, null);
}
LoginResultDTO loginResultDTO = null;
loginResultDTO = new LoginResultDTO()
{
UserId = loginResult.UserId.ToString(),
UserName = loginCommand.Username
};
var dict = new Dictionary <string, string>();
dict.Add("UserName", loginResultDTO.UserName);
dict.Add("UserId", loginResultDTO.UserId);
var claims = dict?.Select(x => new Claim(x.Key, x.Value));
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_tokenManagement.Secret));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var jwtToken = new JwtSecurityToken(
issuer: _tokenManagement.Issuer,
audience: _tokenManagement.Audience,
claims: claims,
expires: DateTime.Now.AddMinutes(_tokenManagement.AccessExpiration),
signingCredentials: credentials);
var token = new JwtSecurityTokenHandler().WriteToken(jwtToken);
loginResultDTO.Token = token;
return(true, loginResultDTO);
}
public LoginResultDTO AuthenticateUser(string UserName, string Password)
{
//TODO: Authenticate from database
var LoginResult = new LoginResultDTO()
{
LoginResult = Backbone.Enums.LoginResult.Success,
ArtifexUser = new ArtifexUser()
{
Id = 1, Username = "******"
},
};
if (LoginResult.LoginResult == Backbone.Enums.LoginResult.Success)
{
String Token = _tokenGenerator.GenerateToken(LoginResult.ArtifexUser);
LoginResult.CreateProfile();
LoginResult.User.Token = Token;
return(LoginResult);
}
return(null);
}
public async Task <LoginResultDTO> LogIn(LoginDTO model)
{
var loginResult = new LoginResultDTO();
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null)
{
if (user.EmailConfirmed == false)
{
loginResult.Success = false;
loginResult.Message = "You account not activated";
return(loginResult);
}
}
else
{
loginResult.Success = false;
loginResult.Message = "Account with this email address does not exist";
return(loginResult);
}
var result = await _signInManager.CheckPasswordSignInAsync(user, model.Password, true);
if (result.Succeeded)
{
var token = await _tokenService.CreateToken(user, _userManager);
loginResult.Success = true;
loginResult.Token = token;
}
else
{
loginResult.Success = false;
loginResult.Message = "Password is incorrect.";
}
return(loginResult);
}
public async Task <HttpResponseMessage> Login([FromBody] UILogin model)
{
Users foundUser = await _db.Users.Where(x => x.Username == model.Username).FirstOrDefaultAsync();
if (foundUser == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Not authorized!"));
}
string hash = PasswordHelper.GenerateHash(foundUser.PasswordSalt, model.Password);
if (foundUser.PasswordHash != hash)
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Not authorized!"));
}
//deactivate previous tokens
foreach (var item in _db.AuthenticationTokens.Where(x => x.UserID == foundUser.UserID).ToList())
{
item.IsDeleted = true;
}
_db.SaveChanges();
AuthenticationTokens newToken = new AuthenticationTokens
{
DeviceID = model.DeviceID,
IsDeleted = false,
UserID = foundUser.UserID,
TokenDate = DateTime.Now,
Token = Guid.NewGuid().ToString()
};
_db.AuthenticationTokens.Add(newToken);
_db.SaveChanges();
LoginResultDTO loginResult = new LoginResultDTO
{
token = newToken,
user = foundUser
};
return(Request.CreateResponse(HttpStatusCode.OK, loginResult));
}
public async Task <LoginResultDTO> Login(LoginDTO loginDTO)
{
var result = await _signInManager
.PasswordSignInAsync(loginDTO.Username, loginDTO.Password, false, false);
if (!result.Succeeded)
{
throw new ApplicationException(DictionaryResources.InvalidLoginAttempt);
}
var user = _userManager.Users
.SingleOrDefault(u => u.UserName == loginDTO.Username);
var loginResult = new LoginResultDTO
{
Token = GenerateJwtToken(user),
Id = user.Id,
Username = user.UserName
};
return(loginResult);
}
public async Task <ActionResult <LoginResultDTO> > Login([FromBody] LoginDTO loginDto)
{
LoginResultDTO result = new LoginResultDTO();
try
{
//On tente de s'authentifier
var tokenWithClaimsPrincipal = await this.AccountService.LoginAsync(loginDto);
//Si authentifier alors on enregistre les informationq dans les cookies
if (tokenWithClaimsPrincipal != null && tokenWithClaimsPrincipal.IsValid)
{
AuthenticationProperties authProperties = new AuthenticationProperties()
{
AllowRefresh = true,
IsPersistent = loginDto.RememberMe,
ExpiresUtc = DateTime.UtcNow.AddDays(1)
};
var claims = tokenWithClaimsPrincipal.Claims.ToList();
claims.Add(new Claim("AccessToken", $"Bearer {tokenWithClaimsPrincipal.AccessToken}"));
Response.Cookies.Append("Authorization", tokenWithClaimsPrincipal.AccessToken);
await HttpContext.SignInAsync(
new ClaimsPrincipal(new ClaimsIdentity(claims,
CookieAuthenticationDefaults.AuthenticationScheme)), authProperties);
result.User = await this.ApplicationUserService.GetByEmailAsync(loginDto.Email);
}
}
catch (Exception)
{
result.Error = "Login failed due to incorrect credentials";
}
return(Ok(result));
}
public Result <LoginResultDTO> PerformLogIn(string inGameName, string forPlayerName)
{
inGameName = inGameName.Trim();
forPlayerName = forPlayerName.Trim();
var gameFound = this._games.FirstOrDefault(g => g.Name == inGameName);
if (gameFound == null)
{
return(Result.Failure <LoginResultDTO>("Game has not been found by its name"));
}
var playerFound = gameFound.FindPlayer(forPlayerName);
if (playerFound == null)
{
return(Result.Failure <LoginResultDTO>("Player does not exist in Game"));
}
var jwtPlayerToken = this._bingoSecurity.CreateJWTTokenForPlayer(inGameName);
var loginResult = new LoginResultDTO(playerFound, gameFound.BallsPlayed, jwtPlayerToken);
return(Result.Ok(loginResult));
}
public async Task <LoginResultDTO> Login(LoginRequestDTO item)
{
var result = new LoginResultDTO {
Successful = false
};
var request = new HttpRequestMessage(HttpMethod.Post, this.UrlApi + "Login");
request.Headers.Accept.Clear();
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var content = new StringContent(JsonConvert.SerializeObject(item), Encoding.UTF8, "application/json");
request.Content = content;
//request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
var response = await _httpClient.SendAsync(request, CancellationToken.None);
string str = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <LoginResultDTO>(str);
await LocalStorageManagerService.SavePermanentItemAsync("Token", result.Token);
await LocalStorageManagerService.SavePermanentItemAsync("UserId", result.UserId);
return(result);
}
public async Task <LoginResultDTO> Login(LoginDTO loginDTO)
{
var user = _userManager.Users.SingleOrDefault(u => u.Email == loginDTO.Email);
if (!await _userManager.IsEmailConfirmedAsync(user) && !_userManager.GetLoginsAsync(user).Result.Any())
{
throw new ApplicationException(DictionaryResources.EmailNotConfirmed);
}
var result = await _signInManager.PasswordSignInAsync(loginDTO.Email, loginDTO.Password, false, false);
if (!result.Succeeded)
{
throw new ApplicationException(DictionaryResources.InvalidLoginAttempt);
}
var loginResult = new LoginResultDTO
{
Token = GenerateJwtToken(user),
Id = user.Id
};
return(loginResult);
}
public async Task <IActionResult> Login([FromBody] LoginDTO login)
{
this.logger.LogDebug($"登录账户: {login.UserName}");
var result = await this.signInManager.PasswordSignInAsync(login.UserName, login.Password, true, false);
if (!result.Succeeded)
{
var errorMessage = result switch
{
{ } when result.IsLockedOut => "账户被锁定",
{ } when result.IsNotAllowed => "账户被禁用",
{ } when result.RequiresTwoFactor => "账户需要验证",
_ => "邮箱或密码无效"
};
this.logger.LogDebug($"登录账户失败: {login.UserName} ({errorMessage})");
var failedResul = new LoginResultDTO
{
Successful = false,
Error = errorMessage
};
return(this.BadRequest(failedResul));
}
var claims = await this.GetClaimsAsync(login.UserName);
var token = this.tokenGenerator.GenerateSecurityToken(claims);
var loginResul = new LoginResultDTO
{
Successful = true,
Token = token
};
this.logger.LogDebug($"登录账户成功: {login.UserName}");
return(this.Ok(loginResul));
}
public async Task <LoginResultDTO> LoginAsync(string email, string password, bool rememberMe)
{
string token = "";
ApplicationUser user = await _userManager.FindByEmailAsync(email);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(email, password, rememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
string secret = _appSettings.Secret;
token = IdentityUtil.generateJwtToken(user, secret);
UserSignInResultDTO customerResult = new UserSignInResultDTO
{
firstname = user.FirstName,
lastname = user.LastName,
email = user.Email,
phone = user.PhoneNumber,
token = token
};
LoginResultDTO loginResultDTO = new LoginResultDTO
{
Status = "success",
ResponseCode = "00",
ResponseMessage = "Sign in Successfully",
UserSignInResult = customerResult,
ErrorList = null
};
return(loginResultDTO);
}
else
{
LoginResultDTO loginResultDTO = new LoginResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "Invalid Credentials",
UserSignInResult = null,
ErrorList = null
};
return(loginResultDTO);
}
}
else
{
LoginResultDTO loginResultDTO = new LoginResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "User does not exist",
UserSignInResult = null,
ErrorList = null
};
return(loginResultDTO);
}
}
