/// <summary>
/// 更新登录凭证
/// </summary>
/// <param name="model"></param>
public void Update(UserTokenDto model)
{
UserTokenEntity entity = _userTokenRepository.Table.Where(a => a.UserID == model.UserID).FirstOrDefault();
entity = model.ToEntity(entity);
_userTokenRepository.Update(entity);
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
if (filterContext.ActionDescriptor.GetCustomAttributes(typeof(AllowAnonymousAttribute), true).Length != 0)
{
return;
}
HttpCookie cookie = HttpContext.Current.Request.Cookies[AuthCookieHelper.AuthCookieName];
if (cookie != null)
{
FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(cookie.Value);
string email = ticket.Name;
UserTokenEntity token = new UserTokenEntity(ticket.UserData);
UserEntity user = new UserEntity()
{
Email = email,
LoggedAuthToken = token
};
if (_avisameSiService.IsUserLogged(user))
{
var identity = new GenericIdentity(email, "AvisameSi");
//identity.AddClaim(new Claim("userEmail", ticket.Name));
HttpContext.Current.User = new GenericPrincipal(identity, null);
return;
}
}
this.HandleUnauthorizedRequest(filterContext);
}
public async Task <IActionResult> Login(string userName, string password)
{
var user = await userManager.FindByNameAsync(userName);
if (user != null)
{
var result = await signInManager.PasswordSignInAsync(user, password, isPersistent : false, false);
if (result.Succeeded)
{
string securityKey = "super_long_security_key_pls_work_2137";
var symmetricSecurityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(securityKey));
var signingCredentials = new SigningCredentials(symmetricSecurityKey, SecurityAlgorithms.HmacSha256Signature);
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, user.Id)
};
var token = new JwtSecurityToken(
issuer: "smieszek",
audience: "readers",
signingCredentials: signingCredentials,
claims: claims
);
string tokenString = new JwtSecurityTokenHandler().WriteToken(token).ToString();
var resultOutput = new UserTokenEntity(tokenString, user);
var resultOutputJSON = JsonConvert.SerializeObject(resultOutput, Formatting.Indented);
// JsonConvert.SerializeObject(resultOutput);
return(Content(resultOutputJSON));
}
}
return(BadRequest("Wrong username or password."));
}
public async Task <IActionResult> SignInAsync([FromBody] Models.AccountViewModels.LoginViewModel loginModel)
{
Result result;
var signinResult = await _signInManager.PasswordSignInAsync(loginModel.Email, loginModel.Password, true, lockoutOnFailure : false);
if (signinResult.Succeeded)
{
var userInfo = await _userRepository.FetchAsync(u => u.Email == loginModel.Email);
ArgumentNullException.ThrowIfNull(userInfo);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, userInfo.Email),
new Claim(JwtRegisteredClaimNames.NameId, userInfo.Id.ToString()),
};
var token = (TokenEntityWithRefreshToken)await _tokenService.GenerateToken(claims);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
RefreshToken = token.RefreshToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.Id,
UserName = userInfo.UserName
};
result = Result.Success(userToken);
}
else
{
result = Result.Fail(signinResult.IsLockedOut ? "Account locked out" : "failed to authenticate");
}
return(Ok(result));
}
public async Task <UserAuthentication> Handle(AuthenticateUserCommand request, CancellationToken cancellationToken)
{
var user = await unitOfWork.GetUser(request.Nickname);
var hash = hasher.Generate(request.Password, user.PasswordSalt);
if (user.PasswordHash == hash)
{
user.PasswordSalt = hasher.GetSalt(UserAuthConstants.PasswordSaltLength);
user.PasswordHash = hasher.Generate(request.Password, user.PasswordSalt);
user.LastLoginDate = dateTime.Now;
await unitOfWork.UpdateAsync(user);
var token = new UserTokenEntity()
{
Token = hasher.Generate(user.LastLoginDate.ToString(), request.Nickname), Nickname = request.Nickname, CreatedDate = user.LastLoginDate, ExpirationDate = user.LastLoginDate.Add(request.TokenExpirationTime)
};
await unitOfWork.AddAndSaveAsync(token);
return(new UserAuthentication()
{
User = user, Token = token.Token
});
}
throw new UserAuthenticationFailedException($"incorrect password");
}
private UserTokenEntity CreateLoggedUserToken(string userId)
{
IDatabase redis = _redisConn.GetDatabase();
UserTokenEntity userToken = new UserTokenEntity();
redis.HashSet(REDIS_USER_DATA + userId, REDIS_USER_DATA_LOGGED_AUTH, userToken.GetTokenString());
return(userToken);
}
public async Task <IActionResult> SignInAsync([FromBody] Models.AccountViewModels.LoginViewModel loginModel)
{
if (!ModelState.IsValid)
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
var userInfo = new SparkTodo.Models.UserAccount()
{
Email = loginModel.Email
};
var result = new Models.JsonResponseModel <JWT.TokenEntity>();
var signinResult = await _signInManager.PasswordSignInAsync(loginModel.Email, loginModel.Password, true, lockoutOnFailure : false);
if (signinResult.Succeeded)
{
_logger.LogInformation("User logged in.");
userInfo = await _userRepository.FetchAsync(u => u.Email == loginModel.Email);
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Jti, ObjectIdGenerator.Instance.NewId()),
new Claim(JwtRegisteredClaimNames.Sub, userInfo.Email),
new Claim(JwtRegisteredClaimNames.NameId, userInfo.Id.ToString()),
};
var token = _tokenGenerator.GenerateToken(claims);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.Id,
UserName = userInfo.UserName
};
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = userToken, Msg = "", Status = Models.JsonResponseStatus.Success
};
}
else
{
if (signinResult.IsLockedOut)
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = null, Msg = "Account locked out", Status = Models.JsonResponseStatus.RequestError
};
}
else
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = null, Msg = "failed to authenticate", Status = Models.JsonResponseStatus.AuthFail
};
}
}
return(Json(result));
}
public async Task <IActionResult> SignInAsync([FromForm] Models.AccountViewModels.LoginViewModel loginModel)
{
if (!ModelState.IsValid)
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
var userInfo = new SparkTodo.Models.UserAccount()
{
Email = loginModel.Email
};
var result = new Models.JsonResponseModel <JWT.TokenEntity>();
Microsoft.AspNetCore.Identity.SignInResult signinResult = await _signInManager.PasswordSignInAsync(loginModel.Email, loginModel.Password, true, lockoutOnFailure : false);
if (signinResult.Succeeded)
{
_logger.LogInformation(1, "User logged in.");
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_apiSetting.Value.SecretKey));
var options = new JWT.TokenOptions
{
Audience = "SparkTodoAudience",
Issuer = "SparkTodo",
SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256),
};
var token = new TokenProvider(options).GenerateToken(HttpContext, userInfo.Email);
userInfo = await _userRepository.FetchAsync(u => u.Email == loginModel.Email);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.UserId,
UserName = userInfo.UserName
};
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = userToken, Msg = "µÇ¼³É¹¦", Status = Models.JsonResponseStatus.Success
};
}
else
{
if (signinResult.IsLockedOut)
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = null, Msg = "µÇ¼ʧ°Ü£¬ÕË»§Òѱ»Ëø¶¨", Status = Models.JsonResponseStatus.RequestError
};
}
else
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = null, Msg = "µÇ¼ʧ°Ü", Status = Models.JsonResponseStatus.AuthFail
};
}
}
return(Json(result));
}
public async Task AddUserTokenAsync(UserTokenEntity userToken)
{
if (!_configuration.Value.AllowMultipleLoginsFromTheSameUser)
{
await InvalidateUserTokensAsync(userToken.F_UserId);
}
await DeleteTokensWithSameRefreshTokenSourceAsync(userToken.F_RefreshTokenIdHashSource);
_tokens.Add(userToken);
}
public async Task SetTokenAsync(string tenantId, string userId, string token)
{
await _tableClient.CreateIfNotExistsAsync();
var entity = new UserTokenEntity
{
TenantId = tenantId,
UserId = userId,
Token = token
};
await _tableClient.UpsertEntityAsync(entity);
}
public JsonResult PhoneLogin([FromForm] string phone, [FromForm] string code)
{
DataResult dr = new DataResult();
try
{
DataResult dataResult = ExaminePhoneAndCode(phone, code);
if (dataResult.code != "200")
{
return(Json(dataResult));
}
UserEntity userEntity = userBLL.GetByPhone(phone);
if (userEntity == null)
{
int rows = userBLL.CreateToPhone(phone);
}
PhoneCodeBLL phoneCodeBLL = new PhoneCodeBLL();
phoneCodeBLL.Delete(phone);
UserEntity user = userBLL.GetByPhone(phone);
UserTokenBLL userTokenBLL = new UserTokenBLL();
UserTokenEntity userTokenEntity = userTokenBLL.GetByUserId(user.userId);
UserTokenEntity userToken = new UserTokenEntity();
if (userTokenEntity == null)
{
userToken = userTokenBLL.Create(user.userId);
}
else
{
userToken = userTokenBLL.Update(userTokenEntity);
}
LoginResult loginResult = new LoginResult();
loginResult.token = userToken.token;
loginResult.userEntity = user;
dr.code = "200";
dr.data = loginResult;
}
catch (Exception ex)
{
dr.code = "999";
dr.msg = ex.Message;
}
return(Json(dr));
}
public async Task <IActionResult> SignUpAsync([FromForm] Models.AccountViewModels.RegisterViewModel regModel)
{
if (!ModelState.IsValid)
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
var userInfo = new SparkTodo.Models.UserAccount()
{
UserName = regModel.Email,
Email = regModel.Email,
EmailConfirmed = true,//ĬÈϲ»ÐèÒªÑéÖ¤ÓÊÏ䣬עÊÍÒÔÆôÓÃ
CreatedTime = DateTime.Now
};
var result = new Models.JsonResponseModel <JWT.TokenEntity>();
var signupResult = await _userManager.CreateAsync(userInfo, regModel.Password);
if (signupResult.Succeeded)
{
_logger.LogInformation(3, "User created a new account");
var signingKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_apiSetting.Value.SecretKey));
var options = new JWT.TokenOptions
{
Audience = "SparkTodoAudience",
Issuer = "SparkTodo",
SigningCredentials = new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256),
};
var token = new TokenProvider(options).GenerateToken(HttpContext, userInfo.Email);
userInfo = await _userRepository.FetchAsync(u => u.Email == regModel.Email);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.UserId,
UserName = userInfo.UserName
};
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = userToken, Msg = "×¢²á³É¹¦", Status = Models.JsonResponseStatus.Success
};
}
else
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = null, Msg = "sign up failed," + String.Join(",", signupResult.Errors.Select(e => e.Description).ToArray()), Status = Models.JsonResponseStatus.ProcessFail
};
}
return(Json(result));
}
public async Task <IActionResult> SignUpAsync([FromBody] Models.AccountViewModels.RegisterViewModel regModel)
{
if (!ModelState.IsValid)
{
return(new StatusCodeResult(StatusCodes.Status400BadRequest));
}
var userInfo = new SparkTodo.Models.UserAccount()
{
UserName = regModel.Email,
Email = regModel.Email,
EmailConfirmed = true,
CreatedTime = DateTime.Now
};
var result = new Models.JsonResponseModel <JWT.TokenEntity>();
var signupResult = await _userManager.CreateAsync(userInfo, regModel.Password);
if (signupResult.Succeeded)
{
_logger.LogInformation(3, "User created a new account");
userInfo = await _userRepository.FetchAsync(u => u.Email == regModel.Email);
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Jti, ObjectIdGenerator.Instance.NewId()),
new Claim(JwtRegisteredClaimNames.Sub, userInfo.Email),
new Claim(ClaimTypes.Name, userInfo.UserName),
};
var token = _tokenGenerator.GenerateToken(claims);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.Id,
UserName = userInfo.UserName
};
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = userToken, Msg = "", Status = Models.JsonResponseStatus.Success
};
}
else
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = null, Msg = "sign up failed," + string.Join(",", signupResult.Errors.Select(e => e.Description).ToArray()), Status = Models.JsonResponseStatus.ProcessFail
};
}
return(Json(result));
}
public JsonResult PhonePasswordLogin([FromForm] string phone, [FromForm] string password)
{
DataResult dr = new DataResult();
try
{
if (string.IsNullOrWhiteSpace(phone) || phone.Length != 11)
{
dr.code = "201";
dr.msg = "手机号码错误";
return(Json(dr));
}
UserEntity user = userBLL.GetByPhoneAndPassword(phone, Helper.DataEncrypt.DataMd5(password));
if (user == null)
{
dr.code = "201";
dr.msg = "手机号码或密码错误错误";
return(Json(dr));
}
UserTokenBLL userTokenBLL = new UserTokenBLL();
UserTokenEntity userTokenEntity = userTokenBLL.GetByUserId(user.userId);
UserTokenEntity userToken = new UserTokenEntity();
if (userTokenEntity == null)
{
userToken = userTokenBLL.Create(user.userId);
}
else
{
userToken = userTokenBLL.Update(userTokenEntity);
}
LoginResult loginResult = new LoginResult();
loginResult.token = userToken.token;
loginResult.userEntity = user;
dr.code = "200";
dr.data = loginResult;
}
catch (Exception ex)
{
dr.code = "999";
dr.msg = ex.Message;
}
return(Json(dr));
}
public UserTokenEntity Login(UserEntity user)
{
UserTokenEntity token = null;
IDatabase redis = _redisConn.GetDatabase();
string userId = redis.HashGet(REDIS_USERS_LIST, user.Email);
if (!string.IsNullOrEmpty(userId))
{
string storedPassword = redis.HashGet(REDIS_USER_DATA + userId, REDIS_USER_DATA_PASSWORD);
if (user.Password == storedPassword)
{
token = CreateLoggedUserToken(userId);
}
}
return(token);
}
public async Task <IActionResult> SignInAsync([FromBody] Models.AccountViewModels.LoginViewModel loginModel)
{
JsonResponseModel result;
var signinResult = await _signInManager.PasswordSignInAsync(loginModel.Email, loginModel.Password, true, lockoutOnFailure : false);
if (signinResult.Succeeded)
{
var userInfo = await _userRepository.FetchAsync(u => u.Email == loginModel.Email);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Jti, GuidIdGenerator.Instance.NewId()),
new Claim(JwtRegisteredClaimNames.Sub, userInfo.Email),
new Claim(JwtRegisteredClaimNames.NameId, userInfo.Id.ToString()),
};
var token = _tokenGenerator.GenerateToken(claims);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.Id,
UserName = userInfo.UserName
};
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = userToken, Msg = "", Status = Models.JsonResponseStatus.Success
};
}
else
{
if (signinResult.IsLockedOut)
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Msg = "Account locked out", Status = Models.JsonResponseStatus.RequestError
};
}
else
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Msg = "failed to authenticate", Status = Models.JsonResponseStatus.AuthFail
};
}
}
return(Ok(result));
}
public ResultInfo <string> CheckToken(UserTokenEntity tokenEntity)
{
ResultInfo <string> result = new ResultInfo <string>();
//验证token
if (Cache.GetCheckTokenCache(tokenEntity.Userid, tokenEntity.Token))
{
result.ResultData = null;
result.ResultCode = EmResultDescribe.OK;
}
else
{
result.ResultData = null;
result.ResultCode = EmResultDescribe.会话过期;
}
return(result);
}
/// <summary>
/// 根据token获取个人信息
/// </summary>
/// <param name="token"></param>
/// <returns></returns>
protected UserEntity GetUserByToken(string token)
{
if (!string.IsNullOrWhiteSpace(token))
{
UserBLL userBLL = new UserBLL();
UserTokenBLL userTokenBLL = new UserTokenBLL();
UserTokenEntity userTokenEntity = userTokenBLL.GetByToken(token);
UserEntity userEntity = userBLL.GetById(userTokenEntity.userId);
return(userEntity);
}
else
{
return(null);
}
}
public async Task AddUserTokenAsync(UserEntity user, string refreshTokenSerial, string accessToken, string refreshTokenSourceSerial)
{
var now = DateTimeOffset.Now;
var token = new UserTokenEntity
{
F_UserId = user.F_Id,
// Refresh token handles should be treated as secrets and should be stored hashed
F_RefreshTokenIdHash = _securityService.GetSha256Hash(refreshTokenSerial),
F_RefreshTokenIdHashSource = string.IsNullOrWhiteSpace(refreshTokenSourceSerial) ?
null : _securityService.GetSha256Hash(refreshTokenSourceSerial),
F_AccessTokenHash = _securityService.GetSha256Hash(accessToken),
F_RefreshTokenExpiresDateTime = now.AddMinutes(_configuration.Value.RefreshTokenExpirationMinutes),
F_AccessTokenExpiresDateTime = now.AddMinutes(_configuration.Value.AccessTokenExpirationMinutes)
};
await AddUserTokenAsync(token);
}
public async Task <IActionResult> SignUpAsync([FromBody] Models.AccountViewModels.RegisterViewModel regModel)
{
var userInfo = new SparkTodo.Models.UserAccount()
{
UserName = regModel.Email,
Email = regModel.Email,
EmailConfirmed = true,
CreatedTime = DateTime.UtcNow
};
JsonResponseModel <TokenEntity> result;
var signUpResult = await _userManager.CreateAsync(userInfo, regModel.Password);
if (signUpResult.Succeeded)
{
userInfo = await _userRepository.FetchAsync(u => u.Email == regModel.Email);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Jti, GuidIdGenerator.Instance.NewId()),
new Claim(JwtRegisteredClaimNames.Sub, userInfo.Email),
new Claim(JwtRegisteredClaimNames.NameId, userInfo.Id.ToString()),
};
var token = _tokenGenerator.GenerateToken(claims);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
UserEmail = userInfo.Email,
UserId = userInfo.Id,
UserName = userInfo.UserName
};
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Data = userToken, Msg = "", Status = Models.JsonResponseStatus.Success
};
}
else
{
result = new Models.JsonResponseModel <JWT.TokenEntity> {
Msg = "sign up failed," + string.Join(",", signUpResult.Errors.Select(e => e.Description).ToArray()), Status = Models.JsonResponseStatus.ProcessFail
};
}
return(Ok(result));
}
public async Task <long> AddAsync(long userId, string token)
{
using (MyDbContext dbc = new MyDbContext())
{
UserTokenEntity userToken = await dbc.GetAll <UserTokenEntity>().SingleOrDefaultAsync(u => u.UserId == userId);
if (userToken != null)
{
return(-1);
}
UserTokenEntity Token = new UserTokenEntity();
Token.UserId = userId;
Token.Token = token;
dbc.UserTokens.Add(Token);
await dbc.SaveChangesAsync();
return(Token.Id);
}
}
public UserTokenEntity RegisterUser(UserEntity user)
{
IDatabase redis = _redisConn.GetDatabase();
long userId = redis.StringIncrement(REDIS_SEQUENCE_USERS_ID);
redis.HashSet(REDIS_USERS_LIST, user.Email, userId.ToString());
HashEntry[] hashEntryArray = new HashEntry[] {
new HashEntry(REDIS_USER_DATA_EMAIL, user.Email),
new HashEntry(REDIS_USER_DATA_PASSWORD, user.Password)
};
redis.HashSet(REDIS_USER_DATA + userId, hashEntryArray);
redis.SortedSetAdd(REDIS_USERS_BY_CREATIONDATE, user.Email, DateTime.Now.Ticks);
UserTokenEntity token = CreateLoggedUserToken(userId.ToString());
return(token);
}
public async Task <IActionResult> SignUpAsync([FromBody] Models.AccountViewModels.RegisterViewModel regModel)
{
var userInfo = new UserAccount()
{
UserName = regModel.Email,
Email = regModel.Email,
EmailConfirmed = true,
CreatedTime = DateTime.UtcNow
};
Result <UserTokenEntity> result;
var signUpResult = await _userManager.CreateAsync(userInfo, regModel.Password);
if (signUpResult.Succeeded)
{
userInfo = await _userRepository.FetchAsync(u => u.Email == regModel.Email);
ArgumentNullException.ThrowIfNull(userInfo);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, userInfo.Email),
new Claim(JwtRegisteredClaimNames.NameId, userInfo.Id.ToString()),
};
var token = (TokenEntityWithRefreshToken)await _tokenService.GenerateToken(claims);
var userToken = new UserTokenEntity
{
AccessToken = token.AccessToken,
ExpiresIn = token.ExpiresIn,
RefreshToken = token.RefreshToken,
UserEmail = userInfo.Email,
UserId = userInfo.Id,
UserName = userInfo.UserName
};
result = Result.Success(userToken);
}
else
{
result = Result.Fail <UserTokenEntity>(
$"sign up failed,{string.Join(",", signUpResult.Errors.Select(e => e.Description).ToArray())}");
}
return(Ok(result));
}
public ActionResult Login(string email, string password)
{
IAccountRepository accountRepository = new AccountRepository(MvcApplication.RedisConn);
AccountService service = new AccountService(accountRepository);
UserEntity user = new UserEntity()
{
Email = email,
Password = password
};
UserTokenEntity token = service.Login(user);
if (token != null)
{
AuthCookieHelper.CreateAuthCookie(email, token.GetTokenString(), false);
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Register"));
}
}
public async Task <long> UpdateAsync(long userId, string token)
{
using (MyDbContext dbc = new MyDbContext())
{
UserTokenEntity userToken = await dbc.GetAll <UserTokenEntity>().SingleOrDefaultAsync(u => u.UserId == userId);
if (userToken != null)
{
userToken.Token = token;
}
else
{
UserTokenEntity entity = new UserTokenEntity();
entity.UserId = userId;
entity.Token = token;
dbc.UserTokens.Add(entity);
}
await dbc.SaveChangesAsync();
return(1);
}
}
public ActionResult Register(string email, string password, string passwordRepeat)
{
try
{
IAccountRepository accountRepository = new AccountRepository(MvcApplication.RedisConn);
AccountService service = new AccountService(accountRepository);
UserEntity user = new UserEntity()
{
Email = email,
Password = password
};
UserTokenEntity token = service.Register(user);
AuthCookieHelper.CreateAuthCookie(email, token.GetTokenString(), false);
return(RedirectToAction("Index", "Home"));
}
catch
{
throw;
//return RedirectToAction("Error500", "Error");
}
}
public static UserTokenEntity ToEntity(this UserTokenDto model, UserTokenEntity destination)
{
return(model.MapTo(destination));
}
/// <summary>
/// 插入登录凭证
/// </summary>
/// <param name="model"></param>
public void Insert(UserTokenDto model)
{
UserTokenEntity entity = model.ToEntity();
_userTokenRepository.Insert(entity);
}
public static UserTokenDto ToModel(this UserTokenEntity entity)
{
return(entity.MapTo <UserTokenEntity, UserTokenDto>());
}
public JsonResult WxLogin([FromForm] string code)
{
DataResult dr = new DataResult();
try
{
if (string.IsNullOrWhiteSpace(code))
{
dr.code = "201";
dr.msg = "参数错误";
return(Json(dr));
}
//UserEntity userEntity = userBLL.GetById(10007);
//userEntity.account = code;
//userBLL.ActionDal.ActionDBAccess.Updateable(userEntity).ExecuteCommand();
AccessTokenEntity accessTokenEntity = WeChat.LoginHelper.GetAccessToken(code);
if (!string.IsNullOrWhiteSpace(accessTokenEntity.errcode))
{
dr.code = "201";
dr.msg = "获取AccessToken失败";
return(Json(dr));
}
AccessTokenEntity accessToken = WeChat.LoginHelper.GetRefreshToken(accessTokenEntity.refresh_token);
if (!string.IsNullOrWhiteSpace(accessToken.errcode))
{
dr.code = "201";
dr.msg = "获取RefreshToken失败";
return(Json(dr));
}
AccessTokenEntity tokenEntity = WeChat.LoginHelper.SetExpiresIn(accessToken);
if (string.IsNullOrWhiteSpace(tokenEntity.access_token) || string.IsNullOrWhiteSpace(tokenEntity.openid))
{
dr.code = "201";
dr.msg = "续期失败";
return(Json(dr));
}
WeChat.WxUserEntity wxUserEntity = WeChat.LoginHelper.GetWxUser(tokenEntity.access_token, tokenEntity.openid);
if (string.IsNullOrWhiteSpace(wxUserEntity.openid) || !string.IsNullOrWhiteSpace(wxUserEntity.errcode))
{
dr.code = "201";
dr.msg = "获取用户信息失败";
return(Json(dr));
}
WxUserBLL wxUserBLL = new WxUserBLL();
Entity.WxUserEntity wxUser = wxUserBLL.GetByOpenId(wxUserEntity.openid);
if (wxUser == null)
{
int rows = CreateWxUser(wxUserEntity);
if (rows > 0)
{
dr.code = "201";
dr.msg = "创建用户失败";
return(Json(dr));
}
}
Entity.WxUserEntity wx = wxUserBLL.GetByOpenId(wxUserEntity.openid);
UserEntity user = userBLL.GetById(wx.userId);
UserTokenBLL userTokenBLL = new UserTokenBLL();
UserTokenEntity userTokenEntity = userTokenBLL.GetByUserId(user.userId);
UserTokenEntity userToken = new UserTokenEntity();
if (userTokenEntity == null)
{
userToken = userTokenBLL.Create(user.userId);
}
else
{
userToken = userTokenBLL.Update(userTokenEntity);
}
LoginResult loginResult = new LoginResult();
loginResult.token = userToken.token;
loginResult.userEntity = user;
dr.code = "200";
dr.data = loginResult;
}
catch (Exception ex)
{
dr.code = "999";
dr.msg = ex.Message;
}
return(Json(dr));
}
