public ActionResult Login(UserAuthModel model, string returnUrl)
{
if (ModelState.IsValid)
{
User user = UserManager.Find(model.UserLoginModel.Email, model.UserLoginModel.Password);
if (user == null)
{
ModelState.AddModelError("", "Wrong email or password.");
}
else
{
ClaimsIdentity claim = UserManager.CreateIdentity(user,
DefaultAuthenticationTypes.ApplicationCookie);
AuthenticationManager.SignOut();
AuthenticationManager.SignIn(new AuthenticationProperties
{
IsPersistent = true
}, claim);
if (String.IsNullOrEmpty(returnUrl))
{
return(RedirectToAction("Index", "Home"));
}
return(Redirect(returnUrl));
}
}
//var authmodel = new UserAuthModel() { UserLoginModel = model };
return(View("Authentication", model));
}
public async Task <ActionResult> RegisterUser(UserAuthModel userModel)
{
if (!ModelState.IsValid)
{
return(CustomApiResponse(ModelState));
}
var user = new IdentityUser
{
UserName = userModel.Email,
Email = userModel.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, userModel.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(CustomApiResponse(await GerarJwt(user.Email)));
//return CustomApiResponse(user.Email);
}
foreach (var error in result.Errors)
{
ErrorNotification(error.Description);
}
return(CustomApiResponse(userModel));
}
protected async void Register(object sender, EventArgs args)
{
if (string.IsNullOrEmpty(Number.Text) ||
string.IsNullOrEmpty(Email.Text) ||
string.IsNullOrEmpty(User.Text) ||
string.IsNullOrEmpty(Password.Text))
{
await Application.Current.MainPage.DisplayAlert("Ошибка", "Заполните все поля для продолжения!", "ОК");
return;
}
var phone = Number.Text;
var finalPhone = Regex.Replace(phone, @"\(", "");
finalPhone = Regex.Replace(finalPhone, @"\)", "");
finalPhone = Regex.Replace(finalPhone, @"\s+", "");
finalPhone = finalPhone.Replace("+7", "8");
var user = new UserAuthModel()
{
Email = Email.Text,
Name = User.Text,
Password = Password.Text,
Phone = finalPhone
};
(BindingContext as RegisterOneViewModel).RegisterStepOne.Execute(user);
}
public UserEntity Authenticate(UserAuthModel authUser)
{
var user = _repository.GetCompleteUserByUsername(authUser.Username);
if (user == null || !HashHelper.ValidatePassword(authUser.Password, user.Password))
{
return(null);
}
var userEntity = new UserEntity();
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new[]
{
new Claim(ClaimTypes.Name, user.Id.ToString()),
new Claim("Username", user.Username),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim("DateOfJoin", user.Date.ToString("yyyy-MM-dd hh:mm:ss")),
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
userEntity.Token = tokenHandler.WriteToken(token);
userEntity.Username = user.Username;
userEntity.Id = user.Id;
userEntity.Email = user.Email;
return(userEntity);
}
public string CreateUserAccessToken(UserAuthModel userAuthModel)
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(appSetting.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim("id", userAuthModel.Id.ToString()),
new Claim("email", userAuthModel.Email),
new Claim("role-name", userAuthModel.RoleName)
}),
// Expires = DateTime.Now.AddMinutes(45),
Issuer = "https://securetoken.google.com/flutter-chat-ba7c2",
Audience = "flutter-chat-ba7c2",
IssuedAt = DateTime.UtcNow,
NotBefore = DateTime.UtcNow,
SigningCredentials = new SigningCredentials(
new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature),
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
return(tokenString);
}
public ObjectResult Authorize([FromBody] UserAuthModel userModel)
{
if (!ModelState.IsValid)
{
_context.Journals.Add(JournalEntryBuilder.CreateEntry("Authorize", false, "Unauthorized"));
_context.SaveChanges();
return(new BadRequestObjectResult(ModelState));
}
var user = _context.Users.FirstOrDefault(c => c.Email == userModel.Email && c.Password == userModel.Password);
if (user == null)
{
_context.Journals.Add(JournalEntryBuilder.CreateEntry("Authorize", false, "Unauthorized"));
_context.SaveChanges();
return(new BadRequestObjectResult("Invalid credentials"));
}
List <Claim> claims = new List <Claim>();
claims.Add(new Claim("user", user.Id.ToString()));
claims.Add(new Claim("role", user.Status.ToString()));
var accessToken = _jwtHandler.GenerateToken(claims);
var tokenString = $"{accessToken.EncodedHeader}.{accessToken.EncodedPayload}.{accessToken.RawSignature}";
user.Modified = DateTime.Now;
_context.Update(user);
_context.Journals.Add(JournalEntryBuilder.CreateEntry("Authorize", true, user.Id.ToString()));
_context.SaveChanges();
return(new OkObjectResult(tokenString));
}
public static UserAuthModel TokenLogin(string token)
{
UserAuthModel model = new UserAuthModel();
if (token != MTConfig.AdminToken)
{
return(model);
}
model.User = UserModel.FirstOrDefault("where Id = 1 and DelFlag = 0 ");
if (model.User != null)
{
model.RoleList = RoleDAL.GetAllRoleByUserID(model.User.ID);
model.GroupList = GroupDAL.GetAllGroup();
model.NodeList = NodeDAL.GetAccessNodeList(model.User.ID);
int groupCount = model.GroupList.Count;
for (int i = groupCount - 1; i >= 0; i--)
{
if (!model.NodeList.Exists(m => m.GroupID.ToString() == model.GroupList[i].ID && m.NodeLevel != 1))
{
model.GroupList.RemoveAt(i);
}
}
}
return(model);
}
//POST: /api/admin/login
public async Task <IActionResult> Login(UserAuthModel model)
{
var user = await _userManager.FindByEmailAsync(model.Email);
if (user != null && await _userManager.CheckPasswordAsync(user, model.Password))
{
//Get role assigned to the user
//var role = await _userManager.GetRolesAsync(user);
//if (role == null)
//{
// await _userManager.AddToRoleAsync(user, "Admin");
//role = await _userManager.GetRolesAsync(user);
//}
IdentityOptions _options = new IdentityOptions();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim("UserID", user.Id.ToString()),
new Claim(_options.ClaimsIdentity.RoleClaimType, "Admin")
}),
Expires = DateTime.UtcNow.AddHours(3),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes("1234567890123456")), SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var securityToken = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(securityToken);
return(Ok(new { token }));
}
else
{
return(Unauthorized());
}
}
public async Task <UserAuthModel> RegisterUser(RegisterModel userModel)
{
var usernameAvaible = await userManager.CheckIfUsernameAvaible(userModel.Username);
if (usernameAvaible == false)
{
return(null);
}
var userEntity = new User
{
Username = userModel.Username,
Email = userModel.Email,
Nickname = userModel.Nickname,
Password = userModel.Password,
FirstName = userModel.FirstName,
LastName = userModel.LastName,
Role = RoleType.Client
};
int userId = await userManager.RegisterUser(userEntity);
var userAuthModel = new UserAuthModel
{
Id = userId,
Username = userEntity.Username,
Role = RoleType.Client
};
return(userAuthModel);
}
public async Task RefreshToken(string jwtToken, string refreshToken)
{
// getting user name from token
ClaimsPrincipal principal = TokenService.GetPrincipalFromToken(jwtToken);
if (principal != null)
{
NTContext.Context.UserName = principal.Identity.Name;
UserAuthModel authModel = await DbService.GetModelByKeyAsyc <UserAuthModel>(principal.Identity.Name, SecurityAppSettings.ServiceSettings.DocumentTypes.UserAuth);
// checking refresh token validity
if (authModel.RefreshToken == refreshToken)
{
TokenService.GenerateJwtToken(principal);
}
else
{
TokenService.SetTokenHeader(refreshTokenExpired: true);
}
}
else
{
TokenService.SetTokenHeader(refreshTokenExpired: true);
}
}
public async Task SendOtp(string mobileNumber)
{
int otp = 123456;
//int otp = new Random().Next(100000, 999999); // random OTP
SharedCollectionDocument <UserAuthModel> userAuthDocument = await DbService.GetDocumentByKeyAsyc <UserAuthModel>(mobileNumber, SecurityAppSettings.ServiceSettings.DocumentTypes.UserAuth);
if (userAuthDocument == null)
{
UserAuthModel user = new UserAuthModel()
{
UserName = mobileNumber,
PasswordHash = PasswordService.DefaultPassword,
Otp = otp,
RefreshToken = TokenService.GenerateRefreshToken(),
};
SharedCollectionDocument <UserAuthModel> document = await DbService.CreateDocumentAsync(user.UserName, user, SecurityAppSettings.ServiceSettings.DocumentTypes.UserAuth);
}
else
{
userAuthDocument.Model.Otp = otp;
await DbService.ReplaceDocumentAsync(userAuthDocument);
}
string appHash = CacheService.AndroidSignatureHash;
string message = String.Format(SmsManager.OtpTemplate, otp, appHash);
SmsManager.SendSms(mobileNumber, message);
}
public async Task <UserAuthModel> ValidateUser(LoginModel userLoginModel)
{
var userEntity = new User
{
Username = userLoginModel.Username,
Password = userLoginModel.Password
};
try
{
var user = await userManager.CheckUserCredentials(userEntity);
var userAuthModel = new UserAuthModel
{
Id = user.Id,
Username = user.Username,
Role = user.Role
};
return(userAuthModel);
}
catch (InvalidUserException)
{
// UserResultModel - will be added later
return(null);
}
}
public IActionResult Authenticate(UserAuthenticationInputModel user)
{
if (user.Username == null || user.Password == null)
{
throw new InvalidInputException(_path, "Authenticate()");
}
var token = _generateJwtToken.Authenticate(user.Username, user.Password);
if (token == null)
{
return(Unauthorized());
}
var userData = _getUserData.GetDataByUsername(user.Username);
var userAuth = new UserAuthModel
{
Id = userData.Id,
Username = userData.Username,
JwtToken = token,
ProfileImgUrl = userData.ProfileImgUrl
};
return(Ok(userAuth));
}
public async Task <IActionResult> Auth([FromServices] IUserRepository repository,
[FromServices] IConfiguration configuration,
[FromBody] UserAuthModel model)
{
try
{
var user = await repository.GetAsync(model.Email, model.Password);
if (user == null)
{
return(BadRequest(new { Message = "Email e/ou senha está(ão) inválido(s)." }));
}
var token = JwtAuthHelper.GenerateToken(configuration["KeySecretAuth"], user.ToModel());
return(Ok(new
{
Token = token,
Usuario = user
}));
}
catch (Exception ex)
{
return(BadRequest(new { Message = ex.Message }));
}
}
//POST : /api/Customer/signup
public async Task <Object> CreatePartner(UserAuthModel model)
{
model.Role = "Partner";
var partnerToBeCreated = new ApplicationUser()
{
UserName = model.Username,
Email = model.Email,
Partner = new Partner()
{
Hotel = new Hotel()
{
Name = model.HotelName
}
}
};
try
{
var result = await _userManager.CreateAsync(partnerToBeCreated, model.Password);
await _userManager.AddToRoleAsync(partnerToBeCreated, model.Role);
return(Ok(result));
}
catch (Exception ex)
{
throw ex;
}
}
//POST : /api/Customer/signup
public async Task <Object> PostCustomer(UserAuthModel model)
{
model.Role = "Customer";
var customerToSignup = new ApplicationUser()
{
UserName = model.Username,
Email = model.Email,
Customer = new Customer()
{
Name = model.Username
}
};
try
{
var result = await _userManager.CreateAsync(customerToSignup, model.Password);
await _userManager.AddToRoleAsync(customerToSignup, model.Role);
return(Ok(result));
}
catch (Exception ex)
{
throw ex;
}
}
private List <Claim> PopulateTokenClaims(UserAuthModel user)
{
return(new List <Claim>()
{
new Claim(JwtRegisteredClaimNames.Jti, user.Id.ToString()),
new Claim(ClaimTypes.Role, user.Role.ToString())
});
}
public bool Login(UserAuthModel user)
{
if (_repository.GetAll().Where(x => x.Login.ToLower() == user.Name.ToLower() && x.Password == user.Password).FirstOrDefault() != null)
{
return(true);
}
return(false);
}
public ActionResult Authenticate()
{
var model = new UserAuthModel();
model.loginModel = new UserLoginViewModel();
model.regModel = new UserRegisterViewModel();
return(View("Authenticate", model));
}
public async Task GetToken_FromValid_LocalUser()
{
var model = new UserAuthModel
{
Password = "******",
Username = "******"
};
HttpResponseMessage response = await _client.PostAsync("/api/v1/token", new StringContent(JsonConvert.SerializeObject(model)));
}
public async Task RegisterUser([FromBody] UserAuthModel user)
{
var userCred = new UserCredential()
{
UserName = user.UserName, Email = user.UserName + "@email.com"
};
var result = await _userMgr.CreateAsync(userCred, user.Password);
var status = result.Succeeded;
}
public IActionResult Authenticate([FromBody] UserAuthModel user)
{
var staff = _staffRepository.Authenticate(user.Email, user.Password);
if (staff != null)
{
return(Ok(staff));
}
return(BadRequest(new { message = "Login failed. Email or password is incorrect." }));
}
public new JsonResult User(UserAuthModel userAuth)
{
if (!ModelState.IsValid)
{
return(Json(new { Error = string.Join(", ", ModelStateErrors) }));
}
var user = _authLogic.AuthenticateUser(userAuth);
return(Json(user));
}
public async Task <IdentityResult> RegisterUser(UserAuthModel userModel)
{
var user = new UserModel
{
UserName = userModel.Login
};
var result = await _userManager.CreateAsync(user, userModel.Password);
return(result);
}
public async Task <ServiceResult> Authenticate([FromBody] UserAuthModel apiEntity)
{
var result = await _userService.AuthenticateAsync(apiEntity.Username, apiEntity.Password);
if (result.TryCastModel(out AppUser user))
{
var token = _tokenGenerator.GenerateNewToken(user.Id, user.Role);
result.ViewModel = UserAuthViewModel.Map(user, token);
}
return(result);
}
public async Task LoginWorksTest()
{
var auth = new UserAuthModel();
auth.Email = "*****@*****.**";
auth.Password = "******";
var response = await service.PostRequest <ResponseModel <string>, UserAuthModel>("user/login", auth);
Token = response.Response;
service.Token = Token;
Assert.Greater(response.Code, 0);
}
public async Task <ActionResult <AuthResponseModel> > Login(UserAuthModel userAuthModel)
{
AuthResponseModel authResult = await _iAuthService.Value.Login(userAuthModel);
if (authResult == null)
{
return(Unauthorized(new AuthResponseModel {
ErrorMessage = "Invalid Authentication"
}));
}
return(Ok(new Response <AuthResponseModel>(authResult)));
}
public UserAuthModel CurrentUser()
{
bool IsAuthenticated = HttpContext.Current.User.Identity.IsAuthenticated;
if (IsAuthenticated == true)
{
ClaimsIdentity claimsIdentity = HttpContext.Current.User.Identity as ClaimsIdentity;
List <string> roles = null;
UserAuthModel user = new UserAuthModel();
foreach (var claim in claimsIdentity.Claims)
{
switch (claim.Type)
{
case ClaimTypes.NameIdentifier:
int id = 0;
if (Int32.TryParse(claim.Value, out id))
{
user.Id = id;
}
break;
case ClaimTypes.Name:
user.Name = claim.Value;
break;
case ClaimTypes.Email:
user.Email = claim.Value;
break;
case ClaimTypes.Role:
if (roles == null)
{
roles = new List <string>();
}
roles.Add(claim.Value);
break;
default:
break;
}
}
user.Roles = roles;
return(user);
}
return(null);
}
public async Task <IActionResult> GetToken([FromBody] UserAuthModel model)
{
if (!model.UsePlexOAuth)
{
await _audit.Record(AuditType.None, AuditArea.Authentication,
$"UserName {model.Username} attempting to authenticate");
var user = await _userManager.FindByNameAsync(model.Username);
if (user == null)
{
// Could this be an email login?
user = await _userManager.FindByEmailAsync(model.Username);
if (user == null)
{
return(new UnauthorizedResult());
}
user.EmailLogin = true;
}
// Verify Password
if (await _userManager.CheckPasswordAsync(user, model.Password))
{
return(await CreateToken(model.RememberMe, user));
}
}
else
{
// Plex OAuth
// Redirect them to Plex
// We need a PIN first
var pin = await _plexOAuthManager.RequestPin();
var websiteAddress = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}";
//https://app.plex.tv/auth#?forwardUrl=http://google.com/&clientID=Ombi-Test&context%5Bdevice%5D%5Bproduct%5D=Ombi%20SSO&pinID=798798&code=4lgfd
var url = await _plexOAuthManager.GetOAuthUrl(pin.id, pin.code, websiteAddress);
if (url == null)
{
return(new JsonResult(new
{
error = "Application URL has not been set"
}));
}
return(new JsonResult(new { url = url.ToString() }));
}
return(new UnauthorizedResult());
}
public ActionResult Auth(UserAuthModel user)
{
if (ModelState.IsValid)
{
if (_authService.Login(user))
{
FormsAuthentication.SetAuthCookie(user.Name, true);
return(RedirectToAction("Index", "Home"));
}
ModelState.AddModelError("", "Такого пользователя не существует");
}
return(View());
}
