public ActionResult Giris(string username, string password, User user)
{
LoginValidation loginValidation = new LoginValidation();
ValidationResult result = loginValidation.Validate(user);
if (result.IsValid == false)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return(View(user));
}
else
{
var loginuser = _userService.CheckUser(username, password);
if (loginuser != null)
{
AuthenticationHelper.CreateAuthCookie(loginuser.UserId, loginuser.Username, loginuser.Email, DateTime.Now.AddDays(15), _userService.GetUserRole(username).Select(x => x.RoleName).ToArray(), false, loginuser.FirstName, loginuser.LastName);
return(RedirectToAction("Index", "AnaSayfa"));
}
ViewBag.LoginError = "Kullanıcı adı veya şifre yanlış!";
return(View());
}
}
private void tbxUsername_TextChanged(object sender, TextChangedEventArgs e)
{
var textbox = sender as TextBox;
var input = textbox.Text;
LoginValidation loginValidation = new LoginValidation();
bool isUsernameAvailable = true;
try
{
isUsernameAvailable = loginValidation.IsUsernameAvailable(input);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.ToString());
}
if (isUsernameAvailable)
{
ImgAcceptMark.Visibility = Visibility.Visible;
tbxUsername.Foreground = Brushes.Black;
gotUsername = true;
}
else
{
ImgAcceptMark.Visibility = Visibility.Hidden;
tbxUsername.Foreground = Brushes.Red;
gotUsername = false;
}
}
private void btnLogIn_Click(object sender, RoutedEventArgs e)
{
try
{
var loginValidationService = new LoginValidation();
var isValid = loginValidationService.UsernamePasswordValidation(tbUserName.Text.ToString(), tbxPassword.Password.ToString());
if (isValid)
{
AdminHome adminHome = new AdminHome();
adminHome.Show();
this.Close();
}
else
{
//Things which happen before the timer starts
lableWrongPassword.Visibility = Visibility.Visible;
//Start the timer
dispatcherTimer.Start();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message.ToString(), "Error");
}
}
public async Task <IActionResult> Authenticate([FromBody] LoginViewModel model)
{
if (model == null)
{
return(NoContent());
}
var validation = new LoginValidation(_user).Validate(model);
if (!validation.IsValid)
{
return(BadRequest(new Validator(validation)));
}
var user = await _user.Authenticate(model.Login, model.Password);
if (user == null)
{
return(NotFound());
}
else
{
return(Ok(new { token = new JWTToken(_configuration).Generate(user) }));
}
}
public async Task Login(IdentityUser usuario, string senha)
{
var validationLoginResult = new LoginValidation().Validate(usuario);
var validationSenhaUsuarioResult = new SenhaUsuarioValidation().Validate(senha);
if (!validationLoginResult.IsValid)
{
_notifications.Add(validationLoginResult);
return;
}
if (!validationSenhaUsuarioResult.IsValid)
{
_notifications.Add(validationSenhaUsuarioResult);
return;
}
var result = await _signInManager.PasswordSignInAsync(usuario.Email, senha, false, false);
if (!result.Succeeded)
{
_notifications.Add("E-mail ou senha incorretos.");
return;
}
}
public IActionResult Update(Kunder K)
{
var Session = new SessionData(_httpContextAccessor);
var UserID = Session.GetSessionKundId();
var Validate = new RegisterValidation();
if (_Connection.GetKund(UserID).AnvandarNamn != K.Kund.AnvandarNamn)
{
if (!Validate.ValidateRegister(K, _Connection.GetAllKunder().ToList()))
{
ModelState.AddModelError("Kund.AnvandarNamn", "Användarnamn taget");
return(View(K));
}
}
if (ModelState.IsValid)
{
_Connection.UpdateKund(K, Session.GetSessionKund());
var LoginValidation = new LoginValidation(_Connection, _httpContextAccessor);
LoginValidation.CheckLogin(K);
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(K));
}
}
private void AttemptLogIn()
{
LoginValidation login = new LoginValidation(Username, Password, this.ActionOnError);
User user = null;
if (LoginValidation.ValidateUserInput(ref user))
{
Student student = StudentValidation.GetStudentDataByUser(user);
if (student == null)
{
MessageBox.Show("User '" + user.Username + "' does not have field facultyNumber.");
Password = "";
OnPropertyChanged("Password");
return;
}
OnSuccessfulLogin(student);
}
else
{
Password = "";
OnPropertyChanged("Password");
}
}
public IActionResult Login(Kunder K)
{
var Validate = new LoginValidation(_Connection, _httpContextAccessor);
var Kunder = _Connection.GetAllKunder();
if (Validate.ValidateLogin(K, Kunder) && Validate.ValidatePassword(K, Kunder))
{
Validate.CheckLogin(K);
return(RedirectToAction("Index", "Home"));
}
else
{
if (!Validate.ValidateLogin(K, Kunder))
{
ModelState.AddModelError("Kund.Anvandarnamn", "Fel Användarnamn");
}
if (!Validate.ValidatePassword(K, Kunder))
{
ModelState.AddModelError("Kund.Losenord", "Fel Lösenord");
}
return(View(K));
}
}
public async Task Registrar(IdentityUser novoUsuario, string senha)
{
var validationNovoUsuarioResult = new LoginValidation().Validate(novoUsuario);
var validationSenhaUsuarioResult = new SenhaUsuarioValidation().Validate(senha);
if (!validationNovoUsuarioResult.IsValid)
{
_notifications.Add(validationNovoUsuarioResult);
return;
}
if (!validationSenhaUsuarioResult.IsValid)
{
_notifications.Add(validationSenhaUsuarioResult);
return;
}
var result = await _userManager.CreateAsync(novoUsuario, senha);
if (result.Succeeded)
{
await _signInManager.SignInAsync(novoUsuario, false);
}
else
{
_notifications.Add(result.Errors.Select(x => x.Description));
return;
}
}
public async Task <UsuarioAutenticadoTokenViewModel> Login(IdentityUser usuario, string senha)
{
var validationLoginResult = new LoginValidation().Validate(usuario);
var validationSenhaUsuarioResult = new SenhaUsuarioValidation().Validate(senha);
if (!validationLoginResult.IsValid)
{
_notifications.Add(validationLoginResult);
return(null);
}
if (!validationSenhaUsuarioResult.IsValid)
{
_notifications.Add(validationSenhaUsuarioResult);
return(null);
}
var result = await _signInManager.PasswordSignInAsync(usuario.Email, senha, false, false);
if (!result.Succeeded)
{
_notifications.Add("E-mail ou senha incorretos.");
return(null);
}
return(await GerarTokenAcesso(usuario.Email));
}
public async Task <IActionResult> Authenticate([FromBody] LoginViewModel model)
{
if (model == null)
{
return(NotFound());
}
var validation = new LoginValidation(_login).Validate(model);
if (!validation.IsValid)
{
var returnValidate = new
{
erros = validation.Errors.Select(x => new
{
field = x.PropertyName,
error = x.ErrorMessage
})
};
return(BadRequest(returnValidate));
}
var usuario = await _login.Authenticate(model);
var retorno = new
{
token = new Token(_configuration).Generate(usuario)
};
return(Ok(retorno));
}
public Welcome()
{
validation = new LoginValidation();
controller = new Controller();
InitializeComponent();
ResizeMode = ResizeMode.NoResize;
}
// Attention!
// Data used for these tests are depend from other sources (like webservice or database)
// If eg.:
// - pesel will shown on black list then tests can be failed!
// - Some user did invalid vote (0 or 2, 3, ... candidates)
private LoginValidation Execute(string firstName, string lastName, string pesel)
{
LoginCredentials loginCredentials = new LoginCredentials(firstName, lastName, pesel);
Domain.Models.User user = new Domain.Models.User(loginCredentials, _fixture.Context, _fixture.Webservice);
LoginValidation loginValidation = user.Login();
return(loginValidation);
}
public void ValidateUserNotAuthenticated(string email, string password)
{
var user = _mapper.Map<Entities.User>(userViewModel);
_user.Setup(x => x.Authenticate(user.Email, user.Password)).ReturnsAsync(user);
var validation = new LoginValidation(_userApplication).Validate(new LoginViewModel() { Login = email, Password = password });
Assert.False(validation.IsValid);
Assert.True(validation.Errors.Where(x => x.ErrorMessage == "Usuário não encontrado.").Any());
}
public async void VerifyUserIsNotAuthenticated(string email, string password)
{
var user = _mapper.Map<Entities.User>(userViewModel);
_user.Setup(x => x.Authenticate(user.Email, user.Password)).ReturnsAsync(user);
var validation = new LoginValidation(_userApplication).Validate(new LoginViewModel() { Login = email, Password = password });
var authenticate = await _userApplication.Authenticate(email, password);
user.ToExpectedObject().ShouldNotMatch(authenticate);
}
public bool Validate()
{
var validation = new LoginValidation(this);
if (validation.Invalid)
{
Notifications = validation.Notifications;
return(false);
}
return(true);
}
public async Task <ActionResult <dynamic> > Authenticate([FromBody] UserRequest model)
{
LoginValidation validator = new LoginValidation(model, _userBusiness);
ValidationResult result = validator.Validate(model);
if (!result.IsValid)
{
return(BadRequest(result.Errors[0].ErrorMessage));
}
var user = _userBusiness.Validate(model.Username, model.Password);
return(Ok(new Login(user)));
}
public void ReturnsLoginValidatorErrors()
{
LoginValidation loginValidation = Execute("A", "B", "0");
Assert.True(loginValidation.Error);
Assert.Contains(loginValidation.LoginErrors,
e => e == LoginError.UserFirstNameIsTooShort);
Assert.Contains(loginValidation.LoginErrors,
e => e == LoginError.UserLastNameIsTooShort);
Assert.Contains(loginValidation.LoginErrors,
e => e == LoginError.PeselIsNotValid);
loginValidation = Execute("Ce", "De", "10321519761");
Assert.True(loginValidation.Warning);
Assert.Contains(loginValidation.LoginWarnings,
e => e == LoginWarning.UserIsNotEighteen);
}
public IActionResult Login(LoginValidation userToCheck)
{
if (ModelState.IsValid)
{
User IsUser = _context.Users.SingleOrDefault(u => u.Email == userToCheck.Email);
if (IsUser != null)
{
var Hasher = new PasswordHasher <User>();
if (0 != Hasher.VerifyHashedPassword(IsUser, IsUser.Password, userToCheck.Password))
{
HttpContext.Session.SetInt32("UserId", (int)IsUser.UserId);
return(RedirectToAction("Index", "Idea"));
}
}
}
return(View("Index"));
}
public IActionResult Logar([FromBody] LoginDTO loginDTO)
{
LoginValidation validation = new LoginValidation();
ValidationResult validationResult = validation.Validate(loginDTO);
if (!validationResult.IsValid)
{
return(ResponseValidationResult(validationResult));
}
try
{
var usuario = _usuarioService.Logar(loginDTO.Email, loginDTO.Senha);
if (usuario != null)
{
var data = new
{
result = new
{
nome = usuario.Nome,
email = usuario.Email,
}
};
return(Ok(new { success = true, data = data }));
}
else
{
var data = new
{
result = new
{
mensagem = "Usuário não encontrado!"
}
};
return(NotFound(new { success = true, data = data }));
}
}
catch (Exception ex)
{
return(BadRequest(new { success = false, errors = new KeyValuePair <string, string>("BadRequest", $"Erro ao executar o método Logar: {ex.Message}") }));
}
}
private void Login(object parameter)
{
var _loginValidation = new LoginValidation(Username, Password, ActionOnError);
if (_loginValidation.ValidateUserInput(ref _user))
{
var studentValidation = new StudentValidation(ActionOnError);
if (_user != null)
{
var student = studentValidation.GetStudentDataByUser(_user);
var mainWindow = new MainWindow(student);
mainWindow.Show();
_loginWindow.Close();
}
}
}
public bool Register(string username, string password, string loginDate, string key)
{
try
{
LoginValidation lv = new LoginValidation();
DateTime date = DateTime.Parse(loginDate);
lv.ParameterValidation(username, password, date, key);
lv.LoginDateValidation(username, date);
lv.KeyValidation(username, password, date, key);
lv.Register(username, password);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public ActionResult Login(LoginModel model)
{
logger.Info("begin");
try
{
//waking up the BE, may give error..(channel security error)
bool online = WSStub.beIsReady();
}
catch (Exception e)
{
logger.ErrorFormat("beIsReady gave error {0} :{1} mabee a wakeup error", e.Message, e.StackTrace);
}
if (ModelState.IsValid)
{
string username = model.UserName;
string password = model.Password;
LoginRequest loginRequest = new LoginRequest();
loginRequest.UserName = username;
loginRequest.Password = password;
try
{
LoginResponse loginResponse = WSStub.login(loginRequest);
if (loginResponse.Code == LoginResponseCode.OK)
{
logger.Info("login success");
NavigationHandler.clearSession();
NavigationHandler.LoggedInfo = loginResponse.UserInfo;
return(RedirectToAction("Index", "Home"));
}
else
{
logger.Info("error in login");
ModelState.AddModelError("", LoginValidation.ErrorCodeToString(loginResponse.Code));
}
}
catch (Exception e)
{
logger.Info("exception: " + e);
ModelState.AddModelError("", LoginValidation.ErrorCodeToString(LoginResponseCode.SYSTEM_ERROR));
}
}
logger.Info("end");
return(View(model));
}
private async void BtnLogin_Clicked(object sender, EventArgs e)
{
activityControl.MakeVisible(ActivityLayout, activity);
btnLogin.IsEnabled = false;
User logonUser = new User();
string email = entryEmail.Text;
string password = entryPassword.Text;
LoginValidation validate = new LoginValidation();
if (validate.ReturnSituation(entryEmail.Text, entryPassword.Text) != "Success")
{
activityControl.MakeUnVisible(ActivityLayout, activity);
btnLogin.IsEnabled = true;
await DisplayAlert("Uyarı", validate.ReturnSituation(entryEmail.Text, entryPassword.Text), "OK");
}
else
{
try
{
logonUser = await service.Login(email, password);
if (logonUser != null)
{
CrossSecureStorage.Current.SetValue("loggedUserId", logonUser.Id.ToString());
CrossSecureStorage.Current.SetValue("loggedUserEmail", logonUser.Email);
CrossSecureStorage.Current.SetValue("loggedUserPassword", logonUser.Password);
Application.Current.MainPage = new NavigationPage(new IndexPageMain());
}
else
{
activityControl.MakeUnVisible(ActivityLayout, activity);
btnLogin.IsEnabled = true;
await DisplayAlert("Uyarı", "Kullanıcı adı veya şifre hatalı", "OK");
}
}
catch (Exception ex)
{
activityControl.MakeUnVisible(ActivityLayout, activity);
btnLogin.IsEnabled = true;
await DisplayAlert("Uyarı", "Kullanıcı adı veya şifre hatalı", "OK");
}
}
}
public void executeTest()
{
//prepare test
List <string> actual = new List <string>();
LoginValidation myLV = new LoginValidation("myusername", "mypassword");
IDBConnect dbConnector = new dbCommTEST();
myLV.setDBConnectInstance(dbConnector);
actual = myLV.execute();
//prepare expected values
List <string> expected = new List <string>();
expected.Add("01");
expected.Add("1");
expected.Add("Joshua Nielsen");
Assert.AreEqual(expected[0], actual[0]);
Assert.AreEqual(expected[1], actual[1]);
Assert.AreEqual(expected[2], actual[2]);
}
public ActionResult validatelogin(LoginValidation lv)
{
if (ModelState.IsValid)
{
string username = Request.Form["username"];
string password = Request.Form["password"];
bool res = LayoutOperations.Checklogin(username, password);
if (res == true)
{
return(View("validatelogin"));
}
else
{
return(View("LoginPage"));
}
}
else
{
return(View("LoginPage"));
}
}
public async Task <RetornoAutenticacaoViewModel> Authenticate(LoginViewModel autenticacao)
{
ValidationResult _validationResult = new LoginValidation().Validate(autenticacao);
if (!_validationResult.IsValid)
{
throw new ApiException(_validationResult.GetErrors(), ApiErrorCodes.MODNOTVALD);
}
SignInResult _signInResult = await _signInManager.PasswordSignInAsync(autenticacao.Email, autenticacao.Senha, isPersistent : true, lockoutOnFailure : true);
if (!_signInResult.Succeeded)
{
if (_signInResult.IsLockedOut)
{
throw new ApiException(ApiErrorCodes.LCKLOG);
}
else if (_signInResult.IsNotAllowed)
{
throw new ApiException(ApiErrorCodes.NOTALLW);
}
else
{
throw new ApiException(ApiErrorCodes.INVUSPASS);
}
}
Usuario _autenticacao = _repository.GetByUserName(
autenticacao.Email,
q => q
.Include(i => i.Perfil));
string _generatedToken = GenerateTokenByAutenticacao(_autenticacao);
return(new RetornoAutenticacaoViewModel(token: _generatedToken,
isSenhaExpirada: _autenticacao.IsExpiredPassword(),
usuarioId: _autenticacao.Id));
}
public IActionResult Create([Bind] Login user)
{
LoginValidation validator = new LoginValidation();
ValidationResult result = validator.Validate(user);
if (!result.IsValid)
{
foreach (ValidationFailure failer in result.Errors)
{
ModelState.AddModelError(failer.PropertyName, failer.ErrorMessage);
}
}
else
{
//Acciones que queramos ejecutar (crear el usuario)
}
return(View(user));
}
private void loginbtn_Click(object sender, EventArgs e)
{
try
{
InputValidation();
LoginValidation access = new LoginValidation();
var data = access.InputValidation(emailaddressltxt.Text, Passwordtxt.Text);
Dashboard dashboard = new Dashboard();
this.Hide();
if (access.GetRole(data))
{
dashboard.Show();
}
else
{
// Todo add login page for users.
MessageBox.Show("you are not an admin");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public User GetUser(string username, string password)
{
LoginValidation lv = new LoginValidation(username, password, _controller.TellUser);
return(lv.ValidateUserInput(out var user) ? user : null);
}
