public static void Save(object arr)
{
int i = 0;
IEnumerable <Role> iRoleList = RoleList.Where(r => r.Name != System.Configuration.ConfigurationManager.AppSettings["GroupAdmin"]);
foreach (object[] item in (object[])arr)
{
int j = 0;
foreach (bool subItem in item)
{
if (subItem != AuthenticationList[i][j])
{
Role role = iRoleList.ElementAt(i);
TopicPermission topicPermission = TopicPermissionList[j];
if (subItem)
{
TopicAuthenticationManager.AddPermission(topicPermission, role);
}
else
{
TopicAuthenticationManager.RemovePermission(topicPermission, role);
}
}
j++;
}
i++;
}
}
internal static bool GetGrantExpectation(TopicPermission topicPermission, TestIdentity identity, params AuthorizationRule[] rules)
{
List<AuthorizationRule> sortedRules = new List<AuthorizationRule>();
sortedRules.AddRange(rules);
sortedRules.Sort();
bool granted = false;
foreach (AuthorizationRule rule in sortedRules)
{
if (DoesRuleApply(rule, identity))
{
if (rule.Polarity == AuthorizationRulePolarity.Allow)
{
if ((int)topicPermission >= (int)rule.Action)
{
granted = true;
}
}
else if (rule.Polarity == AuthorizationRulePolarity.Deny)
{
if ((int)topicPermission <= (int)rule.Action)
{
granted = false;
}
}
else
{
throw new NotImplementedException();
}
}
}
return granted;
}
public Task DeleteTopicPermissionAsync(TopicPermission topicPermission,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.ArgumentNotNull(topicPermission, nameof(topicPermission));
return(DeleteAsync($"topic-permissions/{topicPermission.Vhost}/{topicPermission.User}", cancellationToken));
}
/// <summary>
/// Delete a topic permission
/// </summary>
/// <param name="source"></param>
/// <param name="permission">The topic permission to delete</param>
/// <param name="cancellationToken"></param>
public static void DeleteTopicPermission(
[NotNull] this IManagementClient source,
[NotNull] TopicPermission permission,
CancellationToken cancellationToken = default
)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
source.DeleteTopicPermissionAsync(permission, cancellationToken)
.GetAwaiter()
.GetResult();
}
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
// If it's not a built-in topic, just pass the question along
if (!IsBuiltInTopic(topic))
{
return Next.HasPermission(topic, permission);
}
// Otherwise, if it is a built-in topic, does it exist in the next provider?
if (Next.TopicExists(topic))
{
// If it does, whatever is true here is true there
return Next.HasPermission(topic, permission);
}
if (permission == TopicPermission.Read)
{
return true;
}
// Otherwise, it's writable only if the next provider is writable as a whole.
else if (permission == TopicPermission.Edit)
{
return !Next.IsReadOnly;
}
return false;
}
private void AssertHasPermissionFromCache(
TestParameters<TopicCacheProvider> parameters,
UnqualifiedTopicName topicName,
TopicPermission topicPermission,
string messageTag)
{
string messageFormat = "Checking that retrieval comes from cache: {0} {1}";
parameters.Store.HasPermissionCalled = false;
bool thirteenthRetrieval = parameters.Provider.HasPermission(topicName, topicPermission);
Assert.IsFalse(parameters.Store.HasPermissionCalled,
string.Format(messageFormat, topicPermission, messageTag));
}
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
if (!_sqlHelper.TopicExists(Namespace, topic.LocalName))
{
// It might seem a little weird to return true if the topic doesn't exist, but
// basically what we're saying is that there's no reason to deny read/edit
return true;
}
if (permission == TopicPermission.Read)
{
return true;
}
else if (permission == TopicPermission.Edit)
{
return _sqlHelper.IsExistingTopicWritable(Namespace, topic.LocalName);
}
else
{
throw new ArgumentException("Unrecognized topic permission: " + permission.ToString());
}
}
public override bool HasPermission(UnqualifiedTopicName topicName, TopicPermission permission)
{
throw new NotImplementedException();
}
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
AddDependency(new TopicPermissionsDependency(topic.ResolveRelativeTo(Namespace)));
return Next.HasPermission(topic, permission);
}
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
_hasPermissionCalled = true;
MockTopic mockTopic = GetTopic(topic, ExistencePolicy.ExistingOnly);
if (mockTopic == null)
{
return true;
}
if (permission == TopicPermission.Edit)
{
return mockTopic.Latest.CanWrite;
}
else if (permission == TopicPermission.Read)
{
return mockTopic.Latest.CanRead;
}
else
{
throw new ArgumentException("Unrecognized TopicPermission " + permission.ToString());
}
}
/// <summary>
/// Answer whether the current user has the given permission for the specified topic.
/// </summary>
/// <param name="topic">The topic </param>
/// <returns>true if the topic exists AND the specified permission is allowed for the current user; else false</returns>
public virtual bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
return _next.HasPermission(topic, permission);
}
//public static string ExtractNameFromTopicName(string topicName)
//{
// int p = topicName.IndexOf("(");
// if (p == -1)
// return topicName;
// return topicName.Substring(0, p);
//}
//public static string ExtractVersionFromTopicName(string topicName)
//{
// // ab(xyz)
// //
// int p = topicName.IndexOf("(");
// if (p == -1)
// return topicName;
// int close = topicName.LastIndexOf(")");
// return topicName.Substring(p + 1, close - p - 1);
//}
/// <summary>
/// Answer whether a topic exists and is writable
/// </summary>
/// <param name="topic">The topic (must directly be in this content base)</param>
/// <returns>true if the topic exists AND is writable by the current user; else false</returns>
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
throw new NotImplementedException();
//if (!SqlHelper.TopicExists(Namespace, topic.LocalName, _connectionString))
//{
// return false;
//}
//return SqlHelper.IsExistingTopicWritable(Namespace, topic.LocalName, _connectionString);
}
public bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
using (CreateRecursionContext())
{
return _next.HasPermission(topic, permission);
}
}
public abstract bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission);
/// <summary>
/// Answer whether a topic is readable or writable
/// </summary>
/// <param name="topic">The topic (must directly be in this content base)</param>
/// <returns>true is writable by the current user (or does not exist); else false</returns>
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
string path = TopicPath(topic, null);
if (!FileSystem.FileExists(path))
{
// It might seem a little weird to return true if the topic doesn't exist, but
// basically what we're saying is that there's no reason to deny read/edit.
return true;
}
if (permission == TopicPermission.Edit)
{
if (!FileSystem.HasWritePermission(path))
{
return false;
}
}
else if (permission == TopicPermission.Read)
{
if (!FileSystem.HasReadPermission(path))
{
return false;
}
}
return true;
}
public bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
return ContentProviderChain.HasPermission(topic, permission);
}
public override bool HasPermission(UnqualifiedTopicName topic, TopicPermission permission)
{
RegisterCall(MethodInfo.GetCurrentMethod());
throw new NotImplementedException();
}
private void AssertDenied(AuthorizationProvider provider, string topic, TopicPermission topicPermission)
{
Assert.IsFalse(provider.HasPermission(new UnqualifiedTopicName(topic), topicPermission),
string.Format("Checking that user is denied permission {0} on topic {1}", topicPermission, topic));
}
