public void ResetPassword_Success_ReturnsOk()
{
var userId = 2;
var passwordForResetDto = new PasswordForResetDto
{
Token = It.IsAny <string>(),
Email = "*****@*****.**",
Password = "******",
};
var response = new UserManagerResponse
{
IsSuccess = true,
Message = "Password reset was successful"
};
var userFromRepo = FakeUsers().SingleOrDefault(x => x.Id == userId);
_mockEmailService.Setup(x => x.ResetPasswordAsync(passwordForResetDto)).ReturnsAsync(response);
_recipeRepoMock.Setup(x => x.GetUser(passwordForResetDto.Email)).ReturnsAsync(userFromRepo);
var result = _authController.ResetPassword(passwordForResetDto).Result;
var okResult = Assert.IsType <OkObjectResult>(result);
// Assert.Equal(response, okResult.Value);
}
public async Task <UserManagerResponse> LoginUserAsync(LoginRequest loginRequest)
{
StringContent serializedLoginRequest = new StringContent(JsonSerializer.Serialize(loginRequest, serializerOptions), Encoding.UTF8, "application/json");
var response = await httpClient.PostAsync(_baseUrl + "/api/auth/login", serializedLoginRequest);
var responseAsString = await response.Content.ReadAsStringAsync();
UserManagerResponse userManagerResponse = JsonSerializer.Deserialize <UserManagerResponse>(responseAsString, serializerOptions);
return(userManagerResponse);
}
public static UserManagerResponse Create(string Message, bool IsSuccess, IEnumerable <string> Errors)
{
UserManagerResponse response = new UserManagerResponse
{
Message = Message,
IsSuccess = IsSuccess,
Errors = Errors
};
return(response);
}
public async Task <UserManagerResponse> MakeDeposit(string id, DepositDetail dd)
{
var localDP = DepositPlanDetail.CurrentPlans.FirstOrDefault(d => d.Id == dd.Id);
//return new UserManagerResponse()
//{
// IsSuccess = false,
// Message= JsonConvert.SerializeObject(localDP)
//};
var response = new UserManagerResponse()
{
IsSuccess = false
};
if (localDP == null)
{
response.Message = "Plan not found!";
return(response);
}
if (!(dd.Amount >= localDP.Min && dd.Amount <= localDP.Max))
{
response.Message = "Amount can't be greater than or less than package ";
return(response);
}
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(null);
}
var investment = new Investment()
{
PlanId = dd.Id,
Confirmed = false,
UserId = user.Id.ToString()
};
await _db.Investments.AddAsync(investment);
await _db.SaveChangesAsync();
response.Message = await _bitCoinService.GetAddressToDeposit(user.Id.ToString(), investment.Id) + "|" + investment.Id;
response.IsSuccess = true;
return(response);
}
public async Task <IActionResult> Login([FromBody] LoginModel model)
{
if (ModelState.IsValid)
{
UserManagerResponse serverResponse = await userServices.LoginUserAsync(model);
if (serverResponse.IsSuccess)
{
return(Ok(serverResponse)); // Status Code: 200
}
return(BadRequest(serverResponse));
}
return(BadRequest("Some properties are not valid")); // Status code: 400
}
public async Task <UserManagerResponse> GetAllSportAsync(HttpRequest request)
{
var data = await _dbContext.Sports.Select(x => new Sport()
{
Id = x.Id,
Name = x.Name,
ImageName = String.Format("{0}://{1}{2}/Images/Sport/{3}", request.Scheme, request.Host, request.PathBase, x.ImageName)
})
.ToListAsync();
var x = new UserManagerResponse {
Message = "All Sports",
IsSuccess = true,
Data = _mapper.Map <IEnumerable <SportDto> >(data)
};
return(x);
}
public async Task <UserManagerResponse> GetTeamBySportAsync(HttpRequest request, int id)
{
var data = await _dbContext.Teams.Where(x => x.SportId == id).Select(x => new Team()
{
Id = x.Id,
Name = x.Name,
SportId = x.SportId,
ImageName = String.Format("{0}://{1}{2}/Images/Team/{3}", request.Scheme, request.Host, request.PathBase, x.ImageName)
})
.ToListAsync();
var x = new UserManagerResponse {
Message = "All Teams",
IsSuccess = true,
Data = _mapper.Map <IEnumerable <TeamDto> >(data)
};
return(x);
}
public IActionResult Token(LoginRequest token)
{
var identity = GetIdentity(token.Login, token.Password);
if (identity == null)
{
var badRequest = new UserManagerResponse
{
Message = "Неверный логин или пароль",
IsSuccess = false
};
return(Json(badRequest));
}
var now = DateTime.UtcNow;
// создаем JWT-токен
var jwt = new JwtSecurityToken(
issuer: AuthOptions.ISSUER,
audience: AuthOptions.AUDIENCE,
notBefore: now,
claims: identity.Claims,
expires: now.Add(TimeSpan.FromMinutes(AuthOptions.LIFETIME)),
signingCredentials: new SigningCredentials(AuthOptions.GetSymmetricSecurityKey(), SecurityAlgorithms.HmacSha256));
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
var employee = _context.Set <Employee>().FirstOrDefault(x => x.Id == int.Parse(identity.Name));
var umr = new UserManagerResponse
{
UserInfo = new Dictionary <string, string>
{
{ "FirstName", employee?.FirstName },
{ "LastName", employee?.LastName },
{ ClaimTypes.NameIdentifier, employee?.Id.ToString() },
{ ClaimTypes.Role, identity.Claims.Where(x => x.Type == ClaimTypes.Role).Select(x => x.Value).FirstOrDefault() }
},
Message = encodedJwt,
IsSuccess = true
};
return(Json(umr));
}
public async Task <IActionResult> LoginAsync([FromBody] LoginViewModel loginViewModel)
{
if (ModelState.IsValid)
{
UserManagerResponse loginResult = await _userService.LoginUserAsync(loginViewModel);
if (loginResult.IsSuccess)
{
// в случае успешной авторизации в DTO объекте loginResult поле message содержит токен.
// сохранение токена в куках
SetTokenInCookies(loginResult.Message);
loginResult.Message = "Signed in successfully";
return(Ok(loginResult));
}
return(BadRequest(loginResult));
}
return(BadRequest("Some properties are not valid"));
}
public void ResetPassWord_Fails_ReturnsBadRequest()
{
var passwordForResetDto = new PasswordForResetDto
{
Token = It.IsAny <string>(),
Email = "*****@*****.**",
Password = "******",
};
var response = new UserManagerResponse
{
IsSuccess = false,
Message = "Password reset failed"
};
_mockEmailService.Setup(x => x.ResetPasswordAsync(passwordForResetDto)).ReturnsAsync(response);
var result = _authController.ResetPassword(passwordForResetDto).Result;
var okResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(response, okResult.Value);
}
public void ForgetPassword_FindsUser_FailsToSendsEmail_ReturnsBadRequest()
{
var email = "*****@*****.**";
var response = new UserManagerResponse
{
IsSuccess = false,
Message = "Failed to send email to user"
};
_recipeRepoMock.Setup(x => x.GetUser(email)).ReturnsAsync(
new User
{
UserName = "******",
Email = email
}
);
_mockEmailService.Setup(x => x.ForgetPasswordAsync(email)).ReturnsAsync(response);
var result = _authController.ForgetPassword(email).Result;
var okResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(response, okResult.Value);
}
public void ForgetPassword_FindsUser_SendsEmail_ReturnsOk()
{
var email = "*****@*****.**";
var response = new UserManagerResponse
{
IsSuccess = true,
Message = "Reset password URL has been sent to the email successfully"
};
_recipeRepoMock.Setup(x => x.GetUser(email)).ReturnsAsync(
new User
{
UserName = "******",
Email = email
}
);
_mockEmailService.Setup(x => x.ForgetPasswordAsync(email)).ReturnsAsync(response);
var result = _authController.ForgetPassword(email).Result;
var okResult = Assert.IsType <OkObjectResult>(result);
Assert.Equal(response, okResult.Value);
}
public void Confirm_Email_Fails_Returns_BadRequest()
{
// Arrange
int userId = 10;
var response = new UserManagerResponse
{
Errors = null, ExpireDate = null, IsSuccess = false, Message = "email confirmation failed"
};
_recipeRepoMock.Setup(x => x.GetUser(userId)).ReturnsAsync(new User
{
Email = "*****@*****.**",
UserName = "******"
});
_mockEmailService.Setup(x => x.ConfirmEmailAsync(userId, It.IsAny <string>())).ReturnsAsync(response);
// Act
var result = _authController.ConfirmEmail(userId, "somerandomstring").Result;
// Assert
var okResult = Assert.IsType <BadRequestObjectResult>(result);
Assert.Equal(response, okResult.Value);
}
