public IEnumerable<ClaimModel> Login(string email, string password, out string message)
{
int status = 0;
var request = new UserLoginRequest() { Email = email, Password = password };
var userInfo = client.Login(request, out status, out message);
if (userInfo != null && userInfo.UserId > 0)
{
var claims = new List<ClaimModel>();
var properties = userInfo.GetType().GetProperties();
foreach (var prop in properties)
{
string att = prop.Name;
string value = string.Empty;
if (prop.GetValue(userInfo, null) != null)
{
value = prop.PropertyType != typeof(Dictionary<string, string>)
? prop.GetValue(userInfo, null).ToString()
: "";
}
claims.Add(new ClaimModel(att, value));
}
return claims;
}
return null;
}
public async Task <IActionResult> Login([FromBody] UserLoginRequest request)
{
if (request == null)
{
return(BadRequest());
}
var authResponse = await _identityService.LoginAsync(request.Email, request.Password);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}));
}
public MainResponse LoginUser(UserLoginRequest userLoginRequest)
{
string encodePassword = EncryptDecryptHelper.GetMd5Hash(userLoginRequest.Password);
var userDetails = _userRepository.GetSingle(x => x.UserName == userLoginRequest.UserName.ToLower() && x.Password == encodePassword && x.IsActive == true && x.IsDeleted == false);
if (userDetails != null)
{
if (userDetails.IsApproved == true)
{
var userRole = _userRoleRepository.GetSingle(x => x.UserId == userDetails.UserId);
if (userRole != null)
{
var role = _roleRepository.GetSingle(x => x.RoleId == userRole.RoleId);
var userResponse = _mapper.Map <UserResponse>(userDetails);
userResponse.Role = role.RoleName;
_mainResponse.UserResponse = userResponse;
}
else
{
var userResponse = _mapper.Map <UserResponse>(userDetails);
_mainResponse.UserResponse = userResponse;
}
_mainResponse.Message = Constants.LOG_IN;
_mainResponse.Success = true;
}
else
{
_mainResponse.Message = Constants.ADMIN_APPROVAL;
_mainResponse.Success = false;
}
}
else
{
_mainResponse.Message = Constants.USERNAME_PASSWORD_INCORRECT;
_mainResponse.Success = false;
}
return(_mainResponse);
}
public async Task <ActionResult <string> > SignIn([FromForm] UserLoginRequest form)
{
var user = await(from x in _db.Users
where x.Email == form.Email
select x).FirstOrDefaultAsync();
if (user == null)
{
return(BadRequest("Email wrong !"));
}
if (!BC.Verify(form.Password, user.Password))
{
return(BadRequest("Password wrong !"));
}
var token = JWTTool.GeneraToken(user);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
}));
}
public async Task <IActionResult> Register([FromBody] UserLoginRequest userRegistrationRequest)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse()
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage))
}));
}
var authResponse = await this.identity.Register(userRegistrationRequest);
if (!authResponse.Success)
{
return(BadRequest(authResponse.ErrorMessage));
}
return(Ok(new AuthResponse()
{
Token = authResponse.Token
}));
}
public async Task <IActionResult> Login(UserLoginRequest request)
{
try
{
var _userInfo = await _facade.AutenticateUser(request);
if (_userInfo != null)
{
return(Ok(new { token = GenerarTokenJWT(_userInfo) }));
}
else
{
return(Unauthorized());
}
}
catch (Exception ex)
{
log.Error(new Exception(), ex.Message);
}
return(null);
}
public IActionResult Login([FromBody] UserLoginRequest request)
{
try
{
var authResponse = _authService.Login(request.Email, request.Password);
if (authResponse.Success)
{
return(Ok(new LoginSuccessResponse
{
Token = authResponse.Token
}));
}
return(BadRequest(new LoginFailedResponse
{
Error = authResponse.Error
}));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
/// <summary>
/// 用户登陆
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
/// <returns></returns>
public string LoginIn(string userName, string password)
{
string resultToken = "";
try
{
string apiName = "token";
UserLoginRequest user = new UserLoginRequest()
{
username = userName, password = password
};
string json = JsonConvert.SerializeObject(user);
string resultStr = HttpHelper.HttpUrlSend(apiName, "POST", json);
UserLoginResponse resultInfo = JsonConvert.DeserializeObject <UserLoginResponse>(resultStr);
resultToken = resultInfo.sessionToken;
}
catch (Exception ex)
{
WPFClientCheckWordUtil.Log.TextLog.SaveError(ex.Message);
}
return(resultToken);
}
public async Task <IActionResult> UserLogin([FromBody] UserLoginRequest userObj)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(xx => xx.ErrorMessage))
}));
}
var AuthResponse = await _identityService.LoginAsync(userObj.Email, userObj.Password);
if (!AuthResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = AuthResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse {
Token = AuthResponse.Token
}));
}
public UserResponse loginUser(UserLoginRequest userLoginRequest)
{
var response = new HttpResponseMessage();
try
{
using (var context = new HackathonEntities())
{
var user = context.users.FirstOrDefault(x => x.email.Equals(userLoginRequest.email) && x.delete_ts != null);
if (user == null)
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest,
"Email supplied does not match account in our records.");
throw new HttpResponseException(response);
}
var success = unHashPassword(user.password, userLoginRequest.password);
if (!success)
{
response = Request.CreateErrorResponse(HttpStatusCode.BadRequest,
"User email and password combination does not match our records.");
throw new HttpResponseException(response);
}
return(new UserResponse()
{
id = user.id,
email = user.email,
firstName = user.first_name,
lastName = user.last_name
});
}
}
catch (Exception e)
{
throw new HttpResponseException(response);
}
}
public ActionResult Index(UserLoginRequest model)
{
model.Recaptcha = Request["g-recaptcha-response"];
if (string.IsNullOrEmpty(model.Recaptcha))
{
ViewBag.ScriptUp = $"ShowError('{ConfigurationManager.AppSettings.Get("Recaptcha.Empty")}');";
return(View(model));
}
if (ModelState.IsValid)
{
var recaptchaResponse = userBLL.ValidateCaptcha(model.Recaptcha);
if (!(recaptchaResponse.IsSuccess && recaptchaResponse.Result))
{
ViewBag.ScriptUp = $"ShowError('{ConfigurationManager.AppSettings.Get("Recaptcha.Invalid")}');";
return(View(model));
}
Response <User> response = userBLL.Login(model);
if (response.Message.Count > 0)
{
ViewBag.ScriptUp = response.Message.FirstOrDefault().Message;
}
if (response.IsSuccess && response.Result != null)
{
FormsAuthentication.SignOut();
string userName = Convert.ToString(response.Result.Id);
SessionHelper.Id = Convert.ToString(response.Result.Id);
SessionHelper.Role = response.Result.Role;
SessionHelper.Name = response.Result.UserName;
//Set the Form Aunthentication Cookie
FormsAuthentication.SetAuthCookie(userName, true);
return(RedirectToAction("Index", "Home"));
}
}
//return RedirectToAction("Index", "Account", new { ViewBag.ScriptUp } );
return(View(model));
}
public async Task <IActionResult> Login([FromBody] UserLoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(UserLoginResponse.Failed(Resource.InvalidPayload)));
}
var existingUser = await _UserManager.FindByEmailAsync(request.Email);
if (existingUser == null)
{
return(BadRequest(UserLoginResponse.Failed(Resource.InvalidLoginRequest)));
}
var isCorrect = await _UserManager.CheckPasswordAsync(existingUser, request.Password);
if (!isCorrect)
{
return(BadRequest(UserLoginResponse.Failed(Resource.InvalidLoginRequest)));
}
//убедиться что Email подтвержден
bool emailConfirmed = await _UserManager.IsEmailConfirmedAsync(existingUser);
if (!emailConfirmed)
{
return(BadRequest(UserLoginResponse.Failed(Resource.EmailNotConfirmed)));
}
var jwtToken = _GenerateJwtToken(existingUser);
return(Ok(new RegistrationResponse()
{
Success = true,
Token = jwtToken.JWT,
Expires = jwtToken.Expires
}));
}
public AuthenticatedUser Login(UserLoginRequest request)
{
var entity = _context.Users.FirstOrDefault(x => x.UserName == request.UserName);
#region User existence check
if (entity == null)
{
throw new UserException("Wrong username or password");
}
var hash = GenerateHash(entity.PasswordSalt, request.Password);
if (hash != entity.PasswordHash)
{
throw new UserException("Wrong username or password");
}
#endregion
#region Token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_options.Value.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.NameIdentifier, entity.Id.ToString()),
new Claim(ClaimTypes.Name, entity.UserName),
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
#endregion
var user = _mapper.Map <AuthenticatedUser>(entity);
user.Token = tokenHandler.WriteToken(token);
return(user);
}
public async Task <bool> LoginAsync(UserLoginRequest loginRequest)
{
var user = await _userService.LoginAsync <UserLoggedResponse>(loginRequest);
if (user == null)
{
return(false);
}
var claims = new List <Claim>
{
new Claim(nameof(user.Id), user.Id.ToString()),
new Claim(nameof(user.Email), user.Email)
};
var id =
new ClaimsIdentity(claims, "ApplicationCookie", nameof(user.Email),
ClaimsIdentity.DefaultRoleClaimType);
await _httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(id));
return(true);
}
public async Task <IActionResult> Login([FromBody] UserLoginRequest user)
{
if (!ModelState.IsValid)
{
return(new BadRequestResult());
}
try
{
var jwt = await _loginService.Login(user.Email, user.Password);
return(Ok(new { authToken = jwt }));
}
//TODO: catch unauthorized exception
catch (LoginFailedException)
{
return(new UnauthorizedResult());
}
catch (Exception)
{
return(new StatusCodeResult(500));
}
}
public async Task <IActionResult> Login(UserLoginRequest request)
{
var user = await _userManager.Users.IgnoreQueryFilters()
.Include(x => x.Organization)
.Include(x => x.UserRoles).ThenInclude(x => x.Role)
.FirstOrDefaultAsync(x => x.UserName == request.Username);
if (user == null)
{
return(Unauthorized());
}
var result = await _signInManager.CheckPasswordSignInAsync(user, request.Password, false);
if (result.Succeeded)
{
var userInfo = _mapper.Map <UserDetail>(user);
return(Ok(new { token = GenerateJwtToken(user).Result, user = userInfo }));
}
return(Unauthorized());
}
public UserSession Login(UserLoginRequest user)
{
//Daniel 123
var userHelper = CommonContext.GetInstance().Users.SingleOrDefault(u => u.Email == user.Email && u.Password == user.Password);
if (!(userHelper == null))
{
return(new UserSession
{
IsSuccess = true,
Email = userHelper.Email,
Rut = userHelper.Rut,
Message = "Session Open",
IdUserType = userHelper.IdUserType
});
}
return(new UserSession
{
IsSuccess = false,
Message = "Session not created"
});
}
public async Task <IActionResult> SignIn(UserLoginRequest model)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, true);
if (result.Succeeded)
{
return(CustomResponse(await GenerateJwt(model.Email)));
}
if (result.IsLockedOut)
{
AddError("User temporarily blocked by invalid attempts");
return(CustomResponse());
}
AddError("Incorrect username or password");
return(CustomResponse());
}
/// <summary>
/// 用户安全密码获取
/// </summary>
/// <returns></returns>
public async Task <XDocument> GetUserSecurityquestion(UserLoginRequest request)
{
return(await Task <XDocument> .Run(() =>
{
var fetchXml = $@"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='true'>
<entity name='mcs_usersecurityquestion'>
<attribute name='mcs_securityquestionid' />
<attribute name='mcs_answer' />
<attribute name='mcs_name' />
<link-entity name='mcs_user' from='mcs_userid' to='mcs_userid' link-type='inner' alias='ac'>
<link-entity name='mcs_loginname' from='mcs_userid' to='mcs_userid' link-type='inner' alias='ad'>
<filter type='and'>
<condition attribute='mcs_name' operator='eq' value='{request.account}' />
<condition attribute='mcs_status' operator='eq' value='1' />
<condition attribute='mcs_logintype' operator='eq' value='{request.logintype}' />
</filter>
</link-entity>
</link-entity>
</entity>
</fetch>";
return XDocument.Parse(fetchXml);
}));
}
public async Task <ActionResult <LoginResponse> > LoginAsync([FromBody] UserLoginRequest userLoginRequest)
{
var user = await userManager.FindByEmailAsync(userLoginRequest.Email);
if (user == null)
{
return(NotFound($"Can't find user with email {userLoginRequest.Email}"));
}
if (!user.EmailConfirmed)
{
return(BadRequest("User's email isn't confirmed"));
}
if (!await userManager.CheckPasswordAsync(user, userLoginRequest.Password))
{
return(BadRequest($"Incorrect password"));
}
var loginResponse = await GetLoginResponseAsync(user);
return(Ok(loginResponse));
}
public async Task <AuthenticationResult> Login(UserLoginRequest userLoginRequest)
{
var content = new StringContent(JsonSerializer.Serialize(userLoginRequest), Encoding.UTF8, HttpContentType.ApplicationJson);
var response = await _identityClient.PostAsync(IdentityActions.Login, content);
var authResult = JsonSerializer.Deserialize <AuthenticationResult>(await response.Content.ReadAsStringAsync(),
new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
authResult.Success = response.IsSuccessStatusCode;
if (!response.IsSuccessStatusCode)
{
return(authResult);
}
await SetTokens(authResult.Token, authResult.RefreshToken);
((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(userLoginRequest.Email);
return(authResult);
}
public async Task <IActionResult> Login(UserLoginRequest user)
{
var logged = await _repo.LoginAsync(user);
if (logged == null)
{
return(Unauthorized("You do not have access to login"));
}
string jwtToken = _provider.GeneratedToken(
new User {
UserUniqueIdentity = logged.UserUniqueIdentity,
Username = logged.Username,
Email = logged.Email
});
return(Ok(new
{
token = jwtToken,
logged
}));
}
public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
{
// call api
UserLoginRequest userLoginRequest = new UserLoginRequest()
{
UserSubject = context.UserName, UserPassword = context.Password
};
try
{
UserInfo currentUserInfo = await _callSystemServiceApi.UserLogin(userLoginRequest);
context.Result = new GrantValidationResult(
subject: userLoginRequest.UserSubject,
authenticationMethod: "custom",
claims: new Claim[] { new Claim("current_user_info", JsonConvert.SerializeObject(currentUserInfo)) }
);
}
catch (Exception ex)
{
context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, ex == null ? "InvalidGrant" : ex.Message);
}
}
public async Task <IActionResult> Login([FromBody] UserLoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ValidFildeFormBody()));
}
var authResponse = await _identityService.Login_Async(request.Email, request.Password);
if (authResponse == null || !authResponse.Success)
{
return(BadRequest(new AuthFailedResponse
{
Errors = authResponse.Errors
}));
}
return(Ok(
new AuthSuccessResopnse
{
Token = authResponse.Token,
RefreshToken = authResponse.RefreshToken
}
));
}
public async Task <IActionResult> Login([FromBody] UserLoginRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthFailedResponse
{
Errors = ModelState.Values.SelectMany(e => e.Errors.Select(er => er.ErrorMessage))
}));
}
var authResponse = await _identityService.LoginAsync(request.Email, request.Password);
if (!authResponse.Success)
{
return(BadRequest(new AuthFailedResponse {
Errors = authResponse.Errors
}));
}
return(Ok(new AuthSuccessResponse {
Token = authResponse.Token
}));
}
public async Task <ActionResult> UserLogin([FromBody] UserLoginRequest request)
{
if (ModelState.IsValid)
{
AppUser user = await _userManager.FindByEmailAsync(request.Email);
if (user != null && await _userManager.CheckPasswordAsync(user, request.Password))
{
HttpContext.Session.SetString(SessionKeyManager.Login, user.Id.ToString());
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var signinKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("MySuperSecureKey"));
var token = new JwtSecurityToken(
issuer: "http://google.com",
audience: "http://google.com",
expires: DateTime.UtcNow.AddHours(1),
claims: claims,
signingCredentials: new Microsoft.IdentityModel.Tokens.SigningCredentials(signinKey, SecurityAlgorithms.HmacSha256)
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
}));
}
else
{
return(BadRequest("Hatalı kullanıcı girişi yaptınız..."));
}
}
return(BadRequest("Veriler uygun değil"));
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="name"></param>
/// <param name="dh"></param>
/// <returns></returns>
public UserLoginResponse UserLogin(UserLoginRequest userlogin)
{
UserLoginResponse response = new UserLoginResponse();
UserModel userModel = new UserModel()
{
UserName = userlogin.UserName,
PassWord = userlogin.Pwd
};
if (userlogin == null || userlogin.UserName == null)
{
response.Status = false;
response.Message = "用户不能为空";
return(response);
}
if (userlogin == null || userlogin.Pwd == null)
{
response.Status = false;
response.Message = "密码不能为空";
return(response);
}
var res = d.UserLogin(userModel);
if (res > 0)
{
response.IsRegistSuccess = true;
response.UserName = userlogin.UserName;
response.Message = "登录成功";
}
else
{
response.Status = false;
response.Message = "登录失败";
}
return(response);
}
public async Task <AuthenticationResult> LoginAsync(UserLoginRequest request)
{
var user = await this.userManager.FindByEmailAsync(request.Email);
if (user == null)
{
return(new AuthenticationResult
{
Errors = new[] { "User does not exist" }
});
}
var userHasValidPassword = await this.userManager.CheckPasswordAsync(user, request.Password);
if (!userHasValidPassword)
{
return(new AuthenticationResult
{
Errors = new[] { "User/password combination is wrong" }
});
}
return(await GenerateAuthenticationResultForUserAsync(user));
}
public async Task <IActionResult> Authenticate(UserLoginRequest userLoginRequest)
{
var user = await _userManager.FindByNameAsync(userLoginRequest.UserName);
if (user == null)
{
return(BadRequest("Invalid user name or password."));
}
var loginResult = await _signInManager.CheckPasswordSignInAsync(user, userLoginRequest.Password, false);
if (!loginResult.Succeeded)
{
return(BadRequest("Invalid user name or password."));
}
// TODO: setup JWT token
DateTime expires = DateTime.UtcNow.AddHours(24);
var token = await CreateJwtKey(user, expires);
var response = new JwtSecurityTokenHandler().WriteToken(token);
return(Ok(new { jwt = response, expires, user.UserName }));
}
public Token GenerateToken(UserLoginRequest user)
{
ClaimsIdentity identity = new ClaimsIdentity(
new GenericIdentity(user.Email, "Login"),
new[] {
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString("N")),
new Claim(JwtRegisteredClaimNames.UniqueName, user.Email),
new Claim(ClaimTypes.Role, _userService.GetBy(x => x.Email.Equals(user.Email)).Role),
}
);
DateTime dataCriacao = DateTime.Now;
DateTime dataExpiracao = dataCriacao +
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 = dataCriacao,
Expires = dataExpiracao,
});
var token = handler.WriteToken(securityToken);
return(new Token()
{
Authenticated = true,
Created = dataCriacao.ToString("yyyy-MM-dd HH:mm:ss"),
Expiration = dataExpiracao.ToString("yyyy-MM-dd HH:mm:ss"),
AccessToken = token,
Message = "OK",
});
}
public async Task <IActionResult> Token(UserLoginRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await _context.Users.FirstOrDefaultAsync(t => t.UserPhone == model.UserPhone && t.UserPwd == model.UserPwd.ToMD5());
if (user == null)
{
return(NotFound());
}
var token = GetJwtSecurityToken(user);
return(new ObjectResult(
FormatResult.Success(
new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
})));
}
public UserInfoResponse Register(UserLoginRequest request, out int status, out string message)
{
status = 0;
message = string.Empty;
var response = new UserInfoResponse();
try
{
IHttpOrderClient client = new HttpOrderClient(Publickey, true);
var dic = new Dictionary<string, string>();
var url = GetUrl(BusinessObjectPublicUser.RequestFunction.Register);
var result = client.Post(request, url, dic, Appid, Uid);
if (result != null && result.ResponseData != null)
{
status = result.Status;
message = result.Message;
ResponseMessage = result.Message;
Status = result.Status;
return SerializerObject.ProtoBufDeserialize<UserInfoResponse>(result.ResponseData, client.Saltkey);
}
return null;
}
catch (Exception exception)
{
status = 0;
message = "Lỗi từ user api";
ResponseMessage = SetResponseMessage(exception);
return null;
}
}
