private void ValidateUserLoginRequest(UserSignInRequest request)
{
ValidationException exception = new ValidationException();
if (request == null)
{
exception.Add(new ValidationError("common.invalidRequest"));
}
if (string.IsNullOrWhiteSpace(request.Email))
{
exception.Add(new ValidationError("registration.signin.validation.emailRequired"));
}
if (string.IsNullOrWhiteSpace(request.Pwd))
{
exception.Add(new ValidationError("registration.signin.validation.pwdRequired"));
}
IUserRepository userRepository = IoC.Container.Resolve <IUserRepository>();
User userProfile = userRepository.GetByEmail(request.Email);
if (userProfile == null || EncodeHelper.EncodePassword(request.Pwd) != userProfile.Password)
{
exception.Add(new ValidationError("registration.signin.validation.invalidEmailOrPwd"));
}
exception.ThrowIfError();
}
public override async Task <User> Authenticate(UserSignInRequest request, ServerCallContext context)
{
if (string.IsNullOrEmpty(request.User.UserName) || string.IsNullOrEmpty(request.User.Password))
{
return(null);
}
var user = await _context.Users.SingleOrDefaultAsync(x => x.UserName == request.User.UserName);
if (user == null)
{
return(null);
}
var userResponse = _mapper.Map <User>(user);
if (!VerifyPasswordHash(request.User.Password, Convert.FromBase64String(user.PasswordHash), user.PasswordSalt))
{
throw new ArgumentException("Username or password is incorrect");
}
var tokenString = GetJwtToken(user.Id);
userResponse.JWT = tokenString;
return(userResponse);
}
public async Task <UserLoginResponse> SignIn(UserSignInRequest request)
{
LogUtil.Debug("SignIn : " + request.Username + " In time: " + DateTime.UtcNow.ToString());
IAuthenticationManager authentication = HttpContext.Current.GetOwinContext().Authentication;
UserLoginResponse response = await Task.Run(() => _userService.UserSignIn(request));
string token = string.Empty;
if (response != null && response.ErrorCode == LAMPConstants.API_SUCCESS_CODE)
{
UserSessionToken tokenObj = _authService.CreateSessionTokenObject(response.UserId, response.Email, response.StudyId);
if (tokenObj.ErrorCode == LAMPConstants.API_SUCCESS_CODE)
{
response.SessionToken = tokenObj.SessionToken;
}
else
{
response = new UserLoginResponse
{
ErrorCode = LAMPConstants.API_SESSION_TOKEN_UPDATION_FAILED,
ErrorMessage = ResourceHelper.GetStringResource(LAMPConstants.API_SESSION_TOKEN_UPDATION_FAILED)
};
}
}
LogUtil.Debug("SignIn : " + request.Username + " Out time: " + DateTime.UtcNow.ToString());
return(response);
}
public async Task <IActionResult> SignInAsync(UserSignInRequest model)
{
var authenticationResult = await _userService.AuthenticateAsync(model);
return(!authenticationResult.Result
? BadRequest(new { message = authenticationResult.Message })
: Ok(authenticationResult.Data));
}
public async Task <ActionResult> SignInAsync([FromForm] UserSignInRequest request)
{
User user = mapper.Map <UserSignInRequest, User>(request);
AuthStatusResponse response = await authService.SignInAsync(user);
if (response.Status)
{
return(Ok(response));
}
return(Unauthorized(new ErrorResponse {
Error = response.Message, Status = response.Status
}));
}
public IResponseData <UserSignInResponse> SignIn([FromBody] UserSignInRequest request)
{
IResponseData <UserSignInResponse> response = new ResponseData <UserSignInResponse>();
try
{
IUserService userService = IoC.Container.Resolve <IUserService>();
UserSignInResponse signInResponse = userService.SignIn(request);
response.SetData(signInResponse);
}
catch (ValidationException ex)
{
response.SetErrors(ex.Errors);
response.SetStatus(System.Net.HttpStatusCode.PreconditionFailed);
}
return(response);
}
public async Task <AuthenticationResult> AuthenticateAsync(UserSignInRequest model)
{
var user = (await _userStoreManager.GetAllAsync())
.SingleOrDefault(x => x.Username == model.Username && x.Password == model.Password);
return(user is null
? new AuthenticationResult
{
Message = "Username or password is incorrect",
}
: new AuthenticationResult
{
Result = true,
Message = "User is successfully authenticated",
Data = new AuthenticateResponse(user, GenerateJwtToken(user))
});
}
public override async Task <User> Authenticate(UserSignInRequest request, ServerCallContext context)
{
if (string.IsNullOrEmpty(request.User.UserName) || string.IsNullOrEmpty(request.User.Password))
{
return(null);
}
var user = await _context.Users.SingleOrDefaultAsync(x => x.UserName == request.User.UserName);
var userResponse = _mapper.Map <User>(user);
if (user == null)
{
return(null);
}
return(!VerifyPasswordHash(request.User.Password, Convert.FromBase64String(user.PasswordHash), user.PasswordSalt)
? null
: userResponse);
}
public UserSignInResponse SignIn(UserSignInRequest request)
{
AuthenticationToken token;
User user;
this.ValidateUserLoginRequest(request);
using (IUnitOfWork uow = new App.Common.Data.UnitOfWork(RepositoryType.MSSQL))
{
IUserRepository userRepository = IoC.Container.Resolve <IUserRepository>(uow);
token = new App.Common.AuthenticationToken(Guid.NewGuid(), DateTimeHelper.GetAuthenticationTokenExpiredUtcDateTime());
user = userRepository.GetByEmail(request.Email);
user.Token = token.Value;
user.TokenExpiredAfter = token.ExpiredAfter;
userRepository.Update(user);
uow.Commit();
}
UserQuickProfile profile = new UserQuickProfile(user);
return(new UserSignInResponse(token, profile));
}
private void ValidateUserLoginRequest(UserSignInRequest request)
{
if (request == null)
{
throw new ValidationException("Common.InvalidRequest");
}
if (String.IsNullOrWhiteSpace(request.Email))
{
throw new ValidationException("Registration.SignIn.InvalidEmail");
}
if (String.IsNullOrWhiteSpace(request.Pwd))
{
throw new ValidationException("Registration.SignIn.InvalidPwd");
}
IUserRepository userRepository = IoC.Container.Resolve <IUserRepository>();
User userProfile = userRepository.GetByEmail(request.Email);
if (userProfile == null || EncodeHelper.EncodePassword(request.Pwd) != userProfile.Password)
{
throw new ValidationException("Registration.SignIn.InvalidEmailOrPwd");
}
}
public async Task <bool> SignIn(UserSignInFormModel form)
{
var request = new UserSignInRequest
{
Email = form.Email,
Password = form.Password
};
var response = await signInServiceClient.SignInAsync(request);
localStorage.SetAuthorizationTokens(response.TokenType, response.AccessToken, response.RefreshToken);
try
{
await currentUserService.SyncCurrentUserInfo();
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
Console.WriteLine(exception.StackTrace);
}
return(!response.IsError);
}
public async Task <ActionResult <UserLoginResponse> > SignIn([FromBody] UserSignInRequest request)
{
var user =
await _authenticationService.FindUserByEmailOrLoginAndPasswordAsync(request.LoginOrEmail,
request.Password);
if (user is null)
{
_logger.LogWarning($"{nameof(SignInIdentityController)}: user with email or login = {request.LoginOrEmail} and wrote password not exist.");
return(new UserLoginResponse
{
IsUserExists = false,
IsUserActive = false,
IsUserBlocked = false,
MetaInfo =
$"User not found with request credentials. {nameof(request.LoginOrEmail)}:{request.LoginOrEmail}"
});
}
_logger.LogInformation($"{nameof(SignInIdentityController)}: user with email or login = {request.LoginOrEmail} entered the service");
await _usersEntrancesService.LogAsync(user.Id);
var token = new JwtUserToken(_jwtConfiguration)
{
Email = user.Email,
Role = user.Role.RoleTitle
};
var userLoginResponse = _mapper.Map <UserEntityReadDto, UserLoginResponse>(user);
userLoginResponse.IsUserExists = true;
userLoginResponse.JwtToken = token.GetToken();
return(userLoginResponse);
}
public async Task <UserSignInResponse> OnSignInAsync(UserSignInRequest userSignIn)
{
var loginResponse = await _restClient.MakeApiCall <UserSignInResponse>(Constants.ApiUrl + "UserSignIn", HttpMethod.Post, userSignIn);
return(loginResponse);
}
public UserSignInResponse UserSignIn([FromBody] UserSignInRequest req)
{
var rep = new UserSignInResponse();
if (req.IsOAuth)
{
var param = req.OAuthParam;
var temp = DefaultStorage.UserOAuthGet(param.Provider, param.OpenId);
if (temp != null)
{
rep.Data = DefaultStorage.UserGet(temp.Id);
if (rep.Data != null)
{
Task.Factory.StartNew(() => SyncUserOAuth(temp.Id, param));
}
}
else
{
var user = new User();
var profile = new UserProfile();
var now = DateTime.Now;
user.Guid = Guid.NewGuid().ToString();// ObjectId.New();
user.Name = param.OpenId;
user.Email = string.Empty;
user.Mobile = string.Empty;
user.Nickname = param.OpenName;
user.Password = string.Empty;
user.Role = UserRole.Buyer;
user.Grade = UserGrade.One;
user.Limitation = UserLimitation.None;
user.Permission = UserPermission.None;
user.Avatar = string.Empty;
user.Status = UserStatus.Normal;
user.AuthedOn = null;
user.CreatedBy = param.Provider;
user.CreatedOn = now;
user.ModifiedBy = "app.api";
profile.Code = string.Empty;
profile.Name = string.Empty;
profile.Gender = Gender.Secrect;
profile.Marital = Marital.Secrect;
profile.Birthday = null;
profile.Phone = string.Empty;
profile.Mobile = string.Empty;
profile.RegionId = string.Empty;
profile.Street = string.Empty;
profile.SignUpIp = req.Ip;
profile.SignUpBy = 0;
profile.TraceCode = req.TraceCode;
profile.LastSignInIp = req.Ip;
profile.LastSignInOn = now;
user.Profile = profile;
var id = DefaultStorage.UserCreate(user);
if (id > 0)
{
user.Id = id;
profile.Id = id;
rep.Data = user;
Task.Factory.StartNew(() => CreateUserOAuth(id, param));
}
else
{
rep.Error("关联用户失败", 201);
}
}
}
else
{
if (req.Uid.IsEmpty())
{
rep.Error("请输入登录帐号");
return(rep);
}
if (req.Pwd.IsEmpty())
{
rep.Error("请输入登录密码");
return(rep);
}
var user = DefaultStorage.UserGet(req.Uid, req.Pwd);
if (user != null)
{
rep.Data = user;
}
else
{
rep.Error("用户名或密码错误", 200);
return(rep);
}
}
return(rep);
}
