Files
using.cash/Logic/Security/Authority.cs
T

309 lines
11 KiB
C#

using System.Collections.Generic;
using Activizr.Logic.Pirates;
using Activizr.Logic.Structure;
using Activizr.Basic.Enums;
using Activizr.Basic.Types;
using Activizr.Basic.Types.Security;
using System;
namespace Activizr.Logic.Security
{
public class Authority : BasicAuthority
{
#region Construction and Creation
private Authority ()
: base(0, null, null, null)
{
}
private Authority (BasicAuthority basic)
: base(basic.PersonId, basic.SystemPersonRoles, basic.OrganizationPersonRoles, basic.LocalPersonRoles)
{
}
public static Authority FromBasic (BasicAuthority basic)
{
return new Authority(basic);
}
#endregion
public Organizations GetOrganizations (RoleType[] forRoles)
{
if (HasRoleType(RoleType.SystemAdmin))
{
return Organizations.GetAll();
}
var orgIdentities = new List<int>();
foreach (BasicPersonRole role in OrganizationPersonRoles)
{
if (Array.IndexOf(forRoles, role.Type) >= 0)
orgIdentities.Add(role.OrganizationId);
}
foreach (BasicPersonRole role in LocalPersonRoles)
{
if (Array.IndexOf(forRoles, role.Type) >= 0)
orgIdentities.Add(role.OrganizationId);
}
return Organizations.FromIdentities(orgIdentities.ToArray());
}
public bool CanSeePerson (Person person)
{
People initialList = People.FromArray(new[] { person });
People filteredList = Authorization.FilterPeopleToMatchAuthority(initialList, this);
if (filteredList.Count == 0)
{
return false;
}
return true;
}
public Geographies GetGeographiesForOrganization (Organization organization)
{
return
GetGeographiesForOrganization(organization, RoleTypes.AllRoleTypes);
}
public Geographies GetGeographiesForOrganization (Organization organization, RoleType[] roleTypes)
{
return
Geographies.FromArray(Authorization.GetNodesInAuthorityForOrganization(this, organization.Identity, roleTypes));
}
public bool HasLocalRoleAtOrganizationGeography (Organization organization, Geography geography, Authorization.Flag flags)
{
return HasLocalRoleAtOrganizationGeography(organization, geography, RoleTypes.AllLocalRoleTypes, flags);
}
public bool HasLocalRoleAtOrganizationGeography (Organization organization, Geography geography,
RoleType roleType, Authorization.Flag flags)
{
return HasLocalRoleAtOrganizationGeography(organization, geography,
new RoleType[] { roleType }, flags);
}
public bool HasLocalRoleAtOrganizationGeography (Organization organization, Geography geography,
RoleType[] roleTypes, Authorization.Flag flags)
{
if (organization != null && organization.Identity == Organization.SandboxIdentity)
{
return true; // UGLY UGLY HACK
}
if (organization == null && (flags & Authorization.Flag.AnyOrganization) == 0)
return false;
if (geography == null && (flags & Authorization.Flag.AnyGeography) == 0)
return false;
foreach (BasicPersonRole role in LocalPersonRoles)
{
foreach (RoleType type in roleTypes)
{
if (type == role.Type)
{
// Expensive op. The org/geo lookups need a cache at the logic layer.
bool organizationClear = false;
bool geographyClear = false;
// First, check if the organization and geography match identically.
if ((flags & Authorization.Flag.AnyOrganization) != 0)
{
// then it is used to check if they have a local role for any org
organizationClear = true;
}
else if (organization != null && organization.Identity == role.OrganizationId)
{
organizationClear = true;
}
if ((flags & Authorization.Flag.AnyGeography) != 0)
{
// then it is used to check if they have a local role anywhere
geographyClear = true;
}
else if (geography != null && geography.Identity == role.GeographyId)
{
geographyClear = true;
}
// If not clear, then check if there is inherited authority.
if (!organizationClear
&& (flags & Authorization.Flag.ExactOrganization) == 0)
{
if (organization != null && organization.Inherits(role.OrganizationId))
{
organizationClear = true;
}
}
if (!geographyClear && (flags & Authorization.Flag.ExactGeography) == 0)
{
if (geography != null && geography.Inherits(role.GeographyId))
{
geographyClear = true;
}
}
// If both are ok, return that there is authority at this org & geo.
if (organizationClear && geographyClear)
{
return true;
}
}
}
}
return false;
}
public bool HasRoleAtOrganization (Organization organization, Authorization.Flag flags)
{
return HasRoleAtOrganization(organization, RoleTypes.AllOrganizationalRoleTypes, flags);
}
public bool HasRoleAtOrganization (Organization organization, RoleType roleType, Authorization.Flag flags)
{
return HasRoleAtOrganization(organization, new RoleType[] { roleType }, flags);
}
public bool HasRoleAtOrganization (Organization organization, RoleType[] roleTypes, Authorization.Flag flags)
{
if (organization == null)
{
if ((flags & Authorization.Flag.AnyOrganization) != 0)
return true;
else
return false;
}
if (organization != null && organization.Identity == Organization.SandboxIdentity)
{
return true; // UGLY UGLY HACK
}
foreach (BasicPersonRole role in OrganizationPersonRoles)
{
foreach (RoleType type in roleTypes)
{
if (type == role.Type)
{
if ((flags & Authorization.Flag.AnyOrganization) != 0)
return true;
if (organization.Identity == role.OrganizationId)
{
return true;
}
if ((flags & Authorization.Flag.ExactOrganization) == 0)
{
if (organization.Inherits(role.OrganizationId))
{
return true;
}
}
}
}
}
return false;
}
public bool HasRoleType (RoleType roleType)
{
return HasAnyRoleType(new RoleType[] { roleType });
}
public bool HasAnyRoleType (RoleType[] roleTypes)
{
foreach (RoleType r in roleTypes)
{
foreach (BasicPersonRole r2 in this.LocalPersonRoles)
if (r2.Type == r) return true;
foreach (BasicPersonRole r2 in this.OrganizationPersonRoles)
if (r2.Type == r) return true;
foreach (BasicPersonRole r2 in this.SystemPersonRoles)
if (r2.Type == r) return true;
}
return false;
}
public bool CanEditSystemRoles ()
{
return HasPermission(Permission.CanEditSystemRoles, -1, -1, Authorization.Flag.ExactGeography | Authorization.Flag.ExactOrganization);
}
public bool CanEditOrgRolesForOrg (int orgId)
{
return HasPermission(Permission.CanEditOrganisationalRoles, orgId, -1, Authorization.Flag.Default);
}
public bool HasAnyPermission (Permission perm)
{
return Authorization.CheckAuthorization(new PermissionSet(perm), -1, -1, this, Authorization.Flag.AnyGeographyAnyOrganization);
}
private bool HasPermission (Permission perm, int organizationId, Authorization.Flag flags)
{
return Authorization.CheckAuthorization(new PermissionSet(perm), organizationId, Organization.RootIdentity, this, flags);
}
public bool HasPermission (Permission perm, int organizationId, int geographyId, Authorization.Flag flags)
{
return Authorization.CheckAuthorization(new PermissionSet(perm, organizationId, geographyId), organizationId, geographyId, this, flags);
}
public bool HasPermission (PermissionSet perm, Authorization.Flag flags)
{
return Authorization.CheckAuthorization(perm, -1, -1, this, flags);
}
public bool HasPermission (PermissionSet perm, int organizationId, int geographyId, Authorization.Flag flags)
{
return Authorization.CheckAuthorization(perm, organizationId, geographyId, this, flags);
}
public Organizations OrganisationsWithPermission (Permission perm, RoleType[] roles)
{
Organizations orgList = GetOrganizations(roles);
Organizations retList = new Organizations();
foreach (Organization org in orgList)
{
if (HasPermission(perm, org.Identity, -1, Authorization.Flag.Default))
if (!retList.Contains(org))
retList.Add(org);
}
return retList;
}
}
}