mirror of
https://github.com/Alfresco/alfresco-community-repo.git
synced 2025-07-24 17:32:48 +00:00
Schema changes and ID-based node storage
git-svn-id: https://svn.alfresco.com/repos/alfresco-enterprise/alfresco/HEAD/root@2727 c4b6b30b-aa2e-2d43-bbcb-ca4b014f7261
This commit is contained in:
@@ -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());
|
||||
}
|
||||
|
@@ -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();
|
||||
}
|
||||
|
||||
|
@@ -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)
|
||||
|
@@ -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");
|
||||
|
@@ -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);
|
||||
|
||||
}
|
@@ -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
|
||||
}
|
||||
}
|
||||
|
||||
}
|
@@ -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());
|
||||
}
|
||||
|
||||
}
|
@@ -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();
|
||||
|
||||
}
|
@@ -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();
|
||||
}
|
||||
|
||||
}
|
@@ -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>
|
@@ -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();
|
||||
}
|
@@ -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;
|
||||
}
|
||||
|
||||
}
|
@@ -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);
|
||||
}
|
@@ -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();
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
@@ -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();
|
||||
}
|
@@ -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();
|
||||
}
|
||||
|
||||
|
||||
}
|
Reference in New Issue
Block a user