public void Login()
{
var options = new DbContextOptionsBuilder <UsersDbContext>()
.UseInMemoryDatabase(databaseName: nameof(Login))
.Options;
using (var context = new UsersDbContext(options))
{
var userService = new UserService(context, config);
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "Gavrilut",
LastName = "Lucian",
Password = "******",
Username = "******"
};
userService.Register(added);
var loggedIn = new LoginPostModel
{
Username = "******",
Password = "******"
};
var result = userService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(result);
//Assert.AreEqual(7, result.Id);
Assert.AreEqual(loggedIn.Username, result.Username);
}
}
public JsonResult Login (LoginPostModel model)
{
var result = new LoginPostResult();
using(WebDbContext db = DbContextFactory.CreateDbContext())
{
Account acc =
db.Accounts.FirstOrDefault(a => a.UserName == model.UserName && a.Password == model.Password);
if(acc != null)
{
result.IsOk = true;
result.Credits = acc.Credits;
result.IsAuthorized = acc.IsAuthorized;
result.IsFrozen = acc.IsFrozen;
result.Level = acc.Level;
result.UserType = acc.UserType;
result.UserName = acc.UserName;
result.UserId = acc.Id;
acc.LoginCount += 1;
acc.LastLoginTime = DateTime.Now;
acc.LastLoginIp = HttpContext.Request.UserHostAddress;
acc.Token = TokenHelper.MakeToken();
result.Token = acc.Token;
db.SaveChanges();
} else
{
throw new HttpException("帐号或密码错误");
}
}
return new JsonResult {Data = result};
}
public async Task <ActionResult <string> > Login([FromBody] LoginPostModel model)
{
return(await Task.Run(() =>
{
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(configuration["JwtTokenSecret"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var claims = new[]
{
new Claim(ClaimTypes.Name, model.Username),
new Claim("BasicUser", string.Empty)
};
var token = new JwtSecurityToken(
issuer: "jwt-example.org",
audience: "jwt-example.org",
claims: claims,
expires: DateTime.Now.AddMinutes(30),
signingCredentials: creds
);
var tokenString = new JwtSecurityTokenHandler().WriteToken(token);
return Ok(tokenString);
}));
}
public void AuthenticateShouldLoginAUser()
{
var options = new DbContextOptionsBuilder <MoviesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser))
.Options;
using (var context = new MoviesDbContext(options))
{
var usersService = new UserService(context, config, registerValidator, roleValidator);
var added = new RegisterPostModel
{
FirstName = "alina",
LastName = "demian",
Username = "******",
Email = "*****@*****.**",
Password = "******"
};
var result = usersService.Register(added);
var authenticated = new LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authresult);
//Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
}
}
public async Task <IActionResult> Post(LoginPostModel postModel)
{
var otp = $"{new Random().Next(0, 9)}{new Random().Next(0, 9)}{new Random().Next(0, 9)}" +
$"{new Random().Next(0, 9)}{new Random().Next(0, 9)}{new Random().Next(0, 9)}";
using (var context = new AppContext())
{
var model = new LoginOtpModel()
{
PhoneNumber = postModel.PhoneNumber
};
if (context.LoginOtpModel.FirstOrDefault(x => x.PhoneNumber.Trim() == postModel.PhoneNumber.Trim()) != null)
{
context.LoginOtpModel.Remove(model);
await context.SaveChangesAsync();
}
model.Otp = otp;
model.Timestamp = DateTime.UtcNow;
context.LoginOtpModel.Add(model);
await context.SaveChangesAsync();
}
//SendSms(postModel.PhoneNumber, "OTP for Skybean GoSafe is " + otp);
otp = "123456";
return(Ok(otp));
}
public async Task <ActionResult> Login(LoginPostModel model)
{
var userManager = HttpContext.GetOwinContext().GetUserManager <EmployeeManager>();
var authManager = HttpContext.GetOwinContext().Authentication;
var user = await userManager.FindAsync(model.Username, model.Password);
ClaimsIdentity test = HttpContext.User.Identity as ClaimsIdentity;
if (user != null)
{
var ident = userManager.CreateIdentity(user,
DefaultAuthenticationTypes.ApplicationCookie);
ident.AddClaim(new Claim("Language", user.Language));
authManager.SignIn(new AuthenticationProperties {
IsPersistent = false
}, ident);
}
return(RedirectToAction("Index"));
}
public async Task <IActionResult> LoginMember(LoginPostModel loginPost)
{
Member IsLoginMember;
using (var httpClient = new HttpClient())
{
StringContent content = new StringContent(JsonConvert.SerializeObject(loginPost), Encoding.UTF8, "application/json");
using (var response = await httpClient.PostAsync("https://localhost:44309/api/Member", content))
{
string apiResponse = await response.Content.ReadAsStringAsync();
IsLoginMember = JsonConvert.DeserializeObject <Member>(apiResponse);
}
}
if (IsLoginMember != null)
{
var data = JsonConvert.SerializeObject(IsLoginMember);
HttpContext.Session.SetString("MemberLog", data);
return(RedirectToAction("Index", "Home"));
}
else
{
return(RedirectToAction("Index", "Login"));
}
}
public void AuthenticateShouldLogTheUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var usersService = new UsersService(context, config);
var added = new RegisterPostModel
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var result = usersService.Register(added);
var authenticate = new LoginPostModel
{
Username = "******",
Password = "******",
};
var authenticateresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authenticateresult);
Assert.AreEqual(1, authenticateresult.Id);
Assert.AreEqual(authenticate.Username, authenticateresult.Username);
}
}
public IActionResult Authenticate([FromBody]LoginPostModel login)
{
var user = _userService.Authenticate(login.Username, login.Password);
if (user == null)
return BadRequest(new { message = "Username or password is incorrect" });
return Ok(user);
}
public IActionResult Authenticate([FromBody] LoginPostModel login)
{
var user = _userService.Authenticate(login.Email, login.Password);
if (user == null)
{
return(BadRequest(new { message = "Email or password is incorrect" }));
}
return(Ok(user));
}
public IActionResult Post([FromBody] LoginPostModel loginPostModel)
{
if (loginPostModel.UserName == "xbh" && loginPostModel.Password == "123456")
{
var claims = new[]
{
new Claim(ClaimTypes.Name, loginPostModel.UserName),
new Claim(ClaimTypes.Expiration, DateTime.Now.AddDays(7).ToString())
};
return(Ok(JwtToken.BuildJwtToken(claims, _requirement)));
}
return(BadRequest("用户名密码错误"));
}
public async Task <ActionResult> SignIn(LoginPostModel model)
{
var ctx = HttpContext.GetOwinContext();
var userManager = ctx.GetUserManager <EmployeeManager>();
var auth = ctx.Authentication;
var user = await userManager.FindAsync(model.UserName, model.Password);
var identity = userManager.CreateIdentity(user, DefaultAuthenticationTypes.ApplicationCookie);
auth.SignIn(new Microsoft.Owin.Security.AuthenticationProperties
{
IsPersistent = false,
}, identity);
return(View("Index"));
}
public async Task <bool> AuthenticateClient(LoginPostModel cliente)
{
try
{
var content = JsonConvert.SerializeObject(cliente);
var response = await _client.PostAsync(URL_auth, new StringContent(content, Encoding.UTF8, "application/json"));
bool success = response.IsSuccessStatusCode;
App.AuthToken = JsonConvert.DeserializeObject <AuthToken>(response.Content.ReadAsStringAsync().Result); // set auth token
return(success);
}
catch (Exception ex)
{
throw ex;
}
}
public void AuthenticateShouldLogTheUser()
{
var options = new DbContextOptionsBuilder <ExpensesDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLogTheUser))
.Options;
using (var context = new ExpensesDbContext(options))
{
var registerValidator = new RegisterValidator();
var validator = new UserRoleValidator();
var user_userRoleService = new User_UserRoleService(validator, context);
UsersService usersService = new UsersService(context, registerValidator, config, user_userRoleService);
var userRole = new UserRole
{
Name = "Regular"
};
context.UserRoles.Add(userRole);
context.SaveChanges();
var added = new RegisterPostModel()
{
Email = "*****@*****.**",
FirstName = "User",
LastName = "Test",
Password = "******",
Username = "******"
};
var result = usersService.Register(added);
var authenticate = new LoginPostModel()
{
Username = added.Username,
Password = added.Password,
};
var authenticateresult = usersService.Authenticate(added.Username, added.Password);
Assert.IsNotNull(authenticateresult);
//var isNotRegistered = usersService.Authenticate("ABCD", "ABCDERF");
//Assert.IsNotNull(authenticateresult.Token);
//Assert.IsNotNull(isNotRegistered);
}
}
public ActionResult Login(LoginPostModel postModel)
{
if (!ModelState.IsValid)
{
return(View(postModel));
}
AuthenticationManager.SignOut("ApplicationCookie");
DOWTank.Core.Domain.TANK_usp_sel.TANK_usp_sel_Security_spResults userDetails = null;
if (_userManager.Athenticate(postModel.UserName, postModel.Password, ref userDetails))
{
var identity = _userManager.CreateIdentity(userDetails);
AuthenticationManager.SignIn(new AuthenticationProperties()
{
IsPersistent = false
}, identity);
return(RedirectToAction("Index", "Home"));
}
Error("User Name or Password is not valid, please try again.");
return(View(postModel));
}
public void AuthenticateShouldLoginAUser()
{
var options = new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser))
.Options;
using (var context = new AppDbContext(options))
{
var usersService = new UserService(context, config);
var result = usersService.Register(user);
var authenticated = new LoginPostModel
{
Username = "******",
Password = "******"
};
var authresult = usersService.Authenticate(user.Username, user.Password);
Assert.IsNotNull(authresult);
Assert.AreEqual(1, authresult.Id);
Assert.AreEqual(authenticated.Username, authresult.Username);
}
}
public LoginViewModel()
{
API = new ClienteAPIService();
Login = new LoginPostModel();
LabelVisible = false;
MessagingCenter.Subscribe <LoginPage>(this, "LoginClicked", async(page) =>
{
var success = await API.AuthenticateClient(Login);
// Login falhou
if (!success)
{
LabelVisible = true;
}
// Login bem sucedido
else
{
LabelVisible = false;
MainPage homePage = new MainPage();
App.Current.MainPage = homePage;
}
});
}
public async Task <IActionResult> LoginAsync(LoginPostModel model)
{
//ViewData["ReturnUrl"] = returnUrl;
if (!ModelState.IsValid)
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = MvcHelper.GetValidMsg(ModelState)
}));
}
#region 验证码
var serverCaptcha = (string)HttpContext.Session.GetString("CaptchaStr");
if (string.IsNullOrEmpty(serverCaptcha) || serverCaptcha.ToLower() != model.Captcha.ToLower())//不区分大小写，一律转换成小写再去比较
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = "验证码错误。"
}));
}
#endregion
//账号密码的验证
var ip = HttpContext.GetClientUserIp();
//账号密码
var user = _userSvc.Login(model.Account, model.Password, ip);
if (user == null)
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = "账号或密码错误。"
}));
}
//账号状态
if (user.IsLock)
{
return(Json(new AjaxResult {
Status = "error", ErrorMsg = "该账号未审核或已被锁定"
}));
}
var claims = new List <Claim>()
{
new Claim(ClaimTypes.Name, user.Name), //姓名
new Claim(ClaimTypes.MobilePhone, user.PhoneNum), //手机号
new Claim(ClaimTypes.Email, user.Email), //邮箱
new Claim(ClaimTypes.Role, user.RoleId.ToString()), //角色
new Claim("Id", user.Id.ToString()),
new Claim("SigninCount", user.SigninCount.ToString()),
new Claim("LastSigninTime", user.LastSigninTimeStr),
new Claim("LastSigninIP", user.LastSigninIP)
};
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity));
return(Json(new AjaxResult {
Status = "ok"
}));
}
private async Task <bool> HandleSocialLogin(IOwinEnvironment context, IClient client, LoginPostModel model,
CancellationToken cancellationToken)
{
if (string.IsNullOrEmpty(model.ProviderData.ProviderId))
{
return(await Error.Create(context, new BadRequest("No provider specified"), cancellationToken));
}
var application = await client.GetApplicationAsync(_configuration.Application.Href, cancellationToken);
var socialExecutor = new SocialExecutor(client, _configuration, _handlers, _logger);
try
{
IProviderAccountRequest providerRequest;
switch (model.ProviderData.ProviderId)
{
case "facebook":
{
providerRequest = client.Providers()
.Facebook()
.Account()
.SetAccessToken(model.ProviderData.AccessToken)
.Build();
break;
}
case "google":
{
providerRequest = client.Providers()
.Google()
.Account()
.SetCode(model.ProviderData.Code)
.Build();
break;
}
case "github":
{
providerRequest = client.Providers()
.Github()
.Account()
.SetAccessToken(model.ProviderData.AccessToken)
.Build();
break;
}
case "linkedin":
{
providerRequest = client.Providers()
.LinkedIn()
.Account()
.SetAccessToken(model.ProviderData.AccessToken)
.Build();
break;
}
default:
providerRequest = null;
break;
}
if (providerRequest == null)
{
return(await Error.Create(context,
new BadRequest($"Unknown provider '{model.ProviderData.ProviderId}'"), cancellationToken));
}
var loginResult =
await socialExecutor.LoginWithProviderRequestAsync(context, providerRequest, cancellationToken);
await socialExecutor.HandleLoginResultAsync(
context,
application,
loginResult,
cancellationToken);
var sanitizer = new AccountResponseSanitizer();
var responseModel = new
{
account = sanitizer.Sanitize(loginResult.Account)
};
return(await JsonResponse.Ok(context, responseModel));
}
catch (ResourceException rex)
{
// TODO improve error logging (include request id, etc)
_logger.Error(rex.DeveloperMessage, source: nameof(HandleSocialLogin));
return(await Error.Create(context, new BadRequest("An error occurred while processing the login"), cancellationToken));
}
catch (Exception ex)
{
_logger.Error(ex, source: nameof(HandleSocialLogin));
return(await Error.Create(context, new BadRequest("An error occurred while processing the login"), cancellationToken));
}
}
public ActionResult Login()
{
var model = new LoginPostModel();
return(View(model));
}
/// <summary>
/// 通过教务网 获取 用户信息
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
private async Task <UserInfoDTO> GetNatUserInfo(UserLoginRequest model)
{
var userInfo = new UserInfoDTO();
var postModel = new LoginPostModel()
{
__VIEWSTATE = System.Web.HttpUtility.UrlEncode(model.LoginViewState, HttpHelper.DefaultEncoding),
txtUserName = model.UserId,
TextBox2 = System.Web.HttpUtility.UrlEncode(model.Password, HttpHelper.DefaultEncoding),
txtSecretCode = model.ValidateCode
};
var dic = ModelHelper.ObjectToMap <LoginPostModel>(postModel);
try
{
var response = await HttpHelper.CreatePostHttpResponse(model.LoginUrl, dic);
if (!response.ResponseUri.ToString().Contains("xs_main"))
{
throw new ArgumentNullException("用户名或密码有误");
}
var str = await response.GetResponseString();
var doc = new HtmlDocument();
doc.LoadHtml(str);
string name = doc.GetElementbyId("xhxm").InnerText.Replace("同学", "");
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("服务异常，稍后在尝试");
}
UserName = name;
// 课表url
string kbUrl =
$"{model.PreUrl}/xskbcx.aspx?xh={model.UserId}&xm={System.Web.HttpUtility.UrlEncode(UserName, HttpHelper.DefaultEncoding)}&gnmkdm=N121602";
var kbResponse =
await HttpHelper.CreateHttpResponse(kbUrl, $"{model.PreUrl}/xs_main.aspx?xh={model.UserId}");
var kbStr = await kbResponse.GetResponseString();
doc.LoadHtml(kbStr);
string college = doc.GetElementbyId("Label7").InnerText;
string majorName = doc.GetElementbyId("Label8").InnerText;
string className = doc.GetElementbyId("Label9").InnerText;
userInfo.College = college.Substring(college.LastIndexOf('：') + 1);
userInfo.MajorName = majorName.Substring(majorName.LastIndexOf('：') + 1);
userInfo.ClassName = className.Substring(className.LastIndexOf('：') + 1);
userInfo.RealUserName = UserName;
userInfo.UserId = model.UserId;
userInfo.LoginUserName = model.LoginUserName;
try
{
// MQ 同步到志愿管理服务 中
SchoolUser.PushMessage("school", new
{
UserName = userInfo.LoginUserName,
SchoolUserName = userInfo.RealUserName,
UserId = userInfo.UserId
});
userInfo.IsSynchronization = true;
Logger.LogInformation("MQ发送消息成功");
}
catch (Exception e)
{
userInfo.IsSynchronization = false;
Logger.LogError(e, "MQ 发送消息失败");
}
var addResult = await UserManagerRepository.AddUserInfo(userInfo);
if (addResult == false)
{
throw new ArgumentNullException("同步本地数据失败");
}
return(userInfo);
}
catch (Exception e)
{
if (e is NetworkInformationException)
{
throw new ArgumentNullException("服务器忙，稍后再试");
}
else
{
throw e;
}
}
}
public Member Post(LoginPostModel model)
{
return(_memberService.Get(x => x.Username == model.Username && x.Password == model.Password));
}
