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