public ActionResult SignIn(SignInModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (MembershipService.ValidateUser(model.UserName, model.Password))
{
FormsService.SignIn(model.UserName, model.RememberMe);
if (!String.IsNullOrEmpty(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 ActionResult SignIn(SignInModel model)
{
try
{
SignInResult result = AccountsManager.Authenticate(model.Username, model.Password);
if (result.Ok)
{
// Set the authentication cookie
FormsAuthentication.SetAuthCookie(result.Username, true);
}
else
{
return(CreateValidationError(result.Reason));
}
return(JsonOK());
}
catch (Exception ex)
{
EventLog.WriteEntry("Krypto", "An error occured while trying to sign-in: " + ex.Message);
return(CreateValidationError("Internal Server Error"));
}
}
public IActionResult SignIn(SignInModel obj)
{
if (ModelState.IsValid)
{
Member member = app.Member.SignIn(obj.Usr, obj.Pwd);
if (member != null)
{
ClaimsIdentity claims = new ClaimsIdentity(CookieAuthenticationDefaults.AuthenticationScheme);
claims.AddClaim(new Claim(ClaimTypes.NameIdentifier, member.Id.ToString()));
claims.AddClaim(new Claim(ClaimTypes.Name, member.Username));
claims.AddClaim(new Claim(ClaimTypes.Email, member.Email));
//load roles
if (member.Roles != null)
{
foreach (Role item in member.Roles)
{
claims.AddClaim(new Claim(ClaimTypes.Role, item.Name));
}
}
AuthenticationProperties properties = new AuthenticationProperties
{
AllowRefresh = true,
IsPersistent = obj.Remember,
};
HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claims), properties);
return(Redirect("/"));
}
else
{
ModelState.AddModelError("error", "Đăng nhập bị lỗi!");
}
}
return(View(obj));
}
public ActionResult <SignInModel> SignIn(
[FromForm] string sEmail
, [FromForm] string sPW)
{
ApiResultReady armResult = new ApiResultReady(this);
//로그인 처리용 모델
SignInModel smResult = new SignInModel();
armResult.ResultObject = smResult;
if (sEmail == "*****@*****.**" && sPW == "1111")
{
smResult.Complete = true;
//이 프로젝트에서는 사인인한 유저의 정보를 어디에도 저장하지 않는다.
//그래서 토큰으로 유저를 구분할 수 있게 만든다.
smResult.Token
= string.Format("{0}▩{1}"
, sEmail
, Guid.NewGuid().ToString());
}
else
{
armResult.InfoCode = "-1";
armResult.Message = "일치하는 정보가 없습니다.";
smResult.Complete = false;
}
return(armResult.ToResult());
}
public static bool authenticate(IWorkUnit workUnit, SignInModel logOnModel)
{
var password = logOnModel.Password;
Account account = null;
try {
//get the contact with the provided email
account = workUnit.AccountRepository.Entities.First(x => x.EmailAddress.ToUpper() == logOnModel.Email.ToUpper());
}
catch {
return(false);//failed to find user account
}
//encode password
var encodedPassword = SHA1PasswordSecurity.encrypt(password);
//authenticate
var databasePassword = account.Password;
var pwValidation = comparePassword(encodedPassword, databasePassword);
//if valid record log in datetime
if (pwValidation)
{
try {
account.LastLogin = DateTime.Now;
workUnit.AccountRepository.UpdateEntity(account);
workUnit.saveChanges();
}
catch {
//do error logging here
}
}
return(pwValidation);
}
public Task <IResult <string> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var signedInModel = UserRepository.SignInAsync(signInModel).Result;
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(Task.FromResult(validation));
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.Login);
UserLogDomain.AddAsync(userLogModel);
var jwt = CreateJwt(signedInModel);
return(new SuccessResult <string>(jwt).ToTask());
}
//[ValidateAntiForgeryToken]
public async Task <IActionResult> SignIn(SignInModel model)
{
if (User.Identity.IsAuthenticated)
{
return(RedirectToDefault);
}
if (!ModelState.IsValid)
{
return(RedirectToDefault.WithError(JoinWithHtmlLineBreak(ModelState.GetErrorMessages())));
}
try
{
var signInResult = await _authService.SignInAsync(model.NameOrEmail, model.Password, false);
if (signInResult.IsLockedOut)
{
return(View("Lockout"));
}
return(signInResult.Succeeded
? RedirectToDefault
: RedirectToDefault.WithError(MessagesOptions.LoginFailed));
}
catch (Exception exception)
{
_appLogger.LogError(exception);
return(RedirectToDefault.WithError(exception.Message));
}
}
public async Task <IActionResult> SignIn([FromBody] SignInModel signIn, string returnUrl = null)
{
try
{
if (string.IsNullOrEmpty(returnUrl))
{
return(BadRequest("returnUrl is null or empty"));
}
if (ModelState.IsValid)
{
var result = await _signInManager.PasswordSignInAsync(signIn.Email, signIn.Password, signIn.IsRememberMe, true);
if (result.Succeeded)
{
return(Redirect(returnUrl));
}
return(BadRequest("Authentication failed"));
}
return(BadRequest());
}
catch (Exception ex)
{
_logger.LogDebug(ex.Message);
return(InternalServerError($"Errors:{ex.Message}"));
}
}
public void SignIn(SignInModel user)
{
SignInModule module = new SignInModule();
m_user = module.GetUserBySignID(user);
if (m_user == null)
{
throw new Exception("請輸入正確帳號或密碼");
}
if (m_user.UserAccount == "manager")
{
m_user.Role = UserRoleEnum.SUPERADMIN;
}
else if (m_user.UserAccount == "admin")
{
m_user.Role = UserRoleEnum.ADMIN;
}
else
{
m_user.Role = UserRoleEnum.USER;
}
Context.Session["UserInfo"] = m_user;
//寫入登入紀錄
//string ip = System.Web.HttpContext.Current.Request.UserHostAddress;
//IpHistoryModule ipMdu = new IpHistoryModule();
//ipMdu.WriteIp(ip, "manager");
//ipMdu.Dispose();
}
public async Task <IActionResult> SignIn(SignInModel model)
{
if (model == null || string.IsNullOrEmpty(model.Username) || string.IsNullOrEmpty(model.Password))
{
return(BadRequest("Required parameters missing."));
}
var user = await _dbService.Users.FindByUsernameAsync(model.Username);
if (user == null || !_authService.VerifyPassword(user.Password, model.Password))
{
if (user != null)
{
var failureCount = (user.BadPasswordCount ?? 0) + 1;
var windowStart = user.BadPasswordWindowStart ?? DateTime.UtcNow;
var windowEnd = windowStart.Add(TimeSpan.FromHours(1));
if (DateTime.UtcNow > windowEnd)
{
user.BadPasswordWindowStart = DateTime.UtcNow;
user.BadPasswordCount = 1;
}
else if (failureCount >= 3)
{
user.IsLockedOut = true;
}
else
{
user.BadPasswordWindowStart = windowStart;
user.BadPasswordCount = failureCount;
}
user.ModifiedDate = DateTime.UtcNow;
await _dbService.Users.UpdateAsync(user);
}
return(BadRequest("Invalid username or password."));
}
var claims = new List <Claim>
{
new Claim(ClaimTypes.Name, user.Username),
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, user.Role)
};
user.LastLoginDate = DateTime.UtcNow;
user.ModifiedDate = DateTime.UtcNow;
await _dbService.Users.UpdateAsync(user);
var identity = new ClaimsIdentity(claims, "Basic");
HttpContext.User = new ClaimsPrincipal(identity);
return(Ok(new
{
Token = _authService.GenerateJwtToken(identity),
User = new
{
Username = user.Username
}
}));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <TokenModel>(validation.Message));
}
var signedInModel = await UserRepository.SignInAsync(signInModel);
if (!SignInService.Validate(signedInModel, signInModel))
{
return(new ErrorDataResult <TokenModel>(Texts.LoginPasswordInvalid));
}
var userLogModel = new UserLogModel(signedInModel.UserId, LogType.SignIn);
await UserLogApplicationService.AddAsync(userLogModel);
await UnitOfWork.SaveChangesAsync();
var tokenModel = SignInService.CreateToken(signedInModel);
return(new SuccessDataResult <TokenModel>(tokenModel));
}
public async Task <IActionResult> ResetPassword(SignInModel model)
{
if (!string.IsNullOrEmpty(model.Token))
{
var principal = _authService.VerifyPasswordResetToken(model.Token);
if (principal == null)
{
return(BadRequest("Invalid token."));
}
var user = await _dbService.Users.FindByUsernameAsync(principal.Identity.Name);
user.Password = model.Password;
await _dbService.Users.UpdateAsync(user);
}
else
{
var user = await _dbService.Users.FindByUsernameAsync(model.Username);
if (user == null)
{
return(BadRequest("Invalid username."));
}
var token = _authService.GeneratePasswordResetToken(user.Username);
// send email
}
return(Ok());
}
public IActionResult SignIn(SignInModel signInModel, string returnUrl)
{
var domainModel = signInModel.ToModel();
if (ModelState.IsValid)
{
var response = _service.SignIn(domainModel.Username, domainModel.Password, signInModel.IsPersistent, HttpContext);
if (response.Success)
{
if (returnUrl == null)
{
return(RedirectToAction("Overview", "Movies"));
}
else
{
return(Redirect(returnUrl));
}
}
else
{
ModelState.AddModelError("", response.Message);
//return RedirectToAction("SignIn", new { ErrorMessage = response.Message });
}
}
return(View(signInModel));
}
public async Task <IActionResult> Login(SignInModel signInModel, string returnUrl)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.PasswordSignInAsync(signInModel);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
if (result.IsNotAllowed)
{
ModelState.AddModelError("", "Not allowed to login");
}
else
{
ModelState.AddModelError("", "Invalid Username and Password");
}
}
return(View());
}
public async Task <IResult <TokenModel> > SignInAsync(SignInModel model)
{
var failResult = Result <TokenModel> .Fail("Invalid login or password!");
var validation = await new SignInModelValidator().ValidationAsync(model);
if (validation.Failed)
{
return(failResult);
}
var auth = await _authRepository.GetByLoginAsync(model.Login);
if (auth is null)
{
return(failResult);
}
var password = _hashService.Create(model.Password, auth.Salt);
if (auth.Password != password)
{
return(failResult);
}
return(CreateToken(auth));
}
public async Task <AuthResultModel> AuthorizeUser(SignInModel model)
{
var user = await _userManager.Users.Include(u => u.UserRoles).ThenInclude(ur => ur.Role)
.FirstOrDefaultAsync(u => u.UserName == model.Username);
if (user == null)
{
throw new UserNotAuthorizedException("Username or password is incorrect");
}
if (!await _userManager.CheckPasswordAsync(user, model.Password))
{
throw new UserNotAuthorizedException("Username or password is incorrect");
}
user.RefreshToken = GenerateRefreshToken();
await _userManager.UpdateAsync(user);
var roles = user.UserRoles?.Select(_ => _.Role.Name).ToList();
var userPermissions = user.UserRoles?.SelectMany(_ => _.Role.Permissions.Split(",")).ToList();
var resultModel = new AuthResultModel
{
Token = await GenerateUserToken(user),
Expire = DateTime.UtcNow.AddDays(7),
UserId = user.Id,
RefreshToken = user.RefreshToken,
Roles = roles,
Permissions = userPermissions,
};
return(resultModel);
}
public SignInResponse SignIn(SignInModel userInfo)
{
SignInResponse resp = new SignInResponse();
try
{
resp = _IAuthRepository.SignIn(userInfo);
if (resp != null && resp.userInfo != null)
{
resp.status = resp.status;
resp.message = resp.message;
resp.token = _IAuthRepository.BuildToken("Sign In", resp.userInfo.accountId);
resp.userInfo.avatar = null;
resp.userInfo.remember = userInfo.remember;
}
return(resp);
}
catch (Exception ex)
{
_ILogs.LogError("SignIn Service: ", ex.Message.ToString(), ex.StackTrace);
}
return(null);
}
public async Task <IActionResult> Login(SignInModel signInModel, string returnUrl)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.PasswordSignInAsync(signInModel);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
if (result.IsNotAllowed)
{
ModelState.AddModelError("", "Not allowed to Login!");
}
else if (result.IsLockedOut)
{
ModelState.AddModelError("", "Account Blocked for 5 minutes!");
}
else
{
ModelState.AddModelError("", "Invalid credertials");
}
}
return(View(signInModel));
}
public async Task <IActionResult> Login(SignInModel signInModel, string returnUrl)
{
if (ModelState.IsValid)
{
var result = await _accountRepository.SignInAsync(signInModel);
if (result.Succeeded)
{
if (!string.IsNullOrEmpty(returnUrl))
{
return(LocalRedirect(returnUrl));
}
return(RedirectToAction("GetAllBooks", "Book"));
}
if (result.IsNotAllowed)
{
ModelState.AddModelError("", "Not Allowed");
}
else
{
ModelState.AddModelError("", "Invalid Credentials");
}
}
return(View());
}
async void SignInButton_Clicked(object sender, EventArgs e)
{
var errorMessage = "";
var valid = ValidateLoginInput(out errorMessage);
if (valid)
{
if (CrossConnectivity.Current.IsConnected)
{
ShowBusy(MessageHelper.LoggingIn);
TryExecute(async() =>
{
var payload = new SignInModel
{
Username = loginuserName.Text.Trim(),
Password = loginpassword.Text.Trim(),
ApartmentName = ApartmentName.Text.Trim()
};
var task = await SignInTask(payload);
HideBusy();
});
}
else
{
UserDialogs.Instance.ErrorToast(MessageHelper.NoInternet);
}
}
else
{
await DisplayAlert(MessageHelper.InvalidInput, errorMessage, "OK");
}
}
public async Task <IActionResult> SignIn(SignInModel signInModel, string returnUrl = null)
{
if (ModelState.IsValid)
{
Response response = await AuthService.SignIn(signInModel.Username, signInModel.Password, HttpContext);
if (response.IsSuccessful)
{
if (!String.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Overview", "Blog"));
}
}
else
{
ModelState.AddModelError(string.Empty, response.Message);
return(View(signInModel));
}
}
else
{
return(View(signInModel));
}
}
async Task <TokenModel> SignInTask(SignInModel payload)
{
var userService = DependencyService.Get <ILoginService>();
var result = await userService.SignIn(payload);
if (result.Success == true)
{
App.SetAuth(result);
var json = JsonConvert.SerializeObject(result);
var service = DependencyService.Get <ILoginService>();
await service.SaveUserData(json);
await service.SaveAppartment(ApartmentName.Text.Trim());
var MainPage = new RootPage();
await Navigation.PushModalAsync(MainPage);
MessageHelper.ShowToast(ToastNotificationType.Success, MessageHelper.LoggedSucess);
}
else
{
MessageHelper.ShowToast(ToastNotificationType.Error, result.ErrorMessage);
}
return(result);
}
public async Task <IActionResult> SignIn(bool isRememberMeActivated, [FromBody] SignInModel loginData)
{
var userModel = await _accountService.SignInAsync(loginData);
var tokenModel = new TokenModel();
if (userModel.Errors.Any())
{
tokenModel.Errors = userModel.Errors;
return(Ok(tokenModel));
}
double tokenLifeTime = _jwtConfig.GetValue <double>("AccessTokenLifeTime");
string secretKey = _jwtConfig.GetValue <string>("SecretKey");
tokenModel.AccessToken = _jwtHelper.GenerateToken(userModel, tokenLifeTime, secretKey, true);
tokenLifeTime = isRememberMeActivated
? _jwtConfig.GetValue <double>("RefreshTokenLifeTimeLong")
: _jwtConfig.GetValue <double>("RefreshTokenLifeTime");
tokenModel.RefreshToken = _jwtHelper.GenerateToken(userModel, tokenLifeTime, secretKey, false);
return(Ok(tokenModel));
}
public IActionResult SignIn(SignInModel signInModel, string returnUrl)
{
if (ModelState.IsValid)
{
var response = _authService.SignIn(signInModel.Username, signInModel.Password, signInModel.IsPersistent, HttpContext);
if (response.IsSuccessful)
{
if (returnUrl == null)
{
return(RedirectToAction("Overview", "Movies"));
}
else
{
return(Redirect(returnUrl));
}
}
else
{
ModelState.AddModelError("", response.Message);
return(View(signInModel));
}
}
else
{
return(View(signInModel));
}
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Validate(signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var signedInModel = await _userRepository.SignInAsync(signInModel);
validation = _signInService.Validate(signedInModel, signInModel);
if (validation.Failed)
{
return(DataResult <TokenModel> .Fail(validation.Message));
}
var userLogModel = new UserLogModel(signedInModel.Id, LogType.SignIn);
await _userLogApplicationService.AddAsync(userLogModel);
var tokenModel = _signInService.CreateToken(signedInModel);
return(DataResult <TokenModel> .Success(tokenModel));
}
public async Task <IActionResult> SignIn(SignInModel model, string returnUrl = null)
{
if (ModelState.IsValid)
{
var isSignedIn = await AuthService.SignInAsync(model.Username, model.Password, HttpContext);
if (isSignedIn)
{
if (!String.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
return(RedirectToAction("Overview", "Recipes"));
}
}
else
{
ModelState.AddModelError(string.Empty, "Username or password is incorrect");
return(View(model));
}
}
return(View(model));
}
public async Task <IDataResult <SignedInModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(new ErrorDataResult <SignedInModel>(validation.Message));
}
var userDomain = UserDomainFactory.Create(signInModel);
userDomain.SignIn();
signInModel = userDomain.Map <SignInModel>();
var signedInModel = await UserRepository.SignInAsync(signInModel).ConfigureAwait(false);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(new ErrorDataResult <SignedInModel>(validation.Message));
}
await AddUserLogAsync(signedInModel.UserId, LogType.SignIn).ConfigureAwait(false);
return(new SuccessDataResult <SignedInModel>(signedInModel));
}
public ActionResult ComputeSignIn(SignInModel model)
{
if (CurrentUser != null)
{
return(RedirectToAction("Index", "Home"));
}
if (!ModelState.IsValid)
{
return(View("SignIn", model));
}
Account account = DataContext.Accounts.FirstOrDefault(
ac => ac.Login == model.Login && ac.Hash == model.Password.MD5());
if (account == null)
{
ModelState.AddModelError("", "Invalid login or password");
if (model.BreadcrumbModel == null)
{
model.BreadcrumbModel =
new BreadcrumbModel(Url.Action("SignIn", "Account", null, Request.Url.Scheme));
}
return(View("SignIn", model));
}
DoLogin(account);
return(RedirectToAction("Index", "Home"));
}
public async Task <IDataResult <TokenModel> > SignInAsync(SignInModel signInModel)
{
var validation = new SignInModelValidator().Valid(signInModel);
if (!validation.Success)
{
return(ErrorDataResult <TokenModel>(validation.Message));
}
UserDomainService.GenerateHash(signInModel);
var signedInModel = await UserRepository.SignInAsync(signInModel);
validation = new SignedInModelValidator().Valid(signedInModel);
if (!validation.Success)
{
return(ErrorDataResult <TokenModel>(validation.Message));
}
var addUserLogModel = new AddUserLogModel(signedInModel.UserId, LogType.SignIn);
await UserLogApplicationService.AddAsync(addUserLogModel);
var tokenModel = UserDomainService.GenerateToken(signedInModel);
return(SuccessDataResult(tokenModel));
}
public ActionResult Index(SignInModel model, string returnUrl)
{
HttpContext.Session["facilityDateHash"] = null;
if (ModelState.IsValid)
{
string errorMessage = "";
string hash = "";
if (userRepository.ValidateUser(model.Email, model.Password, ref errorMessage, ref hash))
{
FormsAuthentication.SetAuthCookie(model.Email, model.RememberMe);
HttpContext.Session["facilityDateHash"] = hash;
HttpContext.Session["email"] = model.Email;
if (UrlSafe(returnUrl))
{
return(Redirect(returnUrl));
}
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", errorMessage);
}
return(View(model));
}
// shows the signin screen
public ActionResult SignIn(string returnUrl, bool mobile=false)
{
// you can call AuthenticationHelper.GetRelyingPartyDetailsFromReturnUrl to get more information about the requested relying party
var vm = new SignInModel()
{
ReturnUrl = returnUrl,
ShowClientCertificateLink = ConfigurationRepository.Global.EnableClientCertificateAuthentication
};
if (mobile) vm.IsSigninRequest = true;
return View(vm);
}
public ActionResult SignIn(SignInModel model, string returnUrl)
{
if (ModelState.IsValid)
{
if (_userRepository.ValidateUser(model.UserName, model.Password))
{
return SetPrincipalAndRedirect(model.UserName, AuthenticationMethods.Password, returnUrl, model.EnableSSO, _configurationRepository.Configuration.SsoCookieLifetime);
}
}
ModelState.AddModelError("", "Incorrect credentials or no authorization.");
ViewBag.ShowClientCertificateLink = _configurationRepository.Configuration.EnableClientCertificates;
return View(model);
}
public ActionResult SignIn(SignInModel model)
{
if (ModelState.IsValid)
{
if (UserRepository.ValidateUser(model.UserName, model.Password))
{
// establishes a principal, set the session cookie and redirects
// you can also pass additional claims to signin, which will be embedded in the session token
return SignIn(
model.UserName,
AuthenticationMethods.Password,
model.ReturnUrl,
model.EnableSSO,
ConfigurationRepository.Global.SsoCookieLifetime);
}
}
ModelState.AddModelError("", Resources.AccountController.IncorrectCredentialsNoAuthorization);
model.ShowClientCertificateLink = ConfigurationRepository.Global.EnableClientCertificateAuthentication;
return View(model);
}
