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));
}
