public async Task <ActionResult> DashBoardAsync(UserToReturnDto model)
{
HttpClient client = new HttpClient();
// string endpoint = apiBaseUrl + "api/account/register";
var Response = await client.GetAsync("http://localhost:5000/api/admin/getusers");
var responseBody = await Response.Content.ReadAsStringAsync();
var responseObject = JsonConvert.DeserializeObject <IEnumerable <UserToReturnDto> >(responseBody);
ViewBag.female = responseObject.Where(x => x.Gender.ToLower() == "female").Count();
ViewBag.male = responseObject.Where(x => x.Gender.ToLower() == "male").Count();
var res = new UserList
{
AllUsers = responseObject,
User = model
};
var user = responseObject.ToList();
ViewBag.IsLoggedIn = true;
return(View(res));
}
public async Task GetUser_ShouldReturnUser()
{
// Arrange
var userId = 1;
var firstname = "Jelena";
var lastname = "Ralevic";
var user = new PowerUser()
{
Id = userId,
Firstname = firstname,
Lastname = lastname
};
var userToReturnDto = new UserToReturnDto()
{
Id = userId,
Firstname = firstname,
Lastname = lastname
};
_unitOfWorkMock.Setup(x => x.Users.GetUserByIdWithAdditionalInformation(userId))
.ReturnsAsync(user);
_mapperMock.Setup(x => x.Map <UserToReturnDto>(It.IsAny <PowerUser>()))
.Returns(userToReturnDto);
// Act
var result = await _sut.GetUser(userId);
// Assert
Assert.Equal(userId, result.Id);
Assert.Equal(firstname, result.Firstname);
Assert.Equal(lastname, result.Lastname);
}
public async Task <IActionResult> EditUser(string id, UserToReturnDto user)
{
int userId = Convert.ToInt32(id);
if (userId != user.Id)
{
return(BadRequest());
}
var userObj = _context.Users.FindAsync(userId);
// _context.Entry(userChk).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok(user));
}
public async Task <ActionResult <List <Post> > > getPostsByCategorieTitle(string title)
{
List <PostToReturnDto> postToReturnDto = new List <PostToReturnDto>();
AuthorToReturnDto authorToReturnDto = new AuthorToReturnDto();
List <Post> posts = new List <Post>();
posts = await _db.getPostsByCategorieTitle(title);
foreach (var item in posts)
{
Author author = new Author();
UserToReturnDto userToReturnDto = new UserToReturnDto();
PostToReturnDto tempPost = new PostToReturnDto();
author = item.Author;
authorToReturnDto.user = userToReturnDto;
userToReturnDto.id = item.Author.user.id;
userToReturnDto.posts = item.Author.user.posts;
userToReturnDto.username = item.Author.user.username;
authorToReturnDto.user = userToReturnDto;
authorToReturnDto.id = item.authorId;
authorToReturnDto.userId = item.Author.userId;
tempPost.Author = authorToReturnDto;
tempPost.authorId = item.authorId;
tempPost.Categorie = item.Categorie;
tempPost.categorieId = item.categorieId;
tempPost.content = item.content;
tempPost.date = item.date;
tempPost.id = item.id;
tempPost.imageUrl = item.imageUrl;
tempPost.PostType = item.PostType;
tempPost.postTypeId = item.postTypeId;
tempPost.reactionSet = item.reactionSet;
tempPost.reactionSetId = item.reactionSetId;
tempPost.title = item.title;
postToReturnDto.Add(tempPost);
}
return(Ok(postToReturnDto));
}
public async Task <IActionResult> Login(UserDto userDto)
{
var user = await authRepositery.Login(userDto.UserName, userDto.Password);
if (user == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, user.UserId.ToString()),
new Claim(ClaimTypes.Name, userDto.UserName)
};
var key = new SymmetricSecurityKey(Encoding.UTF8
.GetBytes(_configuration.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
SigningCredentials = creds,
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1)
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
//var userToReturn = _mapper.Map<UserToReturnDto>(user);
UserToReturnDto userToReturnDto = new UserToReturnDto()
{
UserId = user.UserId,
Username = user.UserName
};
return(Ok(new
{
token = tokenHandler.WriteToken(token),
userToReturnDto
}));
}
public async Task Post_Login_returnsJWTTokenAndUserObject()
{
// Arrange
var testUsername = "******";
var dbContext = DbContextMocker.GetLandmarkingContext(nameof(Post_Login_returnsJWTTokenAndUserObject));
var repository = new AuthRepository(dbContext);
var mapper = IMapperMocker.getMapper();
var iConfig = IConfigMocker.getIconfiguration();
var controller = new AuthController(repository, mapper, iConfig);
var userLogin = new UserLoginDto()
{
Username = testUsername,
Password = "******"
};
// Act
var response = await controller.Login(userLogin);
// Assert
var OkObjectResult = Assert.IsType <OkObjectResult>(response);
//// retrieve & convert anonymous response object with Reflection
dynamic responseObject = OkObjectResult.Value;
var tokenProperty = responseObject.GetType().GetProperty("token");
string encodedToken = tokenProperty.GetValue(responseObject, null);
var userObjectProperty = responseObject.GetType().GetProperty("userObject");
UserToReturnDto userObject = userObjectProperty.GetValue(responseObject, null);
Assert.Equal(testUsername.ToLower(), userObject.Username);
// decode verifyJWT
var decodedToken = new JwtSecurityToken(encodedToken);
var jwtUsername = decodedToken.Claims.First(claim => claim.Type == "unique_name").Value;
Assert.Equal(testUsername.ToLower(), jwtUsername);
//cleanup
dbContext.Dispose();
}
private IActionResult ShapeResultAsync(IQueryable <ApplicationUser> result)
{
var usersToReturn = new List <UserToReturnDto>();
foreach (var item in result)
{
var user = new UserToReturnDto
{
LastName = item.LastName,
FirstName = item.FirstName,
Email = item.Email,
Gender = item.Gender,
DateCreated = item.DateCreated,
};
usersToReturn.Add(user);
}
return(Ok(usersToReturn));
}
public async Task <IActionResult> GetActionResultAsync(UserToLoginDto model)
{
if (ModelState.IsValid)
{
var result = await _userManager.FindByEmailAsync(model.Email);
if (result != null)
{
var dto = new UserToReturnDto
{
FirstName = result.FirstName,
LastName = result.LastName,
Gender = result.Gender,
Email = result.Email,
DateCreated = result.DateCreated
};
return(Ok(dto));
}
}
return(BadRequest("Incorrect User Input"));
}
public async Task <IActionResult> Login(UserToLoginDto model)
{
//if (!ModelState.IsValid)
// return BadRequest(ModelState);
var user = _userManager.Users.FirstOrDefault(x => x.Email == model.Email);
if (user == null)
{
return(Unauthorized());
}
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, isPersistent : model.RememberMe, false);
if (!result.Succeeded)
{
return(Unauthorized("Invalid credentials"));
}
if (result.Succeeded)
{
var role = await _userManager.GetRolesAsync(user);
var userReturn = new UserToReturnDto
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
DateCreated = user.DateCreated,
Role = role.ToList(),
Gender = user.Gender,
};
return(Ok(userReturn));
}
return(BadRequest());
}
public async Task GetAllUsers_ShouldReturnTwo()
{
// Arrange
var firstUserId = 1;
var firstUserName = "******";
var firstUserLastName = "Nikic";
var secondUserId = 1;
var secondUserName = "******";
var secondUserLastName = "Nikic";
ICollection <User> users = new List <User>();
var firstUser = new PowerUser()
{
Id = firstUserId,
Firstname = firstUserName,
Lastname = firstUserLastName
};
var secondUser = new PowerUser()
{
Id = secondUserId,
Firstname = secondUserName,
Lastname = secondUserLastName
};
users.Add(firstUser);
users.Add(secondUser);
ICollection <UserToReturnDto> userToReturnDtos = new List <UserToReturnDto>();
var firstUserToReturnDto = new UserToReturnDto()
{
Id = firstUserId,
Firstname = firstUserName,
Lastname = firstUserLastName
};
var secondUserToReturnDto = new UserToReturnDto()
{
Id = secondUserId,
Firstname = secondUserName,
Lastname = secondUserLastName
};
userToReturnDtos.Add(firstUserToReturnDto);
userToReturnDtos.Add(secondUserToReturnDto);
_unitOfWorkMock.Setup(x => x.Users.GetUsers())
.ReturnsAsync(users);
_mapperMock.Setup(x =>
x.Map <ICollection <UserToReturnDto> >
(users))
.Returns(userToReturnDtos);
// Act
var response = await _sut.GetAllUsers();
// Assert
var firstUserFromList = response.FirstOrDefault(x => x.Id == firstUserToReturnDto.Id);
var secondUserFromList = response.FirstOrDefault(x => x.Id == secondUserToReturnDto.Id);
Assert.Equal(firstUserToReturnDto.Id, firstUserFromList.Id);
Assert.Equal(firstUserToReturnDto.Firstname, firstUserFromList.Firstname);
Assert.Equal(firstUserToReturnDto.Lastname, firstUserFromList.Lastname);
Assert.Equal(secondUserToReturnDto.Id, secondUserFromList.Id);
Assert.Equal(secondUserToReturnDto.Firstname, secondUserFromList.Firstname);
Assert.Equal(secondUserToReturnDto.Lastname, secondUserFromList.Lastname);
}
