public async Task <ActionResult> Login(LoginInputDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
return(NotFound());
}
var isAuthenticated = await _userManager.CheckPasswordAsync(user, model.Password);
if (!isAuthenticated)
{
return(StatusCode(StatusCodes.Status401Unauthorized));
}
var refreshToken = _tokenFactory.GenerateToken();
user.RefreshToken = refreshToken;
await _userManager.UpdateAsync(user);
var response = new LoginOutputDto(
await _jwtFactory.GenerateEncodedToken(user.Id, user.UserName),
refreshToken,
true);
return(Ok(response));
}
public bool Login(LoginInputDto input)
{
var result = _enterpriseRepository.Single(x =>
x.LoginName.Equals(input.LoginName) && x.Password.Equals(input.Password));
return(result != null);
}
public async Task <string> LoginAsync(LoginInputDto inputDto)
{
inputDto.Password = inputDto.Password.GetMd5();
var user = await _dbContext.User
.Where(u => !u.IsDeleted)
.Where(u => u.IsAction)
.Where(u => u.LoginName == inputDto.LoginName.Trim())
.Where(u => u.Password == inputDto.Password.Trim())
.FirstOrDefaultAsync();
if (user == null)
{
throw new StringResponseException("用户名或密码错误！");
}
var claims = new[]
{
new Claim("Id", user.Id.ToString()),
new Claim("Name", user.LoginName)
};
var key = new SymmetricSecurityKey(Encoding.Unicode.GetBytes(_jwtOption.SigningKey));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var jwtToken = new JwtSecurityToken(_jwtOption.Issuer, _jwtOption.Audience, claims,
expires: DateTime.Now.AddMinutes(30), signingCredentials: credentials);
var token = new JwtSecurityTokenHandler().WriteToken(jwtToken);
return(token);
}
public async Task <(OperationResponse item, Claim[] cliams)> Login(LoginInputDto input)
{
input.NotNull(nameof(input));
var user = await _userManager.FindByNameAsync(input.UserName);
if (user == null)
{
return(new OperationResponse(ResultMessage.UserNameNotFind, OperationEnumType.Error), new Claim[] { });
}
var result = await _userManager.CheckPasswordAsync(user, input.Password);
if (!result)
{
return(new OperationResponse(ResultMessage.PassWordNotCheck, OperationEnumType.Error), new Claim[] { });
}
var jwtToken = _jwtBearerService.CreateToken(user.Id, user.UserName);
return(new OperationResponse(ResultMessage.LoginSusscess, new
{
AccessToken = jwtToken.AccessToken,
NickName = user.NickName,
UserId = user.Id.ToString(),
AccessExpires = jwtToken.AccessExpires
}, OperationEnumType.Error), new Claim[] { });
}
public LoginResultDto Login(LoginInputDto input)
{
var user = GetUser(input.userName);
if (user == null)
{
throw new Exception("Invalid username");
}
var checkPassword = _passwordHasher.VerifyHashedPassword(user, user.password, input.password);
if (checkPassword != PasswordVerificationResult.Success)
{
throw new Exception("Invalid Password");
}
var tokenStr = GenerateJSONWebToken(user);
return(new LoginResultDto
{
UserId = user.Id,
userName = user.userName,
email = user.email,
phoneNumber = user.phoneNumber,
RoleId = user.RoleId,
token = tokenStr
});
}
public async Task <string> JwtLogin(LoginInputDto loginInputDto)
{
LinUser user = await _userRepository.GetUserAsync(r => r.Username == loginInputDto.Username);
if (user == null)
{
throw new LinCmsException("用户不存在", ErrorCode.NotFound);
}
bool valid = await _userIdentityService.VerifyUserPasswordAsync(user.Id, loginInputDto.Password);
if (!valid)
{
throw new LinCmsException("请输入正确密码", ErrorCode.ParameterError);
}
await _userRepository.UpdateLastLoginTimeAsync(user.Id);
List <Claim> claims = new List <Claim>()
{
new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
new Claim(ClaimTypes.Email, user.Email ?? ""),
new Claim(ClaimTypes.GivenName, user.Nickname ?? ""),
new Claim(ClaimTypes.Name, user.Username ?? ""),
};
string token = _jsonWebTokenService.Encode(claims);
return(token);
}
public IActionResult Login(LoginInputDto input)
{
if (!CheckPwd(input))
{
return(Json(new ResultDto()
{
Message = "invalid username or password"
}));
}
var token = JwtHelper.GenerateJwtToken(options.Secret, new Dictionary <string, string>
{
{ "username", input.UserName },
{ "logintime", DateTime.Now.ToString() }
});
ResponseCookie.Add(new HttpCookie
{
Name = "authorization",
Value = token
});
return(Json(new ResultDto()
{
Success = true
}));
}
public async Task <LoginOutputDto> PostAsync(LoginInputDto input)
{
var result = await _signInManager.PasswordSignInAsync(input.Name, input.Password, false, true);
if (!result.Succeeded)
{
throw new BusinessException("Login Faild");
}
var user = await _userManager.FindByNameAsync(input.Name);
if (user != null)
{
if (user == null)
{
throw new BusinessException("Login Faild");
}
var roles = await _userManager.GetRolesAsync(user);
if (roles == null || roles.Count == 0)
{
throw new BusinessException("Login Faild");
}
var token = GenerateJwt(user, roles.ToList());
var loginOutputDto = ObjectMapper.Map <IdentityUser, LoginOutputDto>(user);
loginOutputDto.Token = token;
loginOutputDto.Expiration = DateTime.Now.AddHours(_jwtOptions.ExpirationTime);
return(loginOutputDto);
}
throw new BusinessException("Login Faild");
}
public async Task <StatusResult <string> > UserLogin(LoginInputDto dto)
{
var result = await _accountService.LoginAsync(dto);
#region 添加登录日志
#endregion
if (!result.IsSuccess)
{
return(new StatusResult <string>(result.Message));
}
// 生成 token
var accessToken = JWTEncryption.Encrypt(new Dictionary <string, object>()
{
{ ClaimConst.USERID, result.Data.Id }, // 存储Id
{ ClaimConst.USERNAME, result.Data.UserName }, // 存储用户名
{ ClaimConst.USERNICKNAME, result.Data.NickName },
{ ClaimConst.QINGSHANUSERISSUPER, result.Data.IsSuper },
});
return(new StatusResult <string>()
{
Data = "Bearer " + accessToken
});
}
public async Task <JObject> Login(LoginInputDto loginInputDto)
{
_logger.LogInformation("login");
string authority = $"{_configuration["Identity:Protocol"]}://{_configuration["Identity:IP"]}:{_configuration["Identity:Port"]}";
HttpClient client = new HttpClient();
TokenResponse response = await client.RequestTokenAsync(new TokenRequest
{
Address = authority + "/connect/token",
GrantType = GrantType.ResourceOwnerPassword,
ClientId = _configuration["Service:ClientId"],
ClientSecret = _configuration["Service:ClientSecrets"],
Parameters =
{
{ "UserName", loginInputDto.Username },
{ "Password", loginInputDto.Password }
}
});
if (response.IsError)
{
throw new LinCmsException(response.ErrorDescription);
}
return(response.Json);
}
public ActionResult <string> Get(LoginInputDto loginInputDto)
{
if (ModelState.IsValid)
{
if (loginInputDto.UserName == "lihonghui" && loginInputDto.Password == "123")
{
var claims = new Claim[]
{
new Claim(ClaimTypes.Name, "lihonghui"),
new Claim(ClaimTypes.Role, "admin")
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_jwtSettings.SecretKey));
var credit = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(_jwtSettings.Issuer, _jwtSettings.Audience, claims, null,
DateTime.UtcNow.AddMinutes(30), credit);
return(Ok(new
{
Token = new JwtSecurityTokenHandler().WriteToken(token)
}));
}
}
return(BadRequest());
}
public ActionResult Login(Models.Home.UIModel_Login model)
{
EcdrpSite ecdrpSite = EcdrpSite.Admin;
LoginEnum result = LoginEnum.Empty;
bool IsValid = false;
IBLL.IBase_UserManager u = new BLL.Base_UserManager();
if (!string.IsNullOrEmpty(model.CheckCode) && model.CheckCode.Equals(Session["ValidateCode"] ?? ""))
{
IsValid = true;
}
if (IsValid)
{
LoginInputDto input = new LoginInputDto(); //参数实体
input.UserName = model.accountName; //用户名
input.UserPwd = model.password; //密码
input.IP = HttpRequestHelper.GetIP(this.Request); //登录IP地址
input.Browser = HttpRequestHelper.GetBrowser(this.Request); //浏览器版本号
result = u.Login(input, out ecdrpSite);
//验证测试系统是否存在自动上传
//var obj = new ZiXin.ERP.PublicModels.PublicData().CheckAutoUpload();
//if (obj.Tag == -1)
//{//测试系统中存在自动上传功能
// result = -9;
//}
}
else
{
result = LoginEnum.CheckCodeErr; //验证码错误，返回9
}
return(Json(new { result = result, site = ecdrpSite.ToString(), par = System.Web.HttpUtility.UrlEncode(model.accountName) }));
}
/// <summary>
/// 根据名称和密码获取用户信息
/// </summary>
/// <param name="name"></param>
/// <param name="pwd"></param>
/// <returns></returns>
public UserDto CheckLogin(LoginInputDto inputDto)
{
SysUserEntity entity = _sysUserRepository.GetAll().Where(b => b.UserName.Equals(inputDto.Name) && b.Password.Equals(inputDto.Pwd)).FirstOrDefault();
UserDto dto = AutoMapper.Mapper.Map <UserDto>(entity);
return(dto);
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public async Task <StatusResult <AuthLoginOutputDto> > LoginAsync(LoginInputDto dto)
{
var user = await _userRepository
.Select
.Where(o => o.UserName == dto.Account).FirstAsync();
if (user == null)
{
return(new StatusResult <AuthLoginOutputDto>("账号或密码错误"));
}
if (user.Status != EAdministratorStatus.Normal)
{
return(new StatusResult <AuthLoginOutputDto>($"当前账号状态为：{user.Status.ToDescription()}"));
}
//前端小写加密 再用32位大写加密
if (user.Password != MySecurity.MD5(dto.Password))
{
return(new StatusResult <AuthLoginOutputDto>("账号或密码错误"));
}
var model = new AuthLoginOutputDto()
{
Id = user.Id,
NickName = user.NickName,
UserName = user.UserName,
IsSuper = user.IsSuper
};
return(new StatusResult <AuthLoginOutputDto>(model));
}
public ActionResult Login(LoginInputDto vm)
{
if (vm != null && !string.IsNullOrEmpty(vm.Account) &&
!string.IsNullOrEmpty(vm.Password) && !string.IsNullOrEmpty(vm.Random))
{
var userinfo = userService.Login(vm);
if (userinfo != null)
{
this.UserSession = new UserSessionDto()
{
UserId = userinfo.Id,
Account = userinfo.Account,
Name = userinfo.Name,
RoleId = userinfo.RoleId,
LoginTime = DateTime.Now
};
return(Success(true));
}
return(Failure());
}
return(Error());
}
public async Task <LoginOutputDto> Login(LoginInputDto loginInputDto)
{
var user = _defaultDbContext.MbpUsers.Where(u => u.LoginName == loginInputDto.LoginName).FirstOrDefault();
if (user != null)
{
if (user.Password != ApplicationHelper.EncryptPwdMd5(loginInputDto.Password))
{
return(new LoginOutputDto()
{
AccessToken = new Jwt(), IsPassPwdCheck = false
});
}
// 如果是管理员权限就给管理员属性,如果是用户就给用户属性,这里只定义两种角色,一种是超管,一种是普通用户,这里的角色只做身份鉴定,不做鉴权用,方便区分超管类的API和普通用户的API
// 安全级别较高的API需要超管的可以单独限定,其他按照全局授权策略来进行
// token会默认添加用户名和登录名,现在根据需要,在这里扩展更多的扩展信息,加入角色名称,用户Id
var token = await _jwtBearerService.CreateJwt(loginInputDto.LoginName, loginInputDto.ClientID, new List <Claim>()
{
new Claim(ClaimTypes.Role, user.IsAdmin?"admin":"user"), // 角色名称,这里的ClaimTypes.Role,可以用来约束基于角色的权限验证
new Claim(ClaimTypes.Sid, user.Id.ToString()) // 登录名
});
return(new LoginOutputDto()
{
AccessToken = token, Menus = new List <string>(), UserName = user.UserName, Role = user.IsAdmin ? "admin" : "user", IsPassPwdCheck = true
});
}
return(new LoginOutputDto()
{
AccessToken = new Jwt(), IsPassPwdCheck = false
});
}
public async Task <OperatorModel> CheckLoginAsync(LoginInputDto loginInput)
{
if (Md5.md5(loginInput.validCode, 16) != WebHelper.GetSession("ProjectManage_session_verifycode"))
{
throw new ProgramLogicException((new { message = "验证码不正确", errorCode = LoginResultType.loginFail }).ToJson());
}
var param = new List <SqlParameter>()
{
new SqlParameter("@AccountNo", loginInput.cardNo),
new SqlParameter("@AccountType", loginInput.accountType)
};
var loginEntity = (await commonRepository.FindListAsync <LoginOutputDto>("EXEC SP_Ly_Check_Login @AccountNo,@AccountType", param));
if (loginEntity == null || loginEntity.Count <= 0)
{
throw new ProgramLogicException((new { message = "该账号不存在，请重新输入", errorCode = LoginResultType.loginNotExist }).ToJson());
}
if (!loginEntity[0].isEnabled)
{
throw new ProgramLogicException((new { message = "该账号被锁住，请联系管理员", errorCode = LoginResultType.loginLocking }).ToJson());
}
string pwd = DESEncrypt.Encrypt(loginInput.cardPwd);
if (!loginEntity[0].accountPwd.Equals(pwd.ToUpper()))
{
throw new ProgramLogicException((new { message = "密码输入错误，请重新输入", errorCode = LoginResultType.loginFail }).ToJson());
}
return(loginEntity[0].ToModel <OperatorModel>());
}
/// <summary>
/// 多福-销售注册
/// </summary>
/// <param name="dto"></param>
/// <param name="workUser"></param>
/// <returns></returns>
public async Task <ReturnValueModel> Login(LoginInputDto dto, WorkUser workUser)
{
ReturnValueModel rvm = new ReturnValueModel
{
Success = true,
Msg = "",
Result = null
};
if (string.IsNullOrEmpty(workUser?.WxUser?.Id))
{
rvm.Success = false;
rvm.Msg = "Invalid WxUser";
rvm.Result = null;
return(rvm);
}
//匹配AD白名单
var whiteName = _rep.FirstOrDefault <BotADWhiteName>(s => s.IsDeleted != 1 && s.ADAccount == dto.UserName);
if (whiteName == null)
{
rvm.Success = false;
rvm.Msg = "您输入的账号无权限访问或账号密码不正确。";
rvm.Result = null;
LoggerHelper.WriteLogInfo("[CheckWhiteName]:错误------不在白名单");
return(rvm);
}
var verify = await GetVerifyApi(dto.UserName, dto?.Password);
if (verify.Success == false)
{
return(verify);
}
var user = _rep.FirstOrDefault <WxUserModel>(s => s.IsDeleted != 1 && s.Id == workUser.WxUser.Id);
if (user == null)
{
rvm.Success = false;
rvm.Msg = "获取用户信息失败！";
rvm.Result = null;
return(rvm);
}
user.UserName = dto.UserName;
user.IsSalesPerson = 2;//设置为内部员工
user.IsVerify = 1;
user.IsCompleteRegister = 1;
_rep.Update(user);
_rep.Insert(new DocTag
{
Id = Guid.NewGuid().ToString(),
CreateTime = DateTime.UtcNow.AddHours(8),
TagId = "3a8670c8-29e9-482a-bb54-53766b6babdb",//此处 固定内部员工标签 TagInfo id=9481d4a8-a259-474b-b912-2a61c9069a1d
});
_rep.SaveChanges();
return(rvm);
}
public HttpResponseMessage Login(HttpRequestMessage request, LoginInputDto loginDto)
{
return(CreateHttpResponse(request, () =>
{
MembershipContext loginResult = this._accountAppService.Login(loginDto);
return request.CreateResponse(HttpStatusCode.OK, new { success = loginResult.IsAuthenticated });
}));
}
public async Task <AjaxResult> LoginAsync([FromBody] LoginInputDto loginDto)
{
var result = await _identityContract.Login(loginDto);
var identity = new ClaimsIdentity(JwtBearerDefaults.AuthenticationScheme);//用户标识
identity.AddClaims(result.cliams);
return(result.item.ToAjaxResult());
}
public async Task <TokenOutputDto> CreateToken(LoginInputDto model)
{
var tokenModel = new TokenOutputDto()
{
HasVerifiedEmail = false
};
var user = await _userManager.FindByEmailAsync(model.Email);
if (user == null)
{
tokenModel.Errors = new string[] { "Not Found User" };
return(tokenModel);
}
//if (!_environment.IsDevelopment())
//{
// if (!user.EmailConfirmed)
// {
// tokenModel.Errors = new string[] { "No Email Confirmed" };
// return tokenModel;
// }
// if (user.LockoutEnabled)
// {
// tokenModel.Errors = new string[] { "This account has been locked." };
// return tokenModel;
// }
//}
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
tokenModel.HasVerifiedEmail = true;
tokenModel.UserId = user.Id;
tokenModel.UserName = user.UserName;
var roles = await _userManager.GetRolesAsync(user);
tokenModel.Roles = roles.ToList();
JwtSecurityToken jwtSecurityToken = await CreateJwtToken(user);
tokenModel.Token = new JwtSecurityTokenHandler().WriteToken(jwtSecurityToken);
tokenModel.RefreshToken = await _userManager.GetAuthenticationTokenAsync(user, "BBC", "RefreshToken");
if (String.IsNullOrEmpty(tokenModel.RefreshToken))
{
tokenModel.RefreshToken = await _userManager.GenerateUserTokenAsync(user, "BBC", "RefreshToken");
await _userManager.SetAuthenticationTokenAsync(user, "BBC", "RefreshToken", tokenModel.RefreshToken);
}
return(tokenModel);
}
tokenModel.Errors = new string[] { "Invalid login attempt." };
return(tokenModel);
}
/// <summary>
/// 登录
/// </summary>
/// <returns></returns>
public async Task <IActionResult> Login(LoginInputDto loginInputDto)
{
var result = await _accountQueryService.Login(loginInputDto.AccountName, loginInputDto.AccountName);
if (result.LoginType == LoginType.NotLoggedSuccessfully)
{
return(Json(result));
}
return(View());
}
public async Task Shuold_Login_Success()
{
var loginInfo = new LoginInputDto()
{
Name = "*****@*****.**", Password = "******"
};
var result = await _loginAppService.PostAsync(loginInfo);
result.Code.ShouldBe((int)DTOs.Public.ApiCodeEnum.成功);
}
public async Task <IActionResult> Post([FromBody] LoginInputDto input)
{
//if (!ModelState.IsValid)
//{
// return Ok()
//}
var result = await _userService.GetAsync(input.UserName, input.Password);
return(Ok(result));
}
public async Task <ActionResult> Authenticate(LoginInputDto inputDto)
{
var response = await _authService.Login(inputDto);
return(new ContentResult
{
ContentType = "application/json",
Content = JsonSerializer.Serialize(response),
StatusCode = (int)(response.Success ? HttpStatusCode.OK : HttpStatusCode.InternalServerError)
});
}
public async Task <IActionResult> Index()
{
var login = new LoginInputDto
{
Email = "*****@*****.**",
Password = "******"
};
var result = await _authenticationService.Login(login);
if (result.Success)
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, login.Email),
};
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
//AllowRefresh = <bool>,
// Refreshing the authentication session should be allowed.
ExpiresUtc = DateTimeOffset.UtcNow.AddDays(10),
// The time at which the authentication ticket expires. A
// value set here overrides the ExpireTimeSpan option of
// CookieAuthenticationOptions set with AddCookie.
IsPersistent = true,
// Whether the authentication session is persisted across
// multiple requests. When used with cookies, controls
// whether the cookie's lifetime is absolute (matching the
// lifetime of the authentication ticket) or session-based.
//IssuedUtc = <DateTimeOffset>,
// The time at which the authentication ticket was issued.
//RedirectUri = <string>
// The full path or absolute URI to be used as an http
// redirect response value.
};
HttpContext.Session.SetString("access_token", result.AccessToken.Token);
HttpContext.Session.SetString("refresh_token", result.RefreshToken);
await HttpContext.SignInAsync(
CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity),
authProperties);
}
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> Login([FromBody] LoginInputDto model)
{
var result = await _authService.CreateToken(model);
if (result.Errors != null)
{
return(BadRequest(result.Errors));
}
return(Ok(result));
}
public async Task <IActionResult> GetToken([FromBody] LoginInputDto loginUser)
{
var user = await dbContext.Users
.Include(u => u.Role)
.FirstOrDefaultAsync(u => u.Code == loginUser.UserCode && u.PassWord == Encrypt.Md5Encrypt(loginUser.PassWord));
if (user == null)
{
return(NotFound(Json(new { Error = "用户名或密码错误！" })));
}
return(Json(new { Token = CreatToken(user) }));
}
public JsonResult Login(LoginInputDto input, string returnUrl)
{
using (ResponseResult <AdminUserLoginInfo> result = new ResponseResult <AdminUserLoginInfo>())
{
input.Password = Server.HtmlDecode(input.Password);
var adminUser = this.authProvider.Authenticate(input);
//消除敏感数据
adminUser.User.Password = string.Empty;
result.Entity = adminUser;
return(new JsonResultEx(result));
}
}
public ICurrentUser Login(LoginInputDto input)
{
ValidationObject.Validate(string.IsNullOrWhiteSpace(input.LoginName), "登录名不能为空");
ValidationObject.Validate(string.IsNullOrWhiteSpace(input.Password), "密码不能为空");
var userDto = _userRepository.QueryableAsNoTracking.SingleOrDefault(t => t.LoginName == input.LoginName);
ValidationObject.Validate(userDto == null, "登录名不存在");
ValidationObject.Validate(userDto.PasswordHash != input.Password, "密码不正确");
var currentUser = Get(userDto.Id);
return(currentUser);
}
