public async Task GetRolesById()
{
// Arrange
// Act
var result = await sut.GetById(1);
// Assert
Assert.That(result.Success, Is.True);
Assert.That((Role)result.Object, Is.InstanceOf <Role>());
}
public async Task <IActionResult> Edit([FromBody] UpdateUser model, string id)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Users user = await _usersRepository.GetById(id);
if (user == null)
{
return(NotFound());
}
if (!HttpContext.User.IsInRole(UserRoles.Administrator) && (HttpContext.User.Identity.Name != user.UserName))
{
return(Forbid());
}
IdentityRole role = await _rolesRepository.GetById(model.RoleId);
if (role == null)
{
return(BadRequest(ResponseMessage.RoleNotExists));
}
user = _mapper.Map <UpdateUser, Users>(model, user);
user.DateModified = DateTime.Now;
await _usersRepository.Update(user, model.RoleId);
return(Ok());
}
public ActionResult GenerateRegisterDates()
{
IEnumerable <User> users = _userRepository.GetAllUsers();
foreach (User user in users)
{
Announcement announcement = user.Apartments.OrderBy(a => a.Created).FirstOrDefault();
if (announcement != null)
{
user.RegisterDate = announcement.Created;
}
else
{
user.RegisterDate = DateTime.Now;
}
user.Role = _rolesRepository.GetById("User");
}
_userRepository.SaveChanges();
return(Json(new { Done = true }));
}
public string GetRoleByUserId(string id)
{
return _roles.GetById(_users.GetById(id).AspNetRoles.First().Id).Name;
}
public async Task <Roles> GetById(int id)
{
return(await _rolesRepository.GetById(id));
}
public async Task <IRoleResult> GetRole(
int id,
bool fullRecord = true)
{
var result = new RoleResult();
if (id == 0)
{
result.Success = false;
result.Message = RolesMessages.RoleNotFoundMessage;
return(result);
}
try
{
var response = await rolesRepository.GetById(id, fullRecord);
if (response.Success)
{
var role = (Role)response.Object;
if (fullRecord)
{
foreach (var userRole in role.Users)
{
userRole.User.Apps = null;
userRole.User.Roles = null;
userRole.User.Games = null;
}
}
result.Success = response.Success;
result.Message = RolesMessages.RoleFoundMessage;
result.Role = role;
return(result);
}
else if (!response.Success && response.Exception != null)
{
result.Success = response.Success;
result.Message = response.Exception.Message;
return(result);
}
else
{
result.Success = false;
result.Message = RolesMessages.RoleNotFoundMessage;
return(result);
}
}
catch (Exception exp)
{
result.Success = false;
result.Message = exp.Message;
return(result);
}
}
public async Task <IAuthenticatedUserResult> IsAuthenticated(ITokenRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var result = new AuthenticatedUserResult();
var validateUserTask = userManagementService.IsValidUser(request.UserName, request.Password);
validateUserTask.Wait();
if (!validateUserTask.Result)
{
result.Success = false;
result.Message = UsersMessages.UserNotFoundMessage;
return(result);
}
var user = (User)(await usersRepository.GetByUserName(request.UserName, true)).Object;
var app = (App)(await appsRepository.GetByLicense(request.License)).Object;
if (!app.IsActive)
{
result.Success = false;
result.Message = AppsMessages.AppDeactivatedMessage;
return(result);
}
if (!app.PermitCollectiveLogins && !app.Users.Any(ua => ua.UserId == user.Id))
{
result.Success = false;
result.Message = AppsMessages.UserIsNotARegisteredUserOfThisAppMessage;
return(result);
}
var appAdmins = (await appAdminsRepository.GetAll()).Objects.ConvertAll(aa => (AppAdmin)aa);
if (!user.IsSuperUser)
{
if (user.Roles.Any(ur => ur.Role.RoleLevel == RoleLevel.ADMIN))
{
if (!appAdmins.Any(aa => aa.AppId == app.Id && aa.UserId == user.Id && aa.IsActive))
{
var adminRole = user
.Roles
.FirstOrDefault(ur => ur.Role.RoleLevel == RoleLevel.ADMIN);
user.Roles.Remove(adminRole);
}
}
}
else
{
if (!app.PermitSuperUserAccess)
{
if (user.Roles.Any(ur => ur.Role.RoleLevel == RoleLevel.SUPERUSER))
{
var superUserRole = user
.Roles
.FirstOrDefault(ur => ur.Role.RoleLevel == RoleLevel.SUPERUSER);
user.Roles.Remove(superUserRole);
}
if (user.Roles.Any(ur => ur.Role.RoleLevel == RoleLevel.ADMIN))
{
var adminRole = user
.Roles
.FirstOrDefault(ur => ur.Role.RoleLevel == RoleLevel.ADMIN);
user.Roles.Remove(adminRole);
}
}
}
result.User.UpdateWithUserInfo(user);
var claim = new List <Claim> {
new Claim(ClaimTypes.Name, request.UserName)
};
foreach (var role in user.Roles)
{
var r = (Role)(await rolesRepository.GetById(role.Role.Id)).Object;
claim.Add(new Claim(ClaimTypes.Role, r.RoleLevel.ToString()));
}
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(tokenManagement.Secret));
var credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
DateTime expirationLimit;
if (app.TimeFrame == TimeFrame.SECONDS)
{
expirationLimit = DateTime.UtcNow.AddSeconds(app.AccessDuration);
}
else if (app.TimeFrame == TimeFrame.MINUTES)
{
expirationLimit = DateTime.UtcNow.AddMinutes(app.AccessDuration);
}
else if (app.TimeFrame == TimeFrame.HOURS)
{
expirationLimit = DateTime.UtcNow.AddHours(app.AccessDuration);
}
else if (app.TimeFrame == TimeFrame.DAYS)
{
expirationLimit = DateTime.UtcNow.AddDays(app.AccessDuration);
}
else
{
expirationLimit = DateTime.UtcNow.AddMonths(app.AccessDuration);
}
var jwtToken = new JwtSecurityToken(
tokenManagement.Issuer,
tokenManagement.Audience,
claim.ToArray(),
notBefore: DateTime.UtcNow,
expires: expirationLimit,
signingCredentials: credentials
);
result.Token = new JwtSecurityTokenHandler().WriteToken(jwtToken);
result.Success = true;
result.Message = UsersMessages.UserFoundMessage;
return(result);
}
public ActionResult Register(RegisterViewModel model, ICollection <MobileNumber> mobileNumbers, string returnUrl)
{
string error;
if (ModelState.IsValid)
{
if (model.IsValid(out error))
{
//Get only numbers
string phone = StringHelper.GetOnlyNumbers(model.Phone);
if (phone.Length == 12)
{
if (_userRepository.GetUserByPhone(phone) == null)
{
User newUser = new User();
newUser.Username = model.UserName;
newUser.Phone = phone;
newUser.Password = _passwordEncryptor.EncryptPassword(model.Password);
newUser.ReceiveNewAnnouncements = model.CanReceiveEmail;
newUser.EmailAddress = model.Email;
newUser.RegisterDate = DateTime.Now;
newUser.Role = _rolesRepository.GetById("User");
newUser.ConfirmationCode = Guid.NewGuid();
newUser.Profile = _profilesRepository.GetBasicProfile();
newUser.ProfileExpires = null;
newUser.IsConfirmed = true;
_userRepository.Add(newUser);
_userRepository.SaveChanges();
if (mobileNumbers == null)
{
mobileNumbers = new List <MobileNumber>();
}
foreach (MobileNumber mobile in mobileNumbers)
{
mobile.UserId = newUser.UserID;
_mobileNumbersRepository.Add(mobile);
}
_mobileNumbersRepository.SaveChanges();
//sendConfirmEmail(newUser);
//return RedirectToAction("RegisterConfirm", new { userphone = newUser.Phone, confirmationCode = newUser.ConfirmationCode });
if (_authProvider.Authenticate(newUser) == AuthResult.Success)
{
return(RedirectToLocal(string.Empty));
}
}
else
{
error = Translation.Translation.RegisterPagePhoneNumberIsUsedAlready;
}
}
else
{
error = Translation.Translation.RegisterPageShortPhoneNumber;
}
}
}
else
{
error = Translation.Translation.RegisterPageError;
}
ModelState.AddModelError("", error);
ViewBag.MaxMobileNumbers = int.Parse(ConfigurationManager.AppSettings["MaxAdditionalMobileNumbers"]);
return(View(model));
}
