public async Task <IActionResult> UserLogin(UserSignInModel userSignInModel)
{
if (ModelState.IsValid)
{
if (User.Identity.IsAuthenticated)
{
return(BadRequest("user is already logged in"));
}
Microsoft.AspNetCore.Identity.SignInResult result = await _authService.Login(userSignInModel.Password, userSignInModel.Email);
if (result.Succeeded)
{
IdentityUser identityUser = await _authService.GetIdentUserByEmail(userSignInModel.Email);
return(Ok(_mapper.Map <AuthOutgoingDto>(identityUser)));
}
ModelState.AddModelError("", "Invalid username or password");
}
IEnumerable <string> errorList = ModelState.SelectMany(m => m.Value.Errors.Select(e => e.ErrorMessage));
return(BadRequest(errorList));
}
public async Task<IActionResult> SingIn([FromBody]UserSignInModel model)
{
try
{
await _accountService.SignInAsync(model);
TokenResponseModel token = await _jwtProvider.GetTokensAsync(model.Email);
return Ok(token);
}
catch(ServerException ex)
{
switch (ex.ErrorCode)
{
case Enums.Errors.Unauthorized:
return Unauthorized(ex.Description);
break;
case Enums.Errors.NotFound:
return NotFound(ex.Description);
break;
default:
break;
}
}
return Ok();
}
public async Task <IHttpActionResult> SignInAsync(
UserSignInModel model)
{
var user = await appService.SignInAsync(OwinContext, model);
return(Ok(user.Id));
}
public async Task <IActionResult> UserLogin(UserSignInModel userSignInModel, string returnUrl)
{
// valid the login form and login user if success
if (ModelState.IsValid)
{
var result = await _accountRepository.SignInUserAsync(userSignInModel);
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("", "You account is locked, Please try again");
}
else
{
ModelState.AddModelError("", "Invalid credentials!");
}
}
return(View(userSignInModel));
}
public async Task <IActionResult> SignUp([FromBody] UserSignInModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
if (await _userManager.FindByEmailAsync(model.Email) != null)
{
return(BadRequest("Email exists"));
}
var user = new ApplicationUser()
{
Email = model.Email, UserName = model.Email
};
var results = await _userManager.CreateAsync(user, model.Password);
if (!results.Succeeded)
{
throw new Exception($"Error: {results.Errors}");
}
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public Task <AppUser> SignInAsync(
IOwinContext owinContext,
UserSignInModel model)
{
model.Valid();
var timeSpan = TimeSpan.FromHours(8);
return(service.SignInAsync(owinContext, model.UserName, model.UserPwd, timeSpan));
}
public async Task<IActionResult> Login(UserSignInModel userModel) {
if (!ModelState.IsValid)
return BadRequest("Model state issue");
var user = await factory.GetByNameAsync(userModel.Name);
if (user == null)
return BadRequest("User not found");
if (userModel.Password != user.Password)
return BadRequest("Incorrect password");
var token = AuthService.GenerateToken(user.Id);
userModel.Token = token;
return Ok(userModel);
}
public async Task <IResponse> SignIn(UserSignInModel model)
{
IResponse response = null;
try
{
}
catch (Exception ex)
{
_logger.LogWarning("Error when sign In", ex);
}
return(await Task.FromResult(response));
}
[ValidateAntiForgeryToken]//güvenlik önlemi. dışarıdan değer gönderilemez.
public async Task <IActionResult> GirisYap(UserSignInModel model)
{
if (ModelState.IsValid)
{
var identityResult = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, model.RememberMe, false);
if (identityResult.Succeeded)
{
return(RedirectToAction("Index", "Panel"));
}
ModelState.AddModelError("", "Kullanıcı adı yada şifre hatalı");
}
return(View("Index", model));
}
public async Task <(bool, UserModel)> SignInAsync(UserSignInModel userSignInModel)
{
var user = await _context.Users.Where(u => u.Email == userSignInModel.Email)
.SingleOrDefaultAsync();
if (user == null)
{
throw new NotFoundException();
}
if (user.Password.Equals(userSignInModel.Password) && user.IsEmailComfirmed == true)
{
return(true, _mapper.Map <UserModel>(user));
}
else
{
return(false, null);
}
}
public Task SignInAsync(HttpContext httpContext, UserSignInModel user)
{
var claims = new[]
{
new Claim(ClaimTypes.Email, user.Email),
new Claim(ClaimTypes.Role, user.Role.Name),
new Claim("Id", user.Id.ToString()),
};
var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
var authProperties = new AuthenticationProperties
{
IsPersistent = true,
ExpiresUtc = DateTimeOffset.UtcNow.AddDays(2),
};
return(httpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme,
new ClaimsPrincipal(claimsIdentity), authProperties));
}
private void button6_Click(object sender, EventArgs e)
{
Users users = new Users();
UserSignInModel userSignIn = new UserSignInModel();
userSignIn.Email = txbx_email.Text;
userSignIn.Password = txbx_password.Text;
dbContext.GetAllData(users.GetType());
Table <Users> data = dbContext.userData;
if (DbExtensions.HasUserByEmail(data, userSignIn.Email) && DbExtensions.HasUserByPassword(data, userSignIn.Password))
{
AddCAR addCAR = new AddCAR(userSignIn.Email);
this.Hide();
addCAR.ShowDialog();
}
else
{
MessageBox.Show("Bele Bir User Qeydiyyatdan Kecmeyib");
}
}
private void button1_Click(object sender, EventArgs e)
{
text_errorEmail.Text = "";
text_errorPassword.Text = "";
Users users = new Users();
UserSignInModel signInModel = new UserSignInModel();
signInModel.Email = text_sign_email.Text;
signInModel.Password = text_sign_password.Text;
UserValidator validator = new UserValidator();
if (!validator.Valid <UserSignInModel>(signInModel))
{
carSearch = new CarSearch(signInModel.Email);
dbContext.GetAllData(users.GetType());
Table <Users> data = dbContext.userData;
if (DbExtensions.HasUserByEmail(data, signInModel.Email) && DbExtensions.HasUserByPassword(data, signInModel.Password))
{
carSearch = new CarSearch(signInModel.Email);
this.Hide();
carSearch.ShowDialog();
}
}
else
{
var errors = validator.GetAllData();
foreach (var user in errors)
{
if (user.Key == 3)
{
text_errorEmail.Text = user.Value;
}
if (user.Key == 4)
{
text_errorPassword.Text = user.Value;
}
}
}
}
public async Task SignInAsync(UserSignInModel userModel)
{
User user = await _userRepository.GetUserByEmailAsync(userModel.Email);
if (user is null)
{
throw new ServerException(Constants.Errors.USER_NOT_FOUND, Enums.Errors.NotFound);
}
if (user.IsBlocked)
{
throw new ServerException(Constants.Errors.USER_IS_BLOCKED, Enums.Errors.Unauthorized);
}
var result =
await _signInManager.PasswordSignInAsync(user, userModel.Password, userModel.IsRemember, false);
if (!result.Succeeded)
{
throw new ServerException(Constants.Errors.INVALID_CREDENTIALS, Enums.Errors.Unauthorized);
}
}
public async Task <IActionResult> SignIn(UserSignInModel userSignInModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { title = "Model is not valid" }));
}
var(state, user) = await _authService.SignInAsync(userSignInModel);
if (state)
{
var access_token = new JwtSecurityTokenHandler().WriteToken(await _tokenService.GenerateAccessTokenAsync(user.Id));
var refresh_token = (await _tokenService.GenerateRefreshTokenAsync(user)).Token;
return(Ok(new
{
access_token,
refresh_token
}));
}
return(NotFound(new { title = "You have entered an invalid username or password" }));
}
public async Task <IActionResult> SignUp(UserSignInModel model)
{
if (ModelState.IsValid)
{
if (await _userManager.FindByEmailAsync(model.Email) != null)
{
return(BadRequest("Email exists"));
}
var user = new ApplicationUser()
{
Email = model.Email, UserName = model.Username
};
var results = await _userManager.CreateAsync(user, model.Password);
if (results.Succeeded)
{
//success
}
}
return(BadRequest());
}
public async Task <IActionResult> Register(UserSignInModel model)
{
if (ModelState.IsValid)
{
User user = new User {
Email = model.Email, UserName = model.Email, DateOfRegistration = DateTime.Now
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await signInManager.SignInWithClaimsAsync(user, false, new List <Claim>() { new Claim(ClaimTypes.Role, "user") });
}
else
{
foreach (var error in result.Errors)
{
log.LogError(error.Description, null);
}
}
}
return(RedirectToAction("MainPage", "Main"));
}
public async Task <TokenResponseModel> SignInAsync(UserSignInModel signInModel)
{
var user = await _userManager.FindByNameAsync(signInModel.Email);
if (user is null)
{
throw new CustomExeption(Constants.Error.LOGIN_FAILD_NO_USER_WITH_THIS_EMAIL,
StatusCodes.Status400BadRequest);
}
var signIn = await _signInManager.PasswordSignInAsync(signInModel.Email, signInModel.Password, false, false);
if (!signIn.Succeeded)
{
throw new CustomExeption(Constants.Error.LOGIN_FAILD_WRONG_PASSWORD, StatusCodes.Status400BadRequest);
}
var roleList = await _userManager.GetRolesAsync(user);
if (roleList is null)
{
throw new Exception($"{Constants.Error.ERROR_NO_USERROLE} {StatusCodes.Status500InternalServerError}");
}
bool isRoleAdmin = roleList.Any(s => s.Contains("admin"));
var result = new TokenResponseModel();
if (isRoleAdmin)
{
result.AccessToken = _jwtProvider.GenerateJwt(signInModel.Email, "admin");
return(result);
}
result.AccessToken = _jwtProvider.GenerateJwt(signInModel.Email, "user");
return(result);
}
public async Task <ActionResult> SignIn(UserSignInModel userView)
{
User user = await userManager.Users
.Include(u => u.LockRecord)
.Where(u => u.Email == userView.Email || u.UserName == userView.UserName)
.FirstOrDefaultAsync();
if (user != null)
{
var result = await signInManager.CheckPasswordSignInAsync(user, userView.Password, true);
if (result.Succeeded && user.EmailConfirmed)
{
logger.LogInformation($"Account/SignIn: User {user.Email} successfully signed in");
IList <string> roles = await userManager.GetRolesAsync(user);
return(Ok(new {
id = user.Id,
userName = user.UserName,
email = user.Email,
accessToken = tokensService.GetAccessToken(user, roles),
refreshToken = tokensService.GetRefreshToken(user),
roles
}));
}
else if (result.IsLockedOut)
{
logger.LogInformation($"Account/SignIn: User {user.Email} has been blocked");
return(Unauthorized(new { error = $"Account blocked: {user.ReasonOfLockOut}" }));
}
else
{
return(Unauthorized(new { error = "Email is not confirmed" }));
}
}
return(UnprocessableEntity(new { error = "Wrong email or password" }));
}
public ActionResult ChangePassword(UserSignInModel model, string newPassword, string confirmPassword)
{
try {
if (_userService.ValidateLogin(model.Username, model.Password)) {
if (newPassword.Equals(confirmPassword, StringComparison.Ordinal)) {
var user = _userService.GetUserByUsername(model.Username);
var salt = "";
var hashedPassword = SecurityHelper.HashPassword(newPassword, ref salt);
user.PasswordHash = hashedPassword;
user.PasswordSalt = salt;
user.IsLocked = false;
Success("Record Saved.");
_userService.Update(user);
return RedirectToAction("Index", "Home");
}
throw new Exception("Passwords do not match");
}
throw new Exception("Current Password is incorrect");
} catch (Exception ex) {
Error(ex.Message);
return RedirectToAction("ChangePassword");
}
}
public async Task <SignInResult> SignInUserAsync(UserSignInModel userSignInModel)
{
// sign in user
return(await _signManager.PasswordSignInAsync(
userSignInModel.Email, userSignInModel.Password, userSignInModel.RememberMe, true));
}
public PartialViewResult LoadForgotPassword(UserSignInModel model)
{
return PartialView("_ForgotPassword", model);
}
public ActionResult ResetPassword(UserSignInModel model, string returnUrl = "swag")
{
try
{
User user = _userService.GetUserByUsername(model.Username);
if (user != null)
{
var salt = "";
var tempPassword = CommonHelper.GenerateRandomString();
var hashedPassword = SecurityHelper.HashPassword(tempPassword, ref salt);
user.PasswordHash = hashedPassword;
user.PasswordSalt = salt;
user.IsLocked = true;
_userService.Update(user);
_emailService.SendResetPasswordEmail(user, tempPassword);
}
else
{
throw new Exception("Invalid username.");
}
} catch (Exception ex){
return RedirectToAction("SignIn",ex.Message);
}
return RedirectToAction("SignIn", "User");
}
public ActionResult SignIn(string returnUrl)
{
var model = new UserSignInModel();
model.ReturnUrl = returnUrl;
return View("SignIn", model);
}
public ActionResult SignIn(UserSignInModel model, string returnUrl)
{
try {
if (_userService.ValidateLogin(model.Username, model.Password)) {
var user = _userService.GetUserByUsername(model.Username);
if (_userService.VerifyKeyCheck(user)) {
// Set the last login date
user.LastLogin = DateTime.Now;
user.PasswordFailuresSinceLastSuccess = 0;
_userService.Update(user);
FormsAuthentication.SetAuthCookie(model.Username, model.RememberMe);
// Store data in session
SessionDataHelper.Username = model.Username;
SessionDataHelper.UserRole = user.Role;
SessionDataHelper.UserId = user.Id;
SessionDataHelper.SessionId = System.Web.HttpContext.Current.Session.SessionID;
// Store the login entry
if (SessionDataHelper.UserId != 1)
{
_loginService.LogUser(SessionDataHelper.UserId, SessionDataHelper.SessionId);
}
SessionDataHelper.SubscriberId = user.SubscriberId ?? 0;
if (Url.IsLocalUrl(returnUrl)) {
return Redirect(returnUrl);
}
if (user.IsLocked)
{
UserSignInModel signInModel = new UserSignInModel();
return ChangePassword();
}
return RedirectToAction("Index", "Home");
}
throw new Exception("Your subscription is out of date, please provide payment to renew.");
}
throw new Exception("Your username/password combination was incorrect");
} catch (Exception ex) {
ModelState.AddModelError("Error", ex.Message);
}
return View(model);
}
public async Task <IActionResult> SignIn([FromBody] UserSignInModel model)
{
return(Json(await _managerUserControl.SignIn(model)));
}
public async Task <IActionResult> SignIn([FromBody] UserSignInModel signInModel)
{
var result = await _accountService.SignInAsync(signInModel);
return(Ok(result));
}
public ActionResult ChangePassword()
{
var model = new UserSignInModel();
model.Username = SessionDataHelper.Username;
return View("_ChangePasswordPartial", model);
}
public async Task <UserStatusModel> SignIn(UserSignInModel model)
{
var user = await _managerUser.FindByEmailAsync(model.Email);
if (user == null || !await _managerUser.CheckPasswordAsync(user, model.Password))
{
_eNotFound <UserStatusModel>("User not found");
}
var userRoles = await _managerUser.GetRolesAsync(user);
var token = _serviceToken.GenerateToken(user.Id, user.Email, userRoles);
UserLoginInfo li = null;
string callbackToken = null;
if (!string.IsNullOrWhiteSpace(model.ProviderSlug))
{
var provider = await _repositoryProvider.GetFirst(x => x.Slug == model.ProviderSlug && x.State == MREntityState.Active);
if (provider != null && provider.Options.IsEnabled)
{
li = new UserLoginInfo(provider.Id, token, provider.Slug);
_serviceToken.GenerateToken("SOME_SECRET_KEY", "MR_IDENTITY", "SOME_PROVIDER", 60, new List <Tuple <string, string> >
{
new Tuple <string, string>("provider.id", provider.Id),
new Tuple <string, string>("user.id", user.Id)
}, "name", "password");
callbackToken = ProviderTokenGenerator.Generate(provider.Id, user.Id);
}
}
if (li == null)
{
li = new UserLoginInfo(_tokenOptions.Issuer, token, _tokenOptions.Issuer);
}
if (await _managerUser.FindByLoginAsync(li.LoginProvider, li.ProviderKey) != null)
{
await _managerUser.RemoveLoginAsync(user, li.LoginProvider, li.ProviderKey);
}
await _managerUser.AddLoginAsync(user, li);
var isEmailOnChange = await _repositoryEmailChangeUnit.Any(x => x.State == MREntityState.Active && x.UserId == user.Id && x.Status == Infrastructure.Entity.Enum.EmailChangeResult.NEW);
_logger.LogInformation($"User login");
return(new UserStatusModel
{
FirstName = user.FirstName,
LastName = user.LastName,
Roles = userRoles.ToList(),
AccessToken = token,
LanguageCode = user.LanguageCode,
Email = user.Email,
Sex = user.Sex,
IsEmailConfirmed = user.IsEmailConfirmed,
IsEmailOnChange = isEmailOnChange,
CallbackUrl = model.CallbackUrl,
CallbackToken = callbackToken
});
}
