/// <exclude />
public override IEnumerable <XElement> Install()
{
foreach (string usergroupName in _names)
{
IUserGroup userGroup = DataFacade.GetData <IUserGroup>().SingleOrDefault(f => f.Name == usergroupName);
if (userGroup == null)
{
continue;
}
IEnumerable <IUser> users = DataFacade.GetData <IUser>().Evaluate();
foreach (IUser user in users)
{
var userUserGroupRelation = DataFacade.BuildNew <IUserUserGroupRelation>();
userUserGroupRelation.UserId = user.Id;
userUserGroupRelation.UserGroupId = userGroup.Id;
DataFacade.AddNew <IUserUserGroupRelation>(userUserGroupRelation);
}
foreach (var cultureInfo in DataLocalizationFacade.ActiveLocalizationCultures)
{
var userGroupActiveLocale = DataFacade.BuildNew <IUserGroupActiveLocale>();
userGroupActiveLocale.UserGroupId = userGroup.Id;
userGroupActiveLocale.CultureName = cultureInfo.Name;
DataFacade.AddNew <IUserGroupActiveLocale>(userGroupActiveLocale);
}
}
yield break;
}
public IUserGroup RegisterGroup(IUserGroup group, string password)
{
IRegistrantGroup registrantGroup = this.CreateGroup(group, password);
registrantGroup.Register();
return(group);
}
public IUserGroup ChangeGroupPassword(IUserGroup group, string password, string newPassword)
{
IRegistrantGroup registrantGroup = this.CreateGroup(group, password);
registrantGroup.ChangePassword(newPassword);
return(registrantGroup);
}
public ProtectedTrueFalseApiController(UmbracoContext umbracoContext, IUserService userService)
{
_umbracoContext = umbracoContext;
_userService = userService;
_administratorUserGroup = _userService.GetUserGroupByAlias(ConfigurationManager.AppSettings["AdminUserGroupAlias"]);
}
public void Can_Perform_Update_On_UserGroupRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
repository.Save(userGroup);
// Act
IUserGroup resolved = repository.Get((int)userGroup.Id);
resolved.Name = "New Name";
resolved.Permissions = new[] { "Z", "Y", "X" };
repository.Save(resolved);
scope.Complete();
IUserGroup updatedItem = repository.Get((int)userGroup.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
Assert.That(updatedItem.Permissions, Is.EqualTo(resolved.Permissions));
}
}
public void ThenTheUserGroupHasRoles()
{
IEnumerable <IUserGroup> userGroups = ScenarioContext.Current.Get <IEnumerable <IUserGroup> >();
IUserGroup userGroup = userGroups.First();
Assert.That(userGroup.Roles, Is.Not.Empty);
}
public static UserGroupDto BuildDto(IUserGroup entity)
{
var dto = new UserGroupDto
{
Alias = entity.Alias,
DefaultPermissions = entity.Permissions == null ? string.Empty : string.Join(string.Empty, entity.Permissions),
Name = entity.Name,
UserGroup2AppDtos = new List <UserGroup2AppDto>(),
CreateDate = entity.CreateDate,
UpdateDate = entity.UpdateDate,
Icon = entity.Icon,
StartMediaId = entity.StartMediaId,
StartContentId = entity.StartContentId,
};
foreach (var app in entity.AllowedSections)
{
var appDto = new UserGroup2AppDto {
AppAlias = app
};
if (entity.HasIdentity)
{
appDto.UserGroupId = entity.Id;
}
dto.UserGroup2AppDtos.Add(appDto);
}
if (entity.HasIdentity)
{
dto.Id = short.Parse(entity.Id.ToString());
}
return(dto);
}
public void Can_Remove_Section_From_All_Assigned_UserGroups()
{
var userGroup1 = new UserGroup(ShortStringHelper)
{
Alias = "Group1",
Name = "Group 1"
};
var userGroup2 = new UserGroup(ShortStringHelper)
{
Alias = "Group2",
Name = "Group 2"
};
UserService.Save(userGroup1);
UserService.Save(userGroup2);
// adds some allowed sections
userGroup1.AddAllowedSection("test");
userGroup2.AddAllowedSection("test");
UserService.Save(userGroup1);
UserService.Save(userGroup2);
// now clear the section from all users
UserService.DeleteSectionFromAllUserGroups("test");
// Assert
IUserGroup result1 = UserService.GetUserGroupById(userGroup1.Id);
IUserGroup result2 = UserService.GetUserGroupById(userGroup2.Id);
Assert.IsFalse(result1.AllowedSections.Contains("test"));
Assert.IsFalse(result2.AllowedSections.Contains("test"));
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='id'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> GetByIdAsync(this IUserGroup operations, int id, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.GetByIdWithHttpMessagesAsync(id, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='userGroupModel'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <object> AddAsync(this IUserGroup operations, GroupModel userGroupModel, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.AddWithHttpMessagesAsync(userGroupModel, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public override void Add(Contact contact, IUserGroup userGroup)
{
Assert.ArgumentNotNull(contact, nameof(contact));
Assert.ArgumentNotNull(userGroup, nameof(userGroup));
var listId = userGroup.GetAssociatedListRequired();
var candidate = listId.ToString();
if (TryGetListIds(contact, out var lists))
{
if (lists.Contains(candidate, StringComparer.OrdinalIgnoreCase))
{
return; // Already enrolled.
}
lists.Add(candidate);
Update(contact, lists.ToString());
}
else
{
Update(contact, candidate);
}
_listEnrollment.Subscribe(listId, contact.ContactId);
}
public void Can_Update_Section_For_Group()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
IUserGroup[] groups = CreateAndCommitMultipleUserGroups(repository);
// Act
groups[0].RemoveAllowedSection("content");
groups[0].AddAllowedSection("settings");
repository.Save(groups[0]);
scope.Complete();
// Assert
IUserGroup result = repository.Get(groups[0].Id);
Assert.AreEqual(2, result.AllowedSections.Count());
Assert.IsTrue(result.AllowedSections.Contains("settings"));
Assert.IsTrue(result.AllowedSections.Contains("media"));
}
}
protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext context)
{
//Check to see if appSetting AnalyticsStartupInstalled is true or even present
string installAppSetting = WebConfigurationManager.AppSettings[AppSettingKey];
if (string.IsNullOrEmpty(installAppSetting) || installAppSetting != true.ToString())
{
var install = new Helpers.Installer();
//Check to see if section needs to be added
install.AddSection(context);
//Add Section Dashboard XML
install.AddSectionDashboard();
//Add Content dashboard XML
install.AddContentSectionDashboard();
// Grant the admin group access to the worfklow section
//since the app is starting, we don't have a current user. Safest assumption is the installer was an admin
IUserGroup adminGroup = context.Services.UserService.GetUserGroupByAlias("admin");
adminGroup.AddAllowedSection("workflow");
context.Services.UserService.Save(adminGroup, null, false);
//All done installing our custom stuff
//As we only want this to run once - not every startup of Umbraco
Configuration webConfig = WebConfigurationManager.OpenWebConfiguration("/");
webConfig.AppSettings.Settings.Add(AppSettingKey, true.ToString());
webConfig.Save();
}
//Add OLD Style Package Event
InstalledPackage.BeforeDelete += InstalledPackage_BeforeDelete;
}
public void WhenIAddTheUserToTheGroup()
{
IUser user = GetSavedUser();
IUserGroup userGroup = GetSavedUserGroup();
user.JoinGroup(userGroup.Name);
}
public static void UpdateCruds(IUserGroup userGroup, CMSNode node, string permissions)
{
ApplicationContext.Current.Services.UserService.ReplaceUserGroupPermissions(
userGroup.Id,
permissions.ToCharArray(),
node.Id);
}
private bool ValidateUserPreservesAdminRights(IUserGroup userGroup, List <string> newUserGroupEntityTokens)
{
string systemPerspectiveEntityToken = EntityTokenSerializer.Serialize(AttachingPoint.SystemPerspective.EntityToken);
Guid groupId = userGroup.Id;
string userName = UserSettings.Username;
var userGroupIds = UserGroupFacade.GetUserGroupIds(userName);
HashSet <Guid> groupsWithAccessToSystemPerspective = new HashSet <Guid>(GetGroupsThatHasAccessToPerspective(systemPerspectiveEntityToken));
if (groupsWithAccessToSystemPerspective.Contains(groupId) &&
!newUserGroupEntityTokens.Contains(systemPerspectiveEntityToken) &&
!UserPerspectiveFacade.GetSerializedEntityTokens(userName).Contains(systemPerspectiveEntityToken) &&
!userGroupIds.Any(anotherGroupId => anotherGroupId != groupId && groupsWithAccessToSystemPerspective.Contains(anotherGroupId)))
{
this.ShowMessage(DialogType.Message,
SR.GetString("Composite.Management", "EditUserWorkflow.EditErrorTitle"),
SR.GetString("Composite.Management", "EditUserWorkflow.EditOwnAccessToSystemPerspective"));
return(false);
}
return(true);
}
/// <summary>
/// The add section to user group.
/// </summary>
/// <param name="formulateSection">
/// The formulate section.
/// </param>
/// <param name="userGroup">
/// The user group.
/// </param>
private void AddSectionToUserGroup(ISection formulateSection, IUserGroup userGroup)
{
if (userGroup == null)
{
Logger.Warn <HandleInstallAndUpgradeComponent>(
$"Skipping permit access. No user group was found.");
return;
}
if (userGroup.AllowedSections.Contains(formulateSection.Alias))
{
Logger.Info <HandleInstallAndUpgradeComponent>(
$"Skipping permit access. {formulateSection.Name} Section already exists on User Group, {userGroup.Name}.");
return;
}
try
{
userGroup.AddAllowedSection(formulateSection.Alias);
UserService.Save(userGroup);
Logger.Info <HandleInstallAndUpgradeComponent>(
$"Successfully added {formulateSection.Name} Section to User Group, {userGroup.Name}.");
}
catch (Exception ex)
{
Logger.Error <HandleInstallAndUpgradeComponent>(ex, $"Error adding {formulateSection.Name} Section to User Group, {userGroup.Name}.");
}
}
private void step1CodeActivity_ShowDocument_ExecuteCode(object sender, EventArgs e)
{
IFormMarkupProvider markupProvider = new FormDefinitionFileMarkupProvider(@"\Administrative\UserGroupElementProviderEditUserGroupStep1.xml");
XDocument formDocument;
using (var reader = markupProvider.GetReader())
{
formDocument = XDocument.Load(reader);
}
XElement bindingsElement = formDocument.Root.Element(DataTypeDescriptorFormsHelper.CmsNamespace + FormKeyTagNames.Bindings);
XElement layoutElement = formDocument.Root.Element(DataTypeDescriptorFormsHelper.CmsNamespace + FormKeyTagNames.Layout);
XElement placeHolderElement = layoutElement.Element(DataTypeDescriptorFormsHelper.MainNamespace + "PlaceHolder");
IUserGroup userGroup = this.GetBinding <IUserGroup>("UserGroup");
UpdateFormDefinitionWithActivePerspectives(userGroup, bindingsElement, placeHolderElement);
UpdateFormDefinitionWithGlobalPermissions(userGroup, bindingsElement, placeHolderElement);
var clientValidationRules = new Dictionary <string, List <ClientValidationRule> >();
clientValidationRules.Add("Name", ClientValidationRuleFacade.GetClientValidationRules(userGroup, "Name"));
string formDefinition = formDocument.GetDocumentAsString();
this.DeliverFormData(
userGroup.Name,
StandardUiContainerTypes.Document,
formDefinition,
this.Bindings,
clientValidationRules
);
}
public void Can_Perform_Delete_On_UserGroupRepository()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
// Act
repository.Save(userGroup);
int id = userGroup.Id;
var repository2 = new UserGroupRepository((IScopeAccessor)provider, global::Umbraco.Cms.Core.Cache.AppCaches.Disabled, LoggerFactory.CreateLogger <UserGroupRepository>(), LoggerFactory, ShortStringHelper);
repository2.Delete(userGroup);
scope.Complete();
IUserGroup resolved = repository2.Get((int)id);
// Assert
Assert.That(resolved, Is.Null);
}
}
public void Can_Perform_Get_On_UserGroupRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
UserGroupRepository repository = CreateRepository(provider);
UserGroup userGroup = UserGroupBuilder.CreateUserGroup();
repository.Save(userGroup);
scope.Complete();
// Act
IUserGroup resolved = repository.Get((int)userGroup.Id);
// Assert
Assert.That(resolved.Id, Is.EqualTo(userGroup.Id));
//// Assert.That(resolved.CreateDate, Is.GreaterThan(DateTime.MinValue));
//// Assert.That(resolved.UpdateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(resolved.Name, Is.EqualTo(userGroup.Name));
Assert.That(resolved.Alias, Is.EqualTo(userGroup.Alias));
Assert.That(resolved.Permissions, Is.EqualTo(userGroup.Permissions));
}
}
/// <summary>
/// 根据id删除用户用户组信息
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public static bool DeleteUserGroupInfo(Guid id)
{
bool ret = false;
IDbConnection conn = null;
IDbCommand cmd = null;
IDbTransaction trans = null;
try
{
IUserGroup dp = DataProvider.DbUserGroupDP;
conn = DbConnOperation.CreateMySqlConnection();
cmd = conn.CreateCommand();
conn.Open();
trans = conn.BeginTransaction();
cmd.Transaction = trans;
ret = dp.DeleteUserGroupInfo(cmd, id);
trans.Commit();
}
catch (Exception ex)
{
if (trans != null)
{
trans.Rollback();
}
log.Error(string.Format("DeleteUserGroupInfo()出错,错误信息如下:{0}", ex.Message));
}
finally
{
if (conn != null)
{
conn.Close();
}
}
return(ret);
}
/// <summary>
/// 根据uid获取用户组权限信息
/// </summary>
/// <param name="uid"></param>
/// <returns></returns>
public static List <UserGroup> GetUserGroupByUid(Guid uid)
{
List <UserGroup> list = new List <UserGroup>();
IDbConnection conn = null;
IDbCommand cmd = null;
IDbTransaction trans = null;
try
{
IUserGroup dp = DataProvider.DbUserGroupDP;
conn = DbConnOperation.CreateMySqlConnection();
cmd = conn.CreateCommand();
conn.Open();
trans = conn.BeginTransaction();
cmd.Transaction = trans;
list = dp.GetUserGroupByUid(cmd, uid);
trans.Commit();
}
catch (Exception ex)
{
if (trans != null)
{
trans.Rollback();
}
log.Error(string.Format("GetUserGroupByUid()出错,错误信息如下:{0}", ex.Message));
}
finally
{
if (conn != null)
{
conn.Close();
}
}
return(list);
}
public void Can_Serialize_Without_Error()
{
IUserGroup item = Build();
var json = JsonConvert.SerializeObject(item);
Debug.Print(json);
}
public Authorization GetAuthorization(IUserGroup group, ISecurableAction action)
{
var viewAlbumItem = action as ViewAction<AlbumItem>;
if (viewAlbumItem == null || !viewAlbumItem.Target.IsProposedToBeDeleted || !(group is IUser))
return Authorization.Unknown;
return viewAlbumItem.Target.ProposedToBeDeletedBy == group ? Authorization.Unknown : Authorization.Denied;
}
private void HasUsers(object sender, ConditionalEventArgs e)
{
DataEntityToken dataEntityToken = (DataEntityToken)this.EntityToken;
IUserGroup userGroup = (IUserGroup)dataEntityToken.Data;
e.Result = DataFacade.GetData <IUserUserGroupRelation>(f => f.UserGroupId == userGroup.Id).Any();
}
private void ValidateData(object sender, ConditionalEventArgs e)
{
IUserGroup userGroup = this.GetBinding <IUserGroup>("NewUserGroup");
ValidationResults validationResults = ValidationFacade.Validate <IUserGroup>(userGroup);
e.Result = validationResults.IsValid;
}
private void initializeCodeActivity_Initialize_ExecuteCode(object sender, EventArgs e)
{
IUserGroup userGroup = DataFacade.BuildNew <IUserGroup>();
userGroup.Id = Guid.NewGuid();
this.Bindings.Add("NewUserGroup", userGroup);
}
public void AddGroupWithEmail(IUserGroup userGroup, string email)
{
var filter = Builders <Models.User.SpotUser> .Filter.Where(u => u.Email == email);
var update = Builders <Models.User.SpotUser> .Update.Push(SpotUserCollections.MyGroups, userGroup);
MongoContext.Collection.UpdateOne(filter, update);
}
public void ThenTheRoleIsAssignedToTheGroup()
{
IUserGroup userGroup = GetSavedUserGroup();
IEnumerable <IUserRole> userRoles = userGroup.Roles;
Assert.That(userRoles.Select(ur => ur.Name), Contains.Item("Developer"));
}
// mappers
private static void Map(UserGroupSave source, IUserGroup target, MapperContext context)
{
if (!(target is UserGroup ttarget))
{
throw new NotSupportedException($"{nameof(target)} must be a UserGroup.");
}
Map(source, ttarget);
}
public IDictionary <string, IEnumerable <Permission> > Resolve(IUserGroup source)
{
return(_actions
.Where(x => x.CanBePermissionAssigned)
.Select(x => GetPermission(x, source))
.GroupBy(x => x.Category)
.ToDictionary(x => x.Key, x => (IEnumerable <Permission>)x.ToArray()));
}
protected Profile(IDbPersonRepository dbPersonRepository,
IUserGroup userGroup, ILangSetter langSetter,
IGridViewProfileManager<HttpSessionState> gridViewProfileManager, IImageService imageService)
{
_dbPersonRepository = dbPersonRepository;
_userGroup = userGroup;
_langSetter = langSetter;
_gridViewProfileManager = gridViewProfileManager;
_imageService = imageService;
}
protected ProductCatalog(IDbProductRepository dbProductRepository, IOrderRepository<HttpSessionState> orderRepository,
IUserGroup userGroup, ILangSetter langSetter, IGridViewProductCatalogManager<HttpSessionState> gridViewProductCatalogManager,
ICurrencyCultureService<HttpCookieCollection> currencyCultureService)
{
_dbProductRepository = dbProductRepository;
_orderRepository = orderRepository;
_userGroup = userGroup;
_langSetter = langSetter;
_gridViewProductCatalogManager = gridViewProductCatalogManager;
_currencyCultureService = currencyCultureService;
}
protected Basket(IDbOrderHistoryRepository dbOrderHistoryRepository, IMailSender mailSender,
IUserGroup userGroup, ILangSetter langSetter, ICurrencyCultureService<HttpCookieCollection> currencyCultureService,
IGridViewBasketManager<HttpSessionState> gridViewBasketManager)
{
_dbOrderHistoryRepository = dbOrderHistoryRepository;
_mailSender = mailSender;
_userGroup = userGroup;
_langSetter = langSetter;
_currencyCultureService = currencyCultureService;
_gridViewBasketManager = gridViewBasketManager;
}
protected ProductManagement(IDbProductRepository dbProductRepository, ICurrencyConverter currencyConverter,
IUserGroup userGroup, ILangSetter langSetter, ICurrencyCultureService<HttpCookieCollection> currencyCultureService,
IGridViewProductManagementManager<HttpSessionState> gridViewProductManagementManager)
{
_dbProductRepository = dbProductRepository;
_currencyConverter = currencyConverter;
_userGroup = userGroup;
_langSetter = langSetter;
_currencyCultureService = currencyCultureService;
_gridViewProductManagementManager = gridViewProductManagementManager;
}
public string GetReference(IUserGroup userGroup)
{
var concreteUserGroup = userGroup as UserGroup;
if (concreteUserGroup != null)
return userGroup.Name;
var user = userGroup as KnownUser;
if (user != null) {
using (var md5 = MD5.Create()) {
return "u:" + md5.ComputeHashAsString(Encoding.UTF8.GetBytes(user.Email));
}
}
throw new NotSupportedException();
}
public UserGroupViewModel(IUserGroup userGroup)
{
var user = userGroup as KnownUser;
if (user != null) {
this.Key = "user:"******"group");
this.Key = "group:" + concreteGroup.Name;
}
this.UserGroup = userGroup;
this.Users = userGroup.GetUsers().OfType<KnownUser>().ToList().AsReadOnly();
}
/// <summary>
/// 创建子用户组
/// </summary>
/// <param name="parentGroup"></param>
/// <param name="childGroup"></param>
/// <returns></returns>
public bool CreateChildGroup(IUserGroup parentGroup, IUserGroup childGroup)
{
UserGroup child = childGroup as UserGroup;
UserGroup parent = parentGroup as UserGroup;
if (child != null && parent != null)
{
child.ParentId = parent.GroupId;
child.GroupLevel = (short)(parent.GroupLevel + (short)1);
child.CreateBy = SecuritySession.CurrentUser.UserId;
child.CreateTime = DateTime.Now;
child.ModifyBy = child.CreateBy;
child.ModifyTime = child.CreateTime;
child.GroupType = parent.GroupType;
return child.Create(this._session);
}
return false;
}
public bool CreateUserGroup(IUserGroup userGroup)
{
if (userGroup != null)
{
return EntityManager.Create(_session, userGroup);
}
return false;
}
private void UpdateFormDefinitionWithGlobalPermissions(IUserGroup userGroup, XElement bindingsElement, XElement placeHolderElement)
{
var helper = new GlobalPermissionsFormsHelper(
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.GlobalPermissionsFieldLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.GlobalPermissionsMultiSelectLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.GlobalPermissionsMultiSelectHelp")
);
bindingsElement.Add(helper.GetBindingsMarkup());
placeHolderElement.Add(helper.GetFormMarkup());
EntityToken rootEntityToken = ElementFacade.GetRootsWithNoSecurity().Select(f => f.ElementHandle.EntityToken).Single();
IEnumerable<PermissionType> permissionTypes = PermissionTypeFacade.GetLocallyDefinedUserGroupPermissionTypes(userGroup.Id, rootEntityToken).ToList();
helper.UpdateWithNewBindings(this.Bindings, permissionTypes);
}
public Authorization GetAuthorization(IUserGroup group, ISecurableAction action)
{
return group.Name == Owners ? Authorization.UndeniablyAllowed : Authorization.Unknown;
}
public void Add(IUserGroup someGroup)
{
_groups.Add(someGroup.Name, someGroup);
}
private void UpdateFormDefinitionWithActivePerspectives(IUserGroup userGroup, XElement bindingsElement, XElement placeHolderElement)
{
List<string> serializedEntityToken = UserGroupPerspectiveFacade.GetSerializedEntityTokens(userGroup.Id).ToList();
var helper = new ActivePerspectiveFormsHelper(
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.ActivePerspectiveFieldLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.ActivePerspectiveMultiSelectLabel"),
SR.GetString("Composite.Plugins.UserGroupElementProvider", "EditUserGroup.EditUserGroupStep1.ActivePerspectiveMultiSelectHelp")
);
bindingsElement.Add(helper.GetBindingsMarkup());
placeHolderElement.Add(helper.GetFormMarkup());
helper.UpdateWithNewBindings(this.Bindings, serializedEntityToken);
}
/// <summary>
/// 获取当前用户在指定用户组上的所有祖先用户组
/// </summary>
/// <param name="user"></param>
/// <param name="group"></param>
/// <returns></returns>
public IList<IUserGroup> GetAncestryAssociation(UserBase user, IUserGroup group)
{
return null;
}
/// <summary>
/// This method is invoked after a UserGroup was deleted
/// </summary>
/// <param name="userGroup">The UserGroup that was delete</param>
/// <param name="session">The session that must be used to perform tasks on additional objects</param>
/// <remarks>When this action is invoked, none of the object involved were saved to Content Store yet.</remarks>
public void OnAfterUserGroupDelete(IUserGroup userGroup, IUserWriteSession session)
{
}
bool IAuthorizationRepository.DeleteUserGroup(IUserGroup userGroup, bool throwOnPopulatedGroup)
{
return DeleteUserGroup((UserGroup)userGroup, throwOnPopulatedGroup);
}
bool IAuthorizationRepository.AddUsersToGroups(UserBase[] users, IUserGroup[] userGroups)
{
if (ArrayIsNullOrEmpty(users) || ArrayIsNullOrEmpty(userGroups))
{
throw new ArgumentNullException("users,groups", "Users or UserGroups can not be null or empty!");
}
bool flag = false;
foreach (UserGroup grp in userGroups)
{
flag = this.AddUsersToGroup(users, grp);
}
return flag;
}
public AnonymousMember(IUserGroup userGroup)
{
this.userGroup = userGroup;
}
private void DeleteUserGroup(IUserGroup userGroup)
{
DeleteUserGroup(userGroup.Name);
}
private Authorization GetAuthorization(IUserGroup @group, ISecurableAction action, HashSet<IUserGroup> authorizedByProviders)
{
var authorization = GetAuthorizationAccordingToRules(group, action);
if (authorization == Authorization.Unknown && authorizedByProviders.Contains(@group))
authorization = Authorization.Allowed;
return authorization;
}
/// <summary>
/// 判断用户是否在用户组
/// </summary>
/// <param name="user"></param>
/// <param name="group"></param>
/// <returns></returns>
public bool IsUserInGroup(UserBase user, IUserGroup group)
{
if (group == null)
throw new ArgumentNullException("group");
if (user == null)
throw new ArgumentNullException("user");
return IsUserInGroup(user.UserId, ((UserGroup)group).GroupId);
}
void IAuthorizationRepository.RemoveUsersFromGroups(UserBase[] users, IUserGroup[] userGroups)
{
if (ArrayIsNullOrEmpty(users) || ArrayIsNullOrEmpty(userGroups))
{
throw new ArgumentNullException("users,groups", "Users or UserGroups can not be null or empty!");
}
foreach (IUserGroup grp in userGroups)
{
if (!grp.RemoveUserFromGroup(users, this._session))
{
throw new ApplicationException(string.Format("从用户组{0}中移出用户失败！", grp.Name));
}
}
}
private bool ValidateUserPreservsAdminRights(IUserGroup userGroup, List<string> newUserGroupEntityTokens)
{
string systemPerspectiveEntityToken = EntityTokenSerializer.Serialize(AttachingPoint.SystemPerspective.EntityToken);
Guid groupId = userGroup.Id;
string userName = UserSettings.Username;
List<Guid> userGroupIds = UserGroupFacade.GetUserGroupIds(userName);
HashSet<Guid> groupsWithAccessToSystemPerspective = new HashSet<Guid>(GetGroupsThatHasAccessToPerspective(systemPerspectiveEntityToken));
if (groupsWithAccessToSystemPerspective.Contains(groupId)
&& !newUserGroupEntityTokens.Contains(systemPerspectiveEntityToken)
&& !UserPerspectiveFacade.GetSerializedEntityTokens(userName).Contains(systemPerspectiveEntityToken)
&& !userGroupIds.Any(anotherGroupId => anotherGroupId != groupId && groupsWithAccessToSystemPerspective.Contains(anotherGroupId)))
{
this.ShowMessage(DialogType.Message,
SR.GetString("Composite.Management", "EditUserWorkflow.EditErrorTitle"),
SR.GetString("Composite.Management", "EditUserWorkflow.EditOwnAccessToSystemPerspective"));
return false;
}
return true;
}
/// <summary>
/// This method is invoked after a UserGroup was created
/// </summary>
/// <param name="userGroup">The new UserGroup that was created</param>
/// <param name="session">The session that must be used to perform tasks on additional objects</param>
/// <remarks>When this action is invoked, none of the object involved were saved to Content Store yet.</remarks>
public void OnUserGroupCreated(IUserGroup userGroup, IUserWriteSession session)
{
}
/// <summary>
/// This method is invoked before a UserGroup is deleted
/// </summary>
/// <param name="userGroup">The UserGroup to delete</param>
/// <param name="session">The session that must be used to perform tasks on additional objects</param>
/// <remarks>When this action is invoked, none of the object involved were saved to Content Store yet.</remarks>
public void OnBeforeUserGroupDelete(IUserGroup userGroup, IUserWriteSession session)
{
}
/// <summary>
/// 查找Group中的所有用户
/// </summary>
/// <param name="group"></param>
/// <param name="usernameToMathc"></param>
/// <returns></returns>
public IList<UserBase> FindUsersInGroup(IUserGroup group, string usernameToMathc)
{
if (group == null)
throw new ArgumentNullException("group");
// string sql = @"select * from sys_user u inner join sys_user_to_group ug on u.user_id=ug.user_id where group_id=@Group_ID";
string oql = @"select u.* from User u inner join UserToGroup g on u.UserId=g.UserId";
UserGroup urgrp = (UserGroup)group;
return _session.CreateObjectQuery(oql)
.Attach(typeof(User))
.Attach(typeof(UserToGroup))
.Attach(typeof(UserBase))
.And(Exp.Eq("g.GroupId",urgrp.GroupId))
.List<UserBase>();
}
public NewUser(IUserGroup userGroup)
{
_userGroup = userGroup;
}
private Authorization GetAuthorizationAccordingToRules(IUserGroup @group, ISecurableAction action)
{
var authorization = Authorization.Unknown;
foreach (var rule in this.rules) {
var result = rule.GetAuthorization(@group, action);
if (result == Authorization.Unknown)
continue;
if (result == Authorization.UndeniablyAllowed)
return result;
if (result == Authorization.Allowed && authorization == Authorization.Unknown)
authorization = result;
if (result == Authorization.Denied)
authorization = result;
}
return authorization;
}
/// <summary>
/// 创建子用户组
/// </summary>
/// <param name="parentGroupName"></param>
/// <param name="childGroup"></param>
/// <returns></returns>
public bool CreateChildGroup(string parentGroupName, IUserGroup childGroup)
{
UserGroup parent = FindGroupByName(parentGroupName) as UserGroup;
return CreateChildGroup(parent, childGroup);
}
public Authorization GetAuthorization(IUserGroup group, ISecurableAction action)
{
return action is ViewAction<AlbumItem> ? Authorization.Allowed : Authorization.Unknown;
}
