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()); }