public async Task CallGetRequest_WhenCalled_ReturnsAllUsers()
{
getUsersHelper getUsersHelper = new getUsersHelper();
List <TblUser> userList = getUsersHelper.getUserFromList();
List <UserForListDto> userForListDtos = new List <UserForListDto>(3);
for (int i = 0; i < userList.Count; i++)
{
UserForListDto userForListDto = new UserForListDto();
userForListDto.Aname = userList[i].Aname;
userForListDto.ACustomerId = userList[i].ACustomerId;
userForListDto.AUsername = userList[i].AUsername;
userForListDto.AEmail = userList[i].AEmail;
userForListDtos.Add(userForListDto);
}
_mockUserRepository = new Mock <IUserRepository>();
_mockUserMapper = new Mock <IMapper>();
_mockUserMapper.Setup(mapper => mapper.Map <IEnumerable <UserForListDto> >(It.IsAny <TblUser[]>())).Returns(userForListDtos);
_mockUserRepository.Setup(repo => repo.GetUsers(new UserParams {
}))
.ReturnsAsync(getUsersHelper.getUserFromList());
_usersController = new UsersController(_mockUserRepository.Object, _mockUserMapper.Object);
var users = await _usersController.Getusers(new UserParams { });
var okResult = users as OkObjectResult;
var result = ((OkObjectResult)users).Value;
Assert.AreEqual(result, userForListDtos);
Assert.AreEqual(200, okResult.StatusCode);
Assert.NotNull(users);
Assert.IsAssignableFrom <OkObjectResult>(users);
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
var user = await _userManager.FindByNameAsync(userForLoginDto.UserName);
if (user == null)
{
return(Unauthorized());
}
var result = await _signInManager.CheckPasswordSignInAsync(user, userForLoginDto.Password, false);
if (result.Succeeded)
{
var appUser = await _userManager.Users.FirstOrDefaultAsync(u => u.NormalizedUserName == userForLoginDto.UserName.ToUpper());
var userToReturn = new UserForListDto()
{
Id = appUser.Id,
UserName = appUser.UserName,
FirstName = appUser.FirstName,
LastName = appUser.LastName,
Created = appUser.Created,
LastActive = appUser.LastActive
};
return(Ok(new
{
token = GenerateJwtToken(appUser).Result,
user = userToReturn
}));
}
return(Unauthorized());
}
public bool Login_ValidRequest_ReturnsOkResult()
{
var userForLogin = new UserForLoginDto
{
UserName = "******",
Password = "******"
};
var user = new User()
{
UserName = "******",
PasswordHash = "test"
};
var userForList = new UserForListDto()
{
Username = "******"
};
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(m => m.Map <UserForListDto>(It.IsAny <User>())).Returns(() => userForList);
var configurationMock = new Mock <IConfiguration>();
var userManagerMock = new Mock <FakeUserManager>();
var signInManagerMock = new Mock <FakeSignInManager>();
var controllerMock = new AuthController(configurationMock.Object, mapperMock.Object, userManagerMock.Object, signInManagerMock.Object);
return(true);
}
public async Task <string> GenerateJwtToken(UserForListDto userForListDto)
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, userForListDto.Id.ToString()),
new Claim(ClaimTypes.Name, userForListDto.UserName)
};
User user = mapper.Map <User>(userForListDto);
var roles = await userManager.GetRolesAsync(user);
foreach (string role in roles)
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
var key = new SymmetricSecurityKey(Encoding.UTF8.
GetBytes(configuration.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescription = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescription);
return(tokenHandler.WriteToken(token));
}
private void UsersListView_ItemClick(object sender, AdapterView.ItemClickEventArgs e)
{
userSelected = usersList.ElementAt(e.Position);
Intent intent = new Intent(this, typeof(UpdateUserActivity));
intent.PutExtra("userId", userSelected.Id.ToString());
StartActivityForResult(intent, 1);
}
public async Task <User> AddUser(UserForListDto userDto)
{
var mapped = _mapper.Map <User>(userDto);
await _context.Users.AddAsync(mapped);
await _context.SaveChangesAsync();
return(mapped);
}
public async Task <IActionResult> UpdateUser(UserForListDto user)
{
var userFromDB = await _repo.UpdateUser(user);
var userToReturn = _mapper.Map <UserForListDto>(userFromDB);
//return Ok(userToReturn);
return(NoContent());
}
private IEnumerable <UserForListDto> ReturnedUsers()
{
List <UserForListDto> list_users = new List <UserForListDto>();
var user_list = new UserForListDto()
{
Username = "******"
};
list_users.Add(user_list);
return(list_users);
}
protected UserForListDto GetUserClaims()
{
var identityClaims = (ClaimsIdentity)User.Identity;
UserForListDto userForListDto = null;
if (identityClaims != null && identityClaims.Claims.Count() > 0)
{
userForListDto = new UserForListDto();
userForListDto.Id = new Guid(identityClaims.FindFirst("UserId").Value);
userForListDto.Email = identityClaims.FindFirst("UserName").Value;
}
return(userForListDto);
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
var user = await _authRepository.Login(userForLoginDto.Email, userForLoginDto.Password);
if (user == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, user.UserId.ToString()),
new Claim(ClaimTypes.Email, userForLoginDto.Email)
};
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 = new UserForListDto
{
Name = user.Name,
Phone = user.Phone,
Orders = user.Orders,
CreatedAt = user.CreatedAt,
Address = user.Address,
UserRole = user.UserRole
};
return(Ok(new
{
token = tokenHandler.WriteToken(token),
userToReturn
}));
}
public async Task <UserForListDto> Login(string userName, string password)
{
User user = await userManager.FindByNameAsync(userName);
var result = await signInManager.CheckPasswordSignInAsync(user, password, false);
if (result.Succeeded)
{
User appUser = await userManager.Users.FirstOrDefaultAsync(u => u.NormalizedUserName == userName.ToUpper());
UserForListDto userForListDto = mapper.Map <UserForListDto>(appUser);
return(userForListDto);
}
return(null);
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
UserForListDto userFromRepo = await authService.Login(userForLoginDto.UserName.ToLower(),
userForLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
return(Ok(new
{
token = authService.GenerateJwtToken(userFromRepo),
user = userFromRepo
}));
}
public string GetScope(UserForListDto user)
{
if (user.OrganizationId == null)
{
return("Global");
}
else if (user.StoreId != null)
{
return("Store");
}
else if (user.FacilityId != null)
{
return("Facility");
}
else if (user.DepartmentId != null)
{
return("Department");
}
return("Organization");
}
/// <summary>
/// Searchs for the name of a specified group in the connection group table.
/// </summary>
/// <returns><c>true</c>, if group name was found, <c>false</c> otherwise.</returns>
public UserForListDto GetAllConnectionGroupUsers(int id, ref List <Exception> excepts)
{
UserForListDto userInfo = new UserForListDto();
List <string> dawgtags = new List <string>();
const string queryString =
"SELECT guacamole_entity.name, guacamole_entity.entity_id FROM guacamole_connection_group_permission AS permiss, guacamole_user_group, guacamole_user_group_member AS mem, guacamole_entity " +
"WHERE permiss.connection_group_id = @id AND permiss.entity_id = guacamole_user_group.entity_id AND mem.user_group_id = guacamole_user_group.user_group_id AND guacamole_entity.entity_id = mem.member_entity_id";
try
{
using (GuacamoleDatabaseConnector gdbc = new GuacamoleDatabaseConnector(ref excepts))
{
using (MySqlCommand query = new MySqlCommand(queryString, gdbc.getConnection()))
{
query.Prepare();
//Add the agruments given
query.Parameters.AddWithValue("@id", id);
//Collect the query result column
using (MySqlDataReader reader = query.ExecuteReader())
{
while (reader.Read())
{
dawgtags.Add(reader.GetValue(0).ToString());
userInfo.Id = Int32.Parse(reader.GetValue(1).ToString());
}
}
userInfo.Users = dawgtags;
return(userInfo);
}
}
}
catch (Exception e)
{
excepts.Add(e);
Console.WriteLine("\n\n\n\n" + e.Message);
return(null);
}
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
//throw new Exception("Application says no!");
User userFromRepo = await _repo.Login(userForLoginDto.Username.ToLower(), userForLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
var claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
var key = new SymmetricSecurityKey(System.Text.Encoding.UTF8.
GetBytes(_config.GetSection("AppSettings:Token").Value));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha512Signature);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = creds
};
var tokenHandler = new JwtSecurityTokenHandler();
var token = tokenHandler.CreateToken(tokenDescriptor);
UserForListDto user = _mapper.Map <UserForListDto>(userFromRepo);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
user
}));
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
User userFromRepo = await _authRepository.Login(userForLoginDto.Username.ToLower(), userForLoginDto.Password);
if (userFromRepo == null)
{
return(Unauthorized());
}
Claim[] claims = new[]
{
new Claim(ClaimTypes.NameIdentifier, userFromRepo.Id.ToString()),
new Claim(ClaimTypes.Name, userFromRepo.Username)
};
SymmetricSecurityKey key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config.GetSection("AppSettings:Token").Value));
SigningCredentials creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256Signature);
SecurityTokenDescriptor tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddHours(6),
SigningCredentials = creds
};
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
SecurityToken token = tokenHandler.CreateToken(tokenDescriptor);
UserForListDto user = _mapper.Map <UserForListDto>(userFromRepo);
return(Ok(new
{
token = tokenHandler.WriteToken(token),
user
}));
}
public async Task <IActionResult> Login(UserForLoginDto userForLoginDto)
{
User user = await _userManager.FindByNameAsync(userForLoginDto.Username);
Microsoft.AspNetCore.Identity.SignInResult result
= await _signInManager.CheckPasswordSignInAsync(user, userForLoginDto.Password, false);
if (result.Succeeded)
{
User appUser = await _userManager.Users.Include(p => p.Photos)
.FirstOrDefaultAsync(u => u.NormalizedUserName == userForLoginDto.Username.ToUpper());
UserForListDto userToReturn = _mapper.Map <UserForListDto>(appUser);
return(Ok(new
{
token = GenerateJwtToken(appUser).Result,
user = userToReturn
}));
}
return(Unauthorized());
}
public string GenerateToken(UserForListDto userForListDto, string secret, string issuer, string audience)
{
var claims = new[]
{
new Claim("UserId", userForListDto.Id.ToString()),
new Claim("UserName", userForListDto.FirstName + " " + userForListDto.LastName)
};
var tokenHandler = new JwtSecurityTokenHandler();
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.Now.AddHours(12),
Issuer = issuer,
Audience = audience,
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(Encoding.UTF8.GetBytes(secret)), SecurityAlgorithms.HmacSha512)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
return(tokenHandler.WriteToken(token));;
}
public async Task <IActionResult> GetUsers()
{
var users = await _userManager.Users.ToListAsync();
var userList = new List <UserForListDto>();
foreach (var user in users)
{
var newUser = new UserForListDto()
{
Id = user.Id,
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Created = user.Created,
LastActive = user.LastActive
};
userList.Add(newUser);
}
return(Ok(userList));
}
//[Authorize(Roles = "Admin")]
public IActionResult GetList()
{
//var Users = UC.Users.Include(x => x.UserPhotos).Select(data => new User { Email=data.Email,NameSurname=data.NameSurname,UserPhotos=data.UserPhotos}).ToList();
// UsersContext UC = new UsersContext();
// var users3 = UC.Users.Include(x => x.UserPhotos).ToList();
try
{
int currentUserId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
var contextResult = _userDal.GetUsers();
var mappingResult = _mapper.Map <List <UserForListDto> >(contextResult);
UserForListDto userForListDto = new UserForListDto();
userForListDto = mappingResult.Find(data => data.Id == currentUserId);
mappingResult.Remove(userForListDto);
return(Ok(mappingResult));
}
catch
{
return(NotFound(404));
}
}
