private static void CombineToAccessRightsMap(
IDictionary <string, AccessRight> map,
References references,
PermissionAssignment assignment)
{
if (map == null)
{
throw new ArgumentNullException(nameof(map));
}
if (references == null)
{
throw new ArgumentNullException(nameof(references));
}
if (assignment == null)
{
throw new ArgumentNullException(nameof(assignment));
}
var permission = assignment.Permission;
foreach (var reference in references)
{
string codeName = reference.CodeName;
AccessRight accessRight;
if (!map.TryGetValue(codeName, out accessRight))
{
accessRight = new AccessRight();
map[codeName] = accessRight;
}
foreach (var entityAccess in permission.EntityAccesses)
{
accessRight.CombineEntityAccess(entityAccess);
}
foreach (var managerAccess in permission.ManagerAccesses)
{
accessRight.CombineManagerAccess(managerAccess.ManagerType);
}
accessRight.CombinePermission(permission.CodeName);
foreach (var statePathAccess in permission.StatePathAccesses)
{
accessRight.CombineStatePathAccess(statePathAccess.StatePathCodeName);
}
}
}
/// <summary>
/// Combine selected access rights found in an access rights dictionary.
/// </summary>
/// <param name="accessRightsMapByCodeName">An access rights dictionary.</param>
/// <param name="codeNames">The keys used to fetch items from the dictionary.</param>
/// <returns>Returns the combined access right.</returns>
private static AccessRight CombineAccessRights(
IReadOnlyDictionary <string, AccessRight> accessRightsMapByCodeName,
IEnumerable <string> codeNames)
{
var combinedAccessRight = new AccessRight();
foreach (string codeName in codeNames)
{
if (accessRightsMapByCodeName.TryGetValue(codeName, out AccessRight accessRight))
{
combinedAccessRight.Combine(accessRight);
}
}
return(combinedAccessRight);
}
/// <summary>
/// Determine whether a user can execute a <see cref="StatePath"/>
/// over a stateful instance.
/// </summary>
/// <typeparam name="ST">The type of state transitions, derived from <see cref="StateTransition{U}"/>.</typeparam>
/// <param name="user">The user.</param>
/// <param name="stateful">The stateful instance.</param>
/// <param name="statePath">The state path to execute.</param>
public bool CanUserExecuteStatePath <ST>(U user, IStateful <U, ST> stateful, StatePath statePath)
where ST : StateTransition <U>
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (stateful == null)
{
throw new ArgumentNullException(nameof(stateful));
}
if (statePath == null)
{
throw new ArgumentNullException(nameof(statePath));
}
if (!CanUserReadEntity(user, stateful) || !CanUserWriteEntity(user, stateful))
{
return(false);
}
var rolesAccessRight = GetRolesAccessRight(user);
if (rolesAccessRight.SupportsStatePath(statePath))
{
return(true);
}
if (stateful is ISegregatedEntity segregatedStateful)
{
AccessRight dispositionsAccessRight = GetDispositionsAccessRight(user, segregatedStateful);
return(dispositionsAccessRight.SupportsStatePath(statePath));
}
return(false);
}