public void PerformanceRoleTest()
{
int all;
const int PERF_COUNT = 20;
var users = mp.GetAllUsers(0, 10, out all);
var usrStr = users.Cast <MembershipUser>().Select(p => p.UserName);
var roles = new List <string>(PERF_COUNT);
var now = DateTime.Now;
for (int i = 0; i < PERF_COUNT; i++)
{
string roleName = Guid.NewGuid().ToString().Replace("-", "");
rp.CreateRole(roleName);
roles.Add(roleName);
}
Console.WriteLine("Creating {0} roles took {1}", PERF_COUNT, (DateTime.Now - now));
now = DateTime.Now;
rp.AddUsersToRoles(usrStr.ToArray(), roles.ToArray());
Assert.AreEqual(rp.GetUsersInRole(roles.Last()).Length, users.Count);
Console.WriteLine("Assigning {0} roles to {1} users operations took {2}", PERF_COUNT, users.Count, (DateTime.Now - now));
now = DateTime.Now;
rp.RemoveUsersFromRoles(usrStr.ToArray(), roles.ToArray());
Assert.AreEqual(rp.GetUsersInRole(roles.Last()).Length, 0);
for (int i = 0; i < PERF_COUNT; i++)
{
rp.DeleteRole(roles[i], false);
}
Console.WriteLine("Removing created roles and assignes took {0}", (DateTime.Now - now));
}
public override string[] GetUsersInRole(string roleName)
{
if (!Initialized)
{
return(_prevProvider.GetUsersInRole(roleName));
}
if (string.IsNullOrEmpty(roleName))
{
MySqlSimpleMembershipProvider.NullArgumentException("roleName");
}
int roleid = GetRoleId(roleName);
if (roleid > 0)
{
using (MySqlDatabaseWrapper dbConn = new MySqlDatabaseWrapper(ConnectionString))
{
var users = dbConn.ExecuteQuery(string.Format("select ut.{0} from {1} as urt join {2} as ut on urt.userid = ut.{3} where urt.roleid=?;", UserNameColumn, _userInRolesTable, UserTableName, UserIdColumn), roleid);
if (users.Count() > 0)
{
return(users.Select(role => role[0].ToString()).ToArray());
}
}
}
return(null);
}
private IEnumerable <PrincipalInfo> EnumerateMembershipUsersInRole(string providerName, string roleName)
{
List <PrincipalInfo> userInfos = new List <PrincipalInfo>();
try {
RoleProvider provider = Roles.Providers[providerName];
if (provider == null)
{
throw new ConfigurationErrorsException(String.Format("Role provider \"{0}\" not found", providerName));
}
foreach (string username in provider.GetUsersInRole(roleName))
{
PrincipalInfo resolvedUser = ResolveMembershipUser(null, username);
if (resolvedUser != null)
{
userInfos.Add(resolvedUser);
}
}
} catch (PrincipalResolveException) {
throw;
} catch (Exception ex) {
userInfos.Add(ExceptionHandler(new PrincipalResolveException(roleName, ex)));
}
return(userInfos);
}
internal static void CreateRoles(RoleProvider provider)
{
ProviderRoles = provider.GetAllRoles().ToList <string>().FindAll(roleName => roleName.ToLower().Contains("test_"));
foreach (string role in ProviderRoles)
{
if (provider.RoleExists(role))
{
string[] usersInRoles = provider.GetUsersInRole(role);
if (usersInRoles.Length != 0)
{
provider.RemoveUsersFromRoles(usersInRoles, new string[] { role }); //remove users from role
}
provider.DeleteRole(role, false); //remove role
}
}
ProviderRoles.Clear();
for (int x = 0; x < 20; x++)
{
string roleName = string.Format("TEST_ROLE:{0:000}", x);
ProviderRoles.Add(roleName);
provider.CreateRole(roleName);
}
//NOTE: roles 0-9 are reserved for query type operations and should be considered read only
// roles 10-19 may be used for C-U-D operations
addUserToRole(Users[0], ProviderRoles[0], provider); // several users in one role
addUserToRole(Users[2], ProviderRoles[0], provider);
addUserToRole(Users[4], ProviderRoles[0], provider);
addUserToRole(Users[6], ProviderRoles[1], provider); // same user in multiple roles
addUserToRole(Users[6], ProviderRoles[2], provider);
addUserToRole(Users[6], ProviderRoles[3], provider);
addUserToRole(Users[10], ProviderRoles[1], provider); // same user in multiple roles
addUserToRole(Users[10], ProviderRoles[2], provider);
addUserToRole(Users[10], ProviderRoles[3], provider);
addUserToRole(Users[8], ProviderRoles[1], provider);
addUserToRole(Users[8], ProviderRoles[2], provider);
/*
* TEST_ROLE:000
* Users[0]
* Users[2]
* Users[4]
* TEST_ROLE:001
* Users[6]
* Users[8]
* TEST_ROLE:002
* Users[6]
* Users[8]
* TEST_ROLE:003
* Users[6]
* TEST_ROLE:004
* -- no users
*
*/
}
public override string[] GetUsersInRole(string roleName)
{
LogDebug("Entering CachedProvider.GetUsersInRole");
string[] users;
users = _provider.GetUsersInRole(roleName);
return(users);
}
public void GetUsersInRole_GetRolesForExistingUserAndGetUsersInAllRoles_ExistingUserInRoles()
{
var roles = provider.GetRolesForUser(ExistingUserName);
foreach (var role in roles)
{
IEnumerable <string> users = provider.GetUsersInRole(role);
Assert.IsTrue(users.Contains(ExistingUserName), string.Format("User '{0}' not in role '{1}'", ExistingUserName, role));
}
}
public bool AdminExists()
{
var users = _provider.GetUsersInRole("Admin");
if (users.Length == 0)
{
return(false);
}
return(true);
}
/// <summary>
/// The GetRoleNonMembers method returns a list of roles that doesn´t have any members.
/// </summary>
/// <param name="roleId">The role id.</param>
/// <param name="portalAlias">The portal alias</param>
public IList <RainbowRole> GetRoleNonMembers(Guid roleId, string portalAlias)
{
IList <RainbowRole> res = new List <RainbowRole>();
IList <RainbowRole> allRoles = RoleProvider.GetAllRoles(portalAlias);
foreach (RainbowRole s in allRoles)
{
if (RoleProvider.GetUsersInRole(portalAlias, s.Id).Length == 0)
{
res.Add(s);
}
}
return(res);
}
public void Can_Get_Users_In_Role()
{
var user1 = new User {
Username = "******", Password = "******"
};
var user2 = new User {
Username = "******", Password = "******"
};
RoleProvider.CreateRole("admin");
RoleProvider.CreateRole("engineering");
RoleProvider.CreateRole("sales");
MembershipProvider.CreateAccount(user1);
MembershipProvider.CreateAccount(user2);
RoleProvider.AddUsersToRoles(new[] { "sallen", "missmm" }, new[] { "admin", "engineering" });
Assert.Equal(2, RoleProvider.GetUsersInRole("admin").Length);
}
public bool ModeratorExists()
{
var users = _provider.GetUsersInRole("Moderator");
return(users.Count() != 0);
}
protected void SendMailFromDb(Project project, dynamic model, ProjectWorkflow.Trigger trigger, UserType userType)
{
var template = Repository.GetOne <MailTemplate>(t => t.Trigger == trigger && t.UserType == userType);
if (template == null)
{
template = new MailTemplate
{
UserType = userType,
Trigger = trigger,
Title = "Шаблон письма отсутствует",
Body =
string.Format("Необходимо добавить шаблон письма для {0} пользователя на {1} событие", userType,
trigger)
};
}
if (template.UserType == UserType.Admin)
{
string[] users = RoleProvider.GetUsersInRole("Admin");
foreach (var userName in users)
{
Users user = Repository.GetOne <Users>(u => u.Username == userName);
if (user != null && user.NotificationTypeList.Contains(project.GetType().Name))
{
Email
.From("*****@*****.**")
.UsingClient(Client)
.To(user.Email)
.Subject(template.Title)
.UsingTemplate(template.Body, model)
.Send();
_protalNotification.PushNotificate(new NotificationQueue
{
IsRead = false,
NotificationTime = DateTime.Now,
NotificationTitle = template.Title,
NotigicationBody = template.Body,
UserName = user.Username
});
}
}
}
if (template.UserType == UserType.Investor)
{
string investorMail = project.InvestorUser;
if (string.IsNullOrEmpty(investorMail))
{
investorMail = project.Responses.Last().InvestorEmail;
}
Email
.From("*****@*****.**")
.UsingClient(Client)
.To(investorMail)
.Subject(template.Title)
.UsingTemplate(template.Body, model)
.Send();
_protalNotification.PushNotificate(new NotificationQueue
{
IsRead = false,
NotificationTime = DateTime.Now,
NotificationTitle = template.Title,
NotigicationBody = template.Body,
UserName = project.Responses.Last().InvestorEmail
});
}
if (template.UserType == UserType.User)
{
string[] users = RoleProvider.GetUsersInRole("User");
foreach (var userName in users)
{
MembershipUser user = Membership.GetUser(userName, false);
if (user != null)
{
Email
.From("*****@*****.**")
.UsingClient(Client)
.To(user.Email)
.Subject(template.Title)
.UsingTemplate(template.Body, model)
.Send();
_protalNotification.PushNotificate(new NotificationQueue
{
IsRead = false,
NotificationTime = DateTime.Now,
NotificationTitle = template.Title,
NotigicationBody = template.Body,
UserName = user.UserName
});
}
}
}
}
/// <summary>
/// Finds the user names by role.
/// </summary>
/// <param name="roleName">Name of the role.</param>
/// <returns></returns>
public IEnumerable <string> FindUserNamesByRole(string roleName)
{
return(_roleProvider.GetUsersInRole(roleName));
}
public List <string> GetUsersInRole(string roleName)
{
return(_provider.GetUsersInRole(roleName).ToList <string>());
}
public IEnumerable <string> GetUsersInRole(string roleName)
{
return(roleProvider.GetUsersInRole(roleName));
}
public string[] GetUsersInRole(string roleName)
{
return(roleProvider.GetUsersInRole(roleName));
}
public override string[] GetUsersInRole(string roleName)
{
return(_Provider.GetUsersInRole(roleName));
}
public string Process(string[] args)
{
var sb = new StringBuilder();
var p = new OptionSet()
{
{ "c|create", "create a role\nUSAGE: role --create rolename",
v => _command = Command.Create },
{ "d|delete", "delete a role\nUSAGE: role --delete rolename",
v => _command = Command.Delete },
{ "l|list", "return a list of roles\nUSAGE: role --list",
v => _command = Command.List },
{ "g|give", "add a user to a role\nUSAGE: role --give username rolename",
v => _command = Command.Give },
{ "t|take", "remove a user from a role\nUSAGE: role --take username rolename",
v => _command = Command.Take },
{ "u|users", "list all users in a role\nUSAGE: role --users rolename",
v => _command = Command.Users },
{ "r|roles", "list all roles for a user\nUSAGE: role --roles username",
v => _command = Command.Roles },
{ "h|help", "show this list of options\nUSAGE --help",
v => _command = null }
};
List <string> extras;
try
{
extras = p.Parse(args);
}
catch (OptionException e)
{
sb.Append("role: ");
sb.AppendLine(e.Message);
sb.AppendLine("Try `role --help' for more information.");
return(sb.ToString());
}
// perform the selected command
if (_command == Command.Create)
{
if (extras.Count == 1)
{
_provider.CreateRole(extras[0]);
sb.AppendLine("Role successfully created");
}
else
{
sb.AppendLine("USAGE: role --create rolename");
}
}
else if (_command == Command.Delete)
{
if (extras.Count == 1)
{
try
{
var success = _provider.DeleteRole(extras[0], true);
if (success)
{
sb.AppendLine("Role successfully deleted");
}
else
{
sb.AppendFormat("Could not delete role: {0}", extras[0]);
sb.AppendLine();
}
}
catch (Exception ex)
{
sb.AppendFormat("Could not delete role: {0} - {1}", extras[0], ex.Message);
sb.AppendLine();
}
}
else
{
sb.AppendLine("USAGE: role --delete rolename");
}
}
else if (_command == Command.List)
{
if (extras.Count == 0)
{
var roles = _provider.GetAllRoles();
if (roles.Count() > 0)
{
foreach (var role in roles)
{
sb.AppendLine(role);
}
}
else
{
sb.AppendLine("No roles found");
}
}
else
{
sb.AppendLine("USAGE: role --list");
}
}
else if (_command == Command.Give)
{
if (extras.Count == 2)
{
_provider.AddUsersToRoles(new string[] { extras[0] }, new string[] { extras[1] });
sb.AppendFormat("Added {0} to {1}", extras[0], extras[1]);
sb.AppendLine();
}
else
{
sb.AppendLine("USAGE: role --give username rolename");
}
}
else if (_command == Command.Take)
{
if (extras.Count == 2)
{
_provider.RemoveUsersFromRoles(new string[] { extras[0] }, new string[] { extras[1] });
sb.AppendFormat("Removed {0} from {1}", extras[0], extras[1]);
sb.AppendLine();
}
else
{
sb.AppendLine("USAGE: role --take username rolename");
}
}
else if (_command == Command.Users)
{
if (extras.Count == 1)
{
var users = _provider.GetUsersInRole(extras[0]);
if (users.Count() > 0)
{
sb.AppendFormat("{0} users in {1}", users.Count(), extras[0]);
sb.AppendLine();
foreach (var u in users)
{
sb.AppendLine(u);
}
}
else
{
sb.AppendLine("No users in role");
}
}
else
{
sb.AppendLine("USAGE: role --users rolename");
}
}
else if (_command == Command.Roles)
{
if (extras.Count == 1)
{
var roles = _provider.GetRolesForUser(extras[0]);
if (roles.Count() > 0)
{
sb.AppendFormat("{0} roles for {1}", roles.Count(), extras[0]);
sb.AppendLine();
foreach (var r in roles)
{
sb.AppendLine(r);
}
}
else
{
sb.AppendLine("No roles found for user");
}
}
else
{
sb.AppendLine("USAGE: role --roles username");
}
}
else
{
sb.AppendLine(ShowHelp(p));
}
return(sb.ToString());
}
public void MembershipRole_GetUsersInRoleTests()
{
string roleName;
string[] results;
//-------------------------------------------------------
// existing role no users
//-------------------------------------------------------
roleName = TestUtils.ProviderRoles[10];
results = _provider.GetUsersInRole(roleName);
Assert.IsNotNull(results);
Assert.AreEqual <int>(0, results.Length);
//-------------------------------------------------------
// existing role with users
//-------------------------------------------------------
roleName = TestUtils.ProviderRoles[0];
results = _provider.GetUsersInRole(roleName);
Assert.IsNotNull(roleName);
Assert.AreEqual <int>(3, results.Length);
Assert.AreEqual <string>(TestUtils.Users[0].Username, results[0]);
Assert.AreEqual <string>(TestUtils.Users[2].Username, results[1]);
Assert.AreEqual <string>(TestUtils.Users[4].Username, results[2]);
//-------------------------------------------------------
// nonexisting role
//-------------------------------------------------------
roleName = Guid.NewGuid().ToString();
try
{
results = _provider.GetUsersInRole(roleName);
Assert.Fail("Provider did not throw expected ProviderException");
}
catch (ProviderException)
{
//ignore expected exception
}
//-------------------------------------------------------
// null role
//-------------------------------------------------------
roleName = null;
try
{
results = _provider.GetUsersInRole(roleName);
Assert.Fail("Provider did not throw expected ArgumentNullException");
}
catch (ArgumentNullException)
{
//ignore expected exception
}
//-------------------------------------------------------
// empty role
//-------------------------------------------------------
roleName = string.Empty;
try
{
results = _provider.GetUsersInRole(roleName);
Assert.Fail("Provider did not throw expected ArgumentException");
}
catch (ArgumentException)
{
//ignore expected exception
}
}
/// <summary>
/// The GetRoleMembers method returns a list of all members in the specified security role.
/// </summary>
/// <param name="roleId">The role id.</param>
/// <returns>a <code>string[]</code> of user names
/// </returns>
public string[] GetRoleMembers(Guid roleId)
{
return(RoleProvider.GetUsersInRole(CurrentPortalSettings.PortalAlias, roleId));
}
