public LoginResultDto Execute(LoginDto dto)
{
User user = unit.User.GetByEmailIncludingRoles(dto.Email);
LoginResultDto result = new LoginResultDto();
if (user == null)
{
result.Message = Messages.UserNotExist;
}
else if (!user.ValidatePassword(dto.Password, _encrypter))
{
result.Message = Messages.InvalidPassword;
}
else if (user.Status != Enums.EntityStatus.Active.ToInt())
{
result.Message = Messages.UserNotActivated;
}
else if (user.UserRole == null || !user.UserRole.Any(p => p.RoleId == Roles.Admin.ToInt()))
{
result.Message = Messages.AccessDenied;
}
else
{
result.Object = DtoBuilder.CreateLoginDto(user);
result.Object.Token = _jwtHandler.Create(user.Id);
result.Status = true;
}
return(result);
}
private async Task <LoginResultDto> CreateToken(string username, UserAccount user)
{
try
{
LoginResultDto loginResult = new LoginResultDto();
loginResult.Authenticated = true;
var identity = await ClaimsIdentity(username, user);
loginResult.CreatedDate = DateTime.Now;
loginResult.ExpirationDate =
loginResult.CreatedDate + TimeSpan.FromSeconds(_tokenConfigurations.Seconds);
var handler = new JwtSecurityTokenHandler();
var securityToken = handler.CreateToken(new SecurityTokenDescriptor
{
Issuer = _tokenConfigurations.Issuer,
Audience = _tokenConfigurations.Audience,
SigningCredentials = _signingConfigurations.SigningCredentials,
Subject = identity,
NotBefore = loginResult.CreatedDate,
Expires = loginResult.ExpirationDate
});
loginResult.AccessToken = handler.WriteToken(securityToken);
loginResult.Message = "Ok";
return(loginResult);
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
throw;
}
}
public LoginResultDto LoginUser(string email, string password)
{
LoginResultDto loginResultDto = new LoginResultDto();
List <User> userList = UserRepository.Find(u => u.Email == email && u.Password == password);
if (userList.Count == 0)
{
return(null);
}
User user = userList.First();
try
{
JwtTokenData jwtTokensData = TokenBusinessLogic.CreateJwtTokens(user);
TokenBusinessLogic.AddNewToken(user, jwtTokensData.AccessToken, jwtTokensData.RefreshTokenSerial, jwtTokensData.RefreshToken);
loginResultDto.AccessToken = jwtTokensData.AccessToken;
loginResultDto.RefreshTokenSerial = jwtTokensData.RefreshTokenSerial;
return(loginResultDto);
}
catch (Exception e)
{
return(null);
}
}
public async Task <LoginResultDto> Authenticate(string username, string password)
{
LoginResultDto loginResult = new LoginResultDto();
loginResult.Authenticated = false;
loginResult.Message = "Falha ao autenticar";
try
{
if (!string.IsNullOrWhiteSpace(username))
{
var userIdentity = await _userManager.FindByNameAsync(username);
if (userIdentity != null)
{
var result = await _signInManager.CheckPasswordSignInAsync(userIdentity, password, false);
if (result.Succeeded)
{
loginResult = await CreateToken(username, userIdentity);
loginResult.Username = userIdentity.UserName;
}
}
}
return(loginResult);
}
catch (Exception e)
{
ConsoleEx.WriteError(e);
return(loginResult);
}
}
public async Task <ResponseDto <LoginResultDto> > LoginAsync(LoginDto loginDto)
{
var response = new LoginResultDto();
response.SignInResult = await _signInManager.PasswordSignInAsync(loginDto.Username, loginDto.Password, loginDto.RememberMe, true);
if (response.SignInResult.Succeeded)
{
var user = await _userManager.FindByNameAsync(loginDto.Username);
response.AccessToken = _tokenService.GenerateJwtToken(user);
response.ReturnUrl = "redirect home";
return(_responseService.Response(response, UserMessage.SuccessLogin));
}
if (response.SignInResult.RequiresTwoFactor)
{
response.ReturnUrl = "two factore redirect";
return(_responseService.Response(response, UserMessage.RequiresTwoFactor));
}
if (response.SignInResult.IsLockedOut)
{
response.ReturnUrl = "lock page show";
return(_responseService.Response(response, UserMessage.IsLockedOut));
}
response.ReturnUrl = "not allowed page ";
return(_responseService.Response(response, UserMessage.IsNotAllowed));
}
public async Task LoginTests()
{
var loginDto = new LoginDto()
{
Email = Faker.Internet.Email()
};
var response = new LoginResultDto
{
authenticated = true,
create = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"),
expiration = DateTime.UtcNow.AddHours(8).ToString("yyyy-MM-dd HH:mm:ss"),
accessToken = Guid.NewGuid().ToString(),
userName = loginDto.Email,
message = "Authentication successful",
};
_serviceMock = new Mock <ILoginService>();
_serviceMock.Setup(m => m.FindByLoginAsync(loginDto))
.ReturnsAsync(response);
_service = _serviceMock.Object;
var result = await _service.FindByLoginAsync(loginDto);
Assert.NotNull(result);
Assert.Equal(response, result);
}
public static int Login(string username, string password, double minutes)
{
String sha1Pwd = password;
LoginResultDto result = ServiceCall.Instance.UserService.TryLogin(username, sha1Pwd);
if (result.Tag == 1)
{
Exit();
UserDto user = ServiceCall.Instance.UserService.GetUser(result.Uid);
HttpContext.Current.Session[adminSK] = user;
HttpCookie cookie = new HttpCookie(String.Format("cms_sid_{0}", GeneratorRandomStr()));
cookie.Expires = DateTime.Now.AddMinutes(minutes);
// cookie.Domain=AppContext.Config.Domain.HostName;
//保存到Cookie中的密钥
string token = (username + Generator.Offset + sha1Pwd).EncodeMD5();
byte[] encodeBytes = Encoding.UTF8.GetBytes(username + "&" + token);
string encodedtokenStr = Convert.ToBase64String(encodeBytes);
cookie.Value = encodedtokenStr;
cookie.Path = "/" + Settings.SYS_ADMIN_TAG;
HttpContext.Current.Response.Cookies.Add(cookie);
}
return(result.Tag);
}
public LoginResultDto Login(LoginDto dto)
{
var result = new LoginResultDto();
dto.Password = DatabaseCreation.GetMd5(DatabaseCreation.GetSimpleMd5(dto.Password));
var accountFromDb = db.Accounts.FirstOrDefault(x => x.UserName == dto.UserName && x.Password == dto.Password && !x.DelFlag);
if (accountFromDb == null)
{
return(null);
}
var user = db.Users.FirstOrDefault(u => u.Id == accountFromDb.UserId && !u.DelFlag);
if (user != null)
{
result.User = new UserInformationResponseDto(user, accountFromDb.UserName);
}
var group = db.Groups.FirstOrDefault(g => g.Id == accountFromDb.GroupId && !g.DelFlag);
if (group != null)
{
result.Group = new GroupResponseDto
{
Id = group.Id,
Name = group.Name
};
}
db.SaveChanges();
return(result);
}
public async Task <LoginResultDto> Login([FromBody] UserLoginDto loginDto)
{
var user = await _userService.LoginAsync(loginDto.Login, loginDto.Password);
if (user == null)
{
return(new LoginResultDto {
ErrorMessage = "Login or password is incorrect"
});
}
var claims = new[] { new Claim(JwtRegisteredClaimNames.Typ, Constants.JwtClaim) };
var key = new SymmetricSecurityKey(_jwtConfig.KeyBytes);
var signingCredentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(_jwtConfig.Issuer,
_jwtConfig.Audience,
claims,
null,
DateTime.Now.AddMinutes(30),
signingCredentials);
var loginResultDto = new LoginResultDto
{
User = _mapper.Map <UserDto>(user),
Token = new JwtSecurityTokenHandler().WriteToken(token),
ErrorMessage = string.Empty
};
return(loginResultDto);
}
public async Task <IActionResult> Authenticate([FromBody] LoginDto login)
{
var loginResultDto = new LoginResultDto();
var result = await _signInManager.PasswordSignInAsync(login.Email, login.Password, true, lockoutOnFailure : false); // Check the user's email and password
if (result.Succeeded)
{
var token = _authenticationService.GenerateAuthToken(login.Email, _appSettings.Secret); // The login was successful so generate a auth token and send it to the user along with a refresh token
if (string.IsNullOrEmpty(token))
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var user = await _userManager.FindByEmailAsync(login.Email);
_authenticationService.RemoveRefreshTokenByUser(user.Id, "providername", "refresh", "phone"); // Remove any existing refresh tokens for the user so that we can add the new one
var newRefreshToken = _authenticationService.GenerateRefreshToken(); // Generate a new refresh token
_authenticationService.AddRefreshToken(user.Id, "providername", "refresh", newRefreshToken, "phone"); // Save the new refresh token
loginResultDto.WasSuccessful = true;
loginResultDto.Token = token;
loginResultDto.RefreshToken = newRefreshToken;
return(Ok(loginResultDto));
}
loginResultDto.WasSuccessful = false;
return(Ok(loginResultDto));
}
public void Login_ValidUser_InvalidPassword_ReturnsSuccess()
{
LoginResultDto result = this.service.Login("test", "password");
Assert.IsNotNull(result);
Assert.IsFalse(result.Success);
}
public async Task <LoginResultDto> Login([FromBody] UserLoginDto loginDto)
{
var user = await _userService.LoginAsync(loginDto.Login, loginDto.Password);
if (user == null)
{
return new LoginResultDto {
ErrorMessage = ErrorText.LoginIncorrect
}
}
;
var token = new JwtSecurityToken(
_jwtConfig.Issuer,
_jwtConfig.Audience,
new[] { new Claim(JwtRegisteredClaimNames.Typ, user.IsAdmin.ToString()) },
expires: DateTime.Now.AddMinutes(30),
signingCredentials: new SigningCredentials(
new SymmetricSecurityKey(_jwtConfig.KeyBytes),
SecurityAlgorithms.HmacSha256)
);
var loginResultDto = new LoginResultDto
{
User = _mapper.Map <UserDto>(user),
Token = new JwtSecurityTokenHandler().WriteToken(token),
ErrorMessage = string.Empty
};
return(loginResultDto);
}
}
/// <summary>
/// 登录
/// </summary>
/// <param name="dto">登录数据传输对象</param>
/// <returns>登录结果</returns>
public Dto.Business.LoginResultDto Login(Dto.Business.LoginDto dto)
{
LoginResultDto result = new LoginResultDto {
User = new UserManage.UserDto {
UserName = dto.UserName
}, Result = LoginResult.UserNameNotExist
};
var user = _userRepository.Get(t => t.LoginId == dto.UserName);
if (user == null)
{
return(result);
}
if (!user.CheckPassword(dto.Password))
{
result.Result = LoginResult.InvalidPassword;
}
else
{
result.Result = LoginResult.Success;
LsSession.SignIn(user, true);
//WriteOperateLog(LogType.信息, LogModule.系统管理, "用户{0}登录成功！", user.UserName);
}
return(result);
}
public async Task <LoginResultDto> RefreshToken()
{
var claims = ((ClaimsIdentity)_claimPrincipal.Identity).Claims;
var userRole = claims.SingleOrDefault(x => x.Type == ClaimTypes.Name);
if (userRole == null)
{
throw new Exception("No role found for current user... aborting request!");
}
var currentUserId = Guid.Parse(userRole.Value);
var user = await _dbCtx.Users.FirstOrDefaultAsync(x => x.Id == currentUserId);
_logger.LogInformation($"RefreshToken for [{user.UserName}]");
var reslogin = new LoginResultDto();
reslogin.User = user.ToDto();
reslogin.User.RoleName = user.Role.Name;
reslogin.User.IdRole = user.IdRole;
reslogin.Token = CreateToken(user);
reslogin.Role = 0; //ADMIN
reslogin.Id = user.Id;
reslogin.Authenticated = true;
return(reslogin);
}
public static string CreateToken(LoginResultDto result)
{
var issuedAt = DateTime.UtcNow;
//set the time when it expires
var expires = DateTime.UtcNow.AddDays(7);
var tokenHandler = new JwtSecurityTokenHandler();
//create a identity and add claims to the user which we want to log in
var claimsIdentity = new ClaimsIdentity(new[]
{
new Claim(Constants.UserIdClaimKey, result.User.Id.ToString()),
new Claim(Constants.UsernameClaimKey, result.User.Username),
new Claim(Constants.GroupIdClaimKey, result.Group.Id.ToString()),
new Claim(Constants.GroupNameClaimKey, result.Group.Name)
});
var securityKey = new SymmetricSecurityKey(System.Text.Encoding.Default.GetBytes(Constants.TokenSecretKey));
var signingCredentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256Signature);
//create the jwt
var token = tokenHandler.CreateJwtSecurityToken(
issuer: Constants.ValidIssuer,
audience: Constants.ValidAudience,
subject: claimsIdentity,
notBefore: issuedAt,
expires: expires,
signingCredentials: signingCredentials);
return($"Bearer {tokenHandler.WriteToken(token)}");
}
public async Task <ActionResult <LoginResultDto> > LoginAsync([FromBody] LoginRequestDto requestDto)
{
var user = await _userManager.FindByNameAsync(requestDto.UserName);
LoginResultDto result;
if (user != null && await _userManager.CheckPasswordAsync(user, requestDto.Password))
{
var claims = new List <Claim> {
new Claim(ClaimTypes.Name, user.UserName)
};
var token = _jwtTokenFactory.CreateToken(claims);
result = new LoginResultDto {
Claims = claims, LoginSuccess = true, Token = token,
};
}
else
{
result = new LoginResultDto {
LoginSuccess = false
};
}
return(Ok(result));
}
public LoginResultDto loadLoginSession()
{
if (cache == null)
{
cache = JsonConvert.DeserializeObject <LoginResultDto>(ObscuredPrefs.GetString(KEY_LOGIN_SESSION));
}
return(cache);
}
private void CompleteLoginAsync(LoginResultDto loginResult, string email)
{
//clear all stored data about user
_accountService.Logout();
//save auth tokens
_accountService.ResetTokens(loginResult.AccessToken, loginResult.RefreshToken);
_accountService.SaveProfileInfo(email, null, null);
}
public LoginResultDto <UserDto> LoginCheck(string account, string passwd, Enums.LoginPlatform loginPlatform)
{
LoginResultDto <UserDto> result = new LoginResultDto <UserDto>();
try
{
if (String.IsNullOrWhiteSpace(account) || String.IsNullOrWhiteSpace(passwd))
{
result.Failed("用户名/密码不能为空!");
return(result);
}
//passwd = RSAHelper.Instance.Encrypt(account+passwd);
var user = FindUserByLoginName(account);
if (user == null || user.State == Enums.UserStatus.Deleted || user == null || user.State == Enums.UserStatus.Deleted || user.LoginPasswd != passwd)
{
result.Failed("用户名/密码错误!");
return(result);
}
if (user.State == Enums.UserStatus.Forbid)
{
result.Failed("您的账号已被停用,请联系单位管理员!");
return(result);
}
//走到这里说明验证通过
if (loginPlatform == Enums.LoginPlatform.Web)
{
var token = Tools.CreateWebToken(user.Id, user.LoginName, Enums.LoginPlatform.Web);
RedisHelper.Instance.SetHash(RedisCacheTables.WebTokenDto, user.Id, token);
result.Success("登录成功!");
result.Data = user;
result.Token = token;
}
else if (loginPlatform == Enums.LoginPlatform.Android)
{
}
else if (loginPlatform == Enums.LoginPlatform.IOS)
{
}
else if (loginPlatform == Enums.LoginPlatform.WeiXinProgram)
{
}
}
catch (Exception ex)
{
result.Failed(ex);
}
return(result);
}
public ConnectionManager(LoginResultDto loginResultDto)
{
LoginResultDto = loginResultDto;
Zz = new ServerConnection(AdressPool.ZZ_EF_APK.Ip, AdressPool.ZZ_EF_APK.Port);
DelegateAction del = new DelegateAction();
del.act = ReturnServer;
Zz.PutDelegate(del);
}
public LoginResultDto Login(LoginCommand loginCommand)
{
var result = new LoginResultDto()
{
Sucess = true
};
// result.Roles.Add(new Rol(){ Name = "admin" });
return(result);
}
public void saveLoginSession(LoginResultDto dto)
{
clean();
string js = JsonConvert.SerializeObject(dto);
if (string.IsNullOrWhiteSpace(dto.jSessionId))
{
throw new System.Exception("not set jSessionId :" + js);
}
ObscuredPrefs.SetString(KEY_LOGIN_SESSION, js);
}
public static LoginResultDto LoginResultInfo(bool isSuccess, string reason, string token = null, int?userID = null)
{
var loginResultDto = new LoginResultDto();
loginResultDto.IsSuccess = isSuccess;
loginResultDto.Reason = reason;
loginResultDto.Token = token;
//null 即为 userID == 0
loginResultDto.UserID = userID == null ? 0 : (int)userID;
return(loginResultDto);
}
public async Task <ResultModel> Register(RegisterUserInfo userDto)
{
var user = MiCakeApp.User.Create(userDto.Act, userDto.Pwd, userDto.Avatar, userDto.Gender);
await _userRepo.AddAsync(user);
var token = _jwtSupporter.CreateToken(user);
var userRes = new LoginResultDto()
{
AccessToken = token, HasUser = true, UserInfo = user.Adapt <UserDto>()
};
return(new ResultModel(0, "", userRes));
}
public static async Task AddUserConnection(LoginResultDto loginResult)
{
var del = new DelegateAction {
act = ReturnLoginRequest
};
var cmd = new Command {
Cmd = ServerCommands.AddClientAuthorized, Json = await SerializerAsync.SerializeJson(loginResult.Username)
};
await Zz.WriteServer(del, cmd);
var conn = new ConnectionManager(loginResult);
UsersConnections.Add(loginResult.Username, conn);
}
/// <summary>
/// логинимся в системе
/// </summary>
/// <param name="input">данные передаваемые для логина</param>
/// <returns></returns>
static internal LoginResultDto Login(LoginInputDto input)
{
// Проверяем логин и пароль, получаем данные о человеке
Person person;
try
{
person = _bankGuaranteeContext.Credentials
.Include(c => c.Person)
.FirstOrDefault(c => c.Login == input.Login && c.PasswordEncrypt == input.Password)
?.Person;
}
catch (Exception ex)
{
// при ошибке с БД возвращаем информацию об ошибке
return(new LoginResultDto
{
Success = false,
ErrorText = Resources.DatabaseError + ": " + ex.Message
});
}
var result = new LoginResultDto
{
Success = person != null
};
//
if (result.Success)
{
// открываем соответствующие страницы для менеджера и специалиста
if (person.Appointment == Appointment.Manager)
{
result.NextForm = new GuaranteesListFormManager();
}
else
{
result.NextForm = new GuaranteesListFormSpecialist();
}
}
else
{
// если человек не найден, то выводим ошибку, что данные введены некорректно
result.ErrorText = Resources.CredentialsDenied;
}
return(result);
}
public static LoginResultDto ToLoginResultDto(this User entity)
{
if (entity == null)
{
return(null);
}
LoginResultDto dto = new LoginResultDto();
dto.CopyPropertiesFrom(entity);
dto.UserName = entity.Accounts.FirstOrDefault().UserName;
dto.UserId = entity.Id;
return(dto);
}
private IEnumerable <Claim> CreateClaimsForUser(LoginResultDto user)
{
var claims = new List <Claim>
{
new Claim(ClaimContants.UserId, user.UserId.ToString()),
new Claim(JwtRegisteredClaimNames.GivenName, user.FullName ?? string.Empty),
new Claim(ClaimContants.UserName, user.UserName),
};
foreach (var item in user.UserRoles)
{
claims.Add(new Claim(ClaimContants.Role, item.Role.Role));
}
return(claims);
}
public async Task <LoginResultDto> GetCurrentWebInfo()
{
var output = new LoginResultDto();
output.Menu = (await _userNavigationManager.GetMenuAsync("MainMenu", AbpSession.ToUserIdentifier())).UserMenuToNgMenu();
output.App = new AppConsts()
{
name = ParkConsts.AppName, description = ParkConsts.Description, year = AppVersionHelper.ReleaseDate
};
return(output);
}
public async Task <LoginResultDto> Login(LoginRequestDto requestDto)
{
var users = await _unitOfWork.FindAsyncByPredicateWithIncludeProperty <UserEntity>(x => x.UserName == requestDto.UserName && x.Password == requestDto.Password);
if (users.Count == 0)
{
return(new LoginResultDto());
}
var user = users.FirstOrDefault();
var userRoles = await _unitOfWork.FindAsyncByPredicateWithIncludeProperty <UserRoleEntity>(x => x.UserId == user.Id, e => e.Role, e => e.User);
user.UserRoles = userRoles;
var loginResult = new LoginResultDto(user);
return(loginResult);
}
