inteligr8/alfresco-community-repo
1
0
Fork 0
mirror of https://github.com/Alfresco/alfresco-community-repo.git synced 2025-07-24 17:32:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Schema changes and ID-based node storage

Browse Source 
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@2727 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
Derek Hulley
2006-04-28 12:54:29 +00:00
parent 2b251c922b
commit 7edcb18bc0
64 changed files with 2798 additions and 2820 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
source/java/org/alfresco/repo/security/permissions/impl/AbstractPermissionEntry.java
View File

@@ -44,10 +44,8 @@ public abstract class AbstractPermissionEntry implements PermissionEntry
return false;
}
AbstractPermissionEntry other = (AbstractPermissionEntry) o;
return EqualsHelper.nullSafeEquals(this.getNodeRef(),
other.getNodeRef())
&& EqualsHelper.nullSafeEquals(this.getPermissionReference(),
other.getPermissionReference())
return EqualsHelper.nullSafeEquals(this.getNodeRef(), other.getNodeRef())
&& EqualsHelper.nullSafeEquals(this.getPermissionReference(), other.getPermissionReference())
&& EqualsHelper.nullSafeEquals(this.getAuthority(), other.getAuthority())
&& EqualsHelper.nullSafeEquals(this.getAccessStatus(), other.getAccessStatus());
}

10
source/java/org/alfresco/repo/security/permissions/impl/AbstractPermissionTest.java
View File

@@ -136,7 +136,15 @@ public class AbstractPermissionTest extends BaseSpringTest
protected void onTearDownInTransaction() throws Exception
{
flushAndClear();
try
{
flushAndClear();
}
catch (Throwable e)
{
// don't absorb the exception
e.printStackTrace();
}
super.onTearDownInTransaction();
}

53
source/java/org/alfresco/repo/security/permissions/impl/PermissionServiceImpl.java
View File

@@ -73,7 +73,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
/*
* Access to permissions
*/
private PermissionsDAO permissionsDAO;
private PermissionsDaoComponent permissionsDaoComponent;
/*
* Access to the node service
@@ -127,9 +127,9 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
this.nodeService = nodeService;
}
public void setPermissionsDAO(PermissionsDAO permissionsDAO)
public void setPermissionsDaoComponent(PermissionsDaoComponent permissionsDaoComponent)
{
this.permissionsDAO = permissionsDAO;
this.permissionsDaoComponent = permissionsDaoComponent;
}
public void setAuthenticationComponent(AuthenticationComponent authenticationComponent)
@@ -171,7 +171,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
{
throw new IllegalArgumentException("Property 'nodeService' has not been set");
}
if (permissionsDAO == null)
if (permissionsDaoComponent == null)
{
throw new IllegalArgumentException("Property 'permissionsDAO' has not been set");
}
@@ -332,7 +332,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
public NodePermissionEntry getSetPermissions(NodeRef nodeRef)
{
return permissionsDAO.getPermissions(nodeRef);
return permissionsDaoComponent.getPermissions(nodeRef);
}
public AccessStatus hasPermission(NodeRef nodeRef, PermissionReference perm)
@@ -469,55 +469,60 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
public void deletePermissions(NodeRef nodeRef)
{
permissionsDAO.deletePermissions(nodeRef);
permissionsDaoComponent.deletePermissions(nodeRef);
accessCache.clear();
}
public void deletePermissions(NodePermissionEntry nodePermissionEntry)
{
permissionsDAO.deletePermissions(nodePermissionEntry);
permissionsDaoComponent.deletePermissions(nodePermissionEntry.getNodeRef());
accessCache.clear();
}
/**
* @see #deletePermission(NodeRef, String, PermissionReference)
*/
public void deletePermission(PermissionEntry permissionEntry)
{
permissionsDAO.deletePermissions(permissionEntry);
accessCache.clear();
NodeRef nodeRef = permissionEntry.getNodeRef();
String authority = permissionEntry.getAuthority();
PermissionReference permission = permissionEntry.getPermissionReference();
deletePermission(nodeRef, authority, permission);
}
public void deletePermission(NodeRef nodeRef, String authority, PermissionReference perm, boolean allow)
public void deletePermission(NodeRef nodeRef, String authority, PermissionReference perm)
{
permissionsDAO.deletePermissions(nodeRef, authority, perm, allow);
permissionsDaoComponent.deletePermission(nodeRef, authority, perm);
accessCache.clear();
}
public void clearPermission(NodeRef nodeRef, String authority)
{
permissionsDAO.clearPermission(nodeRef, authority);
permissionsDaoComponent.deletePermissions(nodeRef, authority);
accessCache.clear();
}
public void setPermission(NodeRef nodeRef, String authority, PermissionReference perm, boolean allow)
{
permissionsDAO.setPermission(nodeRef, authority, perm, allow);
permissionsDaoComponent.setPermission(nodeRef, authority, perm, allow);
accessCache.clear();
}
public void setPermission(PermissionEntry permissionEntry)
{
permissionsDAO.setPermission(permissionEntry);
permissionsDaoComponent.setPermission(permissionEntry);
accessCache.clear();
}
public void setPermission(NodePermissionEntry nodePermissionEntry)
{
permissionsDAO.setPermission(nodePermissionEntry);
permissionsDaoComponent.setPermission(nodePermissionEntry);
accessCache.clear();
}
public void setInheritParentPermissions(NodeRef nodeRef, boolean inheritParentPermissions)
{
permissionsDAO.setInheritParentPermissions(nodeRef, inheritParentPermissions);
permissionsDaoComponent.setInheritParentPermissions(nodeRef, inheritParentPermissions);
accessCache.clear();
}
@@ -526,7 +531,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
*/
public boolean getInheritParentPermissions(NodeRef nodeRef)
{
return permissionsDAO.getInheritParentPermissions(nodeRef);
return permissionsDaoComponent.getInheritParentPermissions(nodeRef);
}
@@ -567,9 +572,9 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
return modelDAO.getExposedPermissions(nodeRef);
}
public void deletePermission(NodeRef nodeRef, String authority, String perm, boolean allow)
public void deletePermission(NodeRef nodeRef, String authority, String perm)
{
deletePermission(nodeRef, authority, getPermissionReference(perm), allow);
deletePermission(nodeRef, authority, getPermissionReference(perm));
}
public AccessStatus hasPermission(NodeRef nodeRef, String perm)
@@ -584,7 +589,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
public void deletePermissions(String recipient)
{
permissionsDAO.deleteAllPermissionsForAuthority(recipient);
permissionsDaoComponent.deletePermissions(recipient);
accessCache.clear();
}
@@ -748,7 +753,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
if (car.getParentRef() != null)
{
NodePermissionEntry nodePermissions = permissionsDAO.getPermissions(car.getChildRef());
NodePermissionEntry nodePermissions = permissionsDaoComponent.getPermissions(car.getChildRef());
if ((nodePermissions == null) || (nodePermissions.inheritPermissions()))
{
@@ -848,7 +853,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
// Build the next element of the evaluation chain
if (car.getParentRef() != null)
{
NodePermissionEntry nodePermissions = permissionsDAO.getPermissions(car.getChildRef());
NodePermissionEntry nodePermissions = permissionsDaoComponent.getPermissions(car.getChildRef());
if ((nodePermissions == null) || (nodePermissions.inheritPermissions()))
{
car = nodeService.getPrimaryParent(car.getParentRef());
@@ -900,7 +905,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
Set<Pair<String, PermissionReference>> deniedSet = new HashSet<Pair<String, PermissionReference>>();
// Loop over all denied permissions
NodePermissionEntry nodeEntry = permissionsDAO.getPermissions(nodeRef);
NodePermissionEntry nodeEntry = permissionsDaoComponent.getPermissions(nodeRef);
if (nodeEntry != null)
{
for (PermissionEntry pe : nodeEntry.getPermissionEntries())
@@ -950,7 +955,7 @@ public class PermissionServiceImpl implements PermissionServiceSPI, Initializing
*/
boolean checkRequired(Set<String> authorisations, NodeRef nodeRef, Set<Pair<String, PermissionReference>> denied)
{
NodePermissionEntry nodeEntry = permissionsDAO.getPermissions(nodeRef);
NodePermissionEntry nodeEntry = permissionsDaoComponent.getPermissions(nodeRef);
// No permissions set - short cut to deny
if (nodeEntry == null)

494
source/java/org/alfresco/repo/security/permissions/impl/PermissionServiceTest.java
View File

@@ -32,6 +32,14 @@ import org.alfresco.service.namespace.QName;
public class PermissionServiceTest extends AbstractPermissionTest
{
private SimplePermissionEntry denyAndyAll;
private SimplePermissionEntry allowAndyAll;
private SimplePermissionEntry denyAndyRead;
private SimplePermissionEntry allowAndyRead;
private SimplePermissionEntry denyAndyReadProperties;
private SimplePermissionEntry allowAndyReadProperties;
private SimplePermissionEntry allowAndyReadChildren;
public PermissionServiceTest()
{
super();
@@ -51,9 +59,48 @@ public class PermissionServiceTest extends AbstractPermissionTest
}
fail("Missing role ROLE_AUTHENTICATED ");
}
@Override
protected void onSetUpInTransaction() throws Exception
{
super.onSetUpInTransaction();
denyAndyAll = new SimplePermissionEntry(
rootNodeRef,
permissionService.getAllPermissionReference(),
"andy",
AccessStatus.DENIED);
allowAndyAll = new SimplePermissionEntry(
rootNodeRef,
permissionService.getAllPermissionReference(),
"andy",
AccessStatus.ALLOWED);
denyAndyRead = new SimplePermissionEntry(
rootNodeRef,
getPermission(PermissionService.READ),
"andy",
AccessStatus.DENIED);
allowAndyRead = new SimplePermissionEntry(
rootNodeRef,
getPermission(PermissionService.READ),
"andy",
AccessStatus.ALLOWED);
denyAndyReadProperties = new SimplePermissionEntry(
rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES),
"andy",
AccessStatus.DENIED);
allowAndyReadProperties = new SimplePermissionEntry(
rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES),
"andy",
AccessStatus.ALLOWED);
allowAndyReadChildren = new SimplePermissionEntry(
rootNodeRef,
getPermission(PermissionService.READ_CHILDREN),
"andy",
AccessStatus.ALLOWED);
}
public void testSetInheritFalse()
{
runAs("andy");
@@ -137,6 +184,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
public void testSetPermissionEntryElements()
{
// add andy-all (allow)
permissionService.setPermission(rootNodeRef, "andy", permissionService.getAllPermission(), true);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
@@ -153,70 +201,59 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertEquals(rootNodeRef, pe.getNodeRef());
}
// Set duplicate
// add andy-all (allow)
permissionService.setPermission(rootNodeRef, "andy", permissionService.getAllPermission(), true);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(1, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// Set new
// add other-all (allow)
permissionService.setPermission(rootNodeRef, "other", permissionService.getAllPermission(), true);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(2, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// Add deny
// add andy-all (deny)
permissionService.setPermission(rootNodeRef, "andy", permissionService.getAllPermission(), false);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(3, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// new
permissionService.setPermission(rootNodeRef, "andy", PermissionService.READ, false);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(4, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// delete
permissionService.deletePermission(rootNodeRef, "andy", PermissionService.READ, false);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(3, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(rootNodeRef, "andy", permissionService.getAllPermission(), false);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(2, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(rootNodeRef, "other", permissionService.getAllPermission(), true);
// add andy-read (deny)
permissionService.setPermission(rootNodeRef, "andy", PermissionService.READ, false);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(3, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// remove andy-read
permissionService.deletePermission(rootNodeRef, "andy", PermissionService.READ);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(2, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// remove andy-all
permissionService.deletePermission(rootNodeRef, "andy", permissionService.getAllPermission());
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(1, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(rootNodeRef, "andy", permissionService.getAllPermission(), true);
// remove other-all
permissionService.deletePermission(rootNodeRef, "other", permissionService.getAllPermission());
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(0, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
}
public void testSetPermissionEntry()
{
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyAll);
permissionService.setPermission(rootNodeRef, "andy", permissionService.getAllPermission(), true);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
@@ -235,8 +272,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
// Set duplicate
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyAll);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
@@ -253,12 +289,11 @@ public class PermissionServiceTest extends AbstractPermissionTest
// Deny
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyAll);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(3, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
assertEquals(2, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// new
@@ -267,31 +302,30 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(4, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
assertEquals(3, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef, new SimplePermissionReference(QName
.createQName("A", "B"), "C"), "andy", AccessStatus.DENIED));
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(3, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.DENIED));
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(2, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "other", AccessStatus.ALLOWED));
permissionService.deletePermission(denyAndyAll);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(1, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.ALLOWED));
.getAllPermissionReference(), "other", AccessStatus.ALLOWED));
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
assertEquals(0, permissionService.getSetPermissions(rootNodeRef).getPermissionEntries().size());
// delete when we know there's nothing do delete
permissionService.deletePermission(allowAndyAll);
assertNotNull(permissionService.getSetPermissions(rootNodeRef));
assertTrue(permissionService.getSetPermissions(rootNodeRef).inheritPermissions());
assertEquals(rootNodeRef, permissionService.getSetPermissions(rootNodeRef).getNodeRef());
@@ -356,7 +390,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
@@ -364,33 +398,17 @@ public class PermissionServiceTest extends AbstractPermissionTest
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
assertEquals(0, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -476,8 +494,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertEquals(0, permissionService.getAllSetPermissions(rootNodeRef).size());
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyRead);
runAs("andy");
assertEquals(25, permissionService.getPermissions(rootNodeRef).size());
@@ -494,78 +511,20 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
runAs("andy");
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
runAs("andy");
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
runAs("andy");
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
runAs("andy");
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), "andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyRead);
runAs("andy");
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), "andy", AccessStatus.ALLOWED));
permissionService.deletePermission(allowAndyRead);
runAs("andy");
assertEquals(0, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
@@ -595,8 +554,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertEquals(0, permissionService.getAllSetPermissions(rootNodeRef).size());
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyReadProperties);
runAs("andy");
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -607,8 +565,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_CHILDREN), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyReadChildren);
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -617,58 +574,16 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
assertEquals(3, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
assertEquals(3, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
assertEquals(3, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
assertEquals(3, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyReadProperties);
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
permissionService.deletePermission(allowAndyReadChildren);
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -676,6 +591,15 @@ public class PermissionServiceTest extends AbstractPermissionTest
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.deletePermission(allowAndyReadProperties);
assertEquals(0, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
}
public void testPermissionGroupSimpleInheritance()
@@ -704,8 +628,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyRead);
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -725,8 +648,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyRead);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -746,92 +668,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), "andy", AccessStatus.DENIED));
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(n1, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), "andy", AccessStatus.ALLOWED));
permissionService.deletePermission(allowAndyRead);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -859,29 +696,19 @@ public class PermissionServiceTest extends AbstractPermissionTest
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyReadProperties);
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyReadProperties);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.ALLOWED));
permissionService.deletePermission(allowAndyReadProperties);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
runAs("lemur");
@@ -902,8 +729,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyRead);
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -915,8 +741,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyRead);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -928,21 +753,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), "andy", AccessStatus.DENIED));
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), "andy", AccessStatus.ALLOWED));
permissionService.deletePermission(allowAndyRead);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -969,8 +780,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyRead);
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -982,8 +792,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_PROPERTIES), "andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyReadProperties);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -995,8 +804,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ_CHILDREN), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyReadChildren);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -1008,8 +816,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyRead);
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -1107,8 +914,8 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
assertEquals(0, permissionService.getAllSetPermissions(rootNodeRef).size());
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.ALLOWED));
permissionService.setPermission(allowAndyAll);
assertEquals(1, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
@@ -1125,8 +932,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyRead);
runAs("andy");
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
@@ -1143,9 +949,8 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.DENIED));
assertEquals(3, permissionService.getAllSetPermissions(rootNodeRef).size());
permissionService.setPermission(denyAndyAll);
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.WRITE)) == AccessStatus.ALLOWED);
@@ -1160,10 +965,8 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
}
public void testOldAllPermissions()
{
runAs("andy");
@@ -1199,8 +1002,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
"andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyRead);
runAs("andy");
assertEquals(2, permissionService.getAllSetPermissions(rootNodeRef).size());
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
@@ -1217,8 +1019,7 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, permissionService
.getAllPermissionReference(), "andy", AccessStatus.DENIED));
permissionService.setPermission(denyAndyAll);
assertEquals(3, permissionService.getAllSetPermissions(rootNodeRef).size());
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
@@ -1234,13 +1035,10 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
}
public void testAuthenticatedAuthority()
{
runAs("andy");
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
@@ -1278,19 +1076,6 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), ROLE_AUTHENTICATED, AccessStatus.DENIED));
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), ROLE_AUTHENTICATED, AccessStatus.ALLOWED));
runAs("andy");
@@ -1345,19 +1130,6 @@ public class PermissionServiceTest extends AbstractPermissionTest
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertFalse(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), permissionService.getAllAuthorities(), AccessStatus.DENIED));
runAs("andy");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
runAs("lemur");
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_PROPERTIES)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CHILDREN)) == AccessStatus.ALLOWED);
assertTrue(permissionService.hasPermission(rootNodeRef, getPermission(PermissionService.READ_CONTENT)) == AccessStatus.ALLOWED);
permissionService.deletePermission(new SimplePermissionEntry(rootNodeRef,
getPermission(PermissionService.READ), permissionService.getAllAuthorities(), AccessStatus.ALLOWED));
runAs("andy");

57
source/java/org/alfresco/repo/security/permissions/impl/PermissionsDAO.java → source/java/org/alfresco/repo/security/permissions/impl/PermissionsDaoComponent.java
View File

@@ -26,7 +26,7 @@ import org.alfresco.service.cmr.repository.NodeRef;
*
* @author andyh
*/
public interface PermissionsDAO
public interface PermissionsDaoComponent
{
/**
* Get the permissions that have been set on a given node.
@@ -37,42 +37,36 @@ public interface PermissionsDAO
public NodePermissionEntry getPermissions(NodeRef nodeRef);
/**
* Delete all the permissions on a given node.
* The node permission and all the permission entries it contains will be deleted.
* Delete the access control list and all access control entries for the node.
*
* @param nodeRef
* @param nodeRef the node for which to delete permission
*/
public void deletePermissions(NodeRef nodeRef);
/**
* Delete all the permissions on a given node.
* The node permission and all the permission entries it contains will be deleted.
*
* @param nodePermissionEntry
* Remove all permissions for the specvified authority
* @param authority
*/
public void deletePermissions(NodePermissionEntry nodePermissionEntry);
public void deletePermissions(String authority);
/**
* Delete permission entries for the given node and authority
*
* @param nodeRef the node to query against
* @param authority the specific authority to query against
*/
public void deletePermissions(NodeRef nodeRef, String authority);
/**
* Delete as single permission entry.
* This deleted one permission on the node. It does not affect the persistence of any other permissions.
*
* @param permissionEntry
*/
public void deletePermissions(PermissionEntry permissionEntry);
/**
*
* Delete as single permission entry, if a match is found.
* This deleted one permission on the node. It does not affect the persistence of any other permissions.
*
* @param nodeRef
* @param authority
* @param perm
* @param allow
* @param nodeRef the node with the access control list
* @param authority the specific authority to look for
* @param permission the permission to look for
*/
public void deletePermissions(NodeRef nodeRef, String authority, PermissionReference perm, boolean allow);
public void deletePermission(NodeRef nodeRef, String authority, PermissionReference permission);
/**
* Set a permission on a node.
* If the node has no permissions set then a default node permission (allowing inheritance) will be created to
@@ -114,19 +108,4 @@ public interface PermissionsDAO
* @return inheritParentPermissions
*/
public boolean getInheritParentPermissions(NodeRef nodeRef);
/**
* Clear all the permissions set for a given authentication
*
* @param nodeRef
* @param authority
*/
public void clearPermission(NodeRef nodeRef, String authority);
/**
* Remove all permissions for the specvified authority
* @param authority
*/
public void deleteAllPermissionsForAuthority(String authority);
}

255
source/java/org/alfresco/repo/security/permissions/impl/hibernate/HibernatePermissionTest.java
View File

@@ -18,17 +18,36 @@ package org.alfresco.repo.security.permissions.impl.hibernate;
import java.io.Serializable;
import org.alfresco.repo.domain.NodeKey;
import org.alfresco.repo.domain.DbAccessControlEntry;
import org.alfresco.repo.domain.DbAccessControlList;
import org.alfresco.repo.domain.DbAuthority;
import org.alfresco.repo.domain.DbPermission;
import org.alfresco.repo.domain.Node;
import org.alfresco.repo.domain.Store;
import org.alfresco.repo.domain.hibernate.DbAccessControlEntryImpl;
import org.alfresco.repo.domain.hibernate.DbAccessControlListImpl;
import org.alfresco.repo.domain.hibernate.DbAuthorityImpl;
import org.alfresco.repo.domain.hibernate.DbPermissionImpl;
import org.alfresco.repo.node.db.NodeDaoService;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.namespace.NamespaceService;
import org.alfresco.service.namespace.QName;
import org.alfresco.util.BaseSpringTest;
import org.alfresco.util.GUID;
import org.hibernate.ObjectDeletedException;
/**
* Test persistence and retrieval of Hibernate-specific implementations of the
* {@link org.alfresco.repo.domain.Node} interface
* @see org.alfresco.repo.domain.hibernate.PermissionsDaoComponentImpl
* @see org.alfresco.repo.domain.DbAccessControlList
* @see org.alfresco.repo.domain.DbAccessControlEntry
*
* @author Andy Hind
*/
public class HibernatePermissionTest extends BaseSpringTest
{
{
private NodeDaoService nodeDaoService;
private Node node;
private QName qname;
public HibernatePermissionTest()
{
@@ -36,174 +55,172 @@ public class HibernatePermissionTest extends BaseSpringTest
protected void onSetUpInTransaction() throws Exception
{
nodeDaoService = (NodeDaoService) applicationContext.getBean("nodeDaoService");
// create the node to play with
Store store = nodeDaoService.createStore(
StoreRef.PROTOCOL_WORKSPACE,
getName() + "_" + System.currentTimeMillis());
qname = QName.createQName(NamespaceService.ALFRESCO_URI, getName());
node = nodeDaoService.newNode(
store,
GUID.generate(),
qname);
}
protected void onTearDownInTransaction()
{
// force a flush to ensure that the database updates succeed
getSession().flush();
getSession().clear();
try
{
// force a flush to ensure that the database updates succeed
getSession().flush();
getSession().clear();
}
catch (Throwable e)
{
// don't mask any other exception coming through
e.printStackTrace();
}
}
public void testSimpleNodePermission() throws Exception
public void testSimpleAccessControlList() throws Exception
{
// create a new Node
NodePermissionEntry nodePermission = new NodePermissionEntryImpl();
NodeKey key = new NodeKey("Random Protocol", "Random Identifier", "AAA");
nodePermission.setNodeKey(key);
nodePermission.setInherits(true);
DbAccessControlList accessControlList = new DbAccessControlListImpl();
accessControlList.setNode(node);
accessControlList.setInherits(true);
Serializable id = getSession().save(nodePermission);
Serializable id = getSession().save(accessControlList);
// throw the reference away and get the a new one for the id
nodePermission = (NodePermissionEntry) getSession().load(NodePermissionEntryImpl.class, id);
assertNotNull("Node not found", nodePermission);
assertTrue(nodePermission.getInherits());
accessControlList = (DbAccessControlList) getSession().load(DbAccessControlListImpl.class, id);
assertNotNull("Access control list not found", accessControlList);
assertTrue(accessControlList.getInherits());
// Update inherits
nodePermission.setInherits(false);
id = getSession().save(nodePermission);
accessControlList.setInherits(false);
id = getSession().save(accessControlList);
// throw the reference away and get the a new one for the id
nodePermission = (NodePermissionEntry) getSession().load(NodePermissionEntryImpl.class, id);
assertNotNull("Node not found", nodePermission);
assertFalse(nodePermission.getInherits());
accessControlList = (DbAccessControlList) getSession().load(DbAccessControlListImpl.class, id);
assertNotNull("Node not found", accessControlList);
assertFalse(accessControlList.getInherits());
}
public void testSimplePermissionReference()
public void testSimplePermission()
{
PermissionReference permissionReference = new PermissionReferenceImpl();
permissionReference.setName("Test");
permissionReference.setTypeUri("TestUri");
permissionReference.setTypeName("TestName");
DbPermission permission = new DbPermissionImpl();
permission.setTypeQname(qname);
permission.setName("Test");
Serializable id = getSession().save(permissionReference);
Serializable id = getSession().save(permission);
// throw the reference away and get the a new one for the id
permissionReference = (PermissionReference) getSession().load(PermissionReferenceImpl.class, id);
assertNotNull("Node not found", permissionReference);
assertEquals("Test", permissionReference.getName());
assertEquals("TestUri", permissionReference.getTypeUri());
assertEquals("TestName", permissionReference.getTypeName());
permission = (DbPermission) getSession().load(DbPermissionImpl.class, id);
assertNotNull("Permission not found", permission);
assertEquals("Test", permission.getName());
assertEquals(qname, permission.getTypeQname());
// Test key
PermissionReference key = new PermissionReferenceImpl();
key.setName("Test");
key.setTypeUri("TestUri");
key.setTypeName("TestName");
permissionReference = (PermissionReference) getSession().load(PermissionReferenceImpl.class, key);
assertNotNull("Node not found", permissionReference);
assertEquals("Test", permissionReference.getName());
assertEquals("TestUri", permissionReference.getTypeUri());
assertEquals("TestName", permissionReference.getTypeName());
permission = (DbPermission) getSession().load(DbPermissionImpl.class, id);
assertNotNull("Permission not found", permission);
assertEquals("Test", permission.getName());
assertEquals(qname, permission.getTypeQname());
}
public void testSimpleRecipient()
public void testSimpleAuthority()
{
Recipient recipient = new RecipientImpl();
recipient.setRecipient("Test");
recipient.getExternalKeys().add("One");
DbAuthority authority = new DbAuthorityImpl();
authority.setRecipient("Test");
authority.getExternalKeys().add("One");
Serializable id = getSession().save(recipient);
Serializable id = getSession().save(authority);
// throw the reference away and get the a new one for the id
recipient = (Recipient) getSession().load(RecipientImpl.class, id);
assertNotNull("Node not found", recipient);
assertEquals("Test", recipient.getRecipient());
assertEquals(1, recipient.getExternalKeys().size());
// Key
Recipient key = new RecipientImpl();
key.setRecipient("Test");
recipient = (Recipient) getSession().load(RecipientImpl.class, key);
assertNotNull("Node not found", recipient);
assertEquals("Test", recipient.getRecipient());
assertEquals(1, recipient.getExternalKeys().size());
authority = (DbAuthority) getSession().load(DbAuthorityImpl.class, id);
assertNotNull("Node not found", authority);
assertEquals("Test", authority.getRecipient());
assertEquals(1, authority.getExternalKeys().size());
// Update
recipient.getExternalKeys().add("Two");
id = getSession().save(recipient);
authority.getExternalKeys().add("Two");
id = getSession().save(authority);
// throw the reference away and get the a new one for the id
recipient = (Recipient) getSession().load(RecipientImpl.class, id);
assertNotNull("Node not found", recipient);
assertEquals("Test", recipient.getRecipient());
assertEquals(2, recipient.getExternalKeys().size());
authority = (DbAuthority) getSession().load(DbAuthorityImpl.class, id);
assertNotNull("Node not found", authority);
assertEquals("Test", authority.getRecipient());
assertEquals(2, authority.getExternalKeys().size());
// complex
recipient.getExternalKeys().add("Three");
recipient.getExternalKeys().remove("One");
recipient.getExternalKeys().remove("Two");
id = getSession().save(recipient);
authority.getExternalKeys().add("Three");
authority.getExternalKeys().remove("One");
authority.getExternalKeys().remove("Two");
id = getSession().save(authority);
// Throw the reference away and get the a new one for the id
recipient = (Recipient) getSession().load(RecipientImpl.class, id);
assertNotNull("Node not found", recipient);
assertEquals("Test", recipient.getRecipient());
assertEquals(1, recipient.getExternalKeys().size());
authority = (DbAuthority) getSession().load(DbAuthorityImpl.class, id);
assertNotNull("Node not found", authority);
assertEquals("Test", authority.getRecipient());
assertEquals(1, authority.getExternalKeys().size());
}
public void testNodePermissionEntry()
public void testAccessControlList()
{
// create a new Node
NodePermissionEntry nodePermission = new NodePermissionEntryImpl();
NodeKey key = new NodeKey("Random Protocol", "Random Identifier", "AAA");
nodePermission.setNodeKey(key);
nodePermission.setInherits(true);
// create a new access control list for the node
DbAccessControlList accessControlList = new DbAccessControlListImpl();
accessControlList.setNode(node);
accessControlList.setInherits(true);
Recipient recipient = new RecipientImpl();
DbAuthority recipient = new DbAuthorityImpl();
recipient.setRecipient("Test");
recipient.getExternalKeys().add("One");
PermissionReference permissionReference = new PermissionReferenceImpl();
permissionReference.setName("Test");
permissionReference.setTypeUri("TestUri");
permissionReference.setTypeName("TestName");
DbPermission permission = new DbPermissionImpl();
permission.setTypeQname(qname);
permission.setName("Test");
PermissionEntry permissionEntry = PermissionEntryImpl.create(nodePermission, permissionReference, recipient, true);
DbAccessControlEntry accessControlEntry = DbAccessControlEntryImpl.create(accessControlList, permission, recipient, true);
Serializable idNodePermision = getSession().save(nodePermission);
Serializable nodeAclId = getSession().save(accessControlList);
getSession().save(recipient);
getSession().save(permissionReference);
Serializable idPermEnt = getSession().save(permissionEntry);
permissionEntry = (PermissionEntry) getSession().load(PermissionEntryImpl.class, idPermEnt);
assertNotNull("Permission entry not found", permissionEntry);
assertTrue(permissionEntry.isAllowed());
assertNotNull(permissionEntry.getNodePermissionEntry());
assertTrue(permissionEntry.getNodePermissionEntry().getInherits());
assertNotNull(permissionEntry.getPermissionReference());
assertEquals("Test", permissionEntry.getPermissionReference().getName());
assertNotNull(permissionEntry.getRecipient());
assertEquals("Test", permissionEntry.getRecipient().getRecipient());
assertEquals(1, permissionEntry.getRecipient().getExternalKeys().size());
// Check traversal down
nodePermission = (NodePermissionEntry) getSession().load(NodePermissionEntryImpl.class, idNodePermision);
assertEquals(1, nodePermission.getPermissionEntries().size());
permissionEntry.delete();
getSession().delete(permissionEntry);
nodePermission = (NodePermissionEntry) getSession().load(NodePermissionEntryImpl.class, idNodePermision);
assertEquals(0, nodePermission.getPermissionEntries().size());
getSession().save(permission);
Serializable aceEntryId = getSession().save(accessControlEntry);
accessControlEntry = (DbAccessControlEntry) getSession().load(DbAccessControlEntryImpl.class, aceEntryId);
assertNotNull("Permission entry not found", accessControlEntry);
assertTrue(accessControlEntry.isAllowed());
assertNotNull(accessControlEntry.getAccessControlList());
assertTrue(accessControlEntry.getAccessControlList().getInherits());
assertNotNull(accessControlEntry.getPermission());
assertEquals("Test", accessControlEntry.getPermission().getName());
assertNotNull(accessControlEntry.getAuthority());
assertEquals("Test", accessControlEntry.getAuthority().getRecipient());
assertEquals(1, accessControlEntry.getAuthority().getExternalKeys().size());
// Check that deletion of the list cascades
getSession().delete(accessControlList);
try
{
getSession().get(DbAccessControlListImpl.class, nodeAclId);
fail("Access control list was not deleted");
}
catch (ObjectDeletedException e)
{
// expected
}
try
{
getSession().get(DbAccessControlEntryImpl.class, aceEntryId);
fail("Access control entries were not cascade deleted");
}
catch (ObjectDeletedException e)
{
// expected
}
}
}

422
source/java/org/alfresco/repo/security/permissions/impl/hibernate/HibernatePermissionsDAO.java
View File

@@ -1,422 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.alfresco.repo.cache.SimpleCache;
import org.alfresco.repo.domain.NodeKey;
import org.alfresco.repo.security.permissions.NodePermissionEntry;
import org.alfresco.repo.security.permissions.PermissionEntry;
import org.alfresco.repo.security.permissions.PermissionReference;
import org.alfresco.repo.security.permissions.impl.PermissionsDAO;
import org.alfresco.repo.security.permissions.impl.SimpleNodePermissionEntry;
import org.alfresco.repo.security.permissions.impl.SimplePermissionEntry;
import org.alfresco.repo.security.permissions.impl.SimplePermissionReference;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.security.AccessStatus;
import org.alfresco.service.namespace.QName;
import org.hibernate.ObjectDeletedException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
/**
* Support for accessing persisted permission information.
*
* This class maps between persisted objects and the external API defined in the
* PermissionsDAO interface.
*
* @author andyh
*/
public class HibernatePermissionsDAO extends HibernateDaoSupport implements PermissionsDAO
{
private SimpleCache<NodeRef, SimpleNodePermissionEntry> nullPermissionCache;
public HibernatePermissionsDAO()
{
super();
}
public void setNullPermissionCache(SimpleCache<NodeRef, SimpleNodePermissionEntry> nullPermissionCache)
{
this.nullPermissionCache = nullPermissionCache;
}
public NodePermissionEntry getPermissions(NodeRef nodeRef)
{
// Create the object if it is not found.
// Null objects are not cached in hibernate
// If the object does not exist it will repeatedly query to check its
// non existence.
NodePermissionEntry npe = nullPermissionCache.get(nodeRef);
if (npe != null)
{
return npe;
}
npe = createSimpleNodePermissionEntry(getHibernateNodePermissionEntry(nodeRef, false));
if (npe == null)
{
SimpleNodePermissionEntry snpe = new SimpleNodePermissionEntry(nodeRef, true, Collections
.<SimplePermissionEntry> emptySet());
npe = snpe;
nullPermissionCache.put(nodeRef, snpe);
}
return npe;
}
/**
* Get the persisted NodePermissionEntry
*
* @param nodeRef
* @param create -
* create the object if it is missing
* @return
*/
private org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry getHibernateNodePermissionEntry(
NodeRef nodeRef, boolean create)
{
// Build the key
NodeKey nodeKey = getNodeKey(nodeRef);
try
{
Object obj = getHibernateTemplate().get(NodePermissionEntryImpl.class, nodeKey);
// Create if required
if ((obj == null) && create)
{
NodePermissionEntryImpl entry = new NodePermissionEntryImpl();
entry.setNodeKey(nodeKey);
entry.setInherits(true);
getHibernateTemplate().save(entry);
nullPermissionCache.remove(nodeRef);
return entry;
}
return (org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry) obj;
}
catch (DataAccessException e)
{
if (e.contains(ObjectDeletedException.class))
{
// the object no loner exists
if (create)
{
NodePermissionEntryImpl entry = new NodePermissionEntryImpl();
entry.setNodeKey(nodeKey);
entry.setInherits(true);
getHibernateTemplate().save(entry);
nullPermissionCache.remove(nodeRef);
return entry;
}
else
{
return null;
}
}
throw e;
}
}
/**
* Get a node key from a node reference
*
* @param nodeRef
* @return
*/
private NodeKey getNodeKey(NodeRef nodeRef)
{
NodeKey nodeKey = new NodeKey(nodeRef.getStoreRef().getProtocol(), nodeRef.getStoreRef().getIdentifier(),
nodeRef.getId());
return nodeKey;
}
public void deletePermissions(NodeRef nodeRef)
{
org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry found = getHibernateNodePermissionEntry(
nodeRef, false);
if (found != null)
{
deleteHibernateNodePermissionEntry(found);
}
}
private void deleteHibernateNodePermissionEntry(
org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry hibernateNodePermissionEntry)
{
deleteHibernatePermissionEntries(hibernateNodePermissionEntry.getPermissionEntries());
getHibernateTemplate().delete(hibernateNodePermissionEntry);
}
private void deleteHibernatePermissionEntries(
Set<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> permissionEntries)
{
// Avoid concurrent access problems during deletion
Set<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> copy = new HashSet<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry>();
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry permissionEntry : copy)
{
deleteHibernatePermissionEntry(permissionEntry);
}
}
private void deleteHibernatePermissionEntry(
org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry permissionEntry)
{
// Unhook bidirectoinal relationships
permissionEntry.delete();
getHibernateTemplate().delete(permissionEntry);
}
public void deletePermissions(NodePermissionEntry nodePermissionEntry)
{
deletePermissions(nodePermissionEntry.getNodeRef());
}
public void deletePermissions(PermissionEntry permissionEntry)
{
org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry found = getHibernateNodePermissionEntry(
permissionEntry.getNodeRef(), false);
if (found != null)
{
Set<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> deletable = new HashSet<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry>();
Set<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> entries = found.getPermissionEntries();
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry current : entries)
{
if (permissionEntry.equals(createSimplePermissionEntry(current)))
{
deletable.add(current);
}
}
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry current : deletable)
{
deleteHibernatePermissionEntry(current);
}
}
}
public void clearPermission(NodeRef nodeRef, String authority)
{
org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry found = getHibernateNodePermissionEntry(
nodeRef, false);
if (found != null)
{
Set<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> deletable = new HashSet<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry>();
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry current : found
.getPermissionEntries())
{
if (createSimplePermissionEntry(current).getAuthority().equals(authority))
{
deletable.add(current);
}
}
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry current : deletable)
{
deleteHibernatePermissionEntry(current);
}
}
}
public void deletePermissions(NodeRef nodeRef, String authority, PermissionReference perm, boolean allow)
{
SimplePermissionEntry spe = new SimplePermissionEntry(nodeRef, perm == null ? null
: new SimplePermissionReference(perm.getQName(), perm.getName()), authority,
allow ? AccessStatus.ALLOWED : AccessStatus.DENIED);
deletePermissions(spe);
}
public void setPermission(NodeRef nodeRef, String authority, PermissionReference perm, boolean allow)
{
deletePermissions(nodeRef, authority, perm, allow);
PermissionEntryImpl entry = PermissionEntryImpl.create(getHibernateNodePermissionEntry(nodeRef, true),
getHibernatePermissionReference(perm, true), getHibernateAuthority(authority, true), allow);
getHibernateTemplate().save(entry);
nullPermissionCache.remove(nodeRef);
}
/**
* Utility method to find or create a persisted authority
*
* @param authority
* @param create
* @return
*/
private Recipient getHibernateAuthority(String authority, boolean create)
{
Recipient key = new RecipientImpl();
key.setRecipient(authority);
Recipient found = (Recipient) getHibernateTemplate().get(RecipientImpl.class, key);
if ((found == null) && create)
{
getHibernateTemplate().save(key);
return key;
}
else
{
return found;
}
}
/**
* Utility method to find and optionally create a persisted permission
* reference.
*
* @param perm
* @param create
* @return
*/
private org.alfresco.repo.security.permissions.impl.hibernate.PermissionReference getHibernatePermissionReference(
PermissionReference perm, boolean create)
{
org.alfresco.repo.security.permissions.impl.hibernate.PermissionReference key = new PermissionReferenceImpl();
key.setTypeUri(perm.getQName().getNamespaceURI());
key.setTypeName(perm.getQName().getLocalName());
key.setName(perm.getName());
org.alfresco.repo.security.permissions.impl.hibernate.PermissionReference found;
found = (org.alfresco.repo.security.permissions.impl.hibernate.PermissionReference) getHibernateTemplate().get(
PermissionReferenceImpl.class, key);
if ((found == null) && create)
{
getHibernateTemplate().save(key);
return key;
}
else
{
return found;
}
}
public void setPermission(PermissionEntry permissionEntry)
{
setPermission(permissionEntry.getNodeRef(), permissionEntry.getAuthority(), permissionEntry
.getPermissionReference(), permissionEntry.isAllowed());
}
public void setPermission(NodePermissionEntry nodePermissionEntry)
{
deletePermissions(nodePermissionEntry);
NodePermissionEntryImpl entry = new NodePermissionEntryImpl();
entry.setInherits(nodePermissionEntry.inheritPermissions());
entry.setNodeKey(getNodeKey(nodePermissionEntry.getNodeRef()));
getHibernateTemplate().save(entry);
nullPermissionCache.remove(nodePermissionEntry.getNodeRef());
for (PermissionEntry pe : nodePermissionEntry.getPermissionEntries())
{
setPermission(pe);
}
}
public void setInheritParentPermissions(NodeRef nodeRef, boolean inheritParentPermissions)
{
getHibernateNodePermissionEntry(nodeRef, true).setInherits(inheritParentPermissions);
}
public boolean getInheritParentPermissions(NodeRef nodeRef)
{
return getHibernateNodePermissionEntry(nodeRef, true).getInherits();
}
@SuppressWarnings("unchecked")
public void deleteAllPermissionsForAuthority(final String authority)
{
HibernateCallback callback = new HibernateCallback()
{
public Object doInHibernate(Session session)
{
Query query = session.getNamedQuery("permission.GetPermissionsForRecipient");
query.setString("recipientKey", authority);
return query.list();
}
};
List<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> queryResults = (List) getHibernateTemplate().execute(callback);
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry current : queryResults)
{
deleteHibernatePermissionEntry(current);
}
}
// Utility methods to create simple detached objects for the outside world
// We do not pass out the hibernate objects
private static SimpleNodePermissionEntry createSimpleNodePermissionEntry(
org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry npe)
{
if (npe == null)
{
return null;
}
SimpleNodePermissionEntry snpe = new SimpleNodePermissionEntry(npe.getNodeRef(), npe.getInherits(),
createSimplePermissionEntries(npe.getPermissionEntries()));
return snpe;
}
private static Set<SimplePermissionEntry> createSimplePermissionEntries(
Set<org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry> nes)
{
if (nes == null)
{
return null;
}
HashSet<SimplePermissionEntry> spes = new HashSet<SimplePermissionEntry>(nes.size(), 1.0f);
if (nes.size() != 0)
{
for (org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry pe : nes)
{
spes.add(createSimplePermissionEntry(pe));
}
}
return spes;
}
private static SimplePermissionEntry createSimplePermissionEntry(
org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry pe)
{
if (pe == null)
{
return null;
}
return new SimplePermissionEntry(pe.getNodePermissionEntry().getNodeRef(), createSimplePermissionReference(pe
.getPermissionReference()), pe.getRecipient().getRecipient(), pe.isAllowed() ? AccessStatus.ALLOWED
: AccessStatus.DENIED);
}
private static SimplePermissionReference createSimplePermissionReference(
org.alfresco.repo.security.permissions.impl.hibernate.PermissionReference pr)
{
if (pr == null)
{
return null;
}
return new SimplePermissionReference(QName.createQName(pr.getTypeUri(), pr.getTypeName()), pr.getName());
}
}

70
source/java/org/alfresco/repo/security/permissions/impl/hibernate/NodePermissionEntry.java
View File

@@ -1,70 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import java.util.Set;
import org.alfresco.repo.domain.NodeKey;
import org.alfresco.service.cmr.repository.NodeRef;
/**
* The interface to support persistence of node permission entries in hibernate
*
* @author andyh
*/
public interface NodePermissionEntry
{
/**
* Get the node key.
*
* @return
*/
public NodeKey getNodeKey();
/**
* Set the node key.
*
* @param key
*/
public void setNodeKey(NodeKey key);
/**
* Get the node ref
*
* @return
*/
public NodeRef getNodeRef();
/**
* Get inheritance behaviour
* @return
*/
public boolean getInherits();
/**
* Set inheritance behaviour
* @param inherits
*/
public void setInherits(boolean inherits);
/**
* Get the permission entries set for the node
* @return
*/
public Set<PermissionEntry> getPermissionEntries();
}

117
source/java/org/alfresco/repo/security/permissions/impl/hibernate/NodePermissionEntryImpl.java
View File

@@ -1,117 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import java.util.HashSet;
import java.util.Set;
import org.alfresco.repo.domain.NodeKey;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.StoreRef;
/**
* The hibernate persisted class for node permission entries.
*
* @author andyh
*/
public class NodePermissionEntryImpl implements NodePermissionEntry
{
/**
* The key to find node permission entries
*/
private NodeKey nodeKey;
/**
* Inherit permissions from the parent node?
*/
private boolean inherits;
/**
* The set of permission entries.
*/
private Set<PermissionEntry> permissionEntries = new HashSet<PermissionEntry>();
public NodePermissionEntryImpl()
{
super();
}
public NodeKey getNodeKey()
{
return nodeKey;
}
public void setNodeKey(NodeKey nodeKey)
{
this.nodeKey = nodeKey;
}
public NodeRef getNodeRef()
{
return new NodeRef(new StoreRef(nodeKey.getProtocol(), nodeKey
.getIdentifier()), nodeKey.getGuid());
}
public boolean getInherits()
{
return inherits;
}
public void setInherits(boolean inherits)
{
this.inherits = inherits;
}
public Set<PermissionEntry> getPermissionEntries()
{
return permissionEntries;
}
// Hibernate
/* package */ void setPermissionEntries(Set<PermissionEntry> permissionEntries)
{
this.permissionEntries = permissionEntries;
}
// Hibernate pattern
@Override
public boolean equals(Object o)
{
if (this == o)
{
return true;
}
if (!(o instanceof NodePermissionEntryImpl))
{
return false;
}
NodePermissionEntryImpl other = (NodePermissionEntryImpl) o;
return this.nodeKey.equals(other.nodeKey)
&& (this.inherits == other.inherits)
&& (this.permissionEntries.equals(other.permissionEntries));
}
@Override
public int hashCode()
{
return nodeKey.hashCode();
}
}

174
source/java/org/alfresco/repo/security/permissions/impl/hibernate/Permission.hbm.xml
View File

@@ -1,174 +0,0 @@
<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
'-//Hibernate/Hibernate Mapping DTD 3.0//EN'
'http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd'>
<hibernate-mapping>
<class
name="org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntryImpl"
proxy="org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntry"
table="node_perm_entry"
dynamic-insert="false"
dynamic-update="false"
select-before-update="false"
lazy="true"
optimistic-lock="version" >
<composite-id name="nodeKey" class="org.alfresco.repo.domain.NodeKey">
<key-property name="protocol" length="50" />
<key-property name="identifier" length="100" />
<key-property name="guid" length="36"/>
</composite-id>
<property name="inherits" column="inherits" type="boolean" not-null="true" />
<set
name="permissionEntries"
lazy="true"
sort="unsorted"
inverse="true"
fetch="select"
optimistic-lock="true"
cascade="delete" >
<key>
<column name="protocol" length="50" />
<column name="identifier" length="100" />
<column name="guid" length="36" />
</key>
<one-to-many class="org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntryImpl" />
</set>
</class>
<class
name="org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntryImpl"
proxy="org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntry"
table="perm_entry"
dynamic-insert="false"
dynamic-update="false"
select-before-update="false"
lazy="true"
optimistic-lock="version" >
<id
name="id"
column="id"
type="long" >
<generator class="increment" />
</id>
<many-to-one
name="nodePermissionEntry"
class="org.alfresco.repo.security.permissions.impl.hibernate.NodePermissionEntryImpl"
lazy="no-proxy" fetch="select" optimistic-lock="true" not-null="true" >
<column name="protocol" length="50" />
<column name="identifier" length="100" />
<column name="guid" length="36"/>
</many-to-one>
<many-to-one
name="permissionReference"
class="org.alfresco.repo.security.permissions.impl.hibernate.PermissionReferenceImpl"
lazy="no-proxy" fetch="select" optimistic-lock="true" not-null="false">
<column name="typeUri" length="100" />
<column name="typeName" length="100" />
<column name="name" length="100" />
</many-to-one>
<many-to-one
name="recipient"
class="org.alfresco.repo.security.permissions.impl.hibernate.RecipientImpl"
lazy="no-proxy" fetch="select" optimistic-lock="true" not-null="false">
</many-to-one>
<property name="allowed" column="allowed" type="boolean" not-null="true" />
</class>
<class
name="org.alfresco.repo.security.permissions.impl.hibernate.PermissionReferenceImpl"
proxy="org.alfresco.repo.security.permissions.impl.hibernate.PermissionReference"
table="perm_ref"
dynamic-insert="false"
dynamic-update="false"
select-before-update="false"
lazy="true"
optimistic-lock="version" >
<composite-id>
<key-property name="typeUri" type="string" length="100" column="type_uri"/>
<key-property name="typeName" type="string" length="100" column="type_name"/>
<key-property name="name" type="string" length="100" column="name" />
</composite-id>
</class>
<class
name="org.alfresco.repo.security.permissions.impl.hibernate.RecipientImpl"
proxy="org.alfresco.repo.security.permissions.impl.hibernate.Recipient"
table="recipient"
dynamic-insert="false"
dynamic-update="false"
select-before-update="false"
lazy="true"
optimistic-lock="version" >
<composite-id>
<key-property name="recipient"
column="recipient"
type="string" length="100" />
</composite-id>
<set name="externalKeys" lazy="true"
sort="unsorted"
fetch="select"
optimistic-lock="true" >
<key >
<column name="id" />
</key>
<element column="externalKey" length="100" not-null="true" type="string" />
</set>
</class>
<query name="permission.GetPermissionsForRecipient">
select
permissionEntry
from
org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntryImpl as permissionEntry
join permissionEntry.recipient as recipient
where
recipient = :recipientKey
</query>
<query name="permission.patch.UpdatePermissionEntryTypeName" >
update
org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntryImpl as entry
set
typeName = :typeNameNew
where
typeName = :typeNameOld and
name in ('Coordinator', 'Contributor', 'Editor', 'Guest')
</query>
<query name="permission.patch.UpdatePermissionEntryType" >
update
org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntryImpl as entry
set
typeUri = :typeUriNew,
typeName = :typeNameNew
where
typeUri = :typeUriOld and
typeName = :typeNameOld and
name in ( :names )
</query>
<query name="permission.patch.UpdatePermissionName" >
update
org.alfresco.repo.security.permissions.impl.hibernate.PermissionEntryImpl as entry
set
name = :nameNew
where
name = :nameOld
</query>
</hibernate-mapping>

73
source/java/org/alfresco/repo/security/permissions/impl/hibernate/PermissionEntry.java
View File

@@ -1,73 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
/**
* The interface against which permission entries are persisted
*
* @author andyh
*/
public interface PermissionEntry
{
/**
* Get the identifier for this object.
*
* @return
*/
public long getId();
/**
* Get the containing node permission entry.
*
* @return
*/
public NodePermissionEntry getNodePermissionEntry();
/**
* Get the permission to which this entry applies.
*
* @return
*/
public PermissionReference getPermissionReference();
/**
* Get the recipient to which this entry applies.
*
* @return
*/
public Recipient getRecipient();
/**
* Is this permission allowed?
* @return
*/
public boolean isAllowed();
/**
* Set if this permission is allowed, otherwise it is denied.
*
* @param allowed
*/
public void setAllowed(boolean allowed);
/**
* Delete this permission entry - allows for deleting of the bidirectional relationship to the node permission entry.
*
*/
public void delete();
}

181
source/java/org/alfresco/repo/security/permissions/impl/hibernate/PermissionEntryImpl.java
View File

@@ -1,181 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import org.alfresco.util.EqualsHelper;
/**
* Persisted permission entries
*
* @author andyh
*/
public class PermissionEntryImpl implements PermissionEntry
{
/**
* The object id
*/
private long id;
/**
* The container of this permissions
*/
private NodePermissionEntry nodePermissionEntry;
/**
* The permission to which this applies
* (non null - all is a special string)
*/
private PermissionReference permissionReference;
/**
* The recipient to which this applies
* (non null - all is a special string)
*/
private Recipient recipient;
/**
* Is this permission allowed?
*/
private boolean allowed;
public PermissionEntryImpl()
{
super();
}
public long getId()
{
return id;
}
// Hibernate
/* package */ void setId(long id)
{
this.id = id;
}
public NodePermissionEntry getNodePermissionEntry()
{
return nodePermissionEntry;
}
private void setNodePermissionEntry(NodePermissionEntry nodePermissionEntry)
{
this.nodePermissionEntry = nodePermissionEntry;
}
public PermissionReference getPermissionReference()
{
return permissionReference;
}
private void setPermissionReference(PermissionReference permissionReference)
{
this.permissionReference = permissionReference;
}
public Recipient getRecipient()
{
return recipient;
}
private void setRecipient(Recipient recipient)
{
this.recipient = recipient;
}
public boolean isAllowed()
{
return allowed;
}
public void setAllowed(boolean allowed)
{
this.allowed = allowed;
}
/**
* Factory method to create an entry and wire it in to the contained nodePermissionEntry
*
* @param nodePermissionEntry
* @param permissionReference
* @param recipient
* @param allowed
* @return
*/
public static PermissionEntryImpl create(NodePermissionEntry nodePermissionEntry, PermissionReference permissionReference, Recipient recipient, boolean allowed)
{
PermissionEntryImpl permissionEntry = new PermissionEntryImpl();
permissionEntry.setNodePermissionEntry(nodePermissionEntry);
permissionEntry.setPermissionReference(permissionReference);
permissionEntry.setRecipient(recipient);
permissionEntry.setAllowed(allowed);
nodePermissionEntry.getPermissionEntries().add(permissionEntry);
return permissionEntry;
}
/**
* Unwire
*/
public void delete()
{
nodePermissionEntry.getPermissionEntries().remove(this);
}
//
// Hibernate object pattern
//
@Override
public boolean equals(Object o)
{
if (this == o)
{
return true;
}
if (!(o instanceof PermissionEntryImpl))
{
return false;
}
PermissionEntryImpl other = (PermissionEntryImpl) o;
return EqualsHelper.nullSafeEquals(this.nodePermissionEntry,
other.nodePermissionEntry)
&& EqualsHelper.nullSafeEquals(this.permissionReference,
other.permissionReference)
&& EqualsHelper.nullSafeEquals(this.recipient, other.recipient)
&& (this.allowed == other.allowed);
}
@Override
public int hashCode()
{
int hashCode = nodePermissionEntry.hashCode();
if (permissionReference != null)
{
hashCode = hashCode * 37 + permissionReference.hashCode();
}
if (recipient != null)
{
hashCode = hashCode * 37 + recipient.hashCode();
}
hashCode = hashCode * 37 + (allowed ? 1 : 0);
return hashCode;
}
}

69
source/java/org/alfresco/repo/security/permissions/impl/hibernate/PermissionReference.java
View File

@@ -1,69 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import java.io.Serializable;
/**
* The interface against which permission references are persisted in hibernate.
*
* @author andyh
*/
public interface PermissionReference extends Serializable
{
/**
* Get the URI for the type to which this permission applies.
*
* @return
*/
public String getTypeUri();
/**
* Set the URI for the type to which this permission applies.
*
* @param typeUri
*/
public void setTypeUri(String typeUri);
/**
* Get the local name of the type to which this permission applies.
*
* @return
*/
public String getTypeName();
/**
* Set the local name of the type to which this permission applies.
*
* @param typeName
*/
public void setTypeName(String typeName);
/**
* Get the name of the permission.
*
* @return
*/
public String getName();
/**
* Set the name of the permission.
*
* @param name
*/
public void setName(String name);
}

110
source/java/org/alfresco/repo/security/permissions/impl/hibernate/PermissionReferenceImpl.java
View File

@@ -1,110 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
/**
* The persisted class for permission references.
*
* @author andyh
*/
public class PermissionReferenceImpl implements PermissionReference
{
/**
* Comment for <code>serialVersionUID</code>
*/
private static final long serialVersionUID = -6352566900815035461L;
private String typeUri;
private String typeName;
private String name;
public PermissionReferenceImpl()
{
super();
}
@Override
public String toString()
{
StringBuilder sb = new StringBuilder(128);
sb.append("PermissionReferenceImpl")
.append("[ typeUri=").append(getTypeUri())
.append(", typeName=").append(getTypeName())
.append(", name=").append(getName())
.append("]");
return sb.toString();
}
public String getTypeUri()
{
return typeUri;
}
public void setTypeUri(String typeUri)
{
this.typeUri = typeUri;
}
public String getTypeName()
{
return typeName;
}
public void setTypeName(String typeName)
{
this.typeName = typeName;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
// Hibernate pattern
@Override
public boolean equals(Object o)
{
if(this == o)
{
return true;
}
if(!(o instanceof PermissionReference))
{
return false;
}
PermissionReference other = (PermissionReference)o;
return this.getTypeUri().equals(other.getTypeUri()) && this.getTypeName().equals(other.getTypeName()) && this.getName().equals(other.getName());
}
@Override
public int hashCode()
{
return ((typeUri.hashCode() * 37) + typeName.hashCode() ) * 37 + name.hashCode();
}
}

48
source/java/org/alfresco/repo/security/permissions/impl/hibernate/Recipient.java
View File

@@ -1,48 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import java.io.Serializable;
import java.util.Set;
/**
* The interface against which recipients of permission are persisted
* @author andyh
*/
public interface Recipient extends Serializable
{
/**
* Get the recipient.
*
* @return
*/
public String getRecipient();
/**
* Set the recipient
*
* @param recipient
*/
public void setRecipient(String recipient);
/**
* Get the external keys that map to this recipient.
*
* @return
*/
public Set<String> getExternalKeys();
}

88
source/java/org/alfresco/repo/security/permissions/impl/hibernate/RecipientImpl.java
View File

@@ -1,88 +0,0 @@
/*
* Copyright (C) 2005 Alfresco, Inc.
*
* Licensed under the Mozilla Public License version 1.1
* with a permitted attribution clause. You may obtain a
* copy of the License at
*
* http://www.alfresco.org/legal/license.txt
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
* either express or implied. See the License for the specific
* language governing permissions and limitations under the
* License.
*/
package org.alfresco.repo.security.permissions.impl.hibernate;
import java.util.HashSet;
import java.util.Set;
/**
* The persisted class for recipients.
*
* @author andyh
*/
public class RecipientImpl implements Recipient
{
/**
* Comment for <code>serialVersionUID</code>
*/
private static final long serialVersionUID = -5582068692208928127L;
private String recipient;
private Set<String> externalKeys = new HashSet<String>();
public RecipientImpl()
{
super();
}
public String getRecipient()
{
return recipient;
}
public void setRecipient(String recipient)
{
this.recipient = recipient;
}
public Set<String> getExternalKeys()
{
return externalKeys;
}
// Hibernate
/* package */ void setExternalKeys(Set<String> externalKeys)
{
this.externalKeys = externalKeys;
}
// Hibernate pattern
@Override
public boolean equals(Object o)
{
if(this == o)
{
return true;
}
if(!(o instanceof Recipient))
{
return false;
}
Recipient other = (Recipient)o;
return this.getRecipient().equals(other.getRecipient());
}
@Override
public int hashCode()
{
return getRecipient().hashCode();
}
}

2
source/java/org/alfresco/repo/security/permissions/noop/PermissionServiceNOOPImpl.java
View File

@@ -113,7 +113,7 @@ public class PermissionServiceNOOPImpl
/* (non-Javadoc)
* @see org.alfresco.repo.security.permissions.PermissionService#deletePermission(org.alfresco.service.cmr.repository.NodeRef, java.lang.String, org.alfresco.repo.security.permissions.PermissionReference, boolean)
*/
public void deletePermission(NodeRef nodeRef, String authority, String perm, boolean allow)
public void deletePermission(NodeRef nodeRef, String authority, String perm)
{
}