public async void RemoveSelectedRole()
{
await _userEndPoint.RemoveUserFromRole(SelectedUser.Id, SelectedUserRole);
AvailableRoles.Remove(SelectedUserRole);
UserRoles.Add(SelectedUserRole);
}
public async Task AddToRoleAsync(AppUser user, string normalizedRoleName, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrWhiteSpace(normalizedRoleName))
{
throw new ArgumentException("ValueCannotBeNullOrEmpty", nameof(normalizedRoleName));
}
var roleEntity = await Roles.SingleOrDefaultAsync(r => r.NormalizedName == normalizedRoleName, cancellationToken);
if (roleEntity == null)
{
throw new InvalidOperationException("Role doesn't exists: " + normalizedRoleName);
}
var userRole = new IdentityUserRole <int>
{
UserId = user.Id,
RoleId = roleEntity.Id
};
UserRoles.Add(userRole);
}
public void CreateDefaultAccount(IPasswordService passwordService)
{
if (Users.Any(u => u.Login == "administrator"))
{
return;
}
// create admin role
var adminRole = new Role()
{
Name = "admin"
};
Roles.Add(adminRole);
// create admin user
var salt = string.Empty;
var hash = passwordService.HashPassword("password", out salt);
var adminUser = new User()
{
Login = "******",
PasswordHash = hash,
HashSalt = salt
};
// link user and role
UserRoles.Add(new UserRole
{
Role = adminRole,
User = adminUser
});
SaveChanges();
}
/// <inheritdoc />
public override async Task AddToRoleAsync(TUser user, string normalizedRoleName,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
user.ThrowIfNull(nameof(user));
if (string.IsNullOrEmpty(normalizedRoleName))
{
throw new ArgumentException($"Parameter {nameof(normalizedRoleName)} cannot be null or empty.");
}
var roleEntity = await FindRoleAsync(normalizedRoleName, cancellationToken);
if (roleEntity == null)
{
throw new InvalidOperationException($"Role '{normalizedRoleName}' was not found.");
}
var userRoles = (await UserRolesRecord.GetRolesAsync(user.Id))?.Select(x => new TUserRole
{
UserId = user.Id,
RoleId = x.Id
}).ToList();
UserRoles = userRoles;
UserRoles.Add(CreateUserRole(user, roleEntity));
}
public void SetRoles(CMSDataContext Db, string[] value)
{
if (value == null)
{
Db.UserRoles.DeleteAllOnSubmit(UserRoles);
return;
}
var qdelete = from r in UserRoles
where !value.Contains(r.Role.RoleName)
select r;
Db.UserRoles.DeleteAllOnSubmit(qdelete);
var q = from s in value
join r in UserRoles on s equals r.Role.RoleName into g
from t in g.DefaultIfEmpty()
where t == null
select s;
foreach (var s in q)
{
var role = Db.Roles.Single(r => r.RoleName == s);
UserRoles.Add(new UserRole {
Role = role
});
}
}
public async void CreateDefaultAccount()
{
if (!Users.Any(u => u.Login == "administrator"))
{
// create admin role
var adminRole = new Role()
{
Name = "admin"
};
Roles.Add(adminRole);
// create admin user
var salt = string.Empty;
var hash = AuthHelper.HashPassword("password", out salt);
var adminUser = new User()
{
Login = "******",
PasswordHash = hash,
HashSalt = salt
};
// link user and role
UserRoles.Add(new UserRole {
Role = adminRole,
User = adminUser
});
await SaveChangesAsync();
}
}
public async void AddSelectedRole()
{
await _userEndpoint.AddUserToRole(SelectedUser.Id, SelectedAvailableRole);
UserRoles.Add(SelectedAvailableRole);
AvailableRoles.Remove(SelectedAvailableRole);
}
public void SetRoles(CMSDataContext db, string[] value)
{
if (value == null)
{
db.UserRoles.DeleteAllOnSubmit(UserRoles);
db.SubmitChanges();
return;
}
var qdelete = from r in UserRoles
where !value.Contains(r.Role.RoleName)
select r;
db.UserRoles.DeleteAllOnSubmit(qdelete);
var q = from s in value
join r in UserRoles on s equals r.Role.RoleName into g
from t in g.DefaultIfEmpty()
where t == null
select s;
foreach (var s in q)
{
var role = db.Roles.SingleOrDefault(r => r.RoleName == s);
var roleid = role?.RoleId;
if (role == null)
{
roleid = CreateRole(db, s);
}
UserRoles.Add(new UserRole {
RoleId = roleid.Value, UserId = UserId
});
}
db.SubmitChanges();
}
/// <summary>
/// Adds a user to this role instance.
/// </summary>
/// <param name="user">The user to add.</param>
public void AddUser(User user)
{
var userRole = new UserRole()
{
User = user,
Role = this
};
UserRoles.Add(userRole);
}
public async void AddSelectedRole()
{
if (!string.IsNullOrEmpty(SelectedAvailableRole))
{
await _userEndpoint.AddUserToRole(SelectedUser.Id, SelectedAvailableRole);
UserRoles.Add(SelectedAvailableRole);
AvailableRoles.Remove(SelectedAvailableRole);
}
}
public UserRole AddUser(User u)
{
var ur = new UserRole {
Id = Utils.GenerateID()
};
u.UserRoles.Add(ur);
UserRoles.Add(ur);
return(ur);
}
public void SetRoles(IList <Guid> roleIds)
{
if (roleIds != null)
{
foreach (var roleId in roleIds)
{
UserRoles.Add(new UserRole(roleId, Id));
}
}
}
public void AddRole(Role role)
{
UserRole userRole = new UserRole(this, role);
if (UserRoles == null)
{
UserRoles = new List <UserRole>();
}
UserRoles.Add(userRole);
}
public void AddUserToRoles(string userId, IList <string> roles)
{
foreach (var role in roles)
{
UserRoles.Add(new IdentityUserRole <string> {
UserId = userId, RoleId = role
});
}
SaveChanges();
}
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
if (!DesignerProperties.GetIsInDesignMode(this))
{
foreach (var userRole in UserRoleData.ReadUserRoles())
{
UserRoles.Add(userRole);
}
}
}
private void SeedDefaultUser()
{
var id = "E428D8D6-4C5E-4D33-9437-569195B3B80A".ToLower();
var email = "*****@*****.**";
var username = "******";
var password = "******";
var user = Users.FirstOrDefault(a => a.Id == id);
if (user == null)
{
user = new User()
{
Id = "E428D8D6-4C5E-4D33-9437-569195B3B80A".ToLower(),
UserName = username,
Email = email,
NormalizedEmail = email.ToUpper(),
NormalizedUserName = username.ToUpper(),
SecurityStamp = Guid.NewGuid().ToString("D"),
LockoutEnabled = true,
};
var hashedPassword = new PasswordHasher <User>().HashPassword(user, password);
user.PasswordHash = hashedPassword;
Users.Add(user);
}
else
{
var hashedPassword = new PasswordHasher <User>().HashPassword(user, password);
user.UserName = username;
user.Email = email;
user.NormalizedEmail = email.ToUpper();
user.NormalizedUserName = username.ToUpper();
user.PasswordHash = hashedPassword;
user.LockoutEnabled = true;
}
SaveChanges();
var foundRole = UserRoles.FirstOrDefault(a => a.UserId == user.Id && a.RoleId == AppRoles.ADMIN_ROLE);
if (foundRole == null)
{
var role = new IdentityUserRole <string>();
role.UserId = user.Id;
role.RoleId = AppRoles.ADMIN_ROLE;
UserRoles.Add(role);
}
SaveChanges();
}
public void ProcessMessageSubModuleAccessDoesNotAllowParentAccess()
{
var module = CommandModuleMock.Object;
var role = UserRoles.First();
role.CommandList = "CommandMock.SubMock.*";
UserRoles.Add(new UserRole("OtherRole", null, new List <string>(new string[] { "CommandMock.*" })));
var result = CommandManager.ProcessMessage("Foo", "Auth");
Assert.IsTrue(result.Processed);
Assert.IsTrue(result.Errors.Any());
ExecutorMocks["Foo"].Verify(x => x(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
}
public void ProcessMessageAllowsAuthorizedUserWhenWildcardIsRestricted()
{
var module = CommandModuleMock.Object;
var role = UserRoles.First();
role.CommandList = "CommandMock.SubMock.*";
UserRoles.Add(new UserRole("OtherRole", null, new List <string>(new string[] { "CommandMock.*" })));
var result = CommandManager.ProcessMessage("Foobar", "Auth");
Assert.IsTrue(result.Processed);
Assert.IsNull(result.Errors);
ExecutorMocks["Foobar"].Verify(x => x(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
public void SetRoles(CMSDataContext db, string[] value, bool log = true)
{
if (value == null)
{
db.UserRoles.DeleteAllOnSubmit(UserRoles);
db.SubmitChanges();
return;
}
var deletes = (from r in db.UserRoles
where r.UserId == UserId
where !value.Contains(r.Role.RoleName)
select new { r, r.Role.RoleName }).ToList();
db.UserRoles.DeleteAllOnSubmit(deletes.Select(rr => rr.r));
var addlist = (from s in value
join r in UserRoles on s equals r.Role.RoleName into g
from t in g.DefaultIfEmpty()
where t == null
select s).ToList();
foreach (var s in addlist)
{
var role = db.Roles.SingleOrDefault(r => r.RoleName == s);
var roleid = role?.RoleId;
if (role == null)
{
roleid = CreateRole(db, s);
}
UserRoles.Add(new UserRole {
RoleId = roleid.Value, UserId = UserId
});
}
db.SubmitChanges();
if (!log)
{
return;
}
if (deletes.Count > 0)
{
db.LogActivity($"Remove Roles {string.Join(",", deletes.Select(rr => rr.RoleName))} from user {Username}", pid: PeopleId, uid: Util.UserPeopleId);
}
if (addlist.Count > 0)
{
db.LogActivity($"Add Roles {string.Join(",", addlist)} to user {Username}", pid: PeopleId, uid: Util.UserPeopleId);
}
}
/// <summary>
/// Fill the in memory database with our mock data.
/// </summary>
private void PopulateDatabaseWithMockData()
{
Roles.Add(MockRoles.Admin);
Roles.Add(MockRoles.User);
var allUsers = MockApplicationUsers.GetAll().ToArray();
Users.AddRange(allUsers);
SaveChanges();
foreach (var user in allUsers)
{
UserRoles.Add(MockUserRoles.GetUserRoleForUser(user.Id));
}
Todo.AddRange(MockTodos.GetAll());
SaveChanges();
}
public void AddRoles(CMSDataContext Db, string[] value)
{
var q = from s in value
join r in UserRoles on s equals r.Role.RoleName into g
from t in g.DefaultIfEmpty()
where t == null
select s;
foreach (var s in q)
{
var role = Db.Roles.Single(r => r.RoleName == s);
UserRoles.Add(new UserRole {
Role = role
});
}
}
public async void AddSelectedRole()
{
if (UserRoles.IndexOf(SelectedAvailableRole) < 0)
{
await _userEndPoint.AddUserToRole(SelectedUser.Id, SelectedAvailableRole);
UserRoles.Add(SelectedAvailableRole);
await LoadUsers();
NotifyOfPropertyChange(() => Users);
NotifyOfPropertyChange(() => UserRoles);
}
else
{
MessageBox.Show("Already There!");
}
}
public override SettingsPropertyValueCollection GetPropertyValues(SettingsContext context, SettingsPropertyCollection collection)
{
SettingsPropertyValueCollection ret = new SettingsPropertyValueCollection();
SqlConnection sqlCon = new SqlConnection(ConnectionString);
SqlCommand sqlCmd = new SqlCommand(GetProcedure, sqlCon);
sqlCmd.CommandType = CommandType.StoredProcedure;
sqlCmd.Parameters.AddWithValue("@UserID", (string)context["UserName"]);
try
{
sqlCon.Open();
SqlDataReader reader = sqlCmd.ExecuteReader();
UserRoles roles = new UserRoles();
SettingsProperty sp = new SettingsProperty("Roles");
sp.PropertyType = typeof(UserRoles);
SettingsPropertyValue spValue = new SettingsPropertyValue(sp);
spValue.PropertyValue = roles;
while (reader.Read())
{
UserRole role = new UserRole
{
UserID = (string)reader["UserID"],
EntityContext = (int)reader["EntityContext"],
EntityID = (string)reader["EntityID"],
Role = (int)reader["Role"]
};
roles.Add(role);
}
ret.Add(spValue);
}
finally
{
sqlCon.Close();
sqlCmd.Dispose();
}
return(ret);
}
public UserDbContext(DbContextOptions options)
: base(options)
{
Database.EnsureCreated();
if (Users.Find("User1") != null)
{
return;
}
Users.Add(new User("User1", "123"));
Users.Add(new User("User2", "123"));
Roles.Add(new Role("Admin"));
UserRoles.Add(new UserRole
{
NormalizedUserName = "******",
NormalizedRoleName = "ADMIN"
});
SaveChanges();
}
public User AddUser(string role, RegisterDto dto)
{
var user = dto.ToEntity();
user.Password = _passwordHasher.HashPassword(user, dto.Password);
Add(user);
var userRole = new UserRole
{
RoleId = Roles.SingleOrDefault(x => x.Name.Equals(role)).Id,
UserId = user.Id
};
UserRoles.Add(userRole);
return(user);
}
/// <summary>
/// Assign / Remove roles
/// </summary>
/// <param name="roles">Roles id</param>
/// <param name="roleEntities">Role entities</param>
/// <exception cref="ForbiddenOperationDomainException"></exception>
public void EditRoles(IEnumerable <int> roles, List <Role.Role> roleEntities)
{
if (Root)
{
throw new ForbiddenOperationDomainException("Root user");
}
var roleIds = roles as int[] ?? roles.ToArray();
// Add new roles
foreach (var roleId in roleIds)
{
var role = roleEntities.SingleOrDefault(r => r.Id == roleId);
// Skip if the role to add no exists in the context
if (role == null)
{
continue;
}
// Skip if the role is just assigned
if (UserRoles.Any(i => i.RoleId == roleId))
{
continue;
}
UserRoles.Add(
new UserRole
{
RoleId = role.Id,
UserId = Id
});
}
// Remove deleted roles
foreach (var userRole in UserRoles.ToArray())
{
if (!roleIds.Contains(userRole.RoleId))
{
UserRoles.Remove(userRole);
}
}
}
/// <summary>
/// Adds the given <paramref name="normalizedRoleName"/> to the specified <paramref name="user"/>.
/// </summary>
/// <param name="user">The user to add the role to.</param>
/// <param name="normalizedRoleName">The role to add.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param>
/// <returns>The <see cref="Task"/> that represents the asynchronous operation.</returns>
public async override Task AddToRoleAsync(User user, string normalizedRoleName, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrWhiteSpace(normalizedRoleName))
{
throw new ArgumentException(Resources.ValueCannotBeNullOrEmpty, nameof(normalizedRoleName));
}
var roleEntity = await FindRoleAsync(normalizedRoleName, cancellationToken);
if (roleEntity == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.RoleNotFound, normalizedRoleName));
}
UserRoles.Add(CreateUserRole(user, roleEntity));
}
public void AddRoles(CMSDataContext db, params string[] value)
{
var q = from s in value
join r in UserRoles on s equals r.Role.RoleName into g
from t in g.DefaultIfEmpty()
where t == null
select s;
foreach (var s in q)
{
var role = db.Roles.SingleOrDefault(r => r.RoleName == s);
if (role == null)
{
throw new Exception($"Role {s} does not exist");
}
UserRoles.Add(new UserRole {
Role = role
});
}
}
public User AddChild(ChildInfoDto dto)
{
var user = dto.ToEntity();
user.Status = UserStatus.Activate;
user.Password = _passwordHasher.HashPassword(user, DefaultPassword);
Add(user);
var userRole = new UserRole
{
RoleId = Roles.SingleOrDefault(x => x.Name.Equals(Settings.UserRoles.Child)).Id,
UserId = user.Id
};
UserRoles.Add(userRole);
return(user);
}
/// <summary>
/// Adds the given <paramref name="normalizedRoleName"/> to the specified <paramref name="user"/>.
/// </summary>
/// <param name="user">The user to add the role to.</param>
/// <param name="normalizedRoleName">The role to add.</param>
/// <param name="companyId">The id of the company to which this role to be added.</param>
/// <param name="tenantId">The id of the tenant to which this role to be added.</param>
/// <param name="cancellationToken">The <see cref="CancellationToken"/> used to propagate notifications that the operation should be canceled.</param>
/// <returns>The <see cref="Task"/> that represents the asynchronous operation.</returns>
public async override Task AddToRoleAsync(User user, string normalizedRoleName, Guid?companyId, Guid?tenantId, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrWhiteSpace(normalizedRoleName))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(normalizedRoleName));
}
var roleEntity = await FindRoleAsync(normalizedRoleName, companyId, tenantId, cancellationToken);
if (roleEntity == null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, $"Role {normalizedRoleName} does not exist.", normalizedRoleName));
}
UserRoles.Add(CreateUserRole(user, roleEntity));
}
