private static IReadOnlyCollection <PermissionType> RecursiveUpdateCurrentUserGroupPermissionTypes(UserToken userToken, EntityToken entityToken, IEnumerable <UserGroupPermissionDefinition> userGroupPermissionDefinitions, HashSet <EntityTokenPair> alreadyProcessedTokens)
{
IReadOnlyCollection <PermissionType> cached = PermissionTypeFacadeCaching.GetUserGroupPermissionTypes(userToken, entityToken);
if (cached != null)
{
return(cached);
}
IEnumerable <UserGroupPermissionDefinition> selectedUserGroupPermissionDefinitions = userGroupPermissionDefinitions.Where(f => entityToken.EqualsWithVersionIgnore(f.EntityToken));
List <PermissionType> thisPermisstionTypes = new List <PermissionType>();
foreach (UserGroupPermissionDefinition userGroupPermissionDefinition in selectedUserGroupPermissionDefinitions)
{
List <PermissionType> groupPermissionTypes = userGroupPermissionDefinition.PermissionTypes.ToList();
thisPermisstionTypes.AddRange(groupPermissionTypes);
}
if (thisPermisstionTypes.Count > 0)
{
thisPermisstionTypes = thisPermisstionTypes.Distinct().ToList();
if (thisPermisstionTypes.Contains(PermissionType.ClearPermissions))
{
thisPermisstionTypes = new List <PermissionType>();
}
PermissionTypeFacadeCaching.SetUserGroupPermissionTypes(userToken, entityToken, thisPermisstionTypes);
// Local defined permission overrules all other permissions
return(thisPermisstionTypes);
}
// Call resursively on all parents
List <EntityToken> parentEntityTokens = ParentsFacade.GetAllParents(entityToken);
IEnumerable <PermissionType> parentsPermisstionTypes = new List <PermissionType>();
foreach (EntityToken parentEntityToken in parentEntityTokens)
{
EntityTokenPair pair = new EntityTokenPair(entityToken, parentEntityToken);
if (alreadyProcessedTokens.Contains(pair) == false)
{
alreadyProcessedTokens.Add(pair);
IEnumerable <PermissionType> thisParentPermisstionTypes = RecursiveUpdateCurrentUserGroupPermissionTypes(userToken, parentEntityToken, userGroupPermissionDefinitions, alreadyProcessedTokens);
parentsPermisstionTypes = parentsPermisstionTypes.Concat(thisParentPermisstionTypes);
}
}
List <PermissionType> permisstionTypes = parentsPermisstionTypes.Distinct().ToList();
PermissionTypeFacadeCaching.SetUserGroupPermissionTypes(userToken, entityToken, permisstionTypes);
return(permisstionTypes);
}
/// <exclude />
public static IEnumerable <PermissionType> GetInheritedGroupPermissionsTypes(Guid userGroupId, EntityToken entityToken)
{
IEnumerable <UserGroupPermissionDefinition> userGroupPermissionDefinitions = GetUserGroupPermissionDefinitions(userGroupId);
List <EntityToken> parentEntityTokens = ParentsFacade.GetAllParents(entityToken);
List <PermissionType> permissionTypes = new List <PermissionType>();
foreach (EntityToken parentEntityToken in parentEntityTokens)
{
permissionTypes.AddRange(GetInheritedGroupPermissionsTypesRecursivly(parentEntityToken, userGroupPermissionDefinitions));
}
return(permissionTypes.Distinct());
}
private static IEnumerable <PermissionType> GetInheritedGroupPermissionsTypesRecursivly(EntityToken entityToken, IEnumerable <UserGroupPermissionDefinition> userGroupPermissionDefinitions, List <EntityToken> visitedParents = null)
{
UserGroupPermissionDefinition selectedUserGroupPermissionDefinition = userGroupPermissionDefinitions.Where(f => entityToken.EqualsWithVersionIgnore(f.EntityToken)).SingleOrDefault();
if (selectedUserGroupPermissionDefinition != null)
{
if (selectedUserGroupPermissionDefinition.PermissionTypes.Contains(PermissionType.ClearPermissions) == false)
{
foreach (PermissionType permissionType in selectedUserGroupPermissionDefinition.PermissionTypes)
{
yield return(permissionType);
}
}
yield break;
}
List <EntityToken> parentEntityTokens = ParentsFacade.GetAllParents(entityToken);
if (visitedParents == null)
{
visitedParents = new List <EntityToken>();
}
IEnumerable <PermissionType> parentsPermisstionTypes = new List <PermissionType>();
foreach (EntityToken parentEntityToken in parentEntityTokens)
{
if (visitedParents.Contains(parentEntityToken))
{
continue;
}
visitedParents.Add(parentEntityToken);
IEnumerable <PermissionType> result = GetInheritedGroupPermissionsTypesRecursivly(parentEntityToken, userGroupPermissionDefinitions, visitedParents).ToList();
parentsPermisstionTypes = parentsPermisstionTypes.Concat(result);
}
foreach (PermissionType permissionType in parentsPermisstionTypes.Distinct())
{
yield return(permissionType);
}
}
/// <summary>
/// This returns a merged result of user permissions and user group permissions
/// </summary>
/// <param name="userToken"></param>
/// <param name="entityToken"></param>
/// <param name="presetUserGroupPermissions">
/// This is used for simulating that local defined user group permissions has been set
/// </param>
/// <returns></returns>
public static IEnumerable <PermissionType> GetInheritedPermissionsTypes(UserToken userToken, EntityToken entityToken, Dictionary <Guid, IEnumerable <PermissionType> > presetUserGroupPermissions)
{
if (userToken == null)
{
throw new ArgumentNullException("userToken");
}
if (entityToken == null)
{
throw new ArgumentNullException("entityToken");
}
IEnumerable <PermissionType> permissionTypes = PermissionTypeFacadeCaching.GetInheritedPermissionsTypes(userToken, entityToken);
if (permissionTypes != null)
{
return(permissionTypes);
}
if (presetUserGroupPermissions == null || presetUserGroupPermissions.Count == 0)
{
ICollection <PermissionType> localDefinedUserGroupPermissionTypes = GetLocallyDefinedUserGroupPermissionTypes(userToken.Username, entityToken).Evaluate();
if (localDefinedUserGroupPermissionTypes.Count > 0)
{
PermissionTypeFacadeCaching.SetInheritedPermissionsTypes(userToken, entityToken, localDefinedUserGroupPermissionTypes.ToList());
return(localDefinedUserGroupPermissionTypes);
}
}
else
{
List <Guid> userGroupIds = UserGroupFacade.GetUserGroupIds(userToken.Username);
var localDefinedUserGroupPermissionTypes = new List <PermissionType>();
foreach (Guid userGroupId in userGroupIds)
{
IEnumerable <PermissionType> groupPermissionTypes;
if (presetUserGroupPermissions.TryGetValue(userGroupId, out groupPermissionTypes))
{
localDefinedUserGroupPermissionTypes.AddRange(groupPermissionTypes);
}
}
if (localDefinedUserGroupPermissionTypes.Contains(PermissionType.ClearPermissions))
{
return(new PermissionType[0]);
}
return(localDefinedUserGroupPermissionTypes.Distinct());
}
ICollection <UserPermissionDefinition> userPermissionDefinitions = GetUserPermissionDefinitions(userToken.Username).Evaluate();
ICollection <UserGroupPermissionDefinition> userGroupPermissionDefinitions = GetUserGroupPermissionDefinitions(userToken.Username).Evaluate();
List <EntityToken> parentEntityTokens = ParentsFacade.GetAllParents(entityToken);
foreach (EntityToken parentEntityToken in parentEntityTokens)
{
RecursiveUpdateCurrentUserPermissionTypes(userToken, parentEntityToken, userPermissionDefinitions, new HashSet <EntityTokenPair>());
RecursiveUpdateCurrentUserGroupPermissionTypes(userToken, parentEntityToken, userGroupPermissionDefinitions, new HashSet <EntityTokenPair>());
}
if (!PermissionTypeFacadeCaching.CachingWorking)
{
throw new InvalidOperationException("RequestLifetimeCache is not operational");
}
permissionTypes = new List <PermissionType>();
foreach (EntityToken parentEntityToken in parentEntityTokens)
{
IEnumerable <PermissionType> parentUserPermissionTypes = PermissionTypeFacadeCaching.GetUserPermissionTypes(userToken, parentEntityToken);
if (parentUserPermissionTypes != null)
{
permissionTypes = permissionTypes.Concat(parentUserPermissionTypes);
}
IEnumerable <PermissionType> parentUserGroupPermissionTypes = PermissionTypeFacadeCaching.GetUserGroupPermissionTypes(userToken, parentEntityToken);
if (parentUserGroupPermissionTypes != null)
{
permissionTypes = permissionTypes.Concat(parentUserGroupPermissionTypes);
}
}
var distinctPermissionTypes = permissionTypes.Distinct().ToList();
PermissionTypeFacadeCaching.SetInheritedPermissionsTypes(userToken, entityToken, distinctPermissionTypes);
return(distinctPermissionTypes);
}
private static IReadOnlyCollection <PermissionType> RecursiveUpdateCurrentUserPermissionTypes(UserToken userToken, EntityToken entityToken, IEnumerable <UserPermissionDefinition> userPermissionDefinitions, HashSet <EntityTokenPair> alreadyProcessedTokens)
{
var cached = PermissionTypeFacadeCaching.GetUserPermissionTypes(userToken, entityToken);
if (cached != null)
{
return(cached);
}
UserPermissionDefinition userPermissionDefinition = userPermissionDefinitions
.Where(f => entityToken.EqualsWithVersionIgnore(f.EntityToken)).SingleOrDefaultOrException("More then one UserPermissionDefinition for the same entity token");
var thisPermissionTypes = new List <PermissionType>();
if (userPermissionDefinition != null)
{
thisPermissionTypes.AddRange(userPermissionDefinition.PermissionTypes);
}
if (thisPermissionTypes.Count > 0)
{
thisPermissionTypes = thisPermissionTypes.Distinct().ToList();
if (thisPermissionTypes.Contains(PermissionType.ClearPermissions))
{
thisPermissionTypes = new List <PermissionType>();
}
PermissionTypeFacadeCaching.SetUserPermissionTypes(userToken, entityToken, thisPermissionTypes);
// Local defined permission overrules all other permissions
return(thisPermissionTypes);
}
// Call resursively on all parents
var parentEntityTokens = ParentsFacade.GetAllParents(entityToken);
var parentsPermissionTypes = Enumerable.Empty <PermissionType>();
foreach (var parentEntityToken in parentEntityTokens)
{
var pair = new EntityTokenPair(entityToken, parentEntityToken);
if (alreadyProcessedTokens.Contains(pair))
{
continue;
}
alreadyProcessedTokens.Add(pair);
var thisParentPermissionTypes = RecursiveUpdateCurrentUserPermissionTypes(userToken, parentEntityToken, userPermissionDefinitions, alreadyProcessedTokens);
var filteredPermissions = FilterParentPermissions(userToken, parentEntityToken, thisParentPermissionTypes);
parentsPermissionTypes = parentsPermissionTypes.Concat(filteredPermissions);
}
List <PermissionType> permissionTypes = parentsPermissionTypes.Distinct().ToList();
PermissionTypeFacadeCaching.SetUserPermissionTypes(userToken, entityToken, permissionTypes);
return(permissionTypes);
}
