public override void SetUp()
{
base.SetUp();
_handle = DomainObjectIDs.Order1.GetHandle <Order>();
_converter = new DomainObjectHandleConverter();
}
public DomainObjectHandleParameterTestTransactedFunction(
ITransactionMode transactionMode,
Action <WxeContext, DomainObjectHandleParameterTestTransactedFunction> testDelegate,
IDomainObjectHandle <SampleObject> inParameter)
: base(transactionMode, (ctx, f) => testDelegate(ctx, (DomainObjectHandleParameterTestTransactedFunction)f), inParameter)
{
}
public AccessType[] GetAccessTypes(IDomainObjectHandle <AccessControlList> aclHandle, SecurityToken token)
{
ArgumentUtility.CheckNotNull("aclHandle", aclHandle);
ArgumentUtility.CheckNotNull("token", token);
using (SecurityFreeSection.Activate())
{
using (ClientTransaction.CreateRootTransaction().EnterDiscardingScope())
{
using (StopwatchScope.CreateScope(
s_log,
LogLevel.Info,
string.Format(
"Evaluated access types of ACL '{0}' for principal '{1}'. Time taken: {{elapsed:ms}}ms",
aclHandle.ObjectID,
token.Principal.User != null ? token.Principal.User.ObjectID.ToString() : "<unknown>")))
{
LoadAccessTypeDefinitions();
var acl = LoadAccessControlList(aclHandle);
var accessInformation = acl.GetAccessTypes(token);
return(Array.ConvertAll(accessInformation.AllowedAccessTypes, ConvertToAccessType));
}
}
}
}
protected void StubClassDefinition <TClass> (
[CanBeNull] IDomainObjectHandle <StatelessAccessControlList> statelessAcl,
[NotNull] params StatefulAccessControlListData[] statefulAcls)
where TClass : ISecurableObject
{
_securityContextRepositoryStub.Stub(_ => _.GetClass(TypeUtility.GetPartialAssemblyQualifiedName(typeof(TClass))))
.Return(new SecurableClassDefinitionData(null, statelessAcl, statefulAcls));
}
public override void SetUp()
{
base.SetUp();
_orderHandle1 = DomainObjectIDs.Order1.GetHandle <Order>();
_orderHandle2 = DomainObjectIDs.Order2.GetHandle <Order> ();
_notFoundOrderHandle = new ObjectID(typeof(Order), Guid.NewGuid()).GetHandle <Order>();
_clientTransaction = ClientTransaction.CreateRootTransaction();
}
public static IQueryable <Group> FindByTenant(IDomainObjectHandle <Tenant> tenantHandle)
{
ArgumentUtility.CheckNotNull("tenantHandle", tenantHandle);
return(from g in QueryFactory.CreateLinqQuery <Group>()
where g.Tenant.ID == tenantHandle.ObjectID
orderby g.Name, g.ShortName
select g);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_dbFixtures = new DatabaseFixtures();
Tenant tenant = _dbFixtures.CreateAndCommitOrganizationalStructureWithTwoTenants(ClientTransaction.CreateRootTransaction());
_expectedTenantHandle = tenant.GetHandle();
}
public ISecurityManagerPrincipal Create(
IDomainObjectHandle <Tenant> tenantHandle,
IDomainObjectHandle <User> userHandle,
IDomainObjectHandle <Substitution> substitutionHandle)
{
ArgumentUtility.CheckNotNull("tenantHandle", tenantHandle);
ArgumentUtility.CheckNotNull("userHandle", userHandle);
return(new SecurityManagerPrincipal(tenantHandle, userHandle, substitutionHandle));
}
protected OrganizationalStructureObjectProxy(IDomainObjectHandle <T> handle, string uniqueIdentifier, string displayName)
{
ArgumentUtility.CheckNotNull("handle", handle);
ArgumentUtility.CheckNotNullOrEmpty("uniqueIdentifier", uniqueIdentifier);
ArgumentUtility.CheckNotNullOrEmpty("displayName", displayName);
_handle = handle;
_uniqueIdentifier = uniqueIdentifier;
_displayName = displayName;
}
public State(IDomainObjectHandle <StatePropertyDefinition> propertyHandle, string propertyName, string value)
{
ArgumentUtility.CheckNotNull("propertyHandle", propertyHandle);
ArgumentUtility.CheckNotNullOrEmpty("propertyName", propertyName);
ArgumentUtility.CheckNotNullOrEmpty("value", value);
_propertyHandle = propertyHandle;
_propertyName = propertyName;
_value = value;
}
public SecurableClassDefinitionData(
[CanBeNull] string baseClass,
[CanBeNull] IDomainObjectHandle <StatelessAccessControlList> statelessAccessControlList,
IEnumerable <StatefulAccessControlListData> statefulAccessControlLists)
{
ArgumentUtility.CheckNotNull("statefulAccessControlLists", statefulAccessControlLists);
_baseClass = baseClass;
_statelessAccessControlList = statelessAccessControlList;
_statefulAccessControlLists = statefulAccessControlLists.ToArray().AsReadOnly();
}
public override void SetUp()
{
base.SetUp();
SecurityManagerPrincipal.Current = SecurityManagerPrincipal.Null;
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
User user = User.FindByUserName("substituting.user");
_userHandle = user.GetHandle();
_tenantHandle = user.Tenant.GetHandle();
_substitutionIDs = user.GetActiveSubstitutions().Select(s => s.ID).ToArray();
Assert.That(_substitutionIDs.Length, Is.EqualTo(2));
}
public override void SetUp()
{
base.SetUp();
SecurityManagerPrincipal.Current = SecurityManagerPrincipal.Null;
ClientTransaction.CreateRootTransaction().EnterNonDiscardingScope();
User user = User.FindByUserName("substituting.user");
_userHandle = user.GetHandle();
_rootTenantHandle = user.Tenant.GetHandle();
_childTenantHandle = user.Tenant.Children.Single().GetHandle();
_grandChildTenantHandle = user.Tenant.Children.Single().Children.Single().GetHandle();
}
public StatefulAccessControlListData([NotNull] IDomainObjectHandle <StatefulAccessControlList> handle, [NotNull] IEnumerable <State> states)
{
ArgumentUtility.CheckNotNull("handle", handle);
ArgumentUtility.CheckNotNull("states", states);
var stateArray = states.ToArray().AsReadOnly();
if (stateArray.Select(s => s.PropertyHandle).Distinct().Count() != stateArray.Count)
{
throw new ArgumentException("Multiple state values found for a single state property.", "states");
}
_handle = handle;
_states = stateArray;
}
public SecurityToken(
[NotNull] Principal principal,
[CanBeNull] IDomainObjectHandle <Tenant> owningTenant,
[CanBeNull] IDomainObjectHandle <Group> owningGroup,
[CanBeNull] IDomainObjectHandle <User> owningUser,
[NotNull] IEnumerable <IDomainObjectHandle <AbstractRoleDefinition> > abstractRoles)
{
ArgumentUtility.CheckNotNull("principal", principal);
ArgumentUtility.CheckNotNull("abstractRoles", abstractRoles);
_principal = principal;
_owningTenant = owningTenant;
_owningGroup = owningGroup;
_owningUser = owningUser;
_abstractRoles = abstractRoles.ToList().AsReadOnly();
}
public bool Equals(IDomainObjectHandle <IDomainObject> other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
if (GetType() != other.GetType())
{
return(false);
}
return(Equals(_objectID, other.ObjectID));
}
private bool MatchPrincipalAgainstUser(Principal principal, IDomainObjectHandle <User> referenceUser)
{
// User is only compared using the DomainObjectHandle to prevent spamming the ClientTransaction with unnecessary User-objects
if (referenceUser == null)
{
return(false);
}
var principalUser = principal.User;
if (principalUser == null)
{
return(false);
}
return(referenceUser.ObjectID.Equals(principalUser.ObjectID));
}
public SecurityManagerPrincipal(
IDomainObjectHandle <Tenant> tenantHandle, IDomainObjectHandle <User> userHandle, IDomainObjectHandle <Substitution> substitutionHandle)
{
ArgumentUtility.CheckNotNull("tenantHandle", tenantHandle);
ArgumentUtility.CheckNotNull("userHandle", userHandle);
_tenantHandle = tenantHandle;
_userHandle = userHandle;
_substitutionHandle = substitutionHandle;
_revision = GetRevision();
var transaction = CreateClientTransaction();
_tenantProxy = CreateTenantProxy(GetTenant(transaction));
_userProxy = CreateUserProxy(GetUser(transaction));
var substitution = GetSubstitution(transaction);
_substitutionProxy = substitution != null?CreateSubstitutionProxy(substitution) : null;
_securityPrincipal = CreateSecurityPrincipal(transaction);
}
private AccessControlList LoadAccessControlList(IDomainObjectHandle <AccessControlList> aclHandle)
{
using (StopwatchScope.CreateScope(
s_log,
LogLevel.Debug,
"Fetched ACL '" + aclHandle.ObjectID + "' for AccessResolver. Time taken: {elapsed:ms}ms"))
{
var queryTemplate = s_queryCache.GetQuery <AccessControlList> (
MethodInfo.GetCurrentMethod().Name,
acls => acls.Where(o => s_aclParameter.Equals(o.ID.Value))
.Select(o => o)
.FetchMany(o => o.AccessControlEntries)
.ThenFetchMany(ace => ace.GetPermissionsForQuery()));
var query = queryTemplate.CreateCopyFromTemplate(new Dictionary <object, object> {
{ s_aclParameter, aclHandle.ObjectID.Value }
});
return(ClientTransaction.Current.QueryManager.GetCollection <AccessControlList> (query)
.AsEnumerable()
.Single(() => new ObjectsNotFoundException(EnumerableUtility.Singleton(aclHandle.ObjectID))));
}
}
public EditPositionFormFunction(ITransactionMode transactionMode, [CanBeNull] IDomainObjectHandle <Position> currentObjectHandle)
: base(transactionMode, currentObjectHandle)
{
}
private bool Equals(IDomainObjectHandle <DomainObject> x, IDomainObjectHandle <DomainObject> y)
{
return(x.ObjectID.Equals(y.ObjectID));
}
protected FormFunction(ITransactionMode transactionMode, IDomainObjectHandle <T> currentObjectHandle)
: base(transactionMode, currentObjectHandle)
{
}
private void StubClassDefinition <TClass> ([CanBeNull] IDomainObjectHandle <StatelessAccessControlList> statelessAcl)
where TClass : ISecurableObject
{
StubClassDefinition <TClass> (statelessAcl, CreateStatefulAcl());
}
