public async Task <ActionResult> ChangePassword(ChangePassword objChangePassword) { AuthenticateViewModel model = new AuthenticateViewModel(); if (!ModelState.IsValid) { return(View(model)); } model.objchangePassword = new ChangePassword(); model.objchangePassword.confirmNewPassWord = objChangePassword.confirmNewPassWord; model.objchangePassword.currentPassword = objChangePassword.currentPassword; model.objchangePassword.newPassWord = objChangePassword.newPassWord; await model.ChangePassword(Session); if (model.errorOccurred == true) { model.ErrorMessage = "Pasword is not valid."; return(View(model)); } model.ErrorMessage = "Your New Pasword successfully saved."; return(View("ChangePassword", model)); }
private AuthenticateViewModel GetSignInProfile(ClaimsIdentity claims) { try { if (claims == null) { return(null); } var profile = new AuthenticateViewModel() { AccountTypeFid = GetClaimValue(claims, ClaimConstant.AccountType) ?? string.Empty, UserId = GetClaimValue(claims, ClaimConstant.UserId) ?? string.Empty, RoleId = GetClaimValue(claims, ClaimConstant.RoleId) ?? string.Empty, UniqueId = GetClaimValue(claims, ClaimConstant.UniqueId) ?? string.Empty, Name = GetClaimValue(claims, ClaimConstant.Name) ?? string.Empty, Email = GetClaimValue(claims, ClaimConstant.Email) ?? string.Empty, UserRole = GetClaimValue(claims, ClaimConstant.Role) ?? string.Empty, AccessToken = GetClaimValue(claims, ClaimConstant.AccessToken) ?? string.Empty, RefreshToken = GetClaimValue(claims, ClaimConstant.RefreshToken) ?? string.Empty, TokenEffectiveDate = GetClaimValue(claims, ClaimConstant.TokenEffectiveDate) ?? string.Empty, Expired = GetClaimValue(claims, ClaimConstant.TokenExpired) ?? string.Empty, TokenEffectiveTimeStick = GetClaimValue(claims, ClaimConstant.TokenEffectiveTimeStick) ?? string.Empty }; if (profile != null && string.IsNullOrEmpty(profile.AccessToken)) { profile.AccessToken = GetJwtTokenFromRequestHeader(); } return(profile); } catch { return(null); } }
public void Change_Password_IncorrectPassword() { // Given const string username = "******"; var resources = new Resources(); var viewModel = new AuthenticateViewModel { Username = username }; var currentPassword = "******"; var newPassword = "******"; resources.MockApiCaller.AddMockResponse("WebApi:Authenticate:Login", new LoginRequestModel { Username = username, Password = currentPassword, Browser = "Unable to determine", Device = "Unable to determine", }, new UserModel { Username = username, IsAuthenticated = false }); // When var result = resources.Controller.ChangePassword(username, currentPassword, newPassword) as RedirectToActionResult; // Then Assert.IsNotNull(result); Assert.AreEqual("ChangePasswordIndex", result.ActionName); Assert.AreEqual("Authenticate", result.ControllerName); }
public C1Rescponse Authenticate([FromBody] AuthenticateViewModel model) { Argument.Require(model != null, "Параметры не заданы."); var response = c1Service.Authenticate(model.CertificateId, model.TextForUser); return(response); }
public void WhenNotLoggedIn_NavigateToAuthenticateView() { //Prepare Mock <IRegion> mockRegion = new Mock <IRegion>(); mockRegion.Setup(x => x.RequestNavigate(new Uri("AuthenticateView", UriKind.Relative), It.IsAny <Action <NavigationResult> >())).Verifiable(); Mock <IRegionManager> mockedRegionManager = new Mock <IRegionManager>(); mockedRegionManager.Setup(x => x.Regions[RegionNames.ShellContentRegion]).Returns(mockRegion.Object); MockLoginStatusChangedEvent mockedLoginStatusChangedEvent = new MockLoginStatusChangedEvent(); Mock <IEventAggregator> mockedEventAggregator = new Mock <IEventAggregator>(); mockedEventAggregator.Setup(x => x.GetEvent <LoginStatusChangedEvent>()).Returns(mockedLoginStatusChangedEvent); Mock <IUserService> mockedUserService = new Mock <IUserService>(); mockedUserService.Setup(x => x.IsLoggedIn).Returns(false); //Act AuthenticateViewModel target = new AuthenticateViewModel(mockedRegionManager.Object, mockedEventAggregator.Object, mockedUserService.Object); target.IsLoggedIn = true; mockedLoginStatusChangedEvent.Publish(mockedUserService.Object); //Verify Assert.IsFalse(target.IsLoggedIn); mockRegion.Verify(x => x.RequestNavigate(new Uri("AuthenticateView", UriKind.Relative), It.IsAny <Action <NavigationResult> >()), Times.Once()); }
public void WhenSelectGameRegionCommandExecuted_SelectedRegionPropertyChanged() { //Prepare Mock <IRegionManager> mockedRegionManager = new Mock <IRegionManager>(); MockLoginStatusChangedEvent mockedLoginStatusChangedEvent = new MockLoginStatusChangedEvent(); Mock <IEventAggregator> mockedEventAggregator = new Mock <IEventAggregator>(); mockedEventAggregator.Setup(x => x.GetEvent <LoginStatusChangedEvent>()).Returns(mockedLoginStatusChangedEvent); Mock <IUserService> mockedUserService = new Mock <IUserService>(); mockedUserService.Setup(x => x.Login(It.Is <string>(user => user == "user"), It.Is <SecureString>(pass => pass.Length == 2))).Returns(new UserQueryResult()).Verifiable(); AuthenticateViewModel target = new AuthenticateViewModel(mockedRegionManager.Object, mockedEventAggregator.Object, mockedUserService.Object); GameRegion gameRegion = new GameRegion(); //Act target.SelectGameRegionCommand.Execute(gameRegion); //Verify Assert.AreEqual(gameRegion, target.SelectedRegion); }
public ApplicationServiceResponse AuthenticateUser(AuthenticateViewModel model) { model.Validate(); if (!model.IsValid) { return(BadRequest(model.GetValidationMessagesList())); } var user = _userBusiness.AuthenticateUser(model.Email, model.Password); if (user == null) { return(BadRequest(new List <string> { "Email or password is incorrect" })); } var tokenString = _userBusiness.GenerateToken(user); var authenticatedUser = new AuthenticatedUserViewModel { Id = user.Id, Email = user.Email, FirstName = user.FirstName, LastName = user.LastName, Administrator = user.Administrator, Token = tokenString }; return(Ok(authenticatedUser)); }
public void WhenLoginAsGuestCommandExecuted_UserLoggedIn() { //Prepare Mock <IRegionManager> mockedRegionManager = new Mock <IRegionManager>(); MockLoginStatusChangedEvent mockedLoginStatusChangedEvent = new MockLoginStatusChangedEvent(); Mock <IEventAggregator> mockedEventAggregator = new Mock <IEventAggregator>(); mockedEventAggregator.Setup(x => x.GetEvent <LoginStatusChangedEvent>()).Returns(mockedLoginStatusChangedEvent); Mock <IUserService> mockedUserService = new Mock <IUserService>(); mockedUserService.Setup(x => x.Login(It.Is <string>(user => user == "Guest"), It.Is <SecureString>(pass => pass.Length == 0))).Returns(new UserQueryResult()).Verifiable(); AuthenticateViewModel target = new AuthenticateViewModel(mockedRegionManager.Object, mockedEventAggregator.Object, mockedUserService.Object); //Act target.LoginAsGuestCommand.Execute(null); //Verify mockedUserService.Verify(x => x.Login(It.IsAny <string>(), It.IsAny <SecureString>()), Times.Once); mockedUserService.VerifyAll(); }
public async Task <IActionResult> Login(AuthenticateViewModel request) { if (string.Compare(request.UserName, SilkierQuartzAuthenticateConfig.UserName, StringComparison.InvariantCulture) != 0 || string.Compare(request.Password, SilkierQuartzAuthenticateConfig.UserPassword, StringComparison.InvariantCulture) != 0) { request.IsLoginError = true; return(View(request)); } var claims = new List <Claim> { new Claim(ClaimTypes.NameIdentifier, string.IsNullOrEmpty(SilkierQuartzAuthenticateConfig.UserName) ? "SilkierQuartzAdmin" : SilkierQuartzAuthenticateConfig.UserName), new Claim(ClaimTypes.Name, string.IsNullOrEmpty(SilkierQuartzAuthenticateConfig.UserPassword) ? "SilkierQuartzPassword" : SilkierQuartzAuthenticateConfig.UserPassword), new Claim(SilkierQuartzAuthenticateConfig.SilkierQuartzSpecificClaim, "Authorized") }; var authProperties = new AuthenticationProperties() { IsPersistent = request.IsPersist }; var userIdentity = new ClaimsIdentity(claims, SilkierQuartzAuthenticateConfig.AuthScheme); await HttpContext.SignInAsync(SilkierQuartzAuthenticateConfig.AuthScheme, new ClaimsPrincipal(userIdentity), authProperties); return(RedirectToAction(nameof(SchedulerController.Index), nameof(Scheduler))); }
public async Task <IActionResult> Authenticate(AuthenticateViewModel viewModel) { if (viewModel == null) { throw new ArgumentNullException(nameof(viewModel)); } var result = await _identityServerClientFactory.CreateAuthSelector() .UseClientSecretBasicAuth("ProtectedWebsite", "ProtectedWebsite") .UsePassword(viewModel.Login, viewModel.Password, "openid", "profile") .ResolveAsync(Constants.OpenIdUrl); if (result.Content == null) { System.Console.WriteLine("error"); } else { System.Console.WriteLine("bingo"); } var userInfo = await _identityServerClientFactory.CreateUserInfoClient() .Resolve(Constants.OpenIdUrl, result.Content.AccessToken).ConfigureAwait(false); var claims = new List <Claim>(); claims.Add(new Claim("sub", userInfo.Content["sub"].ToString())); claims.Add(new Claim("id_token", result.Content.IdToken)); await SetLocalCookie(claims); var accessibleResources = await _resourceManagerResolver.ResolveAccessibleResources(result.Content.IdToken); this.PersistAccessibleResources(accessibleResources.ToList(), _dataProtector); return(RedirectToAction("Index", "Home")); }
public IActionResult Authenticate([FromBody] AuthenticateViewModel model) { if (model != null) { var user = userService.Authenticate(model.Username, model.Password); if (user == null) { return(BadRequest("Username or password is incorrect")); } // return user info and token return(Ok(new { user.UserId, Username = user.UserName, user.FirstName, user.LastName, //Token = generateJwtToken(user.UserId,user.Email) Token = userService.GenerateJwtToken(user.UserId.ToString(CultureInfo.InvariantCulture), user.Email, appSettings.Secret) })); } else { return(BadRequest("Please provide user Information")); } }
public async Task <ActionResult> ResetPassword(ResetPassword objResetPassword) { AuthenticateViewModel model = new AuthenticateViewModel(); if (string.IsNullOrEmpty(objResetPassword.emailAddress) || string.IsNullOrEmpty(objResetPassword.resetCode)) { model.ErrorMessage = "Some value is missing. Please click reset password link in email."; return(View(model)); } model.objResetPassword = new ResetPassword(); model.objResetPassword.emailAddress = objResetPassword.emailAddress; model.objResetPassword.resetCode = objResetPassword.resetCode; if (!ModelState.IsValid) { return(View(model)); } await model.ResetPassword(Session, objResetPassword); if (model.errorOccurred == true) { model.ErrorMessage = "Email Address or Reset Code is not valid."; return(View(model)); } model.ErrorMessage = "Your New Pasword successfully saved."; return(View("Index", model)); }
public async Task <IActionResult> Index(AuthenticateViewModel viewModel) { if (viewModel == null) { return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}", area = string.Empty })); } viewModel.Check(ModelState); if (!ModelState.IsValid) { return(View(viewModel)); } try { var user = await _passwordAuthService.Authenticate(viewModel.Login, viewModel.Password); return(await Authenticate(viewModel.ReturnUrl, Constants.AMR, user, viewModel.RememberLogin)); } catch (CryptographicException) { ModelState.AddModelError("invalid_request", "invalid_request"); return(View(viewModel)); } catch (BaseUIException ex) { ModelState.AddModelError(ex.Code, ex.Code); return(View(viewModel)); } }
public async Task <IActionResult> Authenticate(string userName, string password) { var secretKey = _configuration.GetValue <string>("TokenKey"); var tokenTimeOut = _configuration.GetValue <int>("TokenTimeOut"); // authentication successful so generate jwt token var tokenHandler = new JwtSecurityTokenHandler(); var key = Encoding.UTF8.GetBytes(secretKey); var tokenDescriptor = new SecurityTokenDescriptor { Subject = new ClaimsIdentity(new Claim[] { new Claim(ClaimTypes.Name, "Ali Rezaei"), new Claim("email", "*****@*****.**"), }), Expires = DateTime.UtcNow.AddMinutes(tokenTimeOut), SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature) }; var securityToken = tokenHandler.CreateToken(tokenDescriptor); var token = tokenHandler.WriteToken(securityToken); var model = new AuthenticateViewModel() { RefreshToken = "", Token = token }; return(Ok(model)); }
public ActionResult ChangePassword() { AuthenticateViewModel model = new AuthenticateViewModel(); model.objchangePassword = new ChangePassword(); return(View(model)); }
public ActionResult Login(AuthenticateViewModel model) { if (_facade.Login(model.Username, model.Pincode)) { return(Ok(CreateToken(model.Username))); } return(new UnauthorizedWithChallengeResult("Bearer realm=\"jwt\"")); }
private async Task <AuthenticateViewModel> BuildLoginViewModelAsync(AuthenticateViewModel model) { var vm = await BuildLoginViewModelAsync(model.ReturnUrl); vm.Username = model.Username; vm.RememberLogin = model.RememberLogin; return(vm); }
public ActionResult Login() { var returnValue = new AuthenticateViewModel(); returnValue.Username = "******"; returnValue.Pincode = "0000"; return(Json(returnValue)); }
public IHttpActionResult GetUserAuthenticated([FromBody] AuthenticateViewModel model) { var userName = model.Username; var pwd = model.Password; // Code logic here. return(Ok(model)); }
public bool AuthenticateUserService(AuthenticateViewModel user) { if ((user.Username == "test" && user.Password == "test")) { return(true); } return(false); }
public ActionResult ResetPassword(string t, string e) { AuthenticateViewModel model = new AuthenticateViewModel(); model.objResetPassword = new ResetPassword(); model.objResetPassword.emailAddress = e; model.objResetPassword.resetCode = t; return(View(model)); }
public async Task <IActionResult> Index(AuthenticateViewModel viewModel, CancellationToken token) { if (viewModel == null) { return(RedirectToAction("Index", "Errors", new { code = "invalid_request", ReturnUrl = $"{Request.Path}{Request.QueryString}", area = string.Empty })); } switch (viewModel.Action) { case "SENDCONFIRMATIONCODE": viewModel.CheckRequiredFields(ModelState); if (!ModelState.IsValid) { return(View(viewModel)); } try { await _emailAuthService.SendCode(viewModel.Email, token); SetSuccessMessage("confirmationcode_sent"); return(View(viewModel)); } catch (BaseUIException ex) { ModelState.AddModelError(ex.Code, ex.Code); return(View(viewModel)); } default: viewModel.CheckRequiredFields(ModelState); viewModel.CheckConfirmationCode(ModelState); if (!ModelState.IsValid) { return(View(viewModel)); } try { var user = await _emailAuthService.Authenticate(viewModel.Email, viewModel.OTPCode.Value, token); return(await Authenticate(viewModel.ReturnUrl, Constants.AMR, user, token, viewModel.RememberLogin)); } catch (CryptographicException) { ModelState.AddModelError("invalid_request", "invalid_request"); return(View(viewModel)); } catch (BaseUIException ex) { ModelState.AddModelError(ex.Code, ex.Code); return(View(viewModel)); } } }
//[Route("authenticate")] public IHttpActionResult Post(AuthenticateViewModel viewModel) { /* REPLACE THIS WITH REAL AUTHENTICATION * ----------------------------------------------*/ if (!(viewModel.Username == "test" && viewModel.Password == "test")) { return(Ok(new { success = false, message = "User code or password is incorrect" })); } return(Ok(new { success = true })); }
public IActionResult Authenticate([FromBody] AuthenticateViewModel model) { var user = _autenticacion.Authenticate(model.Username, model.Password); if (user == null) { return(BadRequest(new { message = "Nombre de usuario o contraseña incorrectos" })); } return(Ok(user)); }
public async Task <IActionResult> Auth([FromBody] AuthenticateViewModel model) { if (model == null) { return(Forbid()); } var cliente = await _authenticationService.AuthenticateCliente(model.UserName, model.Password); return(ResponseWithAllNotifications(cliente, "Autenticado com sucesso!")); }
public IActionResult Authenticate([FromBody] AuthenticateViewModel model) { var user = _userService.Authenticate(model.Username, model.Password); if (user == null) { return(BadRequest(new { message = "Username or password is incorrect" })); } return(Ok(user)); }
public ViewResult ChangePasswordIndex(AuthenticateViewModel viewModel) { var loggedInUser = CookieHelper.GetCookie <UserModel>("LoggedInUser"); if (loggedInUser != null) { return(View("ChangePassword", viewModel)); } return(View("Index", viewModel)); // Login screen }
public async Task <ActionResult> ForgotPassword(AuthenticateViewModel model) { await model.ForgotPassword(Session); if (model.errorOccurred == true) { return(RedirectToAction("ForgotPassword", "Authenticate")); } model.ErrorMessage = "Email Sent."; return(View("ForgotPassword", model)); }
public async Task <ActionResult> LogOut() { AuthenticateViewModel obj = new AuthenticateViewModel(); await obj.LogOut(Session); if (obj.errorOccurred == true) { return(RedirectToAction("Index", "Authenticate")); } return(RedirectToAction("Index", "Authenticate")); }
public C1Rescponse <string> Authenticate([FromBody] AuthenticateViewModel model) { Argument.Require(model != null, "Параметры не заданы."); var response = c1Service.Authenticate(model.CertificateId, model.TextForUser); if (response.StatusCode >= STATUS_BAD_MIN) { return(new C1Rescponse <string>(response)); } return(WaitTillResponse <string>(response.TransactionGuid)); }