private static async Task PostRecord(
IGHPTravelportClient restClient,
AuthResource authResource,
ApiReservationDetailsRequest request)
{
await restClient.CreateReservationDetails(authResource.ToString(), request);
}
public async Task <IActionResult> SignIn(UserSignInResource userSignInResource)
{
var user = await _authService.FindUserByEmail(userSignInResource.Email);
if (user == null)
{
return(NotFound("User not found"));
}
var isCorrect = await _authService.IsUserPasswordCorrect(user, userSignInResource.Password);
if (!isCorrect)
{
return(BadRequest("Email or password is incorrect"));
}
var roles = await _authService.GetUserRoles(user);
var jwtString = _authService.GenerateJwt(user, roles);
var userResource = _mapper.Map <User, UserResource>(user);
var authResource = new AuthResource()
{
JwtString = jwtString,
User = userResource
};
return(Ok(authResource));
}
public async Task <IActionResult> Authenticate([FromBody] AuthResource authResource)
{
var player = await authService.Authenticate(authResource.Login, authResource.Password);
var result = mapper.Map <Player, PlayerResource>(player);
var response = new GenericResponse <PlayerResource>(result != null, result != null ? "" : "Incorrect login or password", result);
return(Ok(response));
}
public async Task <IActionResult> Register([FromBody] LoginResource loginResource)
{
AuthResource authTokens = await _userService.Register(loginResource.Email, loginResource.Password);
if (authTokens == null)
{
return(new BadRequestObjectResult("Пользователь с таким Email уже зарегистрирован."));
}
return(new OkObjectResult(authTokens));
}
public async Task <IActionResult> Authenticate([FromBody] LoginResource loginResource)
{
AuthResource authTokens = await _userService.Authenticate(loginResource.Email, loginResource.Password);
if (authTokens == null)
{
return(new BadRequestObjectResult("Email или пароль неверны."));
}
return(new OkObjectResult(authTokens));
}
public async Task <ActionResult <string> > SignInAsync([FromBody] AuthResource credentials)
{
var validationResult = _validator.Validate(credentials);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
var user = await _service.SignInAsync(credentials.Email, credentials.Password);
return(GenerateJwtToken(user));
}
public async Task <IActionResult> AccessToken([FromBody] AuthResource model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var token = await authService.CreateAccessToken(model.Email, model.Password);
if (!token.Success)
{
return(BadRequest(token.Message));
}
return(Ok(token.Result));
}
public IActionResult Login([FromBody] LoginResource user)
{
if (_unitOfWork.UserRepository.Get(user.UserId, user.Password) != null)
{
var auth = new AuthResource
{
Token = GenerateToekn(user),
UserId = user.UserId
};
return(Ok(auth));
}
else
{
return(Unauthorized());
}
}
public void Can_add_new_authResource()
{
var provider = GetProivder();
var authResource = new AuthResource
{
Name = "create new client test",
AuthResourceType = AuthResourceType.None
};
var id = provider.AddAsync(authResource).Result;
var result = provider.GetAsync(id).Result;
Assert.IsNotNull(result);
}
public void Can_delete_authResource()
{
var provider = GetProivder();
var authResource = new AuthResource
{
Name = "update client test",
AuthResourceType = AuthResourceType.None
};
var id = provider.AddAsync(authResource).Result;
authResource = provider.GetAsync(id).Result;
Assert.IsNotNull(authResource);
provider.DeleteAsync(authResource.Id).Wait();
var result = provider.GetAsync(id).Result;
Assert.IsNull(result);
}
public async Task <IActionResult> RefreshToken([FromBody] AuthResource authResource)
{
var principal = _tokenService.GetPrincipalFromExpiredToken(authResource.Token);
var email = principal.Claims.Single(x => x.Type == ClaimTypes.Email).Value;
var user = await _userService.GetUser(email);
var savedRefreshToken = user.RefreshToken;
if (savedRefreshToken != authResource.RefreshToken)
{
throw new SecurityTokenException("Invalid refresh token");
}
var newJwtToken = _tokenService.GenerateJwtToken(email);
var newRefreshToken = _tokenService.GenerateRefreshToken();
await _userService.UpdateRefreshToken(email, newRefreshToken);
return(new OkObjectResult(new
{
token = newJwtToken,
refreshToken = newRefreshToken
}));
}
public async Task SignIn_ReturnOkObjectResult_WhenSignInIsSuccess()
{
//Arrange
var userSignInResource = new UserSignInResource();
var jwtString = "MockJwt";
var user = new User()
{
Id = 1,
FirstName = "User1"
};
var userResource = _mapper.Map <User, UserResource>(user);
var authResource = new AuthResource()
{
JwtString = jwtString,
User = userResource
};
_mockService.Setup(service => service.FindUserByEmail(It.IsAny <string>()))
.ReturnsAsync(user);
_mockService.Setup(service => service.IsUserPasswordCorrect(It.IsAny <User>(), It.IsAny <string>()))
.ReturnsAsync(true);
_mockService.Setup(service => service.GetUserRoles(It.IsAny <User>()))
.ReturnsAsync(new List <string>());
_mockService.Setup(service => service.GenerateJwt(It.IsAny <User>(), It.IsAny <List <string> >()))
.Returns(jwtString);
var controller = new AuthController(_mapper, _mockService.Object);
//Act
var actionResult = await controller.SignIn(userSignInResource);
var objectResult = actionResult as OkObjectResult;
var value = objectResult.Value;
//Assert
Assert.IsType <OkObjectResult>(actionResult);
Assert.Equal(serializeObject(authResource), serializeObject(value));
}
public void Can_update_authResource()
{
var provider = GetProivder();
var authResource = new AuthResource
{
Name = "update client test",
AuthResourceType = AuthResourceType.None
};
var id = provider.AddAsync(authResource).Result;
authResource = provider.GetAsync(id).Result;
var newName = Guid.NewGuid().ToString();
authResource.Name = newName;
provider.UpdateAsync(authResource).Wait();
var result = provider.GetAsync(authResource.Id).Result;
Assert.IsNotNull(result);
Assert.AreEqual(authResource.Name, newName);
}
