public async Task<ActionResult> Login(LoginModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var blogContext = new BlogContext();
var user = await blogContext.Users.Find(x => x.Email == model.Email).SingleOrDefaultAsync();
if (user == null)
{
ModelState.AddModelError("Email", "Email address has not been registered.");
return View(model);
}
var identity = new ClaimsIdentity(new[] {
new Claim(ClaimTypes.Name, user.Name),
new Claim(ClaimTypes.Email, user.Email)
}, "ApplicationCookie");
var context = Request.GetOwinContext();
var authManager = context.Authentication;
authManager.SignIn(identity);
return Redirect(GetRedirectUrl(model.ReturnUrl));
}
public ActionResult Index(LoginModel model)
{
var displaydeps = db.Departments.Where(s => s.DepartmentCode != null).ToList();
IEnumerable<SelectListItem> selectList = from s in displaydeps
select new SelectListItem
{
Text = s.DepartmentCode + " - " + s.Name,
Value = s.DepartmentCode
};
ViewBag.DisplayDepartments = new SelectList(selectList, "Text" , "Value");
if (ModelState.IsValid)
{
if (DataAccessLayer.UserIsValid(model.DisplayDepartments, model.Password))
{
string selectedDepartment = model.DisplayDepartments;
Session["department"] = selectedDepartment;
FormsAuthentication.SetAuthCookie(model.DisplayDepartments, false); //set to false: cookie is destroyed when browser is closed - user will have to login in again if browser is closed
return RedirectToAction("index", "AddRequest", selectedDepartment); //page is redirected to the page 'index' which has the controller 'home'
}
{
ModelState.AddModelError("", "Invalid password");
}
}
return View();
}
public ActionResult LogOn(LoginModel employee)
{
if (ModelState.IsValid)
{
Employee user = _LoginService.Login(new Employee { EmployeeName = employee.UserName, Password = employee.Password });
if (user != null)
{
if (!_LoginService.IpAccess_Check(user))
{
ViewBag.LoginFailed = "ip验证错误";
ViewBag.isload = false;
return View("Index");
}
user.Sid = AppData.CreateRandomCode(24);//登录成功，写入24为随机字符，用于比对是否重读登录
DateTime loginDate=DateTime.Now;
user.LoginDate = loginDate.Date;
user.LoginTime = loginDate.Subtract(user.LoginDate.Value);
_LoginService.Update(user);
_LoginService.Commit();
FormsAuthentication.SetAuthCookie(user.Rank + "," + user.EmployeeName + "," + user.Sid, true);
return RedirectToAction("Index", "SPBG", new { area = "SPBG" });
}
ViewBag.LoginFailed = "帳號或密碼錯誤";
}
ViewBag.isload = false;
return View("Index");
}
public ActionResult Login(LoginModel login)
{
if (ModelState.IsValid)
{
var user = new AuthRepository().Login(login.Username, login.Password);
if (user != null)
{
// Create ticket
var ticket = new FormsAuthenticationTicket(1, login.Username,
DateTime.Now, DateTime.Now.AddMinutes(2880),
false,
Enum.GetName(typeof(Role), user.Position),
FormsAuthentication.FormsCookiePath);
// Encode ticket
string hash = FormsAuthentication.Encrypt(ticket);
var cookie = new HttpCookie(FormsAuthentication.FormsCookieName, hash);
if (ticket.IsPersistent)
{
cookie.Expires = ticket.Expiration;
}
//Save ticket in coockie
Response.Cookies.Add(cookie);
if (user.Position == Role.User)
return RedirectToAction("UserPage", "Profile");
if (user.Position == Role.Restaurateur)
return RedirectToAction("RestaurateurPage", "Profile");
}
}
return View(login);
}
public LoginState()
: base()
{
m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>();
m_Login = ServiceRegistry.GetService<LoginModel>();
m_Input = ServiceRegistry.GetService<InputManager>();
}
public UserModel GetUser(LoginModel model)
{
User user = null;
if (model.provider == Provider.Twitter)
{
user = repository.AsQueryable<User>().FirstOrDefault(x => x.TwitterSecret == model.Secret && x.TwitterToken == model.Token) ?? new User();
user.TwitterToken = model.Token;
user.TwitterSecret = model.Secret;
user.TwitterEnabled = true;
repository.Save(user);
}
else if (model.provider == Provider.Facebook)
{
user = repository.AsQueryable<User>().FirstOrDefault(x => x.FacebookId == model.ExternalId) ?? new User();
user.FacebookId = model.ExternalId;
user.FacebookToken = model.Token;
user.FacebookEnabled = true;
repository.Save(user);
}
repository.Commit();
var response = new UserModel()
{
UserId = user.Id,
IsFacebookEnabled = user.FacebookEnabled,
IsTwitterEnabled = user.TwitterEnabled
};
return response;
}
public ViewResult Index(string Name, string Email, string Password)
{
try
{
UserRepository userRep = new UserRepository();
Expression<Func<t_user, bool>> filter =
x => (x.mail == Email && Email != null);
List<t_user> users = userRep.Get(filter).ToList();
LoginModel model = new LoginModel();
if (users.Count > 0)
{
return View(model);
}
else
{
t_user newUser = new t_user();
newUser.name = Name;
newUser.mail = Email;
newUser.password = Password;
newUser.roleID = 2;
userRep.Save(newUser);
model.Name = Name;
model.Email = Email;
model.Password = Password;
}
return View(model);
}
catch (Exception)
{
return null;
}
}
public ActionResult Login(LoginModel model)
{
if (ModelState.IsValid)
{
Account account = accountRepository.HaalAccountOp(model.Naam, model.Wachtwoord);
if (account != null)
{
FormsAuthentication.SetAuthCookie(account.Wachtwoord, false);
//account onthouden
Session["loggedIn_account"] = account;
//
return RedirectToAction("index", "Contact");
}
else
{
//
}
}
else
{
ModelState.AddModelError("login_error", "naam of wachtwoord incorrect");
}
return View(model);
}
public TwitterUser GetUser(LoginModel model)
{
var twitterService = new TweetSharp.TwitterService(ConsumerKey, ConsumerSecret);
twitterService.AuthenticateWith(model.Token, model.Secret);
TwitterUser user = twitterService.VerifyCredentials(new VerifyCredentialsOptions() { IncludeEntities = false, SkipStatus = false });
return user;
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var result = this._userService.Authenticate(model.UserName, model.Password);
if (ModelState.Process(result))
{
var user = result.Entity;
_authenticationService.SignIn(user, model.RememberMe);
if (_userService.IsPasswordExpired(model.UserName))
{
return RedirectToAction("ChangePassword", "Account");
}
new MembershipEvent(MembershipEventCode.UserLogin, user).Raise();
if (Url.IsLocalUrl(model.ReturnUrl))
{
return Redirect(model.ReturnUrl);
}
return RedirectToAction("Index", "Home");
}
ModelState.AddModelError("", "Invalid Username or Password");
}
return View(model);
}
public ActionResult Login(LoginModel model)
{
using (var db = new ReqcyclerEntities())
{
var tmpUser = (db.Usuario
.Where(u => u.email == model.LoginMail)
.FirstOrDefault()) as Usuario;
if (tmpUser != null)
{
var numProjetos = (from pu in db.ProjetoUsuario
join p in db.Projeto on pu.projetoId equals p.id
where pu.usuarioId == tmpUser.id
select pu).ToList().Count();
Session["UsuarioLogadoID"] = tmpUser.id;
Session["UsuarioLogado"] = ((Usuario)tmpUser).nome;
Session["NumProjetos"] = (Int32)numProjetos;
return RedirectToAction("Index", "Home");
}
else
{
return RedirectToAction("Index", "Login");
}
}
}
public async Task<ActionResult> Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
ApplicationUser user = await UserManager.FindAsync(model.Email, model.Password);
if (user == null)
{
ModelState.AddModelError("", "Неверный логин или пароль.");
}
else
{
ClaimsIdentity claim = await UserManager.CreateIdentityAsync(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
if (String.IsNullOrEmpty(returnUrl))
return RedirectToAction("Index", "Account");
return Redirect(returnUrl);
}
}
ViewBag.returnUrl = returnUrl;
return View(model);
}
/// <summary>
/// 用户登录
/// </summary>
/// <param name="model">登录模型信息</param>
/// <returns>业务操作结果</returns>
public OperationResult Login(LoginModel model)
{
Validator.ValidateObject(model, new ValidationContext(model));
LoginInfo2 loginInfo = new LoginInfo2
{
Access = model.Account,
Password = model.Password,
};
OperationResult result = base.Login(loginInfo);
if (result.ResultType == OperationResultType.Success)
{
User user = (User)result.AppendData;
List<UserGroup> usergroups =user.UserGroups.ToList();
List<Res> reses = new List<Res>();
List<Mdl> mdls = new List<Mdl>();
foreach (var a in usergroups)
{
reses.AddRange(a.Ress);
mdls.AddRange(a.Mdls);
}
if (reses.SingleOrDefault(r=>r.RESCODE==model.ResCode)==null)
{
result.ResultType = OperationResultType.Error;
result.Message = "用户没有该资源的权限";
}
result.AppendData = mdls;
}
return result;
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (Membership.ValidateUser(model.UserName, model.Password))
{
FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "Home");
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public OperationResult Login(LoginModel model)
{
var operationResult = new OperationResult(OperationResultType.Error);
Validator.ValidateObject(model, new ValidationContext(model));
User user = UserFormService.Users().SingleOrDefault(m => m.usercode == model.Account);
if (user == null)
{
operationResult.Message = Properties.Resources.FrmLogin_Login_UserNotExist;
return operationResult;
}
if (user.userpwd != model.Password)
{
operationResult.Message = Properties.Resources.FrmLogin_Login_PasswordError;
return operationResult;
}
var usergroups = user.UserGroups.ToList();
var reses = new List<Res>();
var mdls = new List<Mdl>();
foreach (var a in usergroups)
{
reses.AddRange(a.Ress);
mdls.AddRange(a.Mdls);
}
if (reses.SingleOrDefault(r => r.RESCODE == model.ResCode) == null)
{
operationResult.Message = Properties.Resources.FrmLogin_Login_UserNotRes;
return operationResult;
}
operationResult.ResultType=OperationResultType.Success;
operationResult.AppendData = mdls;
operationResult.Message = Properties.Resources.FrmLogin_Login_LoginSuccess;
return operationResult;
}
public ViewResult Login()
{
LoginModel model = new LoginModel();
model.Realm = AuthenticationUtility.GetApplicationUri(HttpContext.Request);
model.Namespace = CloudConfigurationManager.GetSetting("AcsNamespace");
return View(model);
}
public override void ViewDidLoad()
{
base.ViewDidLoad ();
this.ForgotPassword.TouchUpInside += (object sender, EventArgs e) => {
var board = UIStoryboard.FromName ("MainStoryboard", null);
var password = (ForgotPasswordController)board.InstantiateViewController ("forgotpassword");
this.NavigationController.PushViewController(password, true);
};
this.Login.TouchUpInside += (object sender, EventArgs e) => {
//((UIWindow)UIApplication.SharedApplication.Delegate.Window).RootViewController =
// new MainTabController();
var request = new RestRequest();
var model = new LoginModel { Email = this.Email.Text, Password = this.Password.Text, RememberMe = true };
request.Send(RequestConfig.Login, "POST", model);
request.RequestFinished += (object send, RequestEndedArgs ev) => {
var jsonId = (int)JsonConvert.DeserializeObject (ev.Result, typeof(int));
InvokeOnMainThread (delegate {
AppDelegate.SaveProfileId(jsonId);
var tabbar = new MainTabController();
UIApplication.SharedApplication.Delegate.Window.RootViewController = tabbar;
});
};
};
}
internal static string GetUserRedirect(LoginModel model)
{
WebMatrix.WebData.SimpleRoleProvider roleProvider = new WebMatrix.WebData.SimpleRoleProvider();
string redirect_url = "";
string[] roles = roleProvider.GetRolesForUser(model.UserName);
foreach (string role in roles)
{
switch (role.ToLower())
{
case "administrator":
redirect_url = "Admin/Dashboard";
break;
case "customer" :
redirect_url = "Site/Dashboard";
break;
default :
redirect_url = "Site/Dashboard";
break;
}
}
return redirect_url;
}
public async Task<ActionResult> Login(LoginModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
var user = await _applicationService.GetCandidateByEmailAsync(model.Email);
if (user == null)
{
AddWrongEmailPasswordError();
return View(model);
}
var hashPassword = _applicationService.GenerateHashPassword(model.Password, user);
if (hashPassword == user.Password)
{
var identity = _authenticationService.CreateCandidateIdentity(user);
_authenticationService.SignIn(identity, Request);
if (user.HasSkills())
{
return Redirect(GetRedirectUrl(model.ReturnUrl));
}
return RedirectToAction("Index", "CandidateProfile");
}
AddWrongEmailPasswordError();
return View(model);
}
public async Task<ActionResult> Login(LoginModel model)
{
if (!ModelState.IsValid)
{
return View();
}
var authProxy = new AuthenticationProxy(WebConfigurationManager.AppSettings["WebApiUrl"], "/api/oauth");
var token = await authProxy.Login(model.UserName, model.Password);
if (token == null)
{
ModelState.AddModelError("password", "Wachtwoord of gebruikersnaam is onjuist");
return View();
}
var tokenCookie = new HttpCookie("token", token.Value)
{
Expires = DateTime.Now.AddMinutes(token.ExpiresIn),
HttpOnly = false
};
var roleCookie = new HttpCookie("role", token.Role)
{
Expires = DateTime.Now.AddMinutes(token.ExpiresIn),
HttpOnly = true
};
Response.Cookies.Add(tokenCookie);
Response.Cookies.Add(roleCookie);
return RedirectToAction("Index", "Dashboard");
}
public async void Post_WhenHeaderIsModifiedOnServer_ShouldReturnModifiedHeader()
{
var loginModel = new LoginModel("Test", "Test", "http://localhost:55399/api/test");
var response = await this.Client.PostAsync("http://localhost:55399/api/test/login", new StringContent(JsonConvert.SerializeObject(loginModel), Encoding.UTF8, "application/json"));
Console.Write(await response.ToTestString());
Assert.AreEqual(loginModel.ReturnUrl, response.Headers.Location.ToString());
}
public ActionResult Login(string returnUrl)
{
var model = new LoginModel
{
ReturnUrl = returnUrl
};
return View(model);
}
public HttpResponseMessage PostLogin(LoginModel model)
{
if (loginCommon.Login(ModelState, model))
{
return Request.CreateResponse(HttpStatusCode.OK);
}
return Request.CreateResponse(HttpStatusCode.BadRequest);
}
public ActionResult OpenId(LoginModel model)
{
Identifier id;
if (Identifier.TryParse(model.OpenID_Identifier, out id))
{
try
{
model.Config = _services.Config.Current;
var openId = new OpenIdRelyingParty();
returnToUrl = new Uri(Url.Action("OpenIdCallback", "Authentication", new { ReturnUrl = model.ReturnUrl }, Request.Url.Scheme), UriKind.Absolute);
// hack for google oauth2
if (model.OpenID_Identifier.Contains("google"))
{
client = new GoogleOAuth2Client(model.Config.ClientId, model.Config.ClientSecret);
client.RequestAuthentication(this.HttpContext, returnToUrl);
GoogleOAuth2Client.RewriteRequest();
return Redirect(returnToUrl.ToString());
}
else
{
var request = openId.CreateRequest(id, Realm.AutoDetect, returnToUrl);
// add request for name and email using sreg (OpenID Simple Registration
// Extension)
request.AddExtension(new ClaimsRequest
{
Email = DemandLevel.Require,
FullName = DemandLevel.Require,
Nickname = DemandLevel.Require
});
// also add AX request
var axRequest = new FetchRequest();
axRequest.Attributes.AddRequired(WellKnownAttributes.Name.FullName);
axRequest.Attributes.AddRequired(WellKnownAttributes.Name.First);
axRequest.Attributes.AddRequired(WellKnownAttributes.Name.Last);
axRequest.Attributes.AddRequired(WellKnownAttributes.Contact.Email);
request.AddExtension(axRequest);
var redirectingResponse = request.RedirectingResponse;
return redirectingResponse.AsActionResult();
}
}
catch (ProtocolException ex)
{
model.Message = ex.Message;
return View("Login", model);
}
}
else
{
model.Message = "Invalid identifier";
return View("Login", model);
}
}
private User VerifyUser(LoginModel model)
{
// TODO: Lets abstract this away later so we dont need to think about partitionkey and rowkey here
var user = _users.Get(model.Email, "Manual");
if (user == null)
return null;
return _saltedHash.VerifyHashString(model.Password, user.Value.HashAndSalt)
? user.Value
: null;
}
public ActionResult Login(LoginModel model, string returnUrl)
{
//if (ModelState.IsValid && WebSecurity.Login(model.UserName, model.Password, persistCookie: model.RememberMe))
//{
// return RedirectToLocal(returnUrl);
//}
//// 如果我们进行到这一步时某个地方出错，则重新显示表单
//ModelState.AddModelError("", "提供的用户名或密码不正确。");
return View(model);
}
public ActionResult LogIn(LoginModel model)
{
var user = _userService.Authorize(model.Email, model.Password);
if (user == null)
{
ViewBag.Message = "Tên đăng nhập hoặc mật khẩu không đúng.";
return View();
}
SessionContext.setUser(user);
return RedirectToAction("Index", "Management");
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid && WebSecurity.Login(model.UserName, model.Password, persistCookie: model.RememberMe))
{
return RedirectToLocal(returnUrl);
}
// If we got this far, something failed, redisplay form
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return View(model);
}
public override void Intitialize()
{
base.Intitialize();
m_UserInterface = ServiceRegistry.GetService<UserInterfaceService>();
m_Login = ServiceRegistry.GetService<LoginModel>();
m_Gump = (LoggingInGump)m_UserInterface.AddControl(new LoggingInGump(), 0, 0);
m_Gump.OnCancelLogin += OnCancelLogin;
m_Login.Client.Disconnect();
}
/// <summary>
/// クッキーの妥当性の確認を行います。
/// </summary>
private static bool ValidateCookie(LoginModel loginModel,
CookieContainer cc)
{
var validator = loginModel.CookieValidator;
if (validator == null)
{
return true;
}
return validator(cc);
}
private void btnSave_Click(object sender, EventArgs e)
{
Cursor = Cursors.WaitCursor;
try
{
if (validate())
{
LoginBAL _objBAL = new LoginBAL();
LoginModel _objModel = new LoginModel();
_objModel._LoginID = selecteRecordId;
_objModel._Username = tbxUsername.Text;
_objModel._Password = tbxPassword.Text;
_objModel._EmailAddress = tbxEmail.Text;
_objModel._ModifiedDate = DateTime.Now;
_objModel._UserRole = Convert.ToInt32(cmbRole.SelectedIndex);
if (selecteRecordId == 0)
{
_objBAL.SaveUser(_objModel);
}
else
{
_objBAL.UpdateUser(_objModel);
}
MakeEmpty();
MessageBox.Show("Record Saved Successfully!");
FillGrid();
}
}
catch
{ }
finally
{
Cursor = Cursors.Default;
}
}
public ResponseModel Login(string request)
{
LoginModel requestModel = JsonConvert.DeserializeObject <LoginModel>(request);
brokenRules = new StringBuilder();
ResponseModel result = new ResponseModel();
var nulCheck = checkEmailandPasswordControl(requestModel.Email, requestModel.Sifre);
if (nulCheck)
{
result.Message = brokenRules.ToString();
result.Status = false;
result.Data = null;
return(result);
}
KullaniciDTO user = GetUser(requestModel.Email, requestModel.Sifre);
if (user.Email != null && user.Id > 0)
{
var messageAsJson = JsonConvert.SerializeObject(user);
result.Message = brokenRules.AppendLine("Kullanıcı başarılı bir şekilde giriş yaptı.").ToString();
result.Status = true;
result.Data = messageAsJson;
return(result);
}
result.Message = brokenRules.AppendLine("Kullanıcı bulunamadı.").ToString();
result.Status = false;
result.Data = null;
return(result);
}
public async Task <ActionResult> Login(LoginModel model, string returnUrl)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// To enable password failures to trigger account lockout, change to shouldLockout: true
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, true, true);
switch (result)
{
case SignInStatus.Success:
return(RedirectToAction(returnUrl));
case SignInStatus.LockedOut:
return(View("Lockout"));
case SignInStatus.Failure:
default:
ModelState.AddModelError("", "Invalid login attempt.");
return(View(model));
}
}
public BackResult Login([FromBody] LoginModel loginModel)
{
_logger.LogInformation($"{loginModel.UserName} login！");
if (loginModel.UserName == "gsw" && loginModel.Password == "111111")
{
var claims = new Claim[] {
new Claim(ClaimTypes.Name, "gsw"),
new Claim(ClaimTypes.Role, "admin"),
};
var token = _tokenBuilder.BuildJwtToken(claims);
_logger.LogInformation($"{loginModel.UserName} login success，and generate token return");
return(new BackResult {
Result = true, Data = token
});
}
else
{
_logger.LogInformation($"{loginModel.UserName} login faile");
return(new BackResult
{
Result = false
});
}
}
public HttpResponseMessage verifyOTP([FromBody] LoginModel loginm)
{
var result = objAuthorization.checkOTP(loginm);
if (result == true)
{
resp = Request.CreateResponse <ResponseModel>(HttpStatusCode.OK, new ResponseModel()
{
message = "OTP Verified successfully", output = dt2, statuscode = Convert.ToInt16(HttpStatusCode.OK)
});
return(resp);
}
else
{
resp = Request.CreateResponse <ResponseModel>(
HttpStatusCode.OK,
new ResponseModel()
{
message = "Incorrect otp", output = dt2, statuscode = Convert.ToInt16(HttpStatusCode.OK)
}
);
}
return(resp);
}
public async Task <IActionResult> Login(LoginModel model)
{
model.ReturnUrl = model.ReturnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, isPersistent : false, lockoutOnFailure : false);
if (result.Succeeded)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (!string.IsNullOrWhiteSpace(model.ReturnUrl))
{
return(LocalRedirect(model.ReturnUrl));
}
}
if (result.RequiresTwoFactor)
{
return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = model.ReturnUrl, RememberMe = model.RememberMe }));
}
if (result.IsLockedOut)
{
// _logger.LogWarning("User account locked out.");
return(RedirectToPage("./Lockout"));
}
else
{
ModelState.AddModelError(string.Empty, "Invalid login attempt.");
return(View(model));
}
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> Login(LoginModel loginModel)
{
var userFromRepo = await _repo.Login(loginModel.Username, loginModel.Password).ConfigureAwait(false);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.UserId.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.UserName)
};
var key = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
return(Ok(new
{
token = tokenHandler.WriteToken(token)
}));
}
public async Task <IActionResult> Login(LoginModel loginModel)
{
if (ModelState.IsValid)
{
await _signInManager.SignOutAsync();
UserApp appUser = await _userManager.FindByEmailAsync(loginModel.Email);
if (appUser != null)
{
await _signInManager.PasswordSignInAsync(appUser, loginModel.Password, true, true);
//string User = appUser.UserName;
//HttpContext.Session.SetString("UserName", User);
//HttpContext.Session.SetString("Id", appUser.Id);
return(RedirectToAction("Index", "Home"));
}
}
return(View());
}
public async Task <IActionResult> Login([FromBody] LoginModel model)
{
var user = await _userManager.FindByNameAsync(model.Email);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
{
var userRoles = await _userManager.GetRolesAsync(user);
List <Claim> authClaims = JwtUtils.GetClaims(user, userRoles);
var jwtSecret = _configuration["JWT:Secret"];
var minutesExpiration = JwtUtils.MinutesExpiration;
user = _userRepo.GetById(user.Id);//load the user record againg
return(CreatedAtAction(
nameof(Login),
new
{
jwt = JwtUtils.GenerateJwtToken(jwtSecret, authClaims, minutesExpiration),
refresh_token = JwtUtils.GenerateRefreshToken(user, _userRepo).Token
}));
}
return(Unauthorized());
}
public async Task LoginInvalidNonExistantActiveDirectoryAsync()
{
_authController.Request = CreateRequestMessage(LOGIN_ENDPOINT, null, false, false);
Settings.Current.EnableActiveDirectoryAuth = true;
// create model
var loginModel = new LoginModel {
Email = TestDomainLoginProvider.ValidUsername + ".au",
Password = "******"
};
var actionResult = await _authController.LoginAsync(loginModel);
var result = await actionResult.ExecuteAsync(new CancellationToken());
Assert.Equal(System.Net.HttpStatusCode.Unauthorized, result.StatusCode);
// Verify that a user account was not added
var provider = new TestDomainLoginProvider();
string email = provider.GetEmailAddressFromUsername(TestDomainLoginProvider.ValidUsername);
var user = await _userRepository.GetByEmailAddressAsync(email + ".au");
Assert.Null(user);
}
public async Task LoginValidExistingActiveDirectoryAsync()
{
_authController.Request = CreateRequestMessage(LOGIN_ENDPOINT, null, false, false);
Settings.Current.EnableActiveDirectoryAuth = true;
// add user
var provider = new TestDomainLoginProvider();
string email = provider.GetEmailAddressFromUsername(TestDomainLoginProvider.ValidUsername);
var user = new User {
EmailAddress = email,
IsEmailAddressVerified = true,
FullName = "User 6"
};
await _userRepository.AddAsync(user);
await _configuration.Client.RefreshAsync();
// create model
var loginModel = new LoginModel {
Email = email,
Password = TestDomainLoginProvider.ValidPassword
};
var actionResult = await _authController.LoginAsync(loginModel);
var result = await actionResult.ExecuteAsync(new CancellationToken());
Assert.True(result.IsSuccessStatusCode, "Status Code is failure.");
Assert.Equal(System.Net.HttpStatusCode.OK, result.StatusCode);
var tokenResult = GetResult <TokenResult>(result);
Assert.NotNull(tokenResult);
Assert.False(string.IsNullOrEmpty(tokenResult.Token));
}
public async Task <IActionResult> Login(LoginModel details, string returnUrl)
{
if (ModelState.IsValid)
{
AppUser user = await userManager.FindByEmailAsync(details.Email);
if (user != null)
{
await signInManager.SignOutAsync();
Microsoft.AspNetCore.Identity.SignInResult result =
await signInManager.PasswordSignInAsync(
user, details.Password, false, false);
if (result.Succeeded)
{
return(Redirect(returnUrl ?? "/"));
}
}
ModelState.AddModelError(nameof(LoginModel.Email),
"Invalid user or password");
}
return(View(details));
}
public async Task <IActionResult> LogIn(LoginModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest("Enter all Required fields"));
}
var user = _userManager.Users.FirstOrDefault(e => e.PatientSsn == model.PatientSSN);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password)) // valid user //
{
var role = await _userManager.GetRolesAsync(user);
var options = new IdentityOptions();
var secretKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("superSecretKey@345"));
var signinCredentials = new SigningCredentials(secretKey, SecurityAlgorithms.HmacSha256);
var tokeOptions = new JwtSecurityToken(
issuer: "http://localhost:4200",
audience: "http://localhost:4200",
claims: new List <Claim>()
{
new Claim(options.ClaimsIdentity.RoleClaimType, role.FirstOrDefault())
},
expires: DateTime.Now.AddDays(1),
signingCredentials: signinCredentials
);
var tokenString = new JwtSecurityTokenHandler().WriteToken(tokeOptions);
return(Ok(new { Token = tokenString, UserId = user.Id }));
}
return(BadRequest(new { message = "patientSSN or password is incorrect." }));
}
public async Task <IActionResult> Login(LoginModel loginModel)
{
if (ModelState.IsValid)
{
// Efetuando a busca do usuário pelo nome/login
IdentityUser user =
await userManager.FindByNameAsync(loginModel.Name);
if (user != null)
{
// Garante que o usuário não logara mais de uma vez
await signInManager.SignOutAsync();
// Checagem de senha
if ((await signInManager.PasswordSignInAsync(user, loginModel.Password, false, false)).Succeeded)
{
return(Redirect(loginModel?.ReturnUrl ?? "/Admin/Index"));
}
}
}
ModelState.AddModelError("", "Usuário ou Senha inválidos");
return(View(loginModel));
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (Membership.ValidateUser(model.UserName, model.Password))
{
FormsAuthentication.SetAuthCookie(model.UserName, model.RememberMe);
if (Url.IsLocalUrl(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
return(View(model));
}
public async Task <ActionResult> SignIn(LoginModel userModel)
{
// Model Validation
if (ModelState.IsValid)
{
var user = await _accountService.FindUserByEmail(userModel.Email);
if (user == null)
{
ModelState.AddModelError("Email", "Email doesn't exist");
return(View(userModel));
}
string pass = Crypto.Hash(userModel.Password);
if (String.Compare(pass, user.Password, StringComparison.Ordinal) != 0)
{
ModelState.AddModelError("Password", "Password is not correct");
return(View(userModel));
}
FormsAuthentication.SetAuthCookie(userModel.Email, userModel.RememberMe);
return(RedirectByRole(user));
}
ViewBag.Message = "Invalid Request";
return(View(userModel));
}
public ActionResult Index(LoginModel objuserlogin)
{
string messageCode;
try
{ var display = Userloginvalues().Where(m => m.UserName == objuserlogin.UserName && m.UserPassword == objuserlogin.UserPassword).FirstOrDefault();
if (display != null)
{
messageCode = "CY-" + (int)ErrorCodesEnum.CorrectDetails;
return(Ok(_localizer[messageCode].Value));
}
else
{
messageCode = "CY-" + (int)ErrorCodesEnum.WrongDetails;
return(Ok(_localizer[messageCode].Value));
} }
catch (Exception ex)
{
messageCode = "CY-" + (int)ErrorCodesEnum.UnknownError;
return(Ok(_localizer[messageCode].Value));
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (Session["loginModel"] == null)
{
ShowMessageBox.Showmessagebox(this, "请重新登录", "../../Default.aspx");
return;
}
if (!IsPostBack)
{
loginModel = new LoginModel();
loginModel = (LoginModel)Session["loginModel"];
StudentsName = loginModel.name;
TrainingBaseCode = loginModel.training_base_code;
}
DeptName = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["DeptName"]).Trim());
PatientName = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["PatientName"]).Trim());
CaseId = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["CaseId"]).Trim());
SurgeryName = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["SurgeryName"]).Trim());
IntraoperativePosition = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["IntraoperativePosition"]).Trim());
Emergency = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["Emergency"]).Trim());
SurgeryDate = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["SurgeryDate"]).Trim());
SurgeryIsStop = CommonFunc.FilterSpecialString(CommonFunc.SafeGetStringFromObj(Request.Form["SurgeryIsStop"]).Trim());
}
public async Task <IActionResult> Login(LoginModel loginModel, string returnUrl)
{
var user = await userManager.FindByEmailAsync(loginModel.Email);
if (user != null)
{
await SignInManager.SignOutAsync();
var result = await SignInManager.PasswordSignInAsync(user, loginModel.Password, false, false);
if (result.Succeeded)
{
return(Redirect(returnUrl ?? "/"));
}
}
else
{
ModelState.AddModelError("Email", "Invalid Email or Password");
}
return(View(loginModel));
}
public ActionResult Login(LoginModel model)
{
if (ModelState.IsValid)
{
var dao = new UserD();
var result = dao.login(model.UserName, Encryptor.MD5Hash(model.Password));
if (result == 1)
{
var user = dao.GetById(model.UserName);
var userSession = new UserLogin();
userSession.UserName = user.UserName;
userSession.UserID = user.ID;
userSession.GroupID = user.GroupID;
Session.Add(Common.CommonConstants.USER_SESSION, userSession);
return(Redirect("/"));
}
else if (result == 0)
{
ModelState.AddModelError("", "Tài khoản không tồn tại.");
}
else if (result == -1)
{
ModelState.AddModelError("", "Tài khoản đang bị khoá.");
}
else if (result == -2)
{
ModelState.AddModelError("", "Mật khẩu không đúng.");
}
else
{
ModelState.AddModelError("", "đăng nhập không đúng.");
}
}
return(View(model));
}
public async Task <IActionResult> LoginUser(LoginModel model)
{
if (ModelState.IsValid)
{
var user = await userManager.FindByNameAsync(model.UserName);
if (user != null && !await userManager.IsLockedOutAsync(user))
{
if (await userManager.CheckPasswordAsync(user, model.Password))
{
if (!await userManager.IsEmailConfirmedAsync(user))
{
ModelState.AddModelError("", "Email is not confimed");
return(View());
}
await userManager.ResetAccessFailedCountAsync(user);
ViewBag.name = user.Fullname;
var principal = await claimPrincipalFactory.CreateAsync(user);
await HttpContext.SignInAsync("Identity.Application", new System.Security.Claims.ClaimsPrincipal(principal));
return(RedirectToAction("Index", "Home"));
}
await userManager.AccessFailedAsync(user);
if (await userManager.IsLockedOutAsync(user))
{
EmailService.Send(user.Email, user.Fullname, "Account Lockout", "Your Account has been locked <a href= \"" + Url.Action("ForgotUserPassword", "Customer") + "\">click here</a> to Unlock it");
//notify them to reset there password
}
}
ModelState.AddModelError("", "Invalid Username or Password");
}
return(View());
}
public ActionResult Login(LoginModel model)
{
JsonResultModel result = new JsonResultModel();
Validate validate = new Validate();
validate.CheckObjectArgument <LoginModel>("model", model);
if (validate.IsFailed)
{
result.BuilderErrorMessage(validate.ErrorMessages);
return(Json(result));
}
model.PostValidate(ref validate);
if (validate.IsFailed)
{
result.BuilderErrorMessage(validate.ErrorMessages);
return(Json(result));
}
User user = this.userService.Login(model.Mobile.Trim(), model.Password.Trim());
if (user == null)
{
result.Message = WebResource.Message_LoginError;
}
else
{
this.Session["Mobile"] = model.Mobile;
this.Session["Roles"] = user.Roles;
this.Session["Name"] = user.Name;
FormsAuthentication.SetAuthCookie(model.Mobile, false);
result.Result = true;
result.Data = string.IsNullOrWhiteSpace(model.ReturnUrl) ? "/" : model.ReturnUrl;
}
return(Json(result));
}
public UserClientModel UserAuth(LoginModel lm)
{
UserClientEntity ue = ((UserClientRepository)_userRepository).GetFromLogin(lm.Login);
if (ue == null)
{
return(null);
}
if (ue != null)
{
return(new UserClientModel()
{
IdUserClient = ue.IdUserClient,
Nom = ue.Nom,
Prenom = ue.Prenom,
Login = ue.Login,
Email = ue.Email,
});
}
else
{
return(null);
}
}
public IActionResult Index(LoginModel model)
{
ViewResult view = View(model);
if (model.Username == null || model.Password == null)
{
model.Message = "Không được để trống tài khoản và mật khẩu.";
}
else
{
string user = model.Username.Trim();
string pass = model.Password.Trim();
if (this._unitOfWork.Users.isUserNameExists(user))
{
User account = this._unitOfWork.Users.GetUserByAccount(user, pass);
if (account == null)
{
model.Message = "Tài khoản hoặc mật khẩu bị sai.";
}
else if (account.Status == USER_STATUS.DISABLED)
{
model.Message = "Tài khoản này đã bị khóa.";
}
else
{
this.SetSession(account);
return(RedirectToAction("Index", "Home"));
}
}
else
{
model.Message = "Tài khoản này không tồn tại.";
}
}
return(view);
}
public IActionResult Login(LoginModel model)
{
Usuario usu =
this.repo.LoginUsuario(model.Username
, model.Password);
if (usu != null)
{
Claim[] claims = new[]
{
new Claim("UserData",
JsonConvert.SerializeObject(usu))
};
JwtSecurityToken token = new JwtSecurityToken
(
issuer: helper.Issuer
, audience: helper.Audience
, claims: claims
, expires: DateTime.UtcNow.AddMinutes(10)
, notBefore: DateTime.UtcNow
, signingCredentials:
new SigningCredentials(this.helper.GetKeyToken(), SecurityAlgorithms.HmacSha256)
);
return(Ok(
new
{
response =
new JwtSecurityTokenHandler().WriteToken(token)
}));
}
else
{
return(Unauthorized());
}
}
public ActionResult Login(LoginModel model)
{
var userList = GetUserList();
if (userList != null && userList.ContainsKey(model.Username) && userList[model.Username] == model.Password)
{
var claimList = new List <Claim>
{
new Claim("roles", "admin"),
new Claim(ClaimTypes.Email, model.Username),
new Claim(ClaimTypes.GivenName, "Jane"),
new Claim(ClaimTypes.Surname, "Doe")
};
_logger.LogInformation($"'{model.Username}' > user authenticated.");
return(this.Ok(new IdentityModel {
Token = GenerateToken(claimList)
}));
}
else
{
_logger.LogInformation($"'{model.Username}' > unauthorized user.");
return(this.BadRequest("Invalid username or password"));
}
}
public IActionResult Login([FromBody] LoginModel loginModel)
{
try // Начало блока перехвата исключений
{
// Ппроверяем данные пользователя по данным из хранилища
var userModel = usersManager.Login(loginModel, HttpContext);
// Если данные пользователя не получениы или жетон доступа не пустой, то
if (userModel == null || string.IsNullOrEmpty(userModel.ValidationToken))
{
// Возвращаем "Плохой запрос"
// с сообщением "Имя пользователя и пароль неправильные"
return(BadRequest(new { message = "Login or password is incorrect" }));
}
// Возвращаем "Ok" и данные опользователе с очищенным паролем
return(Ok(userModel.WithoutPassword()));
}
catch (Exception exp) // Перехватываем возникшие исключения
{
// Возвращаем "Плохой запрос"
return(BadRequest());
}
}
public async Task <IHttpActionResult> Login(LoginModel loginModel)
{
var user = await UserManager.FindAsync(loginModel.UserName, loginModel.Password);
if (user == null)
{
return(Ok(new ResponseBase <JObject>
{
statusCode = 400,
userMessage = "Invalid email address or password.",
devMessage = "Invalid email address or password.",
}));
}
var confirmed = await UserManager.IsEmailConfirmedAsync(user.Id);
if (confirmed == false)
{
return(Ok(new ResponseBase <JObject>
{
statusCode = 402,
userMessage = "You need to confirm your email.",
devMessage = "You need to confirm your email.",
}));
}
var token = await GenerateLocalAccessTokenResponse(user);
return(Ok(new ResponseBase <JObject>
{
statusCode = 200,
userMessage = "Success",
devMessage = "Success",
item = token
}));
}
public IActionResult LogoutSvc()
{
LoginModel model = CurrentModel;
bool loggedOut = false;
if (model != null && model.User != null)
{
loggedOut = UserDB.Logout(model.User.UserId, model.User.Language != null ? model.User.Language.Id : 1, GetConfiguration().GetConnectionString(DEFAULT_CONNECTION));
}
if (loggedOut)
{
TempData["LoginModel"] = null;
TempData["TutorModel"] = null;
TempData["StudentModel"] = null;
HttpContext.Response.Cookies.Delete("user");
HttpContext.Response.Cookies.Delete("tutor");
LoginModel loginModel = new LoginModel {
Date = DateTime.Now, RedirectAction = "Index", RedirectController = "Home"
};
TempData["LoginModel"] = JsonConvert.SerializeObject(loginModel);
return(Json(loginModel));
}
return(Json(new { Success = false }));
}
public User GetUserByLoginModel(LoginModel loginModel)
{
using (var conn = new MySqlConnection(GetConnectionString()))
{
try
{
string queryString = "SELECT * FROM users WHERE Email=@Email";
conn.Open();
MySqlCommand sqlCmd = new MySqlCommand(queryString, conn);
sqlCmd.Parameters.AddWithValue("@Email", loginModel.Email);
MySqlDataReader rdr = sqlCmd.ExecuteReader(CommandBehavior.SingleRow);
var userModel = new User();
if (rdr.Read())
{
userModel.Id = Convert.ToInt32(rdr["Id"]);
userModel.Email = rdr["Email"].ToString();
userModel.FirstName = rdr["FirstName"].ToString();
userModel.LastName = rdr["LastName"].ToString();
userModel.PasswordHash = rdr["PasswordHash"].ToString();
userModel.Role = rdr["Role"].ToString();
}
conn.Close();
return(userModel);
}
finally
{
if (conn != null)
{
conn.Close();
}
}
}
}
