public async Task <ActionResult <UserToken> > CreateUser([FromBody] UserInfoToken model)
{
try {
var user = new ApplicationUserToken {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(_tokenService.BuildToken(model));
}
else
{
return(BadRequest("Usuário ou senha inválidos"));
}
}
catch (Exception e)
{
return(NotFound(new
{
message = e.Message,
errorCode = (int)HttpStatusCode.NotFound
}));
}
}
public async Task <ActionResult <UserTokenDTO> > Register([FromBody] UserRegisterDTO userRegisterDTO)
{
var identityResult = await _authenticationService.RegisterAsync(userRegisterDTO);
if (!identityResult.Succeeded)
{
return(BadRequest(identityResult.Errors));
}
return(await _tokenService.BuildToken(userRegisterDTO));
}
public async Task <IActionResult> Login(string userAccessToken)
{
if (userAccessToken == string.Empty)
{
return(BadRequest());
}
var appToken = await _facebookService.CreateAppAccessTokenAsync(_configuration["Facebook:AppID"],
_configuration["Facebook:AppSecret"]);
var userIsValid = await _facebookService.CheckTokenValidityAsync(userAccessToken, appToken);
if (!userIsValid)
{
return(BadRequest());
}
var userData = await _facebookService.GetUserDataAsync(userAccessToken);
var userClaims = await _facebookService.Login(userData);
var token = _tokenService.BuildToken(userClaims, DateTime.Now.AddDays(1));
return(Ok(new UserViewModel {
Token = token, Username = userClaims.Email
}));
}
public IActionResult Login(UserCredentialsDTO credentials)
{
if (!IsCredentialsObjectValid(credentials))
{
return(BadRequest());
}
var user = _userService.GetAll().FirstOrDefault(x => x.Name == credentials.Username);
if (user == null)
{
return(new NotFoundResult());
}
if (!string.IsNullOrWhiteSpace(user.HashedPassword))
{
//TODO: Hash the supplied password and compared it hashed password on the user object
}
var token =
_tokenService.BuildToken(
_config["Jwt:Key"].ToString(),
_config["Jwt:Issuer"].ToString(),
user);
return(new ContentResult {
Content = token, StatusCode = 200
});
}
public IActionResult Login(UserModel userModel)
{
if (string.IsNullOrEmpty(userModel.UserName) ||
string.IsNullOrEmpty(userModel.Password))
{
return(RedirectToAction("Error"));
}
IActionResult response = Unauthorized();
var validUser = GetUser(userModel);
if (validUser != null)
{
generatedToken = _tokenService.BuildToken(_config["Jwt:Key"].ToString(), _config["Jwt:Issuer"].ToString(), validUser);
if (generatedToken != null)
{
HttpContext.Session.SetString("Token", generatedToken);
return(RedirectToAction("mainwindow"));
}
else
{
return(RedirectToAction("Error"));
}
}
else
{
return(RedirectToAction("Error"));
}
}
public async Task <Result <AuthToken> > TryRegister(RegisterInput input)
{
var errors = new Dictionary <string, List <string> >()
{
{ "email", new List <string>() },
{ "login", new List <string>() },
};
if (await _context.Users.AnyAsync(x => x.Email.ToLower() == input.Email.ToLower()))
{
errors["email"].Add("Ten adres e-mail został już użyty!");
}
if (await _context.Users.AnyAsync(x => x.Login.ToLower() == input.Login.ToLower()))
{
errors["login"].Add("Ten login jest już używany");
}
if (errors.Any(x => x.Value.Any()))
{
return(new Result <AuthToken>(false, null, errors, ErrorType.BadRequest));
}
var user = User.CreateUser(input.Login, input.UserName, input.Email, 50.MBtoKB());
user.PasswordHash = _hasher.HashPassword(user, input.Password);
var token = _tokenService.BuildToken(user);
token.DiskInfo = new LoginDiskInfo
{
DiskId = user.DiskId,
DiskName = user.Disk.Name,
FolderId = user.Disk.FolderId
};
var result = await _context.Users.AddAsync(user);
var changedRows = await _context.SaveChangesAsync();
if (changedRows == 0)
{
return(new Result <AuthToken>(false, null, "Coś poszło nie tak. Spróbuj później", ErrorType.Internal));
}
return(new Result <AuthToken>(true, token));
}
private string BuildVerificationEmailContent(User user)
{
var userClaims = _mapper.Map <UserClaimsDto>(user);
var token = _tokenService.BuildToken(userClaims, DateTime.Now.AddDays(30));
return($"<a href=\"htt" + $"p://localhost:3000/verify/{token}\" > <H2>VERIFY</H2> </a> ");
}
public async Task <OperationResult <JwtToken> > CreateToken(string email, string password)
{
User user = await userManager.FindByEmailAsync(email);
if (user == null)
{
return(OperationResult <JwtToken> .Invalid("Login failed: invalid e-mail or password."));
}
OperationResult result = await signInManager.CheckPasswordSignInAsync(user, password, lockoutOnFailure : false);
if (!result.IsValid)
{
return(result.Cast <JwtToken>());
}
var encodedToken = tokenService.BuildToken(user);
return(OperationResult <JwtToken> .Valid(new JwtToken(encodedToken)));
}
public async Task <ActionResult <UserToken> > PostUsuario(UsuarioVM usuarioVM)
{
var result = await _usuarioRepository.Criar(_mapper.Map <Usuario>(usuarioVM));
if (result.Equals(Resultado.Falha))
{
ModelState.AddModelError("Error", "Não foi possível criar o usuário.");
return(BadRequest(ModelState));
}
return(_tokenService.BuildToken(usuarioVM.Email));
}
public async Task <IActionResult> CreateToken([FromBody] LoginService login)
{
IActionResult response = Unauthorized();
var user = await _token.Authenticate(login);
if (user != null)
{
var tokenString = await _token.BuildToken(user);
response = Ok(new { token = tokenString });
}
return(response);
}
public async Task <ActionResult <string> > Login(LoginViewModel model)
{
try
{
int userId = await _usersService.LoginUser(model);
string token = _tokenService.BuildToken(userId);
return(Ok(token));
}
catch (Exception ex)
{
return(NotFound());
}
}
public async Task <OperationResult <JwtToken> > ConfirmEmailChange(string userId, string email, string token)
{
User user = await userManager.FindByIdAsync(userId);
OperationResult result = await emailConfirmationService.ConfirmEmailChange(user, email, token);
if (!result.IsValid)
{
return(result.Cast <JwtToken>());
}
// the information in the user's token is stale after the e-mail change
// - generate and send a new token with current user info
var encodedToken = tokenService.BuildToken(user);
return(OperationResult <JwtToken> .Valid(new JwtToken(encodedToken)));
}
public async Task <IActionResult> Login([FromBody] UserModel user)
{
if (!await ValidateModel(user))
{
return(BadRequest());
}
var userEntity = await _mediator.Send(new GetUserByUsernameRequest { Username = user.Username });
if (_cipherService.ValidatePasswordAgainstHash(user.Password, userEntity.PasswordSalt, userEntity.Password))
{
return(Ok(new TokenResult {
Token = _tokenService.BuildToken(user.Username)
}));
}
return(BadRequest());
}
public async Task <ActionResult <UserToken> > Login([FromBody] CredenciaisVM credenciais)
{
var userIdentity = await _userManager.FindByNameAsync(credenciais.UserName);
if (userIdentity == null)
{
return(FalhaLogin());
}
var result = await _signInManager.PasswordSignInAsync(userIdentity, credenciais.Password, false, false);
if (!result.Succeeded)
{
return(FalhaLogin());
}
return(_tokenService.BuildToken(userIdentity.Email));
}
public async Task Invoke(HttpContext context)
{
IHeaderDictionary requestHeaders = context.Request.Headers;
context.Response.OnStarting(() =>
{
if (requestHeaders.TryGetValue("Authorization", out StringValues previousHeader))
{
var previousJwt = new JwtSecurityToken(previousHeader.ToString().Replace("Bearer ", string.Empty));
var id = previousJwt.Claims.Where(x => x.Type == "Id").First().Value;
var updatedToken = _tokenService.BuildToken(id);
context.Response.Headers.Add("Authorization", updatedToken);
}
return(Task.CompletedTask);
});
await _next(context);
}
public ActionResult Login(UserModel userModel)
{
if (string.IsNullOrEmpty(userModel.UserName) || string.IsNullOrEmpty(userModel.Password))
{
return(RedirectToAction("Error"));
}
IActionResult response = Unauthorized();
var user = _userRepositoryService.GetUser(userModel);
if (user != null)
{
var generatedToken = _tokenService.BuildToken(_configuration["Jwt:Key"].ToString(), _configuration["Jwt:Issuer"].ToString(), user);
return(Ok(new
{
token = generatedToken,
user = user.UserName
}));
}
return(RedirectToAction("Error"));
}
public async Task <IActionResult> Login([FromBody] LoginViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
UserViewModel result = null;
try
{
result = await _userService.FindUser(model);
var jwtToken = _tokenService.BuildToken(result.Id);
return(Ok(new { auth_token = jwtToken, user_id = result.Id }));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <LoginRpsModel> Login(string userName, string password, string packType)
{
if (string.IsNullOrWhiteSpace(userName))
{
throw new MyException(_localizer["用户名不能为空"]);
}
if (string.IsNullOrWhiteSpace(password))
{
throw new MyException(_localizer["密码不能为空"]);
}
var user = await _userRepository.Query(x => x.UserName == userName).FirstOrDefaultAsync();
if (user == null)
{
throw new MyException(_localizer["用户名未注册"]);
}
//检查登录次数
//检查密码
//创建token
//先删除以前的
//删除已有的token
var rm = new LoginRpsModel()
{
UserId = user.Id,
UserName = user.UserName,
Token = null
};
await _tokenService.DelToken(user.Id, packType);
rm.Token = await _tokenService.BuildToken(new TokenInfo(user) { PackType = packType });
return(new LoginRpsModel()
{
});
}
public async Task <(LoginRpsModel rpsModel, ClaimsPrincipal principal)> Login(string userName, string password)
{
if (string.IsNullOrWhiteSpace(userName))
{
throw new HopexException(_localizer["用户名不能为空"]);
}
if (string.IsNullOrWhiteSpace(password))
{
throw new HopexException(_localizer["密码不能为空"]);
}
var user = await _adminUserRepository.Query(x => x.UserName == userName && x.IsValid && x.IsDeleted == false).SingleOrDefaultAsync();
if (user == null)
{
throw new HopexException(_localizer["用户不存在"]);
}
if (!HashUtil.PasswordHashCheck(user.Salt, user.PasswordHash, password))
{
throw new HopexException(_localizer["密码不正确"]);
}
var(token, principal) = await _tokenService.BuildToken(new TokenInfo()
{
UserName = user.UserName,
UserId = user.Id,
IsAdmin = user.IsAdmin
});
return(new LoginRpsModel()
{
UserId = user.Id,
Token = token
}, principal);
}
public async Task <IActionResult> Login([FromBody] AddUserDto userDto)
{
UserClaimsDto user = await _service.Login(userDto);
if (user == null)
{
return(Unauthorized());
}
if (!user.Verified)
{
return(Forbid());
}
string tokenString = _tokenService.BuildToken(user, DateTime.Now.AddDays(1));
var userViewModel = new UserViewModel
{
Username = user.UserName,
Token = tokenString
};
return(Ok(userViewModel));
}
public async Task <IActionResult> Authenticate([FromBody] UserDto userDto)
{
#region test
//var details = _context.Users.Where(user => user.Username == input.Username).FirstOrDefault();
//PasswordService.GetPasswordHash(out byte[] passHash, details.PasswordSalt);
//var results = await _signInManager.PasswordSignInAsync(
// input.Username,
// System.Text.Encoding.Default.GetString(passHash),
// rememberMe,
// lockoutOnFailure: false);
//if (results.Succeeded)
//{
// _logger.LogInformation("User logged in succesfully.");
//}
//Return the user info to client
#endregion test
var user = await _authenticationService.Authenticate(userDto.Email, userDto.Password);
if (user == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
return(Ok(new
{
Id = user.EncodedId,
Username = user.Username,
FirstName = user.FirstName,
LastName = user.LastName,
Token = _token.BuildToken(user)
}));
}
public async Task <UserToken> CreateUserAsync(RegisterViewModel model)
{
UserToken userToken = new UserToken();
try
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
PhoneNumber = model.MobileNo,
RegistrationTime = DateTime.Now
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
var roles = await _roleManager.Roles.CountAsync();
if (roles > 0)
{
var roleAssignResult = await _userManager.AddToRoleAsync(user, "User");
if (roleAssignResult.Succeeded)
{
var role = await _userManager.GetRolesAsync(user);
var userInfo = new UserInfo
{
Email = model.Email,
Name = $"{model.FirstName} {model.LastName}",
Username = model.Email,
Roles = role,
UserId = user.Id
};
userToken = _tokenService.BuildToken(userInfo);
userToken.Status = "success";
return(userToken);
}
}
else
{
IdentityRole role = new IdentityRole
{
Name = "User"
};
var resultRole = await _roleManager.CreateAsync(role);
if (resultRole.Succeeded)
{
var roleAssignResult = await _userManager.AddToRoleAsync(user, "User");
if (roleAssignResult.Succeeded)
{
var roleElse = await _userManager.GetRolesAsync(user);
var userInfo = new UserInfo
{
Email = model.Email,
Name = $"{model.FirstName} {model.LastName}",
Username = model.Email,
Roles = roleElse,
UserId = user.Id
};
userToken = _tokenService.BuildToken(userInfo);
userToken.Status = "success";
return(userToken);
}
}
}
}
}
catch (Exception ex)
{
userToken.Status = ex.Message;
return(userToken);
}
userToken.Status = "failed";
return(userToken);
}
public IActionResult CreateJwtWithIdClaim([FromBody] string id)
{
var token = _tokenService.BuildToken(id);
return(Ok(new { status = "success", token }));
}