protected override void CreateEnvironments() { base.CreateEnvironments(); var arr = startPos.GetChildList(); _slots = new RoleEntry[arr?.Count ?? 0]; for (var i = 0; i < arr?.Count; i++) { _slots[i] = new RoleEntry { root = arr[i], index = i } } ; var go = mainCamera.transform.Find("bg"); if (go) { var r = go.GetComponent <MeshRenderer>(); if (r) { r.material.renderQueue = MaskRenderQueue + 1; } } }
private RoleUpgrader.EntryComparisonState AnalyzeEntries(RoleEntry curOld, RoleEntry curNew) { RoleUpgrader.EntryComparisonState entryComparisonState = RoleUpgrader.EntryComparisonState.NoEntriesFound; if (curOld != null) { entryComparisonState |= RoleUpgrader.EntryComparisonState.OnlyExistsInOld; } if (curNew != null) { entryComparisonState |= RoleUpgrader.EntryComparisonState.OnlyExistsInNew; } if (entryComparisonState == RoleUpgrader.EntryComparisonState.ExistsInBoth) { int num = RoleEntry.NameComparer.Compare(curOld, curNew); if (num < 0) { entryComparisonState = RoleUpgrader.EntryComparisonState.OnlyExistsInOld; } else if (num > 0) { entryComparisonState = RoleUpgrader.EntryComparisonState.OnlyExistsInNew; } } return(entryComparisonState); }
public static void InitSuperAdmin(ShuNiuContext context) { try { var rl = context.Roles.ToList(); var rol = rl.Where(a => a.Name.Equals("SuperAdmin")).FirstOrDefault(); if (rol == null) { string roleId = Guid.NewGuid().ToString(); AccountEntry account = new AccountEntry() { Id = Guid.NewGuid().ToString(), RoleId = roleId, Name = "EricYang", ChineseName = "杨明", PassWord = "******", }; context.Accounts.Add(account); RoleEntry role = new RoleEntry() { Id = roleId, Name = "SuperAdmin", }; context.Roles.Add(role); context.SaveChanges(); } } catch (Exception ex) { } }
private static ValidationRule Create(ValidationRuleDefinition definition, RoleEntry roleEntry) { ExTraceGlobals.PublicCreationAPITracer.TraceDebug <string, string>((long)definition.GetHashCode(), "Entering ValidationRuleFactory.GetValidationRule({0}) - Creating ValidationRule. Name: '{1}'", (null == roleEntry) ? "<NULL>" : roleEntry.ToString(), definition.Name); OrganizationValidationRuleDefinition organizationValidationRuleDefinition = definition as OrganizationValidationRuleDefinition; if (organizationValidationRuleDefinition != null) { return(new OrganizationValidationRule(organizationValidationRuleDefinition, roleEntry)); } IEnumerable <Capability> restrictedCapabilities = definition.RestrictedCapabilities; List <CapabilityIdentifierEvaluator> list = new List <CapabilityIdentifierEvaluator>(); foreach (Capability capability in restrictedCapabilities) { list.Add(CapabilityIdentifierEvaluatorFactory.Create(capability)); } IEnumerable <Capability> overridingAllowCapabilities = definition.OverridingAllowCapabilities; List <CapabilityIdentifierEvaluator> list2 = new List <CapabilityIdentifierEvaluator>(); foreach (Capability capability2 in overridingAllowCapabilities) { list2.Add(CapabilityIdentifierEvaluatorFactory.Create(capability2)); } if (definition.Expressions == null) { return(new RestrictedValidationRule(definition, list, list2, roleEntry)); } return(new ExpressionFilterValidationRule(definition, list, list2, roleEntry)); }
public async Task Role_CreateUpdateDelete() { Skip.If(string.IsNullOrEmpty(TestHelper.MasterToken)); var roleEntry = new RoleEntry { Name = "APITestingRole", Description = "Role for API Testing (Role_CreateUpdateDelete)" }; var newRoleResult = await _client.Role.Create(roleEntry); Assert.NotNull(newRoleResult.Response); Assert.NotEqual(TimeSpan.Zero, newRoleResult.RequestTime); Assert.False(string.IsNullOrEmpty(newRoleResult.Response.ID)); Assert.Equal(roleEntry.Description, newRoleResult.Response.Description); Assert.Equal(roleEntry.Name, newRoleResult.Response.Name); newRoleResult.Response.Description = "This is an updated role for API testing (Role_CreateUpdateDelete)"; var updatedRoleResult = await _client.Role.Update(newRoleResult.Response); Assert.NotNull(updatedRoleResult.Response); Assert.NotEqual(TimeSpan.Zero, updatedRoleResult.RequestTime); Assert.Equal(newRoleResult.Response.ID, updatedRoleResult.Response.ID); Assert.Equal(newRoleResult.Response.Name, updatedRoleResult.Response.Name); Assert.Equal(newRoleResult.Response.Description, updatedRoleResult.Response.Description); Assert.NotEqual(roleEntry.Description, updatedRoleResult.Response.Description); var deleteResponse = await _client.Role.Delete(updatedRoleResult.Response.ID); Assert.True(deleteResponse.Response); }
public ActionResult Create(RoleEntry model) { var info = _role.GetByCode(model.RoleCode); if (info != null && info.RoleCode == model.RoleCode) { ModelState.AddModelError("RoleCode", string.Format("{0} has been used, please change one.", "Action Code")); } if (ModelState.IsValid) { model.CreatedBy = Utility.CurrentUserName; model.CreatedTime = DateTime.UtcNow; Utility.Operate(this, Operations.Add, () => { _cache.Remove(Constants.CACHE_KEY_ROLES); return _role.Add(model); }, model.DisplayName); } else { Utility.SetErrorModelState(this); } return Redirect("~/Admin/Roles/Index"); }
private void RemoveObsoleteEntriesAndParameters(ExchangeRole role) { if (role.RoleType == RoleType.UnScoped) { return; } List <RoleEntry> list = new List <RoleEntry>(); foreach (RoleEntry roleEntry in role.RoleEntries) { RoleEntry roleEntry2 = roleEntry.FindAndIntersectWithMatchingParameters(this.allAllowedRoleEntriesForSKU); if (roleEntry2 != null) { list.Add(roleEntry2); if (roleEntry2 != roleEntry) { base.WriteVerbose(Strings.ConfirmationMessageRemoveManagementRoleEntry(roleEntry.ToString(), role.Id.ToString())); base.WriteVerbose(Strings.ConfirmationMessageNewManagementRoleEntry(roleEntry2.ToString(), role.Id.ToString())); } } else { base.WriteVerbose(Strings.ConfirmationMessageRemoveManagementRoleEntry(roleEntry.ToString(), role.Id.ToString())); } } role.RoleEntries = new MultiValuedProperty <RoleEntry>(list); }
public async Task Role_CreateListDelete() { Skip.If(string.IsNullOrEmpty(TestHelper.MasterToken)); var roleEntry = new RoleEntry { Name = "APITestingRole", Description = "Role for API Testing (Role_CreateListDelete)" }; var newRoleResult = await _client.Role.Create(roleEntry); Assert.NotNull(newRoleResult.Response); Assert.NotEqual(TimeSpan.Zero, newRoleResult.RequestTime); Assert.False(string.IsNullOrEmpty(newRoleResult.Response.ID)); Assert.Equal(roleEntry.Description, newRoleResult.Response.Description); Assert.Equal(roleEntry.Name, newRoleResult.Response.Name); var aclRoleList = await _client.Role.List(); Assert.NotNull(aclRoleList.Response); Assert.NotEqual(TimeSpan.Zero, aclRoleList.RequestTime); Assert.True(aclRoleList.Response.Length >= 1); var deleteResponse = await _client.Role.Delete(newRoleResult.Response.ID); Assert.True(deleteResponse.Response); }
public bool IsRuleApplicable(RoleEntry targetRoleEntry, out RoleEntry matchingRoleEntry) { if (null == targetRoleEntry) { throw new ArgumentNullException("targetRoleEntry"); } ExTraceGlobals.AccessCheckTracer.TraceDebug <RoleEntry, string>((long)this.GetHashCode(), "Entering ValidationRuleDefinition.IsRuleApplicable({0}). Rule name: '{1}'", targetRoleEntry, this.Name); matchingRoleEntry = null; int num = this.ApplicableRoleEntries.BinarySearch(targetRoleEntry, RoleEntry.NameComparer); if (num < 0) { ExTraceGlobals.AccessCheckTracer.TraceDebug <RoleEntry, string>((long)this.GetHashCode(), "ValidationRuleDefinition.IsRuleApplicable({0}) returns false. Rule name: '{1}'. Cmdlet not applicable.", targetRoleEntry, this.Name); return(false); } RoleEntry roleEntry = this.ApplicableRoleEntries[num]; matchingRoleEntry = roleEntry.IntersectParameters(targetRoleEntry); if (matchingRoleEntry.Parameters.Count > 0) { ExTraceGlobals.AccessCheckTracer.TraceDebug <RoleEntry, string>((long)this.GetHashCode(), "ValidationRuleDefinition.IsRuleApplicable({0}) returns true. Rule name: '{1}'. Parameters match.", targetRoleEntry, this.Name); return(true); } if (targetRoleEntry.Parameters.Count == 0 && roleEntry.Parameters.Contains("_RestrictionDefinedForAllParameters")) { ExTraceGlobals.AccessCheckTracer.TraceDebug <RoleEntry, string>((long)this.GetHashCode(), "ValidationRuleDefinition.IsRuleApplicable({0}) returns true. Rule name: '{1}'. No parameters specified but restriction defined for all parameters.", targetRoleEntry, this.Name); return(true); } ExTraceGlobals.AccessCheckTracer.TraceDebug <RoleEntry, string>((long)this.GetHashCode(), "ValidationRuleDefinition.IsRuleApplicable({0}) returns false. Rule name: '{1}'. Parameters doesn't match. ", targetRoleEntry, this.Name); return(false); }
protected bool RoleEntriesMatch(RoleEntry[] entriesA, RoleEntry[] entriesB) { if (entriesA.Length != entriesB.Length) { return(false); } int i = 0; while (i < entriesA.Length) { RoleEntry roleEntry = entriesA[i]; int num = Array.BinarySearch <RoleEntry>(entriesB, roleEntry, RoleEntryComparer.Instance); bool result; if (num >= 0) { if (roleEntry.Equals(entriesB[num])) { i++; continue; } result = false; } else { result = false; } return(result); } return(true); }
public ActionResult Create(RoleEntry model) { var info = _role.GetByCode(model.RoleCode); if (info != null && info.RoleCode == model.RoleCode) { ModelState.AddModelError("RoleCode", string.Format("{0} has been used, please change one.", "Action Code")); } if (ModelState.IsValid) { model.CreatedBy = Utility.CurrentUserName; model.CreatedTime = DateTime.UtcNow; Utility.Operate(this, Operations.Add, () => { _cache.Remove(Constants.CACHE_KEY_ROLES); return(_role.Add(model)); }, model.DisplayName); } else { Utility.SetErrorModelState(this); } return(Redirect("~/Admin/Roles/Index")); }
void AddRoles(List <RoleData> roleData) { foreach (var role in roleData) { if (RoleEntries.Exists(x => x.RoleData == role)) { continue; } GameObject roleEntryObject = Instantiate(RoleEntry); roleEntryObject.name = "Entry:" + role.RoleName; TMP_Text roleText = roleEntryObject.GetComponentInChildren <TMP_Text>(); roleText.text = role.RoleName; RoleEntry roleEntry = roleEntryObject.GetComponentInChildren <RoleEntry>(); roleEntry.RoleData = role; roleText.color = RoleData.RoleColors[(int)role.RoleType]; if (InUseRoles.Contains(role)) { Toggle toggle = roleEntryObject.GetComponentInChildren <Toggle>(); toggle.SetIsOnWithoutNotify(true); } RoleEntries.Add(roleEntry); } }
public RoleEntryValidationRuleTuple(ValidationRuleDefinition ruleDefinition, RoleEntry matchingRoleEntry) { if (ruleDefinition == null) { throw new ArgumentNullException("ruleDefinition"); } if (null == matchingRoleEntry) { throw new ArgumentNullException("matchingRoleEntry"); } this.RuleDefinition = ruleDefinition; this.MatchingRoleEntry = matchingRoleEntry; }
public async Task Token_CreateWithRolesDelete() { Skip.If(string.IsNullOrEmpty(TestHelper.MasterToken)); var roleEntryOne = new RoleEntry { Name = "TokenTestRoleOne", Description = "ACL API Test Role One" }; var roleEntryTwo = new RoleEntry { Name = "TokenTestRoleTwo", Description = "ACL API Test Role Two" }; var roleOne = await _client.Role.Create(roleEntryOne); var roleTwo = await _client.Role.Create(roleEntryTwo); Assert.NotNull(roleOne.Response); Assert.NotNull(roleTwo.Response); var tokenEntry = new TokenEntry { Description = "API Testing Token", SecretID = "2F3BF7FF-1297-42FD-9372-9418904ACAE1", Roles = new RoleLink[] { roleOne.Response, roleTwo.Response }, Local = true }; var newToken = await _client.Token.Create(tokenEntry); Assert.NotEqual(TimeSpan.Zero, newToken.RequestTime); Assert.NotNull(newToken.Response); Assert.False(string.IsNullOrEmpty(newToken.Response.AccessorID)); Assert.Equal(tokenEntry.Description, newToken.Response.Description); Assert.Equal(tokenEntry.SecretID, newToken.Response.SecretID); Assert.Equal(tokenEntry.Local, newToken.Response.Local); var deleteResponse = await _client.Token.Delete(newToken.Response.AccessorID); Assert.True(deleteResponse.Response); deleteResponse = await _client.Role.Delete(roleOne.Response.ID); Assert.True(deleteResponse.Response); deleteResponse = await _client.Role.Delete(roleTwo.Response.ID); Assert.True(deleteResponse.Response); }
private RoleEntry ParseListElementToRoleEntry(XmlTextReader reader) { RoleEntry result = null; try { result = RoleEntry.Parse(reader.Value); } catch (FormatException ex) { this.ThrowParserException(reader, new LocalizedString(ex.Message)); } return(result); }
protected List <RoleEntry> GetListOfRoleEntriesForChildRole(RoleEntry[] oldParentRoleEntries, RoleEntry[] oldChildRoleEntries, RoleEntry[] updatedParentRoleEntries, bool versionBumped) { ExTraceGlobals.AccessCheckTracer.TraceFunction(20005L, "-->GetListOfRoleEntriesForChildRole: oldParentRoleEntries.Length = {0}, oldChildRoleEntries.Length = {1}, updatedParentRoleEntries.Length = {2}, versionBumped = {3}", new object[] { oldParentRoleEntries.Length, oldChildRoleEntries.Length, updatedParentRoleEntries.Length, versionBumped }); List <RoleEntry> list = new List <RoleEntry>(updatedParentRoleEntries.Length); foreach (RoleEntry roleEntry in updatedParentRoleEntries) { RoleEntry value = versionBumped ? roleEntry.MapToPreviousVersion() : roleEntry; int num = Array.BinarySearch <RoleEntry>(oldChildRoleEntries, value, RoleEntryComparer.Instance); if (num >= 0) { List <string> list2 = new List <string>(); foreach (string text in roleEntry.Parameters) { string parameterToCheck = versionBumped ? roleEntry.MapParameterToPreviousVersion(text) : text; if (oldChildRoleEntries[num].ContainsParameter(parameterToCheck)) { list2.Add(text); } else { int num2 = Array.BinarySearch <RoleEntry>(oldParentRoleEntries, value, RoleEntryComparer.Instance); if (!oldParentRoleEntries[num2].ContainsParameter(parameterToCheck)) { list2.Add(text); } } } list.Add(roleEntry.Clone(list2)); } else { int num3 = Array.BinarySearch <RoleEntry>(oldParentRoleEntries, value, RoleEntryComparer.Instance); if (num3 < 0) { list.Add(roleEntry); } } } ExTraceGlobals.AccessCheckTracer.TraceFunction <int>(20005L, "<--GetListOfRoleEntriesForChildRole: updatedRoleEntries.Count = {0}", list.Count); return(list); }
public LoginMessage Lgoin(AccountEntry account, ShuNiuContext context) { LoginMessage message = new LoginMessage(); try { AccountEntry byName = context.Accounts.Where(a => a.Name == account.Name).FirstOrDefault(); AccountEntry byPass = context.Accounts.Where(a => a.PassWord == account.PassWord).SingleOrDefault(); if (byName != null && byPass != null) { RoleEntry role = context.Roles.Find(byName.RoleId); if (!string.IsNullOrEmpty(role.Id)) { if (role.Name.Equals("SuperAdmin")) { message.Message = "SuperAdmin登陆成功"; message.LoginResult = LoginResult.SuperAdminLogin; } else if (role.Name.Equals("Admin")) { message.Message = "Admin登陆成功"; message.LoginResult = LoginResult.AdminLogin; } else if (role.Name.Equals("User")) { message.Message = "User登陆成功"; message.LoginResult = LoginResult.UserLogin; } } else { message.Message = "用户名或密码错误"; message.LoginResult = LoginResult.LoginFailed; } } else { message.Message = "用户名或密码错误"; message.LoginResult = LoginResult.LoginFailed; } } catch (Exception ex) { Logger.Error(ex); } return(message); }
public async Task Role_Create_WithServiceIdentitiesUpdateWithServiceIdentityDelete() { Skip.If(string.IsNullOrEmpty(TestHelper.MasterToken)); var serviceIdentityOne = new ServiceIdentity { ServiceName = "apitestingdummyserviceidentityone", Datacenters = new [] { "dc1", "dc2" } }; var serviceIdentityTwo = new ServiceIdentity { ServiceName = "apitestingdummyserviceidentitytwo", Datacenters = new string[] { } }; var roleEntry = new RoleEntry { Name = "APITestingRole", Description = "Role for API Testing (Role_CreateWithServiceIdentityUpdateServiceIdentityDelete)", ServiceIdentities = new ServiceIdentity[] { serviceIdentityOne, serviceIdentityTwo } }; var newRoleResult = await _client.Role.Create(roleEntry); Assert.NotNull(newRoleResult.Response); Assert.NotEqual(TimeSpan.Zero, newRoleResult.RequestTime); Assert.False(string.IsNullOrEmpty(newRoleResult.Response.ID)); Assert.Equal(roleEntry.Description, newRoleResult.Response.Description); Assert.Equal(roleEntry.Name, newRoleResult.Response.Name); newRoleResult.Response.Description = "This is an updated role for API testing (Role_CreateWithServiceIdentityUpdateServiceIdentityDelete)"; newRoleResult.Response.ServiceIdentities = new ServiceIdentity[] { serviceIdentityTwo }; var updatedRoleResult = await _client.Role.Update(newRoleResult.Response); Assert.NotNull(updatedRoleResult.Response); Assert.NotEqual(TimeSpan.Zero, updatedRoleResult.RequestTime); Assert.Equal(newRoleResult.Response.ID, updatedRoleResult.Response.ID); Assert.Equal(newRoleResult.Response.Name, updatedRoleResult.Response.Name); Assert.Equal(newRoleResult.Response.Description, updatedRoleResult.Response.Description); Assert.NotEqual(roleEntry.Description, updatedRoleResult.Response.Description); var deleteResponse = await _client.Role.Delete(updatedRoleResult.Response.ID); Assert.True(deleteResponse.Response); }
internal void ApplyChangesToDownlevelData(ExchangeRole parentRole) { if (parentRole == null) { throw new ArgumentNullException("parentRole"); } if (!this.HasDownlevelData) { return; } MultiValuedProperty <RoleEntry> multiValuedProperty = (MultiValuedProperty <RoleEntry>) this[ExchangeRoleSchema.InternalDownlevelRoleEntries]; object[] removed = this.RoleEntries.Removed; for (int i = 0; i < removed.Length; i++) { RoleEntry roleEntry = (RoleEntry)removed[i]; RoleEntry downlevelEntryToFind = roleEntry.MapToPreviousVersion(); RoleEntry roleEntry2 = multiValuedProperty.Find((RoleEntry dre) => 0 == RoleEntry.CompareRoleEntriesByName(dre, downlevelEntryToFind)); if (roleEntry2 != null) { multiValuedProperty.Remove(roleEntry2); } } object[] added = this.RoleEntries.Added; for (int j = 0; j < added.Length; j++) { RoleEntry roleEntry3 = (RoleEntry)added[j]; RoleEntry downlevelEntryToFind = roleEntry3.MapToPreviousVersion(); MultiValuedProperty <RoleEntry> multiValuedProperty2 = (MultiValuedProperty <RoleEntry>)parentRole[ExchangeRoleSchema.InternalDownlevelRoleEntries]; RoleEntry roleEntry4 = multiValuedProperty2.Find((RoleEntry dre) => 0 == RoleEntry.CompareRoleEntriesByName(dre, downlevelEntryToFind)); if (!(roleEntry4 == null)) { List <string> list = new List <string>(); foreach (string newParameter in roleEntry3.Parameters) { string text = roleEntry3.MapParameterToPreviousVersion(newParameter); if (roleEntry4.ContainsParameter(text)) { list.Add(text); } } RoleEntry item = downlevelEntryToFind.Clone(list); multiValuedProperty.Add(item); } } }
public List <RoleEntry> GetRoleEntriesFilteringProhibitedActions(List <string> features, List <string> prohibitedActions) { if (!this.ContainsProhibitedActions(prohibitedActions)) { throw new InvalidOperationException(string.Format(" Role '{0}' doesn't have any prohibited action.", this.RoleName)); } string input = null; List <RoleEntry> list = new List <RoleEntry>(this.cmdlets.Length); foreach (RoleCmdlet roleCmdlet in this.cmdlets) { if (roleCmdlet.TryGenerateRoleEntryFilteringProhibitedActions(features, prohibitedActions, ref input)) { list.Add(RoleEntry.Parse(input)); } } return(list); }
public ExchangeRole GenerateRole(List <string> enabledFeatures, ADObjectId rolesContainerId, string suffix, string resolutionType) { ExchangeRole exchangeRole = new ExchangeRole(); string input = null; exchangeRole.SetId(rolesContainerId.GetChildId(this.RoleName + suffix)); exchangeRole.RoleType = this.roleType; exchangeRole.MailboxPlanIndex = resolutionType; exchangeRole.StampImplicitScopes(); exchangeRole.StampIsEndUserRole(); foreach (RoleCmdlet roleCmdlet in this.cmdlets) { if (roleCmdlet.TryGenerateRoleEntry(enabledFeatures, ref input)) { exchangeRole.RoleEntries.Add(RoleEntry.Parse(input)); } } return(exchangeRole); }
public ActionResult Edit(RoleEntry model) { var info = _role.GetById(model.RoleId); if (ModelState.IsValid) { model.CreatedTime = info.CreatedTime; model.ChangedBy = info.CreatedBy; model.ChangedBy = Utility.CurrentUserName; model.ChangedTime = DateTime.UtcNow; Utility.Operate(this, Operations.Update, () => { _cache.Remove(Constants.CACHE_KEY_ROLES); return _role.Update(model); }, model.DisplayName); } else { Utility.SetErrorModelState(this); } return Redirect("~/Admin/Roles/Index"); }
public override IDisplayResult Edit(User user) { // This view is always rendered, however there will be no editable roles if the user does not have permission to edit them. return(Initialize <EditUserRoleViewModel>("UserRoleFields_Edit", async model => { // The current user can only view their roles if they have list users, to prevent listing roles when managing their own profile. if (String.Equals(_httpContextAccessor.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier), user.UserId, StringComparison.OrdinalIgnoreCase) && !await _authorizationService.AuthorizeAsync(_httpContextAccessor.HttpContext.User, Permissions.ViewUsers)) { return; } var roleNames = await GetRoleNamesAsync(); // When a user is in a role that the current user cannot manage the role is shown but selection is disabled. var authorizedRoleNames = await GetAuthorizedRoleNamesAsync(roleNames); var userRoleNames = await _userRoleStore.GetRolesAsync(user, default(CancellationToken)); var roleEntries = new List <RoleEntry>(); foreach (var roleName in roleNames) { var roleEntry = new RoleEntry { Role = roleName, IsSelected = userRoleNames.Contains(roleName, StringComparer.OrdinalIgnoreCase) }; if (!authorizedRoleNames.Contains(roleName, StringComparer.OrdinalIgnoreCase)) { roleEntry.IsEditingDisabled = true; } roleEntries.Add(roleEntry); } model.Roles = roleEntries.ToArray(); }) .Location("Content:1.10")); }
public ExchangeRoleEntryPresentation(ExchangeRole role, RoleEntry roleEntry) : base(role) { if (roleEntry is CmdletRoleEntry) { this.Type = ManagementRoleEntryType.Cmdlet; this.PSSnapinName = ((CmdletRoleEntry)roleEntry).PSSnapinName; } else if (roleEntry is ScriptRoleEntry) { this.Type = ManagementRoleEntryType.Script; } else if (roleEntry is ApplicationPermissionRoleEntry) { this.Type = ManagementRoleEntryType.ApplicationPermission; } else if (roleEntry is WebServiceRoleEntry) { this.Type = ManagementRoleEntryType.WebService; } this.Name = roleEntry.Name; this.identity = string.Format("{0}\\{1}", role.Id.ToString(), this.Name); this.Parameters = roleEntry.Parameters; }
public ActionResult Edit(RoleEntry model) { var info = _role.GetById(model.RoleId); if (ModelState.IsValid) { model.CreatedTime = info.CreatedTime; model.ChangedBy = info.CreatedBy; model.ChangedBy = Utility.CurrentUserName; model.ChangedTime = DateTime.UtcNow; Utility.Operate(this, Operations.Update, () => { _cache.Remove(Constants.CACHE_KEY_ROLES); return(_role.Update(model)); }, model.DisplayName); } else { Utility.SetErrorModelState(this); } return(Redirect("~/Admin/Roles/Index")); }
internal IList <RoleEntryValidationRuleTuple> GetApplicableRules(string cmdletFullName, IList <string> parameters, ValidationRuleSkus applicableSku) { if (string.IsNullOrEmpty(cmdletFullName)) { throw new ArgumentNullException("cmdletFullName"); } if (parameters == null) { throw new ArgumentNullException("parameters"); } ExTraceGlobals.AccessCheckTracer.TraceDebug <string, string>((long)this.GetHashCode(), "Entering RBACValidationRulesList.GetApplicableRules({0}). Sku {1} ", cmdletFullName, applicableSku.ToString()); if (!this.IsListInitialized()) { return(RBACValidationRulesList.Nested.TupleEmptyList); } List <ValidationRuleDefinition> list = null; IList <RoleEntryValidationRuleTuple> list2 = RBACValidationRulesList.Nested.TupleEmptyList; if (this.cmdletToRules.TryGetValue(cmdletFullName, out list)) { RoleEntry targetRoleEntry = null; if (this.TryCreateRoleEntry(cmdletFullName, parameters, out targetRoleEntry)) { RoleEntry matchingRoleEntry = null; list2 = new List <RoleEntryValidationRuleTuple>(list.Count); foreach (ValidationRuleDefinition validationRuleDefinition in list) { if ((byte)(validationRuleDefinition.ApplicableSku & applicableSku) != 0 && validationRuleDefinition.IsRuleApplicable(targetRoleEntry, out matchingRoleEntry)) { list2.Add(new RoleEntryValidationRuleTuple(validationRuleDefinition, matchingRoleEntry)); } } } } ExTraceGlobals.AccessCheckTracer.TraceDebug <string, string>((long)this.GetHashCode(), "RBACValidationRulesList.GetApplicableRules({0}). returns '{1}'", cmdletFullName, (list2.Count == 0) ? "<Empty>" : (list2.Count.ToString() + " validation rules.")); return(list2); }
internal RoleEntryInfo(RoleEntry roleEntry) { this.RoleEntry = roleEntry; this.RoleAssignment = null; this.ScopeSet = null; }
private void CreateRole(PRoleSummary rRole, RoleEntry rEntry) { if (rEntry?.root == null || rRole == null) { return; } rEntry.materialList.Clear(); //没有时装数据的角色不创建模型。避免报错 if (rRole.fashion.weapon == 0) { return; } Vector3 pos = Vector3.zero, rot = Vector3.zero; var info = ConfigManager.Get <ShowCreatureInfo>(20001 + rEntry.index); var d = info?.GetDataByIndex(rRole.proto); if (d != null && d.data?.Length > 0) { pos = d.data[0].pos; rot = d.data[0].rotation; } var assets = new List <string>(); Level.PrepareAssets(Module_Battle.BuildPlayerSimplePreloadAssets(rRole, assets), b => { rEntry.creature = Creature.Create(modulePlayer.BuildPlayerInfo(rRole), rEntry.root.position + pos, rot, true, rRole.name, rRole.name, false); rEntry.creature.transform.SetParent(rEntry.root); rEntry.creature.localRotation = Quaternion.Euler(rot); rEntry.creature.roleId = rRole.roleId; CharacterEquip.ChangeCloth(rEntry.creature, rRole.fashion); var renderers = rEntry.creature.gameObject.GetComponentsInChildren <Renderer>(); foreach (var r in renderers) { rEntry.materialList.AddRange(r.materials); } //暂时不显示宠物了 /*if (rRole.pet == null || rRole.pet.itemId == 0) * return; * * var rPet = PetInfo.Create(rRole.pet); * var rGradeInfo = rPet.UpGradeInfo; * var show = ConfigManager.Get<ShowCreatureInfo>(rPet.ID); * if (show == null) * { * Logger.LogError("没有配置config_showCreatureInfo表。宠物ID = {0}, 没有出生位置信息。宠物模型创建失败", rPet.ID); * return; * } * var showData = show.GetDataByIndex(0); * var data = showData.data.GetValue<ShowCreatureInfo.SizeAndPos>(0); * rEntry.pet = moduleHome.CreatePet(rGradeInfo, data.pos + rEntry.creature.position, data.rotation, rEntry.root, true, * Module_Home.TEAM_PET_OBJECT_NAME); * rEntry.pet.transform.localScale *= data.size; * rEntry.pet.transform.localEulerAngles = data.rotation; * * renderers = rEntry.pet.gameObject.GetComponentsInChildren<Renderer>(); * foreach (var r in renderers) * rEntry.materialList.AddRange(r.materials);*/ }); }
public int Compare(RoleEntryInfo a, RoleEntryInfo b) { return(RoleEntry.CompareRoleEntriesByName(a.RoleEntry, b.RoleEntry)); }
internal static bool DoesRoleEntryMatchNameAndParameters(RoleEntry roleEntry, ManagementRoleEntryType type, string name, string[] parameters, string snapinName) { if (null == roleEntry) { throw new ArgumentNullException("roleEntry"); } ManagementRoleEntryType managementRoleEntryType = (ManagementRoleEntryType)0; if (roleEntry is CmdletRoleEntry) { managementRoleEntryType = ManagementRoleEntryType.Cmdlet; } else if (roleEntry is ScriptRoleEntry) { managementRoleEntryType = ManagementRoleEntryType.Script; } else if (roleEntry is ApplicationPermissionRoleEntry) { managementRoleEntryType = ManagementRoleEntryType.ApplicationPermission; } else if (roleEntry is WebServiceRoleEntry) { managementRoleEntryType = ManagementRoleEntryType.WebService; } if ((type & managementRoleEntryType) == (ManagementRoleEntryType)0 && type != ManagementRoleEntryType.All) { return(false); } if (!string.IsNullOrEmpty(snapinName)) { if (managementRoleEntryType != ManagementRoleEntryType.Cmdlet) { return(false); } Regex regex = new Regex(Wildcard.ConvertToRegexPattern(snapinName), RegexOptions.IgnoreCase); if (!regex.IsMatch(((CmdletRoleEntry)roleEntry).PSSnapinName)) { return(false); } } if (!string.IsNullOrEmpty(name)) { Regex regex2 = new Regex(Wildcard.ConvertToRegexPattern(name), RegexOptions.IgnoreCase); if (!regex2.IsMatch(roleEntry.Name)) { if (type != ManagementRoleEntryType.Cmdlet) { return(false); } if (!regex2.IsMatch(roleEntry.Name + "," + ((CmdletRoleEntry)roleEntry).PSSnapinName)) { return(false); } } } if (parameters != null && parameters.Length != 0) { foreach (string wildcardString in parameters) { Regex regex3 = new Regex(Wildcard.ConvertToRegexPattern(wildcardString), RegexOptions.IgnoreCase); bool flag = false; foreach (string input in roleEntry.Parameters) { if (regex3.IsMatch(input)) { flag = true; break; } } if (!flag) { return(false); } } } return(true); }
public int Compare(RoleEntryInfo a, RoleEntryInfo b) { return(RoleEntry.CompareRoleEntriesByNameAndInstanceHashCode(a.RoleEntry, b.RoleEntry)); }
internal RoleEntryInfo(RoleEntry roleEntry, ExchangeRoleAssignment roleAssignment) { this.RoleEntry = roleEntry; this.RoleAssignment = roleAssignment; this.ScopeSet = null; }