public MembershipHelper
(
IUmbracoContextAccessor accessor,
MembershipProvider membershipProvider,
RoleProvider roleProvider,
IMemberService memberService,
IMemberTypeService memberTypeService,
IUserService userService,
IPublicAccessService publicAccessService,
PublishedRouter publishedRouter,
CacheHelper appCaches,
ILogger logger
)
{
_umbracoContextAccessor = accessor ?? throw new ArgumentNullException(nameof(accessor));
_memberService = memberService;
_memberTypeService = memberTypeService;
_userService = userService;
_publicAccessService = publicAccessService;
_publishedRouter = publishedRouter;
_appCaches = appCaches;
_logger = logger;
_membershipProvider = membershipProvider ?? throw new ArgumentNullException(nameof(membershipProvider));
_roleProvider = roleProvider ?? throw new ArgumentNullException(nameof(roleProvider));
}
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);
}
/// <summary>
/// The GetRoles method returns a list of roles for the user.
/// </summary>
/// <param name="email">The email.</param>
/// <param name="portalAlias">The portal alias.</param>
/// <returns>A <code>IList<RainbowRole></code> containing the user's roles</returns>
public IList <RainbowRole> GetRoles(string email, string portalAlias)
{
string userName = MembershipProvider.GetUserNameByEmail(portalAlias, email);
RainbowUser user = (RainbowUser)MembershipProvider.GetUser(portalAlias, userName, true);
return(RoleProvider.GetRolesForUser(portalAlias, user.ProviderUserKey));
}
public MembershipHelper
(
HttpContextBase httpContext,
IPublishedMemberCache memberCache,
MembershipProvider membershipProvider,
RoleProvider roleProvider,
IMemberService memberService,
IMemberTypeService memberTypeService,
IUserService userService,
IPublicAccessService publicAccessService,
AppCaches appCaches,
ILogger logger
)
{
HttpContext = httpContext;
MemberCache = memberCache;
_memberService = memberService;
_memberTypeService = memberTypeService;
_userService = userService;
_publicAccessService = publicAccessService;
_appCaches = appCaches;
_logger = logger;
_membershipProvider = membershipProvider ?? throw new ArgumentNullException(nameof(membershipProvider));
_roleProvider = roleProvider ?? throw new ArgumentNullException(nameof(roleProvider));
}
/// <summary>
/// Clear out everything except the admin user
/// </summary>
private void DoFullReset()
{
foreach (var repository in Repository.GetAllRepositories())
{
Repository.Delete(repository.Id);
}
foreach (var team in TeamRepository.GetAllTeams())
{
TeamRepository.Delete(team.Id);
}
foreach (var user in Users.GetAllUsers())
{
if (!user.Username.Equals("Admin", StringComparison.OrdinalIgnoreCase))
{
Users.DeleteUser(user.Id);
}
}
foreach (var role in RoleProvider.GetAllRoles())
{
if (role != Definitions.Roles.Administrator)
{
RoleProvider.DeleteRole(role, true);
}
}
}
public ActionResult Edit(Guid id)
{
if (id != User.Id() && !User.IsInRole(Definitions.Roles.Administrator))
{
return(RedirectToAction("Unauthorized", "Home"));
}
if (MembershipService.IsReadOnly())
{
return(RedirectToAction("Detail", "Account", new { id = id }));
}
var user = MembershipService.GetUserModel(id);
if (user != null)
{
var model = new UserEditModel
{
Id = user.Id,
Username = user.Username,
Name = user.GivenName,
Surname = user.Surname,
Email = user.Email,
Roles = RoleProvider.GetAllRoles(),
SelectedRoles = RoleProvider.GetRolesForUser(user.Id)
};
return(View(model));
}
return(View());
}
public MemberGroupHelper(IRouteGenerator routeGenerator, IMemberService memberService, IMemberGroupService memberGroupService, RoleProvider roleProvider)
{
_routeGenerator = routeGenerator ?? throw new ArgumentNullException(nameof(routeGenerator));
_memberService = memberService ?? throw new ArgumentNullException(nameof(memberService));
_memberGroupService = memberGroupService ?? throw new ArgumentNullException(nameof(memberGroupService));
_roleProvider = roleProvider ?? throw new ArgumentNullException(nameof(roleProvider));
}
public void OnAuthorization(AuthorizationContext filterContext)
{
var user = filterContext.HttpContext.User;
if (!user.Identity.IsAuthenticated)
{
HandleUnauthorizedRequest(filterContext);
return;
}
if (_usersSplit.Length > 0)
{
if (_usersSplit.Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase))
{
return;
}
}
if (_rolesSplit.Length > 0)
{
if (_rolesSplit.Any(role => RoleProvider.IsUserInRole(user.Identity.Name, role)))
{
return;
}
}
if (_rolesSplit.Length > 0 || _usersSplit.Length > 0)
{
HandleUnauthorizedRequest(filterContext);
}
}
public ActionResult Edit(string id)
{
if (!id.Equals(User.Id(), StringComparison.OrdinalIgnoreCase) && !User.IsInRole(Definitions.Roles.Administrator))
{
return(RedirectToAction("Unauthorized", "Home"));
}
if (MembershipService.IsReadOnly())
{
return(RedirectToAction("Detail", "Account", new { id = id }));
}
if (!String.IsNullOrEmpty(id))
{
var user = MembershipService.GetUser(id);
if (user != null)
{
var model = new UserEditModel
{
Username = user.Name,
Name = user.GivenName,
Surname = user.Surname,
Email = user.Email,
Roles = RoleProvider.GetRolesForUser(user.Name),
};
PopulateRoles();
return(View(model));
}
}
return(View());
}
/// <summary>
/// Initializes a new instance of the <see cref="AspNetRoleProviderWrapper"/> class.
/// </summary>
public AspNetRoleProviderWrapper()
{
if (Roles.Enabled)
{
_roleProvider = Roles.Provider;
}
}
public static void AddUserToRolesIfNotInYet(this RoleProvider p, string username, List <string> roles)
{
string[] rsUserIn = p.GetRolesForUser(username);
List <string> rsToAdd = new List <string>();
if (rsUserIn != null)
{
foreach (string role in roles)
{
if (!rsUserIn.Contains(role))
{
rsToAdd.Add(role);
}
}
}
else
{
rsToAdd = roles;
}
if (rsToAdd.Count > 0)
{
Utils.BaseRoleProvider().AddUsersToRoles(new string[] { username }, rsToAdd.ToArray());
}
}
public DefaultProviderSwitcher(
MembershipProviderAccessor membershipProviderAccessor,
RoleProviderAccessor roleProviderAccessor,
MembershipProvider provider,
RoleProvider roleProvider)
{
Condition.Requires(membershipProviderAccessor, "membershipProviderAccessor").IsNotNull();
Condition.Requires(roleProviderAccessor, "roleProviderAccessor").IsNotNull();
Condition.Requires(provider, "provider").IsNotNull();
Condition.Requires(roleProvider, "roleProvider").IsNotNull();
this.membershipProviderAccessor = membershipProviderAccessor;
this.roleProviderAccessor = roleProviderAccessor;
this.originalMembershipInitializedDefault =
membershipProviderAccessor.SetInitializedDefaultProviderAndReturnOriginalValue(true);
this.originalMembershipInitialized = membershipProviderAccessor.SetInitializedAndReturnOriginalValue(true);
this.originalMembershipProvider = membershipProviderAccessor.SetProviderAndReturnOriginalValue(provider);
this.originalRoleEnabledInitialized = roleProviderAccessor.SetEnabledAndReturnOriginalValue(true);
this.originalRoleProviders =
roleProviderAccessor.SetProvidersAndReturnOriginalValue(new RoleProviderCollection());
this.originalRoleInitializedDefault =
roleProviderAccessor.SetInitializedDefaultProviderAndReturnOriginalValue(true);
this.originalRoleInitialized = roleProviderAccessor.SetInitializedAndReturnOriginalValue(true);
this.originalRoleProvider = roleProviderAccessor.SetProviderAndReturnOriginalValue(roleProvider);
}
public ActionResult Edit(int?ID)
{
var myRoles = DB.Roles.Where(x => CurrentUser.UserRoles.Contains(x.RoleName)).Select(x => x.RoleId).ToList();
var allowedRoles =
DB.UserAllowedRoles.Where(x => myRoles.Contains(x.RoleID))
.Select(x => DB.Roles.FirstOrDefault(z => z.RoleId == x.AllowedRoleID))
.Where(x => x != null)
.Distinct()
.ToList();
ViewBag.AllowedRoles = allowedRoles;
User user = null;
if (ID.HasValue)
{
user = DB.Users.FirstOrDefault(x => x.ID == ID);
if (user == null || ((user.IsDeleted ?? false) && RoleProvider.IsUserInRole(CurrentUser.Name, "Admin")))
{
return(RedirectToAction("Index"));
}
}
else
{
user = new User()
{
Password = new Random(DateTime.Now.Millisecond).GeneratePassword()
};
}
if (user.ID > 0)
{
user.UserRoleRadio = DB.Roles.First(x => x.RoleName == user.UserRoles.First()).RoleId;
}
return(View(user));
}
internal static RoleProvider GetDefaultRoleProvider()
{
if (defaultRoleProviderSet)
{
return(defaultRoleProvider);
}
Type typeOfRoles = TypeOfRoles;
RoleProvider provider = null;
if (typeOfRoles != null)
{
try
{
if ((bool)typeOfRoles.GetProperty("Enabled").GetValue(null, null))
{
provider = typeOfRoles.GetProperty("Provider").GetValue(null, null) as RoleProvider;
}
}
catch (TargetInvocationException exception)
{
if (exception.InnerException != null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception.InnerException);
}
throw;
}
}
defaultRoleProvider = provider;
defaultRoleProviderSet = true;
return(provider);
}
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
*
*/
}
private void RegisterProviders(IUnityContainer container)
{
// 身份
MembershipProviderCollection mProviders = new MembershipProviderCollection();
MembershipSection mSection =
(MembershipSection)WebConfigurationManager.GetSection("system.web/membership");
foreach (ProviderSettings settings in mSection.Providers)
{
if (settings.Parameters["connectionStringName"] != null)
{
settings.Parameters["connectionStringName"] = D.NamedSection.DataConnection;
}
}
ProvidersHelper.InstantiateProviders(
mSection.Providers, mProviders, typeof(MembershipProvider));
MembershipProvider mProvider = mProviders[mSection.DefaultProvider];
// 角色
RoleProviderCollection rProviders = new RoleProviderCollection();
RoleManagerSection rSection =
(RoleManagerSection)WebConfigurationManager.GetSection("system.web/roleManager");
foreach (ProviderSettings settings in rSection.Providers)
{
if (settings.Parameters["connectionStringName"] != null)
{
settings.Parameters["connectionStringName"] = D.NamedSection.DataConnection;
}
}
ProvidersHelper.InstantiateProviders(
rSection.Providers, rProviders, typeof(RoleProvider));
RoleProvider rProvider = rProviders[rSection.DefaultProvider];
// 配置
ProfileProviderCollection pProviders = new ProfileProviderCollection();
ProfileSection pSection =
(ProfileSection)WebConfigurationManager.GetSection("system.web/profile");
foreach (ProviderSettings settings in pSection.Providers)
{
if (settings.Parameters["connectionStringName"] != null)
{
settings.Parameters["connectionStringName"] = D.NamedSection.DataConnection;
}
}
ProvidersHelper.InstantiateProviders(
pSection.Providers, pProviders, typeof(ProfileProvider));
ProfileProvider pProvider = pProviders[pSection.DefaultProvider];
container.RegisterInstance <MembershipProvider>(mProvider);
container.RegisterInstance <RoleProvider>(rProvider);
container.RegisterInstance <ProfileProvider>(pProvider);
}
void Connect()
{
try
{
this.Cursor = Cursors.WaitCursor;
frmAdmin.Provider = System.Web.Security.Membership.Providers[cmbProviders.Text];
RoleProvider wRoleProvider = FwkMembership.GetRoleProvider(cmbProviders.Text);
string cnnString = FwkMembership.GetProvider_ConnectionString(frmAdmin.Provider.Name);
Fwk.DataBase.CnnString cnn = new DataBase.CnnString("", cnnString);
lblServer.Text = cnn.DataSource;
lblDatabase.Text = cnn.InitialCatalog;
lblCnnString.Text = cnn.ToString();
if (!onInit)
{
DataBase.Metadata m = new DataBase.Metadata(cnn);
if (m.TestConnection())
{
CurrentProviderConnectedOk = true;
lblConnectionStatus.Text = "Connected";
this.btnRefreshConnection.Image = global::Fwk.Security.Admin.Properties.Resources.Connection_Check;
this.btnRefreshConnection.Text = "Refresh";
}
else
{
CurrentProviderConnectedOk = false;
lblConnectionStatus.Text = "Disconected";
this.btnRefreshConnection.Image = global::Fwk.Security.Admin.Properties.Resources.Connection_Warning;
this.btnRefreshConnection.Text = "Try reconnect";
}
}
}
catch (Exception ex)
{
CurrentProviderConnectedOk = false;
lblConnectionStatus.Text = "Disconected";
this.btnRefreshConnection.Image = global::Fwk.Security.Admin.Properties.Resources.Connection_Warning;
this.btnRefreshConnection.Text = "Try reconnect";
base.MessageViewInfo.Show(Fwk.Exceptions.ExceptionHelper.GetAllMessageException(ex));
}
if (currontSecurityControlBase == null)
{
this.Cursor = Cursors.Arrow;
return;
}
try
{
currontSecurityControlBase.Initialize();
}
catch (Exception ex)
{
CurrentProviderConnectedOk = false;
lblConnectionStatus.Text = "Disconected";
base.MessageViewInfo.Show(Fwk.Exceptions.ExceptionHelper.GetAllMessageException(ex));
}
this.Cursor = Cursors.Arrow;
}
public virtual string[] GetRoles(string mOperation)
{
if (!Permissions.ContainsKey(mOperation) || Permissions[mOperation] == null)
{
Permissions[mOperation] = RoleProvider.GetRoleForOperation(mOperation, ObjectName);
}
return(Permissions[mOperation] as string[]);
}
public void Can_Delete_Role()
{
RoleProvider.CreateRole("admin");
RoleProvider.DeleteRole("admin", true);
Assert.False(_db.CanFindRole("admin"));
}
public void Can_Delete_Role()
{
RoleProvider.CreateRole("admin");
RoleProvider.DeleteRole("admin", true);
Assert.False(Verifier.Query <Role>().Any(r => r.Name == "admin"));
}
public FakeRoleProviderTest()
{
this.localProvider = Substitute.For <RoleProvider>();
this.provider = new FakeRoleProvider();
this.provider.LocalProvider.Value = this.localProvider;
this.roles = new[] { @"sitecore\Editors", @"sitecore\Authors" };
this.users = new[] { @"sitecore\John", @"sitecore\Jane" };
}
public bool Update(RoleProvider roleMasterList, List <PageControlsProvider> roleDetailList)
{
bool isUpdate = false;
try
{
SqlCommand command = new SqlCommand();
this.ConnectionOpen();
command.Connection = Connection;
this.BeginTransaction(true);
command.Transaction = this.Transaction;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "[UserAccess].[RoleSet]";
command.Parameters.Add("@RoleCode", SqlDbType.Int).Value = roleMasterList.RoleCode;
command.Parameters.Add("@RoleName", SqlDbType.NVarChar).Value = roleMasterList.RoleName;
command.Parameters.Add("@RoleDescription", SqlDbType.NVarChar).Value = roleMasterList.RoleDescription;
command.Parameters.Add("@Option", SqlDbType.Int).Value = DBConstants.DataModificationOption.Update;
command.ExecuteNonQuery();
foreach (PageControlsProvider objList in roleDetailList)
{
command = new SqlCommand();
//ConnectionOpen();
command.Connection = Connection;
command.Transaction = Transaction;
command.CommandType = CommandType.StoredProcedure;
command.CommandText = "[UserAccess].[RoleDetailSet]";
command.Parameters.Add("@MenuID", SqlDbType.Int).Value = objList.MenuId;
command.Parameters.Add("@RoleCode", SqlDbType.Int).Value = roleMasterList.RoleCode;
command.Parameters.Add("@CanSelect", SqlDbType.Bit).Value = objList.CanSelect;
command.Parameters.Add("@CanInsert", SqlDbType.Bit).Value = objList.CanInsert;
command.Parameters.Add("@CanUpdate", SqlDbType.Bit).Value = objList.CanUpdate;
command.Parameters.Add("@CanDelete", SqlDbType.Bit).Value = objList.CanDelete;
command.Parameters.Add("@CanSend", SqlDbType.Bit).Value = objList.CanSend;
command.Parameters.Add("@CanCheck", SqlDbType.Bit).Value = objList.CanCheck;
command.Parameters.Add("@CanApprove", SqlDbType.Bit).Value = objList.CanApprove;
command.Parameters.Add("@CanPreview", SqlDbType.Bit).Value = objList.CanPreview;
command.Parameters.Add("@CanReceive", SqlDbType.Bit).Value = objList.CanReceive;
command.Parameters.Add("@Option", SqlDbType.Int).Value = DBConstants.DataModificationOption.Update;
command.ExecuteNonQuery();
}
CommitTransaction();
ConnectionClosed();
isUpdate = true;
}
catch (Exception exp)
{
this.RollbackTransaction();
throw new Exception(exp.Message);
}
finally
{
this.ConnectionClosed();
}
return(isUpdate);
}
public ActionResult CreateADUser()
{
var efms = MembershipService as EFMembershipService;
if ((!Request.IsAuthenticated) || efms == null)
{
Log.Warning("CreateADUser: can't run IsAuth: {IsAuth}, MemServ {MemServ}",
Request.IsAuthenticated,
MembershipService.GetType());
return(RedirectToAction("Unauthorized", "Home"));
}
var credentials = User.Username();
var adUser = ADHelper.GetUserPrincipal(credentials);
if (adUser != null)
{
var userId = adUser.Guid.GetValueOrDefault(Guid.NewGuid());
if (string.IsNullOrEmpty(adUser.EmailAddress))
{
var username = credentials.Split('\\')[1];
adUser.EmailAddress = $"{username}@{AuthenticationSettings.EmailDomain}";
}
if (MembershipService.CreateUser(credentials, Guid.NewGuid().ToString(), adUser.GivenName, adUser.Surname, adUser.EmailAddress, userId))
{
// 2 because we just added the user and there is the default admin user.
if (AuthenticationSettings.ImportWindowsAuthUsersAsAdmin || efms.UserCount() == 2)
{
Log.Information("Making AD user {User} into an admin", credentials);
var id = MembershipService.GetUserModel(credentials).Id;
RoleProvider.AddUserToRoles(id, new[] { Definitions.Roles.Administrator });
// Add the administrator role to the Identity/cookie
var Identity = (ClaimsIdentity)User.Identity;
Identity.AddClaim(new Claim(ClaimTypes.Role, Definitions.Roles.Administrator));
var AuthenticationManager = HttpContext.GetOwinContext().Authentication;
AuthenticationManager.AuthenticationResponseGrant = new AuthenticationResponseGrant(new ClaimsPrincipal(Identity), new AuthenticationProperties {
IsPersistent = true
});
}
return(RedirectToAction("Index", "Repository"));
}
else
{
ModelState.AddModelError("Username", Resources.Account_Create_AccountAlreadyExists);
return(RedirectToAction("Index"));
}
}
else
{
return(RedirectToAction("Unauthorized", "Home"));
}
}
public bool IsRepositoryAdministrator(Guid userId, Guid repositoryId)
{
bool result = false;
result |= Repository.GetRepository(repositoryId).Administrators.Any(x => x.Id == userId);
result |= RoleProvider.GetRolesForUser(userId).Contains(Definitions.Roles.Administrator);
return(result);
}
public bool IsRepositoryAdministrator(string username, string repositoryName)
{
bool result = false;
result |= Repository.GetRepository(repositoryName).Administrators.Contains(username, StringComparer.OrdinalIgnoreCase);
result |= RoleProvider.GetRolesForUser(username).Contains(Definitions.Roles.Administrator);
return(result);
}
private static SimpleRoleProvider CreateDefaultSimpleRoleProvider(string name, RoleProvider currentDefault)
{
RoleProvider previousProvider = currentDefault;
SimpleRoleProvider provider = new SimpleRoleProvider(previousProvider);
NameValueCollection config = new NameValueCollection();
provider.Initialize(name, config);
return(provider);
}
public ActionResult Edit(UserEditModel model)
{
if (User.Id() != model.Id && !User.IsInRole(Definitions.Roles.Administrator))
{
return(RedirectToAction("Unauthorized", "Home"));
}
if (AuthenticationSettings.DemoModeActive && User.IsInRole(Definitions.Roles.Administrator) && User.Id() == model.Id)
{
// Don't allow the admin user to be changed in demo mode
return(RedirectToAction("Unauthorized", "Home"));
}
if (ModelState.IsValid)
{
bool valid = true;
if (!User.IsInRole(Definitions.Roles.Administrator) && (model.OldPassword == null && model.NewPassword != null))
{
ModelState.AddModelError("OldPassword", Resources.Account_Edit_OldPasswordEmpty);
valid = false;
}
if (model.OldPassword != null && MembershipService.ValidateUser(model.Username, model.OldPassword) != ValidationResult.Success)
{
ModelState.AddModelError("OldPassword", Resources.Account_Edit_OldPasswordIncorrect);
valid = false;
}
if (User.IsInRole(Definitions.Roles.Administrator) && model.Id == User.Id() && !(model.PostedSelectedRoles != null && model.PostedSelectedRoles.Contains(Definitions.Roles.Administrator)))
{
ModelState.AddModelError("Roles", Resources.Account_Edit_CannotRemoveYourselfFromAdminRole);
valid = false;
}
if (valid)
{
MembershipService.UpdateUser(model.Id, model.Username, model.Name, model.Surname, model.Email, model.NewPassword);
// Only Administrators can make any changes to roles
if (User.IsInRole(Definitions.Roles.Administrator))
{
RoleProvider.RemoveUserFromRoles(model.Id, RoleProvider.GetAllRoles());
if (model.PostedSelectedRoles != null)
{
RoleProvider.AddUserToRoles(model.Id, model.PostedSelectedRoles);
}
}
ViewBag.UpdateSuccess = true;
}
}
model.Roles = RoleProvider.GetAllRoles();
model.SelectedRoles = model.PostedSelectedRoles;
return(View(model));
}
public void Can_Get_All_Roles()
{
RoleProvider.CreateRole("admin");
RoleProvider.CreateRole("engineering");
RoleProvider.CreateRole("sales");
var result = RoleProvider.GetAllRoles();
Assert.Equal(3, result.Length);
}
private void Atv_DataBind(Guid groupId, Guid instanceId)
{
Guid roleId = GroupProvider.GetGroupInstanceRole(UserContext.Current.OrganizationId, groupId, instanceId);
m_ActionIdList = GroupProvider.GetActionIdList(groupId, instanceId, roleId);
m_StartActionId = RoleProvider.GetStartActionId(roleId);
Atv.DataSource = ActionProvider.GetActionsTree();
Atv.DataBind();
}
public bool IsInRole(string role)
{
RoleProvider roleProvider = (this.roleProvider as RoleProvider) ?? SystemWebHelper.GetDefaultRoleProvider();
if (roleProvider != null)
{
return(roleProvider.IsUserInRole(this.securityContext.PrimaryIdentity.Name, role));
}
return(false);
}
public void CopyTo(RoleProvider[] array, int index)
{
}
private IRoleProvider GetRoleProvider()
{
// 实例化服务容器
Zongsoft.Services.IServiceProvider serviceProvider = new Zongsoft.Services.ServiceProvider();
// 注册 DataAccess 实例
serviceProvider.Register(new DataAccess(DataProviderFactory.GetProvider()), typeof(IDataAccess));
// 返回用户提供程序
var provider = new RoleProvider(serviceProvider);
provider.Censorship = this.GetCensorship();
return provider;
}
