/// <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; }